FiberVISH: fiber/hdf5/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: uint32_t */
00055 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT32_T
00056     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
00057         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00058 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT32_T
00059     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
00060         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00061 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT32_T */
00062     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
00063         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00064 #endif /* src: unsigned dst: uint32_t */
00065 
00066 /* src: unsigned, dst: uint64_t */
00067 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT64_T
00068     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
00069         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00070 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT64_T
00071     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
00072         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00073 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT64_T */
00074     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
00075         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00076 #endif /* src: unsigned dst: uint64_t */
00077 
00078 /* src: unsigned, dst: size_t */
00079 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_SIZE_T
00080     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
00081         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00082 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_SIZE_T
00083     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
00084         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00085 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_SIZE_T */
00086     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
00087         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00088 #endif /* src: unsigned dst: size_t */
00089 
00090 /* src: unsigned, dst: ssize_t */
00091 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_SSIZE_T
00092     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
00093         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00094 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_SSIZE_T
00095     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
00096         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00097 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_SSIZE_T */
00098     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
00099         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00100 #endif /* src: unsigned dst: ssize_t */
00101 
00102 /* src: unsigned, dst: haddr_t */
00103 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HADDR_T
00104     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
00105         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00106 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HADDR_T
00107     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
00108         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00109 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HADDR_T */
00110     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
00111         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00112 #endif /* src: unsigned dst: haddr_t */
00113 
00114 /* src: unsigned, dst: hsize_t */
00115 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HSIZE_T
00116     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
00117         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00118 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HSIZE_T
00119     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
00120         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00121 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HSIZE_T */
00122     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
00123         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00124 #endif /* src: unsigned dst: hsize_t */
00125 
00126 /* src: unsigned, dst: hssize_t */
00127 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HSSIZE_T
00128     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
00129         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00130 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HSSIZE_T
00131     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
00132         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00133 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HSSIZE_T */
00134     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
00135         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00136 #endif /* src: unsigned dst: hssize_t */
00137 
00138 /* src: unsigned, dst: h5_stat_size_t */
00139 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_H5_STAT_SIZE_T
00140     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00141         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00142 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_H5_STAT_SIZE_T
00143     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00144         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00145 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_H5_STAT_SIZE_T */
00146     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00147         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00148 #endif /* src: unsigned dst: h5_stat_size_t */
00149 
00150 
00151 /* Assignment checks for int */
00152 
00153 /* src: int, dst: unsigned */
00154 #if H5_SIZEOF_INT < H5_SIZEOF_UNSIGNED
00155     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
00156         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00157 #elif H5_SIZEOF_INT > H5_SIZEOF_UNSIGNED
00158     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
00159         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00160 #else /* H5_SIZEOF_INT == H5_SIZEOF_UNSIGNED */
00161     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
00162         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00163 #endif /* src: int dst: unsigned */
00164 
00165 /* src: int, dst: uint8_t */
00166 #if H5_SIZEOF_INT < H5_SIZEOF_UINT8_T
00167     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
00168         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00169 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT8_T
00170     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
00171         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00172 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT8_T */
00173     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
00174         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00175 #endif /* src: int dst: uint8_t */
00176 
00177 /* src: int, dst: uint32_t */
00178 #if H5_SIZEOF_INT < H5_SIZEOF_UINT32_T
00179     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
00180         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00181 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT32_T
00182     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
00183         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00184 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT32_T */
00185     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
00186         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00187 #endif /* src: int dst: uint32_t */
00188 
00189 /* src: int, dst: uint64_t */
00190 #if H5_SIZEOF_INT < H5_SIZEOF_UINT64_T
00191     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
00192         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00193 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT64_T
00194     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
00195         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00196 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT64_T */
00197     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
00198         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00199 #endif /* src: int dst: uint64_t */
00200 
00201 /* src: int, dst: size_t */
00202 #if H5_SIZEOF_INT < H5_SIZEOF_SIZE_T
00203     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
00204         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00205 #elif H5_SIZEOF_INT > H5_SIZEOF_SIZE_T
00206     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
00207         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00208 #else /* H5_SIZEOF_INT == H5_SIZEOF_SIZE_T */
00209     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
00210         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00211 #endif /* src: int dst: size_t */
00212 
00213 /* src: int, dst: ssize_t */
00214 #if H5_SIZEOF_INT < H5_SIZEOF_SSIZE_T
00215     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
00216         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00217 #elif H5_SIZEOF_INT > H5_SIZEOF_SSIZE_T
00218     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
00219         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00220 #else /* H5_SIZEOF_INT == H5_SIZEOF_SSIZE_T */
00221     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
00222         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00223 #endif /* src: int dst: ssize_t */
00224 
00225 /* src: int, dst: haddr_t */
00226 #if H5_SIZEOF_INT < H5_SIZEOF_HADDR_T
00227     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
00228         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00229 #elif H5_SIZEOF_INT > H5_SIZEOF_HADDR_T
00230     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
00231         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00232 #else /* H5_SIZEOF_INT == H5_SIZEOF_HADDR_T */
00233     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
00234         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00235 #endif /* src: int dst: haddr_t */
00236 
00237 /* src: int, dst: hsize_t */
00238 #if H5_SIZEOF_INT < H5_SIZEOF_HSIZE_T
00239     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
00240         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00241 #elif H5_SIZEOF_INT > H5_SIZEOF_HSIZE_T
00242     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
00243         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00244 #else /* H5_SIZEOF_INT == H5_SIZEOF_HSIZE_T */
00245     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
00246         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00247 #endif /* src: int dst: hsize_t */
00248 
00249 /* src: int, dst: hssize_t */
00250 #if H5_SIZEOF_INT < H5_SIZEOF_HSSIZE_T
00251     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
00252         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00253 #elif H5_SIZEOF_INT > H5_SIZEOF_HSSIZE_T
00254     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
00255         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00256 #else /* H5_SIZEOF_INT == H5_SIZEOF_HSSIZE_T */
00257     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
00258         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00259 #endif /* src: int dst: hssize_t */
00260 
00261 /* src: int, dst: h5_stat_size_t */
00262 #if H5_SIZEOF_INT < H5_SIZEOF_H5_STAT_SIZE_T
00263     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00264         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00265 #elif H5_SIZEOF_INT > H5_SIZEOF_H5_STAT_SIZE_T
00266     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00267         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00268 #else /* H5_SIZEOF_INT == H5_SIZEOF_H5_STAT_SIZE_T */
00269     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00270         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00271 #endif /* src: int dst: h5_stat_size_t */
00272 
00273 
00274 /* Assignment checks for uint8_t */
00275 
00276 /* src: uint8_t, dst: unsigned */
00277 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UNSIGNED
00278     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
00279         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00280 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UNSIGNED
00281     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
00282         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00283 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UNSIGNED */
00284     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
00285         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00286 #endif /* src: uint8_t dst: unsigned */
00287 
00288 /* src: uint8_t, dst: int */
00289 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_INT
00290     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
00291         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00292 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_INT
00293     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
00294         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00295 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_INT */
00296     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
00297         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00298 #endif /* src: uint8_t dst: int */
00299 
00300 /* src: uint8_t, dst: uint32_t */
00301 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT32_T
00302     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
00303         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00304 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT32_T
00305     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
00306         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00307 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT32_T */
00308     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
00309         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00310 #endif /* src: uint8_t dst: uint32_t */
00311 
00312 /* src: uint8_t, dst: uint64_t */
00313 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT64_T
00314     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
00315         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00316 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT64_T
00317     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
00318         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00319 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT64_T */
00320     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
00321         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00322 #endif /* src: uint8_t dst: uint64_t */
00323 
00324 /* src: uint8_t, dst: size_t */
00325 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_SIZE_T
00326     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
00327         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00328 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_SIZE_T
00329     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
00330         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00331 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_SIZE_T */
00332     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
00333         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00334 #endif /* src: uint8_t dst: size_t */
00335 
00336 /* src: uint8_t, dst: ssize_t */
00337 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_SSIZE_T
00338     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
00339         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00340 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_SSIZE_T
00341     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
00342         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00343 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_SSIZE_T */
00344     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
00345         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00346 #endif /* src: uint8_t dst: ssize_t */
00347 
00348 /* src: uint8_t, dst: haddr_t */
00349 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HADDR_T
00350     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
00351         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00352 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HADDR_T
00353     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
00354         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00355 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HADDR_T */
00356     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
00357         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00358 #endif /* src: uint8_t dst: haddr_t */
00359 
00360 /* src: uint8_t, dst: hsize_t */
00361 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HSIZE_T
00362     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
00363         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00364 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HSIZE_T
00365     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
00366         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00367 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HSIZE_T */
00368     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
00369         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00370 #endif /* src: uint8_t dst: hsize_t */
00371 
00372 /* src: uint8_t, dst: hssize_t */
00373 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HSSIZE_T
00374     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
00375         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00376 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HSSIZE_T
00377     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
00378         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00379 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HSSIZE_T */
00380     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
00381         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00382 #endif /* src: uint8_t dst: hssize_t */
00383 
00384 /* src: uint8_t, dst: h5_stat_size_t */
00385 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_H5_STAT_SIZE_T
00386     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00387         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00388 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_H5_STAT_SIZE_T
00389     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00390         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00391 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_H5_STAT_SIZE_T */
00392     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00393         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00394 #endif /* src: uint8_t dst: h5_stat_size_t */
00395 
00396 
00397 /* Assignment checks for uint32_t */
00398 
00399 /* src: uint32_t, dst: unsigned */
00400 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UNSIGNED
00401     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
00402         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00403 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UNSIGNED
00404     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
00405         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00406 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UNSIGNED */
00407     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
00408         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00409 #endif /* src: uint32_t dst: unsigned */
00410 
00411 /* src: uint32_t, dst: int */
00412 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_INT
00413     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
00414         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00415 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_INT
00416     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
00417         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00418 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_INT */
00419     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
00420         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00421 #endif /* src: uint32_t dst: int */
00422 
00423 /* src: uint32_t, dst: uint8_t */
00424 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT8_T
00425     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
00426         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00427 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT8_T
00428     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
00429         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00430 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT8_T */
00431     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
00432         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00433 #endif /* src: uint32_t dst: uint8_t */
00434 
00435 /* src: uint32_t, dst: uint64_t */
00436 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT64_T
00437     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
00438         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00439 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT64_T
00440     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
00441         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00442 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT64_T */
00443     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
00444         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00445 #endif /* src: uint32_t dst: uint64_t */
00446 
00447 /* src: uint32_t, dst: size_t */
00448 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_SIZE_T
00449     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
00450         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00451 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_SIZE_T
00452     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
00453         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00454 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_SIZE_T */
00455     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
00456         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00457 #endif /* src: uint32_t dst: size_t */
00458 
00459 /* src: uint32_t, dst: ssize_t */
00460 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_SSIZE_T
00461     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
00462         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00463 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_SSIZE_T
00464     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
00465         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00466 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_SSIZE_T */
00467     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
00468         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00469 #endif /* src: uint32_t dst: ssize_t */
00470 
00471 /* src: uint32_t, dst: haddr_t */
00472 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HADDR_T
00473     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
00474         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00475 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HADDR_T
00476     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
00477         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00478 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HADDR_T */
00479     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
00480         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00481 #endif /* src: uint32_t dst: haddr_t */
00482 
00483 /* src: uint32_t, dst: hsize_t */
00484 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HSIZE_T
00485     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
00486         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00487 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HSIZE_T
00488     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
00489         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00490 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HSIZE_T */
00491     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
00492         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00493 #endif /* src: uint32_t dst: hsize_t */
00494 
00495 /* src: uint32_t, dst: hssize_t */
00496 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HSSIZE_T
00497     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
00498         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00499 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HSSIZE_T
00500     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
00501         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00502 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HSSIZE_T */
00503     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
00504         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00505 #endif /* src: uint32_t dst: hssize_t */
00506 
00507 /* src: uint32_t, dst: h5_stat_size_t */
00508 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_H5_STAT_SIZE_T
00509     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00510         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00511 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_H5_STAT_SIZE_T
00512     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00513         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00514 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_H5_STAT_SIZE_T */
00515     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00516         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00517 #endif /* src: uint32_t dst: h5_stat_size_t */
00518 
00519 
00520 /* Assignment checks for uint64_t */
00521 
00522 /* src: uint64_t, dst: unsigned */
00523 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UNSIGNED
00524     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
00525         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00526 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UNSIGNED
00527     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
00528         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00529 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UNSIGNED */
00530     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
00531         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00532 #endif /* src: uint64_t dst: unsigned */
00533 
00534 /* src: uint64_t, dst: int */
00535 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_INT
00536     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
00537         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00538 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_INT
00539     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
00540         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00541 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_INT */
00542     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
00543         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00544 #endif /* src: uint64_t dst: int */
00545 
00546 /* src: uint64_t, dst: uint8_t */
00547 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT8_T
00548     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
00549         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00550 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT8_T
00551     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
00552         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00553 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT8_T */
00554     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
00555         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00556 #endif /* src: uint64_t dst: uint8_t */
00557 
00558 /* src: uint64_t, dst: uint32_t */
00559 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT32_T
00560     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
00561         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00562 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT32_T
00563     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
00564         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00565 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT32_T */
00566     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
00567         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00568 #endif /* src: uint64_t dst: uint32_t */
00569 
00570 /* src: uint64_t, dst: size_t */
00571 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_SIZE_T
00572     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
00573         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00574 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_SIZE_T
00575     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
00576         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00577 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_SIZE_T */
00578     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
00579         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00580 #endif /* src: uint64_t dst: size_t */
00581 
00582 /* src: uint64_t, dst: ssize_t */
00583 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_SSIZE_T
00584     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
00585         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00586 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_SSIZE_T
00587     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
00588         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00589 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_SSIZE_T */
00590     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
00591         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00592 #endif /* src: uint64_t dst: ssize_t */
00593 
00594 /* src: uint64_t, dst: haddr_t */
00595 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HADDR_T
00596     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
00597         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00598 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HADDR_T
00599     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
00600         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00601 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HADDR_T */
00602     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
00603         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00604 #endif /* src: uint64_t dst: haddr_t */
00605 
00606 /* src: uint64_t, dst: hsize_t */
00607 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HSIZE_T
00608     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
00609         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00610 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HSIZE_T
00611     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
00612         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00613 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HSIZE_T */
00614     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
00615         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00616 #endif /* src: uint64_t dst: hsize_t */
00617 
00618 /* src: uint64_t, dst: hssize_t */
00619 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HSSIZE_T
00620     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
00621         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00622 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HSSIZE_T
00623     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
00624         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00625 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HSSIZE_T */
00626     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
00627         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00628 #endif /* src: uint64_t dst: hssize_t */
00629 
00630 /* src: uint64_t, dst: h5_stat_size_t */
00631 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_H5_STAT_SIZE_T
00632     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00633         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00634 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_H5_STAT_SIZE_T
00635     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00636         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00637 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_H5_STAT_SIZE_T */
00638     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00639         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00640 #endif /* src: uint64_t dst: h5_stat_size_t */
00641 
00642 
00643 /* Assignment checks for size_t */
00644 
00645 /* src: size_t, dst: unsigned */
00646 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UNSIGNED
00647     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
00648         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00649 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UNSIGNED
00650     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
00651         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00652 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UNSIGNED */
00653     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
00654         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00655 #endif /* src: size_t dst: unsigned */
00656 
00657 /* src: size_t, dst: int */
00658 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_INT
00659     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
00660         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00661 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_INT
00662     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
00663         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00664 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_INT */
00665     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
00666         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00667 #endif /* src: size_t dst: int */
00668 
00669 /* src: size_t, dst: uint8_t */
00670 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT8_T
00671     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
00672         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00673 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT8_T
00674     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
00675         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00676 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT8_T */
00677     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
00678         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00679 #endif /* src: size_t dst: uint8_t */
00680 
00681 /* src: size_t, dst: uint32_t */
00682 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT32_T
00683     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
00684         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00685 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT32_T
00686     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
00687         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00688 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT32_T */
00689     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
00690         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00691 #endif /* src: size_t dst: uint32_t */
00692 
00693 /* src: size_t, dst: uint64_t */
00694 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT64_T
00695     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
00696         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00697 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT64_T
00698     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
00699         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00700 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT64_T */
00701     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
00702         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00703 #endif /* src: size_t dst: uint64_t */
00704 
00705 /* src: size_t, dst: ssize_t */
00706 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_SSIZE_T
00707     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
00708         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00709 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_SSIZE_T
00710     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
00711         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00712 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_SSIZE_T */
00713     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
00714         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00715 #endif /* src: size_t dst: ssize_t */
00716 
00717 /* src: size_t, dst: haddr_t */
00718 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HADDR_T
00719     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
00720         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00721 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HADDR_T
00722     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
00723         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00724 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HADDR_T */
00725     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
00726         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00727 #endif /* src: size_t dst: haddr_t */
00728 
00729 /* src: size_t, dst: hsize_t */
00730 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HSIZE_T
00731     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
00732         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00733 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HSIZE_T
00734     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
00735         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00736 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HSIZE_T */
00737     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
00738         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00739 #endif /* src: size_t dst: hsize_t */
00740 
00741 /* src: size_t, dst: hssize_t */
00742 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HSSIZE_T
00743     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
00744         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00745 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HSSIZE_T
00746     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
00747         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00748 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HSSIZE_T */
00749     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
00750         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00751 #endif /* src: size_t dst: hssize_t */
00752 
00753 /* src: size_t, dst: h5_stat_size_t */
00754 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
00755     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00756         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00757 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
00758     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00759         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00760 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
00761     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00762         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00763 #endif /* src: size_t dst: h5_stat_size_t */
00764 
00765 
00766 /* Assignment checks for ssize_t */
00767 
00768 /* src: ssize_t, dst: unsigned */
00769 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UNSIGNED
00770     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
00771         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00772 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UNSIGNED
00773     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
00774         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00775 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UNSIGNED */
00776     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
00777         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00778 #endif /* src: ssize_t dst: unsigned */
00779 
00780 /* src: ssize_t, dst: int */
00781 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_INT
00782     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
00783         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00784 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_INT
00785     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
00786         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00787 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_INT */
00788     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
00789         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00790 #endif /* src: ssize_t dst: int */
00791 
00792 /* src: ssize_t, dst: uint8_t */
00793 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT8_T
00794     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
00795         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00796 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT8_T
00797     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
00798         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00799 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT8_T */
00800     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
00801         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00802 #endif /* src: ssize_t dst: uint8_t */
00803 
00804 /* src: ssize_t, dst: uint32_t */
00805 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT32_T
00806     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
00807         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00808 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT32_T
00809     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
00810         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00811 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT32_T */
00812     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
00813         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00814 #endif /* src: ssize_t dst: uint32_t */
00815 
00816 /* src: ssize_t, dst: uint64_t */
00817 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT64_T
00818     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
00819         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00820 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT64_T
00821     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
00822         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00823 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT64_T */
00824     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
00825         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00826 #endif /* src: ssize_t dst: uint64_t */
00827 
00828 /* src: ssize_t, dst: size_t */
00829 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_SIZE_T
00830     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
00831         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00832 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_SIZE_T
00833     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
00834         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00835 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_SIZE_T */
00836     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
00837         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00838 #endif /* src: ssize_t dst: size_t */
00839 
00840 /* src: ssize_t, dst: haddr_t */
00841 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HADDR_T
00842     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
00843         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00844 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HADDR_T
00845     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
00846         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00847 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HADDR_T */
00848     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
00849         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00850 #endif /* src: ssize_t dst: haddr_t */
00851 
00852 /* src: ssize_t, dst: hsize_t */
00853 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HSIZE_T
00854     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
00855         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00856 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HSIZE_T
00857     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
00858         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00859 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HSIZE_T */
00860     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
00861         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00862 #endif /* src: ssize_t dst: hsize_t */
00863 
00864 /* src: ssize_t, dst: hssize_t */
00865 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HSSIZE_T
00866     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
00867         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00868 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HSSIZE_T
00869     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
00870         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00871 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HSSIZE_T */
00872     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
00873         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00874 #endif /* src: ssize_t dst: hssize_t */
00875 
00876 /* src: ssize_t, dst: h5_stat_size_t */
00877 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
00878     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00879         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00880 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
00881     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00882         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00883 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
00884     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
00885         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
00886 #endif /* src: ssize_t dst: h5_stat_size_t */
00887 
00888 
00889 /* Assignment checks for haddr_t */
00890 
00891 /* src: haddr_t, dst: unsigned */
00892 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UNSIGNED
00893     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
00894         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00895 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UNSIGNED
00896     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
00897         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00898 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UNSIGNED */
00899     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
00900         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00901 #endif /* src: haddr_t dst: unsigned */
00902 
00903 /* src: haddr_t, dst: int */
00904 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_INT
00905     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
00906         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00907 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_INT
00908     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
00909         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00910 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_INT */
00911     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
00912         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00913 #endif /* src: haddr_t dst: int */
00914 
00915 /* src: haddr_t, dst: uint8_t */
00916 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT8_T
00917     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
00918         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00919 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT8_T
00920     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
00921         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00922 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT8_T */
00923     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
00924         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00925 #endif /* src: haddr_t dst: uint8_t */
00926 
00927 /* src: haddr_t, dst: uint32_t */
00928 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT32_T
00929     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
00930         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00931 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT32_T
00932     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
00933         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00934 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT32_T */
00935     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
00936         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00937 #endif /* src: haddr_t dst: uint32_t */
00938 
00939 /* src: haddr_t, dst: uint64_t */
00940 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT64_T
00941     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
00942         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00943 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT64_T
00944     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
00945         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00946 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT64_T */
00947     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
00948         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00949 #endif /* src: haddr_t dst: uint64_t */
00950 
00951 /* src: haddr_t, dst: size_t */
00952 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_SIZE_T
00953     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
00954         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00955 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_SIZE_T
00956     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
00957         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00958 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_SIZE_T */
00959     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
00960         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00961 #endif /* src: haddr_t dst: size_t */
00962 
00963 /* src: haddr_t, dst: ssize_t */
00964 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_SSIZE_T
00965     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
00966         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00967 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_SSIZE_T
00968     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
00969         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00970 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_SSIZE_T */
00971     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
00972         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00973 #endif /* src: haddr_t dst: ssize_t */
00974 
00975 /* src: haddr_t, dst: hsize_t */
00976 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_HSIZE_T
00977     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
00978         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00979 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_HSIZE_T
00980     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
00981         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00982 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_HSIZE_T */
00983     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
00984         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
00985 #endif /* src: haddr_t dst: hsize_t */
00986 
00987 /* src: haddr_t, dst: hssize_t */
00988 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_HSSIZE_T
00989     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
00990         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00991 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_HSSIZE_T
00992     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
00993         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
00994 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_HSSIZE_T */
00995     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
00996         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
00997 #endif /* src: haddr_t dst: hssize_t */
00998 
00999 /* src: haddr_t, dst: h5_stat_size_t */
01000 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_H5_STAT_SIZE_T
01001     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01002         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01003 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_H5_STAT_SIZE_T
01004     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01005         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01006 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_H5_STAT_SIZE_T */
01007     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01008         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01009 #endif /* src: haddr_t dst: h5_stat_size_t */
01010 
01011 
01012 /* Assignment checks for hsize_t */
01013 
01014 /* src: hsize_t, dst: unsigned */
01015 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UNSIGNED
01016     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
01017         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01018 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UNSIGNED
01019     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
01020         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01021 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UNSIGNED */
01022     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
01023         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01024 #endif /* src: hsize_t dst: unsigned */
01025 
01026 /* src: hsize_t, dst: int */
01027 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_INT
01028     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
01029         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01030 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_INT
01031     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
01032         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01033 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_INT */
01034     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
01035         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01036 #endif /* src: hsize_t dst: int */
01037 
01038 /* src: hsize_t, dst: uint8_t */
01039 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT8_T
01040     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01041         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01042 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT8_T
01043     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01044         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01045 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT8_T */
01046     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01047         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01048 #endif /* src: hsize_t dst: uint8_t */
01049 
01050 /* src: hsize_t, dst: uint32_t */
01051 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT32_T
01052     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01053         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01054 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT32_T
01055     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01056         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01057 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT32_T */
01058     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01059         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01060 #endif /* src: hsize_t dst: uint32_t */
01061 
01062 /* src: hsize_t, dst: uint64_t */
01063 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT64_T
01064     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01065         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01066 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT64_T
01067     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01068         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01069 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT64_T */
01070     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01071         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01072 #endif /* src: hsize_t dst: uint64_t */
01073 
01074 /* src: hsize_t, dst: size_t */
01075 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_SIZE_T
01076     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
01077         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01078 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_SIZE_T
01079     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
01080         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01081 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_SIZE_T */
01082     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
01083         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01084 #endif /* src: hsize_t dst: size_t */
01085 
01086 /* src: hsize_t, dst: ssize_t */
01087 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_SSIZE_T
01088     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01089         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01090 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_SSIZE_T
01091     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01092         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01093 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_SSIZE_T */
01094     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01095         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01096 #endif /* src: hsize_t dst: ssize_t */
01097 
01098 /* src: hsize_t, dst: haddr_t */
01099 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_HADDR_T
01100     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01101         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01102 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_HADDR_T
01103     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01104         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01105 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_HADDR_T */
01106     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01107         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01108 #endif /* src: hsize_t dst: haddr_t */
01109 
01110 /* src: hsize_t, dst: hssize_t */
01111 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_HSSIZE_T
01112     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01113         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01114 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_HSSIZE_T
01115     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01116         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01117 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_HSSIZE_T */
01118     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
01119         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01120 #endif /* src: hsize_t dst: hssize_t */
01121 
01122 /* src: hsize_t, dst: h5_stat_size_t */
01123 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
01124     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01125         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01126 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
01127     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01128         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01129 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
01130     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01131         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01132 #endif /* src: hsize_t dst: h5_stat_size_t */
01133 
01134 
01135 /* Assignment checks for hssize_t */
01136 
01137 /* src: hssize_t, dst: unsigned */
01138 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UNSIGNED
01139     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01140         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01141 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UNSIGNED
01142     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01143         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01144 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UNSIGNED */
01145     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
01146         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01147 #endif /* src: hssize_t dst: unsigned */
01148 
01149 /* src: hssize_t, dst: int */
01150 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_INT
01151     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
01152         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01153 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_INT
01154     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
01155         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01156 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_INT */
01157     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
01158         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01159 #endif /* src: hssize_t dst: int */
01160 
01161 /* src: hssize_t, dst: uint8_t */
01162 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT8_T
01163     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01164         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01165 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT8_T
01166     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01167         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01168 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT8_T */
01169     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
01170         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01171 #endif /* src: hssize_t dst: uint8_t */
01172 
01173 /* src: hssize_t, dst: uint32_t */
01174 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT32_T
01175     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01176         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01177 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT32_T
01178     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01179         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01180 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT32_T */
01181     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
01182         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01183 #endif /* src: hssize_t dst: uint32_t */
01184 
01185 /* src: hssize_t, dst: uint64_t */
01186 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT64_T
01187     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01188         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01189 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT64_T
01190     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01191         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01192 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT64_T */
01193     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
01194         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01195 #endif /* src: hssize_t dst: uint64_t */
01196 
01197 /* src: hssize_t, dst: size_t */
01198 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_SIZE_T
01199     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
01200         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01201 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_SIZE_T
01202     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
01203         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01204 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_SIZE_T */
01205     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
01206         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01207 #endif /* src: hssize_t dst: size_t */
01208 
01209 /* src: hssize_t, dst: ssize_t */
01210 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_SSIZE_T
01211     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01212         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01213 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_SSIZE_T
01214     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01215         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01216 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_SSIZE_T */
01217     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
01218         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01219 #endif /* src: hssize_t dst: ssize_t */
01220 
01221 /* src: hssize_t, dst: haddr_t */
01222 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_HADDR_T
01223     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01224         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01225 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_HADDR_T
01226     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01227         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01228 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_HADDR_T */
01229     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
01230         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01231 #endif /* src: hssize_t dst: haddr_t */
01232 
01233 /* src: hssize_t, dst: hsize_t */
01234 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_HSIZE_T
01235     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01236         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01237 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_HSIZE_T
01238     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01239         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01240 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_HSIZE_T */
01241     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
01242         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01243 #endif /* src: hssize_t dst: hsize_t */
01244 
01245 /* src: hssize_t, dst: h5_stat_size_t */
01246 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
01247     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01248         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01249 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
01250     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01251         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01252 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
01253     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
01254         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
01255 #endif /* src: hssize_t dst: h5_stat_size_t */
01256 
01257 
01258 /* Assignment checks for h5_stat_size_t */
01259 
01260 /* src: h5_stat_size_t, dst: unsigned */
01261 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UNSIGNED
01262     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01263         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01264 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UNSIGNED
01265     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01266         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01267 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UNSIGNED */
01268     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
01269         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01270 #endif /* src: h5_stat_size_t dst: unsigned */
01271 
01272 /* src: h5_stat_size_t, dst: int */
01273 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_INT
01274     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
01275         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01276 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_INT
01277     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
01278         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01279 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_INT */
01280     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
01281         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01282 #endif /* src: h5_stat_size_t dst: int */
01283 
01284 /* src: h5_stat_size_t, dst: uint8_t */
01285 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT8_T
01286     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01287         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01288 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT8_T
01289     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01290         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01291 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT8_T */
01292     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
01293         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01294 #endif /* src: h5_stat_size_t dst: uint8_t */
01295 
01296 /* src: h5_stat_size_t, dst: uint32_t */
01297 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT32_T
01298     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01299         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01300 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT32_T
01301     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01302         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01303 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT32_T */
01304     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
01305         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01306 #endif /* src: h5_stat_size_t dst: uint32_t */
01307 
01308 /* src: h5_stat_size_t, dst: uint64_t */
01309 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT64_T
01310     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01311         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01312 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT64_T
01313     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01314         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01315 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT64_T */
01316     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
01317         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01318 #endif /* src: h5_stat_size_t dst: uint64_t */
01319 
01320 /* src: h5_stat_size_t, dst: size_t */
01321 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_SIZE_T
01322     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
01323         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01324 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_SIZE_T
01325     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
01326         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01327 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_SIZE_T */
01328     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
01329         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01330 #endif /* src: h5_stat_size_t dst: size_t */
01331 
01332 /* src: h5_stat_size_t, dst: ssize_t */
01333 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_SSIZE_T
01334     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01335         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01336 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_SSIZE_T
01337     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01338         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01339 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_SSIZE_T */
01340     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
01341         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01342 #endif /* src: h5_stat_size_t dst: ssize_t */
01343 
01344 /* src: h5_stat_size_t, dst: haddr_t */
01345 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HADDR_T
01346     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01347         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01348 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HADDR_T
01349     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01350         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01351 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HADDR_T */
01352     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
01353         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01354 #endif /* src: h5_stat_size_t dst: haddr_t */
01355 
01356 /* src: h5_stat_size_t, dst: hsize_t */
01357 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HSIZE_T
01358     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01359         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01360 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HSIZE_T
01361     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01362         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01363 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HSIZE_T */
01364     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
01365         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
01366 #endif /* src: h5_stat_size_t dst: hsize_t */
01367 
01368 /* src: h5_stat_size_t, dst: hssize_t */
01369 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HSSIZE_T
01370     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01371         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01372 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HSSIZE_T
01373     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01374         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
01375 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HSSIZE_T */
01376     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
01377         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
01378 #endif /* src: h5_stat_size_t dst: hssize_t */
01379 
01380 #endif /* H5overflow_H */
01381