source/include/H5overflow.h

0001 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
0002  * Copyright by The HDF Group.                                               *
0003  * All rights reserved.                                                      *
0004  *                                                                           *
0005  * This file is part of HDF5.  The full HDF5 copyright notice, including     *
0006  * terms governing use, modification, and redistribution, is contained in    *
0007  * the COPYING file, which can be found at the root of the source code       *
0008  * distribution tree, or in https://www.hdfgroup.org/licenses.               *
0009  * If you do not have access to either file, you may request a copy from     *
0010  * help@hdfgroup.org.                                                        *
0011  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
0012
0013 /* Generated automatically by bin/make_overflow -- do not edit */
0014 /* Add new types to H5overflow.txt file */
0015
0016
0017 #ifndef H5overflow_H
0018 #define H5overflow_H
0019
0020
0021 /* Each type in this file is tested for assignment to the other types,
0022  *      and range checks are defined for bad assignments at run-time.
0023  */
0024
0025 /* Assignment checks for unsigned */
0026
0027 /* src: unsigned, dst: int8_t */
0028 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_INT8_T
0029     #define ASSIGN_unsigned_TO_int8_t(dst, dsttype, src, srctype) \
0030         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0031 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_INT8_T
0032     #define ASSIGN_unsigned_TO_int8_t(dst, dsttype, src, srctype) \
0033         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0034 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_INT8_T */
0035     #define ASSIGN_unsigned_TO_int8_t(dst, dsttype, src, srctype) \
0036         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0037 #endif /* src: unsigned dst: int8_t */
0038
0039 /* src: unsigned, dst: int */
0040 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_INT
0041     #define ASSIGN_unsigned_TO_int(dst, dsttype, src, srctype) \
0042         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0043 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_INT
0044     #define ASSIGN_unsigned_TO_int(dst, dsttype, src, srctype) \
0045         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0046 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_INT */
0047     #define ASSIGN_unsigned_TO_int(dst, dsttype, src, srctype) \
0048         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0049 #endif /* src: unsigned dst: int */
0050
0051 /* src: unsigned, dst: long */
0052 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_LONG
0053     #define ASSIGN_unsigned_TO_long(dst, dsttype, src, srctype) \
0054         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0055 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_LONG
0056     #define ASSIGN_unsigned_TO_long(dst, dsttype, src, srctype) \
0057         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0058 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_LONG */
0059     #define ASSIGN_unsigned_TO_long(dst, dsttype, src, srctype) \
0060         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0061 #endif /* src: unsigned dst: long */
0062
0063 /* src: unsigned, dst: int64_t */
0064 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_INT64_T
0065     #define ASSIGN_unsigned_TO_int64_t(dst, dsttype, src, srctype) \
0066         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0067 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_INT64_T
0068     #define ASSIGN_unsigned_TO_int64_t(dst, dsttype, src, srctype) \
0069         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0070 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_INT64_T */
0071     #define ASSIGN_unsigned_TO_int64_t(dst, dsttype, src, srctype) \
0072         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0073 #endif /* src: unsigned dst: int64_t */
0074
0075 /* src: unsigned, dst: uint8_t */
0076 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT8_T
0077     #define ASSIGN_unsigned_TO_uint8_t(dst, dsttype, src, srctype) \
0078         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0079 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT8_T
0080     #define ASSIGN_unsigned_TO_uint8_t(dst, dsttype, src, srctype) \
0081         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0082 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT8_T */
0083     #define ASSIGN_unsigned_TO_uint8_t(dst, dsttype, src, srctype) \
0084         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0085 #endif /* src: unsigned dst: uint8_t */
0086
0087 /* src: unsigned, dst: uint16_t */
0088 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT16_T
0089     #define ASSIGN_unsigned_TO_uint16_t(dst, dsttype, src, srctype) \
0090         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0091 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT16_T
0092     #define ASSIGN_unsigned_TO_uint16_t(dst, dsttype, src, srctype) \
0093         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0094 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT16_T */
0095     #define ASSIGN_unsigned_TO_uint16_t(dst, dsttype, src, srctype) \
0096         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0097 #endif /* src: unsigned dst: uint16_t */
0098
0099 /* src: unsigned, dst: uint32_t */
0100 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT32_T
0101     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
0102         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0103 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT32_T
0104     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
0105         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0106 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT32_T */
0107     #define ASSIGN_unsigned_TO_uint32_t(dst, dsttype, src, srctype) \
0108         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0109 #endif /* src: unsigned dst: uint32_t */
0110
0111 /* src: unsigned, dst: uint64_t */
0112 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_UINT64_T
0113     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
0114         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0115 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_UINT64_T
0116     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
0117         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0118 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_UINT64_T */
0119     #define ASSIGN_unsigned_TO_uint64_t(dst, dsttype, src, srctype) \
0120         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0121 #endif /* src: unsigned dst: uint64_t */
0122
0123 /* src: unsigned, dst: ptrdiff_t */
0124 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_PTRDIFF_T
0125     #define ASSIGN_unsigned_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0126         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0127 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_PTRDIFF_T
0128     #define ASSIGN_unsigned_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0129         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0130 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_PTRDIFF_T */
0131     #define ASSIGN_unsigned_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0132         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0133 #endif /* src: unsigned dst: ptrdiff_t */
0134
0135 /* src: unsigned, dst: size_t */
0136 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_SIZE_T
0137     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
0138         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0139 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_SIZE_T
0140     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
0141         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0142 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_SIZE_T */
0143     #define ASSIGN_unsigned_TO_size_t(dst, dsttype, src, srctype) \
0144         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0145 #endif /* src: unsigned dst: size_t */
0146
0147 /* src: unsigned, dst: ssize_t */
0148 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_SSIZE_T
0149     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
0150         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0151 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_SSIZE_T
0152     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
0153         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0154 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_SSIZE_T */
0155     #define ASSIGN_unsigned_TO_ssize_t(dst, dsttype, src, srctype) \
0156         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0157 #endif /* src: unsigned dst: ssize_t */
0158
0159 /* src: unsigned, dst: haddr_t */
0160 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HADDR_T
0161     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
0162         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0163 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HADDR_T
0164     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
0165         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0166 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HADDR_T */
0167     #define ASSIGN_unsigned_TO_haddr_t(dst, dsttype, src, srctype) \
0168         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0169 #endif /* src: unsigned dst: haddr_t */
0170
0171 /* src: unsigned, dst: hsize_t */
0172 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HSIZE_T
0173     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
0174         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0175 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HSIZE_T
0176     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
0177         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0178 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HSIZE_T */
0179     #define ASSIGN_unsigned_TO_hsize_t(dst, dsttype, src, srctype) \
0180         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0181 #endif /* src: unsigned dst: hsize_t */
0182
0183 /* src: unsigned, dst: hssize_t */
0184 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_HSSIZE_T
0185     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
0186         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0187 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_HSSIZE_T
0188     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
0189         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0190 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_HSSIZE_T */
0191     #define ASSIGN_unsigned_TO_hssize_t(dst, dsttype, src, srctype) \
0192         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0193 #endif /* src: unsigned dst: hssize_t */
0194
0195 /* src: unsigned, dst: h5_stat_size_t */
0196 #if H5_SIZEOF_UNSIGNED < H5_SIZEOF_H5_STAT_SIZE_T
0197     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0198         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0199 #elif H5_SIZEOF_UNSIGNED > H5_SIZEOF_H5_STAT_SIZE_T
0200     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0201         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0202 #else /* H5_SIZEOF_UNSIGNED == H5_SIZEOF_H5_STAT_SIZE_T */
0203     #define ASSIGN_unsigned_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0204         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0205 #endif /* src: unsigned dst: h5_stat_size_t */
0206
0207
0208 /* Assignment checks for int8_t */
0209
0210 /* src: int8_t, dst: unsigned */
0211 #if H5_SIZEOF_INT8_T < H5_SIZEOF_UNSIGNED
0212     #define ASSIGN_int8_t_TO_unsigned(dst, dsttype, src, srctype) \
0213         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0214 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_UNSIGNED
0215     #define ASSIGN_int8_t_TO_unsigned(dst, dsttype, src, srctype) \
0216         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0217 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_UNSIGNED */
0218     #define ASSIGN_int8_t_TO_unsigned(dst, dsttype, src, srctype) \
0219         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0220 #endif /* src: int8_t dst: unsigned */
0221
0222 /* src: int8_t, dst: int */
0223 #if H5_SIZEOF_INT8_T < H5_SIZEOF_INT
0224     #define ASSIGN_int8_t_TO_int(dst, dsttype, src, srctype) \
0225         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0226 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_INT
0227     #define ASSIGN_int8_t_TO_int(dst, dsttype, src, srctype) \
0228         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0229 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_INT */
0230     #define ASSIGN_int8_t_TO_int(dst, dsttype, src, srctype) \
0231         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0232 #endif /* src: int8_t dst: int */
0233
0234 /* src: int8_t, dst: long */
0235 #if H5_SIZEOF_INT8_T < H5_SIZEOF_LONG
0236     #define ASSIGN_int8_t_TO_long(dst, dsttype, src, srctype) \
0237         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0238 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_LONG
0239     #define ASSIGN_int8_t_TO_long(dst, dsttype, src, srctype) \
0240         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0241 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_LONG */
0242     #define ASSIGN_int8_t_TO_long(dst, dsttype, src, srctype) \
0243         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0244 #endif /* src: int8_t dst: long */
0245
0246 /* src: int8_t, dst: int64_t */
0247 #if H5_SIZEOF_INT8_T < H5_SIZEOF_INT64_T
0248     #define ASSIGN_int8_t_TO_int64_t(dst, dsttype, src, srctype) \
0249         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0250 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_INT64_T
0251     #define ASSIGN_int8_t_TO_int64_t(dst, dsttype, src, srctype) \
0252         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0253 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_INT64_T */
0254     #define ASSIGN_int8_t_TO_int64_t(dst, dsttype, src, srctype) \
0255         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0256 #endif /* src: int8_t dst: int64_t */
0257
0258 /* src: int8_t, dst: uint8_t */
0259 #if H5_SIZEOF_INT8_T < H5_SIZEOF_UINT8_T
0260     #define ASSIGN_int8_t_TO_uint8_t(dst, dsttype, src, srctype) \
0261         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0262 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_UINT8_T
0263     #define ASSIGN_int8_t_TO_uint8_t(dst, dsttype, src, srctype) \
0264         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0265 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_UINT8_T */
0266     #define ASSIGN_int8_t_TO_uint8_t(dst, dsttype, src, srctype) \
0267         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0268 #endif /* src: int8_t dst: uint8_t */
0269
0270 /* src: int8_t, dst: uint16_t */
0271 #if H5_SIZEOF_INT8_T < H5_SIZEOF_UINT16_T
0272     #define ASSIGN_int8_t_TO_uint16_t(dst, dsttype, src, srctype) \
0273         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0274 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_UINT16_T
0275     #define ASSIGN_int8_t_TO_uint16_t(dst, dsttype, src, srctype) \
0276         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0277 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_UINT16_T */
0278     #define ASSIGN_int8_t_TO_uint16_t(dst, dsttype, src, srctype) \
0279         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0280 #endif /* src: int8_t dst: uint16_t */
0281
0282 /* src: int8_t, dst: uint32_t */
0283 #if H5_SIZEOF_INT8_T < H5_SIZEOF_UINT32_T
0284     #define ASSIGN_int8_t_TO_uint32_t(dst, dsttype, src, srctype) \
0285         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0286 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_UINT32_T
0287     #define ASSIGN_int8_t_TO_uint32_t(dst, dsttype, src, srctype) \
0288         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0289 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_UINT32_T */
0290     #define ASSIGN_int8_t_TO_uint32_t(dst, dsttype, src, srctype) \
0291         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0292 #endif /* src: int8_t dst: uint32_t */
0293
0294 /* src: int8_t, dst: uint64_t */
0295 #if H5_SIZEOF_INT8_T < H5_SIZEOF_UINT64_T
0296     #define ASSIGN_int8_t_TO_uint64_t(dst, dsttype, src, srctype) \
0297         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0298 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_UINT64_T
0299     #define ASSIGN_int8_t_TO_uint64_t(dst, dsttype, src, srctype) \
0300         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0301 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_UINT64_T */
0302     #define ASSIGN_int8_t_TO_uint64_t(dst, dsttype, src, srctype) \
0303         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0304 #endif /* src: int8_t dst: uint64_t */
0305
0306 /* src: int8_t, dst: ptrdiff_t */
0307 #if H5_SIZEOF_INT8_T < H5_SIZEOF_PTRDIFF_T
0308     #define ASSIGN_int8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0309         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0310 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_PTRDIFF_T
0311     #define ASSIGN_int8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0312         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0313 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_PTRDIFF_T */
0314     #define ASSIGN_int8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0315         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0316 #endif /* src: int8_t dst: ptrdiff_t */
0317
0318 /* src: int8_t, dst: size_t */
0319 #if H5_SIZEOF_INT8_T < H5_SIZEOF_SIZE_T
0320     #define ASSIGN_int8_t_TO_size_t(dst, dsttype, src, srctype) \
0321         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0322 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_SIZE_T
0323     #define ASSIGN_int8_t_TO_size_t(dst, dsttype, src, srctype) \
0324         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0325 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_SIZE_T */
0326     #define ASSIGN_int8_t_TO_size_t(dst, dsttype, src, srctype) \
0327         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0328 #endif /* src: int8_t dst: size_t */
0329
0330 /* src: int8_t, dst: ssize_t */
0331 #if H5_SIZEOF_INT8_T < H5_SIZEOF_SSIZE_T
0332     #define ASSIGN_int8_t_TO_ssize_t(dst, dsttype, src, srctype) \
0333         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0334 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_SSIZE_T
0335     #define ASSIGN_int8_t_TO_ssize_t(dst, dsttype, src, srctype) \
0336         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0337 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_SSIZE_T */
0338     #define ASSIGN_int8_t_TO_ssize_t(dst, dsttype, src, srctype) \
0339         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0340 #endif /* src: int8_t dst: ssize_t */
0341
0342 /* src: int8_t, dst: haddr_t */
0343 #if H5_SIZEOF_INT8_T < H5_SIZEOF_HADDR_T
0344     #define ASSIGN_int8_t_TO_haddr_t(dst, dsttype, src, srctype) \
0345         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0346 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_HADDR_T
0347     #define ASSIGN_int8_t_TO_haddr_t(dst, dsttype, src, srctype) \
0348         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0349 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_HADDR_T */
0350     #define ASSIGN_int8_t_TO_haddr_t(dst, dsttype, src, srctype) \
0351         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0352 #endif /* src: int8_t dst: haddr_t */
0353
0354 /* src: int8_t, dst: hsize_t */
0355 #if H5_SIZEOF_INT8_T < H5_SIZEOF_HSIZE_T
0356     #define ASSIGN_int8_t_TO_hsize_t(dst, dsttype, src, srctype) \
0357         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0358 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_HSIZE_T
0359     #define ASSIGN_int8_t_TO_hsize_t(dst, dsttype, src, srctype) \
0360         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0361 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_HSIZE_T */
0362     #define ASSIGN_int8_t_TO_hsize_t(dst, dsttype, src, srctype) \
0363         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0364 #endif /* src: int8_t dst: hsize_t */
0365
0366 /* src: int8_t, dst: hssize_t */
0367 #if H5_SIZEOF_INT8_T < H5_SIZEOF_HSSIZE_T
0368     #define ASSIGN_int8_t_TO_hssize_t(dst, dsttype, src, srctype) \
0369         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0370 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_HSSIZE_T
0371     #define ASSIGN_int8_t_TO_hssize_t(dst, dsttype, src, srctype) \
0372         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0373 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_HSSIZE_T */
0374     #define ASSIGN_int8_t_TO_hssize_t(dst, dsttype, src, srctype) \
0375         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0376 #endif /* src: int8_t dst: hssize_t */
0377
0378 /* src: int8_t, dst: h5_stat_size_t */
0379 #if H5_SIZEOF_INT8_T < H5_SIZEOF_H5_STAT_SIZE_T
0380     #define ASSIGN_int8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0381         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0382 #elif H5_SIZEOF_INT8_T > H5_SIZEOF_H5_STAT_SIZE_T
0383     #define ASSIGN_int8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0384         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0385 #else /* H5_SIZEOF_INT8_T == H5_SIZEOF_H5_STAT_SIZE_T */
0386     #define ASSIGN_int8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0387         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0388 #endif /* src: int8_t dst: h5_stat_size_t */
0389
0390
0391 /* Assignment checks for int */
0392
0393 /* src: int, dst: unsigned */
0394 #if H5_SIZEOF_INT < H5_SIZEOF_UNSIGNED
0395     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
0396         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0397 #elif H5_SIZEOF_INT > H5_SIZEOF_UNSIGNED
0398     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
0399         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0400 #else /* H5_SIZEOF_INT == H5_SIZEOF_UNSIGNED */
0401     #define ASSIGN_int_TO_unsigned(dst, dsttype, src, srctype) \
0402         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0403 #endif /* src: int dst: unsigned */
0404
0405 /* src: int, dst: int8_t */
0406 #if H5_SIZEOF_INT < H5_SIZEOF_INT8_T
0407     #define ASSIGN_int_TO_int8_t(dst, dsttype, src, srctype) \
0408         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0409 #elif H5_SIZEOF_INT > H5_SIZEOF_INT8_T
0410     #define ASSIGN_int_TO_int8_t(dst, dsttype, src, srctype) \
0411         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0412 #else /* H5_SIZEOF_INT == H5_SIZEOF_INT8_T */
0413     #define ASSIGN_int_TO_int8_t(dst, dsttype, src, srctype) \
0414         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0415 #endif /* src: int dst: int8_t */
0416
0417 /* src: int, dst: long */
0418 #if H5_SIZEOF_INT < H5_SIZEOF_LONG
0419     #define ASSIGN_int_TO_long(dst, dsttype, src, srctype) \
0420         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0421 #elif H5_SIZEOF_INT > H5_SIZEOF_LONG
0422     #define ASSIGN_int_TO_long(dst, dsttype, src, srctype) \
0423         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0424 #else /* H5_SIZEOF_INT == H5_SIZEOF_LONG */
0425     #define ASSIGN_int_TO_long(dst, dsttype, src, srctype) \
0426         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0427 #endif /* src: int dst: long */
0428
0429 /* src: int, dst: int64_t */
0430 #if H5_SIZEOF_INT < H5_SIZEOF_INT64_T
0431     #define ASSIGN_int_TO_int64_t(dst, dsttype, src, srctype) \
0432         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0433 #elif H5_SIZEOF_INT > H5_SIZEOF_INT64_T
0434     #define ASSIGN_int_TO_int64_t(dst, dsttype, src, srctype) \
0435         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0436 #else /* H5_SIZEOF_INT == H5_SIZEOF_INT64_T */
0437     #define ASSIGN_int_TO_int64_t(dst, dsttype, src, srctype) \
0438         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0439 #endif /* src: int dst: int64_t */
0440
0441 /* src: int, dst: uint8_t */
0442 #if H5_SIZEOF_INT < H5_SIZEOF_UINT8_T
0443     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
0444         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0445 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT8_T
0446     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
0447         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0448 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT8_T */
0449     #define ASSIGN_int_TO_uint8_t(dst, dsttype, src, srctype) \
0450         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0451 #endif /* src: int dst: uint8_t */
0452
0453 /* src: int, dst: uint16_t */
0454 #if H5_SIZEOF_INT < H5_SIZEOF_UINT16_T
0455     #define ASSIGN_int_TO_uint16_t(dst, dsttype, src, srctype) \
0456         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0457 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT16_T
0458     #define ASSIGN_int_TO_uint16_t(dst, dsttype, src, srctype) \
0459         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0460 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT16_T */
0461     #define ASSIGN_int_TO_uint16_t(dst, dsttype, src, srctype) \
0462         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0463 #endif /* src: int dst: uint16_t */
0464
0465 /* src: int, dst: uint32_t */
0466 #if H5_SIZEOF_INT < H5_SIZEOF_UINT32_T
0467     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
0468         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0469 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT32_T
0470     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
0471         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0472 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT32_T */
0473     #define ASSIGN_int_TO_uint32_t(dst, dsttype, src, srctype) \
0474         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0475 #endif /* src: int dst: uint32_t */
0476
0477 /* src: int, dst: uint64_t */
0478 #if H5_SIZEOF_INT < H5_SIZEOF_UINT64_T
0479     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
0480         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0481 #elif H5_SIZEOF_INT > H5_SIZEOF_UINT64_T
0482     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
0483         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0484 #else /* H5_SIZEOF_INT == H5_SIZEOF_UINT64_T */
0485     #define ASSIGN_int_TO_uint64_t(dst, dsttype, src, srctype) \
0486         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0487 #endif /* src: int dst: uint64_t */
0488
0489 /* src: int, dst: ptrdiff_t */
0490 #if H5_SIZEOF_INT < H5_SIZEOF_PTRDIFF_T
0491     #define ASSIGN_int_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0492         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0493 #elif H5_SIZEOF_INT > H5_SIZEOF_PTRDIFF_T
0494     #define ASSIGN_int_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0495         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0496 #else /* H5_SIZEOF_INT == H5_SIZEOF_PTRDIFF_T */
0497     #define ASSIGN_int_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0498         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0499 #endif /* src: int dst: ptrdiff_t */
0500
0501 /* src: int, dst: size_t */
0502 #if H5_SIZEOF_INT < H5_SIZEOF_SIZE_T
0503     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
0504         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0505 #elif H5_SIZEOF_INT > H5_SIZEOF_SIZE_T
0506     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
0507         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0508 #else /* H5_SIZEOF_INT == H5_SIZEOF_SIZE_T */
0509     #define ASSIGN_int_TO_size_t(dst, dsttype, src, srctype) \
0510         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0511 #endif /* src: int dst: size_t */
0512
0513 /* src: int, dst: ssize_t */
0514 #if H5_SIZEOF_INT < H5_SIZEOF_SSIZE_T
0515     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
0516         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0517 #elif H5_SIZEOF_INT > H5_SIZEOF_SSIZE_T
0518     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
0519         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0520 #else /* H5_SIZEOF_INT == H5_SIZEOF_SSIZE_T */
0521     #define ASSIGN_int_TO_ssize_t(dst, dsttype, src, srctype) \
0522         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0523 #endif /* src: int dst: ssize_t */
0524
0525 /* src: int, dst: haddr_t */
0526 #if H5_SIZEOF_INT < H5_SIZEOF_HADDR_T
0527     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
0528         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0529 #elif H5_SIZEOF_INT > H5_SIZEOF_HADDR_T
0530     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
0531         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0532 #else /* H5_SIZEOF_INT == H5_SIZEOF_HADDR_T */
0533     #define ASSIGN_int_TO_haddr_t(dst, dsttype, src, srctype) \
0534         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0535 #endif /* src: int dst: haddr_t */
0536
0537 /* src: int, dst: hsize_t */
0538 #if H5_SIZEOF_INT < H5_SIZEOF_HSIZE_T
0539     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
0540         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0541 #elif H5_SIZEOF_INT > H5_SIZEOF_HSIZE_T
0542     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
0543         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0544 #else /* H5_SIZEOF_INT == H5_SIZEOF_HSIZE_T */
0545     #define ASSIGN_int_TO_hsize_t(dst, dsttype, src, srctype) \
0546         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0547 #endif /* src: int dst: hsize_t */
0548
0549 /* src: int, dst: hssize_t */
0550 #if H5_SIZEOF_INT < H5_SIZEOF_HSSIZE_T
0551     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
0552         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0553 #elif H5_SIZEOF_INT > H5_SIZEOF_HSSIZE_T
0554     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
0555         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0556 #else /* H5_SIZEOF_INT == H5_SIZEOF_HSSIZE_T */
0557     #define ASSIGN_int_TO_hssize_t(dst, dsttype, src, srctype) \
0558         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0559 #endif /* src: int dst: hssize_t */
0560
0561 /* src: int, dst: h5_stat_size_t */
0562 #if H5_SIZEOF_INT < H5_SIZEOF_H5_STAT_SIZE_T
0563     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0564         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0565 #elif H5_SIZEOF_INT > H5_SIZEOF_H5_STAT_SIZE_T
0566     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0567         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0568 #else /* H5_SIZEOF_INT == H5_SIZEOF_H5_STAT_SIZE_T */
0569     #define ASSIGN_int_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0570         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0571 #endif /* src: int dst: h5_stat_size_t */
0572
0573
0574 /* Assignment checks for long */
0575
0576 /* src: long, dst: unsigned */
0577 #if H5_SIZEOF_LONG < H5_SIZEOF_UNSIGNED
0578     #define ASSIGN_long_TO_unsigned(dst, dsttype, src, srctype) \
0579         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0580 #elif H5_SIZEOF_LONG > H5_SIZEOF_UNSIGNED
0581     #define ASSIGN_long_TO_unsigned(dst, dsttype, src, srctype) \
0582         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0583 #else /* H5_SIZEOF_LONG == H5_SIZEOF_UNSIGNED */
0584     #define ASSIGN_long_TO_unsigned(dst, dsttype, src, srctype) \
0585         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0586 #endif /* src: long dst: unsigned */
0587
0588 /* src: long, dst: int8_t */
0589 #if H5_SIZEOF_LONG < H5_SIZEOF_INT8_T
0590     #define ASSIGN_long_TO_int8_t(dst, dsttype, src, srctype) \
0591         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0592 #elif H5_SIZEOF_LONG > H5_SIZEOF_INT8_T
0593     #define ASSIGN_long_TO_int8_t(dst, dsttype, src, srctype) \
0594         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0595 #else /* H5_SIZEOF_LONG == H5_SIZEOF_INT8_T */
0596     #define ASSIGN_long_TO_int8_t(dst, dsttype, src, srctype) \
0597         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0598 #endif /* src: long dst: int8_t */
0599
0600 /* src: long, dst: int */
0601 #if H5_SIZEOF_LONG < H5_SIZEOF_INT
0602     #define ASSIGN_long_TO_int(dst, dsttype, src, srctype) \
0603         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0604 #elif H5_SIZEOF_LONG > H5_SIZEOF_INT
0605     #define ASSIGN_long_TO_int(dst, dsttype, src, srctype) \
0606         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0607 #else /* H5_SIZEOF_LONG == H5_SIZEOF_INT */
0608     #define ASSIGN_long_TO_int(dst, dsttype, src, srctype) \
0609         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0610 #endif /* src: long dst: int */
0611
0612 /* src: long, dst: int64_t */
0613 #if H5_SIZEOF_LONG < H5_SIZEOF_INT64_T
0614     #define ASSIGN_long_TO_int64_t(dst, dsttype, src, srctype) \
0615         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0616 #elif H5_SIZEOF_LONG > H5_SIZEOF_INT64_T
0617     #define ASSIGN_long_TO_int64_t(dst, dsttype, src, srctype) \
0618         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0619 #else /* H5_SIZEOF_LONG == H5_SIZEOF_INT64_T */
0620     #define ASSIGN_long_TO_int64_t(dst, dsttype, src, srctype) \
0621         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0622 #endif /* src: long dst: int64_t */
0623
0624 /* src: long, dst: uint8_t */
0625 #if H5_SIZEOF_LONG < H5_SIZEOF_UINT8_T
0626     #define ASSIGN_long_TO_uint8_t(dst, dsttype, src, srctype) \
0627         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0628 #elif H5_SIZEOF_LONG > H5_SIZEOF_UINT8_T
0629     #define ASSIGN_long_TO_uint8_t(dst, dsttype, src, srctype) \
0630         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0631 #else /* H5_SIZEOF_LONG == H5_SIZEOF_UINT8_T */
0632     #define ASSIGN_long_TO_uint8_t(dst, dsttype, src, srctype) \
0633         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0634 #endif /* src: long dst: uint8_t */
0635
0636 /* src: long, dst: uint16_t */
0637 #if H5_SIZEOF_LONG < H5_SIZEOF_UINT16_T
0638     #define ASSIGN_long_TO_uint16_t(dst, dsttype, src, srctype) \
0639         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0640 #elif H5_SIZEOF_LONG > H5_SIZEOF_UINT16_T
0641     #define ASSIGN_long_TO_uint16_t(dst, dsttype, src, srctype) \
0642         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0643 #else /* H5_SIZEOF_LONG == H5_SIZEOF_UINT16_T */
0644     #define ASSIGN_long_TO_uint16_t(dst, dsttype, src, srctype) \
0645         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0646 #endif /* src: long dst: uint16_t */
0647
0648 /* src: long, dst: uint32_t */
0649 #if H5_SIZEOF_LONG < H5_SIZEOF_UINT32_T
0650     #define ASSIGN_long_TO_uint32_t(dst, dsttype, src, srctype) \
0651         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0652 #elif H5_SIZEOF_LONG > H5_SIZEOF_UINT32_T
0653     #define ASSIGN_long_TO_uint32_t(dst, dsttype, src, srctype) \
0654         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0655 #else /* H5_SIZEOF_LONG == H5_SIZEOF_UINT32_T */
0656     #define ASSIGN_long_TO_uint32_t(dst, dsttype, src, srctype) \
0657         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0658 #endif /* src: long dst: uint32_t */
0659
0660 /* src: long, dst: uint64_t */
0661 #if H5_SIZEOF_LONG < H5_SIZEOF_UINT64_T
0662     #define ASSIGN_long_TO_uint64_t(dst, dsttype, src, srctype) \
0663         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0664 #elif H5_SIZEOF_LONG > H5_SIZEOF_UINT64_T
0665     #define ASSIGN_long_TO_uint64_t(dst, dsttype, src, srctype) \
0666         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0667 #else /* H5_SIZEOF_LONG == H5_SIZEOF_UINT64_T */
0668     #define ASSIGN_long_TO_uint64_t(dst, dsttype, src, srctype) \
0669         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0670 #endif /* src: long dst: uint64_t */
0671
0672 /* src: long, dst: ptrdiff_t */
0673 #if H5_SIZEOF_LONG < H5_SIZEOF_PTRDIFF_T
0674     #define ASSIGN_long_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0675         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0676 #elif H5_SIZEOF_LONG > H5_SIZEOF_PTRDIFF_T
0677     #define ASSIGN_long_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0678         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0679 #else /* H5_SIZEOF_LONG == H5_SIZEOF_PTRDIFF_T */
0680     #define ASSIGN_long_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0681         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0682 #endif /* src: long dst: ptrdiff_t */
0683
0684 /* src: long, dst: size_t */
0685 #if H5_SIZEOF_LONG < H5_SIZEOF_SIZE_T
0686     #define ASSIGN_long_TO_size_t(dst, dsttype, src, srctype) \
0687         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0688 #elif H5_SIZEOF_LONG > H5_SIZEOF_SIZE_T
0689     #define ASSIGN_long_TO_size_t(dst, dsttype, src, srctype) \
0690         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0691 #else /* H5_SIZEOF_LONG == H5_SIZEOF_SIZE_T */
0692     #define ASSIGN_long_TO_size_t(dst, dsttype, src, srctype) \
0693         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0694 #endif /* src: long dst: size_t */
0695
0696 /* src: long, dst: ssize_t */
0697 #if H5_SIZEOF_LONG < H5_SIZEOF_SSIZE_T
0698     #define ASSIGN_long_TO_ssize_t(dst, dsttype, src, srctype) \
0699         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0700 #elif H5_SIZEOF_LONG > H5_SIZEOF_SSIZE_T
0701     #define ASSIGN_long_TO_ssize_t(dst, dsttype, src, srctype) \
0702         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0703 #else /* H5_SIZEOF_LONG == H5_SIZEOF_SSIZE_T */
0704     #define ASSIGN_long_TO_ssize_t(dst, dsttype, src, srctype) \
0705         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0706 #endif /* src: long dst: ssize_t */
0707
0708 /* src: long, dst: haddr_t */
0709 #if H5_SIZEOF_LONG < H5_SIZEOF_HADDR_T
0710     #define ASSIGN_long_TO_haddr_t(dst, dsttype, src, srctype) \
0711         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0712 #elif H5_SIZEOF_LONG > H5_SIZEOF_HADDR_T
0713     #define ASSIGN_long_TO_haddr_t(dst, dsttype, src, srctype) \
0714         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0715 #else /* H5_SIZEOF_LONG == H5_SIZEOF_HADDR_T */
0716     #define ASSIGN_long_TO_haddr_t(dst, dsttype, src, srctype) \
0717         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0718 #endif /* src: long dst: haddr_t */
0719
0720 /* src: long, dst: hsize_t */
0721 #if H5_SIZEOF_LONG < H5_SIZEOF_HSIZE_T
0722     #define ASSIGN_long_TO_hsize_t(dst, dsttype, src, srctype) \
0723         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0724 #elif H5_SIZEOF_LONG > H5_SIZEOF_HSIZE_T
0725     #define ASSIGN_long_TO_hsize_t(dst, dsttype, src, srctype) \
0726         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0727 #else /* H5_SIZEOF_LONG == H5_SIZEOF_HSIZE_T */
0728     #define ASSIGN_long_TO_hsize_t(dst, dsttype, src, srctype) \
0729         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0730 #endif /* src: long dst: hsize_t */
0731
0732 /* src: long, dst: hssize_t */
0733 #if H5_SIZEOF_LONG < H5_SIZEOF_HSSIZE_T
0734     #define ASSIGN_long_TO_hssize_t(dst, dsttype, src, srctype) \
0735         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0736 #elif H5_SIZEOF_LONG > H5_SIZEOF_HSSIZE_T
0737     #define ASSIGN_long_TO_hssize_t(dst, dsttype, src, srctype) \
0738         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0739 #else /* H5_SIZEOF_LONG == H5_SIZEOF_HSSIZE_T */
0740     #define ASSIGN_long_TO_hssize_t(dst, dsttype, src, srctype) \
0741         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0742 #endif /* src: long dst: hssize_t */
0743
0744 /* src: long, dst: h5_stat_size_t */
0745 #if H5_SIZEOF_LONG < H5_SIZEOF_H5_STAT_SIZE_T
0746     #define ASSIGN_long_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0747         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0748 #elif H5_SIZEOF_LONG > H5_SIZEOF_H5_STAT_SIZE_T
0749     #define ASSIGN_long_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0750         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0751 #else /* H5_SIZEOF_LONG == H5_SIZEOF_H5_STAT_SIZE_T */
0752     #define ASSIGN_long_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0753         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0754 #endif /* src: long dst: h5_stat_size_t */
0755
0756
0757 /* Assignment checks for int64_t */
0758
0759 /* src: int64_t, dst: unsigned */
0760 #if H5_SIZEOF_INT64_T < H5_SIZEOF_UNSIGNED
0761     #define ASSIGN_int64_t_TO_unsigned(dst, dsttype, src, srctype) \
0762         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0763 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_UNSIGNED
0764     #define ASSIGN_int64_t_TO_unsigned(dst, dsttype, src, srctype) \
0765         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0766 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_UNSIGNED */
0767     #define ASSIGN_int64_t_TO_unsigned(dst, dsttype, src, srctype) \
0768         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0769 #endif /* src: int64_t dst: unsigned */
0770
0771 /* src: int64_t, dst: int8_t */
0772 #if H5_SIZEOF_INT64_T < H5_SIZEOF_INT8_T
0773     #define ASSIGN_int64_t_TO_int8_t(dst, dsttype, src, srctype) \
0774         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0775 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_INT8_T
0776     #define ASSIGN_int64_t_TO_int8_t(dst, dsttype, src, srctype) \
0777         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0778 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_INT8_T */
0779     #define ASSIGN_int64_t_TO_int8_t(dst, dsttype, src, srctype) \
0780         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0781 #endif /* src: int64_t dst: int8_t */
0782
0783 /* src: int64_t, dst: int */
0784 #if H5_SIZEOF_INT64_T < H5_SIZEOF_INT
0785     #define ASSIGN_int64_t_TO_int(dst, dsttype, src, srctype) \
0786         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0787 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_INT
0788     #define ASSIGN_int64_t_TO_int(dst, dsttype, src, srctype) \
0789         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0790 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_INT */
0791     #define ASSIGN_int64_t_TO_int(dst, dsttype, src, srctype) \
0792         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0793 #endif /* src: int64_t dst: int */
0794
0795 /* src: int64_t, dst: long */
0796 #if H5_SIZEOF_INT64_T < H5_SIZEOF_LONG
0797     #define ASSIGN_int64_t_TO_long(dst, dsttype, src, srctype) \
0798         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0799 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_LONG
0800     #define ASSIGN_int64_t_TO_long(dst, dsttype, src, srctype) \
0801         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0802 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_LONG */
0803     #define ASSIGN_int64_t_TO_long(dst, dsttype, src, srctype) \
0804         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0805 #endif /* src: int64_t dst: long */
0806
0807 /* src: int64_t, dst: uint8_t */
0808 #if H5_SIZEOF_INT64_T < H5_SIZEOF_UINT8_T
0809     #define ASSIGN_int64_t_TO_uint8_t(dst, dsttype, src, srctype) \
0810         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0811 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_UINT8_T
0812     #define ASSIGN_int64_t_TO_uint8_t(dst, dsttype, src, srctype) \
0813         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0814 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_UINT8_T */
0815     #define ASSIGN_int64_t_TO_uint8_t(dst, dsttype, src, srctype) \
0816         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0817 #endif /* src: int64_t dst: uint8_t */
0818
0819 /* src: int64_t, dst: uint16_t */
0820 #if H5_SIZEOF_INT64_T < H5_SIZEOF_UINT16_T
0821     #define ASSIGN_int64_t_TO_uint16_t(dst, dsttype, src, srctype) \
0822         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0823 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_UINT16_T
0824     #define ASSIGN_int64_t_TO_uint16_t(dst, dsttype, src, srctype) \
0825         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0826 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_UINT16_T */
0827     #define ASSIGN_int64_t_TO_uint16_t(dst, dsttype, src, srctype) \
0828         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0829 #endif /* src: int64_t dst: uint16_t */
0830
0831 /* src: int64_t, dst: uint32_t */
0832 #if H5_SIZEOF_INT64_T < H5_SIZEOF_UINT32_T
0833     #define ASSIGN_int64_t_TO_uint32_t(dst, dsttype, src, srctype) \
0834         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0835 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_UINT32_T
0836     #define ASSIGN_int64_t_TO_uint32_t(dst, dsttype, src, srctype) \
0837         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0838 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_UINT32_T */
0839     #define ASSIGN_int64_t_TO_uint32_t(dst, dsttype, src, srctype) \
0840         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0841 #endif /* src: int64_t dst: uint32_t */
0842
0843 /* src: int64_t, dst: uint64_t */
0844 #if H5_SIZEOF_INT64_T < H5_SIZEOF_UINT64_T
0845     #define ASSIGN_int64_t_TO_uint64_t(dst, dsttype, src, srctype) \
0846         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0847 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_UINT64_T
0848     #define ASSIGN_int64_t_TO_uint64_t(dst, dsttype, src, srctype) \
0849         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0850 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_UINT64_T */
0851     #define ASSIGN_int64_t_TO_uint64_t(dst, dsttype, src, srctype) \
0852         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0853 #endif /* src: int64_t dst: uint64_t */
0854
0855 /* src: int64_t, dst: ptrdiff_t */
0856 #if H5_SIZEOF_INT64_T < H5_SIZEOF_PTRDIFF_T
0857     #define ASSIGN_int64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0858         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0859 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_PTRDIFF_T
0860     #define ASSIGN_int64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0861         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0862 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_PTRDIFF_T */
0863     #define ASSIGN_int64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
0864         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0865 #endif /* src: int64_t dst: ptrdiff_t */
0866
0867 /* src: int64_t, dst: size_t */
0868 #if H5_SIZEOF_INT64_T < H5_SIZEOF_SIZE_T
0869     #define ASSIGN_int64_t_TO_size_t(dst, dsttype, src, srctype) \
0870         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0871 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_SIZE_T
0872     #define ASSIGN_int64_t_TO_size_t(dst, dsttype, src, srctype) \
0873         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0874 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_SIZE_T */
0875     #define ASSIGN_int64_t_TO_size_t(dst, dsttype, src, srctype) \
0876         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0877 #endif /* src: int64_t dst: size_t */
0878
0879 /* src: int64_t, dst: ssize_t */
0880 #if H5_SIZEOF_INT64_T < H5_SIZEOF_SSIZE_T
0881     #define ASSIGN_int64_t_TO_ssize_t(dst, dsttype, src, srctype) \
0882         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0883 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_SSIZE_T
0884     #define ASSIGN_int64_t_TO_ssize_t(dst, dsttype, src, srctype) \
0885         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0886 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_SSIZE_T */
0887     #define ASSIGN_int64_t_TO_ssize_t(dst, dsttype, src, srctype) \
0888         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0889 #endif /* src: int64_t dst: ssize_t */
0890
0891 /* src: int64_t, dst: haddr_t */
0892 #if H5_SIZEOF_INT64_T < H5_SIZEOF_HADDR_T
0893     #define ASSIGN_int64_t_TO_haddr_t(dst, dsttype, src, srctype) \
0894         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0895 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_HADDR_T
0896     #define ASSIGN_int64_t_TO_haddr_t(dst, dsttype, src, srctype) \
0897         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0898 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_HADDR_T */
0899     #define ASSIGN_int64_t_TO_haddr_t(dst, dsttype, src, srctype) \
0900         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0901 #endif /* src: int64_t dst: haddr_t */
0902
0903 /* src: int64_t, dst: hsize_t */
0904 #if H5_SIZEOF_INT64_T < H5_SIZEOF_HSIZE_T
0905     #define ASSIGN_int64_t_TO_hsize_t(dst, dsttype, src, srctype) \
0906         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0907 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_HSIZE_T
0908     #define ASSIGN_int64_t_TO_hsize_t(dst, dsttype, src, srctype) \
0909         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0910 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_HSIZE_T */
0911     #define ASSIGN_int64_t_TO_hsize_t(dst, dsttype, src, srctype) \
0912         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0913 #endif /* src: int64_t dst: hsize_t */
0914
0915 /* src: int64_t, dst: hssize_t */
0916 #if H5_SIZEOF_INT64_T < H5_SIZEOF_HSSIZE_T
0917     #define ASSIGN_int64_t_TO_hssize_t(dst, dsttype, src, srctype) \
0918         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0919 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_HSSIZE_T
0920     #define ASSIGN_int64_t_TO_hssize_t(dst, dsttype, src, srctype) \
0921         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0922 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_HSSIZE_T */
0923     #define ASSIGN_int64_t_TO_hssize_t(dst, dsttype, src, srctype) \
0924         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0925 #endif /* src: int64_t dst: hssize_t */
0926
0927 /* src: int64_t, dst: h5_stat_size_t */
0928 #if H5_SIZEOF_INT64_T < H5_SIZEOF_H5_STAT_SIZE_T
0929     #define ASSIGN_int64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0930         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0931 #elif H5_SIZEOF_INT64_T > H5_SIZEOF_H5_STAT_SIZE_T
0932     #define ASSIGN_int64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0933         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0934 #else /* H5_SIZEOF_INT64_T == H5_SIZEOF_H5_STAT_SIZE_T */
0935     #define ASSIGN_int64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
0936         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
0937 #endif /* src: int64_t dst: h5_stat_size_t */
0938
0939
0940 /* Assignment checks for uint8_t */
0941
0942 /* src: uint8_t, dst: unsigned */
0943 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UNSIGNED
0944     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
0945         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0946 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UNSIGNED
0947     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
0948         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0949 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UNSIGNED */
0950     #define ASSIGN_uint8_t_TO_unsigned(dst, dsttype, src, srctype) \
0951         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
0952 #endif /* src: uint8_t dst: unsigned */
0953
0954 /* src: uint8_t, dst: int8_t */
0955 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_INT8_T
0956     #define ASSIGN_uint8_t_TO_int8_t(dst, dsttype, src, srctype) \
0957         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0958 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_INT8_T
0959     #define ASSIGN_uint8_t_TO_int8_t(dst, dsttype, src, srctype) \
0960         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0961 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_INT8_T */
0962     #define ASSIGN_uint8_t_TO_int8_t(dst, dsttype, src, srctype) \
0963         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0964 #endif /* src: uint8_t dst: int8_t */
0965
0966 /* src: uint8_t, dst: int */
0967 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_INT
0968     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
0969         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0970 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_INT
0971     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
0972         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0973 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_INT */
0974     #define ASSIGN_uint8_t_TO_int(dst, dsttype, src, srctype) \
0975         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0976 #endif /* src: uint8_t dst: int */
0977
0978 /* src: uint8_t, dst: long */
0979 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_LONG
0980     #define ASSIGN_uint8_t_TO_long(dst, dsttype, src, srctype) \
0981         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0982 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_LONG
0983     #define ASSIGN_uint8_t_TO_long(dst, dsttype, src, srctype) \
0984         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0985 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_LONG */
0986     #define ASSIGN_uint8_t_TO_long(dst, dsttype, src, srctype) \
0987         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0988 #endif /* src: uint8_t dst: long */
0989
0990 /* src: uint8_t, dst: int64_t */
0991 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_INT64_T
0992     #define ASSIGN_uint8_t_TO_int64_t(dst, dsttype, src, srctype) \
0993         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
0994 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_INT64_T
0995     #define ASSIGN_uint8_t_TO_int64_t(dst, dsttype, src, srctype) \
0996         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
0997 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_INT64_T */
0998     #define ASSIGN_uint8_t_TO_int64_t(dst, dsttype, src, srctype) \
0999         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1000 #endif /* src: uint8_t dst: int64_t */
1001
1002 /* src: uint8_t, dst: uint16_t */
1003 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT16_T
1004     #define ASSIGN_uint8_t_TO_uint16_t(dst, dsttype, src, srctype) \
1005         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1006 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT16_T
1007     #define ASSIGN_uint8_t_TO_uint16_t(dst, dsttype, src, srctype) \
1008         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1009 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT16_T */
1010     #define ASSIGN_uint8_t_TO_uint16_t(dst, dsttype, src, srctype) \
1011         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1012 #endif /* src: uint8_t dst: uint16_t */
1013
1014 /* src: uint8_t, dst: uint32_t */
1015 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT32_T
1016     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
1017         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1018 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT32_T
1019     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
1020         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1021 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT32_T */
1022     #define ASSIGN_uint8_t_TO_uint32_t(dst, dsttype, src, srctype) \
1023         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1024 #endif /* src: uint8_t dst: uint32_t */
1025
1026 /* src: uint8_t, dst: uint64_t */
1027 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_UINT64_T
1028     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
1029         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1030 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_UINT64_T
1031     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
1032         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1033 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_UINT64_T */
1034     #define ASSIGN_uint8_t_TO_uint64_t(dst, dsttype, src, srctype) \
1035         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1036 #endif /* src: uint8_t dst: uint64_t */
1037
1038 /* src: uint8_t, dst: ptrdiff_t */
1039 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_PTRDIFF_T
1040     #define ASSIGN_uint8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1041         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1042 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_PTRDIFF_T
1043     #define ASSIGN_uint8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1044         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1045 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_PTRDIFF_T */
1046     #define ASSIGN_uint8_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1047         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1048 #endif /* src: uint8_t dst: ptrdiff_t */
1049
1050 /* src: uint8_t, dst: size_t */
1051 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_SIZE_T
1052     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
1053         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1054 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_SIZE_T
1055     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
1056         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1057 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_SIZE_T */
1058     #define ASSIGN_uint8_t_TO_size_t(dst, dsttype, src, srctype) \
1059         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1060 #endif /* src: uint8_t dst: size_t */
1061
1062 /* src: uint8_t, dst: ssize_t */
1063 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_SSIZE_T
1064     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
1065         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1066 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_SSIZE_T
1067     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
1068         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1069 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_SSIZE_T */
1070     #define ASSIGN_uint8_t_TO_ssize_t(dst, dsttype, src, srctype) \
1071         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1072 #endif /* src: uint8_t dst: ssize_t */
1073
1074 /* src: uint8_t, dst: haddr_t */
1075 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HADDR_T
1076     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
1077         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1078 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HADDR_T
1079     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
1080         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1081 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HADDR_T */
1082     #define ASSIGN_uint8_t_TO_haddr_t(dst, dsttype, src, srctype) \
1083         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1084 #endif /* src: uint8_t dst: haddr_t */
1085
1086 /* src: uint8_t, dst: hsize_t */
1087 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HSIZE_T
1088     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
1089         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1090 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HSIZE_T
1091     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
1092         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1093 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HSIZE_T */
1094     #define ASSIGN_uint8_t_TO_hsize_t(dst, dsttype, src, srctype) \
1095         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1096 #endif /* src: uint8_t dst: hsize_t */
1097
1098 /* src: uint8_t, dst: hssize_t */
1099 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_HSSIZE_T
1100     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
1101         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1102 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_HSSIZE_T
1103     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
1104         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1105 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_HSSIZE_T */
1106     #define ASSIGN_uint8_t_TO_hssize_t(dst, dsttype, src, srctype) \
1107         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1108 #endif /* src: uint8_t dst: hssize_t */
1109
1110 /* src: uint8_t, dst: h5_stat_size_t */
1111 #if H5_SIZEOF_UINT8_T < H5_SIZEOF_H5_STAT_SIZE_T
1112     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1113         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1114 #elif H5_SIZEOF_UINT8_T > H5_SIZEOF_H5_STAT_SIZE_T
1115     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1116         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1117 #else /* H5_SIZEOF_UINT8_T == H5_SIZEOF_H5_STAT_SIZE_T */
1118     #define ASSIGN_uint8_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1119         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1120 #endif /* src: uint8_t dst: h5_stat_size_t */
1121
1122
1123 /* Assignment checks for uint16_t */
1124
1125 /* src: uint16_t, dst: unsigned */
1126 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UNSIGNED
1127     #define ASSIGN_uint16_t_TO_unsigned(dst, dsttype, src, srctype) \
1128         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1129 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UNSIGNED
1130     #define ASSIGN_uint16_t_TO_unsigned(dst, dsttype, src, srctype) \
1131         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1132 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UNSIGNED */
1133     #define ASSIGN_uint16_t_TO_unsigned(dst, dsttype, src, srctype) \
1134         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1135 #endif /* src: uint16_t dst: unsigned */
1136
1137 /* src: uint16_t, dst: int8_t */
1138 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_INT8_T
1139     #define ASSIGN_uint16_t_TO_int8_t(dst, dsttype, src, srctype) \
1140         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1141 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_INT8_T
1142     #define ASSIGN_uint16_t_TO_int8_t(dst, dsttype, src, srctype) \
1143         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1144 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_INT8_T */
1145     #define ASSIGN_uint16_t_TO_int8_t(dst, dsttype, src, srctype) \
1146         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1147 #endif /* src: uint16_t dst: int8_t */
1148
1149 /* src: uint16_t, dst: int */
1150 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_INT
1151     #define ASSIGN_uint16_t_TO_int(dst, dsttype, src, srctype) \
1152         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1153 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_INT
1154     #define ASSIGN_uint16_t_TO_int(dst, dsttype, src, srctype) \
1155         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1156 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_INT */
1157     #define ASSIGN_uint16_t_TO_int(dst, dsttype, src, srctype) \
1158         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1159 #endif /* src: uint16_t dst: int */
1160
1161 /* src: uint16_t, dst: long */
1162 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_LONG
1163     #define ASSIGN_uint16_t_TO_long(dst, dsttype, src, srctype) \
1164         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1165 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_LONG
1166     #define ASSIGN_uint16_t_TO_long(dst, dsttype, src, srctype) \
1167         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1168 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_LONG */
1169     #define ASSIGN_uint16_t_TO_long(dst, dsttype, src, srctype) \
1170         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1171 #endif /* src: uint16_t dst: long */
1172
1173 /* src: uint16_t, dst: int64_t */
1174 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_INT64_T
1175     #define ASSIGN_uint16_t_TO_int64_t(dst, dsttype, src, srctype) \
1176         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1177 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_INT64_T
1178     #define ASSIGN_uint16_t_TO_int64_t(dst, dsttype, src, srctype) \
1179         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1180 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_INT64_T */
1181     #define ASSIGN_uint16_t_TO_int64_t(dst, dsttype, src, srctype) \
1182         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1183 #endif /* src: uint16_t dst: int64_t */
1184
1185 /* src: uint16_t, dst: uint8_t */
1186 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UINT8_T
1187     #define ASSIGN_uint16_t_TO_uint8_t(dst, dsttype, src, srctype) \
1188         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1189 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UINT8_T
1190     #define ASSIGN_uint16_t_TO_uint8_t(dst, dsttype, src, srctype) \
1191         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1192 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UINT8_T */
1193     #define ASSIGN_uint16_t_TO_uint8_t(dst, dsttype, src, srctype) \
1194         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1195 #endif /* src: uint16_t dst: uint8_t */
1196
1197 /* src: uint16_t, dst: uint32_t */
1198 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UINT32_T
1199     #define ASSIGN_uint16_t_TO_uint32_t(dst, dsttype, src, srctype) \
1200         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1201 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UINT32_T
1202     #define ASSIGN_uint16_t_TO_uint32_t(dst, dsttype, src, srctype) \
1203         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1204 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UINT32_T */
1205     #define ASSIGN_uint16_t_TO_uint32_t(dst, dsttype, src, srctype) \
1206         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1207 #endif /* src: uint16_t dst: uint32_t */
1208
1209 /* src: uint16_t, dst: uint64_t */
1210 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_UINT64_T
1211     #define ASSIGN_uint16_t_TO_uint64_t(dst, dsttype, src, srctype) \
1212         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1213 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_UINT64_T
1214     #define ASSIGN_uint16_t_TO_uint64_t(dst, dsttype, src, srctype) \
1215         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1216 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_UINT64_T */
1217     #define ASSIGN_uint16_t_TO_uint64_t(dst, dsttype, src, srctype) \
1218         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1219 #endif /* src: uint16_t dst: uint64_t */
1220
1221 /* src: uint16_t, dst: ptrdiff_t */
1222 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_PTRDIFF_T
1223     #define ASSIGN_uint16_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1224         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1225 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_PTRDIFF_T
1226     #define ASSIGN_uint16_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1227         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1228 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_PTRDIFF_T */
1229     #define ASSIGN_uint16_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1230         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1231 #endif /* src: uint16_t dst: ptrdiff_t */
1232
1233 /* src: uint16_t, dst: size_t */
1234 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_SIZE_T
1235     #define ASSIGN_uint16_t_TO_size_t(dst, dsttype, src, srctype) \
1236         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1237 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_SIZE_T
1238     #define ASSIGN_uint16_t_TO_size_t(dst, dsttype, src, srctype) \
1239         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1240 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_SIZE_T */
1241     #define ASSIGN_uint16_t_TO_size_t(dst, dsttype, src, srctype) \
1242         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1243 #endif /* src: uint16_t dst: size_t */
1244
1245 /* src: uint16_t, dst: ssize_t */
1246 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_SSIZE_T
1247     #define ASSIGN_uint16_t_TO_ssize_t(dst, dsttype, src, srctype) \
1248         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1249 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_SSIZE_T
1250     #define ASSIGN_uint16_t_TO_ssize_t(dst, dsttype, src, srctype) \
1251         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1252 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_SSIZE_T */
1253     #define ASSIGN_uint16_t_TO_ssize_t(dst, dsttype, src, srctype) \
1254         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1255 #endif /* src: uint16_t dst: ssize_t */
1256
1257 /* src: uint16_t, dst: haddr_t */
1258 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_HADDR_T
1259     #define ASSIGN_uint16_t_TO_haddr_t(dst, dsttype, src, srctype) \
1260         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1261 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_HADDR_T
1262     #define ASSIGN_uint16_t_TO_haddr_t(dst, dsttype, src, srctype) \
1263         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1264 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_HADDR_T */
1265     #define ASSIGN_uint16_t_TO_haddr_t(dst, dsttype, src, srctype) \
1266         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1267 #endif /* src: uint16_t dst: haddr_t */
1268
1269 /* src: uint16_t, dst: hsize_t */
1270 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_HSIZE_T
1271     #define ASSIGN_uint16_t_TO_hsize_t(dst, dsttype, src, srctype) \
1272         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1273 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_HSIZE_T
1274     #define ASSIGN_uint16_t_TO_hsize_t(dst, dsttype, src, srctype) \
1275         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1276 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_HSIZE_T */
1277     #define ASSIGN_uint16_t_TO_hsize_t(dst, dsttype, src, srctype) \
1278         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1279 #endif /* src: uint16_t dst: hsize_t */
1280
1281 /* src: uint16_t, dst: hssize_t */
1282 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_HSSIZE_T
1283     #define ASSIGN_uint16_t_TO_hssize_t(dst, dsttype, src, srctype) \
1284         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1285 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_HSSIZE_T
1286     #define ASSIGN_uint16_t_TO_hssize_t(dst, dsttype, src, srctype) \
1287         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1288 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_HSSIZE_T */
1289     #define ASSIGN_uint16_t_TO_hssize_t(dst, dsttype, src, srctype) \
1290         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1291 #endif /* src: uint16_t dst: hssize_t */
1292
1293 /* src: uint16_t, dst: h5_stat_size_t */
1294 #if H5_SIZEOF_UINT16_T < H5_SIZEOF_H5_STAT_SIZE_T
1295     #define ASSIGN_uint16_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1296         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1297 #elif H5_SIZEOF_UINT16_T > H5_SIZEOF_H5_STAT_SIZE_T
1298     #define ASSIGN_uint16_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1299         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1300 #else /* H5_SIZEOF_UINT16_T == H5_SIZEOF_H5_STAT_SIZE_T */
1301     #define ASSIGN_uint16_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1302         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1303 #endif /* src: uint16_t dst: h5_stat_size_t */
1304
1305
1306 /* Assignment checks for uint32_t */
1307
1308 /* src: uint32_t, dst: unsigned */
1309 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UNSIGNED
1310     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
1311         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1312 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UNSIGNED
1313     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
1314         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1315 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UNSIGNED */
1316     #define ASSIGN_uint32_t_TO_unsigned(dst, dsttype, src, srctype) \
1317         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1318 #endif /* src: uint32_t dst: unsigned */
1319
1320 /* src: uint32_t, dst: int8_t */
1321 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_INT8_T
1322     #define ASSIGN_uint32_t_TO_int8_t(dst, dsttype, src, srctype) \
1323         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1324 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_INT8_T
1325     #define ASSIGN_uint32_t_TO_int8_t(dst, dsttype, src, srctype) \
1326         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1327 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_INT8_T */
1328     #define ASSIGN_uint32_t_TO_int8_t(dst, dsttype, src, srctype) \
1329         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1330 #endif /* src: uint32_t dst: int8_t */
1331
1332 /* src: uint32_t, dst: int */
1333 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_INT
1334     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
1335         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1336 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_INT
1337     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
1338         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1339 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_INT */
1340     #define ASSIGN_uint32_t_TO_int(dst, dsttype, src, srctype) \
1341         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1342 #endif /* src: uint32_t dst: int */
1343
1344 /* src: uint32_t, dst: long */
1345 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_LONG
1346     #define ASSIGN_uint32_t_TO_long(dst, dsttype, src, srctype) \
1347         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1348 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_LONG
1349     #define ASSIGN_uint32_t_TO_long(dst, dsttype, src, srctype) \
1350         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1351 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_LONG */
1352     #define ASSIGN_uint32_t_TO_long(dst, dsttype, src, srctype) \
1353         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1354 #endif /* src: uint32_t dst: long */
1355
1356 /* src: uint32_t, dst: int64_t */
1357 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_INT64_T
1358     #define ASSIGN_uint32_t_TO_int64_t(dst, dsttype, src, srctype) \
1359         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1360 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_INT64_T
1361     #define ASSIGN_uint32_t_TO_int64_t(dst, dsttype, src, srctype) \
1362         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1363 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_INT64_T */
1364     #define ASSIGN_uint32_t_TO_int64_t(dst, dsttype, src, srctype) \
1365         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1366 #endif /* src: uint32_t dst: int64_t */
1367
1368 /* src: uint32_t, dst: uint8_t */
1369 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT8_T
1370     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
1371         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1372 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT8_T
1373     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
1374         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1375 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT8_T */
1376     #define ASSIGN_uint32_t_TO_uint8_t(dst, dsttype, src, srctype) \
1377         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1378 #endif /* src: uint32_t dst: uint8_t */
1379
1380 /* src: uint32_t, dst: uint16_t */
1381 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT16_T
1382     #define ASSIGN_uint32_t_TO_uint16_t(dst, dsttype, src, srctype) \
1383         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1384 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT16_T
1385     #define ASSIGN_uint32_t_TO_uint16_t(dst, dsttype, src, srctype) \
1386         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1387 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT16_T */
1388     #define ASSIGN_uint32_t_TO_uint16_t(dst, dsttype, src, srctype) \
1389         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1390 #endif /* src: uint32_t dst: uint16_t */
1391
1392 /* src: uint32_t, dst: uint64_t */
1393 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_UINT64_T
1394     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
1395         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1396 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_UINT64_T
1397     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
1398         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1399 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_UINT64_T */
1400     #define ASSIGN_uint32_t_TO_uint64_t(dst, dsttype, src, srctype) \
1401         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1402 #endif /* src: uint32_t dst: uint64_t */
1403
1404 /* src: uint32_t, dst: ptrdiff_t */
1405 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_PTRDIFF_T
1406     #define ASSIGN_uint32_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1407         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1408 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_PTRDIFF_T
1409     #define ASSIGN_uint32_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1410         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1411 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_PTRDIFF_T */
1412     #define ASSIGN_uint32_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1413         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1414 #endif /* src: uint32_t dst: ptrdiff_t */
1415
1416 /* src: uint32_t, dst: size_t */
1417 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_SIZE_T
1418     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
1419         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1420 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_SIZE_T
1421     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
1422         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1423 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_SIZE_T */
1424     #define ASSIGN_uint32_t_TO_size_t(dst, dsttype, src, srctype) \
1425         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1426 #endif /* src: uint32_t dst: size_t */
1427
1428 /* src: uint32_t, dst: ssize_t */
1429 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_SSIZE_T
1430     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
1431         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1432 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_SSIZE_T
1433     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
1434         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1435 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_SSIZE_T */
1436     #define ASSIGN_uint32_t_TO_ssize_t(dst, dsttype, src, srctype) \
1437         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1438 #endif /* src: uint32_t dst: ssize_t */
1439
1440 /* src: uint32_t, dst: haddr_t */
1441 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HADDR_T
1442     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
1443         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1444 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HADDR_T
1445     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
1446         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1447 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HADDR_T */
1448     #define ASSIGN_uint32_t_TO_haddr_t(dst, dsttype, src, srctype) \
1449         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1450 #endif /* src: uint32_t dst: haddr_t */
1451
1452 /* src: uint32_t, dst: hsize_t */
1453 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HSIZE_T
1454     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
1455         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1456 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HSIZE_T
1457     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
1458         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1459 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HSIZE_T */
1460     #define ASSIGN_uint32_t_TO_hsize_t(dst, dsttype, src, srctype) \
1461         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1462 #endif /* src: uint32_t dst: hsize_t */
1463
1464 /* src: uint32_t, dst: hssize_t */
1465 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_HSSIZE_T
1466     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
1467         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1468 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_HSSIZE_T
1469     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
1470         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1471 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_HSSIZE_T */
1472     #define ASSIGN_uint32_t_TO_hssize_t(dst, dsttype, src, srctype) \
1473         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1474 #endif /* src: uint32_t dst: hssize_t */
1475
1476 /* src: uint32_t, dst: h5_stat_size_t */
1477 #if H5_SIZEOF_UINT32_T < H5_SIZEOF_H5_STAT_SIZE_T
1478     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1479         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1480 #elif H5_SIZEOF_UINT32_T > H5_SIZEOF_H5_STAT_SIZE_T
1481     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1482         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1483 #else /* H5_SIZEOF_UINT32_T == H5_SIZEOF_H5_STAT_SIZE_T */
1484     #define ASSIGN_uint32_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1485         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1486 #endif /* src: uint32_t dst: h5_stat_size_t */
1487
1488
1489 /* Assignment checks for uint64_t */
1490
1491 /* src: uint64_t, dst: unsigned */
1492 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UNSIGNED
1493     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
1494         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1495 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UNSIGNED
1496     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
1497         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1498 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UNSIGNED */
1499     #define ASSIGN_uint64_t_TO_unsigned(dst, dsttype, src, srctype) \
1500         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1501 #endif /* src: uint64_t dst: unsigned */
1502
1503 /* src: uint64_t, dst: int8_t */
1504 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_INT8_T
1505     #define ASSIGN_uint64_t_TO_int8_t(dst, dsttype, src, srctype) \
1506         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1507 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_INT8_T
1508     #define ASSIGN_uint64_t_TO_int8_t(dst, dsttype, src, srctype) \
1509         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1510 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_INT8_T */
1511     #define ASSIGN_uint64_t_TO_int8_t(dst, dsttype, src, srctype) \
1512         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1513 #endif /* src: uint64_t dst: int8_t */
1514
1515 /* src: uint64_t, dst: int */
1516 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_INT
1517     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
1518         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1519 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_INT
1520     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
1521         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1522 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_INT */
1523     #define ASSIGN_uint64_t_TO_int(dst, dsttype, src, srctype) \
1524         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1525 #endif /* src: uint64_t dst: int */
1526
1527 /* src: uint64_t, dst: long */
1528 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_LONG
1529     #define ASSIGN_uint64_t_TO_long(dst, dsttype, src, srctype) \
1530         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1531 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_LONG
1532     #define ASSIGN_uint64_t_TO_long(dst, dsttype, src, srctype) \
1533         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1534 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_LONG */
1535     #define ASSIGN_uint64_t_TO_long(dst, dsttype, src, srctype) \
1536         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1537 #endif /* src: uint64_t dst: long */
1538
1539 /* src: uint64_t, dst: int64_t */
1540 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_INT64_T
1541     #define ASSIGN_uint64_t_TO_int64_t(dst, dsttype, src, srctype) \
1542         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1543 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_INT64_T
1544     #define ASSIGN_uint64_t_TO_int64_t(dst, dsttype, src, srctype) \
1545         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1546 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_INT64_T */
1547     #define ASSIGN_uint64_t_TO_int64_t(dst, dsttype, src, srctype) \
1548         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1549 #endif /* src: uint64_t dst: int64_t */
1550
1551 /* src: uint64_t, dst: uint8_t */
1552 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT8_T
1553     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
1554         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1555 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT8_T
1556     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
1557         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1558 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT8_T */
1559     #define ASSIGN_uint64_t_TO_uint8_t(dst, dsttype, src, srctype) \
1560         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1561 #endif /* src: uint64_t dst: uint8_t */
1562
1563 /* src: uint64_t, dst: uint16_t */
1564 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT16_T
1565     #define ASSIGN_uint64_t_TO_uint16_t(dst, dsttype, src, srctype) \
1566         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1567 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT16_T
1568     #define ASSIGN_uint64_t_TO_uint16_t(dst, dsttype, src, srctype) \
1569         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1570 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT16_T */
1571     #define ASSIGN_uint64_t_TO_uint16_t(dst, dsttype, src, srctype) \
1572         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1573 #endif /* src: uint64_t dst: uint16_t */
1574
1575 /* src: uint64_t, dst: uint32_t */
1576 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_UINT32_T
1577     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
1578         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1579 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_UINT32_T
1580     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
1581         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1582 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_UINT32_T */
1583     #define ASSIGN_uint64_t_TO_uint32_t(dst, dsttype, src, srctype) \
1584         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1585 #endif /* src: uint64_t dst: uint32_t */
1586
1587 /* src: uint64_t, dst: ptrdiff_t */
1588 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_PTRDIFF_T
1589     #define ASSIGN_uint64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1590         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1591 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_PTRDIFF_T
1592     #define ASSIGN_uint64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1593         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1594 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_PTRDIFF_T */
1595     #define ASSIGN_uint64_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1596         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1597 #endif /* src: uint64_t dst: ptrdiff_t */
1598
1599 /* src: uint64_t, dst: size_t */
1600 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_SIZE_T
1601     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
1602         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1603 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_SIZE_T
1604     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
1605         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1606 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_SIZE_T */
1607     #define ASSIGN_uint64_t_TO_size_t(dst, dsttype, src, srctype) \
1608         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1609 #endif /* src: uint64_t dst: size_t */
1610
1611 /* src: uint64_t, dst: ssize_t */
1612 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_SSIZE_T
1613     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
1614         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1615 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_SSIZE_T
1616     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
1617         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1618 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_SSIZE_T */
1619     #define ASSIGN_uint64_t_TO_ssize_t(dst, dsttype, src, srctype) \
1620         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1621 #endif /* src: uint64_t dst: ssize_t */
1622
1623 /* src: uint64_t, dst: haddr_t */
1624 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HADDR_T
1625     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
1626         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1627 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HADDR_T
1628     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
1629         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1630 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HADDR_T */
1631     #define ASSIGN_uint64_t_TO_haddr_t(dst, dsttype, src, srctype) \
1632         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1633 #endif /* src: uint64_t dst: haddr_t */
1634
1635 /* src: uint64_t, dst: hsize_t */
1636 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HSIZE_T
1637     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
1638         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1639 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HSIZE_T
1640     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
1641         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1642 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HSIZE_T */
1643     #define ASSIGN_uint64_t_TO_hsize_t(dst, dsttype, src, srctype) \
1644         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1645 #endif /* src: uint64_t dst: hsize_t */
1646
1647 /* src: uint64_t, dst: hssize_t */
1648 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_HSSIZE_T
1649     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
1650         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1651 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_HSSIZE_T
1652     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
1653         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1654 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_HSSIZE_T */
1655     #define ASSIGN_uint64_t_TO_hssize_t(dst, dsttype, src, srctype) \
1656         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1657 #endif /* src: uint64_t dst: hssize_t */
1658
1659 /* src: uint64_t, dst: h5_stat_size_t */
1660 #if H5_SIZEOF_UINT64_T < H5_SIZEOF_H5_STAT_SIZE_T
1661     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1662         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1663 #elif H5_SIZEOF_UINT64_T > H5_SIZEOF_H5_STAT_SIZE_T
1664     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1665         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1666 #else /* H5_SIZEOF_UINT64_T == H5_SIZEOF_H5_STAT_SIZE_T */
1667     #define ASSIGN_uint64_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1668         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1669 #endif /* src: uint64_t dst: h5_stat_size_t */
1670
1671
1672 /* Assignment checks for ptrdiff_t */
1673
1674 /* src: ptrdiff_t, dst: unsigned */
1675 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UNSIGNED
1676     #define ASSIGN_ptrdiff_t_TO_unsigned(dst, dsttype, src, srctype) \
1677         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1678 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UNSIGNED
1679     #define ASSIGN_ptrdiff_t_TO_unsigned(dst, dsttype, src, srctype) \
1680         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1681 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UNSIGNED */
1682     #define ASSIGN_ptrdiff_t_TO_unsigned(dst, dsttype, src, srctype) \
1683         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1684 #endif /* src: ptrdiff_t dst: unsigned */
1685
1686 /* src: ptrdiff_t, dst: int8_t */
1687 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_INT8_T
1688     #define ASSIGN_ptrdiff_t_TO_int8_t(dst, dsttype, src, srctype) \
1689         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1690 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_INT8_T
1691     #define ASSIGN_ptrdiff_t_TO_int8_t(dst, dsttype, src, srctype) \
1692         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1693 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_INT8_T */
1694     #define ASSIGN_ptrdiff_t_TO_int8_t(dst, dsttype, src, srctype) \
1695         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1696 #endif /* src: ptrdiff_t dst: int8_t */
1697
1698 /* src: ptrdiff_t, dst: int */
1699 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_INT
1700     #define ASSIGN_ptrdiff_t_TO_int(dst, dsttype, src, srctype) \
1701         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1702 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_INT
1703     #define ASSIGN_ptrdiff_t_TO_int(dst, dsttype, src, srctype) \
1704         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1705 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_INT */
1706     #define ASSIGN_ptrdiff_t_TO_int(dst, dsttype, src, srctype) \
1707         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1708 #endif /* src: ptrdiff_t dst: int */
1709
1710 /* src: ptrdiff_t, dst: long */
1711 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_LONG
1712     #define ASSIGN_ptrdiff_t_TO_long(dst, dsttype, src, srctype) \
1713         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1714 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_LONG
1715     #define ASSIGN_ptrdiff_t_TO_long(dst, dsttype, src, srctype) \
1716         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1717 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_LONG */
1718     #define ASSIGN_ptrdiff_t_TO_long(dst, dsttype, src, srctype) \
1719         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1720 #endif /* src: ptrdiff_t dst: long */
1721
1722 /* src: ptrdiff_t, dst: int64_t */
1723 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_INT64_T
1724     #define ASSIGN_ptrdiff_t_TO_int64_t(dst, dsttype, src, srctype) \
1725         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1726 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_INT64_T
1727     #define ASSIGN_ptrdiff_t_TO_int64_t(dst, dsttype, src, srctype) \
1728         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1729 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_INT64_T */
1730     #define ASSIGN_ptrdiff_t_TO_int64_t(dst, dsttype, src, srctype) \
1731         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1732 #endif /* src: ptrdiff_t dst: int64_t */
1733
1734 /* src: ptrdiff_t, dst: uint8_t */
1735 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT8_T
1736     #define ASSIGN_ptrdiff_t_TO_uint8_t(dst, dsttype, src, srctype) \
1737         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1738 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT8_T
1739     #define ASSIGN_ptrdiff_t_TO_uint8_t(dst, dsttype, src, srctype) \
1740         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1741 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT8_T */
1742     #define ASSIGN_ptrdiff_t_TO_uint8_t(dst, dsttype, src, srctype) \
1743         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1744 #endif /* src: ptrdiff_t dst: uint8_t */
1745
1746 /* src: ptrdiff_t, dst: uint16_t */
1747 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT16_T
1748     #define ASSIGN_ptrdiff_t_TO_uint16_t(dst, dsttype, src, srctype) \
1749         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1750 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT16_T
1751     #define ASSIGN_ptrdiff_t_TO_uint16_t(dst, dsttype, src, srctype) \
1752         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1753 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT16_T */
1754     #define ASSIGN_ptrdiff_t_TO_uint16_t(dst, dsttype, src, srctype) \
1755         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1756 #endif /* src: ptrdiff_t dst: uint16_t */
1757
1758 /* src: ptrdiff_t, dst: uint32_t */
1759 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT32_T
1760     #define ASSIGN_ptrdiff_t_TO_uint32_t(dst, dsttype, src, srctype) \
1761         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1762 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT32_T
1763     #define ASSIGN_ptrdiff_t_TO_uint32_t(dst, dsttype, src, srctype) \
1764         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1765 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT32_T */
1766     #define ASSIGN_ptrdiff_t_TO_uint32_t(dst, dsttype, src, srctype) \
1767         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1768 #endif /* src: ptrdiff_t dst: uint32_t */
1769
1770 /* src: ptrdiff_t, dst: uint64_t */
1771 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_UINT64_T
1772     #define ASSIGN_ptrdiff_t_TO_uint64_t(dst, dsttype, src, srctype) \
1773         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1774 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_UINT64_T
1775     #define ASSIGN_ptrdiff_t_TO_uint64_t(dst, dsttype, src, srctype) \
1776         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1777 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_UINT64_T */
1778     #define ASSIGN_ptrdiff_t_TO_uint64_t(dst, dsttype, src, srctype) \
1779         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1780 #endif /* src: ptrdiff_t dst: uint64_t */
1781
1782 /* src: ptrdiff_t, dst: size_t */
1783 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_SIZE_T
1784     #define ASSIGN_ptrdiff_t_TO_size_t(dst, dsttype, src, srctype) \
1785         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1786 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_SIZE_T
1787     #define ASSIGN_ptrdiff_t_TO_size_t(dst, dsttype, src, srctype) \
1788         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1789 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_SIZE_T */
1790     #define ASSIGN_ptrdiff_t_TO_size_t(dst, dsttype, src, srctype) \
1791         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1792 #endif /* src: ptrdiff_t dst: size_t */
1793
1794 /* src: ptrdiff_t, dst: ssize_t */
1795 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_SSIZE_T
1796     #define ASSIGN_ptrdiff_t_TO_ssize_t(dst, dsttype, src, srctype) \
1797         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1798 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_SSIZE_T
1799     #define ASSIGN_ptrdiff_t_TO_ssize_t(dst, dsttype, src, srctype) \
1800         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1801 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_SSIZE_T */
1802     #define ASSIGN_ptrdiff_t_TO_ssize_t(dst, dsttype, src, srctype) \
1803         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1804 #endif /* src: ptrdiff_t dst: ssize_t */
1805
1806 /* src: ptrdiff_t, dst: haddr_t */
1807 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_HADDR_T
1808     #define ASSIGN_ptrdiff_t_TO_haddr_t(dst, dsttype, src, srctype) \
1809         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1810 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_HADDR_T
1811     #define ASSIGN_ptrdiff_t_TO_haddr_t(dst, dsttype, src, srctype) \
1812         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1813 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_HADDR_T */
1814     #define ASSIGN_ptrdiff_t_TO_haddr_t(dst, dsttype, src, srctype) \
1815         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1816 #endif /* src: ptrdiff_t dst: haddr_t */
1817
1818 /* src: ptrdiff_t, dst: hsize_t */
1819 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_HSIZE_T
1820     #define ASSIGN_ptrdiff_t_TO_hsize_t(dst, dsttype, src, srctype) \
1821         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1822 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_HSIZE_T
1823     #define ASSIGN_ptrdiff_t_TO_hsize_t(dst, dsttype, src, srctype) \
1824         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1825 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_HSIZE_T */
1826     #define ASSIGN_ptrdiff_t_TO_hsize_t(dst, dsttype, src, srctype) \
1827         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1828 #endif /* src: ptrdiff_t dst: hsize_t */
1829
1830 /* src: ptrdiff_t, dst: hssize_t */
1831 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_HSSIZE_T
1832     #define ASSIGN_ptrdiff_t_TO_hssize_t(dst, dsttype, src, srctype) \
1833         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1834 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_HSSIZE_T
1835     #define ASSIGN_ptrdiff_t_TO_hssize_t(dst, dsttype, src, srctype) \
1836         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1837 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_HSSIZE_T */
1838     #define ASSIGN_ptrdiff_t_TO_hssize_t(dst, dsttype, src, srctype) \
1839         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1840 #endif /* src: ptrdiff_t dst: hssize_t */
1841
1842 /* src: ptrdiff_t, dst: h5_stat_size_t */
1843 #if H5_SIZEOF_PTRDIFF_T < H5_SIZEOF_H5_STAT_SIZE_T
1844     #define ASSIGN_ptrdiff_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1845         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1846 #elif H5_SIZEOF_PTRDIFF_T > H5_SIZEOF_H5_STAT_SIZE_T
1847     #define ASSIGN_ptrdiff_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1848         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1849 #else /* H5_SIZEOF_PTRDIFF_T == H5_SIZEOF_H5_STAT_SIZE_T */
1850     #define ASSIGN_ptrdiff_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
1851         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
1852 #endif /* src: ptrdiff_t dst: h5_stat_size_t */
1853
1854
1855 /* Assignment checks for size_t */
1856
1857 /* src: size_t, dst: unsigned */
1858 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UNSIGNED
1859     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
1860         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1861 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UNSIGNED
1862     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
1863         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1864 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UNSIGNED */
1865     #define ASSIGN_size_t_TO_unsigned(dst, dsttype, src, srctype) \
1866         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1867 #endif /* src: size_t dst: unsigned */
1868
1869 /* src: size_t, dst: int8_t */
1870 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_INT8_T
1871     #define ASSIGN_size_t_TO_int8_t(dst, dsttype, src, srctype) \
1872         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1873 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_INT8_T
1874     #define ASSIGN_size_t_TO_int8_t(dst, dsttype, src, srctype) \
1875         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1876 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_INT8_T */
1877     #define ASSIGN_size_t_TO_int8_t(dst, dsttype, src, srctype) \
1878         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1879 #endif /* src: size_t dst: int8_t */
1880
1881 /* src: size_t, dst: int */
1882 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_INT
1883     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
1884         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1885 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_INT
1886     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
1887         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1888 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_INT */
1889     #define ASSIGN_size_t_TO_int(dst, dsttype, src, srctype) \
1890         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1891 #endif /* src: size_t dst: int */
1892
1893 /* src: size_t, dst: long */
1894 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_LONG
1895     #define ASSIGN_size_t_TO_long(dst, dsttype, src, srctype) \
1896         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1897 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_LONG
1898     #define ASSIGN_size_t_TO_long(dst, dsttype, src, srctype) \
1899         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1900 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_LONG */
1901     #define ASSIGN_size_t_TO_long(dst, dsttype, src, srctype) \
1902         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1903 #endif /* src: size_t dst: long */
1904
1905 /* src: size_t, dst: int64_t */
1906 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_INT64_T
1907     #define ASSIGN_size_t_TO_int64_t(dst, dsttype, src, srctype) \
1908         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1909 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_INT64_T
1910     #define ASSIGN_size_t_TO_int64_t(dst, dsttype, src, srctype) \
1911         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1912 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_INT64_T */
1913     #define ASSIGN_size_t_TO_int64_t(dst, dsttype, src, srctype) \
1914         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1915 #endif /* src: size_t dst: int64_t */
1916
1917 /* src: size_t, dst: uint8_t */
1918 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT8_T
1919     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
1920         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1921 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT8_T
1922     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
1923         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1924 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT8_T */
1925     #define ASSIGN_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
1926         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1927 #endif /* src: size_t dst: uint8_t */
1928
1929 /* src: size_t, dst: uint16_t */
1930 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT16_T
1931     #define ASSIGN_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
1932         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1933 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT16_T
1934     #define ASSIGN_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
1935         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1936 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT16_T */
1937     #define ASSIGN_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
1938         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1939 #endif /* src: size_t dst: uint16_t */
1940
1941 /* src: size_t, dst: uint32_t */
1942 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT32_T
1943     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
1944         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1945 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT32_T
1946     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
1947         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1948 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT32_T */
1949     #define ASSIGN_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
1950         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1951 #endif /* src: size_t dst: uint32_t */
1952
1953 /* src: size_t, dst: uint64_t */
1954 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_UINT64_T
1955     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
1956         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1957 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_UINT64_T
1958     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
1959         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1960 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_UINT64_T */
1961     #define ASSIGN_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
1962         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1963 #endif /* src: size_t dst: uint64_t */
1964
1965 /* src: size_t, dst: ptrdiff_t */
1966 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_PTRDIFF_T
1967     #define ASSIGN_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1968         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1969 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_PTRDIFF_T
1970     #define ASSIGN_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1971         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1972 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_PTRDIFF_T */
1973     #define ASSIGN_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
1974         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1975 #endif /* src: size_t dst: ptrdiff_t */
1976
1977 /* src: size_t, dst: ssize_t */
1978 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_SSIZE_T
1979     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
1980         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1981 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_SSIZE_T
1982     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
1983         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1984 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_SSIZE_T */
1985     #define ASSIGN_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
1986         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
1987 #endif /* src: size_t dst: ssize_t */
1988
1989 /* src: size_t, dst: haddr_t */
1990 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HADDR_T
1991     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
1992         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1993 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HADDR_T
1994     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
1995         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
1996 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HADDR_T */
1997     #define ASSIGN_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
1998         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
1999 #endif /* src: size_t dst: haddr_t */
2000
2001 /* src: size_t, dst: hsize_t */
2002 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HSIZE_T
2003     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
2004         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2005 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HSIZE_T
2006     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
2007         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2008 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HSIZE_T */
2009     #define ASSIGN_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
2010         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2011 #endif /* src: size_t dst: hsize_t */
2012
2013 /* src: size_t, dst: hssize_t */
2014 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_HSSIZE_T
2015     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
2016         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2017 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_HSSIZE_T
2018     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
2019         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2020 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_HSSIZE_T */
2021     #define ASSIGN_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
2022         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2023 #endif /* src: size_t dst: hssize_t */
2024
2025 /* src: size_t, dst: h5_stat_size_t */
2026 #if H5_SIZEOF_SIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
2027     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2028         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2029 #elif H5_SIZEOF_SIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
2030     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2031         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2032 #else /* H5_SIZEOF_SIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
2033     #define ASSIGN_size_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2034         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2035 #endif /* src: size_t dst: h5_stat_size_t */
2036
2037
2038 /* Assignment checks for ssize_t */
2039
2040 /* src: ssize_t, dst: unsigned */
2041 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UNSIGNED
2042     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
2043         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2044 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UNSIGNED
2045     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
2046         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2047 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UNSIGNED */
2048     #define ASSIGN_ssize_t_TO_unsigned(dst, dsttype, src, srctype) \
2049         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2050 #endif /* src: ssize_t dst: unsigned */
2051
2052 /* src: ssize_t, dst: int8_t */
2053 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_INT8_T
2054     #define ASSIGN_ssize_t_TO_int8_t(dst, dsttype, src, srctype) \
2055         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2056 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_INT8_T
2057     #define ASSIGN_ssize_t_TO_int8_t(dst, dsttype, src, srctype) \
2058         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2059 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_INT8_T */
2060     #define ASSIGN_ssize_t_TO_int8_t(dst, dsttype, src, srctype) \
2061         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2062 #endif /* src: ssize_t dst: int8_t */
2063
2064 /* src: ssize_t, dst: int */
2065 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_INT
2066     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
2067         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2068 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_INT
2069     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
2070         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2071 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_INT */
2072     #define ASSIGN_ssize_t_TO_int(dst, dsttype, src, srctype) \
2073         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2074 #endif /* src: ssize_t dst: int */
2075
2076 /* src: ssize_t, dst: long */
2077 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_LONG
2078     #define ASSIGN_ssize_t_TO_long(dst, dsttype, src, srctype) \
2079         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2080 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_LONG
2081     #define ASSIGN_ssize_t_TO_long(dst, dsttype, src, srctype) \
2082         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2083 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_LONG */
2084     #define ASSIGN_ssize_t_TO_long(dst, dsttype, src, srctype) \
2085         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2086 #endif /* src: ssize_t dst: long */
2087
2088 /* src: ssize_t, dst: int64_t */
2089 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_INT64_T
2090     #define ASSIGN_ssize_t_TO_int64_t(dst, dsttype, src, srctype) \
2091         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2092 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_INT64_T
2093     #define ASSIGN_ssize_t_TO_int64_t(dst, dsttype, src, srctype) \
2094         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2095 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_INT64_T */
2096     #define ASSIGN_ssize_t_TO_int64_t(dst, dsttype, src, srctype) \
2097         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2098 #endif /* src: ssize_t dst: int64_t */
2099
2100 /* src: ssize_t, dst: uint8_t */
2101 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT8_T
2102     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2103         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2104 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT8_T
2105     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2106         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2107 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT8_T */
2108     #define ASSIGN_ssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2109         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2110 #endif /* src: ssize_t dst: uint8_t */
2111
2112 /* src: ssize_t, dst: uint16_t */
2113 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT16_T
2114     #define ASSIGN_ssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2115         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2116 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT16_T
2117     #define ASSIGN_ssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2118         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2119 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT16_T */
2120     #define ASSIGN_ssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2121         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2122 #endif /* src: ssize_t dst: uint16_t */
2123
2124 /* src: ssize_t, dst: uint32_t */
2125 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT32_T
2126     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2127         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2128 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT32_T
2129     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2130         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2131 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT32_T */
2132     #define ASSIGN_ssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2133         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2134 #endif /* src: ssize_t dst: uint32_t */
2135
2136 /* src: ssize_t, dst: uint64_t */
2137 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_UINT64_T
2138     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2139         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2140 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_UINT64_T
2141     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2142         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2143 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_UINT64_T */
2144     #define ASSIGN_ssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2145         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2146 #endif /* src: ssize_t dst: uint64_t */
2147
2148 /* src: ssize_t, dst: ptrdiff_t */
2149 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_PTRDIFF_T
2150     #define ASSIGN_ssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2151         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2152 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_PTRDIFF_T
2153     #define ASSIGN_ssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2154         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2155 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_PTRDIFF_T */
2156     #define ASSIGN_ssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2157         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2158 #endif /* src: ssize_t dst: ptrdiff_t */
2159
2160 /* src: ssize_t, dst: size_t */
2161 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_SIZE_T
2162     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
2163         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2164 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_SIZE_T
2165     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
2166         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2167 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_SIZE_T */
2168     #define ASSIGN_ssize_t_TO_size_t(dst, dsttype, src, srctype) \
2169         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2170 #endif /* src: ssize_t dst: size_t */
2171
2172 /* src: ssize_t, dst: haddr_t */
2173 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HADDR_T
2174     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2175         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2176 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HADDR_T
2177     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2178         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2179 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HADDR_T */
2180     #define ASSIGN_ssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2181         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2182 #endif /* src: ssize_t dst: haddr_t */
2183
2184 /* src: ssize_t, dst: hsize_t */
2185 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HSIZE_T
2186     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
2187         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2188 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HSIZE_T
2189     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
2190         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2191 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HSIZE_T */
2192     #define ASSIGN_ssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
2193         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2194 #endif /* src: ssize_t dst: hsize_t */
2195
2196 /* src: ssize_t, dst: hssize_t */
2197 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_HSSIZE_T
2198     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
2199         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2200 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_HSSIZE_T
2201     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
2202         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2203 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_HSSIZE_T */
2204     #define ASSIGN_ssize_t_TO_hssize_t(dst, dsttype, src, srctype) \
2205         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2206 #endif /* src: ssize_t dst: hssize_t */
2207
2208 /* src: ssize_t, dst: h5_stat_size_t */
2209 #if H5_SIZEOF_SSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
2210     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2211         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2212 #elif H5_SIZEOF_SSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
2213     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2214         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2215 #else /* H5_SIZEOF_SSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
2216     #define ASSIGN_ssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2217         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2218 #endif /* src: ssize_t dst: h5_stat_size_t */
2219
2220
2221 /* Assignment checks for haddr_t */
2222
2223 /* src: haddr_t, dst: unsigned */
2224 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UNSIGNED
2225     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
2226         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2227 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UNSIGNED
2228     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
2229         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2230 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UNSIGNED */
2231     #define ASSIGN_haddr_t_TO_unsigned(dst, dsttype, src, srctype) \
2232         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2233 #endif /* src: haddr_t dst: unsigned */
2234
2235 /* src: haddr_t, dst: int8_t */
2236 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_INT8_T
2237     #define ASSIGN_haddr_t_TO_int8_t(dst, dsttype, src, srctype) \
2238         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2239 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_INT8_T
2240     #define ASSIGN_haddr_t_TO_int8_t(dst, dsttype, src, srctype) \
2241         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2242 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_INT8_T */
2243     #define ASSIGN_haddr_t_TO_int8_t(dst, dsttype, src, srctype) \
2244         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2245 #endif /* src: haddr_t dst: int8_t */
2246
2247 /* src: haddr_t, dst: int */
2248 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_INT
2249     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
2250         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2251 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_INT
2252     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
2253         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2254 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_INT */
2255     #define ASSIGN_haddr_t_TO_int(dst, dsttype, src, srctype) \
2256         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2257 #endif /* src: haddr_t dst: int */
2258
2259 /* src: haddr_t, dst: long */
2260 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_LONG
2261     #define ASSIGN_haddr_t_TO_long(dst, dsttype, src, srctype) \
2262         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2263 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_LONG
2264     #define ASSIGN_haddr_t_TO_long(dst, dsttype, src, srctype) \
2265         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2266 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_LONG */
2267     #define ASSIGN_haddr_t_TO_long(dst, dsttype, src, srctype) \
2268         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2269 #endif /* src: haddr_t dst: long */
2270
2271 /* src: haddr_t, dst: int64_t */
2272 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_INT64_T
2273     #define ASSIGN_haddr_t_TO_int64_t(dst, dsttype, src, srctype) \
2274         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2275 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_INT64_T
2276     #define ASSIGN_haddr_t_TO_int64_t(dst, dsttype, src, srctype) \
2277         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2278 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_INT64_T */
2279     #define ASSIGN_haddr_t_TO_int64_t(dst, dsttype, src, srctype) \
2280         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2281 #endif /* src: haddr_t dst: int64_t */
2282
2283 /* src: haddr_t, dst: uint8_t */
2284 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT8_T
2285     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
2286         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2287 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT8_T
2288     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
2289         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2290 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT8_T */
2291     #define ASSIGN_haddr_t_TO_uint8_t(dst, dsttype, src, srctype) \
2292         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2293 #endif /* src: haddr_t dst: uint8_t */
2294
2295 /* src: haddr_t, dst: uint16_t */
2296 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT16_T
2297     #define ASSIGN_haddr_t_TO_uint16_t(dst, dsttype, src, srctype) \
2298         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2299 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT16_T
2300     #define ASSIGN_haddr_t_TO_uint16_t(dst, dsttype, src, srctype) \
2301         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2302 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT16_T */
2303     #define ASSIGN_haddr_t_TO_uint16_t(dst, dsttype, src, srctype) \
2304         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2305 #endif /* src: haddr_t dst: uint16_t */
2306
2307 /* src: haddr_t, dst: uint32_t */
2308 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT32_T
2309     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
2310         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2311 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT32_T
2312     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
2313         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2314 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT32_T */
2315     #define ASSIGN_haddr_t_TO_uint32_t(dst, dsttype, src, srctype) \
2316         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2317 #endif /* src: haddr_t dst: uint32_t */
2318
2319 /* src: haddr_t, dst: uint64_t */
2320 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_UINT64_T
2321     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
2322         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2323 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_UINT64_T
2324     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
2325         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2326 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_UINT64_T */
2327     #define ASSIGN_haddr_t_TO_uint64_t(dst, dsttype, src, srctype) \
2328         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2329 #endif /* src: haddr_t dst: uint64_t */
2330
2331 /* src: haddr_t, dst: ptrdiff_t */
2332 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_PTRDIFF_T
2333     #define ASSIGN_haddr_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2334         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2335 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_PTRDIFF_T
2336     #define ASSIGN_haddr_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2337         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2338 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_PTRDIFF_T */
2339     #define ASSIGN_haddr_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2340         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2341 #endif /* src: haddr_t dst: ptrdiff_t */
2342
2343 /* src: haddr_t, dst: size_t */
2344 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_SIZE_T
2345     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
2346         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2347 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_SIZE_T
2348     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
2349         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2350 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_SIZE_T */
2351     #define ASSIGN_haddr_t_TO_size_t(dst, dsttype, src, srctype) \
2352         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2353 #endif /* src: haddr_t dst: size_t */
2354
2355 /* src: haddr_t, dst: ssize_t */
2356 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_SSIZE_T
2357     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
2358         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2359 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_SSIZE_T
2360     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
2361         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2362 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_SSIZE_T */
2363     #define ASSIGN_haddr_t_TO_ssize_t(dst, dsttype, src, srctype) \
2364         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2365 #endif /* src: haddr_t dst: ssize_t */
2366
2367 /* src: haddr_t, dst: hsize_t */
2368 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_HSIZE_T
2369     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
2370         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2371 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_HSIZE_T
2372     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
2373         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2374 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_HSIZE_T */
2375     #define ASSIGN_haddr_t_TO_hsize_t(dst, dsttype, src, srctype) \
2376         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2377 #endif /* src: haddr_t dst: hsize_t */
2378
2379 /* src: haddr_t, dst: hssize_t */
2380 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_HSSIZE_T
2381     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
2382         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2383 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_HSSIZE_T
2384     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
2385         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2386 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_HSSIZE_T */
2387     #define ASSIGN_haddr_t_TO_hssize_t(dst, dsttype, src, srctype) \
2388         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2389 #endif /* src: haddr_t dst: hssize_t */
2390
2391 /* src: haddr_t, dst: h5_stat_size_t */
2392 #if H5_SIZEOF_HADDR_T < H5_SIZEOF_H5_STAT_SIZE_T
2393     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2394         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2395 #elif H5_SIZEOF_HADDR_T > H5_SIZEOF_H5_STAT_SIZE_T
2396     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2397         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2398 #else /* H5_SIZEOF_HADDR_T == H5_SIZEOF_H5_STAT_SIZE_T */
2399     #define ASSIGN_haddr_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2400         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2401 #endif /* src: haddr_t dst: h5_stat_size_t */
2402
2403
2404 /* Assignment checks for hsize_t */
2405
2406 /* src: hsize_t, dst: unsigned */
2407 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UNSIGNED
2408     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
2409         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2410 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UNSIGNED
2411     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
2412         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2413 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UNSIGNED */
2414     #define ASSIGN_hsize_t_TO_unsigned(dst, dsttype, src, srctype) \
2415         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2416 #endif /* src: hsize_t dst: unsigned */
2417
2418 /* src: hsize_t, dst: int8_t */
2419 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_INT8_T
2420     #define ASSIGN_hsize_t_TO_int8_t(dst, dsttype, src, srctype) \
2421         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2422 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_INT8_T
2423     #define ASSIGN_hsize_t_TO_int8_t(dst, dsttype, src, srctype) \
2424         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2425 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_INT8_T */
2426     #define ASSIGN_hsize_t_TO_int8_t(dst, dsttype, src, srctype) \
2427         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2428 #endif /* src: hsize_t dst: int8_t */
2429
2430 /* src: hsize_t, dst: int */
2431 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_INT
2432     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
2433         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2434 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_INT
2435     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
2436         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2437 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_INT */
2438     #define ASSIGN_hsize_t_TO_int(dst, dsttype, src, srctype) \
2439         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2440 #endif /* src: hsize_t dst: int */
2441
2442 /* src: hsize_t, dst: long */
2443 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_LONG
2444     #define ASSIGN_hsize_t_TO_long(dst, dsttype, src, srctype) \
2445         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2446 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_LONG
2447     #define ASSIGN_hsize_t_TO_long(dst, dsttype, src, srctype) \
2448         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2449 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_LONG */
2450     #define ASSIGN_hsize_t_TO_long(dst, dsttype, src, srctype) \
2451         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2452 #endif /* src: hsize_t dst: long */
2453
2454 /* src: hsize_t, dst: int64_t */
2455 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_INT64_T
2456     #define ASSIGN_hsize_t_TO_int64_t(dst, dsttype, src, srctype) \
2457         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2458 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_INT64_T
2459     #define ASSIGN_hsize_t_TO_int64_t(dst, dsttype, src, srctype) \
2460         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2461 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_INT64_T */
2462     #define ASSIGN_hsize_t_TO_int64_t(dst, dsttype, src, srctype) \
2463         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2464 #endif /* src: hsize_t dst: int64_t */
2465
2466 /* src: hsize_t, dst: uint8_t */
2467 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT8_T
2468     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2469         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2470 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT8_T
2471     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2472         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2473 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT8_T */
2474     #define ASSIGN_hsize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2475         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2476 #endif /* src: hsize_t dst: uint8_t */
2477
2478 /* src: hsize_t, dst: uint16_t */
2479 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT16_T
2480     #define ASSIGN_hsize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2481         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2482 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT16_T
2483     #define ASSIGN_hsize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2484         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2485 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT16_T */
2486     #define ASSIGN_hsize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2487         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2488 #endif /* src: hsize_t dst: uint16_t */
2489
2490 /* src: hsize_t, dst: uint32_t */
2491 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT32_T
2492     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2493         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2494 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT32_T
2495     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2496         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2497 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT32_T */
2498     #define ASSIGN_hsize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2499         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2500 #endif /* src: hsize_t dst: uint32_t */
2501
2502 /* src: hsize_t, dst: uint64_t */
2503 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_UINT64_T
2504     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2505         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2506 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_UINT64_T
2507     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2508         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2509 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_UINT64_T */
2510     #define ASSIGN_hsize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2511         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2512 #endif /* src: hsize_t dst: uint64_t */
2513
2514 /* src: hsize_t, dst: ptrdiff_t */
2515 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_PTRDIFF_T
2516     #define ASSIGN_hsize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2517         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2518 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_PTRDIFF_T
2519     #define ASSIGN_hsize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2520         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2521 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_PTRDIFF_T */
2522     #define ASSIGN_hsize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2523         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2524 #endif /* src: hsize_t dst: ptrdiff_t */
2525
2526 /* src: hsize_t, dst: size_t */
2527 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_SIZE_T
2528     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
2529         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2530 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_SIZE_T
2531     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
2532         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2533 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_SIZE_T */
2534     #define ASSIGN_hsize_t_TO_size_t(dst, dsttype, src, srctype) \
2535         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2536 #endif /* src: hsize_t dst: size_t */
2537
2538 /* src: hsize_t, dst: ssize_t */
2539 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_SSIZE_T
2540     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
2541         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2542 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_SSIZE_T
2543     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
2544         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2545 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_SSIZE_T */
2546     #define ASSIGN_hsize_t_TO_ssize_t(dst, dsttype, src, srctype) \
2547         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2548 #endif /* src: hsize_t dst: ssize_t */
2549
2550 /* src: hsize_t, dst: haddr_t */
2551 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_HADDR_T
2552     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2553         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2554 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_HADDR_T
2555     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2556         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2557 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_HADDR_T */
2558     #define ASSIGN_hsize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2559         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2560 #endif /* src: hsize_t dst: haddr_t */
2561
2562 /* src: hsize_t, dst: hssize_t */
2563 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_HSSIZE_T
2564     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
2565         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2566 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_HSSIZE_T
2567     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
2568         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2569 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_HSSIZE_T */
2570     #define ASSIGN_hsize_t_TO_hssize_t(dst, dsttype, src, srctype) \
2571         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2572 #endif /* src: hsize_t dst: hssize_t */
2573
2574 /* src: hsize_t, dst: h5_stat_size_t */
2575 #if H5_SIZEOF_HSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
2576     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2577         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2578 #elif H5_SIZEOF_HSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
2579     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2580         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2581 #else /* H5_SIZEOF_HSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
2582     #define ASSIGN_hsize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2583         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2584 #endif /* src: hsize_t dst: h5_stat_size_t */
2585
2586
2587 /* Assignment checks for hssize_t */
2588
2589 /* src: hssize_t, dst: unsigned */
2590 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UNSIGNED
2591     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
2592         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2593 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UNSIGNED
2594     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
2595         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2596 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UNSIGNED */
2597     #define ASSIGN_hssize_t_TO_unsigned(dst, dsttype, src, srctype) \
2598         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2599 #endif /* src: hssize_t dst: unsigned */
2600
2601 /* src: hssize_t, dst: int8_t */
2602 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_INT8_T
2603     #define ASSIGN_hssize_t_TO_int8_t(dst, dsttype, src, srctype) \
2604         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2605 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_INT8_T
2606     #define ASSIGN_hssize_t_TO_int8_t(dst, dsttype, src, srctype) \
2607         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2608 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_INT8_T */
2609     #define ASSIGN_hssize_t_TO_int8_t(dst, dsttype, src, srctype) \
2610         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2611 #endif /* src: hssize_t dst: int8_t */
2612
2613 /* src: hssize_t, dst: int */
2614 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_INT
2615     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
2616         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2617 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_INT
2618     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
2619         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2620 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_INT */
2621     #define ASSIGN_hssize_t_TO_int(dst, dsttype, src, srctype) \
2622         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2623 #endif /* src: hssize_t dst: int */
2624
2625 /* src: hssize_t, dst: long */
2626 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_LONG
2627     #define ASSIGN_hssize_t_TO_long(dst, dsttype, src, srctype) \
2628         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2629 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_LONG
2630     #define ASSIGN_hssize_t_TO_long(dst, dsttype, src, srctype) \
2631         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2632 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_LONG */
2633     #define ASSIGN_hssize_t_TO_long(dst, dsttype, src, srctype) \
2634         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2635 #endif /* src: hssize_t dst: long */
2636
2637 /* src: hssize_t, dst: int64_t */
2638 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_INT64_T
2639     #define ASSIGN_hssize_t_TO_int64_t(dst, dsttype, src, srctype) \
2640         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2641 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_INT64_T
2642     #define ASSIGN_hssize_t_TO_int64_t(dst, dsttype, src, srctype) \
2643         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2644 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_INT64_T */
2645     #define ASSIGN_hssize_t_TO_int64_t(dst, dsttype, src, srctype) \
2646         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2647 #endif /* src: hssize_t dst: int64_t */
2648
2649 /* src: hssize_t, dst: uint8_t */
2650 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT8_T
2651     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2652         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2653 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT8_T
2654     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2655         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2656 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT8_T */
2657     #define ASSIGN_hssize_t_TO_uint8_t(dst, dsttype, src, srctype) \
2658         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2659 #endif /* src: hssize_t dst: uint8_t */
2660
2661 /* src: hssize_t, dst: uint16_t */
2662 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT16_T
2663     #define ASSIGN_hssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2664         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2665 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT16_T
2666     #define ASSIGN_hssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2667         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2668 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT16_T */
2669     #define ASSIGN_hssize_t_TO_uint16_t(dst, dsttype, src, srctype) \
2670         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2671 #endif /* src: hssize_t dst: uint16_t */
2672
2673 /* src: hssize_t, dst: uint32_t */
2674 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT32_T
2675     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2676         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2677 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT32_T
2678     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2679         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2680 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT32_T */
2681     #define ASSIGN_hssize_t_TO_uint32_t(dst, dsttype, src, srctype) \
2682         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2683 #endif /* src: hssize_t dst: uint32_t */
2684
2685 /* src: hssize_t, dst: uint64_t */
2686 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_UINT64_T
2687     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2688         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2689 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_UINT64_T
2690     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2691         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2692 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_UINT64_T */
2693     #define ASSIGN_hssize_t_TO_uint64_t(dst, dsttype, src, srctype) \
2694         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2695 #endif /* src: hssize_t dst: uint64_t */
2696
2697 /* src: hssize_t, dst: ptrdiff_t */
2698 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_PTRDIFF_T
2699     #define ASSIGN_hssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2700         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2701 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_PTRDIFF_T
2702     #define ASSIGN_hssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2703         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2704 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_PTRDIFF_T */
2705     #define ASSIGN_hssize_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2706         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2707 #endif /* src: hssize_t dst: ptrdiff_t */
2708
2709 /* src: hssize_t, dst: size_t */
2710 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_SIZE_T
2711     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
2712         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2713 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_SIZE_T
2714     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
2715         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2716 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_SIZE_T */
2717     #define ASSIGN_hssize_t_TO_size_t(dst, dsttype, src, srctype) \
2718         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2719 #endif /* src: hssize_t dst: size_t */
2720
2721 /* src: hssize_t, dst: ssize_t */
2722 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_SSIZE_T
2723     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
2724         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2725 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_SSIZE_T
2726     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
2727         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2728 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_SSIZE_T */
2729     #define ASSIGN_hssize_t_TO_ssize_t(dst, dsttype, src, srctype) \
2730         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2731 #endif /* src: hssize_t dst: ssize_t */
2732
2733 /* src: hssize_t, dst: haddr_t */
2734 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_HADDR_T
2735     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2736         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2737 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_HADDR_T
2738     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2739         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2740 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_HADDR_T */
2741     #define ASSIGN_hssize_t_TO_haddr_t(dst, dsttype, src, srctype) \
2742         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2743 #endif /* src: hssize_t dst: haddr_t */
2744
2745 /* src: hssize_t, dst: hsize_t */
2746 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_HSIZE_T
2747     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
2748         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2749 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_HSIZE_T
2750     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
2751         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2752 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_HSIZE_T */
2753     #define ASSIGN_hssize_t_TO_hsize_t(dst, dsttype, src, srctype) \
2754         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2755 #endif /* src: hssize_t dst: hsize_t */
2756
2757 /* src: hssize_t, dst: h5_stat_size_t */
2758 #if H5_SIZEOF_HSSIZE_T < H5_SIZEOF_H5_STAT_SIZE_T
2759     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2760         ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2761 #elif H5_SIZEOF_HSSIZE_T > H5_SIZEOF_H5_STAT_SIZE_T
2762     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2763         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2764 #else /* H5_SIZEOF_HSSIZE_T == H5_SIZEOF_H5_STAT_SIZE_T */
2765     #define ASSIGN_hssize_t_TO_h5_stat_size_t(dst, dsttype, src, srctype) \
2766         ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
2767 #endif /* src: hssize_t dst: h5_stat_size_t */
2768
2769
2770 /* Assignment checks for h5_stat_size_t */
2771
2772 /* src: h5_stat_size_t, dst: unsigned */
2773 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UNSIGNED
2774     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
2775         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2776 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UNSIGNED
2777     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
2778         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2779 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UNSIGNED */
2780     #define ASSIGN_h5_stat_size_t_TO_unsigned(dst, dsttype, src, srctype) \
2781         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2782 #endif /* src: h5_stat_size_t dst: unsigned */
2783
2784 /* src: h5_stat_size_t, dst: int8_t */
2785 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_INT8_T
2786     #define ASSIGN_h5_stat_size_t_TO_int8_t(dst, dsttype, src, srctype) \
2787         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2788 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_INT8_T
2789     #define ASSIGN_h5_stat_size_t_TO_int8_t(dst, dsttype, src, srctype) \
2790         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2791 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_INT8_T */
2792     #define ASSIGN_h5_stat_size_t_TO_int8_t(dst, dsttype, src, srctype) \
2793         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2794 #endif /* src: h5_stat_size_t dst: int8_t */
2795
2796 /* src: h5_stat_size_t, dst: int */
2797 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_INT
2798     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
2799         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2800 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_INT
2801     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
2802         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2803 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_INT */
2804     #define ASSIGN_h5_stat_size_t_TO_int(dst, dsttype, src, srctype) \
2805         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2806 #endif /* src: h5_stat_size_t dst: int */
2807
2808 /* src: h5_stat_size_t, dst: long */
2809 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_LONG
2810     #define ASSIGN_h5_stat_size_t_TO_long(dst, dsttype, src, srctype) \
2811         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2812 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_LONG
2813     #define ASSIGN_h5_stat_size_t_TO_long(dst, dsttype, src, srctype) \
2814         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2815 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_LONG */
2816     #define ASSIGN_h5_stat_size_t_TO_long(dst, dsttype, src, srctype) \
2817         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2818 #endif /* src: h5_stat_size_t dst: long */
2819
2820 /* src: h5_stat_size_t, dst: int64_t */
2821 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_INT64_T
2822     #define ASSIGN_h5_stat_size_t_TO_int64_t(dst, dsttype, src, srctype) \
2823         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2824 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_INT64_T
2825     #define ASSIGN_h5_stat_size_t_TO_int64_t(dst, dsttype, src, srctype) \
2826         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2827 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_INT64_T */
2828     #define ASSIGN_h5_stat_size_t_TO_int64_t(dst, dsttype, src, srctype) \
2829         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2830 #endif /* src: h5_stat_size_t dst: int64_t */
2831
2832 /* src: h5_stat_size_t, dst: uint8_t */
2833 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT8_T
2834     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
2835         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2836 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT8_T
2837     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
2838         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2839 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT8_T */
2840     #define ASSIGN_h5_stat_size_t_TO_uint8_t(dst, dsttype, src, srctype) \
2841         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2842 #endif /* src: h5_stat_size_t dst: uint8_t */
2843
2844 /* src: h5_stat_size_t, dst: uint16_t */
2845 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT16_T
2846     #define ASSIGN_h5_stat_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
2847         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2848 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT16_T
2849     #define ASSIGN_h5_stat_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
2850         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2851 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT16_T */
2852     #define ASSIGN_h5_stat_size_t_TO_uint16_t(dst, dsttype, src, srctype) \
2853         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2854 #endif /* src: h5_stat_size_t dst: uint16_t */
2855
2856 /* src: h5_stat_size_t, dst: uint32_t */
2857 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT32_T
2858     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
2859         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2860 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT32_T
2861     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
2862         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2863 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT32_T */
2864     #define ASSIGN_h5_stat_size_t_TO_uint32_t(dst, dsttype, src, srctype) \
2865         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2866 #endif /* src: h5_stat_size_t dst: uint32_t */
2867
2868 /* src: h5_stat_size_t, dst: uint64_t */
2869 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_UINT64_T
2870     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
2871         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2872 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_UINT64_T
2873     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
2874         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2875 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_UINT64_T */
2876     #define ASSIGN_h5_stat_size_t_TO_uint64_t(dst, dsttype, src, srctype) \
2877         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2878 #endif /* src: h5_stat_size_t dst: uint64_t */
2879
2880 /* src: h5_stat_size_t, dst: ptrdiff_t */
2881 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_PTRDIFF_T
2882     #define ASSIGN_h5_stat_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2883         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2884 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_PTRDIFF_T
2885     #define ASSIGN_h5_stat_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2886         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2887 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_PTRDIFF_T */
2888     #define ASSIGN_h5_stat_size_t_TO_ptrdiff_t(dst, dsttype, src, srctype) \
2889         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2890 #endif /* src: h5_stat_size_t dst: ptrdiff_t */
2891
2892 /* src: h5_stat_size_t, dst: size_t */
2893 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_SIZE_T
2894     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
2895         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2896 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_SIZE_T
2897     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
2898         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2899 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_SIZE_T */
2900     #define ASSIGN_h5_stat_size_t_TO_size_t(dst, dsttype, src, srctype) \
2901         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2902 #endif /* src: h5_stat_size_t dst: size_t */
2903
2904 /* src: h5_stat_size_t, dst: ssize_t */
2905 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_SSIZE_T
2906     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
2907         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2908 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_SSIZE_T
2909     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
2910         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2911 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_SSIZE_T */
2912     #define ASSIGN_h5_stat_size_t_TO_ssize_t(dst, dsttype, src, srctype) \
2913         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2914 #endif /* src: h5_stat_size_t dst: ssize_t */
2915
2916 /* src: h5_stat_size_t, dst: haddr_t */
2917 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HADDR_T
2918     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
2919         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2920 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HADDR_T
2921     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
2922         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2923 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HADDR_T */
2924     #define ASSIGN_h5_stat_size_t_TO_haddr_t(dst, dsttype, src, srctype) \
2925         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2926 #endif /* src: h5_stat_size_t dst: haddr_t */
2927
2928 /* src: h5_stat_size_t, dst: hsize_t */
2929 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HSIZE_T
2930     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
2931         ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2932 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HSIZE_T
2933     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
2934         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2935 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HSIZE_T */
2936     #define ASSIGN_h5_stat_size_t_TO_hsize_t(dst, dsttype, src, srctype) \
2937         ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)
2938 #endif /* src: h5_stat_size_t dst: hsize_t */
2939
2940 /* src: h5_stat_size_t, dst: hssize_t */
2941 #if H5_SIZEOF_H5_STAT_SIZE_T < H5_SIZEOF_HSSIZE_T
2942     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
2943         ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2944 #elif H5_SIZEOF_H5_STAT_SIZE_T > H5_SIZEOF_HSSIZE_T
2945     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
2946         ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
2947 #else /* H5_SIZEOF_H5_STAT_SIZE_T == H5_SIZEOF_HSSIZE_T */
2948     #define ASSIGN_h5_stat_size_t_TO_hssize_t(dst, dsttype, src, srctype) \
2949         ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
2950 #endif /* src: h5_stat_size_t dst: hssize_t */
2951
2952 #endif /* H5overflow_H */
2953