HDK: H5overflow.h Source File

00001 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
00002  * Copyright by The HDF Group.                                               *
00003  * Copyright by the Board of Trustees of the University of Illinois.         *
00004  * All rights reserved.                                                      *
00005  *                                                                           *
00006  * This file is part of HDF5.  The full HDF5 copyright notice, including     *
00007  * terms governing use, modification, and redistribution, is contained in    *
00008  * the files COPYING and Copyright.html.  COPYING can be found at the root   *
00009  * of the source code distribution tree; Copyright.html can be found at the  *
00010  * root level of an installed copy of the electronic HDF5 document set and   *
00011  * is linked from the top-level documents page.  It can also be found at     *
00012  * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
00013  * access to either file, you may request a copy from help@hdfgroup.org.     *
00014  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
00015 
00016 /* Generated automatically by bin/make_overflow -- do not edit */
00017 /* Add new types to H5overflow.txt file */
00018 
00019 
00020 #ifndef _H5overflow_H
00021 #define _H5overflow_H
00022 
00023 
00024 /* Each type in this file is tested for assignment to the other types,
00025  *      and range checks are defined for bad assignments at run-time.
00026  */
00027 
00028 /* Assignment checks for unsigned */
00029 
00030 /* src: unsigned, dst: int */
00031 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_INT
00032     #define ASSIGN_unsigned_TO_int(dst, dsttype, src, srctype) \
00033         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00034 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_INT
00035     #define ASSIGN_unsigned_TO_int(dst, dsttype, src, srctype) \
00036         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00037 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_INT */
00038     #define ASSIGN_unsigned_TO_int(dst, dsttype, src, srctype) \
00039         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00040 #endif /* src: unsigned dst: int */
00041 
00042 /* src: unsigned, dst: uint8_t */
00043 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT8_T
00044     #define ASSIGN_unsigned_TO_uint8_t(dst, dsttype, src, srctype) \
00045         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00046 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT8_T
00047     #define ASSIGN_unsigned_TO_uint8_t(dst, dsttype, src, srctype) \
00048         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00049 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT8_T */
00050     #define ASSIGN_unsigned_TO_uint8_t(dst, dsttype, src, srctype) \
00051         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00052 #endif /* src: unsigned dst: uint8_t */
00053 
00054 /* src: unsigned, dst: uint16_t */
00055 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT16_T
00056     #define ASSIGN_unsigned_TO_uint16_t(dst, dsttype, src, srctype) \
00057         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00058 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT16_T
00059     #define ASSIGN_unsigned_TO_uint16_t(dst, dsttype, src, srctype) \
00060         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00061 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT16_T */
00062     #define ASSIGN_unsigned_TO_uint16_t(dst, dsttype, src, srctype) \
00063         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00064 #endif /* src: unsigned dst: uint16_t */
00065 
00066 /* src: unsigned, dst: uint32_t */
00067 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT32_T
00068     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
00069         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00070 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT32_T
00071     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
00072         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00073 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT32_T */
00074     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
00075         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00076 #endif /* src: unsigned dst: uint32_t */
00077 
00078 /* src: unsigned, dst: uint64_t */
00079 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT64_T
00080     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
00081         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00082 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT64_T
00083     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
00084         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00085 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT64_T */
00086     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
00087         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00088 #endif /* src: unsigned dst: uint64_t */
00089 
00090 /* src: unsigned, dst: ptrdiff_t */
00091 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_PTRDIFF_T
00092     #define ASSIGN_unsigned_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00093         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00094 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_PTRDIFF_T
00095     #define ASSIGN_unsigned_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00096         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00097 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_PTRDIFF_T */
00098     #define ASSIGN_unsigned_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00099         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00100 #endif /* src: unsigned dst: ptrdiff_t */
00101 
00102 /* src: unsigned, dst: size_t */
00103 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_SIZE_T
00104     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
00105         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00106 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_SIZE_T
00107     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
00108         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00109 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_SIZE_T */
00110     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
00111         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00112 #endif /* src: unsigned dst: size_t */
00113 
00114 /* src: unsigned, dst: ssize_t */
00115 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_SSIZE_T
00116     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
00117         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00118 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_SSIZE_T
00119     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
00120         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00121 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_SSIZE_T */
00122     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
00123         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00124 #endif /* src: unsigned dst: ssize_t */
00125 
00126 /* src: unsigned, dst: haddr_t */
00127 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HADDR_T
00128     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
00129         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00130 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HADDR_T
00131     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
00132         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00133 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HADDR_T */
00134     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
00135         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00136 #endif /* src: unsigned dst: haddr_t */
00137 
00138 /* src: unsigned, dst: hsize_t */
00139 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HSIZE_T
00140     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
00141         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00142 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HSIZE_T
00143     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
00144         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00145 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HSIZE_T */
00146     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
00147         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00148 #endif /* src: unsigned dst: hsize_t */
00149 
00150 /* src: unsigned, dst: hssize_t */
00151 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HSSIZE_T
00152     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
00153         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00154 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HSSIZE_T
00155     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
00156         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00157 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HSSIZE_T */
00158     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
00159         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00160 #endif /* src: unsigned dst: hssize_t */
00161 
00162 /* src: unsigned, dst: h5_stat_size_t */
00163 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_H5_STAT_SIZE_T
00164     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00165         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00166 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_H5_STAT_SIZE_T
00167     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00168         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00169 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_H5_STAT_SIZE_T */
00170     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00171         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00172 #endif /* src: unsigned dst: h5_stat_size_t */
00173 
00174 
00175 /* Assignment checks for int */
00176 
00177 /* src: int, dst: unsigned */
00178 #if H5_SIZEOF_INT < H5_SIZEOF_UNSIGNED
00179     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
00180         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00181 #elif H5_SIZEOF_INT > H5_SIZEOF_UNSIGNED
00182     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
00183         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00184 #else /* H5_SIZEOF_INT == H5_SIZEOF_UNSIGNED */
00185     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
00186         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00187 #endif /* src: int dst: unsigned */
00188 
00189 /* src: int, dst: uint8_t */
00190 #if H5_SIZEOF_INT < H5_SIZEOF_UINT8_T
00191     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
00192         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00193 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT8_T
00194     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
00195         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00196 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT8_T */
00197     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
00198         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00199 #endif /* src: int dst: uint8_t */
00200 
00201 /* src: int, dst: uint16_t */
00202 #if H5_SIZEOF_INT < H5_SIZEOF_UINT16_T
00203     #define ASSIGN_int_TO_uint16_t(dst, dsttype, src, srctype) \
00204         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00205 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT16_T
00206     #define ASSIGN_int_TO_uint16_t(dst, dsttype, src, srctype) \
00207         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00208 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT16_T */
00209     #define ASSIGN_int_TO_uint16_t(dst, dsttype, src, srctype) \
00210         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00211 #endif /* src: int dst: uint16_t */
00212 
00213 /* src: int, dst: uint32_t */
00214 #if H5_SIZEOF_INT < H5_SIZEOF_UINT32_T
00215     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
00216         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00217 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT32_T
00218     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
00219         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00220 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT32_T */
00221     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
00222         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00223 #endif /* src: int dst: uint32_t */
00224 
00225 /* src: int, dst: uint64_t */
00226 #if H5_SIZEOF_INT < H5_SIZEOF_UINT64_T
00227     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
00228         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00229 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT64_T
00230     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
00231         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00232 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT64_T */
00233     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
00234         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00235 #endif /* src: int dst: uint64_t */
00236 
00237 /* src: int, dst: ptrdiff_t */
00238 #if H5_SIZEOF_INT < H5_SIZEOF_PTRDIFF_T
00239     #define ASSIGN_int_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00240         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00241 #elif H5_SIZEOF_INT > H5_SIZEOF_PTRDIFF_T
00242     #define ASSIGN_int_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00243         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00244 #else /* H5_SIZEOF_INT == H5_SIZEOF_PTRDIFF_T */
00245     #define ASSIGN_int_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00246         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00247 #endif /* src: int dst: ptrdiff_t */
00248 
00249 /* src: int, dst: size_t */
00250 #if H5_SIZEOF_INT < H5_SIZEOF_SIZE_T
00251     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
00252         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00253 #elif H5_SIZEOF_INT > H5_SIZEOF_SIZE_T
00254     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
00255         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00256 #else /* H5_SIZEOF_INT == H5_SIZEOF_SIZE_T */
00257     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
00258         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00259 #endif /* src: int dst: size_t */
00260 
00261 /* src: int, dst: ssize_t */
00262 #if H5_SIZEOF_INT < H5_SIZEOF_SSIZE_T
00263     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
00264         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00265 #elif H5_SIZEOF_INT > H5_SIZEOF_SSIZE_T
00266     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
00267         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00268 #else /* H5_SIZEOF_INT == H5_SIZEOF_SSIZE_T */
00269     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
00270         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00271 #endif /* src: int dst: ssize_t */
00272 
00273 /* src: int, dst: haddr_t */
00274 #if H5_SIZEOF_INT < H5_SIZEOF_HADDR_T
00275     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
00276         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00277 #elif H5_SIZEOF_INT > H5_SIZEOF_HADDR_T
00278     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
00279         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00280 #else /* H5_SIZEOF_INT == H5_SIZEOF_HADDR_T */
00281     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
00282         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00283 #endif /* src: int dst: haddr_t */
00284 
00285 /* src: int, dst: hsize_t */
00286 #if H5_SIZEOF_INT < H5_SIZEOF_HSIZE_T
00287     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
00288         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00289 #elif H5_SIZEOF_INT > H5_SIZEOF_HSIZE_T
00290     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
00291         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00292 #else /* H5_SIZEOF_INT == H5_SIZEOF_HSIZE_T */
00293     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
00294         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00295 #endif /* src: int dst: hsize_t */
00296 
00297 /* src: int, dst: hssize_t */
00298 #if H5_SIZEOF_INT < H5_SIZEOF_HSSIZE_T
00299     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
00300         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00301 #elif H5_SIZEOF_INT > H5_SIZEOF_HSSIZE_T
00302     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
00303         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00304 #else /* H5_SIZEOF_INT == H5_SIZEOF_HSSIZE_T */
00305     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
00306         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00307 #endif /* src: int dst: hssize_t */
00308 
00309 /* src: int, dst: h5_stat_size_t */
00310 #if H5_SIZEOF_INT < H5_SIZEOF_H5_STAT_SIZE_T
00311     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00312         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00313 #elif H5_SIZEOF_INT > H5_SIZEOF_H5_STAT_SIZE_T
00314     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00315         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00316 #else /* H5_SIZEOF_INT == H5_SIZEOF_H5_STAT_SIZE_T */
00317     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00318         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00319 #endif /* src: int dst: h5_stat_size_t */
00320 
00321 
00322 /* Assignment checks for uint8_t */
00323 
00324 /* src: uint8_t, dst: unsigned */
00325 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UNSIGNED
00326     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
00327         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00328 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UNSIGNED
00329     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
00330         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00331 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UNSIGNED */
00332     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
00333         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00334 #endif /* src: uint8_t dst: unsigned */
00335 
00336 /* src: uint8_t, dst: int */
00337 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_INT
00338     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
00339         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00340 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_INT
00341     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
00342         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00343 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_INT */
00344     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
00345         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00346 #endif /* src: uint8_t dst: int */
00347 
00348 /* src: uint8_t, dst: uint16_t */
00349 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT16_T
00350     #define ASSIGN_uint8_t_TO_uint16_t(dst, dsttype, src, srctype) \
00351         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00352 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT16_T
00353     #define ASSIGN_uint8_t_TO_uint16_t(dst, dsttype, src, srctype) \
00354         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00355 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT16_T */
00356     #define ASSIGN_uint8_t_TO_uint16_t(dst, dsttype, src, srctype) \
00357         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00358 #endif /* src: uint8_t dst: uint16_t */
00359 
00360 /* src: uint8_t, dst: uint32_t */
00361 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT32_T
00362     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
00363         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00364 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT32_T
00365     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
00366         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00367 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT32_T */
00368     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
00369         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00370 #endif /* src: uint8_t dst: uint32_t */
00371 
00372 /* src: uint8_t, dst: uint64_t */
00373 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT64_T
00374     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
00375         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00376 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT64_T
00377     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
00378         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00379 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT64_T */
00380     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
00381         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00382 #endif /* src: uint8_t dst: uint64_t */
00383 
00384 /* src: uint8_t, dst: ptrdiff_t */
00385 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_PTRDIFF_T
00386     #define ASSIGN_uint8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00387         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00388 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_PTRDIFF_T
00389     #define ASSIGN_uint8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00390         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00391 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_PTRDIFF_T */
00392     #define ASSIGN_uint8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00393         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00394 #endif /* src: uint8_t dst: ptrdiff_t */
00395 
00396 /* src: uint8_t, dst: size_t */
00397 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_SIZE_T
00398     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
00399         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00400 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_SIZE_T
00401     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
00402         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00403 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_SIZE_T */
00404     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
00405         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00406 #endif /* src: uint8_t dst: size_t */
00407 
00408 /* src: uint8_t, dst: ssize_t */
00409 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_SSIZE_T
00410     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
00411         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00412 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_SSIZE_T
00413     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
00414         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00415 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_SSIZE_T */
00416     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
00417         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00418 #endif /* src: uint8_t dst: ssize_t */
00419 
00420 /* src: uint8_t, dst: haddr_t */
00421 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HADDR_T
00422     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
00423         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00424 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HADDR_T
00425     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
00426         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00427 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HADDR_T */
00428     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
00429         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00430 #endif /* src: uint8_t dst: haddr_t */
00431 
00432 /* src: uint8_t, dst: hsize_t */
00433 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HSIZE_T
00434     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
00435         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00436 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HSIZE_T
00437     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
00438         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00439 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HSIZE_T */
00440     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
00441         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00442 #endif /* src: uint8_t dst: hsize_t */
00443 
00444 /* src: uint8_t, dst: hssize_t */
00445 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HSSIZE_T
00446     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
00447         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00448 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HSSIZE_T
00449     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
00450         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00451 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HSSIZE_T */
00452     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
00453         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00454 #endif /* src: uint8_t dst: hssize_t */
00455 
00456 /* src: uint8_t, dst: h5_stat_size_t */
00457 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_H5_STAT_SIZE_T
00458     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00459         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00460 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_H5_STAT_SIZE_T
00461     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00462         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00463 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_H5_STAT_SIZE_T */
00464     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00465         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00466 #endif /* src: uint8_t dst: h5_stat_size_t */
00467 
00468 
00469 /* Assignment checks for uint16_t */
00470 
00471 /* src: uint16_t, dst: unsigned */
00472 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UNSIGNED
00473     #define ASSIGN_uint16_t_TO_unsigned(dst, dsttype, src, srctype) \
00474         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00475 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UNSIGNED
00476     #define ASSIGN_uint16_t_TO_unsigned(dst, dsttype, src, srctype) \
00477         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00478 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UNSIGNED */
00479     #define ASSIGN_uint16_t_TO_unsigned(dst, dsttype, src, srctype) \
00480         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00481 #endif /* src: uint16_t dst: unsigned */
00482 
00483 /* src: uint16_t, dst: int */
00484 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_INT
00485     #define ASSIGN_uint16_t_TO_int(dst, dsttype, src, srctype) \
00486         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00487 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_INT
00488     #define ASSIGN_uint16_t_TO_int(dst, dsttype, src, srctype) \
00489         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00490 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_INT */
00491     #define ASSIGN_uint16_t_TO_int(dst, dsttype, src, srctype) \
00492         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00493 #endif /* src: uint16_t dst: int */
00494 
00495 /* src: uint16_t, dst: uint8_t */
00496 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UINT8_T
00497     #define ASSIGN_uint16_t_TO_uint8_t(dst, dsttype, src, srctype) \
00498         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00499 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UINT8_T
00500     #define ASSIGN_uint16_t_TO_uint8_t(dst, dsttype, src, srctype) \
00501         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00502 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UINT8_T */
00503     #define ASSIGN_uint16_t_TO_uint8_t(dst, dsttype, src, srctype) \
00504         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00505 #endif /* src: uint16_t dst: uint8_t */
00506 
00507 /* src: uint16_t, dst: uint32_t */
00508 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UINT32_T
00509     #define ASSIGN_uint16_t_TO_uint32_t(dst, dsttype, src, srctype) \
00510         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00511 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UINT32_T
00512     #define ASSIGN_uint16_t_TO_uint32_t(dst, dsttype, src, srctype) \
00513         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00514 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UINT32_T */
00515     #define ASSIGN_uint16_t_TO_uint32_t(dst, dsttype, src, srctype) \
00516         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00517 #endif /* src: uint16_t dst: uint32_t */
00518 
00519 /* src: uint16_t, dst: uint64_t */
00520 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UINT64_T
00521     #define ASSIGN_uint16_t_TO_uint64_t(dst, dsttype, src, srctype) \
00522         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00523 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UINT64_T
00524     #define ASSIGN_uint16_t_TO_uint64_t(dst, dsttype, src, srctype) \
00525         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00526 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UINT64_T */
00527     #define ASSIGN_uint16_t_TO_uint64_t(dst, dsttype, src, srctype) \
00528         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00529 #endif /* src: uint16_t dst: uint64_t */
00530 
00531 /* src: uint16_t, dst: ptrdiff_t */
00532 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_PTRDIFF_T
00533     #define ASSIGN_uint16_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00534         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00535 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_PTRDIFF_T
00536     #define ASSIGN_uint16_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00537         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00538 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_PTRDIFF_T */
00539     #define ASSIGN_uint16_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00540         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00541 #endif /* src: uint16_t dst: ptrdiff_t */
00542 
00543 /* src: uint16_t, dst: size_t */
00544 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_SIZE_T
00545     #define ASSIGN_uint16_t_TO_size_t(dst, dsttype, src, srctype) \
00546         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00547 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_SIZE_T
00548     #define ASSIGN_uint16_t_TO_size_t(dst, dsttype, src, srctype) \
00549         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00550 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_SIZE_T */
00551     #define ASSIGN_uint16_t_TO_size_t(dst, dsttype, src, srctype) \
00552         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00553 #endif /* src: uint16_t dst: size_t */
00554 
00555 /* src: uint16_t, dst: ssize_t */
00556 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_SSIZE_T
00557     #define ASSIGN_uint16_t_TO_ssize_t(dst, dsttype, src, srctype) \
00558         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00559 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_SSIZE_T
00560     #define ASSIGN_uint16_t_TO_ssize_t(dst, dsttype, src, srctype) \
00561         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00562 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_SSIZE_T */
00563     #define ASSIGN_uint16_t_TO_ssize_t(dst, dsttype, src, srctype) \
00564         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00565 #endif /* src: uint16_t dst: ssize_t */
00566 
00567 /* src: uint16_t, dst: haddr_t */
00568 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_HADDR_T
00569     #define ASSIGN_uint16_t_TO_haddr_t(dst, dsttype, src, srctype) \
00570         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00571 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_HADDR_T
00572     #define ASSIGN_uint16_t_TO_haddr_t(dst, dsttype, src, srctype) \
00573         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00574 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_HADDR_T */
00575     #define ASSIGN_uint16_t_TO_haddr_t(dst, dsttype, src, srctype) \
00576         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00577 #endif /* src: uint16_t dst: haddr_t */
00578 
00579 /* src: uint16_t, dst: hsize_t */
00580 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_HSIZE_T
00581     #define ASSIGN_uint16_t_TO_hsize_t(dst, dsttype, src, srctype) \
00582         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00583 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_HSIZE_T
00584     #define ASSIGN_uint16_t_TO_hsize_t(dst, dsttype, src, srctype) \
00585         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00586 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_HSIZE_T */
00587     #define ASSIGN_uint16_t_TO_hsize_t(dst, dsttype, src, srctype) \
00588         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00589 #endif /* src: uint16_t dst: hsize_t */
00590 
00591 /* src: uint16_t, dst: hssize_t */
00592 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_HSSIZE_T
00593     #define ASSIGN_uint16_t_TO_hssize_t(dst, dsttype, src, srctype) \
00594         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00595 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_HSSIZE_T
00596     #define ASSIGN_uint16_t_TO_hssize_t(dst, dsttype, src, srctype) \
00597         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00598 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_HSSIZE_T */
00599     #define ASSIGN_uint16_t_TO_hssize_t(dst, dsttype, src, srctype) \
00600         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00601 #endif /* src: uint16_t dst: hssize_t */
00602 
00603 /* src: uint16_t, dst: h5_stat_size_t */
00604 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_H5_STAT_SIZE_T
00605     #define ASSIGN_uint16_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00606         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00607 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_H5_STAT_SIZE_T
00608     #define ASSIGN_uint16_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00609         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00610 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_H5_STAT_SIZE_T */
00611     #define ASSIGN_uint16_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00612         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00613 #endif /* src: uint16_t dst: h5_stat_size_t */
00614 
00615 
00616 /* Assignment checks for uint32_t */
00617 
00618 /* src: uint32_t, dst: unsigned */
00619 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UNSIGNED
00620     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
00621         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00622 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UNSIGNED
00623     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
00624         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00625 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UNSIGNED */
00626     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
00627         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00628 #endif /* src: uint32_t dst: unsigned */
00629 
00630 /* src: uint32_t, dst: int */
00631 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_INT
00632     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
00633         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00634 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_INT
00635     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
00636         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00637 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_INT */
00638     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
00639         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00640 #endif /* src: uint32_t dst: int */
00641 
00642 /* src: uint32_t, dst: uint8_t */
00643 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT8_T
00644     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
00645         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00646 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT8_T
00647     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
00648         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00649 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT8_T */
00650     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
00651         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00652 #endif /* src: uint32_t dst: uint8_t */
00653 
00654 /* src: uint32_t, dst: uint16_t */
00655 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT16_T
00656     #define ASSIGN_uint32_t_TO_uint16_t(dst, dsttype, src, srctype) \
00657         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00658 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT16_T
00659     #define ASSIGN_uint32_t_TO_uint16_t(dst, dsttype, src, srctype) \
00660         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00661 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT16_T */
00662     #define ASSIGN_uint32_t_TO_uint16_t(dst, dsttype, src, srctype) \
00663         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00664 #endif /* src: uint32_t dst: uint16_t */
00665 
00666 /* src: uint32_t, dst: uint64_t */
00667 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT64_T
00668     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
00669         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00670 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT64_T
00671     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
00672         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00673 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT64_T */
00674     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
00675         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00676 #endif /* src: uint32_t dst: uint64_t */
00677 
00678 /* src: uint32_t, dst: ptrdiff_t */
00679 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_PTRDIFF_T
00680     #define ASSIGN_uint32_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00681         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00682 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_PTRDIFF_T
00683     #define ASSIGN_uint32_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00684         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00685 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_PTRDIFF_T */
00686     #define ASSIGN_uint32_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00687         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00688 #endif /* src: uint32_t dst: ptrdiff_t */
00689 
00690 /* src: uint32_t, dst: size_t */
00691 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_SIZE_T
00692     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
00693         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00694 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_SIZE_T
00695     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
00696         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00697 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_SIZE_T */
00698     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
00699         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00700 #endif /* src: uint32_t dst: size_t */
00701 
00702 /* src: uint32_t, dst: ssize_t */
00703 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_SSIZE_T
00704     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
00705         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00706 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_SSIZE_T
00707     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
00708         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00709 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_SSIZE_T */
00710     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
00711         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00712 #endif /* src: uint32_t dst: ssize_t */
00713 
00714 /* src: uint32_t, dst: haddr_t */
00715 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HADDR_T
00716     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
00717         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00718 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HADDR_T
00719     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
00720         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00721 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HADDR_T */
00722     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
00723         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00724 #endif /* src: uint32_t dst: haddr_t */
00725 
00726 /* src: uint32_t, dst: hsize_t */
00727 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HSIZE_T
00728     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
00729         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00730 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HSIZE_T
00731     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
00732         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00733 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HSIZE_T */
00734     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
00735         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00736 #endif /* src: uint32_t dst: hsize_t */
00737 
00738 /* src: uint32_t, dst: hssize_t */
00739 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HSSIZE_T
00740     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
00741         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00742 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HSSIZE_T
00743     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
00744         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00745 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HSSIZE_T */
00746     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
00747         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00748 #endif /* src: uint32_t dst: hssize_t */
00749 
00750 /* src: uint32_t, dst: h5_stat_size_t */
00751 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_H5_STAT_SIZE_T
00752     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00753         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00754 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_H5_STAT_SIZE_T
00755     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00756         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00757 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_H5_STAT_SIZE_T */
00758     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00759         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00760 #endif /* src: uint32_t dst: h5_stat_size_t */
00761 
00762 
00763 /* Assignment checks for uint64_t */
00764 
00765 /* src: uint64_t, dst: unsigned */
00766 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UNSIGNED
00767     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
00768         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00769 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UNSIGNED
00770     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
00771         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00772 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UNSIGNED */
00773     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
00774         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00775 #endif /* src: uint64_t dst: unsigned */
00776 
00777 /* src: uint64_t, dst: int */
00778 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_INT
00779     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
00780         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00781 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_INT
00782     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
00783         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00784 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_INT */
00785     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
00786         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00787 #endif /* src: uint64_t dst: int */
00788 
00789 /* src: uint64_t, dst: uint8_t */
00790 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT8_T
00791     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
00792         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00793 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT8_T
00794     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
00795         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00796 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT8_T */
00797     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
00798         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00799 #endif /* src: uint64_t dst: uint8_t */
00800 
00801 /* src: uint64_t, dst: uint16_t */
00802 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT16_T
00803     #define ASSIGN_uint64_t_TO_uint16_t(dst, dsttype, src, srctype) \
00804         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00805 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT16_T
00806     #define ASSIGN_uint64_t_TO_uint16_t(dst, dsttype, src, srctype) \
00807         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00808 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT16_T */
00809     #define ASSIGN_uint64_t_TO_uint16_t(dst, dsttype, src, srctype) \
00810         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00811 #endif /* src: uint64_t dst: uint16_t */
00812 
00813 /* src: uint64_t, dst: uint32_t */
00814 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT32_T
00815     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
00816         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00817 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT32_T
00818     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
00819         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00820 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT32_T */
00821     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
00822         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00823 #endif /* src: uint64_t dst: uint32_t */
00824 
00825 /* src: uint64_t, dst: ptrdiff_t */
00826 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_PTRDIFF_T
00827     #define ASSIGN_uint64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00828         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00829 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_PTRDIFF_T
00830     #define ASSIGN_uint64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00831         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00832 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_PTRDIFF_T */
00833     #define ASSIGN_uint64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
00834         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00835 #endif /* src: uint64_t dst: ptrdiff_t */
00836 
00837 /* src: uint64_t, dst: size_t */
00838 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_SIZE_T
00839     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
00840         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00841 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_SIZE_T
00842     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
00843         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00844 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_SIZE_T */
00845     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
00846         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00847 #endif /* src: uint64_t dst: size_t */
00848 
00849 /* src: uint64_t, dst: ssize_t */
00850 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_SSIZE_T
00851     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
00852         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00853 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_SSIZE_T
00854     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
00855         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00856 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_SSIZE_T */
00857     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
00858         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00859 #endif /* src: uint64_t dst: ssize_t */
00860 
00861 /* src: uint64_t, dst: haddr_t */
00862 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HADDR_T
00863     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
00864         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00865 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HADDR_T
00866     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
00867         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00868 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HADDR_T */
00869     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
00870         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00871 #endif /* src: uint64_t dst: haddr_t */
00872 
00873 /* src: uint64_t, dst: hsize_t */
00874 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HSIZE_T
00875     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
00876         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00877 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HSIZE_T
00878     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
00879         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00880 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HSIZE_T */
00881     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
00882         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00883 #endif /* src: uint64_t dst: hsize_t */
00884 
00885 /* src: uint64_t, dst: hssize_t */
00886 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HSSIZE_T
00887     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
00888         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00889 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HSSIZE_T
00890     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
00891         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00892 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HSSIZE_T */
00893     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
00894         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00895 #endif /* src: uint64_t dst: hssize_t */
00896 
00897 /* src: uint64_t, dst: h5_stat_size_t */
00898 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_H5_STAT_SIZE_T
00899     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00900         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00901 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_H5_STAT_SIZE_T
00902     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00903         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00904 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_H5_STAT_SIZE_T */
00905     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00906         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00907 #endif /* src: uint64_t dst: h5_stat_size_t */
00908 
00909 
00910 /* Assignment checks for ptrdiff_t */
00911 
00912 /* src: ptrdiff_t, dst: unsigned */
00913 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UNSIGNED
00914     #define ASSIGN_ptrdiff_t_TO_unsigned(dst, dsttype, src, srctype) \
00915         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00916 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UNSIGNED
00917     #define ASSIGN_ptrdiff_t_TO_unsigned(dst, dsttype, src, srctype) \
00918         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00919 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UNSIGNED */
00920     #define ASSIGN_ptrdiff_t_TO_unsigned(dst, dsttype, src, srctype) \
00921         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00922 #endif /* src: ptrdiff_t dst: unsigned */
00923 
00924 /* src: ptrdiff_t, dst: int */
00925 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_INT
00926     #define ASSIGN_ptrdiff_t_TO_int(dst, dsttype, src, srctype) \
00927         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00928 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_INT
00929     #define ASSIGN_ptrdiff_t_TO_int(dst, dsttype, src, srctype) \
00930         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00931 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_INT */
00932     #define ASSIGN_ptrdiff_t_TO_int(dst, dsttype, src, srctype) \
00933         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00934 #endif /* src: ptrdiff_t dst: int */
00935 
00936 /* src: ptrdiff_t, dst: uint8_t */
00937 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT8_T
00938     #define ASSIGN_ptrdiff_t_TO_uint8_t(dst, dsttype, src, srctype) \
00939         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00940 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT8_T
00941     #define ASSIGN_ptrdiff_t_TO_uint8_t(dst, dsttype, src, srctype) \
00942         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00943 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT8_T */
00944     #define ASSIGN_ptrdiff_t_TO_uint8_t(dst, dsttype, src, srctype) \
00945         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00946 #endif /* src: ptrdiff_t dst: uint8_t */
00947 
00948 /* src: ptrdiff_t, dst: uint16_t */
00949 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT16_T
00950     #define ASSIGN_ptrdiff_t_TO_uint16_t(dst, dsttype, src, srctype) \
00951         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00952 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT16_T
00953     #define ASSIGN_ptrdiff_t_TO_uint16_t(dst, dsttype, src, srctype) \
00954         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00955 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT16_T */
00956     #define ASSIGN_ptrdiff_t_TO_uint16_t(dst, dsttype, src, srctype) \
00957         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00958 #endif /* src: ptrdiff_t dst: uint16_t */
00959 
00960 /* src: ptrdiff_t, dst: uint32_t */
00961 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT32_T
00962     #define ASSIGN_ptrdiff_t_TO_uint32_t(dst, dsttype, src, srctype) \
00963         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00964 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT32_T
00965     #define ASSIGN_ptrdiff_t_TO_uint32_t(dst, dsttype, src, srctype) \
00966         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00967 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT32_T */
00968     #define ASSIGN_ptrdiff_t_TO_uint32_t(dst, dsttype, src, srctype) \
00969         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00970 #endif /* src: ptrdiff_t dst: uint32_t */
00971 
00972 /* src: ptrdiff_t, dst: uint64_t */
00973 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT64_T
00974     #define ASSIGN_ptrdiff_t_TO_uint64_t(dst, dsttype, src, srctype) \
00975         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00976 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT64_T
00977     #define ASSIGN_ptrdiff_t_TO_uint64_t(dst, dsttype, src, srctype) \
00978         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00979 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT64_T */
00980     #define ASSIGN_ptrdiff_t_TO_uint64_t(dst, dsttype, src, srctype) \
00981         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00982 #endif /* src: ptrdiff_t dst: uint64_t */
00983 
00984 /* src: ptrdiff_t, dst: size_t */
00985 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_SIZE_T
00986     #define ASSIGN_ptrdiff_t_TO_size_t(dst, dsttype, src, srctype) \
00987         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00988 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_SIZE_T
00989     #define ASSIGN_ptrdiff_t_TO_size_t(dst, dsttype, src, srctype) \
00990         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00991 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_SIZE_T */
00992     #define ASSIGN_ptrdiff_t_TO_size_t(dst, dsttype, src, srctype) \
00993         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00994 #endif /* src: ptrdiff_t dst: size_t */
00995 
00996 /* src: ptrdiff_t, dst: ssize_t */
00997 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_SSIZE_T
00998     #define ASSIGN_ptrdiff_t_TO_ssize_t(dst, dsttype, src, srctype) \
00999         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01000 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_SSIZE_T
01001     #define ASSIGN_ptrdiff_t_TO_ssize_t(dst, dsttype, src, srctype) \
01002         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01003 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_SSIZE_T */
01004     #define ASSIGN_ptrdiff_t_TO_ssize_t(dst, dsttype, src, srctype) \
01005         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01006 #endif /* src: ptrdiff_t dst: ssize_t */
01007 
01008 /* src: ptrdiff_t, dst: haddr_t */
01009 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_HADDR_T
01010     #define ASSIGN_ptrdiff_t_TO_haddr_t(dst, dsttype, src, srctype) \
01011         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01012 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_HADDR_T
01013     #define ASSIGN_ptrdiff_t_TO_haddr_t(dst, dsttype, src, srctype) \
01014         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01015 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_HADDR_T */
01016     #define ASSIGN_ptrdiff_t_TO_haddr_t(dst, dsttype, src, srctype) \
01017         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01018 #endif /* src: ptrdiff_t dst: haddr_t */
01019 
01020 /* src: ptrdiff_t, dst: hsize_t */
01021 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_HSIZE_T
01022     #define ASSIGN_ptrdiff_t_TO_hsize_t(dst, dsttype, src, srctype) \
01023         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01024 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_HSIZE_T
01025     #define ASSIGN_ptrdiff_t_TO_hsize_t(dst, dsttype, src, srctype) \
01026         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01027 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_HSIZE_T */
01028     #define ASSIGN_ptrdiff_t_TO_hsize_t(dst, dsttype, src, srctype) \
01029         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01030 #endif /* src: ptrdiff_t dst: hsize_t */
01031 
01032 /* src: ptrdiff_t, dst: hssize_t */
01033 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_HSSIZE_T
01034     #define ASSIGN_ptrdiff_t_TO_hssize_t(dst, dsttype, src, srctype) \
01035         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01036 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_HSSIZE_T
01037     #define ASSIGN_ptrdiff_t_TO_hssize_t(dst, dsttype, src, srctype) \
01038         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01039 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_HSSIZE_T */
01040     #define ASSIGN_ptrdiff_t_TO_hssize_t(dst, dsttype, src, srctype) \
01041         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01042 #endif /* src: ptrdiff_t dst: hssize_t */
01043 
01044 /* src: ptrdiff_t, dst: h5_stat_size_t */
01045 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_H5_STAT_SIZE_T
01046     #define ASSIGN_ptrdiff_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01047         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01048 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_H5_STAT_SIZE_T
01049     #define ASSIGN_ptrdiff_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01050         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01051 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_H5_STAT_SIZE_T */
01052     #define ASSIGN_ptrdiff_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01053         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01054 #endif /* src: ptrdiff_t dst: h5_stat_size_t */
01055 
01056 
01057 /* Assignment checks for size_t */
01058 
01059 /* src: size_t, dst: unsigned */
01060 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UNSIGNED
01061     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01062         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01063 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UNSIGNED
01064     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01065         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01066 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UNSIGNED */
01067     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01068         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01069 #endif /* src: size_t dst: unsigned */
01070 
01071 /* src: size_t, dst: int */
01072 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_INT
01073     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
01074         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01075 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_INT
01076     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
01077         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01078 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_INT */
01079     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
01080         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01081 #endif /* src: size_t dst: int */
01082 
01083 /* src: size_t, dst: uint8_t */
01084 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT8_T
01085     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01086         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01087 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT8_T
01088     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01089         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01090 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT8_T */
01091     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01092         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01093 #endif /* src: size_t dst: uint8_t */
01094 
01095 /* src: size_t, dst: uint16_t */
01096 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT16_T
01097     #define ASSIGN_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
01098         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01099 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT16_T
01100     #define ASSIGN_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
01101         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01102 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT16_T */
01103     #define ASSIGN_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
01104         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01105 #endif /* src: size_t dst: uint16_t */
01106 
01107 /* src: size_t, dst: uint32_t */
01108 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT32_T
01109     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01110         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01111 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT32_T
01112     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01113         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01114 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT32_T */
01115     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01116         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01117 #endif /* src: size_t dst: uint32_t */
01118 
01119 /* src: size_t, dst: uint64_t */
01120 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT64_T
01121     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01122         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01123 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT64_T
01124     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01125         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01126 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT64_T */
01127     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01128         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01129 #endif /* src: size_t dst: uint64_t */
01130 
01131 /* src: size_t, dst: ptrdiff_t */
01132 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_PTRDIFF_T
01133     #define ASSIGN_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01134         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01135 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_PTRDIFF_T
01136     #define ASSIGN_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01137         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01138 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_PTRDIFF_T */
01139     #define ASSIGN_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01140         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01141 #endif /* src: size_t dst: ptrdiff_t */
01142 
01143 /* src: size_t, dst: ssize_t */
01144 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_SSIZE_T
01145     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01146         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01147 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_SSIZE_T
01148     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01149         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01150 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_SSIZE_T */
01151     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01152         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01153 #endif /* src: size_t dst: ssize_t */
01154 
01155 /* src: size_t, dst: haddr_t */
01156 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HADDR_T
01157     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01158         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01159 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HADDR_T
01160     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01161         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01162 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HADDR_T */
01163     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01164         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01165 #endif /* src: size_t dst: haddr_t */
01166 
01167 /* src: size_t, dst: hsize_t */
01168 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HSIZE_T
01169     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01170         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01171 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HSIZE_T
01172     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01173         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01174 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HSIZE_T */
01175     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01176         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01177 #endif /* src: size_t dst: hsize_t */
01178 
01179 /* src: size_t, dst: hssize_t */
01180 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HSSIZE_T
01181     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01182         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01183 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HSSIZE_T
01184     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01185         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01186 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HSSIZE_T */
01187     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01188         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01189 #endif /* src: size_t dst: hssize_t */
01190 
01191 /* src: size_t, dst: h5_stat_size_t */
01192 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
01193     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01194         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01195 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
01196     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01197         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01198 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
01199     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01200         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01201 #endif /* src: size_t dst: h5_stat_size_t */
01202 
01203 
01204 /* Assignment checks for ssize_t */
01205 
01206 /* src: ssize_t, dst: unsigned */
01207 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UNSIGNED
01208     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01209         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01210 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UNSIGNED
01211     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01212         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01213 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UNSIGNED */
01214     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01215         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01216 #endif /* src: ssize_t dst: unsigned */
01217 
01218 /* src: ssize_t, dst: int */
01219 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_INT
01220     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
01221         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01222 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_INT
01223     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
01224         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01225 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_INT */
01226     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
01227         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01228 #endif /* src: ssize_t dst: int */
01229 
01230 /* src: ssize_t, dst: uint8_t */
01231 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT8_T
01232     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01233         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01234 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT8_T
01235     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01236         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01237 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT8_T */
01238     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01239         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01240 #endif /* src: ssize_t dst: uint8_t */
01241 
01242 /* src: ssize_t, dst: uint16_t */
01243 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT16_T
01244     #define ASSIGN_ssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01245         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01246 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT16_T
01247     #define ASSIGN_ssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01248         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01249 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT16_T */
01250     #define ASSIGN_ssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01251         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01252 #endif /* src: ssize_t dst: uint16_t */
01253 
01254 /* src: ssize_t, dst: uint32_t */
01255 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT32_T
01256     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01257         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01258 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT32_T
01259     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01260         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01261 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT32_T */
01262     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01263         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01264 #endif /* src: ssize_t dst: uint32_t */
01265 
01266 /* src: ssize_t, dst: uint64_t */
01267 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT64_T
01268     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01269         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01270 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT64_T
01271     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01272         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01273 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT64_T */
01274     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01275         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01276 #endif /* src: ssize_t dst: uint64_t */
01277 
01278 /* src: ssize_t, dst: ptrdiff_t */
01279 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_PTRDIFF_T
01280     #define ASSIGN_ssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01281         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01282 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_PTRDIFF_T
01283     #define ASSIGN_ssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01284         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01285 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_PTRDIFF_T */
01286     #define ASSIGN_ssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01287         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01288 #endif /* src: ssize_t dst: ptrdiff_t */
01289 
01290 /* src: ssize_t, dst: size_t */
01291 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_SIZE_T
01292     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
01293         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01294 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_SIZE_T
01295     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
01296         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01297 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_SIZE_T */
01298     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
01299         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01300 #endif /* src: ssize_t dst: size_t */
01301 
01302 /* src: ssize_t, dst: haddr_t */
01303 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HADDR_T
01304     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01305         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01306 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HADDR_T
01307     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01308         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01309 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HADDR_T */
01310     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01311         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01312 #endif /* src: ssize_t dst: haddr_t */
01313 
01314 /* src: ssize_t, dst: hsize_t */
01315 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HSIZE_T
01316     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01317         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01318 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HSIZE_T
01319     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01320         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01321 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HSIZE_T */
01322     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01323         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01324 #endif /* src: ssize_t dst: hsize_t */
01325 
01326 /* src: ssize_t, dst: hssize_t */
01327 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HSSIZE_T
01328     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01329         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01330 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HSSIZE_T
01331     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01332         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01333 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HSSIZE_T */
01334     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01335         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01336 #endif /* src: ssize_t dst: hssize_t */
01337 
01338 /* src: ssize_t, dst: h5_stat_size_t */
01339 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
01340     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01341         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01342 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
01343     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01344         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01345 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
01346     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01347         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01348 #endif /* src: ssize_t dst: h5_stat_size_t */
01349 
01350 
01351 /* Assignment checks for haddr_t */
01352 
01353 /* src: haddr_t, dst: unsigned */
01354 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UNSIGNED
01355     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
01356         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01357 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UNSIGNED
01358     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
01359         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01360 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UNSIGNED */
01361     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
01362         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01363 #endif /* src: haddr_t dst: unsigned */
01364 
01365 /* src: haddr_t, dst: int */
01366 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_INT
01367     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
01368         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01369 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_INT
01370     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
01371         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01372 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_INT */
01373     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
01374         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01375 #endif /* src: haddr_t dst: int */
01376 
01377 /* src: haddr_t, dst: uint8_t */
01378 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT8_T
01379     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
01380         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01381 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT8_T
01382     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
01383         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01384 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT8_T */
01385     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
01386         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01387 #endif /* src: haddr_t dst: uint8_t */
01388 
01389 /* src: haddr_t, dst: uint16_t */
01390 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT16_T
01391     #define ASSIGN_haddr_t_TO_uint16_t(dst, dsttype, src, srctype) \
01392         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01393 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT16_T
01394     #define ASSIGN_haddr_t_TO_uint16_t(dst, dsttype, src, srctype) \
01395         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01396 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT16_T */
01397     #define ASSIGN_haddr_t_TO_uint16_t(dst, dsttype, src, srctype) \
01398         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01399 #endif /* src: haddr_t dst: uint16_t */
01400 
01401 /* src: haddr_t, dst: uint32_t */
01402 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT32_T
01403     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
01404         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01405 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT32_T
01406     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
01407         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01408 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT32_T */
01409     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
01410         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01411 #endif /* src: haddr_t dst: uint32_t */
01412 
01413 /* src: haddr_t, dst: uint64_t */
01414 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT64_T
01415     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
01416         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01417 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT64_T
01418     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
01419         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01420 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT64_T */
01421     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
01422         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01423 #endif /* src: haddr_t dst: uint64_t */
01424 
01425 /* src: haddr_t, dst: ptrdiff_t */
01426 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_PTRDIFF_T
01427     #define ASSIGN_haddr_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01428         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01429 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_PTRDIFF_T
01430     #define ASSIGN_haddr_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01431         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01432 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_PTRDIFF_T */
01433     #define ASSIGN_haddr_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01434         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01435 #endif /* src: haddr_t dst: ptrdiff_t */
01436 
01437 /* src: haddr_t, dst: size_t */
01438 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_SIZE_T
01439     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
01440         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01441 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_SIZE_T
01442     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
01443         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01444 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_SIZE_T */
01445     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
01446         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01447 #endif /* src: haddr_t dst: size_t */
01448 
01449 /* src: haddr_t, dst: ssize_t */
01450 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_SSIZE_T
01451     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
01452         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01453 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_SSIZE_T
01454     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
01455         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01456 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_SSIZE_T */
01457     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
01458         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01459 #endif /* src: haddr_t dst: ssize_t */
01460 
01461 /* src: haddr_t, dst: hsize_t */
01462 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_HSIZE_T
01463     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
01464         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01465 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_HSIZE_T
01466     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
01467         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01468 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_HSIZE_T */
01469     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
01470         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01471 #endif /* src: haddr_t dst: hsize_t */
01472 
01473 /* src: haddr_t, dst: hssize_t */
01474 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_HSSIZE_T
01475     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
01476         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01477 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_HSSIZE_T
01478     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
01479         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01480 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_HSSIZE_T */
01481     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
01482         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01483 #endif /* src: haddr_t dst: hssize_t */
01484 
01485 /* src: haddr_t, dst: h5_stat_size_t */
01486 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_H5_STAT_SIZE_T
01487     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01488         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01489 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_H5_STAT_SIZE_T
01490     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01491         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01492 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_H5_STAT_SIZE_T */
01493     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01494         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01495 #endif /* src: haddr_t dst: h5_stat_size_t */
01496 
01497 
01498 /* Assignment checks for hsize_t */
01499 
01500 /* src: hsize_t, dst: unsigned */
01501 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UNSIGNED
01502     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
01503         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01504 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UNSIGNED
01505     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
01506         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01507 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UNSIGNED */
01508     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
01509         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01510 #endif /* src: hsize_t dst: unsigned */
01511 
01512 /* src: hsize_t, dst: int */
01513 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_INT
01514     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
01515         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01516 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_INT
01517     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
01518         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01519 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_INT */
01520     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
01521         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01522 #endif /* src: hsize_t dst: int */
01523 
01524 /* src: hsize_t, dst: uint8_t */
01525 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT8_T
01526     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01527         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01528 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT8_T
01529     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01530         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01531 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT8_T */
01532     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01533         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01534 #endif /* src: hsize_t dst: uint8_t */
01535 
01536 /* src: hsize_t, dst: uint16_t */
01537 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT16_T
01538     #define ASSIGN_hsize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01539         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01540 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT16_T
01541     #define ASSIGN_hsize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01542         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01543 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT16_T */
01544     #define ASSIGN_hsize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01545         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01546 #endif /* src: hsize_t dst: uint16_t */
01547 
01548 /* src: hsize_t, dst: uint32_t */
01549 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT32_T
01550     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01551         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01552 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT32_T
01553     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01554         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01555 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT32_T */
01556     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01557         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01558 #endif /* src: hsize_t dst: uint32_t */
01559 
01560 /* src: hsize_t, dst: uint64_t */
01561 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT64_T
01562     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01563         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01564 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT64_T
01565     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01566         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01567 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT64_T */
01568     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01569         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01570 #endif /* src: hsize_t dst: uint64_t */
01571 
01572 /* src: hsize_t, dst: ptrdiff_t */
01573 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_PTRDIFF_T
01574     #define ASSIGN_hsize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01575         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01576 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_PTRDIFF_T
01577     #define ASSIGN_hsize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01578         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01579 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_PTRDIFF_T */
01580     #define ASSIGN_hsize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01581         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01582 #endif /* src: hsize_t dst: ptrdiff_t */
01583 
01584 /* src: hsize_t, dst: size_t */
01585 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_SIZE_T
01586     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
01587         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01588 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_SIZE_T
01589     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
01590         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01591 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_SIZE_T */
01592     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
01593         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01594 #endif /* src: hsize_t dst: size_t */
01595 
01596 /* src: hsize_t, dst: ssize_t */
01597 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_SSIZE_T
01598     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01599         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01600 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_SSIZE_T
01601     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01602         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01603 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_SSIZE_T */
01604     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01605         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01606 #endif /* src: hsize_t dst: ssize_t */
01607 
01608 /* src: hsize_t, dst: haddr_t */
01609 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_HADDR_T
01610     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01611         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01612 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_HADDR_T
01613     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01614         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01615 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_HADDR_T */
01616     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01617         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01618 #endif /* src: hsize_t dst: haddr_t */
01619 
01620 /* src: hsize_t, dst: hssize_t */
01621 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_HSSIZE_T
01622     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01623         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01624 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_HSSIZE_T
01625     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01626         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01627 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_HSSIZE_T */
01628     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01629         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01630 #endif /* src: hsize_t dst: hssize_t */
01631 
01632 /* src: hsize_t, dst: h5_stat_size_t */
01633 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
01634     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01635         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01636 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
01637     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01638         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01639 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
01640     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01641         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01642 #endif /* src: hsize_t dst: h5_stat_size_t */
01643 
01644 
01645 /* Assignment checks for hssize_t */
01646 
01647 /* src: hssize_t, dst: unsigned */
01648 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UNSIGNED
01649     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01650         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01651 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UNSIGNED
01652     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01653         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01654 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UNSIGNED */
01655     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01656         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01657 #endif /* src: hssize_t dst: unsigned */
01658 
01659 /* src: hssize_t, dst: int */
01660 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_INT
01661     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
01662         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01663 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_INT
01664     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
01665         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01666 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_INT */
01667     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
01668         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01669 #endif /* src: hssize_t dst: int */
01670 
01671 /* src: hssize_t, dst: uint8_t */
01672 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT8_T
01673     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01674         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01675 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT8_T
01676     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01677         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01678 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT8_T */
01679     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01680         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01681 #endif /* src: hssize_t dst: uint8_t */
01682 
01683 /* src: hssize_t, dst: uint16_t */
01684 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT16_T
01685     #define ASSIGN_hssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01686         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01687 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT16_T
01688     #define ASSIGN_hssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01689         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01690 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT16_T */
01691     #define ASSIGN_hssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
01692         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01693 #endif /* src: hssize_t dst: uint16_t */
01694 
01695 /* src: hssize_t, dst: uint32_t */
01696 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT32_T
01697     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01698         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01699 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT32_T
01700     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01701         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01702 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT32_T */
01703     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01704         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01705 #endif /* src: hssize_t dst: uint32_t */
01706 
01707 /* src: hssize_t, dst: uint64_t */
01708 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT64_T
01709     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01710         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01711 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT64_T
01712     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01713         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01714 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT64_T */
01715     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01716         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01717 #endif /* src: hssize_t dst: uint64_t */
01718 
01719 /* src: hssize_t, dst: ptrdiff_t */
01720 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_PTRDIFF_T
01721     #define ASSIGN_hssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01722         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01723 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_PTRDIFF_T
01724     #define ASSIGN_hssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01725         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01726 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_PTRDIFF_T */
01727     #define ASSIGN_hssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01728         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01729 #endif /* src: hssize_t dst: ptrdiff_t */
01730 
01731 /* src: hssize_t, dst: size_t */
01732 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_SIZE_T
01733     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
01734         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01735 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_SIZE_T
01736     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
01737         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01738 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_SIZE_T */
01739     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
01740         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01741 #endif /* src: hssize_t dst: size_t */
01742 
01743 /* src: hssize_t, dst: ssize_t */
01744 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_SSIZE_T
01745     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01746         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01747 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_SSIZE_T
01748     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01749         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01750 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_SSIZE_T */
01751     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01752         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01753 #endif /* src: hssize_t dst: ssize_t */
01754 
01755 /* src: hssize_t, dst: haddr_t */
01756 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_HADDR_T
01757     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01758         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01759 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_HADDR_T
01760     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01761         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01762 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_HADDR_T */
01763     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01764         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01765 #endif /* src: hssize_t dst: haddr_t */
01766 
01767 /* src: hssize_t, dst: hsize_t */
01768 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_HSIZE_T
01769     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01770         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01771 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_HSIZE_T
01772     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01773         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01774 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_HSIZE_T */
01775     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01776         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01777 #endif /* src: hssize_t dst: hsize_t */
01778 
01779 /* src: hssize_t, dst: h5_stat_size_t */
01780 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
01781     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01782         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01783 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
01784     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01785         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01786 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
01787     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01788         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01789 #endif /* src: hssize_t dst: h5_stat_size_t */
01790 
01791 
01792 /* Assignment checks for h5_stat_size_t */
01793 
01794 /* src: h5_stat_size_t, dst: unsigned */
01795 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UNSIGNED
01796     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01797         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01798 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UNSIGNED
01799     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01800         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01801 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UNSIGNED */
01802     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01803         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01804 #endif /* src: h5_stat_size_t dst: unsigned */
01805 
01806 /* src: h5_stat_size_t, dst: int */
01807 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_INT
01808     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
01809         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01810 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_INT
01811     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
01812         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01813 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_INT */
01814     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
01815         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01816 #endif /* src: h5_stat_size_t dst: int */
01817 
01818 /* src: h5_stat_size_t, dst: uint8_t */
01819 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT8_T
01820     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01821         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01822 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT8_T
01823     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01824         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01825 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT8_T */
01826     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01827         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01828 #endif /* src: h5_stat_size_t dst: uint8_t */
01829 
01830 /* src: h5_stat_size_t, dst: uint16_t */
01831 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT16_T
01832     #define ASSIGN_h5_stat_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
01833         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01834 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT16_T
01835     #define ASSIGN_h5_stat_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
01836         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01837 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT16_T */
01838     #define ASSIGN_h5_stat_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
01839         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01840 #endif /* src: h5_stat_size_t dst: uint16_t */
01841 
01842 /* src: h5_stat_size_t, dst: uint32_t */
01843 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT32_T
01844     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01845         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01846 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT32_T
01847     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01848         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01849 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT32_T */
01850     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01851         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01852 #endif /* src: h5_stat_size_t dst: uint32_t */
01853 
01854 /* src: h5_stat_size_t, dst: uint64_t */
01855 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT64_T
01856     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01857         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01858 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT64_T
01859     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01860         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01861 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT64_T */
01862     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01863         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01864 #endif /* src: h5_stat_size_t dst: uint64_t */
01865 
01866 /* src: h5_stat_size_t, dst: ptrdiff_t */
01867 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_PTRDIFF_T
01868     #define ASSIGN_h5_stat_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01869         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01870 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_PTRDIFF_T
01871     #define ASSIGN_h5_stat_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01872         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01873 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_PTRDIFF_T */
01874     #define ASSIGN_h5_stat_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
01875         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01876 #endif /* src: h5_stat_size_t dst: ptrdiff_t */
01877 
01878 /* src: h5_stat_size_t, dst: size_t */
01879 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_SIZE_T
01880     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
01881         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01882 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_SIZE_T
01883     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
01884         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01885 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_SIZE_T */
01886     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
01887         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01888 #endif /* src: h5_stat_size_t dst: size_t */
01889 
01890 /* src: h5_stat_size_t, dst: ssize_t */
01891 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_SSIZE_T
01892     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01893         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01894 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_SSIZE_T
01895     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01896         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01897 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_SSIZE_T */
01898     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01899         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01900 #endif /* src: h5_stat_size_t dst: ssize_t */
01901 
01902 /* src: h5_stat_size_t, dst: haddr_t */
01903 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HADDR_T
01904     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01905         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01906 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HADDR_T
01907     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01908         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01909 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HADDR_T */
01910     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01911         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01912 #endif /* src: h5_stat_size_t dst: haddr_t */
01913 
01914 /* src: h5_stat_size_t, dst: hsize_t */
01915 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HSIZE_T
01916     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01917         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01918 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HSIZE_T
01919     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01920         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01921 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HSIZE_T */
01922     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01923         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01924 #endif /* src: h5_stat_size_t dst: hsize_t */
01925 
01926 /* src: h5_stat_size_t, dst: hssize_t */
01927 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HSSIZE_T
01928     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01929         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01930 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HSSIZE_T
01931     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01932         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01933 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HSSIZE_T */
01934     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01935         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01936 #endif /* src: h5_stat_size_t dst: hssize_t */
01937 
01938 #endif /* H5overflow_H */
01939