From cb91135cabf2a1823f9c1996058d5e2bececf3a7 Mon Sep 17 00:00:00 2001 From: Jordan Henderson Date: Mon, 24 Jun 2024 21:30:41 -0500 Subject: [PATCH] Windows support --- .../examples/tables/predefinedDatatypes.dox | 6 +- src/H5T.c | 22 +- src/H5Tconv_complex.c | 209 +++++---- src/H5Tconv_complex.h | 6 +- src/H5Tconv_float.c | 75 +-- src/H5Tconv_integer.c | 210 +++++---- src/H5Tconv_macros.h | 4 - src/H5Tnative.c | 18 +- src/H5Tpkg.h | 12 +- src/H5Tpublic.h | 9 +- src/H5private.h | 34 ++ src/H5win32defs.h | 15 + test/dsets.c | 26 +- test/dt_arith.c | 437 +++++++++--------- test/dtypes.c | 60 +-- test/ntypes.c | 12 +- test/tarray.c | 36 +- tools/lib/h5diff_array.c | 52 +-- tools/lib/h5tools.h | 9 +- tools/lib/h5tools_str.c | 16 +- tools/src/h5dump/h5dump.c | 8 +- tools/src/h5dump/h5dump_xml.c | 16 +- tools/src/h5repack/h5repack_opttable.c | 62 +-- tools/test/h5dump/h5dumpgentest.c | 160 +++---- 24 files changed, 782 insertions(+), 732 deletions(-) diff --git a/doxygen/examples/tables/predefinedDatatypes.dox b/doxygen/examples/tables/predefinedDatatypes.dox index be80b03c6ac..9409872e107 100644 --- a/doxygen/examples/tables/predefinedDatatypes.dox +++ b/doxygen/examples/tables/predefinedDatatypes.dox @@ -525,15 +525,15 @@ #H5T_NATIVE_FLOAT_COMPLEX -C-style float _Complex (May be H5I_INVALID_HID if platform doesn't support float _Complex type) +C-style float _Complex (MSVC _Fcomplex) (May be H5I_INVALID_HID if platform doesn't support float _Complex / _Fcomplex type) #H5T_NATIVE_DOUBLE_COMPLEX -C-style double _Complex (May be H5I_INVALID_HID if platform doesn't support double _Complex type) +C-style double _Complex (MSVC _Dcomplex) (May be H5I_INVALID_HID if platform doesn't support double _Complex / _Dcomplex type) #H5T_NATIVE_LDOUBLE_COMPLEX -C-style long double _Complex (May be H5I_INVALID_HID if platform doesn't support long double _Complex type) +C-style long double _Complex (MSVC _Lcomplex) (May be H5I_INVALID_HID if platform doesn't support long double _Complex / _Lcomplex type) #H5T_NATIVE_B8 diff --git a/src/H5T.c b/src/H5T.c index d39615fd78b..e15136a1266 100644 --- a/src/H5T.c +++ b/src/H5T.c @@ -43,10 +43,6 @@ #include "H5VLprivate.h" /* Virtual Object Layer */ #include "H5VMprivate.h" /* Vectors and arrays */ -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - /* Datatype conversion functions */ #include "H5Tconv_integer.h" #include "H5Tconv_float.h" @@ -618,12 +614,12 @@ double H5T_NATIVE_DOUBLE_NEG_INF_g = 0.0; long double H5T_NATIVE_LDOUBLE_POS_INF_g = 0.0L; long double H5T_NATIVE_LDOUBLE_NEG_INF_g = 0.0L; #ifdef H5_HAVE_COMPLEX_NUMBERS -float _Complex H5T_NATIVE_FLOAT_COMPLEX_POS_INF_g = 0.0F + 0.0F * (float _Complex)_Complex_I; -float _Complex H5T_NATIVE_FLOAT_COMPLEX_NEG_INF_g = 0.0F + 0.0F * (float _Complex)_Complex_I; -double _Complex H5T_NATIVE_DOUBLE_COMPLEX_POS_INF_g = 0.0 + 0.0 * (double _Complex)_Complex_I; -double _Complex H5T_NATIVE_DOUBLE_COMPLEX_NEG_INF_g = 0.0 + 0.0 * (double _Complex)_Complex_I; -long double _Complex H5T_NATIVE_LDOUBLE_COMPLEX_POS_INF_g = 0.0L + 0.0L * (long double _Complex)_Complex_I; -long double _Complex H5T_NATIVE_LDOUBLE_COMPLEX_NEG_INF_g = 0.0L + 0.0L * (long double _Complex)_Complex_I; +H5_float_complex H5T_NATIVE_FLOAT_COMPLEX_POS_INF_g = H5_CMPLXF(0.0F, 0.0F); +H5_float_complex H5T_NATIVE_FLOAT_COMPLEX_NEG_INF_g = H5_CMPLXF(0.0F, 0.0F); +H5_double_complex H5T_NATIVE_DOUBLE_COMPLEX_POS_INF_g = H5_CMPLX(0.0, 0.0); +H5_double_complex H5T_NATIVE_DOUBLE_COMPLEX_NEG_INF_g = H5_CMPLX(0.0, 0.0); +H5_ldouble_complex H5T_NATIVE_LDOUBLE_COMPLEX_POS_INF_g = H5_CMPLXL(0.0L, 0.0L); +H5_ldouble_complex H5T_NATIVE_LDOUBLE_COMPLEX_NEG_INF_g = H5_CMPLXL(0.0L, 0.0L); #endif /* Declare the free list for H5T_t's and H5T_shared_t's */ @@ -932,9 +928,9 @@ H5T_init(void) H5T_t *native_float16 = NULL; /* Datatype structure for native _Float16 type */ #endif #ifdef H5_HAVE_COMPLEX_NUMBERS - H5T_t *native_float_complex = NULL; /* Datatype structure for native float _Complex type */ - H5T_t *native_double_complex = NULL; /* Datatype structure for native double _Complex type */ - H5T_t *native_ldouble_complex = NULL; /* Datatype structure for native long double _Complex type */ + H5T_t *native_float_complex = NULL; /* Datatype structure for native float _Complex / _Fcomplex type */ + H5T_t *native_double_complex = NULL; /* Datatype structure for native double _Complex / _Dcomplex type */ + H5T_t *native_ldouble_complex = NULL; /* Datatype structure for native long double _Complex / _Lcomplex type */ #endif herr_t ret_value = SUCCEED; /* Return value */ diff --git a/src/H5Tconv_complex.c b/src/H5Tconv_complex.c index 58383ece93a..9754104ccd3 100644 --- a/src/H5Tconv_complex.c +++ b/src/H5Tconv_complex.c @@ -1438,7 +1438,7 @@ H5T__conv_complex_struct(const H5T_t *src, const H5T_t *dst, H5T_cdata_t *cdata, /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_schar * - * Purpose: Converts `float _Complex' to `signed char' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `signed char' * * Return: Non-negative on success/Negative on failure * @@ -1450,14 +1450,14 @@ H5T__conv_fcomplex_schar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, SCHAR, float _Complex, signed char, SCHAR_MIN, SCHAR_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, SCHAR, H5_float_complex, signed char, SCHAR_MIN, SCHAR_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_uchar * - * Purpose: Converts `float _Complex' to `unsigned char' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `unsigned char' * * Return: Non-negative on success/Negative on failure * @@ -1469,14 +1469,14 @@ H5T__conv_fcomplex_uchar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, UCHAR, float _Complex, unsigned char, 0, UCHAR_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, UCHAR, H5_float_complex, unsigned char, 0, UCHAR_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_short * - * Purpose: Converts `float _Complex' to `short' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `short' * * Return: Non-negative on success/Negative on failure * @@ -1488,14 +1488,14 @@ H5T__conv_fcomplex_short(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, SHORT, float _Complex, short, SHRT_MIN, SHRT_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, SHORT, H5_float_complex, short, SHRT_MIN, SHRT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_ushort * - * Purpose: Converts `float _Complex' to `unsigned short' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `unsigned short' * * Return: Non-negative on success/Negative on failure * @@ -1507,14 +1507,14 @@ H5T__conv_fcomplex_ushort(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, USHORT, float _Complex, unsigned short, 0, USHRT_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, USHORT, H5_float_complex, unsigned short, 0, USHRT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_int * - * Purpose: Converts `float _Complex' to `int' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `int' * * Return: Non-negative on success/Negative on failure * @@ -1526,14 +1526,14 @@ H5T__conv_fcomplex_int(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, INT, float _Complex, int, INT_MIN, INT_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, INT, H5_float_complex, int, INT_MIN, INT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_uint * - * Purpose: Converts `float _Complex' to `unsigned int' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `unsigned int' * * Return: Non-negative on success/Negative on failure * @@ -1545,14 +1545,14 @@ H5T__conv_fcomplex_uint(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, UINT, float _Complex, unsigned int, 0, UINT_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, UINT, H5_float_complex, unsigned int, 0, UINT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_long * - * Purpose: Converts `float _Complex' to `long' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `long' * * Return: Non-negative on success/Negative on failure * @@ -1564,14 +1564,14 @@ H5T__conv_fcomplex_long(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, LONG, float _Complex, long, LONG_MIN, LONG_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, LONG, H5_float_complex, long, LONG_MIN, LONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_ulong * - * Purpose: Converts `float _Complex' to `unsigned long' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `unsigned long' * * Return: Non-negative on success/Negative on failure * @@ -1583,14 +1583,14 @@ H5T__conv_fcomplex_ulong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, ULONG, float _Complex, unsigned long, 0, ULONG_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, ULONG, H5_float_complex, unsigned long, 0, ULONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_llong * - * Purpose: Converts `float _Complex' to `long long' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `long long' * * Return: Non-negative on success/Negative on failure * @@ -1602,14 +1602,15 @@ H5T__conv_fcomplex_llong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, LLONG, float _Complex, long long, LLONG_MIN, LLONG_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, LLONG, H5_float_complex, long long, LLONG_MIN, LLONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_ullong * - * Purpose: Converts `float _Complex' to `unsigned long long' + * Purpose: Converts `float _Complex' / `_Fcomplex' to + * `unsigned long long' * * Return: Non-negative on success/Negative on failure * @@ -1621,7 +1622,7 @@ H5T__conv_fcomplex_ullong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(FLOAT_COMPLEX, ULLONG, float _Complex, unsigned long long, 0, ULLONG_MAX); + H5T_CONV_Zx(FLOAT_COMPLEX, ULLONG, H5_float_complex, unsigned long long, 0, ULLONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } @@ -1629,7 +1630,7 @@ H5T__conv_fcomplex_ullong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex__Float16 * - * Purpose: Converts `float _Complex' to `_Float16' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `_Float16' * * Return: Non-negative on success/Negative on failure * @@ -1642,7 +1643,7 @@ H5T__conv_fcomplex__Float16(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata { /* Suppress warning about non-standard floating-point literal suffix */ H5_GCC_CLANG_DIAG_OFF("pedantic") - H5T_CONV_Zf(FLOAT_COMPLEX, FLOAT16, float _Complex, H5__Float16, -FLT16_MAX, FLT16_MAX); + H5T_CONV_Zf(FLOAT_COMPLEX, FLOAT16, H5_float_complex, H5__Float16, -FLT16_MAX, FLT16_MAX); H5_GCC_CLANG_DIAG_ON("pedantic") } #endif @@ -1650,7 +1651,7 @@ H5T__conv_fcomplex__Float16(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_float * - * Purpose: Converts `float _Complex' to `float' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `float' * * Return: Non-negative on success/Negative on failure * @@ -1661,13 +1662,13 @@ H5T__conv_fcomplex_float(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zf(FLOAT_COMPLEX, FLOAT, float _Complex, float, -, -); + H5T_CONV_zf(FLOAT_COMPLEX, FLOAT, H5_float_complex, float, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_double * - * Purpose: Converts `float _Complex' to `double' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `double' * * Return: Non-negative on success/Negative on failure * @@ -1678,13 +1679,13 @@ H5T__conv_fcomplex_double(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zF(FLOAT_COMPLEX, DOUBLE, float _Complex, double, -, -); + H5T_CONV_zF(FLOAT_COMPLEX, DOUBLE, H5_float_complex, double, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_ldouble * - * Purpose: Converts `float _Complex' to `long double' + * Purpose: Converts `float _Complex' / `_Fcomplex' to `long double' * * Return: Non-negative on success/Negative on failure * @@ -1695,13 +1696,14 @@ H5T__conv_fcomplex_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zF(FLOAT_COMPLEX, LDOUBLE, float _Complex, long double, -, -); + H5T_CONV_zF(FLOAT_COMPLEX, LDOUBLE, H5_float_complex, long double, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_dcomplex * - * Purpose: Converts `float _Complex' to `double _Complex' + * Purpose: Converts `float _Complex' / `_Fcomplex' to + * `double _Complex' / `_Dcomplex' * * Return: Non-negative on success/Negative on failure * @@ -1712,13 +1714,14 @@ H5T__conv_fcomplex_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zZ(FLOAT_COMPLEX, DOUBLE_COMPLEX, float _Complex, double _Complex, -, -); + H5T_CONV_zZ(FLOAT_COMPLEX, DOUBLE_COMPLEX, H5_float_complex, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_fcomplex_lcomplex * - * Purpose: Converts `float _Complex' to `long double _Complex' + * Purpose: Converts `float _Complex' / `_Fcomplex' to + * `long double _Complex' / `_Lcomplex' * * Return: Non-negative on success/Negative on failure * @@ -1729,13 +1732,13 @@ H5T__conv_fcomplex_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zZ(FLOAT_COMPLEX, LDOUBLE_COMPLEX, float _Complex, long double _Complex, -, -); + H5T_CONV_zZ(FLOAT_COMPLEX, LDOUBLE_COMPLEX, H5_float_complex, H5_ldouble_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_schar * - * Purpose: Converts `double _Complex' to `signed char' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `signed char' * * Return: Non-negative on success/Negative on failure * @@ -1747,14 +1750,14 @@ H5T__conv_dcomplex_schar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, SCHAR, double _Complex, signed char, SCHAR_MIN, SCHAR_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, SCHAR, H5_double_complex, signed char, SCHAR_MIN, SCHAR_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_uchar * - * Purpose: Converts `double _Complex' to `unsigned char' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `unsigned char' * * Return: Non-negative on success/Negative on failure * @@ -1766,14 +1769,14 @@ H5T__conv_dcomplex_uchar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, UCHAR, double _Complex, unsigned char, 0, UCHAR_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, UCHAR, H5_double_complex, unsigned char, 0, UCHAR_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_short * - * Purpose: Converts `double _Complex' to `short' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `short' * * Return: Non-negative on success/Negative on failure * @@ -1785,14 +1788,15 @@ H5T__conv_dcomplex_short(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, SHORT, double _Complex, short, SHRT_MIN, SHRT_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, SHORT, H5_double_complex, short, SHRT_MIN, SHRT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_ushort * - * Purpose: Converts `double _Complex' to `unsigned short' + * Purpose: Converts `double _Complex' / `_Dcomplex' to + * `unsigned short' * * Return: Non-negative on success/Negative on failure * @@ -1804,14 +1808,14 @@ H5T__conv_dcomplex_ushort(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, USHORT, double _Complex, unsigned short, 0, USHRT_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, USHORT, H5_double_complex, unsigned short, 0, USHRT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_int * - * Purpose: Converts `double _Complex' to `int' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `int' * * Return: Non-negative on success/Negative on failure * @@ -1823,14 +1827,14 @@ H5T__conv_dcomplex_int(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, INT, double _Complex, int, INT_MIN, INT_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, INT, H5_double_complex, int, INT_MIN, INT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_uint * - * Purpose: Converts `double _Complex' to `unsigned int' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `unsigned int' * * Return: Non-negative on success/Negative on failure * @@ -1842,14 +1846,14 @@ H5T__conv_dcomplex_uint(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, UINT, double _Complex, unsigned int, 0, UINT_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, UINT, H5_double_complex, unsigned int, 0, UINT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_long * - * Purpose: Converts `double _Complex' to `long' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `long' * * Return: Non-negative on success/Negative on failure * @@ -1861,14 +1865,14 @@ H5T__conv_dcomplex_long(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, LONG, double _Complex, long, LONG_MIN, LONG_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, LONG, H5_double_complex, long, LONG_MIN, LONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_ulong * - * Purpose: Converts `double _Complex' to `unsigned long' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `unsigned long' * * Return: Non-negative on success/Negative on failure * @@ -1880,14 +1884,14 @@ H5T__conv_dcomplex_ulong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, ULONG, double _Complex, unsigned long, 0, ULONG_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, ULONG, H5_double_complex, unsigned long, 0, ULONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_llong * - * Purpose: Converts `double _Complex' to `long long' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `long long' * * Return: Non-negative on success/Negative on failure * @@ -1899,14 +1903,15 @@ H5T__conv_dcomplex_llong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, LLONG, double _Complex, long long, LLONG_MIN, LLONG_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, LLONG, H5_double_complex, long long, LLONG_MIN, LLONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_ullong * - * Purpose: Converts `double _Complex' to `unsigned long long' + * Purpose: Converts `double _Complex' / `_Dcomplex' to + * `unsigned long long' * * Return: Non-negative on success/Negative on failure * @@ -1918,7 +1923,7 @@ H5T__conv_dcomplex_ullong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(DOUBLE_COMPLEX, ULLONG, double _Complex, unsigned long long, 0, ULLONG_MAX); + H5T_CONV_Zx(DOUBLE_COMPLEX, ULLONG, H5_double_complex, unsigned long long, 0, ULLONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } @@ -1926,7 +1931,7 @@ H5T__conv_dcomplex_ullong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex__Float16 * - * Purpose: Converts `double _Complex' to `_Float16' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `_Float16' * * Return: Non-negative on success/Negative on failure * @@ -1939,7 +1944,7 @@ H5T__conv_dcomplex__Float16(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata { /* Suppress warning about non-standard floating-point literal suffix */ H5_GCC_CLANG_DIAG_OFF("pedantic") - H5T_CONV_Zf(DOUBLE_COMPLEX, FLOAT16, double _Complex, H5__Float16, -FLT16_MAX, FLT16_MAX); + H5T_CONV_Zf(DOUBLE_COMPLEX, FLOAT16, H5_double_complex, H5__Float16, -FLT16_MAX, FLT16_MAX); H5_GCC_CLANG_DIAG_ON("pedantic") } #endif @@ -1947,7 +1952,7 @@ H5T__conv_dcomplex__Float16(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_float * - * Purpose: Converts `double _Complex' to `float' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `float' * * Return: Non-negative on success/Negative on failure * @@ -1958,13 +1963,13 @@ H5T__conv_dcomplex_float(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Zf(DOUBLE_COMPLEX, FLOAT, double _Complex, float, -FLT_MAX, FLT_MAX); + H5T_CONV_Zf(DOUBLE_COMPLEX, FLOAT, H5_double_complex, float, -FLT_MAX, FLT_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_double * - * Purpose: Converts `double _Complex' to `double' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `double' * * Return: Non-negative on success/Negative on failure * @@ -1975,13 +1980,13 @@ H5T__conv_dcomplex_double(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zf(DOUBLE_COMPLEX, DOUBLE, double _Complex, double, -, -); + H5T_CONV_zf(DOUBLE_COMPLEX, DOUBLE, H5_double_complex, double, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_ldouble * - * Purpose: Converts `double _Complex' to `long double' + * Purpose: Converts `double _Complex' / `_Dcomplex' to `long double' * * Return: Non-negative on success/Negative on failure * @@ -1992,13 +1997,14 @@ H5T__conv_dcomplex_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zF(DOUBLE_COMPLEX, LDOUBLE, double _Complex, long double, -, -); + H5T_CONV_zF(DOUBLE_COMPLEX, LDOUBLE, H5_double_complex, long double, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_fcomplex * - * Purpose: Converts `double _Complex' to `float _Complex' + * Purpose: Converts `double _Complex' / `_Dcomplex' to + * `float _Complex' / `_Fcomplex' * * Return: Non-negative on success/Negative on failure * @@ -2009,13 +2015,14 @@ H5T__conv_dcomplex_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Zz(DOUBLE_COMPLEX, FLOAT_COMPLEX, double _Complex, float _Complex, -FLT_MAX, FLT_MAX); + H5T_CONV_Zz(DOUBLE_COMPLEX, FLOAT_COMPLEX, H5_double_complex, H5_float_complex, -FLT_MAX, FLT_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_dcomplex_lcomplex * - * Purpose: Converts `double _Complex' to `long double _Complex' + * Purpose: Converts `double _Complex' / `_Dcomplex' to + * `long double _Complex' / `_Lcomplex' * * Return: Non-negative on success/Negative on failure * @@ -2026,13 +2033,14 @@ H5T__conv_dcomplex_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zZ(DOUBLE_COMPLEX, LDOUBLE_COMPLEX, double _Complex, long double _Complex, -, -); + H5T_CONV_zZ(DOUBLE_COMPLEX, LDOUBLE_COMPLEX, H5_double_complex, H5_ldouble_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_schar * - * Purpose: Converts `long double _Complex' to `signed char' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `signed char' * * Return: Non-negative on success/Negative on failure * @@ -2044,14 +2052,15 @@ H5T__conv_lcomplex_schar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, SCHAR, long double _Complex, signed char, SCHAR_MIN, SCHAR_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, SCHAR, H5_ldouble_complex, signed char, SCHAR_MIN, SCHAR_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_uchar * - * Purpose: Converts `long double _Complex' to `unsigned char' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `unsigned char' * * Return: Non-negative on success/Negative on failure * @@ -2063,14 +2072,14 @@ H5T__conv_lcomplex_uchar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, UCHAR, long double _Complex, unsigned char, 0, UCHAR_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, UCHAR, H5_ldouble_complex, unsigned char, 0, UCHAR_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_short * - * Purpose: Converts `long double _Complex' to `short' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to `short' * * Return: Non-negative on success/Negative on failure * @@ -2082,14 +2091,15 @@ H5T__conv_lcomplex_short(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, SHORT, long double _Complex, short, SHRT_MIN, SHRT_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, SHORT, H5_ldouble_complex, short, SHRT_MIN, SHRT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_ushort * - * Purpose: Converts `long double _Complex' to `unsigned short' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `unsigned short' * * Return: Non-negative on success/Negative on failure * @@ -2101,14 +2111,14 @@ H5T__conv_lcomplex_ushort(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, USHORT, long double _Complex, unsigned short, 0, USHRT_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, USHORT, H5_ldouble_complex, unsigned short, 0, USHRT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_int * - * Purpose: Converts `long double _Complex' to `int' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to `int' * * Return: Non-negative on success/Negative on failure * @@ -2120,14 +2130,15 @@ H5T__conv_lcomplex_int(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, INT, long double _Complex, int, INT_MIN, INT_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, INT, H5_ldouble_complex, int, INT_MIN, INT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_uint * - * Purpose: Converts `long double _Complex' to `unsigned int' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `unsigned int' * * Return: Non-negative on success/Negative on failure * @@ -2139,14 +2150,14 @@ H5T__conv_lcomplex_uint(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, UINT, long double _Complex, unsigned int, 0, UINT_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, UINT, H5_ldouble_complex, unsigned int, 0, UINT_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_long * - * Purpose: Converts `long double _Complex' to `long' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to `long' * * Return: Non-negative on success/Negative on failure * @@ -2158,14 +2169,15 @@ H5T__conv_lcomplex_long(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, LONG, long double _Complex, long, LONG_MIN, LONG_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, LONG, H5_ldouble_complex, long, LONG_MIN, LONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_ulong * - * Purpose: Converts `long double _Complex' to `unsigned long' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `unsigned long' * * Return: Non-negative on success/Negative on failure * @@ -2177,14 +2189,15 @@ H5T__conv_lcomplex_ulong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, ULONG, long double _Complex, unsigned long, 0, ULONG_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, ULONG, H5_ldouble_complex, unsigned long, 0, ULONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_llong * - * Purpose: Converts `long double _Complex' to `long long' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `long long' * * Return: Non-negative on success/Negative on failure * @@ -2197,7 +2210,7 @@ H5T__conv_lcomplex_llong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, LLONG, long double _Complex, long long, LLONG_MIN, LLONG_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, LLONG, H5_ldouble_complex, long long, LLONG_MIN, LLONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } #endif /* H5T_CONV_INTERNAL_LDOUBLE_LLONG */ @@ -2205,7 +2218,8 @@ H5T__conv_lcomplex_llong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_ullong * - * Purpose: Converts `long double _Complex' to `unsigned long long' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `unsigned long long' * * Return: Non-negative on success/Negative on failure * @@ -2218,7 +2232,7 @@ H5T__conv_lcomplex_ullong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { H5_GCC_CLANG_DIAG_OFF("float-equal") - H5T_CONV_Zx(LDOUBLE_COMPLEX, ULLONG, long double _Complex, unsigned long long, 0, ULLONG_MAX); + H5T_CONV_Zx(LDOUBLE_COMPLEX, ULLONG, H5_ldouble_complex, unsigned long long, 0, ULLONG_MAX); H5_GCC_CLANG_DIAG_ON("float-equal") } #endif /* H5T_CONV_INTERNAL_LDOUBLE_ULLONG */ @@ -2228,7 +2242,7 @@ H5T__conv_lcomplex_ullong(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex__Float16 * - * Purpose: Converts `long double _Complex' to `_Float16' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to `_Float16' * * Return: Non-negative on success/Negative on failure * @@ -2241,7 +2255,7 @@ H5T__conv_lcomplex__Float16(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata { /* Suppress warning about non-standard floating-point literal suffix */ H5_GCC_CLANG_DIAG_OFF("pedantic") - H5T_CONV_Zf(LDOUBLE_COMPLEX, FLOAT16, long double _Complex, H5__Float16, -FLT16_MAX, FLT16_MAX); + H5T_CONV_Zf(LDOUBLE_COMPLEX, FLOAT16, H5_ldouble_complex, H5__Float16, -FLT16_MAX, FLT16_MAX); H5_GCC_CLANG_DIAG_ON("pedantic") } #endif @@ -2250,7 +2264,7 @@ H5T__conv_lcomplex__Float16(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_float * - * Purpose: Converts `long double _Complex' to `float' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to `float' * * Return: Non-negative on success/Negative on failure * @@ -2261,13 +2275,13 @@ H5T__conv_lcomplex_float(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Zf(LDOUBLE_COMPLEX, FLOAT, long double _Complex, float, -FLT_MAX, FLT_MAX); + H5T_CONV_Zf(LDOUBLE_COMPLEX, FLOAT, H5_ldouble_complex, float, -FLT_MAX, FLT_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_double * - * Purpose: Converts `long double _Complex' to `double' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to `double' * * Return: Non-negative on success/Negative on failure * @@ -2278,13 +2292,14 @@ H5T__conv_lcomplex_double(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Zf(LDOUBLE_COMPLEX, DOUBLE, long double _Complex, double, -DBL_MAX, DBL_MAX); + H5T_CONV_Zf(LDOUBLE_COMPLEX, DOUBLE, H5_ldouble_complex, double, -DBL_MAX, DBL_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_ldouble * - * Purpose: Converts `long double _Complex' to `long double' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `long double' * * Return: Non-negative on success/Negative on failure * @@ -2295,13 +2310,14 @@ H5T__conv_lcomplex_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_zf(LDOUBLE_COMPLEX, LDOUBLE, long double _Complex, long double, -, -); + H5T_CONV_zf(LDOUBLE_COMPLEX, LDOUBLE, H5_ldouble_complex, long double, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_fcomplex * - * Purpose: Converts `long double _Complex' to `float _Complex' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `float _Complex' / `_Fcomplex' * * Return: Non-negative on success/Negative on failure * @@ -2312,13 +2328,14 @@ H5T__conv_lcomplex_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Zz(LDOUBLE_COMPLEX, FLOAT_COMPLEX, long double _Complex, float _Complex, -FLT_MAX, FLT_MAX); + H5T_CONV_Zz(LDOUBLE_COMPLEX, FLOAT_COMPLEX, H5_ldouble_complex, H5_float_complex, -FLT_MAX, FLT_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_lcomplex_dcomplex * - * Purpose: Converts `long double _Complex' to `double _Complex' + * Purpose: Converts `long double _Complex' / `_Lcomplex' to + * `double _Complex' / `_Dcomplex' * * Return: Non-negative on success/Negative on failure * @@ -2329,6 +2346,6 @@ H5T__conv_lcomplex_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Zz(LDOUBLE_COMPLEX, DOUBLE_COMPLEX, long double _Complex, double _Complex, -DBL_MAX, DBL_MAX); + H5T_CONV_Zz(LDOUBLE_COMPLEX, DOUBLE_COMPLEX, H5_ldouble_complex, H5_double_complex, -DBL_MAX, DBL_MAX); } #endif /* H5_HAVE_COMPLEX_NUMBERS */ diff --git a/src/H5Tconv_complex.h b/src/H5Tconv_complex.h index e0d211345ff..878ad7cd04d 100644 --- a/src/H5Tconv_complex.h +++ b/src/H5Tconv_complex.h @@ -50,7 +50,7 @@ H5_DLL herr_t H5T__conv_complex_struct(const H5T_t *src, const H5T_t *dst, H5T_c /*********************************************/ #ifdef H5_HAVE_COMPLEX_NUMBERS -/* Conversion functions for 'float _Complex' */ +/* Conversion functions for 'float _Complex' / '_Fcomplex' */ H5_DLL herr_t H5T__conv_fcomplex_schar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t bkg_stride, void *buf, void *bkg); @@ -102,7 +102,7 @@ H5_DLL herr_t H5T__conv_fcomplex_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_ const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t bkg_stride, void *buf, void *bkg); -/* Conversion functions for 'double _Complex' */ +/* Conversion functions for 'double _Complex' / '_Dcomplex' */ H5_DLL herr_t H5T__conv_dcomplex_schar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t bkg_stride, void *buf, void *bkg); @@ -154,7 +154,7 @@ H5_DLL herr_t H5T__conv_dcomplex_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_ const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t bkg_stride, void *buf, void *bkg); -/* Conversion functions for 'long double _Complex' */ +/* Conversion functions for 'long double _Complex' / '_Lcomplex' */ H5_DLL herr_t H5T__conv_lcomplex_schar(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t bkg_stride, void *buf, void *bkg); diff --git a/src/H5Tconv_float.c b/src/H5Tconv_float.c index 71221e8c331..cbd9dd13fef 100644 --- a/src/H5Tconv_float.c +++ b/src/H5Tconv_float.c @@ -1611,7 +1611,7 @@ H5T__conv__Float16_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, /*------------------------------------------------------------------------- * Function: H5T__conv__Float16_fcomplex * - * Purpose: Converts `_Float16' to `float _Complex' + * Purpose: Converts `_Float16' to `float _Complex' / `_Fcomplex' * * Return: Non-negative on success/Negative on failure * @@ -1622,13 +1622,13 @@ H5T__conv__Float16_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fZ(FLOAT16, FLOAT_COMPLEX, H5__Float16, float _Complex, -, -); + H5T_CONV_fZ(FLOAT16, FLOAT_COMPLEX, H5__Float16, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv__Float16_dcomplex * - * Purpose: Converts `_Float16' to `double _Complex' + * Purpose: Converts `_Float16' to `double _Complex' / `_Dcomplex' * * Return: Non-negative on success/Negative on failure * @@ -1639,13 +1639,13 @@ H5T__conv__Float16_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fZ(FLOAT16, DOUBLE_COMPLEX, H5__Float16, double _Complex, -, -); + H5T_CONV_fZ(FLOAT16, DOUBLE_COMPLEX, H5__Float16, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv__Float16_lcomplex * - * Purpose: Converts `_Float16' to `long double _Complex' + * Purpose: Converts `_Float16' to `long double _Complex' / `_Lcomplex' * * Return: Non-negative on success/Negative on failure * @@ -1656,7 +1656,7 @@ H5T__conv__Float16_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fZ(FLOAT16, LDOUBLE_COMPLEX, H5__Float16, long double _Complex, -, -); + H5T_CONV_fZ(FLOAT16, LDOUBLE_COMPLEX, H5__Float16, H5_ldouble_complex, -, -); } #endif #endif @@ -1924,8 +1924,9 @@ H5T__conv_float_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co /*------------------------------------------------------------------------- * Function: H5T__conv_float_fcomplex * - * Purpose: Convert native `float' to native `float _Complex' using - * hardware. This is a fast special case. + * Purpose: Convert native `float' to native + * `float _Complex' / `_Fcomplex' using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -1936,14 +1937,15 @@ H5T__conv_float_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fz(FLOAT, FLOAT_COMPLEX, float, float _Complex, -, -); + H5T_CONV_fz(FLOAT, FLOAT_COMPLEX, float, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_float_dcomplex * - * Purpose: Convert native `float' to native `double _Complex' using - * hardware. This is a fast special case. + * Purpose: Convert native `float' to native + * `double _Complex' / `_Dcomplex' using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -1954,14 +1956,15 @@ H5T__conv_float_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fZ(FLOAT, DOUBLE_COMPLEX, float, double _Complex, -, -); + H5T_CONV_fZ(FLOAT, DOUBLE_COMPLEX, float, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_float_lcomplex * - * Purpose: Convert native `float' to native `long double _Complex' - * using hardware. This is a fast special case. + * Purpose: Convert native `float' to native + * `long double _Complex' / `_Lcomplex' using hardware. This + * is a fast special case. * * Return: Non-negative on success/Negative on failure * @@ -1972,7 +1975,7 @@ H5T__conv_float_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fZ(FLOAT, LDOUBLE_COMPLEX, float, long double _Complex, -, -); + H5T_CONV_fZ(FLOAT, LDOUBLE_COMPLEX, float, H5_ldouble_complex, -, -); } #endif @@ -2239,8 +2242,9 @@ H5T__conv_double_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c /*------------------------------------------------------------------------- * Function: H5T__conv_double_fcomplex * - * Purpose: Convert native `double' to native `float _Complex' using - * hardware. This is a fast special case. + * Purpose: Convert native `double' to native + * `float _Complex' / `_Fcomplex' using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2251,14 +2255,15 @@ H5T__conv_double_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Fz(DOUBLE, FLOAT_COMPLEX, double, float _Complex, -FLT_MAX, FLT_MAX); + H5T_CONV_Fz(DOUBLE, FLOAT_COMPLEX, double, H5_float_complex, -FLT_MAX, FLT_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_double_dcomplex * - * Purpose: Convert native `double' to native `double _Complex' using - * hardware. This is a fast special case. + * Purpose: Convert native `double' to native + * `double _Complex' / `_Dcomplex' using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2269,14 +2274,15 @@ H5T__conv_double_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fz(DOUBLE, DOUBLE_COMPLEX, double, double _Complex, -, -); + H5T_CONV_fz(DOUBLE, DOUBLE_COMPLEX, double, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_double_lcomplex * - * Purpose: Convert native `double' to native `long double _Complex' - * using hardware. This is a fast special case. + * Purpose: Convert native `double' to native + * `long double _Complex' / `_Lcomplex' using hardware. This + * is a fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2287,7 +2293,7 @@ H5T__conv_double_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fZ(DOUBLE, LDOUBLE_COMPLEX, double, long double _Complex, -, -); + H5T_CONV_fZ(DOUBLE, LDOUBLE_COMPLEX, double, H5_ldouble_complex, -, -); } #endif @@ -2560,8 +2566,9 @@ H5T__conv_ldouble_double(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c /*------------------------------------------------------------------------- * Function: H5T__conv_ldouble_fcomplex * - * Purpose: Convert native `long double' to native `float _Complex' - * using hardware. This is a fast special case. + * Purpose: Convert native `long double' to native + * `float _Complex' / `_Fcomplex' using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2572,14 +2579,15 @@ H5T__conv_ldouble_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Fz(LDOUBLE, FLOAT_COMPLEX, long double, float _Complex, -FLT_MAX, FLT_MAX); + H5T_CONV_Fz(LDOUBLE, FLOAT_COMPLEX, long double, H5_float_complex, -FLT_MAX, FLT_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_ldouble_dcomplex * - * Purpose: Convert native `long double' to native `double _Complex' - * using hardware. This is a fast special case. + * Purpose: Convert native `long double' to native + * `double _Complex' / `_Dcomplex' using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2590,14 +2598,15 @@ H5T__conv_ldouble_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_Fz(LDOUBLE, DOUBLE_COMPLEX, long double, double _Complex, -DBL_MAX, DBL_MAX); + H5T_CONV_Fz(LDOUBLE, DOUBLE_COMPLEX, long double, H5_double_complex, -DBL_MAX, DBL_MAX); } /*------------------------------------------------------------------------- * Function: H5T__conv_ldouble_lcomplex * - * Purpose: Convert native `long double' to native `long double _Complex' - * using hardware. This is a fast special case. + * Purpose: Convert native `long double' to native + * `long double _Complex' / `_Lcomplex' using hardware. This + * is a fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2608,6 +2617,6 @@ H5T__conv_ldouble_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_fz(LDOUBLE, LDOUBLE_COMPLEX, long double, long double _Complex, -, -); + H5T_CONV_fz(LDOUBLE, LDOUBLE_COMPLEX, long double, H5_ldouble_complex, -, -); } #endif diff --git a/src/H5Tconv_integer.c b/src/H5Tconv_integer.c index 536116bdbf3..8ddd2638850 100644 --- a/src/H5Tconv_integer.c +++ b/src/H5Tconv_integer.c @@ -1231,8 +1231,9 @@ H5T__conv_schar_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co /*------------------------------------------------------------------------- * Function: H5T__conv_schar_fcomplex * - * Purpose: Convert native signed char to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native signed char to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -1243,14 +1244,15 @@ H5T__conv_schar_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(SCHAR, FLOAT_COMPLEX, signed char, float _Complex, -, -); + H5T_CONV_xZ(SCHAR, FLOAT_COMPLEX, signed char, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_schar_dcomplex * - * Purpose: Convert native signed char to native double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native signed char to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -1261,14 +1263,15 @@ H5T__conv_schar_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(SCHAR, DOUBLE_COMPLEX, signed char, double _Complex, -, -); + H5T_CONV_xZ(SCHAR, DOUBLE_COMPLEX, signed char, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_schar_lcomplex * - * Purpose: Convert native signed char to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native signed char to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -1279,7 +1282,7 @@ H5T__conv_schar_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(SCHAR, LDOUBLE_COMPLEX, signed char, long double _Complex, -, -); + H5T_CONV_xZ(SCHAR, LDOUBLE_COMPLEX, signed char, H5_ldouble_complex, -, -); } #endif @@ -1513,8 +1516,9 @@ H5T__conv_uchar_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co /*------------------------------------------------------------------------- * Function: H5T__conv_uchar_fcomplex * - * Purpose: Convert native unsigned char to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native unsigned char to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -1525,14 +1529,15 @@ H5T__conv_uchar_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(UCHAR, FLOAT_COMPLEX, unsigned char, float _Complex, -, -); + H5T_CONV_xZ(UCHAR, FLOAT_COMPLEX, unsigned char, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_uchar_dcomplex * - * Purpose: Convert native unsigned char to native double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned char to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -1543,14 +1548,15 @@ H5T__conv_uchar_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(UCHAR, DOUBLE_COMPLEX, unsigned char, double _Complex, -, -); + H5T_CONV_xZ(UCHAR, DOUBLE_COMPLEX, unsigned char, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_uchar_lcomplex * - * Purpose: Convert native unsigned char to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned char to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -1561,7 +1567,7 @@ H5T__conv_uchar_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(UCHAR, LDOUBLE_COMPLEX, unsigned char, long double _Complex, -, -); + H5T_CONV_xZ(UCHAR, LDOUBLE_COMPLEX, unsigned char, H5_ldouble_complex, -, -); } #endif @@ -1795,8 +1801,9 @@ H5T__conv_short_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co /*------------------------------------------------------------------------- * Function: H5T__conv_short_fcomplex * - * Purpose: Convert native short to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native short to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -1807,14 +1814,15 @@ H5T__conv_short_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(SHORT, FLOAT_COMPLEX, short, float _Complex, -, -); + H5T_CONV_xZ(SHORT, FLOAT_COMPLEX, short, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_short_dcomplex * - * Purpose: Convert native short to native double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native short to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -1825,14 +1833,15 @@ H5T__conv_short_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(SHORT, DOUBLE_COMPLEX, short, double _Complex, -, -); + H5T_CONV_xZ(SHORT, DOUBLE_COMPLEX, short, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_short_lcomplex * - * Purpose: Convert native short to native long double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native short to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -1843,7 +1852,7 @@ H5T__conv_short_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(SHORT, LDOUBLE_COMPLEX, short, long double _Complex, -, -); + H5T_CONV_xZ(SHORT, LDOUBLE_COMPLEX, short, H5_ldouble_complex, -, -); } #endif @@ -2080,8 +2089,9 @@ H5T__conv_ushort_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c /*------------------------------------------------------------------------- * Function: H5T__conv_ushort_fcomplex * - * Purpose: Convert native unsigned short to native float _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned short to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2092,14 +2102,15 @@ H5T__conv_ushort_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(USHORT, FLOAT_COMPLEX, unsigned short, float _Complex, -, -); + H5T_CONV_xZ(USHORT, FLOAT_COMPLEX, unsigned short, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_ushort_dcomplex * - * Purpose: Convert native unsigned short to native double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned short to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2110,14 +2121,15 @@ H5T__conv_ushort_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(USHORT, DOUBLE_COMPLEX, unsigned short, double _Complex, -, -); + H5T_CONV_xZ(USHORT, DOUBLE_COMPLEX, unsigned short, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_ushort_lcomplex * - * Purpose: Convert native unsigned short to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned short to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2128,7 +2140,7 @@ H5T__conv_ushort_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(USHORT, LDOUBLE_COMPLEX, unsigned short, long double _Complex, -, -); + H5T_CONV_xZ(USHORT, LDOUBLE_COMPLEX, unsigned short, H5_ldouble_complex, -, -); } #endif @@ -2365,8 +2377,9 @@ H5T__conv_int_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, cons /*------------------------------------------------------------------------- * Function: H5T__conv_int_fcomplex * - * Purpose: Convert native integer to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native integer to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2377,14 +2390,15 @@ H5T__conv_int_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(INT, FLOAT_COMPLEX, int, float _Complex, -, -); + H5T_CONV_xZ(INT, FLOAT_COMPLEX, int, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_int_dcomplex * - * Purpose: Convert native integer to native double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native integer to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2395,14 +2409,15 @@ H5T__conv_int_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(INT, DOUBLE_COMPLEX, int, double _Complex, -, -); + H5T_CONV_xZ(INT, DOUBLE_COMPLEX, int, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_int_lcomplex * - * Purpose: Convert native integer to native long double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native integer to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2413,7 +2428,7 @@ H5T__conv_int_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(INT, LDOUBLE_COMPLEX, int, long double _Complex, -, -); + H5T_CONV_xZ(INT, LDOUBLE_COMPLEX, int, H5_ldouble_complex, -, -); } #endif @@ -2650,8 +2665,9 @@ H5T__conv_uint_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con /*------------------------------------------------------------------------- * Function: H5T__conv_uint_fcomplex * - * Purpose: Convert native unsigned integer to native float _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned integer to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2662,14 +2678,15 @@ H5T__conv_uint_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(UINT, FLOAT_COMPLEX, unsigned int, float _Complex, -, -); + H5T_CONV_xZ(UINT, FLOAT_COMPLEX, unsigned int, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_uint_dcomplex * - * Purpose: Convert native unsigned integer to native double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned integer to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2680,14 +2697,15 @@ H5T__conv_uint_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(UINT, DOUBLE_COMPLEX, unsigned int, double _Complex, -, -); + H5T_CONV_xZ(UINT, DOUBLE_COMPLEX, unsigned int, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_uint_lcomplex * - * Purpose: Convert native unsigned integer to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned integer to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2698,7 +2716,7 @@ H5T__conv_uint_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(UINT, LDOUBLE_COMPLEX, unsigned int, long double _Complex, -, -); + H5T_CONV_xZ(UINT, LDOUBLE_COMPLEX, unsigned int, H5_ldouble_complex, -, -); } #endif @@ -2935,8 +2953,9 @@ H5T__conv_long_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, con /*------------------------------------------------------------------------- * Function: H5T__conv_long_fcomplex * - * Purpose: Convert native long to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native long to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2947,14 +2966,15 @@ H5T__conv_long_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(LONG, FLOAT_COMPLEX, long, float _Complex, -, -); + H5T_CONV_xZ(LONG, FLOAT_COMPLEX, long, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_long_dcomplex * - * Purpose: Convert native long to native double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native long to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -2965,14 +2985,15 @@ H5T__conv_long_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(LONG, DOUBLE_COMPLEX, long, double _Complex, -, -); + H5T_CONV_xZ(LONG, DOUBLE_COMPLEX, long, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_long_lcomplex * - * Purpose: Convert native long to native long double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native long to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -2983,7 +3004,7 @@ H5T__conv_long_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(LONG, LDOUBLE_COMPLEX, long, long double _Complex, -, -); + H5T_CONV_xZ(LONG, LDOUBLE_COMPLEX, long, H5_ldouble_complex, -, -); } #endif @@ -3220,8 +3241,9 @@ H5T__conv_ulong_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co /*------------------------------------------------------------------------- * Function: H5T__conv_ulong_fcomplex * - * Purpose: Convert native unsigned long to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native unsigned long to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -3232,14 +3254,15 @@ H5T__conv_ulong_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(ULONG, FLOAT_COMPLEX, unsigned long, float _Complex, -, -); + H5T_CONV_xZ(ULONG, FLOAT_COMPLEX, unsigned long, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_ulong_dcomplex * - * Purpose: Convert native unsigned long to native double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned long to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -3250,14 +3273,15 @@ H5T__conv_ulong_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(ULONG, DOUBLE_COMPLEX, unsigned long, double _Complex, -, -); + H5T_CONV_xZ(ULONG, DOUBLE_COMPLEX, unsigned long, H5_double_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_ulong_lcomplex * - * Purpose: Convert native unsigned long to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned long to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -3268,7 +3292,7 @@ H5T__conv_ulong_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(ULONG, LDOUBLE_COMPLEX, unsigned long, long double _Complex, -, -); + H5T_CONV_xZ(ULONG, LDOUBLE_COMPLEX, unsigned long, H5_ldouble_complex, -, -); } #endif @@ -3507,8 +3531,9 @@ H5T__conv_llong_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, co /*------------------------------------------------------------------------- * Function: H5T__conv_llong_fcomplex * - * Purpose: Convert native long long to native float _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native long long to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -3519,14 +3544,15 @@ H5T__conv_llong_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(LLONG, FLOAT_COMPLEX, long long, float _Complex, -, -); + H5T_CONV_xZ(LLONG, FLOAT_COMPLEX, long long, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_llong_dcomplex * - * Purpose: Convert native long long to native double _Complex using - * hardware. This is a fast special case. + * Purpose: Convert native long long to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -3537,15 +3563,16 @@ H5T__conv_llong_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(LLONG, DOUBLE_COMPLEX, long long, double _Complex, -, -); + H5T_CONV_xZ(LLONG, DOUBLE_COMPLEX, long long, H5_double_complex, -, -); } #ifdef H5T_CONV_INTERNAL_LLONG_LDOUBLE /*------------------------------------------------------------------------- * Function: H5T__conv_llong_lcomplex * - * Purpose: Convert native long long to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native long long to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -3556,7 +3583,7 @@ H5T__conv_llong_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(LLONG, LDOUBLE_COMPLEX, long long, long double _Complex, -, -); + H5T_CONV_xZ(LLONG, LDOUBLE_COMPLEX, long long, H5_ldouble_complex, -, -); } #endif /* H5T_CONV_INTERNAL_LLONG_LDOUBLE */ #endif /* H5_HAVE_COMPLEX_NUMBERS */ @@ -3796,8 +3823,9 @@ H5T__conv_ullong_ldouble(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, c /*------------------------------------------------------------------------- * Function: H5T__conv_ullong_fcomplex * - * Purpose: Convert native unsigned long long to native float _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned long long to native + * float _Complex / _Fcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -3808,14 +3836,15 @@ H5T__conv_ullong_fcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(ULLONG, FLOAT_COMPLEX, unsigned long long, float _Complex, -, -); + H5T_CONV_xZ(ULLONG, FLOAT_COMPLEX, unsigned long long, H5_float_complex, -, -); } /*------------------------------------------------------------------------- * Function: H5T__conv_ullong_dcomplex * - * Purpose: Convert native unsigned long long to native double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned long long to native + * double _Complex / _Dcomplex using hardware. This is a fast + * special case. * * Return: Non-negative on success/Negative on failure * @@ -3826,15 +3855,16 @@ H5T__conv_ullong_dcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(ULLONG, DOUBLE_COMPLEX, unsigned long long, double _Complex, -, -); + H5T_CONV_xZ(ULLONG, DOUBLE_COMPLEX, unsigned long long, H5_double_complex, -, -); } #ifdef H5T_CONV_INTERNAL_ULLONG_LDOUBLE /*------------------------------------------------------------------------- * Function: H5T__conv_ullong_lcomplex * - * Purpose: Convert native unsigned long long to native long double _Complex - * using hardware. This is a fast special case. + * Purpose: Convert native unsigned long long to native + * long double _Complex / _Lcomplex using hardware. This is a + * fast special case. * * Return: Non-negative on success/Negative on failure * @@ -3845,7 +3875,7 @@ H5T__conv_ullong_lcomplex(const H5T_t *st, const H5T_t *dt, H5T_cdata_t *cdata, const H5T_conv_ctx_t *conv_ctx, size_t nelmts, size_t buf_stride, size_t H5_ATTR_UNUSED bkg_stride, void *buf, void H5_ATTR_UNUSED *bkg) { - H5T_CONV_xZ(ULLONG, LDOUBLE_COMPLEX, unsigned long long, long double _Complex, -, -); + H5T_CONV_xZ(ULLONG, LDOUBLE_COMPLEX, unsigned long long, H5_ldouble_complex, -, -); } #endif /* H5T_CONV_INTERNAL_ULLONG_LDOUBLE */ #endif /* H5_HAVE_COMPLEX_NUMBERS */ diff --git a/src/H5Tconv_macros.h b/src/H5Tconv_macros.h index 41250738654..bffb53ef667 100644 --- a/src/H5Tconv_macros.h +++ b/src/H5Tconv_macros.h @@ -25,10 +25,6 @@ #include "H5Eprivate.h" /* Error Handling */ #include "H5Tprivate.h" /* Datatypes */ -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - #ifdef H5T_DEBUG /* Conversion debugging data for the hardware conversion functions */ diff --git a/src/H5Tnative.c b/src/H5Tnative.c index 2b8c4e8f41d..c00b79eeaec 100644 --- a/src/H5Tnative.c +++ b/src/H5Tnative.c @@ -1332,15 +1332,15 @@ H5T__init_native_complex_types(void) typedef struct { struct { char c; - float _Complex x; + H5_float_complex x; } FLOAT_COMPLEX; struct { char c; - double _Complex x; + H5_double_complex x; } DOUBLE_COMPLEX; struct { char c; - long double _Complex x; + H5_ldouble_complex x; } LDOUBLE_COMPLEX; } alignments_t; @@ -1354,12 +1354,12 @@ H5T__init_native_complex_types(void) /* H5T_NATIVE_FLOAT_COMPLEX */ if (NULL == (dt = H5T__complex_create(native_float))) - HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create native float _Complex datatype"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create native float complex datatype"); dt->shared->state = H5T_STATE_IMMUTABLE; /* Register the type and set global variables */ if ((H5T_NATIVE_FLOAT_COMPLEX_g = H5I_register(H5I_DATATYPE, dt, false)) < 0) - HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't register ID for native float _Complex datatype"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't register ID for native float complex datatype"); H5T_NATIVE_FLOAT_COMPLEX_ALIGN_g = TAG_ALIGNMENT(FLOAT_COMPLEX); dt = NULL; @@ -1367,13 +1367,13 @@ H5T__init_native_complex_types(void) /* H5T_NATIVE_DOUBLE_COMPLEX */ if (NULL == (dt = H5T__complex_create(native_double))) - HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create native double _Complex datatype"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create native double complex datatype"); dt->shared->state = H5T_STATE_IMMUTABLE; /* Register the type and set global variables */ if ((H5T_NATIVE_DOUBLE_COMPLEX_g = H5I_register(H5I_DATATYPE, dt, false)) < 0) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, - "can't register ID for native double _Complex datatype"); + "can't register ID for native double complex datatype"); H5T_NATIVE_DOUBLE_COMPLEX_ALIGN_g = TAG_ALIGNMENT(DOUBLE_COMPLEX); dt = NULL; @@ -1381,13 +1381,13 @@ H5T__init_native_complex_types(void) /* H5T_NATIVE_LDOUBLE_COMPLEX */ if (NULL == (dt = H5T__complex_create(native_ldouble))) - HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create native long double _Complex datatype"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create native long double complex datatype"); dt->shared->state = H5T_STATE_IMMUTABLE; /* Register the type and set global variables */ if ((H5T_NATIVE_LDOUBLE_COMPLEX_g = H5I_register(H5I_DATATYPE, dt, false)) < 0) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, - "can't register ID for native long double _Complex datatype"); + "can't register ID for native long double complex datatype"); H5T_NATIVE_LDOUBLE_COMPLEX_ALIGN_g = TAG_ALIGNMENT(LDOUBLE_COMPLEX); dt = NULL; diff --git a/src/H5Tpkg.h b/src/H5Tpkg.h index f3213821cc3..282e1462b12 100644 --- a/src/H5Tpkg.h +++ b/src/H5Tpkg.h @@ -445,12 +445,12 @@ H5_DLLVAR double H5T_NATIVE_DOUBLE_NEG_INF_g; H5_DLLVAR long double H5T_NATIVE_LDOUBLE_POS_INF_g; H5_DLLVAR long double H5T_NATIVE_LDOUBLE_NEG_INF_g; #ifdef H5_HAVE_COMPLEX_NUMBERS -H5_DLLVAR float _Complex H5T_NATIVE_FLOAT_COMPLEX_POS_INF_g; -H5_DLLVAR float _Complex H5T_NATIVE_FLOAT_COMPLEX_NEG_INF_g; -H5_DLLVAR double _Complex H5T_NATIVE_DOUBLE_COMPLEX_POS_INF_g; -H5_DLLVAR double _Complex H5T_NATIVE_DOUBLE_COMPLEX_NEG_INF_g; -H5_DLLVAR long double _Complex H5T_NATIVE_LDOUBLE_COMPLEX_POS_INF_g; -H5_DLLVAR long double _Complex H5T_NATIVE_LDOUBLE_COMPLEX_NEG_INF_g; +H5_DLLVAR H5_float_complex H5T_NATIVE_FLOAT_COMPLEX_POS_INF_g; +H5_DLLVAR H5_float_complex H5T_NATIVE_FLOAT_COMPLEX_NEG_INF_g; +H5_DLLVAR H5_double_complex H5T_NATIVE_DOUBLE_COMPLEX_POS_INF_g; +H5_DLLVAR H5_double_complex H5T_NATIVE_DOUBLE_COMPLEX_NEG_INF_g; +H5_DLLVAR H5_ldouble_complex H5T_NATIVE_LDOUBLE_COMPLEX_POS_INF_g; +H5_DLLVAR H5_ldouble_complex H5T_NATIVE_LDOUBLE_COMPLEX_NEG_INF_g; #endif /* Declare extern the free lists for H5T_t's and H5T_shared_t's */ diff --git a/src/H5Tpublic.h b/src/H5Tpublic.h index 989ee4fa7d5..a38602ae9b9 100644 --- a/src/H5Tpublic.h +++ b/src/H5Tpublic.h @@ -846,7 +846,7 @@ H5_DLLVAR hid_t H5T_VAX_F64_g; #define H5T_NATIVE_ULLONG (H5OPEN H5T_NATIVE_ULLONG_g) /** * \ingroup PDTNAT - * C-style \Code{_Float16} (May be H5I_INVALID_HID if platform doesn't support _Float16 type) + * C-style \Code{_Float16} (May be \Code{H5I_INVALID_HID} if platform doesn't support \Code{_Float16} type) */ #define H5T_NATIVE_FLOAT16 (H5OPEN H5T_NATIVE_FLOAT16_g) /** @@ -866,18 +866,17 @@ H5_DLLVAR hid_t H5T_VAX_F64_g; #define H5T_NATIVE_LDOUBLE (H5OPEN H5T_NATIVE_LDOUBLE_g) /** * \ingroup PDTNAT - * C-style \Code{float _Complex} (May be H5I_INVALID_HID if platform doesn't support float _Complex type) + * C-style \Code{float _Complex} / (MSVC) \Code{_Fcomplex} (May be \Code{H5I_INVALID_HID} if platform doesn't support \Code{float _Complex}/\Code{_Fcomplex} type) */ #define H5T_NATIVE_FLOAT_COMPLEX (H5OPEN H5T_NATIVE_FLOAT_COMPLEX_g) /** * \ingroup PDTNAT - * C-style \Code{double _Complex} (May be H5I_INVALID_HID if platform doesn't support double _Complex type) + * C-style \Code{double _Complex} / (MSVC) \Code{_Dcomplex} (May be \Code{H5I_INVALID_HID} if platform doesn't support \Code{double _Complex}/\Code{_Dcomplex} type) */ #define H5T_NATIVE_DOUBLE_COMPLEX (H5OPEN H5T_NATIVE_DOUBLE_COMPLEX_g) /** * \ingroup PDTNAT - * C-style \Code{long double _Complex} (May be H5I_INVALID_HID if platform doesn't support long double - * _Complex type) + * C-style \Code{long double _Complex} / (MSVC) \Code{_Lcomplex} (May be \Code{H5I_INVALID_HID} if platform doesn't support \Code{long double _Complex}/\Code{_Lcomplex} type) */ #define H5T_NATIVE_LDOUBLE_COMPLEX (H5OPEN H5T_NATIVE_LDOUBLE_COMPLEX_g) /** diff --git a/src/H5private.h b/src/H5private.h index c7a622ebd22..49b2839a383 100644 --- a/src/H5private.h +++ b/src/H5private.h @@ -39,6 +39,10 @@ #include #include +#ifdef H5_HAVE_COMPLEX_NUMBERS +#include +#endif + /* POSIX headers */ #ifdef H5_HAVE_SYS_TIME_H #include @@ -664,6 +668,15 @@ typedef struct { typedef struct stat h5_stat_t; #endif +/* Platform-independent definition for complex number types. For Win32, + * see H5win32defs.h. + */ +#if defined(H5_HAVE_COMPLEX_NUMBERS) && (!defined(H5_HAVE_WIN32_API) || !defined(_MSC_VER)) +typedef float _Complex H5_float_complex; +typedef double _Complex H5_double_complex; +typedef long double _Complex H5_ldouble_complex; +#endif + /* __int64 is the correct type for the st_size field of the _stati64 * struct on Windows (MSDN isn't very clear about this). POSIX systems use * off_t. Both of these are typedef'd to HDoff_t in H5public.h. @@ -847,6 +860,27 @@ H5_DLL int HDvasprintf(char **bufp, const char *fmt, va_list _ap); #define HDwrite(F, M, Z) write(F, M, Z) #endif +/* Simple macros to construct complex numbers. Necessary since + * MSVC's use of structure types for complex numbers means that + * arithmetic operators can't be used directly on variables of + * complex number types. Note that the use of _Complex_I means + * that an imaginary part of -0 may be converted to +0. If the + * minimum required C standard is moved to C11 or later, these can + * be simplified to the standard CMPLXF/CMPLX/CMPLXL macros, + * which don't have this problem. + */ +#ifdef H5_HAVE_COMPLEX_NUMBERS +#ifndef H5_CMPLXF +#define H5_CMPLXF(real, imag) ((real) + ((imag) * (H5_float_complex)_Complex_I)) +#endif +#ifndef H5_CMPLX +#define H5_CMPLX(real, imag) ((real) + ((imag) * (H5_double_complex)_Complex_I)) +#endif +#ifndef H5_CMPLXL +#define H5_CMPLXL(real, imag) ((real) + ((imag) * (H5_ldouble_complex)_Complex_I)) +#endif +#endif + /* Macro for "stringizing" an integer in the C preprocessor (use H5_TOSTRING) */ /* (use H5_TOSTRING, H5_STRINGIZE is just part of the implementation) */ #define H5_STRINGIZE(x) #x diff --git a/src/H5win32defs.h b/src/H5win32defs.h index 72d0e556157..09634c1acc5 100644 --- a/src/H5win32defs.h +++ b/src/H5win32defs.h @@ -74,6 +74,21 @@ struct timezone { #define HDfseek(F, O, W) _fseeki64(F, O, W) #endif +#if defined(H5_HAVE_COMPLEX_NUMBERS) && defined(_MSC_VER) +/* + * MSVC uses its own types for complex numbers that are separate from the + * C99 standard types, so we must use a typedef. These types are structure + * types, so we also need some wrapper functions for interacting with them, + * as the arithmetic operators can't be used on them. + */ +typedef _Fcomplex H5_float_complex; +typedef _Dcomplex H5_double_complex; +typedef _Lcomplex H5_ldouble_complex; +#define H5_CMPLXF _FCbuild +#define H5_CMPLX _Cbuild +#define H5_CMPLXL _LCbuild +#endif + #ifdef __cplusplus extern "C" { #endif diff --git a/test/dsets.c b/test/dsets.c index 1c418ea6713..0e39bec1bac 100644 --- a/test/dsets.c +++ b/test/dsets.c @@ -3915,7 +3915,7 @@ test_nbit_compound_2(hid_t file) unsigned int v; char b[2][2]; atomic d[2][2]; - } complex; + } cplx; hid_t i_tid, c_tid, s_tid, f_tid, v_tid; hid_t cmpd_tid1; /* atomic compound datatype */ @@ -3934,8 +3934,8 @@ test_nbit_compound_2(hid_t file) const hsize_t chunk_size[2] = {2, 5}; const float float_val[2][5] = {{188384.0F, 19.103516F, -1.0831790e9F, -84.242188F, 5.2045898F}, {-49140.0F, 2350.25F, -3.2110596e-1F, 6.4998865e-5F, -0.0F}}; - complex orig_data[2][5]; - complex new_data[2][5]; + cplx orig_data[2][5]; + cplx new_data[2][5]; unsigned int i_mask, s_mask, c_mask, b_mask; double power; size_t i, j, m, n, b_failed, d_failed; @@ -4032,15 +4032,15 @@ test_nbit_compound_2(hid_t file) FAIL_STACK_ERROR; /* Create a memory complex compound datatype before setting the order */ - if ((mem_cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(complex))) < 0) + if ((mem_cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(cplx))) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(mem_cmpd_tid2, "a", HOFFSET(complex, a), mem_cmpd_tid1) < 0) + if (H5Tinsert(mem_cmpd_tid2, "a", HOFFSET(cplx, a), mem_cmpd_tid1) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(mem_cmpd_tid2, "v", HOFFSET(complex, v), v_tid) < 0) + if (H5Tinsert(mem_cmpd_tid2, "v", HOFFSET(cplx, v), v_tid) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(mem_cmpd_tid2, "b", HOFFSET(complex, b), array_tid) < 0) + if (H5Tinsert(mem_cmpd_tid2, "b", HOFFSET(cplx, b), array_tid) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(mem_cmpd_tid2, "d", HOFFSET(complex, d), mem_array_cmplx_tid) < 0) + if (H5Tinsert(mem_cmpd_tid2, "d", HOFFSET(cplx, d), mem_array_cmplx_tid) < 0) FAIL_STACK_ERROR; /* Set order of dataset other complex compound member datatype */ @@ -4048,15 +4048,15 @@ test_nbit_compound_2(hid_t file) FAIL_STACK_ERROR; /* Create a dataset complex compound datatype and insert members */ - if ((cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(complex))) < 0) + if ((cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(cplx))) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(cmpd_tid2, "a", HOFFSET(complex, a), cmpd_tid1) < 0) + if (H5Tinsert(cmpd_tid2, "a", HOFFSET(cplx, a), cmpd_tid1) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(cmpd_tid2, "v", HOFFSET(complex, v), v_tid) < 0) + if (H5Tinsert(cmpd_tid2, "v", HOFFSET(cplx, v), v_tid) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(cmpd_tid2, "b", HOFFSET(complex, b), array_tid) < 0) + if (H5Tinsert(cmpd_tid2, "b", HOFFSET(cplx, b), array_tid) < 0) FAIL_STACK_ERROR; - if (H5Tinsert(cmpd_tid2, "d", HOFFSET(complex, d), array_cmplx_tid) < 0) + if (H5Tinsert(cmpd_tid2, "d", HOFFSET(cplx, d), array_cmplx_tid) < 0) FAIL_STACK_ERROR; /* Create the data space */ diff --git a/test/dt_arith.c b/test/dt_arith.c index a2bb55e4fa4..54c7d5baae5 100644 --- a/test/dt_arith.c +++ b/test/dt_arith.c @@ -16,10 +16,6 @@ #include "h5test.h" -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - /* Number of elements in each random test */ #define NTESTELEM 10000 @@ -678,7 +674,7 @@ test_particular_fp_integer(void) #ifdef H5_HAVE_COMPLEX_NUMBERS unsigned char *buf4 = NULL; unsigned char *saved_buf4 = NULL; - float _Complex src_fc = (float _Complex)INT_MAX; + H5_float_complex src_fc = (H5_float_complex)INT_MAX; size_t src_size4; size_t dst_size4; #endif @@ -836,7 +832,7 @@ test_particular_fp_integer(void) #endif /* H5_HAVE__FLOAT16 */ #ifdef H5_HAVE_COMPLEX_NUMBERS - /* Test conversion from float _Complex (the value is INT_MAX) to int. */ + /* Test conversion from float complex (the value is INT_MAX) to int. */ src_size4 = H5Tget_size(H5T_NATIVE_FLOAT_COMPLEX); dst_size4 = H5Tget_size(H5T_NATIVE_INT); buf4 = (unsigned char *)calloc((size_t)1, (size_t)MAX(src_size4, dst_size4)); @@ -858,14 +854,14 @@ test_particular_fp_integer(void) /* Print errors */ if (dst_i != fill_value) { - float _Complex x = 0.0F + 0.0F * _Complex_I; + H5_float_complex x = H5_CMPLXF(0.0F, 0.0F); unsigned char *buf_ptr; int y; if (0 == fails_this_test++) H5_FAILED(); - printf(" test float _Complex to int:\n"); + printf(" test float complex to int:\n"); printf(" src = "); buf_ptr = saved_buf4; for (j = 0; j < src_size4 / 2; j++) @@ -3228,9 +3224,9 @@ my_isnan(dtype_t type, void *val) } else if (FLT_COMPLEX == type) { #ifdef H5_HAVE_COMPLEX_NUMBERS - float _Complex x; + H5_float_complex x; float x_real, x_imag; - memcpy(&x, val, sizeof(float _Complex)); + memcpy(&x, val, sizeof(H5_float_complex)); x_real = crealf(x); x_imag = cimagf(x); if (isinf(x_real) || isinf(x_imag)) @@ -3243,9 +3239,9 @@ my_isnan(dtype_t type, void *val) } else if (DBL_COMPLEX == type) { #ifdef H5_HAVE_COMPLEX_NUMBERS - double _Complex x; + H5_double_complex x; double x_real, x_imag; - memcpy(&x, val, sizeof(double _Complex)); + memcpy(&x, val, sizeof(H5_double_complex)); x_real = creal(x); x_imag = cimag(x); if (isinf(x_real) || isinf(x_imag)) @@ -3258,9 +3254,9 @@ my_isnan(dtype_t type, void *val) } else if (LDBL_COMPLEX == type) { #ifdef H5_HAVE_COMPLEX_NUMBERS - long double _Complex x; + H5_ldouble_complex x; long double x_real, x_imag; - memcpy(&x, val, sizeof(long double _Complex)); + memcpy(&x, val, sizeof(H5_ldouble_complex)); x_real = creall(x); x_imag = cimagl(x); if (isinf(x_real) || isinf(x_imag)) @@ -3312,9 +3308,9 @@ my_isnan(dtype_t type, void *val) } else if (FLT_COMPLEX == type) { #ifdef H5_HAVE_COMPLEX_NUMBERS - float _Complex x; + H5_float_complex x; float x_real; - memcpy(&x, val, sizeof(float _Complex)); + memcpy(&x, val, sizeof(H5_float_complex)); x_real = crealf(x); snprintf(s, sizeof(s), "%g", (double)x_real); #else @@ -3323,9 +3319,9 @@ my_isnan(dtype_t type, void *val) } else if (DBL_COMPLEX == type) { #ifdef H5_HAVE_COMPLEX_NUMBERS - double _Complex x; + H5_double_complex x; double x_real; - memcpy(&x, val, sizeof(double _Complex)); + memcpy(&x, val, sizeof(H5_double_complex)); x_real = creal(x); snprintf(s, sizeof(s), "%g", x_real); #else @@ -3334,9 +3330,9 @@ my_isnan(dtype_t type, void *val) } else if (LDBL_COMPLEX == type) { #ifdef H5_HAVE_COMPLEX_NUMBERS - long double _Complex x; + H5_ldouble_complex x; long double x_real; - memcpy(&x, val, sizeof(long double _Complex)); + memcpy(&x, val, sizeof(H5_ldouble_complex)); x_real = creall(x); snprintf(s, sizeof(s), "%Lg", x_real); #else @@ -3422,13 +3418,13 @@ test_conv_flt_1_hw_conv_from_flt16(void *hw_dst, unsigned char *src_buf, size_t #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: - *((float _Complex *)hw_dst) = (float _Complex)aligned; + *((H5_float_complex *)hw_dst) = (H5_float_complex)aligned; break; case DBL_COMPLEX: - *((double _Complex *)hw_dst) = (double _Complex)aligned; + *((H5_double_complex *)hw_dst) = (H5_double_complex)aligned; break; case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = (long double _Complex)aligned; + *((H5_ldouble_complex *)hw_dst) = (H5_ldouble_complex)aligned; break; #else case FLT_COMPLEX: @@ -3517,13 +3513,13 @@ test_conv_flt_1_hw_conv_from_flt(void *hw_dst, unsigned char *src_buf, size_t id #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: - *((float _Complex *)hw_dst) = (float _Complex)aligned; + *((H5_float_complex *)hw_dst) = (H5_float_complex)aligned; break; case DBL_COMPLEX: - *((double _Complex *)hw_dst) = (double _Complex)aligned; + *((H5_double_complex *)hw_dst) = (H5_double_complex)aligned; break; case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = (long double _Complex)aligned; + *((H5_ldouble_complex *)hw_dst) = (H5_ldouble_complex)aligned; break; #else case FLT_COMPLEX: @@ -3618,7 +3614,7 @@ test_conv_flt_1_hw_conv_from_double(void *hw_dst, unsigned char *src_buf, size_t #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: - *((float _Complex *)hw_dst) = (float _Complex)aligned; + *((H5_float_complex *)hw_dst) = (H5_float_complex)aligned; /* Check for overflow and underflow */ if (fabs(aligned) > (double)FLT_MAX) @@ -3628,10 +3624,10 @@ test_conv_flt_1_hw_conv_from_double(void *hw_dst, unsigned char *src_buf, size_t break; case DBL_COMPLEX: - *((double _Complex *)hw_dst) = (double _Complex)aligned; + *((H5_double_complex *)hw_dst) = (H5_double_complex)aligned; break; case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = (long double _Complex)aligned; + *((H5_ldouble_complex *)hw_dst) = (H5_ldouble_complex)aligned; break; #else case FLT_COMPLEX: @@ -3732,7 +3728,7 @@ test_conv_flt_1_hw_conv_from_ldouble(void *hw_dst, unsigned char *src_buf, size_ #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: - *((float _Complex *)hw_dst) = (float _Complex)aligned; + *((H5_float_complex *)hw_dst) = (H5_float_complex)aligned; /* Check for overflow and underflow */ if (fabsl(aligned) > (long double)FLT_MAX) @@ -3742,7 +3738,7 @@ test_conv_flt_1_hw_conv_from_ldouble(void *hw_dst, unsigned char *src_buf, size_ break; case DBL_COMPLEX: - *((double _Complex *)hw_dst) = (double _Complex)aligned; + *((H5_double_complex *)hw_dst) = (H5_double_complex)aligned; /* Check for overflow and underflow */ if (fabsl(aligned) > (long double)DBL_MAX) @@ -3752,7 +3748,7 @@ test_conv_flt_1_hw_conv_from_ldouble(void *hw_dst, unsigned char *src_buf, size_ break; case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = (long double _Complex)aligned; + *((H5_ldouble_complex *)hw_dst) = (H5_ldouble_complex)aligned; break; #else case FLT_COMPLEX: @@ -3791,9 +3787,9 @@ test_conv_flt_1_hw_conv_from_ldouble(void *hw_dst, unsigned char *src_buf, size_ * Function: test_conv_flt_1_hw_conv_from_fcomplex * * Purpose: Helper function for test_conv_flt_1 to perform conversion - * from float _Complex to another type by casting. Also checks - * for overflow and underflow when the destination type is a - * type with a smaller width than float. + * from float _Complex / _Fcomplex to another type by casting. + * Also checks for overflow and underflow when the destination + * type is a type with a smaller width than float. * * Return: enum conv_func_ret_t value * @@ -3802,10 +3798,10 @@ test_conv_flt_1_hw_conv_from_ldouble(void *hw_dst, unsigned char *src_buf, size_ static conv_func_ret_t test_conv_flt_1_hw_conv_from_fcomplex(void *hw_dst, unsigned char *src_buf, size_t idx, dtype_t dst_type) { - float _Complex aligned; - conv_func_ret_t ret = CONV_SUCCESS; + H5_float_complex aligned; + conv_func_ret_t ret = CONV_SUCCESS; - memcpy(&aligned, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + memcpy(&aligned, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); switch (dst_type) { case FLT_FLOAT: @@ -3844,13 +3840,13 @@ test_conv_flt_1_hw_conv_from_fcomplex(void *hw_dst, unsigned char *src_buf, size #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: - *((float _Complex *)hw_dst) = aligned; + *((H5_float_complex *)hw_dst) = aligned; break; case DBL_COMPLEX: - *((double _Complex *)hw_dst) = (double _Complex)aligned; + *((H5_double_complex *)hw_dst) = (H5_double_complex)aligned; break; case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = (long double _Complex)aligned; + *((H5_ldouble_complex *)hw_dst) = (H5_ldouble_complex)aligned; break; #else case FLT_COMPLEX: @@ -3887,9 +3883,10 @@ test_conv_flt_1_hw_conv_from_fcomplex(void *hw_dst, unsigned char *src_buf, size * Function: test_conv_flt_1_hw_conv_from_dcomplex * * Purpose: Helper function for test_conv_flt_1 to perform conversion - * from double _Complex to another type by casting. Also - * checks for overflow and underflow when the destination type - * is a type with a smaller width than double. + * from double _Complex / _Dcomplex to another type by + * casting. Also checks for overflow and underflow when the + * destination type is a type with a smaller width than + * double. * * Return: enum conv_func_ret_t value * @@ -3898,11 +3895,11 @@ test_conv_flt_1_hw_conv_from_fcomplex(void *hw_dst, unsigned char *src_buf, size static conv_func_ret_t test_conv_flt_1_hw_conv_from_dcomplex(void *hw_dst, unsigned char *src_buf, size_t idx, dtype_t dst_type) { - double _Complex aligned; - double real_val, imag_val; - conv_func_ret_t ret = CONV_SUCCESS; + H5_double_complex aligned; + double real_val, imag_val; + conv_func_ret_t ret = CONV_SUCCESS; - memcpy(&aligned, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + memcpy(&aligned, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); switch (dst_type) { case FLT_FLOAT: @@ -3949,7 +3946,7 @@ test_conv_flt_1_hw_conv_from_dcomplex(void *hw_dst, unsigned char *src_buf, size bool real_over = false, real_under = false; bool imag_over = false, imag_under = false; - *((float _Complex *)hw_dst) = (float _Complex)aligned; + *((H5_float_complex *)hw_dst) = (H5_float_complex)aligned; /* Check for overflow and underflow */ real_val = creal(aligned); @@ -3988,10 +3985,10 @@ test_conv_flt_1_hw_conv_from_dcomplex(void *hw_dst, unsigned char *src_buf, size break; } case DBL_COMPLEX: - *((double _Complex *)hw_dst) = aligned; + *((H5_double_complex *)hw_dst) = aligned; break; case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = (long double _Complex)aligned; + *((H5_ldouble_complex *)hw_dst) = (H5_ldouble_complex)aligned; break; #else case FLT_COMPLEX: @@ -4028,9 +4025,10 @@ test_conv_flt_1_hw_conv_from_dcomplex(void *hw_dst, unsigned char *src_buf, size * Function: test_conv_flt_1_hw_conv_from_lcomplex * * Purpose: Helper function for test_conv_flt_1 to perform conversion - * from long double _Complex to another type by casting. Also - * checks for overflow and underflow when the destination type - * is a type with a smaller width than long double. + * from long double _Complex / _Lcomplex to another type by + * casting. Also checks for overflow and underflow when the + * destination type is a type with a smaller width than + * long double. * * Return: enum conv_func_ret_t value * @@ -4039,11 +4037,11 @@ test_conv_flt_1_hw_conv_from_dcomplex(void *hw_dst, unsigned char *src_buf, size static conv_func_ret_t test_conv_flt_1_hw_conv_from_lcomplex(void *hw_dst, unsigned char *src_buf, size_t idx, dtype_t dst_type) { - long double _Complex aligned; - long double real_val, imag_val; - conv_func_ret_t ret = CONV_SUCCESS; + H5_ldouble_complex aligned; + long double real_val, imag_val; + conv_func_ret_t ret = CONV_SUCCESS; - memcpy(&aligned, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + memcpy(&aligned, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); switch (dst_type) { case FLT_FLOAT: @@ -4098,7 +4096,7 @@ test_conv_flt_1_hw_conv_from_lcomplex(void *hw_dst, unsigned char *src_buf, size bool real_over = false, real_under = false; bool imag_over = false, imag_under = false; - *((float _Complex *)hw_dst) = (float _Complex)aligned; + *((H5_float_complex *)hw_dst) = (H5_float_complex)aligned; /* Check for overflow and underflow */ real_val = creall(aligned); @@ -4140,7 +4138,7 @@ test_conv_flt_1_hw_conv_from_lcomplex(void *hw_dst, unsigned char *src_buf, size bool real_over = false, real_under = false; bool imag_over = false, imag_under = false; - *((double _Complex *)hw_dst) = (double _Complex)aligned; + *((H5_double_complex *)hw_dst) = (H5_double_complex)aligned; /* Check for overflow and underflow */ real_val = creall(aligned); @@ -4179,7 +4177,7 @@ test_conv_flt_1_hw_conv_from_lcomplex(void *hw_dst, unsigned char *src_buf, size break; } case LDBL_COMPLEX: - *((long double _Complex *)hw_dst) = aligned; + *((H5_ldouble_complex *)hw_dst) = aligned; break; #else case FLT_COMPLEX: @@ -4256,9 +4254,9 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) long double hw_ld; /*hardware-converted */ #endif #ifdef H5_HAVE_COMPLEX_NUMBERS - long double _Complex hw_ldouble_complex; - double _Complex hw_double_complex; - float _Complex hw_float_complex; + H5_ldouble_complex hw_ldouble_complex; + H5_double_complex hw_double_complex; + H5_float_complex hw_float_complex; #endif unsigned char *hw = NULL; /*ptr to hardware-conv'd*/ int underflow; /*underflow occurred */ @@ -4666,9 +4664,9 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) hw_half = 911.0; #endif #ifdef H5_HAVE_COMPLEX_NUMBERS - hw_float_complex = 911.0F + 911.0F * (float _Complex)_Complex_I; - hw_double_complex = 911.0 + 911.0 * (double _Complex)_Complex_I; - hw_ldouble_complex = 911.0L + 911.0L * (long double _Complex)_Complex_I; + hw_float_complex = H5_CMPLXF(911.0F, 911.0F); + hw_double_complex = H5_CMPLX(911.0, 911.0); + hw_ldouble_complex = H5_CMPLXL(911.0L, 911.0L); #endif /* The hardware conversion */ @@ -4802,15 +4800,15 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) } #endif #ifdef H5_HAVE_COMPLEX_NUMBERS - else if (FLT_COMPLEX == dst_type && my_isnan(dst_type, buf + j * sizeof(float _Complex)) && + else if (FLT_COMPLEX == dst_type && my_isnan(dst_type, buf + j * sizeof(H5_float_complex)) && my_isnan(dst_type, hw)) { continue; } - else if (DBL_COMPLEX == dst_type && my_isnan(dst_type, buf + j * sizeof(double _Complex)) && + else if (DBL_COMPLEX == dst_type && my_isnan(dst_type, buf + j * sizeof(H5_double_complex)) && my_isnan(dst_type, hw)) { continue; } - else if (LDBL_COMPLEX == dst_type && my_isnan(dst_type, buf + j * sizeof(long double _Complex)) && + else if (LDBL_COMPLEX == dst_type && my_isnan(dst_type, buf + j * sizeof(H5_ldouble_complex)) && my_isnan(dst_type, hw)) { continue; } @@ -4900,12 +4898,12 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) } #ifdef H5_HAVE_COMPLEX_NUMBERS else if (FLT_COMPLEX == dst_type) { - float _Complex fc; + H5_float_complex fc; float real_val, hw_real_val; float imag_val, hw_imag_val; bool val_passes = true; - memcpy(&fc, &buf[j * dst_size], sizeof(float _Complex)); + memcpy(&fc, &buf[j * dst_size], sizeof(H5_float_complex)); real_val = crealf(fc); imag_val = cimagf(fc); hw_real_val = crealf(hw_float_complex); @@ -4929,14 +4927,14 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) /* Check real part against hardware */ if (conv_ret == CONV_OVERFLOW_REAL || conv_ret == CONV_OVERFLOW_BOTH || conv_ret == CONV_OVERUNDER) - if (!my_isinf(dendian, buf + j * sizeof(float _Complex), dst_size / 2, dst_mpos, + if (!my_isinf(dendian, buf + j * sizeof(H5_float_complex), dst_size / 2, dst_mpos, dst_msize, dst_epos, dst_esize)) val_passes = false; /* Check imaginary part against hardware */ if (conv_ret == CONV_OVERFLOW_IMAG || conv_ret == CONV_OVERFLOW_BOTH || conv_ret == CONV_UNDEROVER) - if (!my_isinf(dendian, buf + (j * sizeof(float _Complex)) + (dst_size / 2), + if (!my_isinf(dendian, buf + (j * sizeof(H5_float_complex)) + (dst_size / 2), dst_size / 2, dst_mpos, dst_msize, dst_epos, dst_esize)) val_passes = false; } @@ -4950,12 +4948,12 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) check_mant[3] = (double)frexpf(hw_imag_val, check_expo + 3); } else if (DBL_COMPLEX == dst_type) { - double _Complex dc; + H5_double_complex dc; double real_val, hw_real_val; double imag_val, hw_imag_val; bool val_passes = true; - memcpy(&dc, &buf[j * dst_size], sizeof(double _Complex)); + memcpy(&dc, &buf[j * dst_size], sizeof(H5_double_complex)); real_val = creal(dc); imag_val = cimag(dc); hw_real_val = creal(hw_double_complex); @@ -4979,14 +4977,14 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) /* Check real part against hardware */ if (conv_ret == CONV_OVERFLOW_REAL || conv_ret == CONV_OVERFLOW_BOTH || conv_ret == CONV_OVERUNDER) - if (!my_isinf(dendian, buf + j * sizeof(double _Complex), dst_size / 2, dst_mpos, + if (!my_isinf(dendian, buf + j * sizeof(H5_double_complex), dst_size / 2, dst_mpos, dst_msize, dst_epos, dst_esize)) val_passes = false; /* Check imaginary part against hardware */ if (conv_ret == CONV_OVERFLOW_IMAG || conv_ret == CONV_OVERFLOW_BOTH || conv_ret == CONV_UNDEROVER) - if (!my_isinf(dendian, buf + (j * sizeof(double _Complex)) + (dst_size / 2), + if (!my_isinf(dendian, buf + (j * sizeof(H5_double_complex)) + (dst_size / 2), dst_size / 2, dst_mpos, dst_msize, dst_epos, dst_esize)) val_passes = false; } @@ -5000,11 +4998,11 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) check_mant[3] = frexp(hw_imag_val, check_expo + 3); } else if (LDBL_COMPLEX == dst_type) { - long double _Complex ldc; + H5_ldouble_complex ldc; long double real_val, hw_real_val; long double imag_val, hw_imag_val; - memcpy(&ldc, &buf[j * dst_size], sizeof(long double _Complex)); + memcpy(&ldc, &buf[j * dst_size], sizeof(H5_ldouble_complex)); real_val = creall(ldc); imag_val = cimagl(ldc); hw_real_val = creall(hw_ldouble_complex); @@ -5133,18 +5131,18 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) } #ifdef H5_HAVE_COMPLEX_NUMBERS else if (FLT_COMPLEX == src_type) { - float _Complex fc; - memcpy(&fc, &saved[j * src_size], sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, &saved[j * src_size], sizeof(H5_float_complex)); printf(" %29.20e%+.20ei\n", (double)crealf(fc), (double)cimagf(fc)); } else if (DBL_COMPLEX == src_type) { - double _Complex dc; - memcpy(&dc, &saved[j * src_size], sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, &saved[j * src_size], sizeof(H5_double_complex)); printf(" %29.20e%+.20ei\n", creal(dc), cimag(dc)); } else if (LDBL_COMPLEX == src_type) { - long double _Complex ldc; - memcpy(&ldc, &saved[j * src_size], sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, &saved[j * src_size], sizeof(H5_ldouble_complex)); printf(" %29.20Le%+.20Lei\n", creall(ldc), cimagl(ldc)); } #endif @@ -5194,18 +5192,18 @@ test_conv_flt_1(const char *name, int run_test, hid_t src, hid_t dst) } #ifdef H5_HAVE_COMPLEX_NUMBERS else if (FLT_COMPLEX == dst_type) { - float _Complex fc; - memcpy(&fc, &buf[j * dst_size], sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, &buf[j * dst_size], sizeof(H5_float_complex)); printf(" %29.20e%+.20ei\n", (double)crealf(fc), (double)cimagf(fc)); } else if (DBL_COMPLEX == dst_type) { - double _Complex dc; - memcpy(&dc, &buf[j * dst_size], sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, &buf[j * dst_size], sizeof(H5_double_complex)); printf(" %29.20e%+.20ei\n", creal(dc), cimag(dc)); } else if (LDBL_COMPLEX == dst_type) { - long double _Complex ldc; - memcpy(&ldc, &buf[j * dst_size], sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, &buf[j * dst_size], sizeof(H5_ldouble_complex)); printf(" %29.20Le%+.20Lei\n", creall(ldc), cimagl(ldc)); } #endif @@ -5373,20 +5371,20 @@ test_conv_int_fp_conv_to_schar(void *hw_p, unsigned char *src_buf, size_t idx, d } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (signed char)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (signed char)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (signed char)ldc; break; } @@ -5476,20 +5474,20 @@ test_conv_int_fp_conv_to_uchar(void *hw_p, unsigned char *src_buf, size_t idx, d } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (unsigned char)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (unsigned char)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (unsigned char)ldc; break; } @@ -5579,20 +5577,20 @@ test_conv_int_fp_conv_to_short(void *hw_p, unsigned char *src_buf, size_t idx, d } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (short)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (short)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (short)ldc; break; } @@ -5682,20 +5680,20 @@ test_conv_int_fp_conv_to_ushort(void *hw_p, unsigned char *src_buf, size_t idx, } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (unsigned short)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (unsigned short)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (unsigned short)ldc; break; } @@ -5785,20 +5783,20 @@ test_conv_int_fp_conv_to_int(void *hw_p, unsigned char *src_buf, size_t idx, dty } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (int)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (int)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (int)ldc; break; } @@ -5888,20 +5886,20 @@ test_conv_int_fp_conv_to_uint(void *hw_p, unsigned char *src_buf, size_t idx, dt } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (unsigned int)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (unsigned int)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (unsigned int)ldc; break; } @@ -5991,20 +5989,20 @@ test_conv_int_fp_conv_to_long(void *hw_p, unsigned char *src_buf, size_t idx, dt } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (long)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (long)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (long)ldc; break; } @@ -6094,20 +6092,20 @@ test_conv_int_fp_conv_to_ulong(void *hw_p, unsigned char *src_buf, size_t idx, d } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (unsigned long)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (unsigned long)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (unsigned long)ldc; break; } @@ -6197,20 +6195,20 @@ test_conv_int_fp_conv_to_llong(void *hw_p, unsigned char *src_buf, size_t idx, d } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (long long)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (long long)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (long long)ldc; break; } @@ -6300,20 +6298,20 @@ test_conv_int_fp_conv_to_ullong(void *hw_p, unsigned char *src_buf, size_t idx, } #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, src_buf + idx * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, src_buf + idx * sizeof(H5_float_complex), sizeof(H5_float_complex)); aligned = (unsigned long long)fc; break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, src_buf + idx * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, src_buf + idx * sizeof(H5_double_complex), sizeof(H5_double_complex)); aligned = (unsigned long long)dc; break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, src_buf + idx * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, src_buf + idx * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); aligned = (unsigned long long)ldc; break; } @@ -6761,7 +6759,7 @@ test_conv_int_fp_conv_to_ldouble(void *hw_p, unsigned char *src_buf, size_t idx, * Function: test_conv_int_fp_conv_to_fcomplex * * Purpose: Helper function for test_conv_int_fp to perform conversion - * from a datatype to float _Complex by casting. + * from a datatype to float _Complex / _Fcomplex by casting. * * Return: -1 on failure * 0 on success @@ -6771,70 +6769,70 @@ test_conv_int_fp_conv_to_ldouble(void *hw_p, unsigned char *src_buf, size_t idx, static int test_conv_int_fp_conv_to_fcomplex(void *hw_p, unsigned char *src_buf, size_t idx, dtype_t src_type) { - float _Complex aligned; - int ret = 0; + H5_float_complex aligned; + int ret = 0; - memset(&aligned, 0, sizeof(float _Complex)); + memset(&aligned, 0, sizeof(H5_float_complex)); switch (src_type) { case INT_SCHAR: { signed char c; memcpy(&c, src_buf + idx * sizeof(signed char), sizeof(signed char)); - aligned = (float _Complex)c; + aligned = (H5_float_complex)c; break; } case INT_UCHAR: { unsigned char uc; memcpy(&uc, src_buf + idx * sizeof(unsigned char), sizeof(unsigned char)); - aligned = (float _Complex)uc; + aligned = (H5_float_complex)uc; break; } case INT_SHORT: { short s; memcpy(&s, src_buf + idx * sizeof(short), sizeof(short)); - aligned = (float _Complex)s; + aligned = (H5_float_complex)s; break; } case INT_USHORT: { unsigned short us; memcpy(&us, src_buf + idx * sizeof(unsigned short), sizeof(unsigned short)); - aligned = (float _Complex)us; + aligned = (H5_float_complex)us; break; } case INT_INT: { int i; memcpy(&i, src_buf + idx * sizeof(int), sizeof(int)); - aligned = (float _Complex)i; + aligned = (H5_float_complex)i; break; } case INT_UINT: { unsigned int ui; memcpy(&ui, src_buf + idx * sizeof(unsigned int), sizeof(unsigned int)); - aligned = (float _Complex)ui; + aligned = (H5_float_complex)ui; break; } case INT_LONG: { long l; memcpy(&l, src_buf + idx * sizeof(long), sizeof(long)); - aligned = (float _Complex)l; + aligned = (H5_float_complex)l; break; } case INT_ULONG: { unsigned long ul; memcpy(&ul, src_buf + idx * sizeof(unsigned long), sizeof(unsigned long)); - aligned = (float _Complex)ul; + aligned = (H5_float_complex)ul; break; } case INT_LLONG: { long long ll; memcpy(&ll, src_buf + idx * sizeof(long long), sizeof(long long)); - aligned = (float _Complex)ll; + aligned = (H5_float_complex)ll; break; } case INT_ULLONG: { unsigned long long ull; memcpy(&ull, src_buf + idx * sizeof(unsigned long long), sizeof(unsigned long long)); - aligned = (float _Complex)ull; + aligned = (H5_float_complex)ull; break; } case FLT_FLOAT16: @@ -6852,7 +6850,7 @@ test_conv_int_fp_conv_to_fcomplex(void *hw_p, unsigned char *src_buf, size_t idx goto done; } - *((float _Complex *)hw_p) = aligned; + *((H5_float_complex *)hw_p) = aligned; done: return ret; @@ -6862,7 +6860,7 @@ test_conv_int_fp_conv_to_fcomplex(void *hw_p, unsigned char *src_buf, size_t idx * Function: test_conv_int_fp_conv_to_dcomplex * * Purpose: Helper function for test_conv_int_fp to perform conversion - * from a datatype to double _Complex by casting. + * from a datatype to double _Complex / _Dcomplex by casting. * * Return: -1 on failure * 0 on success @@ -6872,70 +6870,70 @@ test_conv_int_fp_conv_to_fcomplex(void *hw_p, unsigned char *src_buf, size_t idx static int test_conv_int_fp_conv_to_dcomplex(void *hw_p, unsigned char *src_buf, size_t idx, dtype_t src_type) { - double _Complex aligned; - int ret = 0; + H5_double_complex aligned; + int ret = 0; - memset(&aligned, 0, sizeof(double _Complex)); + memset(&aligned, 0, sizeof(H5_double_complex)); switch (src_type) { case INT_SCHAR: { signed char c; memcpy(&c, src_buf + idx * sizeof(signed char), sizeof(signed char)); - aligned = (double _Complex)c; + aligned = (H5_double_complex)c; break; } case INT_UCHAR: { unsigned char uc; memcpy(&uc, src_buf + idx * sizeof(unsigned char), sizeof(unsigned char)); - aligned = (double _Complex)uc; + aligned = (H5_double_complex)uc; break; } case INT_SHORT: { short s; memcpy(&s, src_buf + idx * sizeof(short), sizeof(short)); - aligned = (double _Complex)s; + aligned = (H5_double_complex)s; break; } case INT_USHORT: { unsigned short us; memcpy(&us, src_buf + idx * sizeof(unsigned short), sizeof(unsigned short)); - aligned = (double _Complex)us; + aligned = (H5_double_complex)us; break; } case INT_INT: { int i; memcpy(&i, src_buf + idx * sizeof(int), sizeof(int)); - aligned = (double _Complex)i; + aligned = (H5_double_complex)i; break; } case INT_UINT: { unsigned int ui; memcpy(&ui, src_buf + idx * sizeof(unsigned int), sizeof(unsigned int)); - aligned = (double _Complex)ui; + aligned = (H5_double_complex)ui; break; } case INT_LONG: { long l; memcpy(&l, src_buf + idx * sizeof(long), sizeof(long)); - aligned = (double _Complex)l; + aligned = (H5_double_complex)l; break; } case INT_ULONG: { unsigned long ul; memcpy(&ul, src_buf + idx * sizeof(unsigned long), sizeof(unsigned long)); - aligned = (double _Complex)ul; + aligned = (H5_double_complex)ul; break; } case INT_LLONG: { long long ll; memcpy(&ll, src_buf + idx * sizeof(long long), sizeof(long long)); - aligned = (double _Complex)ll; + aligned = (H5_double_complex)ll; break; } case INT_ULLONG: { unsigned long long ull; memcpy(&ull, src_buf + idx * sizeof(unsigned long long), sizeof(unsigned long long)); - aligned = (double _Complex)ull; + aligned = (H5_double_complex)ull; break; } case FLT_FLOAT16: @@ -6953,7 +6951,7 @@ test_conv_int_fp_conv_to_dcomplex(void *hw_p, unsigned char *src_buf, size_t idx goto done; } - *((double _Complex *)hw_p) = aligned; + *((H5_double_complex *)hw_p) = aligned; done: return ret; @@ -6963,7 +6961,8 @@ test_conv_int_fp_conv_to_dcomplex(void *hw_p, unsigned char *src_buf, size_t idx * Function: test_conv_int_fp_conv_to_lcomplex * * Purpose: Helper function for test_conv_int_fp to perform conversion - * from a datatype to long double _Complex by casting. + * from a datatype to long double _Complex / _Lcomplex by + * casting. * * Return: -1 on failure * 0 on success @@ -6973,70 +6972,70 @@ test_conv_int_fp_conv_to_dcomplex(void *hw_p, unsigned char *src_buf, size_t idx static int test_conv_int_fp_conv_to_lcomplex(void *hw_p, unsigned char *src_buf, size_t idx, dtype_t src_type) { - long double _Complex aligned; - int ret = 0; + H5_ldouble_complex aligned; + int ret = 0; - memset(&aligned, 0, sizeof(long double _Complex)); + memset(&aligned, 0, sizeof(H5_ldouble_complex)); switch (src_type) { case INT_SCHAR: { signed char c; memcpy(&c, src_buf + idx * sizeof(signed char), sizeof(signed char)); - aligned = (long double _Complex)c; + aligned = (H5_ldouble_complex)c; break; } case INT_UCHAR: { unsigned char uc; memcpy(&uc, src_buf + idx * sizeof(unsigned char), sizeof(unsigned char)); - aligned = (long double _Complex)uc; + aligned = (H5_ldouble_complex)uc; break; } case INT_SHORT: { short s; memcpy(&s, src_buf + idx * sizeof(short), sizeof(short)); - aligned = (long double _Complex)s; + aligned = (H5_ldouble_complex)s; break; } case INT_USHORT: { unsigned short us; memcpy(&us, src_buf + idx * sizeof(unsigned short), sizeof(unsigned short)); - aligned = (long double _Complex)us; + aligned = (H5_ldouble_complex)us; break; } case INT_INT: { int i; memcpy(&i, src_buf + idx * sizeof(int), sizeof(int)); - aligned = (long double _Complex)i; + aligned = (H5_ldouble_complex)i; break; } case INT_UINT: { unsigned int ui; memcpy(&ui, src_buf + idx * sizeof(unsigned int), sizeof(unsigned int)); - aligned = (long double _Complex)ui; + aligned = (H5_ldouble_complex)ui; break; } case INT_LONG: { long l; memcpy(&l, src_buf + idx * sizeof(long), sizeof(long)); - aligned = (long double _Complex)l; + aligned = (H5_ldouble_complex)l; break; } case INT_ULONG: { unsigned long ul; memcpy(&ul, src_buf + idx * sizeof(unsigned long), sizeof(unsigned long)); - aligned = (long double _Complex)ul; + aligned = (H5_ldouble_complex)ul; break; } case INT_LLONG: { long long ll; memcpy(&ll, src_buf + idx * sizeof(long long), sizeof(long long)); - aligned = (long double _Complex)ll; + aligned = (H5_ldouble_complex)ll; break; } case INT_ULLONG: { unsigned long long ull; memcpy(&ull, src_buf + idx * sizeof(unsigned long long), sizeof(unsigned long long)); - aligned = (long double _Complex)ull; + aligned = (H5_ldouble_complex)ull; break; } case FLT_FLOAT16: @@ -7054,7 +7053,7 @@ test_conv_int_fp_conv_to_lcomplex(void *hw_p, unsigned char *src_buf, size_t idx goto done; } - *((long double _Complex *)hw_p) = aligned; + *((H5_ldouble_complex *)hw_p) = aligned; done: return ret; @@ -7124,9 +7123,9 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) H5__Float16 hw_half; #endif #ifdef H5_HAVE_COMPLEX_NUMBERS - long double _Complex hw_ldouble_complex; - double _Complex hw_double_complex; - float _Complex hw_float_complex; + H5_ldouble_complex hw_ldouble_complex; + H5_double_complex hw_double_complex; + H5_float_complex hw_float_complex; #endif /* What is the name of the source type */ @@ -7365,7 +7364,7 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) */ memset(&hw_ldouble, 0, sizeof(long double)); #ifdef H5_HAVE_COMPLEX_NUMBERS - memset(&hw_ldouble_complex, 0, sizeof(long double _Complex)); + memset(&hw_ldouble_complex, 0, sizeof(H5_ldouble_complex)); #endif /* Create a dataset transfer property list and datatype conversion @@ -8024,20 +8023,20 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, saved + j * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, saved + j * sizeof(H5_float_complex), sizeof(H5_float_complex)); printf(" %29f%+fi\n", (double)crealf(fc), (double)cimagf(fc)); break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, saved + j * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, saved + j * sizeof(H5_double_complex), sizeof(H5_double_complex)); printf(" %29f%+fi\n", creal(dc), cimag(dc)); break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, saved + j * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, saved + j * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); printf(" %29Lf%+Lfi\n", creall(ldc), cimagl(ldc)); break; } @@ -8160,20 +8159,20 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: { - float _Complex fc; - memcpy(&fc, buf + j * sizeof(float _Complex), sizeof(float _Complex)); + H5_float_complex fc; + memcpy(&fc, buf + j * sizeof(H5_float_complex), sizeof(H5_float_complex)); printf(" %29f%+fi\n", (double)crealf(fc), (double)cimagf(fc)); break; } case DBL_COMPLEX: { - double _Complex dc; - memcpy(&dc, buf + j * sizeof(double _Complex), sizeof(double _Complex)); + H5_double_complex dc; + memcpy(&dc, buf + j * sizeof(H5_double_complex), sizeof(H5_double_complex)); printf(" %29f%+fi\n", creal(dc), cimag(dc)); break; } case LDBL_COMPLEX: { - long double _Complex ldc; - memcpy(&ldc, buf + j * sizeof(long double _Complex), sizeof(long double _Complex)); + H5_ldouble_complex ldc; + memcpy(&ldc, buf + j * sizeof(H5_ldouble_complex), sizeof(H5_ldouble_complex)); printf(" %29Lf%+Lfi\n", creall(ldc), cimagl(ldc)); break; } @@ -8253,16 +8252,16 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst) #endif #ifdef H5_HAVE_COMPLEX_NUMBERS case FLT_COMPLEX: - printf(" %29f%+fi\n", (double)crealf(*((float _Complex *)((void *)hw))), - (double)cimagf(*((float _Complex *)((void *)hw)))); + printf(" %29f%+fi\n", (double)crealf(*((H5_float_complex *)((void *)hw))), + (double)cimagf(*((H5_float_complex *)((void *)hw)))); break; case DBL_COMPLEX: - printf(" %29f%+fi\n", creal(*((double _Complex *)((void *)hw))), - cimag(*((double _Complex *)((void *)hw)))); + printf(" %29f%+fi\n", creal(*((H5_double_complex *)((void *)hw))), + cimag(*((H5_double_complex *)((void *)hw)))); break; case LDBL_COMPLEX: - printf(" %29Lf%+Lfi\n", creall(*((long double _Complex *)((void *)hw))), - cimagl(*((long double _Complex *)((void *)hw)))); + printf(" %29Lf%+Lfi\n", creall(*((H5_ldouble_complex *)((void *)hw))), + cimagl(*((H5_ldouble_complex *)((void *)hw)))); break; #else case FLT_COMPLEX: diff --git a/test/dtypes.c b/test/dtypes.c index 7c1c1818092..cbe9c3ebb84 100644 --- a/test/dtypes.c +++ b/test/dtypes.c @@ -79,10 +79,10 @@ static const char *FILENAME[] = {"dtypes0", "dtypes1", "dtypes2", "dtypes3", #define TESTFILE "bad_compound.h5" -typedef struct complex_t { +typedef struct cplx_t { double re; double im; -} complex_t; +} cplx_t; typedef enum dtype_t { INT_SCHAR, @@ -210,7 +210,7 @@ user_compound_convert(hid_t H5_ATTR_UNUSED src_id, hid_t H5_ATTR_UNUSED dst_id, static int test_classes(void) { - struct complex { /* Struct with complex fields */ + struct cplx { /* Struct with complex fields */ hvl_t vl_c; hvl_t vl_s; }; @@ -272,11 +272,11 @@ test_classes(void) * Check class for member types of compound type. *-----------------------------------------------------------*/ /* Create a compound datatype and insert some complex types */ - if ((cmpd_id = H5Tcreate(H5T_COMPOUND, sizeof(struct complex))) < 0) + if ((cmpd_id = H5Tcreate(H5T_COMPOUND, sizeof(struct cplx))) < 0) TEST_ERROR; - if (H5Tinsert(cmpd_id, "vl_c", HOFFSET(struct complex, vl_c), vlc_id) < 0) + if (H5Tinsert(cmpd_id, "vl_c", HOFFSET(struct cplx, vl_c), vlc_id) < 0) TEST_ERROR; - if (H5Tinsert(cmpd_id, "vl_s", HOFFSET(struct complex, vl_s), vls_id) < 0) + if (H5Tinsert(cmpd_id, "vl_s", HOFFSET(struct cplx, vl_s), vls_id) < 0) TEST_ERROR; if ((nmembs = H5Tget_nmembers(cmpd_id)) < 0) @@ -378,7 +378,7 @@ test_detect(void) double d; short s; }; - struct complex { /* Struct with complex fields */ + struct cplx { /* Struct with complex fields */ hobj_ref_t arr_r[3][3]; int i; hvl_t vl_f; @@ -580,19 +580,19 @@ test_detect(void) * Test class of a compound type with some complex types as fields. *------------------------------------------------------------------------------*/ /* Create a compound datatype and insert some complex types */ - if ((cplx_cmpd_id = H5Tcreate(H5T_COMPOUND, sizeof(struct complex))) < 0) + if ((cplx_cmpd_id = H5Tcreate(H5T_COMPOUND, sizeof(struct cplx))) < 0) TEST_ERROR; - if (H5Tinsert(cplx_cmpd_id, "arr_r", HOFFSET(struct complex, arr_r), atom_arr_id) < 0) + if (H5Tinsert(cplx_cmpd_id, "arr_r", HOFFSET(struct cplx, arr_r), atom_arr_id) < 0) TEST_ERROR; - if (H5Tinsert(cplx_cmpd_id, "i", HOFFSET(struct complex, i), H5T_NATIVE_INT) < 0) + if (H5Tinsert(cplx_cmpd_id, "i", HOFFSET(struct cplx, i), H5T_NATIVE_INT) < 0) TEST_ERROR; - if (H5Tinsert(cplx_cmpd_id, "vl_f", HOFFSET(struct complex, vl_f), atom_vlf_id) < 0) + if (H5Tinsert(cplx_cmpd_id, "vl_f", HOFFSET(struct cplx, vl_f), atom_vlf_id) < 0) TEST_ERROR; - if (H5Tinsert(cplx_cmpd_id, "vl_s", HOFFSET(struct complex, vl_s), atom_vls_id) < 0) + if (H5Tinsert(cplx_cmpd_id, "vl_s", HOFFSET(struct cplx, vl_s), atom_vls_id) < 0) TEST_ERROR; - if (H5Tinsert(cplx_cmpd_id, "c", HOFFSET(struct complex, c), H5T_NATIVE_CHAR) < 0) + if (H5Tinsert(cplx_cmpd_id, "c", HOFFSET(struct cplx, c), H5T_NATIVE_CHAR) < 0) TEST_ERROR; - if (H5Tinsert(cplx_cmpd_id, "s", HOFFSET(struct complex, s), H5T_NATIVE_SHORT) < 0) + if (H5Tinsert(cplx_cmpd_id, "s", HOFFSET(struct cplx, s), H5T_NATIVE_SHORT) < 0) TEST_ERROR; /* Make certain that the correct classes can be detected */ @@ -681,13 +681,13 @@ test_compound_1(void) TESTING("compound datatypes"); /* Create the empty type */ - if ((complex_id = H5Tcreate(H5T_COMPOUND, sizeof(complex_t))) < 0) + if ((complex_id = H5Tcreate(H5T_COMPOUND, sizeof(cplx_t))) < 0) goto error; /* Try to shrink and expand the size */ if (H5Tset_size(complex_id, sizeof(double)) < 0) goto error; - if (H5Tset_size(complex_id, sizeof(complex_t)) < 0) + if (H5Tset_size(complex_id, sizeof(cplx_t)) < 0) goto error; /* Attempt to add the new compound datatype as a field within itself */ @@ -701,9 +701,9 @@ test_compound_1(void) } /* end if */ /* Add a couple fields */ - if (H5Tinsert(complex_id, "real", HOFFSET(complex_t, re), H5T_NATIVE_DOUBLE) < 0) + if (H5Tinsert(complex_id, "real", HOFFSET(cplx_t, re), H5T_NATIVE_DOUBLE) < 0) goto error; - if (H5Tinsert(complex_id, "imaginary", HOFFSET(complex_t, im), H5T_NATIVE_DOUBLE) < 0) + if (H5Tinsert(complex_id, "imaginary", HOFFSET(cplx_t, im), H5T_NATIVE_DOUBLE) < 0) goto error; /* Test some functions that aren't supposed to work for compound type */ @@ -6858,19 +6858,19 @@ test_complex_type(void) * Check that native macros map to valid types */ type_size = H5Tget_size(H5T_NATIVE_FLOAT_COMPLEX); - if (0 == type_size || sizeof(float _Complex) != type_size) { + if (0 == type_size || sizeof(H5_float_complex) != type_size) { H5_FAILED(); printf("Invalid size for H5T_NATIVE_FLOAT_COMPLEX datatype\n"); goto error; } type_size = H5Tget_size(H5T_NATIVE_DOUBLE_COMPLEX); - if (0 == type_size || sizeof(double _Complex) != type_size) { + if (0 == type_size || sizeof(H5_double_complex) != type_size) { H5_FAILED(); printf("Invalid size for H5T_NATIVE_DOUBLE_COMPLEX datatype\n"); goto error; } type_size = H5Tget_size(H5T_NATIVE_LDOUBLE_COMPLEX); - if (0 == type_size || sizeof(long double _Complex) != type_size) { + if (0 == type_size || sizeof(H5_ldouble_complex) != type_size) { H5_FAILED(); printf("Invalid size for H5T_NATIVE_LDOUBLE_COMPLEX datatype\n"); goto error; @@ -6943,7 +6943,7 @@ test_complex_type(void) } type_size = H5Tget_size(complex_type); - if (0 == type_size || sizeof(float _Complex) != type_size) { + if (0 == type_size || sizeof(H5_float_complex) != type_size) { H5_FAILED(); printf("Invalid size for copied H5T_NATIVE_FLOAT_COMPLEX datatype\n"); goto error; @@ -6962,7 +6962,7 @@ test_complex_type(void) } type_size = H5Tget_size(complex_type); - if (0 == type_size || sizeof(double _Complex) != type_size) { + if (0 == type_size || sizeof(H5_double_complex) != type_size) { H5_FAILED(); printf("Invalid size for copied H5T_NATIVE_DOUBLE_COMPLEX datatype\n"); goto error; @@ -6981,7 +6981,7 @@ test_complex_type(void) } type_size = H5Tget_size(complex_type); - if (0 == type_size || sizeof(long double _Complex) != type_size) { + if (0 == type_size || sizeof(H5_ldouble_complex) != type_size) { H5_FAILED(); printf("Invalid size for copied H5T_NATIVE_LDOUBLE_COMPLEX datatype\n"); goto error; @@ -7060,7 +7060,7 @@ test_complex_type(void) } /* - * Create a dataset with the native float _Complex datatype and check + * Create a dataset with the native float complex datatype and check * the dataset raw data storage size, as well as the file size */ h5_fixname(FILENAME[12], H5P_DEFAULT, filename, sizeof filename); @@ -7102,7 +7102,7 @@ test_complex_type(void) goto error; } - if (H5Dget_storage_size(dset_id) != dims[0] * sizeof(float _Complex)) { + if (H5Dget_storage_size(dset_id) != dims[0] * sizeof(H5_float_complex)) { H5_FAILED(); AT(); printf("Incorrect dataset raw data storage size allocated in file\n"); @@ -7128,7 +7128,7 @@ test_complex_type(void) if (file_size < 0) TEST_ERROR; - if ((size_t)file_size < dims[0] * sizeof(float _Complex)) { + if ((size_t)file_size < dims[0] * sizeof(H5_float_complex)) { H5_FAILED(); AT(); printf("File size value was too small\n"); @@ -7136,7 +7136,7 @@ test_complex_type(void) } /* 4096 bytes is arbitrary, but should suffice for now */ - if ((size_t)file_size > (dims[0] * sizeof(float _Complex)) + 4096) { + if ((size_t)file_size > (dims[0] * sizeof(H5_float_complex)) + 4096) { H5_FAILED(); AT(); printf("File size value was too large\n"); @@ -10901,7 +10901,7 @@ test_versionbounds(void) char char_arr[ARRAY_LEN]; float float_complex_sim[2]; #ifdef H5_HAVE_COMPLEX_NUMBERS - float _Complex float_complex_mem; + H5_float_complex float_complex_mem; #endif } simple_cmp_t; @@ -10992,7 +10992,7 @@ test_versionbounds(void) TEST_ERROR; #ifdef H5_HAVE_COMPLEX_NUMBERS - /* Insert native float _Complex field */ + /* Insert native float complex field */ ret = H5Tinsert(simple_cmp_type, "native_float_complex", HOFFSET(simple_cmp_t, float_complex_mem), H5T_NATIVE_FLOAT_COMPLEX); if (ret < 0) diff --git a/test/ntypes.c b/test/ntypes.c index 5d3ef9ede51..8e3195d45b3 100644 --- a/test/ntypes.c +++ b/test/ntypes.c @@ -16,10 +16,6 @@ #include "h5test.h" -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - static const char *FILENAME[] = {"ntypes", NULL}; #define DIM0 100 @@ -3185,13 +3181,13 @@ test_complex(hid_t file) hid_t dtype = H5I_INVALID_HID; hid_t native_type = H5I_INVALID_HID; struct { - float _Complex arr[DIM0][DIM1]; + H5_float_complex arr[DIM0][DIM1]; } *ipoints = NULL; struct { - float _Complex arr[DIM0][DIM1]; + H5_float_complex arr[DIM0][DIM1]; } *icheck = NULL; - TESTING("float _Complex datatype"); + TESTING("float complex datatype"); if (NULL == (ipoints = calloc(1, sizeof(*ipoints)))) TEST_ERROR; @@ -3203,7 +3199,7 @@ test_complex(hid_t file) for (size_t j = 0; j < DIM1; j++) { float real = (float)(rand() / (double)RAND_MAX); float imag = (float)(rand() / (double)RAND_MAX); - ipoints->arr[i][j] = (float _Complex)(real + (imag * _Complex_I)); + ipoints->arr[i][j] = H5_CMPLXF(real, imag); } /* Create the data space */ diff --git a/test/tarray.c b/test/tarray.c index c9c182aebeb..ef35daeecf0 100644 --- a/test/tarray.c +++ b/test/tarray.c @@ -21,10 +21,6 @@ #include "testhdf5.h" #include "H5srcdir.h" -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - #define FILENAME "tarray1.h5" #define TESTFILE "tarrold.h5" @@ -1591,20 +1587,20 @@ test_array_vlen_array(void) static void test_array_complex(void) { - float _Complex wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */ - float _Complex rdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information read in */ - H5T_class_t mclass; /* Datatype class for VL */ - hsize_t sdims1[] = {SPACE1_DIM1}; /* Dataset dimensions */ - hsize_t tdims1[] = {ARRAY1_DIM1}; /* Array type dimensions */ - hid_t fid1; /* HDF5 File IDs */ - hid_t dataset; /* Dataset ID */ - hid_t sid1; /* Dataspace ID */ - hid_t tid1; /* Array Datatype ID */ - hid_t tid2; /* Complex Number Datatype ID */ - hid_t tid3; /* Atomic Datatype ID */ - int ndims; /* Array rank for reading */ - hsize_t rdims1[H5S_MAX_RANK]; /* Array dimensions for reading */ - herr_t ret; /* Generic return value */ + H5_float_complex wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */ + H5_float_complex rdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information read in */ + H5T_class_t mclass; /* Datatype class for VL */ + hsize_t sdims1[] = {SPACE1_DIM1}; /* Dataset dimensions */ + hsize_t tdims1[] = {ARRAY1_DIM1}; /* Array type dimensions */ + hid_t fid1; /* HDF5 File IDs */ + hid_t dataset; /* Dataset ID */ + hid_t sid1; /* Dataspace ID */ + hid_t tid1; /* Array Datatype ID */ + hid_t tid2; /* Complex Number Datatype ID */ + hid_t tid3; /* Atomic Datatype ID */ + int ndims; /* Array rank for reading */ + hsize_t rdims1[H5S_MAX_RANK]; /* Array dimensions for reading */ + herr_t ret; /* Generic return value */ /* Output message about test being performed */ MESSAGE(5, ("Testing 1-D Array of Complex Number Datatypes Functionality\n")); @@ -1615,7 +1611,7 @@ test_array_complex(void) /* Initialize array data to write */ for (size_t i = 0; i < SPACE1_DIM1; i++) for (size_t j = 0; j < ARRAY1_DIM1; j++) - wdata[i][j] = (float _Complex)((float)(i * 100) + ((float)(j * 10) * _Complex_I)); + wdata[i][j] = H5_CMPLXF((float)(i * 100), (float)(j * 10)); /* Create file */ fid1 = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); @@ -1723,7 +1719,7 @@ test_array_complex(void) /* Compare data read in */ for (size_t i = 0; i < SPACE1_DIM1; i++) { for (size_t j = 0; j < ARRAY1_DIM1; j++) { - if (0 != memcmp(&wdata[i][j], &rdata[i][j], sizeof(float _Complex))) + if (0 != memcmp(&wdata[i][j], &rdata[i][j], sizeof(H5_float_complex))) TestErrPrintf( "Complex number data doesn't match!, wdata[%d][%d]=%f%+fi, rdata[%d][%d]=%f%+fi\n", (int)i, (int)j, (double)crealf(wdata[i][j]), (double)cimagf(wdata[i][j]), (int)i, (int)j, diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c index 91aa20ea166..87710f1537e 100644 --- a/tools/lib/h5diff_array.c +++ b/tools/lib/h5diff_array.c @@ -16,10 +16,6 @@ #include "h5diff.h" #include "ph5diff.h" -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - #define ATTR_NAME_MAX 255 /*------------------------------------------------------------------------- @@ -420,8 +416,8 @@ diff_array(void *_mem1, void *_mem2, diff_opt_t *opts, hid_t container1_id, hid_ for (i = 0; i < opts->hs_nelmts; i++) { nfound += diff_float_complex_element(mem1, mem2, i, opts); - mem1 += sizeof(float _Complex); - mem2 += sizeof(float _Complex); + mem1 += sizeof(H5_float_complex); + mem2 += sizeof(H5_float_complex); if (opts->count_bool && nfound >= opts->count) return nfound; } @@ -430,8 +426,8 @@ diff_array(void *_mem1, void *_mem2, diff_opt_t *opts, hid_t container1_id, hid_ for (i = 0; i < opts->hs_nelmts; i++) { nfound += diff_double_complex_element(mem1, mem2, i, opts); - mem1 += sizeof(double _Complex); - mem2 += sizeof(double _Complex); + mem1 += sizeof(H5_double_complex); + mem2 += sizeof(H5_double_complex); if (opts->count_bool && nfound >= opts->count) return nfound; } @@ -440,8 +436,8 @@ diff_array(void *_mem1, void *_mem2, diff_opt_t *opts, hid_t container1_id, hid_ for (i = 0; i < opts->hs_nelmts; i++) { nfound += diff_ldouble_complex_element(mem1, mem2, i, opts); - mem1 += sizeof(long double _Complex); - mem2 += sizeof(long double _Complex); + mem1 += sizeof(H5_ldouble_complex); + mem2 += sizeof(H5_ldouble_complex); if (opts->count_bool && nfound >= opts->count) return nfound; } @@ -1217,19 +1213,19 @@ diff_datum(void *_mem1, void *_mem2, hsize_t elemtno, diff_opt_t *opts, hid_t co *------------------------------------------------------------------------- */ if (type_size == H5_SIZEOF_FLOAT_COMPLEX) { - if (type_size != sizeof(float _Complex)) - H5TOOLS_GOTO_ERROR(H5DIFF_ERR, "Type size is not float _Complex size"); + if (type_size != sizeof(H5_float_complex)) + H5TOOLS_GOTO_ERROR(H5DIFF_ERR, "Type size is not float complex size"); nfound += diff_float_complex_element(mem1, mem2, elemtno, opts); } else if (type_size == H5_SIZEOF_DOUBLE_COMPLEX) { - if (type_size != sizeof(double _Complex)) - H5TOOLS_GOTO_ERROR(H5DIFF_ERR, "Type size is not double _Complex size"); + if (type_size != sizeof(H5_double_complex)) + H5TOOLS_GOTO_ERROR(H5DIFF_ERR, "Type size is not double complex size"); nfound += diff_double_complex_element(mem1, mem2, elemtno, opts); } #if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE else if (type_size == H5_SIZEOF_LONG_DOUBLE_COMPLEX) { - if (type_size != sizeof(long double _Complex)) - H5TOOLS_GOTO_ERROR(H5DIFF_ERR, "Type size is not long double _Complex size"); + if (type_size != sizeof(H5_ldouble_complex)) + H5TOOLS_GOTO_ERROR(H5DIFF_ERR, "Type size is not long double complex size"); nfound += diff_ldouble_complex_element(mem1, mem2, elemtno, opts); } #endif @@ -2515,8 +2511,8 @@ diff_float16_element(unsigned char *mem1, unsigned char *mem2, hsize_t elem_idx, static hsize_t diff_float_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t elem_idx, diff_opt_t *opts) { - float _Complex temp1; - float _Complex temp2; + H5_float_complex temp1; + H5_float_complex temp2; hsize_t nfound = 0; /* number of differences found */ double per; float temp1_real, temp1_imag; @@ -2527,8 +2523,8 @@ diff_float_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t ele H5TOOLS_START_DEBUG("delta_bool:%d - percent_bool:%d", opts->delta_bool, opts->percent_bool); - memcpy(&temp1, mem1, sizeof(float _Complex)); - memcpy(&temp2, mem2, sizeof(float _Complex)); + memcpy(&temp1, mem1, sizeof(H5_float_complex)); + memcpy(&temp2, mem2, sizeof(H5_float_complex)); temp1_real = crealf(temp1); temp1_imag = cimagf(temp1); @@ -2733,8 +2729,8 @@ diff_float_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t ele static hsize_t diff_double_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t elem_idx, diff_opt_t *opts) { - double _Complex temp1; - double _Complex temp2; + H5_double_complex temp1; + H5_double_complex temp2; hsize_t nfound = 0; /* number of differences found */ double per; double temp1_real, temp1_imag; @@ -2745,8 +2741,8 @@ diff_double_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t el H5TOOLS_START_DEBUG("delta_bool:%d - percent_bool:%d", opts->delta_bool, opts->percent_bool); - memcpy(&temp1, mem1, sizeof(double _Complex)); - memcpy(&temp2, mem2, sizeof(double _Complex)); + memcpy(&temp1, mem1, sizeof(H5_double_complex)); + memcpy(&temp2, mem2, sizeof(H5_double_complex)); temp1_real = creal(temp1); temp1_imag = cimag(temp1); @@ -2937,8 +2933,8 @@ diff_double_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t el static hsize_t diff_ldouble_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t elem_idx, diff_opt_t *opts) { - long double _Complex temp1; - long double _Complex temp2; + H5_ldouble_complex temp1; + H5_ldouble_complex temp2; long double temp1_real, temp1_imag; long double temp2_real, temp2_imag; hsize_t nfound = 0; /* number of differences found */ @@ -2949,8 +2945,8 @@ diff_ldouble_complex_element(unsigned char *mem1, unsigned char *mem2, hsize_t e H5TOOLS_START_DEBUG("delta_bool:%d - percent_bool:%d", opts->delta_bool, opts->percent_bool); - memcpy(&temp1, mem1, sizeof(long double _Complex)); - memcpy(&temp2, mem2, sizeof(long double _Complex)); + memcpy(&temp1, mem1, sizeof(H5_ldouble_complex)); + memcpy(&temp2, mem2, sizeof(H5_ldouble_complex)); temp1_real = creall(temp1); temp1_imag = cimagl(temp1); diff --git a/tools/lib/h5tools.h b/tools/lib/h5tools.h index f52e5cd9e77..e9ec198b917 100644 --- a/tools/lib/h5tools.h +++ b/tools/lib/h5tools.h @@ -279,13 +279,16 @@ typedef struct h5tool_format_t { * typed `float'. The default is `%g'. * * fmt_float_complex: The printf() format to use when rendering data which is - * typed `float _Complex'. The default is `%g%+gi'. + * typed `float _Complex' / `_Fcomplex'. The default is + * `%g%+gi'. * * fmt_double_complex: The printf() format to use when rendering data which is - * typed `double _Complex'. The default is `%g%+gi'. + * typed `double _Complex' / `_Dcomplex'. The default is + * `%g%+gi'. * * fmt_ldouble_complex: The printf() format to use when rendering data which is - * typed `long double _Complex'. The default is `%Lg%+Lgi'. + * typed `long double _Complex' / `_Lcomplex'. The default + * is `%Lg%+Lgi'. * * ascii: If set then print 1-byte integer values as an ASCII * character (no quotes). If the character is one of the diff --git a/tools/lib/h5tools_str.c b/tools/lib/h5tools_str.c index bf5d6a402e8..60331f9174e 100644 --- a/tools/lib/h5tools_str.c +++ b/tools/lib/h5tools_str.c @@ -18,10 +18,6 @@ #include "h5tools_ref.h" #include "h5tools_str.h" /* function prototypes */ -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - /* Copied from hl/src/H5LDprivate.h */ /* Info about the list of comma-separated compound fields */ typedef struct H5LD_memb_t { @@ -1369,10 +1365,10 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai * number and print them in real+imaginary"i" format. */ if (H5Tequal(type, H5T_NATIVE_FLOAT_COMPLEX) == true) { - float _Complex fc; + H5_float_complex fc; float real, imag; - memcpy(&fc, vp, sizeof(float _Complex)); + memcpy(&fc, vp, sizeof(H5_float_complex)); real = crealf(fc); imag = cimagf(fc); @@ -1381,10 +1377,10 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai (double)imag); } else if (H5Tequal(type, H5T_NATIVE_DOUBLE_COMPLEX) == true) { - double _Complex dc; + H5_double_complex dc; double real, imag; - memcpy(&dc, vp, sizeof(double _Complex)); + memcpy(&dc, vp, sizeof(H5_double_complex)); real = creal(dc); imag = cimag(dc); @@ -1392,10 +1388,10 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai h5tools_str_append(str, OPT(info->fmt_double_complex, "%g%+gi"), real, imag); } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE_COMPLEX) == true) { - long double _Complex ldc; + H5_ldouble_complex ldc; long double real, imag; - memcpy(&ldc, vp, sizeof(long double _Complex)); + memcpy(&ldc, vp, sizeof(H5_ldouble_complex)); real = creall(ldc); imag = cimagl(ldc); diff --git a/tools/src/h5dump/h5dump.c b/tools/src/h5dump/h5dump.c index 5728d36f146..00c7df11303 100644 --- a/tools/src/h5dump/h5dump.c +++ b/tools/src/h5dump/h5dump.c @@ -1063,10 +1063,10 @@ parse_command_line(int argc, const char *const *argv) * Compose complex number printing format from fp_format. Ideally, * we'd like for a '+' or '-' to always be printed between the real * and imaginary parts, which is why the tools use a '+' flag in the - * default "%g%+gi" format for float _Complex and double _Complex. - * Check to see if fp_format has a '+' in it past the '%'. If so, - * just combine fp_format twice into a single printf format buffer. - * Otherwise, insert a '+' flag. + * default "%g%+gi" format for float _Complex / _Fcomplex and + * double _Complex / _Dcomplex. Check to see if fp_format has a '+' + * in it past the '%'. If so, just combine fp_format twice into a + * single printf format buffer. Otherwise, insert a '+' flag. */ if (NULL == (format_specifier = strstr(fp_format, "%"))) { error_msg("invalid floating-point format specifier (missing '%%')\n"); diff --git a/tools/src/h5dump/h5dump_xml.c b/tools/src/h5dump/h5dump_xml.c index dd8b4e9aba5..6ade4f42410 100644 --- a/tools/src/h5dump/h5dump_xml.c +++ b/tools/src/h5dump/h5dump_xml.c @@ -19,10 +19,6 @@ #include "h5dump_extern.h" #include "h5dump_xml.h" -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - const char *xmlnsprefix = "hdf5:"; /* @@ -3824,11 +3820,11 @@ xml_dump_fill_value(hid_t dcpl, hid_t type) #ifdef H5_HAVE_COMPLEX_NUMBERS if (H5Tequal(n_type, H5T_NATIVE_FLOAT_COMPLEX) == true) { - float _Complex fc; + H5_float_complex fc; float real, imag; char fmt_complex[32]; - memcpy(&fc, buf, sizeof(float _Complex)); + memcpy(&fc, buf, sizeof(H5_float_complex)); real = crealf(fc); imag = cimagf(fc); @@ -3842,11 +3838,11 @@ xml_dump_fill_value(hid_t dcpl, hid_t type) (size_t)outputformat->line_ncols, (hsize_t)0, (hsize_t)0); } else if (H5Tequal(n_type, H5T_NATIVE_DOUBLE_COMPLEX) == true) { - double _Complex dc; + H5_double_complex dc; double real, imag; char fmt_complex[32]; - memcpy(&dc, buf, sizeof(double _Complex)); + memcpy(&dc, buf, sizeof(H5_double_complex)); real = creal(dc); imag = cimag(dc); @@ -3860,11 +3856,11 @@ xml_dump_fill_value(hid_t dcpl, hid_t type) (size_t)outputformat->line_ncols, (hsize_t)0, (hsize_t)0); } else if (H5Tequal(n_type, H5T_NATIVE_LDOUBLE_COMPLEX) == true) { - long double _Complex ldc; + H5_ldouble_complex ldc; long double real, imag; char fmt_complex[32]; - memcpy(&ldc, buf, sizeof(long double _Complex)); + memcpy(&ldc, buf, sizeof(H5_ldouble_complex)); real = creall(ldc); imag = cimagl(ldc); diff --git a/tools/src/h5repack/h5repack_opttable.c b/tools/src/h5repack/h5repack_opttable.c index fdad8780654..cf5bc18241b 100644 --- a/tools/src/h5repack/h5repack_opttable.c +++ b/tools/src/h5repack/h5repack_opttable.c @@ -44,17 +44,17 @@ init_packobject(pack_info_t *obj) /*------------------------------------------------------------------------- * Function: aux_tblinsert_filter * - * Purpose: auxiliary function, inserts the filter in object OBJS[ I ] + * Purpose: auxiliary function, inserts the filter in object OBJS[ idx ] * * Return: void *------------------------------------------------------------------------- */ static void -aux_tblinsert_filter(pack_opttbl_t *table, unsigned int I, filter_info_t filt) +aux_tblinsert_filter(pack_opttbl_t *table, unsigned int idx, filter_info_t filt) { - if (table->objs[I].nfilters < H5_REPACK_MAX_NFILTERS) - table->objs[I].filter[table->objs[I].nfilters++] = filt; + if (table->objs[idx].nfilters < H5_REPACK_MAX_NFILTERS) + table->objs[idx].filter[table->objs[idx].nfilters++] = filt; else H5TOOLS_INFO("cannot insert the filter in this object. Maximum capacity exceeded"); } @@ -62,29 +62,29 @@ aux_tblinsert_filter(pack_opttbl_t *table, unsigned int I, filter_info_t filt) /*------------------------------------------------------------------------- * Function: aux_tblinsert_layout * - * Purpose: auxiliary function, inserts the layout in object OBJS[ I ] + * Purpose: auxiliary function, inserts the layout in object OBJS[ idx ] * * Return: void *------------------------------------------------------------------------- */ static void -aux_tblinsert_layout(pack_opttbl_t *table, unsigned int I, pack_info_t *pack) +aux_tblinsert_layout(pack_opttbl_t *table, unsigned int idx, pack_info_t *pack) { int k; - table->objs[I].layout = pack->layout; + table->objs[idx].layout = pack->layout; if (H5D_CHUNKED == pack->layout) { /* -2 means the NONE option, remove chunking and set the layout to contiguous */ if (pack->chunk.rank == -2) { - table->objs[I].layout = H5D_CONTIGUOUS; - table->objs[I].chunk.rank = -2; + table->objs[idx].layout = H5D_CONTIGUOUS; + table->objs[idx].chunk.rank = -2; } /* otherwise set the chunking type */ else { - table->objs[I].chunk.rank = pack->chunk.rank; + table->objs[idx].chunk.rank = pack->chunk.rank; for (k = 0; k < pack->chunk.rank; k++) - table->objs[I].chunk.chunk_lengths[k] = pack->chunk.chunk_lengths[k]; + table->objs[idx].chunk.chunk_lengths[k] = pack->chunk.chunk_lengths[k]; } } } @@ -179,7 +179,7 @@ options_table_free(pack_opttbl_t *table) int options_add_layout(obj_list_t *obj_list, unsigned n_objs, pack_info_t *pack, pack_opttbl_t *table) { - unsigned i, j, I; + unsigned i, j, idx; unsigned added = 0; bool found = false; int ret_value = 0; @@ -213,10 +213,10 @@ options_add_layout(obj_list_t *obj_list, unsigned n_objs, pack_info_t *pack, pac if (!found) { /* keep the grow in a temp var */ - I = table->nelems + added; + idx = table->nelems + added; added++; - strcpy(table->objs[I].path, obj_list[j].obj); - aux_tblinsert_layout(table, I, pack); + strcpy(table->objs[idx].path, obj_list[j].obj); + aux_tblinsert_layout(table, idx, pack); } /* cases where we have an already inserted name but there is a new name also example: @@ -225,10 +225,10 @@ options_add_layout(obj_list_t *obj_list, unsigned n_objs, pack_info_t *pack, pac */ else if (found && strcmp(obj_list[j].obj, table->objs[i].path) != 0) { /* keep the grow in a temp var */ - I = table->nelems + added; + idx = table->nelems + added; added++; - strcpy(table->objs[I].path, obj_list[j].obj); - aux_tblinsert_layout(table, I, pack); + strcpy(table->objs[idx].path, obj_list[j].obj); + aux_tblinsert_layout(table, idx, pack); } } /* j */ } @@ -236,10 +236,10 @@ options_add_layout(obj_list_t *obj_list, unsigned n_objs, pack_info_t *pack, pac else { /* go through the supplied list of names */ for (j = 0; j < n_objs; j++) { - I = table->nelems + added; + idx = table->nelems + added; added++; - strcpy(table->objs[I].path, obj_list[j].obj); - aux_tblinsert_layout(table, I, pack); + strcpy(table->objs[idx].path, obj_list[j].obj); + aux_tblinsert_layout(table, idx, pack); } } @@ -259,7 +259,7 @@ options_add_layout(obj_list_t *obj_list, unsigned n_objs, pack_info_t *pack, pac int options_add_filter(obj_list_t *obj_list, unsigned n_objs, filter_info_t filt, pack_opttbl_t *table) { - unsigned int i, j, I; + unsigned int i, j, idx; unsigned added = 0; bool found = false; @@ -285,10 +285,10 @@ options_add_filter(obj_list_t *obj_list, unsigned n_objs, filter_info_t filt, pa if (!found) { /* keep the grow in a temp var */ - I = table->nelems + added; + idx = table->nelems + added; added++; - strcpy(table->objs[I].path, obj_list[j].obj); - aux_tblinsert_filter(table, I, filt); + strcpy(table->objs[idx].path, obj_list[j].obj); + aux_tblinsert_filter(table, idx, filt); } /* cases where we have an already inserted name but there is a new name also example: @@ -297,10 +297,10 @@ options_add_filter(obj_list_t *obj_list, unsigned n_objs, filter_info_t filt, pa */ else if (found && strcmp(obj_list[j].obj, table->objs[i].path) != 0) { /* keep the grow in a temp var */ - I = table->nelems + added; + idx = table->nelems + added; added++; - strcpy(table->objs[I].path, obj_list[j].obj); - aux_tblinsert_filter(table, I, filt); + strcpy(table->objs[idx].path, obj_list[j].obj); + aux_tblinsert_filter(table, idx, filt); } } /* j */ } @@ -309,10 +309,10 @@ options_add_filter(obj_list_t *obj_list, unsigned n_objs, filter_info_t filt, pa else { /* go through the supplied list of names */ for (j = 0; j < n_objs; j++) { - I = table->nelems + added; + idx = table->nelems + added; added++; - strcpy(table->objs[I].path, obj_list[j].obj); - aux_tblinsert_filter(table, I, filt); + strcpy(table->objs[idx].path, obj_list[j].obj); + aux_tblinsert_filter(table, idx, filt); } } diff --git a/tools/test/h5dump/h5dumpgentest.c b/tools/test/h5dump/h5dumpgentest.c index 7aa50063f62..b7bf63e1996 100644 --- a/tools/test/h5dump/h5dumpgentest.c +++ b/tools/test/h5dump/h5dumpgentest.c @@ -24,10 +24,6 @@ #include "h5test.h" #include "h5tools.h" -#ifdef H5_HAVE_COMPLEX_NUMBERS -#include -#endif - #define FILE1 "tgroup.h5" #define FILE2 "tdset.h5" #define FILE3 "tattr.h5" @@ -12187,9 +12183,9 @@ gent_float16_be(void) static void gent_complex(void) { - long double _Complex ldc_fillval = -1.0L + 1.0L * (long double _Complex)_Complex_I; - double _Complex dc_fillval = -1.0 + 1.0 * (double _Complex)_Complex_I; - float _Complex fc_fillval = -1.0F + 1.0F * (float _Complex)_Complex_I; + H5_ldouble_complex ldc_fillval = H5_CMPLXL(-1.0L, 1.0L); + H5_double_complex dc_fillval = H5_CMPLX(-1.0, 1.0); + H5_float_complex fc_fillval = H5_CMPLXF(-1.0F, 1.0F); long double val_ldouble; double val_double; float val_float; @@ -12208,15 +12204,15 @@ gent_complex(void) hid_t single_space = H5I_INVALID_HID; struct { - float _Complex arr[F95_XDIM][F95_YDIM]; + H5_float_complex arr[F95_XDIM][F95_YDIM]; } * dset_fc; struct { - double _Complex arr[F95_XDIM][F95_YDIM]; + H5_double_complex arr[F95_XDIM][F95_YDIM]; } * dset_dc; struct { - long double _Complex arr[F95_XDIM][F95_YDIM]; + H5_ldouble_complex arr[F95_XDIM][F95_YDIM]; } * dset_ldc; struct { @@ -12231,7 +12227,7 @@ gent_complex(void) dcpl_id = H5Pcreate(H5P_DATASET_CREATE); - /* float _Complex dataset */ + /* float complex dataset */ H5Pset_fill_value(dcpl_id, H5T_NATIVE_FLOAT_COMPLEX, &fc_fillval); dataset = H5Dcreate2(fid, F95_DSET_FC, H5T_CPLX_IEEE_F32LE, space, H5P_DEFAULT, dcpl_id, H5P_DEFAULT); @@ -12240,14 +12236,12 @@ gent_complex(void) val_float = (float)F95_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_fc->arr[i][0] = (float _Complex)val_float; + dset_fc->arr[i][0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F95_YDIM; - - z = crealf(z) + z * _Complex_I; + float part_val = (float)(j * dims[0] + i) / (float)F95_YDIM; - dset_fc->arr[i][j] = z; + dset_fc->arr[i][j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12257,7 +12251,7 @@ gent_complex(void) free(dset_fc); - /* Create a float _Complex attribute on the dataset with a single value */ + /* Create a float complex attribute on the dataset with a single value */ single_space = H5Screate_simple(2, single_dims, NULL); attr = H5Acreate2(dataset, F95_ATTR_FC, H5T_CPLX_IEEE_F32LE, single_space, H5P_DEFAULT, H5P_DEFAULT); @@ -12268,7 +12262,7 @@ gent_complex(void) H5Aclose(attr); H5Dclose(dataset); - /* double _Complex dataset */ + /* double complex dataset */ H5Pset_fill_value(dcpl_id, H5T_NATIVE_DOUBLE_COMPLEX, &dc_fillval); dataset = H5Dcreate2(fid, F95_DSET_DC, H5T_CPLX_IEEE_F64LE, space, H5P_DEFAULT, dcpl_id, H5P_DEFAULT); @@ -12277,14 +12271,12 @@ gent_complex(void) val_double = (double)F95_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_dc->arr[i][0] = (double _Complex)val_double; + dset_dc->arr[i][0] = (H5_double_complex)val_double; for (size_t j = 1; j < dims[1]; j++) { - double _Complex z = (double)(j * dims[0] + i) / (double)F95_YDIM; + double part_val = (double)(j * dims[0] + i) / (double)F95_YDIM; - z = creal(z) + z * (double _Complex)_Complex_I; - - dset_dc->arr[i][j] = z; + dset_dc->arr[i][j] = H5_CMPLX(part_val, part_val); } val_double -= (double)1; @@ -12296,7 +12288,7 @@ gent_complex(void) H5Dclose(dataset); - /* long double _Complex dataset */ + /* long double complex dataset */ H5Pset_fill_value(dcpl_id, H5T_NATIVE_LDOUBLE_COMPLEX, &ldc_fillval); /* create an IEEE 128-bit little-endian float type */ @@ -12314,14 +12306,12 @@ gent_complex(void) val_ldouble = (long double)F95_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_ldc->arr[i][0] = (long double _Complex)val_ldouble; + dset_ldc->arr[i][0] = (H5_ldouble_complex)val_ldouble; for (size_t j = 1; j < dims[1]; j++) { - long double _Complex z = (long double)(j * dims[0] + i) / (long double)F95_YDIM; - - z = creall(z) + z * (long double _Complex)_Complex_I; + long double part_val = (long double)(j * dims[0] + i) / (long double)F95_YDIM; - dset_ldc->arr[i][j] = z; + dset_ldc->arr[i][j] = H5_CMPLXL(part_val, part_val); } val_ldouble -= (long double)1; @@ -12335,8 +12325,8 @@ gent_complex(void) H5Tclose(complex_tid); H5Dclose(dataset); - /* Compound of float _Complex dataset */ - mem_tid = H5Tcreate(H5T_COMPOUND, sizeof(float _Complex)); + /* Compound of float complex dataset */ + mem_tid = H5Tcreate(H5T_COMPOUND, sizeof(H5_float_complex)); H5Tinsert(mem_tid, "float_complex_mem", 0, H5T_NATIVE_FLOAT_COMPLEX); tid = H5Tcreate(H5T_COMPOUND, H5Tget_size(H5T_CPLX_IEEE_F32LE)); @@ -12348,14 +12338,12 @@ gent_complex(void) val_float = (float)F95_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_fc->arr[i][0] = (float _Complex)val_float; + dset_fc->arr[i][0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F95_YDIM; + float part_val = (float)(j * dims[0] + i) / (float)F95_YDIM; - z = crealf(z) + z * _Complex_I; - - dset_fc->arr[i][j] = z; + dset_fc->arr[i][j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12369,7 +12357,7 @@ gent_complex(void) H5Tclose(tid); H5Dclose(dataset); - /* Variable-length of float _Complex dataset */ + /* Variable-length of float complex dataset */ mem_tid = H5Tvlen_create(H5T_NATIVE_FLOAT_COMPLEX); tid = H5Tvlen_create(H5T_CPLX_IEEE_F32LE); @@ -12383,16 +12371,14 @@ gent_complex(void) val_float = (float)F95_YDIM; for (size_t i = 0; i < dims[0]; i++) { dset_var_fc->arr[i].len = dims[1]; - dset_var_fc->arr[i].p = malloc(dims[1] * sizeof(float _Complex)); + dset_var_fc->arr[i].p = malloc(dims[1] * sizeof(H5_float_complex)); - ((float _Complex *)dset_var_fc->arr[i].p)[0] = (float _Complex)val_float; + ((H5_float_complex *)dset_var_fc->arr[i].p)[0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F95_YDIM; - - z = crealf(z) + z * _Complex_I; + float part_val = (float)(j * dims[0] + i) / (float)F95_YDIM; - ((float _Complex *)dset_var_fc->arr[i].p)[j] = z; + ((H5_float_complex *)dset_var_fc->arr[i].p)[j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12408,7 +12394,7 @@ gent_complex(void) H5Tclose(tid); H5Dclose(dataset); - /* Array of float _Complex dataset */ + /* Array of float complex dataset */ mem_tid = H5Tarray_create2(H5T_NATIVE_FLOAT_COMPLEX, 2, dims); tid = H5Tarray_create2(H5T_CPLX_IEEE_F32LE, 2, dims); @@ -12421,14 +12407,12 @@ gent_complex(void) val_float = (float)F95_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_fc->arr[i][0] = (float _Complex)val_float; + dset_fc->arr[i][0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F95_YDIM; + float part_val = (float)(j * dims[0] + i) / (float)F95_YDIM; - z = crealf(z) + z * _Complex_I; - - dset_fc->arr[i][j] = z; + dset_fc->arr[i][j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12450,9 +12434,9 @@ gent_complex(void) static void gent_complex_be(void) { - long double _Complex ldc_fillval = -1.0L + 1.0L * (long double _Complex)_Complex_I; - double _Complex dc_fillval = -1.0 + 1.0 * (double _Complex)_Complex_I; - float _Complex fc_fillval = -1.0F + 1.0F * (float _Complex)_Complex_I; + H5_ldouble_complex ldc_fillval = H5_CMPLXL(-1.0L, 1.0L); + H5_double_complex dc_fillval = H5_CMPLX(-1.0, 1.0); + H5_float_complex fc_fillval = H5_CMPLXF(-1.0F, 1.0F); long double val_ldouble; double val_double; float val_float; @@ -12471,15 +12455,15 @@ gent_complex_be(void) hid_t single_space = H5I_INVALID_HID; struct { - float _Complex arr[F96_XDIM][F96_YDIM]; + H5_float_complex arr[F96_XDIM][F96_YDIM]; } * dset_fc; struct { - double _Complex arr[F96_XDIM][F96_YDIM]; + H5_double_complex arr[F96_XDIM][F96_YDIM]; } * dset_dc; struct { - long double _Complex arr[F96_XDIM][F96_YDIM]; + H5_ldouble_complex arr[F96_XDIM][F96_YDIM]; } * dset_ldc; struct { @@ -12494,7 +12478,7 @@ gent_complex_be(void) dcpl_id = H5Pcreate(H5P_DATASET_CREATE); - /* float _Complex dataset */ + /* float complex dataset */ H5Pset_fill_value(dcpl_id, H5T_NATIVE_FLOAT_COMPLEX, &fc_fillval); dataset = H5Dcreate2(fid, F96_DSET_FC, H5T_CPLX_IEEE_F32BE, space, H5P_DEFAULT, dcpl_id, H5P_DEFAULT); @@ -12503,14 +12487,12 @@ gent_complex_be(void) val_float = (float)F96_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_fc->arr[i][0] = (float _Complex)val_float; + dset_fc->arr[i][0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F96_YDIM; - - z = crealf(z) + z * _Complex_I; + float part_val = (float)(j * dims[0] + i) / (float)F96_YDIM; - dset_fc->arr[i][j] = z; + dset_fc->arr[i][j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12520,7 +12502,7 @@ gent_complex_be(void) free(dset_fc); - /* Create a float _Complex attribute on the dataset with a single value */ + /* Create a float complex attribute on the dataset with a single value */ single_space = H5Screate_simple(2, single_dims, NULL); attr = H5Acreate2(dataset, F96_ATTR_FC, H5T_CPLX_IEEE_F32BE, single_space, H5P_DEFAULT, H5P_DEFAULT); @@ -12531,7 +12513,7 @@ gent_complex_be(void) H5Aclose(attr); H5Dclose(dataset); - /* double _Complex dataset */ + /* double complex dataset */ H5Pset_fill_value(dcpl_id, H5T_NATIVE_DOUBLE_COMPLEX, &dc_fillval); dataset = H5Dcreate2(fid, F96_DSET_DC, H5T_CPLX_IEEE_F64BE, space, H5P_DEFAULT, dcpl_id, H5P_DEFAULT); @@ -12540,14 +12522,12 @@ gent_complex_be(void) val_double = (double)F96_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_dc->arr[i][0] = (double _Complex)val_double; + dset_dc->arr[i][0] = (H5_double_complex)val_double; for (size_t j = 1; j < dims[1]; j++) { - double _Complex z = (double)(j * dims[0] + i) / (double)F96_YDIM; + double part_val = (double)(j * dims[0] + i) / (double)F96_YDIM; - z = creal(z) + z * (double _Complex)_Complex_I; - - dset_dc->arr[i][j] = z; + dset_dc->arr[i][j] = H5_CMPLX(part_val, part_val); } val_double -= (double)1; @@ -12559,7 +12539,7 @@ gent_complex_be(void) H5Dclose(dataset); - /* long double _Complex dataset */ + /* long double complex dataset */ H5Pset_fill_value(dcpl_id, H5T_NATIVE_LDOUBLE_COMPLEX, &ldc_fillval); /* create an IEEE 128-bit big-endian float type */ @@ -12577,14 +12557,12 @@ gent_complex_be(void) val_ldouble = (long double)F96_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_ldc->arr[i][0] = (long double _Complex)val_ldouble; + dset_ldc->arr[i][0] = (H5_ldouble_complex)val_ldouble; for (size_t j = 1; j < dims[1]; j++) { - long double _Complex z = (long double)(j * dims[0] + i) / (long double)F96_YDIM; - - z = creall(z) + z * (long double _Complex)_Complex_I; + long double part_val = (long double)(j * dims[0] + i) / (long double)F96_YDIM; - dset_ldc->arr[i][j] = z; + dset_ldc->arr[i][j] = H5_CMPLXL(part_val, part_val); } val_ldouble -= (long double)1; @@ -12598,8 +12576,8 @@ gent_complex_be(void) H5Tclose(complex_tid); H5Dclose(dataset); - /* Compound of float _Complex dataset */ - mem_tid = H5Tcreate(H5T_COMPOUND, sizeof(float _Complex)); + /* Compound of float complex dataset */ + mem_tid = H5Tcreate(H5T_COMPOUND, sizeof(H5_float_complex)); H5Tinsert(mem_tid, "float_complex_mem", 0, H5T_NATIVE_FLOAT_COMPLEX); tid = H5Tcreate(H5T_COMPOUND, H5Tget_size(H5T_CPLX_IEEE_F32BE)); @@ -12611,14 +12589,12 @@ gent_complex_be(void) val_float = (float)F96_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_fc->arr[i][0] = (float _Complex)val_float; + dset_fc->arr[i][0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F96_YDIM; + float part_val = (float)(j * dims[0] + i) / (float)F96_YDIM; - z = crealf(z) + z * _Complex_I; - - dset_fc->arr[i][j] = z; + dset_fc->arr[i][j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12632,7 +12608,7 @@ gent_complex_be(void) H5Tclose(tid); H5Dclose(dataset); - /* Variable-length of float _Complex dataset */ + /* Variable-length of float complex dataset */ mem_tid = H5Tvlen_create(H5T_NATIVE_FLOAT_COMPLEX); tid = H5Tvlen_create(H5T_CPLX_IEEE_F32BE); @@ -12646,16 +12622,14 @@ gent_complex_be(void) val_float = (float)F96_YDIM; for (size_t i = 0; i < dims[0]; i++) { dset_var_fc->arr[i].len = dims[1]; - dset_var_fc->arr[i].p = malloc(dims[1] * sizeof(float _Complex)); + dset_var_fc->arr[i].p = malloc(dims[1] * sizeof(H5_float_complex)); - ((float _Complex *)dset_var_fc->arr[i].p)[0] = (float _Complex)val_float; + ((H5_float_complex *)dset_var_fc->arr[i].p)[0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F96_YDIM; - - z = crealf(z) + z * _Complex_I; + float part_val = (float)(j * dims[0] + i) / (float)F96_YDIM; - ((float _Complex *)dset_var_fc->arr[i].p)[j] = z; + ((H5_float_complex *)dset_var_fc->arr[i].p)[j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1; @@ -12671,7 +12645,7 @@ gent_complex_be(void) H5Tclose(tid); H5Dclose(dataset); - /* Array of float _Complex dataset */ + /* Array of float complex dataset */ mem_tid = H5Tarray_create2(H5T_NATIVE_FLOAT_COMPLEX, 2, dims); tid = H5Tarray_create2(H5T_CPLX_IEEE_F32BE, 2, dims); @@ -12684,14 +12658,12 @@ gent_complex_be(void) val_float = (float)F96_YDIM; for (size_t i = 0; i < dims[0]; i++) { - dset_fc->arr[i][0] = (float _Complex)val_float; + dset_fc->arr[i][0] = (H5_float_complex)val_float; for (size_t j = 1; j < dims[1]; j++) { - float _Complex z = (float)(j * dims[0] + i) / (float)F96_YDIM; - - z = crealf(z) + z * _Complex_I; + float part_val = (float)(j * dims[0] + i) / (float)F96_YDIM; - dset_fc->arr[i][j] = z; + dset_fc->arr[i][j] = H5_CMPLXF(part_val, part_val); } val_float -= (float)1;