.. _program_listing_file__tmp_ws_src_proxsuite_include_proxsuite_linalg_veg_internal_external_hedley.ext.hpp: Program Listing for File hedley.ext.hpp ======================================= |exhale_lsh| :ref:`Return to documentation for file ` (``/tmp/ws/src/proxsuite/include/proxsuite/linalg/veg/internal/external/hedley.ext.hpp``) .. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS .. code-block:: cpp /* Hedley - https://nemequ.github.io/hedley * Created by Evan Nemerson * * To the extent possible under law, the author(s) have dedicated all * copyright and related and neighboring rights to this software to * the public domain worldwide. This software is distributed without * any warranty. * * For details, see . * SPDX-License-Identifier: CC0-1.0 */ #if !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < 14) #if defined(HEDLEY_VERSION) #undef HEDLEY_VERSION #endif #define HEDLEY_VERSION 14 #if defined(HEDLEY_STRINGIFY_EX) #undef HEDLEY_STRINGIFY_EX #endif #define HEDLEY_STRINGIFY_EX(x) #x #if defined(HEDLEY_STRINGIFY) #undef HEDLEY_STRINGIFY #endif #define HEDLEY_STRINGIFY(x) HEDLEY_STRINGIFY_EX(x) #if defined(HEDLEY_CONCAT_EX) #undef HEDLEY_CONCAT_EX #endif #define HEDLEY_CONCAT_EX(a, b) a##b #if defined(HEDLEY_CONCAT) #undef HEDLEY_CONCAT #endif #define HEDLEY_CONCAT(a, b) HEDLEY_CONCAT_EX(a, b) #if defined(HEDLEY_CONCAT3_EX) #undef HEDLEY_CONCAT3_EX #endif #define HEDLEY_CONCAT3_EX(a, b, c) a##b##c #if defined(HEDLEY_CONCAT3) #undef HEDLEY_CONCAT3 #endif #define HEDLEY_CONCAT3(a, b, c) HEDLEY_CONCAT3_EX(a, b, c) #if defined(HEDLEY_VERSION_ENCODE) #undef HEDLEY_VERSION_ENCODE #endif #define HEDLEY_VERSION_ENCODE(major, minor, revision) \ (((major)*1000000) + ((minor)*1000) + (revision)) #if defined(HEDLEY_VERSION_DECODE_MAJOR) #undef HEDLEY_VERSION_DECODE_MAJOR #endif #define HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) #if defined(HEDLEY_VERSION_DECODE_MINOR) #undef HEDLEY_VERSION_DECODE_MINOR #endif #define HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) #if defined(HEDLEY_VERSION_DECODE_REVISION) #undef HEDLEY_VERSION_DECODE_REVISION #endif #define HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) #if defined(HEDLEY_GNUC_VERSION) #undef HEDLEY_GNUC_VERSION #endif #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) #define HEDLEY_GNUC_VERSION \ HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) #elif defined(__GNUC__) #define HEDLEY_GNUC_VERSION HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) #endif #if defined(HEDLEY_GNUC_VERSION_CHECK) #undef HEDLEY_GNUC_VERSION_CHECK #endif #if defined(HEDLEY_GNUC_VERSION) #define HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) \ (HEDLEY_GNUC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_MSVC_VERSION) #undef HEDLEY_MSVC_VERSION #endif #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) #define HEDLEY_MSVC_VERSION \ HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, \ (_MSC_FULL_VER % 10000000) / 100000, \ (_MSC_FULL_VER % 100000) / 100) #elif defined(_MSC_FULL_VER) && !defined(__ICL) #define HEDLEY_MSVC_VERSION \ HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, \ (_MSC_FULL_VER % 1000000) / 10000, \ (_MSC_FULL_VER % 10000) / 10) #elif defined(_MSC_VER) && !defined(__ICL) #define HEDLEY_MSVC_VERSION \ HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) #endif #if defined(HEDLEY_MSVC_VERSION_CHECK) #undef HEDLEY_MSVC_VERSION_CHECK #endif #if !defined(HEDLEY_MSVC_VERSION) #define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) (0) #elif defined(_MSC_VER) && (_MSC_VER >= 1400) #define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \ (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) #elif defined(_MSC_VER) && (_MSC_VER >= 1200) #define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \ (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) #else #define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \ (_MSC_VER >= ((major * 100) + (minor))) #endif #if defined(HEDLEY_INTEL_VERSION) #undef HEDLEY_INTEL_VERSION #endif #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && \ !defined(__ICL) #define HEDLEY_INTEL_VERSION \ HEDLEY_VERSION_ENCODE( \ __INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) #elif defined(__INTEL_COMPILER) && !defined(__ICL) #define HEDLEY_INTEL_VERSION \ HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) #endif #if defined(HEDLEY_INTEL_VERSION_CHECK) #undef HEDLEY_INTEL_VERSION_CHECK #endif #if defined(HEDLEY_INTEL_VERSION) #define HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) \ (HEDLEY_INTEL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_INTEL_CL_VERSION) #undef HEDLEY_INTEL_CL_VERSION #endif #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && \ defined(__ICL) #define HEDLEY_INTEL_CL_VERSION \ HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) #endif #if defined(HEDLEY_INTEL_CL_VERSION_CHECK) #undef HEDLEY_INTEL_CL_VERSION_CHECK #endif #if defined(HEDLEY_INTEL_CL_VERSION) #define HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) \ (HEDLEY_INTEL_CL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_PGI_VERSION) #undef HEDLEY_PGI_VERSION #endif #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && \ defined(__PGIC_PATCHLEVEL__) #define HEDLEY_PGI_VERSION \ HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) #endif #if defined(HEDLEY_PGI_VERSION_CHECK) #undef HEDLEY_PGI_VERSION_CHECK #endif #if defined(HEDLEY_PGI_VERSION) #define HEDLEY_PGI_VERSION_CHECK(major, minor, patch) \ (HEDLEY_PGI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_PGI_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_SUNPRO_VERSION) #undef HEDLEY_SUNPRO_VERSION #endif #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) #define HEDLEY_SUNPRO_VERSION \ HEDLEY_VERSION_ENCODE( \ (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \ (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), \ (__SUNPRO_C & 0xf) * 10) #elif defined(__SUNPRO_C) #define HEDLEY_SUNPRO_VERSION \ HEDLEY_VERSION_ENCODE( \ (__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C)&0xf) #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) #define HEDLEY_SUNPRO_VERSION \ HEDLEY_VERSION_ENCODE( \ (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \ (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), \ (__SUNPRO_CC & 0xf) * 10) #elif defined(__SUNPRO_CC) #define HEDLEY_SUNPRO_VERSION \ HEDLEY_VERSION_ENCODE( \ (__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC)&0xf) #endif #if defined(HEDLEY_SUNPRO_VERSION_CHECK) #undef HEDLEY_SUNPRO_VERSION_CHECK #endif #if defined(HEDLEY_SUNPRO_VERSION) #define HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) \ (HEDLEY_SUNPRO_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_EMSCRIPTEN_VERSION) #undef HEDLEY_EMSCRIPTEN_VERSION #endif #if defined(__EMSCRIPTEN__) #define HEDLEY_EMSCRIPTEN_VERSION \ HEDLEY_VERSION_ENCODE( \ __EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) #endif #if defined(HEDLEY_EMSCRIPTEN_VERSION_CHECK) #undef HEDLEY_EMSCRIPTEN_VERSION_CHECK #endif #if defined(HEDLEY_EMSCRIPTEN_VERSION) #define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) \ (HEDLEY_EMSCRIPTEN_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_ARM_VERSION) #undef HEDLEY_ARM_VERSION #endif #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) #define HEDLEY_ARM_VERSION \ HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, \ (__ARMCOMPILER_VERSION % 1000000) / 10000, \ (__ARMCOMPILER_VERSION % 10000) / 100) #elif defined(__CC_ARM) && defined(__ARMCC_VERSION) #define HEDLEY_ARM_VERSION \ HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, \ (__ARMCC_VERSION % 1000000) / 10000, \ (__ARMCC_VERSION % 10000) / 100) #endif #if defined(HEDLEY_ARM_VERSION_CHECK) #undef HEDLEY_ARM_VERSION_CHECK #endif #if defined(HEDLEY_ARM_VERSION) #define HEDLEY_ARM_VERSION_CHECK(major, minor, patch) \ (HEDLEY_ARM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_ARM_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_IBM_VERSION) #undef HEDLEY_IBM_VERSION #endif #if defined(__ibmxl__) #define HEDLEY_IBM_VERSION \ HEDLEY_VERSION_ENCODE( \ __ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) #elif defined(__xlC__) && defined(__xlC_ver__) #define HEDLEY_IBM_VERSION \ HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) #elif defined(__xlC__) #define HEDLEY_IBM_VERSION \ HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) #endif #if defined(HEDLEY_IBM_VERSION_CHECK) #undef HEDLEY_IBM_VERSION_CHECK #endif #if defined(HEDLEY_IBM_VERSION) #define HEDLEY_IBM_VERSION_CHECK(major, minor, patch) \ (HEDLEY_IBM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_IBM_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_VERSION) #undef HEDLEY_TI_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && \ (defined(__TMS470__) || defined(__TI_ARM__) || defined(__MSP430__) || \ defined(__TMS320C2000__)) #if (__TI_COMPILER_VERSION__ >= 16000000) #define HEDLEY_TI_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #endif #if defined(HEDLEY_TI_VERSION_CHECK) #undef HEDLEY_TI_VERSION_CHECK #endif #if defined(HEDLEY_TI_VERSION) #define HEDLEY_TI_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_CL2000_VERSION) #undef HEDLEY_TI_CL2000_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) #define HEDLEY_TI_CL2000_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL2000_VERSION_CHECK) #undef HEDLEY_TI_CL2000_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL2000_VERSION) #define HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_CL2000_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_CL430_VERSION) #undef HEDLEY_TI_CL430_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) #define HEDLEY_TI_CL430_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL430_VERSION_CHECK) #undef HEDLEY_TI_CL430_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL430_VERSION) #define HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_CL430_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_ARMCL_VERSION) #undef HEDLEY_TI_ARMCL_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && \ (defined(__TMS470__) || defined(__TI_ARM__)) #define HEDLEY_TI_ARMCL_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_ARMCL_VERSION_CHECK) #undef HEDLEY_TI_ARMCL_VERSION_CHECK #endif #if defined(HEDLEY_TI_ARMCL_VERSION) #define HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_ARMCL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_CL6X_VERSION) #undef HEDLEY_TI_CL6X_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) #define HEDLEY_TI_CL6X_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL6X_VERSION_CHECK) #undef HEDLEY_TI_CL6X_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL6X_VERSION) #define HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_CL6X_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_CL7X_VERSION) #undef HEDLEY_TI_CL7X_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) #define HEDLEY_TI_CL7X_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL7X_VERSION_CHECK) #undef HEDLEY_TI_CL7X_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL7X_VERSION) #define HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_CL7X_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TI_CLPRU_VERSION) #undef HEDLEY_TI_CLPRU_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) #define HEDLEY_TI_CLPRU_VERSION \ HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, \ (__TI_COMPILER_VERSION__ % 1000000) / 1000, \ (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CLPRU_VERSION_CHECK) #undef HEDLEY_TI_CLPRU_VERSION_CHECK #endif #if defined(HEDLEY_TI_CLPRU_VERSION) #define HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TI_CLPRU_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_CRAY_VERSION) #undef HEDLEY_CRAY_VERSION #endif #if defined(_CRAYC) #if defined(_RELEASE_PATCHLEVEL) #define HEDLEY_CRAY_VERSION \ HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) #else #define HEDLEY_CRAY_VERSION \ HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) #endif #endif #if defined(HEDLEY_CRAY_VERSION_CHECK) #undef HEDLEY_CRAY_VERSION_CHECK #endif #if defined(HEDLEY_CRAY_VERSION) #define HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) \ (HEDLEY_CRAY_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_IAR_VERSION) #undef HEDLEY_IAR_VERSION #endif #if defined(__IAR_SYSTEMS_ICC__) #if __VER__ > 1000 #define HEDLEY_IAR_VERSION \ HEDLEY_VERSION_ENCODE( \ (__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) #else #define HEDLEY_IAR_VERSION HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0) #endif #endif #if defined(HEDLEY_IAR_VERSION_CHECK) #undef HEDLEY_IAR_VERSION_CHECK #endif #if defined(HEDLEY_IAR_VERSION) #define HEDLEY_IAR_VERSION_CHECK(major, minor, patch) \ (HEDLEY_IAR_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_IAR_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_TINYC_VERSION) #undef HEDLEY_TINYC_VERSION #endif #if defined(__TINYC__) #define HEDLEY_TINYC_VERSION \ HEDLEY_VERSION_ENCODE( \ __TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) #endif #if defined(HEDLEY_TINYC_VERSION_CHECK) #undef HEDLEY_TINYC_VERSION_CHECK #endif #if defined(HEDLEY_TINYC_VERSION) #define HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) \ (HEDLEY_TINYC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_DMC_VERSION) #undef HEDLEY_DMC_VERSION #endif #if defined(__DMC__) #define HEDLEY_DMC_VERSION \ HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) #endif #if defined(HEDLEY_DMC_VERSION_CHECK) #undef HEDLEY_DMC_VERSION_CHECK #endif #if defined(HEDLEY_DMC_VERSION) #define HEDLEY_DMC_VERSION_CHECK(major, minor, patch) \ (HEDLEY_DMC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_DMC_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_COMPCERT_VERSION) #undef HEDLEY_COMPCERT_VERSION #endif #if defined(__COMPCERT_VERSION__) #define HEDLEY_COMPCERT_VERSION \ HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, \ (__COMPCERT_VERSION__ / 100) % 100, \ __COMPCERT_VERSION__ % 100) #endif #if defined(HEDLEY_COMPCERT_VERSION_CHECK) #undef HEDLEY_COMPCERT_VERSION_CHECK #endif #if defined(HEDLEY_COMPCERT_VERSION) #define HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) \ (HEDLEY_COMPCERT_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_PELLES_VERSION) #undef HEDLEY_PELLES_VERSION #endif #if defined(__POCC__) #define HEDLEY_PELLES_VERSION \ HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) #endif #if defined(HEDLEY_PELLES_VERSION_CHECK) #undef HEDLEY_PELLES_VERSION_CHECK #endif #if defined(HEDLEY_PELLES_VERSION) #define HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) \ (HEDLEY_PELLES_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_GCC_VERSION) #undef HEDLEY_GCC_VERSION #endif #if defined(HEDLEY_GNUC_VERSION) && !defined(__clang__) && \ !defined(HEDLEY_INTEL_VERSION) && !defined(HEDLEY_PGI_VERSION) && \ !defined(HEDLEY_ARM_VERSION) && !defined(HEDLEY_TI_VERSION) && \ !defined(HEDLEY_TI_ARMCL_VERSION) && !defined(HEDLEY_TI_CL430_VERSION) && \ !defined(HEDLEY_TI_CL2000_VERSION) && !defined(HEDLEY_TI_CL6X_VERSION) && \ !defined(HEDLEY_TI_CL7X_VERSION) && !defined(HEDLEY_TI_CLPRU_VERSION) && \ !defined(__COMPCERT__) #define HEDLEY_GCC_VERSION HEDLEY_GNUC_VERSION #endif #if defined(HEDLEY_GCC_VERSION_CHECK) #undef HEDLEY_GCC_VERSION_CHECK #endif #if defined(HEDLEY_GCC_VERSION) #define HEDLEY_GCC_VERSION_CHECK(major, minor, patch) \ (HEDLEY_GCC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define HEDLEY_GCC_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(HEDLEY_HAS_ATTRIBUTE) #undef HEDLEY_HAS_ATTRIBUTE #endif #if defined(__has_attribute) #define HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) #else #define HEDLEY_HAS_ATTRIBUTE(attribute) (0) #endif #if defined(HEDLEY_GNUC_HAS_ATTRIBUTE) #undef HEDLEY_GNUC_HAS_ATTRIBUTE #endif #if defined(__has_attribute) #define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \ __has_attribute(attribute) #else #define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_ATTRIBUTE) #undef HEDLEY_GCC_HAS_ATTRIBUTE #endif #if defined(__has_attribute) #define HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch) \ __has_attribute(attribute) #else #define HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_HAS_CPP_ATTRIBUTE) #undef HEDLEY_HAS_CPP_ATTRIBUTE #endif #if defined(__has_cpp_attribute) && defined(__cplusplus) && \ (!defined(HEDLEY_SUNPRO_VERSION) || HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0)) #define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) #else #define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) #endif #if defined(HEDLEY_HAS_CPP_ATTRIBUTE_NS) #undef HEDLEY_HAS_CPP_ATTRIBUTE_NS #endif #if !defined(__cplusplus) || !defined(__has_cpp_attribute) #define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0) #elif !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_IAR_VERSION) && \ (!defined(HEDLEY_SUNPRO_VERSION) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0)) && \ (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19, 20, 0)) #define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) \ HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) #else #define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0) #endif #if defined(HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) #undef HEDLEY_GNUC_HAS_CPP_ATTRIBUTE #endif #if defined(__has_cpp_attribute) && defined(__cplusplus) #define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \ __has_cpp_attribute(attribute) #else #define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_CPP_ATTRIBUTE) #undef HEDLEY_GCC_HAS_CPP_ATTRIBUTE #endif #if defined(__has_cpp_attribute) && defined(__cplusplus) #define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \ __has_cpp_attribute(attribute) #else #define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_HAS_BUILTIN) #undef HEDLEY_HAS_BUILTIN #endif #if defined(__has_builtin) #define HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) #else #define HEDLEY_HAS_BUILTIN(builtin) (0) #endif #if defined(HEDLEY_GNUC_HAS_BUILTIN) #undef HEDLEY_GNUC_HAS_BUILTIN #endif #if defined(__has_builtin) #define HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \ __has_builtin(builtin) #else #define HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_BUILTIN) #undef HEDLEY_GCC_HAS_BUILTIN #endif #if defined(__has_builtin) #define HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch) \ __has_builtin(builtin) #else #define HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_HAS_FEATURE) #undef HEDLEY_HAS_FEATURE #endif #if defined(__has_feature) #define HEDLEY_HAS_FEATURE(feature) __has_feature(feature) #else #define HEDLEY_HAS_FEATURE(feature) (0) #endif #if defined(HEDLEY_GNUC_HAS_FEATURE) #undef HEDLEY_GNUC_HAS_FEATURE #endif #if defined(__has_feature) #define HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch) \ __has_feature(feature) #else #define HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_FEATURE) #undef HEDLEY_GCC_HAS_FEATURE #endif #if defined(__has_feature) #define HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch) \ __has_feature(feature) #else #define HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_HAS_EXTENSION) #undef HEDLEY_HAS_EXTENSION #endif #if defined(__has_extension) #define HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) #else #define HEDLEY_HAS_EXTENSION(extension) (0) #endif #if defined(HEDLEY_GNUC_HAS_EXTENSION) #undef HEDLEY_GNUC_HAS_EXTENSION #endif #if defined(__has_extension) #define HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch) \ __has_extension(extension) #else #define HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_EXTENSION) #undef HEDLEY_GCC_HAS_EXTENSION #endif #if defined(__has_extension) #define HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch) \ __has_extension(extension) #else #define HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_HAS_DECLSPEC_ATTRIBUTE) #undef HEDLEY_HAS_DECLSPEC_ATTRIBUTE #endif #if defined(__has_declspec_attribute) #define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) \ __has_declspec_attribute(attribute) #else #define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) #endif #if defined(HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) #undef HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE #endif #if defined(__has_declspec_attribute) #define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \ __has_declspec_attribute(attribute) #else #define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) #undef HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE #endif #if defined(__has_declspec_attribute) #define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \ __has_declspec_attribute(attribute) #else #define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_HAS_WARNING) #undef HEDLEY_HAS_WARNING #endif #if defined(__has_warning) #define HEDLEY_HAS_WARNING(warning) __has_warning(warning) #else #define HEDLEY_HAS_WARNING(warning) (0) #endif #if defined(HEDLEY_GNUC_HAS_WARNING) #undef HEDLEY_GNUC_HAS_WARNING #endif #if defined(__has_warning) #define HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch) \ __has_warning(warning) #else #define HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch) \ HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_GCC_HAS_WARNING) #undef HEDLEY_GCC_HAS_WARNING #endif #if defined(__has_warning) #define HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch) \ __has_warning(warning) #else #define HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ defined(__clang__) || HEDLEY_GCC_VERSION_CHECK(3, 0, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || \ HEDLEY_PGI_VERSION_CHECK(18, 4, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) || \ HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 0, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \ HEDLEY_CRAY_VERSION_CHECK(5, 0, 0) || \ HEDLEY_TINYC_VERSION_CHECK(0, 9, 17) || \ HEDLEY_SUNPRO_VERSION_CHECK(8, 0, 0) || \ (HEDLEY_IBM_VERSION_CHECK(10, 1, 0) && defined(__C99_PRAGMA_OPERATOR)) #define HEDLEY_PRAGMA(value) _Pragma(#value) #elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) #define HEDLEY_PRAGMA(value) __pragma(value) #else #define HEDLEY_PRAGMA(value) #endif #if defined(HEDLEY_DIAGNOSTIC_PUSH) #undef HEDLEY_DIAGNOSTIC_PUSH #endif #if defined(HEDLEY_DIAGNOSTIC_POP) #undef HEDLEY_DIAGNOSTIC_POP #endif #if defined(__clang__) #define HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") #define HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") #elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") #define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") #elif HEDLEY_GCC_VERSION_CHECK(4, 6, 0) #define HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") #define HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") #elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) #define HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) #elif HEDLEY_ARM_VERSION_CHECK(5, 6, 0) #define HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") #define HEDLEY_DIAGNOSTIC_POP _Pragma("pop") #elif HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 4, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") #define HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") #elif HEDLEY_PELLES_VERSION_CHECK(2, 90, 0) #define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") #define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") #else #define HEDLEY_DIAGNOSTIC_PUSH #define HEDLEY_DIAGNOSTIC_POP #endif /* HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ #if defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) #undef HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ #endif #if defined(__cplusplus) #if HEDLEY_HAS_WARNING("-Wc++98-compat") #if HEDLEY_HAS_WARNING("-Wc++17-extensions") #if HEDLEY_HAS_WARNING("-Wc++1z-extensions") #define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ xpr HEDLEY_DIAGNOSTIC_POP #else #define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ xpr HEDLEY_DIAGNOSTIC_POP #endif #else #define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ xpr HEDLEY_DIAGNOSTIC_POP #endif #endif #endif #if !defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) #define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x #endif #if defined(HEDLEY_CONST_CAST) #undef HEDLEY_CONST_CAST #endif #if defined(__cplusplus) #define HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) #elif HEDLEY_HAS_WARNING("-Wcast-qual") || \ HEDLEY_GCC_VERSION_CHECK(4, 6, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_CONST_CAST(T, expr) \ (__extension__({ \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL((T)(expr)); \ HEDLEY_DIAGNOSTIC_POP \ })) #else #define HEDLEY_CONST_CAST(T, expr) ((T)(expr)) #endif #if defined(HEDLEY_REINTERPRET_CAST) #undef HEDLEY_REINTERPRET_CAST #endif #if defined(__cplusplus) #define HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) #else #define HEDLEY_REINTERPRET_CAST(T, expr) ((T)(expr)) #endif #if defined(HEDLEY_STATIC_CAST) #undef HEDLEY_STATIC_CAST #endif #if defined(__cplusplus) #define HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) #else #define HEDLEY_STATIC_CAST(T, expr) ((T)(expr)) #endif #if defined(HEDLEY_CPP_CAST) #undef HEDLEY_CPP_CAST #endif #if defined(__cplusplus) #if HEDLEY_HAS_WARNING("-Wold-style-cast") #define HEDLEY_CPP_CAST(T, expr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")((T)(expr)) \ HEDLEY_DIAGNOSTIC_POP #elif HEDLEY_IAR_VERSION_CHECK(8, 3, 0) #define HEDLEY_CPP_CAST(T, expr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("diag_suppress=Pe137") HEDLEY_DIAGNOSTIC_POP #else #define HEDLEY_CPP_CAST(T, expr) ((T)(expr)) #endif #else #define HEDLEY_CPP_CAST(T, expr) (expr) #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) #undef HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED #endif #if HEDLEY_HAS_WARNING("-Wdeprecated-declarations") #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") #elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("warning(disable:1478 1786)") #elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ __pragma(warning(disable : 1478 1786)) #elif HEDLEY_PGI_VERSION_CHECK(20, 7, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("diag_suppress 1215,1216,1444,1445") #elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") #elif HEDLEY_GCC_VERSION_CHECK(4, 3, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable : 4996)) #elif HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && !defined(__cplusplus) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && defined(__cplusplus) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("error_messages(off,symdeprecated,symdeprecated2)") #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \ _Pragma("diag_suppress=Pe1444,Pe1215") #elif HEDLEY_PELLES_VERSION_CHECK(2, 90, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") #else #define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) #undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS #endif #if HEDLEY_HAS_WARNING("-Wunknown-pragmas") #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") #elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ _Pragma("warning(disable:161)") #elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ __pragma(warning(disable : 161)) #elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") #elif HEDLEY_GCC_VERSION_CHECK(4, 3, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") #elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ __pragma(warning(disable : 4068)) #elif HEDLEY_TI_VERSION_CHECK(16, 9, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") #elif HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") #else #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) #undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES #endif #if HEDLEY_HAS_WARNING("-Wunknown-attributes") #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") #elif HEDLEY_GCC_VERSION_CHECK(4, 6, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #elif HEDLEY_INTEL_VERSION_CHECK(17, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("warning(disable:1292)") #elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ __pragma(warning(disable : 1292)) #elif HEDLEY_MSVC_VERSION_CHECK(19, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ __pragma(warning(disable : 5030)) #elif HEDLEY_PGI_VERSION_CHECK(20, 7, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("diag_suppress 1097,1098") #elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("diag_suppress 1097") #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("error_messages(off,attrskipunsup)") #elif HEDLEY_TI_VERSION_CHECK(18, 1, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("diag_suppress 1173") #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \ _Pragma("diag_suppress=Pe1097") #else #define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) #undef HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL #endif #if HEDLEY_HAS_WARNING("-Wcast-qual") #define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ _Pragma("clang diagnostic ignored \"-Wcast-qual\"") #elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ _Pragma("warning(disable:2203 2331)") #elif HEDLEY_GCC_VERSION_CHECK(3, 0, 0) #define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") #else #define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL #endif #if defined(HEDLEY_DEPRECATED) #undef HEDLEY_DEPRECATED #endif #if defined(HEDLEY_DEPRECATED_FOR) #undef HEDLEY_DEPRECATED_FOR #endif #if HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " #since)) #define HEDLEY_DEPRECATED_FOR(since, replacement) \ __declspec(deprecated("Since " #since "; use " #replacement)) #elif HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \ HEDLEY_GCC_VERSION_CHECK(4, 5, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_ARM_VERSION_CHECK(5, 6, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) || \ HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || HEDLEY_TI_VERSION_CHECK(18, 1, 0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(18, 1, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0) #define HEDLEY_DEPRECATED(since) \ __attribute__((__deprecated__("Since " #since))) #define HEDLEY_DEPRECATED_FOR(since, replacement) \ __attribute__((__deprecated__("Since " #since "; use " #replacement))) #elif defined(__cplusplus) && (__cplusplus >= 201402L) #define HEDLEY_DEPRECATED(since) \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since" \ " " #since)]]) #define HEDLEY_DEPRECATED_FOR(since, replacement) \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_( \ [[deprecated("Since " #since "; use " #replacement)]]) #elif HEDLEY_HAS_ATTRIBUTE(deprecated) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) #define HEDLEY_DEPRECATED_FOR(since, replacement) \ __attribute__((__deprecated__)) #elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || \ HEDLEY_PELLES_VERSION_CHECK(6, 50, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_DEPRECATED(since) __declspec(deprecated) #define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_DEPRECATED(since) _Pragma("deprecated") #define HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") #else #define HEDLEY_DEPRECATED(since) #define HEDLEY_DEPRECATED_FOR(since, replacement) #endif #if defined(HEDLEY_UNAVAILABLE) #undef HEDLEY_UNAVAILABLE #endif #if HEDLEY_HAS_ATTRIBUTE(warning) || HEDLEY_GCC_VERSION_CHECK(4, 3, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_UNAVAILABLE(available_since) \ __attribute__((__warning__("Not available until " #available_since))) #else #define HEDLEY_UNAVAILABLE(available_since) #endif #if defined(HEDLEY_WARN_UNUSED_RESULT) #undef HEDLEY_WARN_UNUSED_RESULT #endif #if defined(HEDLEY_WARN_UNUSED_RESULT_MSG) #undef HEDLEY_WARN_UNUSED_RESULT_MSG #endif #if HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) || \ HEDLEY_PGI_VERSION_CHECK(17, 10, 0) #define HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) #define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) \ __attribute__((__warn_unused_result__)) #elif (HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) #define HEDLEY_WARN_UNUSED_RESULT \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) #define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) #elif HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) #define HEDLEY_WARN_UNUSED_RESULT \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) #define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) #elif defined(_Check_return_) /* SAL */ #define HEDLEY_WARN_UNUSED_RESULT _Check_return_ #define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ #else #define HEDLEY_WARN_UNUSED_RESULT #define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) #endif #if defined(HEDLEY_SENTINEL) #undef HEDLEY_SENTINEL #endif #if HEDLEY_HAS_ATTRIBUTE(sentinel) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_ARM_VERSION_CHECK(5, 4, 0) #define HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) #else #define HEDLEY_SENTINEL(position) #endif #if defined(HEDLEY_NO_RETURN) #undef HEDLEY_NO_RETURN #endif #if HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_NO_RETURN __noreturn #elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_NO_RETURN __attribute__((__noreturn__)) #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #define HEDLEY_NO_RETURN _Noreturn #elif defined(__cplusplus) && (__cplusplus >= 201103L) #define HEDLEY_NO_RETURN \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) #elif HEDLEY_HAS_ATTRIBUTE(noreturn) || HEDLEY_GCC_VERSION_CHECK(3, 2, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_NO_RETURN __attribute__((__noreturn__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) #define HEDLEY_NO_RETURN _Pragma("does_not_return") #elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_NO_RETURN __declspec(noreturn) #elif HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus) #define HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") #elif HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0) #define HEDLEY_NO_RETURN __attribute((noreturn)) #elif HEDLEY_PELLES_VERSION_CHECK(9, 0, 0) #define HEDLEY_NO_RETURN __declspec(noreturn) #else #define HEDLEY_NO_RETURN #endif #if defined(HEDLEY_NO_ESCAPE) #undef HEDLEY_NO_ESCAPE #endif #if HEDLEY_HAS_ATTRIBUTE(noescape) #define HEDLEY_NO_ESCAPE __attribute__((__noescape__)) #else #define HEDLEY_NO_ESCAPE #endif #if defined(HEDLEY_UNREACHABLE) #undef HEDLEY_UNREACHABLE #endif #if defined(HEDLEY_UNREACHABLE_RETURN) #undef HEDLEY_UNREACHABLE_RETURN #endif #if defined(HEDLEY_ASSUME) #undef HEDLEY_ASSUME #endif #if HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_ASSUME(expr) __assume(expr) #elif HEDLEY_HAS_BUILTIN(__builtin_assume) #define HEDLEY_ASSUME(expr) __builtin_assume(expr) #elif HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) #if defined(__cplusplus) #define HEDLEY_ASSUME(expr) std::_nassert(expr) #else #define HEDLEY_ASSUME(expr) _nassert(expr) #endif #endif #if (HEDLEY_HAS_BUILTIN(__builtin_unreachable) && \ (!defined(HEDLEY_ARM_VERSION))) || \ HEDLEY_GCC_VERSION_CHECK(4, 5, 0) || HEDLEY_PGI_VERSION_CHECK(18, 10, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_IBM_VERSION_CHECK(13, 1, 5) #define HEDLEY_UNREACHABLE() __builtin_unreachable() #elif defined(HEDLEY_ASSUME) #define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0) #endif #if !defined(HEDLEY_ASSUME) #if defined(HEDLEY_UNREACHABLE) #define HEDLEY_ASSUME(expr) \ HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (HEDLEY_UNREACHABLE(), 1))) #else #define HEDLEY_ASSUME(expr) HEDLEY_STATIC_CAST(void, expr) #endif #endif #if defined(HEDLEY_UNREACHABLE) #if HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) #define HEDLEY_UNREACHABLE_RETURN(value) \ return (HEDLEY_STATIC_CAST(void, HEDLEY_ASSUME(0)), (value)) #else #define HEDLEY_UNREACHABLE_RETURN(value) HEDLEY_UNREACHABLE() #endif #else #define HEDLEY_UNREACHABLE_RETURN(value) return (value) #endif #if !defined(HEDLEY_UNREACHABLE) #define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0) #endif HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wpedantic") #pragma clang diagnostic ignored "-Wpedantic" #endif #if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" #endif #if HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros", 4, 0, 0) #if defined(__clang__) #pragma clang diagnostic ignored "-Wvariadic-macros" #elif defined(HEDLEY_GCC_VERSION) #pragma GCC diagnostic ignored "-Wvariadic-macros" #endif #endif #if defined(HEDLEY_NON_NULL) #undef HEDLEY_NON_NULL #endif #if HEDLEY_HAS_ATTRIBUTE(nonnull) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) #define HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) #else #define HEDLEY_NON_NULL(...) #endif HEDLEY_DIAGNOSTIC_POP #if defined(HEDLEY_PRINTF_FORMAT) #undef HEDLEY_PRINTF_FORMAT #endif #if defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) && \ !defined(__USE_MINGW_ANSI_STDIO) #define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \ __attribute__((__format__(ms_printf, string_idx, first_to_check))) #elif defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) && \ defined(__USE_MINGW_ANSI_STDIO) #define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \ __attribute__((__format__(gnu_printf, string_idx, first_to_check))) #elif HEDLEY_HAS_ATTRIBUTE(format) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_ARM_VERSION_CHECK(5, 6, 0) || \ HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \ __attribute__((__format__(__printf__, string_idx, first_to_check))) #elif HEDLEY_PELLES_VERSION_CHECK(6, 0, 0) #define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \ __declspec(vaformat(printf, string_idx, first_to_check)) #else #define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) #endif #if defined(HEDLEY_CONSTEXPR) #undef HEDLEY_CONSTEXPR #endif #if defined(__cplusplus) #if __cplusplus >= 201103L #define HEDLEY_CONSTEXPR HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) #endif #endif #if !defined(HEDLEY_CONSTEXPR) #define HEDLEY_CONSTEXPR #endif #if defined(HEDLEY_PREDICT) #undef HEDLEY_PREDICT #endif #if defined(HEDLEY_LIKELY) #undef HEDLEY_LIKELY #endif #if defined(HEDLEY_UNLIKELY) #undef HEDLEY_UNLIKELY #endif #if defined(HEDLEY_UNPREDICTABLE) #undef HEDLEY_UNPREDICTABLE #endif #if HEDLEY_HAS_BUILTIN(__builtin_unpredictable) #define HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) #endif #if (HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && \ !defined(HEDLEY_PGI_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(9, 0, 0) #define HEDLEY_PREDICT(expr, value, probability) \ __builtin_expect_with_probability((expr), (value), (probability)) #define HEDLEY_PREDICT_TRUE(expr, probability) \ __builtin_expect_with_probability(!!(expr), 1, (probability)) #define HEDLEY_PREDICT_FALSE(expr, probability) \ __builtin_expect_with_probability(!!(expr), 0, (probability)) #define HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) #define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) #elif (HEDLEY_HAS_BUILTIN(__builtin_expect) && \ !defined(HEDLEY_INTEL_CL_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(3, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) || \ HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \ HEDLEY_TINYC_VERSION_CHECK(0, 9, 27) || HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) #define HEDLEY_PREDICT(expr, expected, probability) \ (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) \ : (HEDLEY_STATIC_CAST(void, expected), (expr))) #define HEDLEY_PREDICT_TRUE(expr, probability) \ (__extension__({ \ double hedley_probability_ = (probability); \ ((hedley_probability_ >= 0.9) \ ? __builtin_expect(!!(expr), 1) \ : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) \ : !!(expr))); \ })) #define HEDLEY_PREDICT_FALSE(expr, probability) \ (__extension__({ \ double hedley_probability_ = (probability); \ ((hedley_probability_ >= 0.9) \ ? __builtin_expect(!!(expr), 0) \ : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) \ : !!(expr))); \ })) #define HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) #define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) #else #define HEDLEY_PREDICT(expr, expected, probability) \ (HEDLEY_STATIC_CAST(void, expected), (expr)) #define HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) #define HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) #define HEDLEY_LIKELY(expr) (!!(expr)) #define HEDLEY_UNLIKELY(expr) (!!(expr)) #endif #if !defined(HEDLEY_UNPREDICTABLE) #define HEDLEY_UNPREDICTABLE(expr) HEDLEY_PREDICT(expr, 1, 0.5) #endif #if defined(HEDLEY_MALLOC) #undef HEDLEY_MALLOC #endif #if HEDLEY_HAS_ATTRIBUTE(malloc) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(12, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_MALLOC __attribute__((__malloc__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) #define HEDLEY_MALLOC _Pragma("returns_new_memory") #elif HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_MALLOC __declspec(restrict) #else #define HEDLEY_MALLOC #endif #if defined(HEDLEY_PURE) #undef HEDLEY_PURE #endif #if HEDLEY_HAS_ATTRIBUTE(pure) || HEDLEY_GCC_VERSION_CHECK(2, 96, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \ HEDLEY_PGI_VERSION_CHECK(17, 10, 0) #define HEDLEY_PURE __attribute__((__pure__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) #define HEDLEY_PURE _Pragma("does_not_write_global_data") #elif defined(__cplusplus) && (HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) || \ HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)) #define HEDLEY_PURE _Pragma("FUNC_IS_PURE;") #else #define HEDLEY_PURE #endif #if defined(HEDLEY_CONST) #undef HEDLEY_CONST #endif #if HEDLEY_HAS_ATTRIBUTE(const) || HEDLEY_GCC_VERSION_CHECK(2, 5, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \ HEDLEY_PGI_VERSION_CHECK(17, 10, 0) #define HEDLEY_CONST __attribute__((__const__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) #define HEDLEY_CONST _Pragma("no_side_effect") #else #define HEDLEY_CONST HEDLEY_PURE #endif #if defined(HEDLEY_RESTRICT) #undef HEDLEY_RESTRICT #endif #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ !defined(__cplusplus) #define HEDLEY_RESTRICT restrict #elif HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || \ HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 4) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)) || \ HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || defined(__clang__) #define HEDLEY_RESTRICT __restrict #elif HEDLEY_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus) #define HEDLEY_RESTRICT _Restrict #else #define HEDLEY_RESTRICT #endif #if defined(HEDLEY_INLINE) #undef HEDLEY_INLINE #endif #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ (defined(__cplusplus) && (__cplusplus >= 199711L)) #define HEDLEY_INLINE inline #elif defined(HEDLEY_GCC_VERSION) || HEDLEY_ARM_VERSION_CHECK(6, 2, 0) #define HEDLEY_INLINE __inline__ #elif HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 1, 0) || \ HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_INLINE __inline #else #define HEDLEY_INLINE #endif #if defined(HEDLEY_ALWAYS_INLINE) #undef HEDLEY_ALWAYS_INLINE #endif #if HEDLEY_HAS_ATTRIBUTE(always_inline) || \ HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) HEDLEY_INLINE #elif HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_ALWAYS_INLINE __forceinline #elif defined(__cplusplus) && (HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)) #define HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") #else #define HEDLEY_ALWAYS_INLINE HEDLEY_INLINE #endif #if defined(HEDLEY_NEVER_INLINE) #undef HEDLEY_NEVER_INLINE #endif #if HEDLEY_HAS_ATTRIBUTE(noinline) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || \ HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) #define HEDLEY_NEVER_INLINE __attribute__((__noinline__)) #elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_NEVER_INLINE __declspec(noinline) #elif HEDLEY_PGI_VERSION_CHECK(10, 2, 0) #define HEDLEY_NEVER_INLINE _Pragma("noinline") #elif HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus) #define HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_NEVER_INLINE _Pragma("inline=never") #elif HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0) #define HEDLEY_NEVER_INLINE __attribute((noinline)) #elif HEDLEY_PELLES_VERSION_CHECK(9, 0, 0) #define HEDLEY_NEVER_INLINE __declspec(noinline) #else #define HEDLEY_NEVER_INLINE #endif #if defined(HEDLEY_PRIVATE) #undef HEDLEY_PRIVATE #endif #if defined(HEDLEY_PUBLIC) #undef HEDLEY_PUBLIC #endif #if defined(HEDLEY_IMPORT) #undef HEDLEY_IMPORT #endif #if defined(_WIN32) || defined(__CYGWIN__) #define HEDLEY_PRIVATE #define HEDLEY_PUBLIC __declspec(dllexport) #define HEDLEY_IMPORT __declspec(dllimport) #else #if HEDLEY_HAS_ATTRIBUTE(visibility) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \ HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || \ (defined(__TI_EABI__) && ((HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \ defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0))) #define HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) #define HEDLEY_PUBLIC __attribute__((__visibility__("default"))) #else #define HEDLEY_PRIVATE #define HEDLEY_PUBLIC #endif #define HEDLEY_IMPORT extern #endif #if defined(HEDLEY_NO_THROW) #undef HEDLEY_NO_THROW #endif #if HEDLEY_HAS_ATTRIBUTE(nothrow) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_NO_THROW __attribute__((__nothrow__)) #elif HEDLEY_MSVC_VERSION_CHECK(13, 1, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || \ HEDLEY_ARM_VERSION_CHECK(4, 1, 0) #define HEDLEY_NO_THROW __declspec(nothrow) #else #define HEDLEY_NO_THROW #endif #if defined(HEDLEY_FALL_THROUGH) #undef HEDLEY_FALL_THROUGH #endif #if HEDLEY_HAS_ATTRIBUTE(fallthrough) || HEDLEY_GCC_VERSION_CHECK(7, 0, 0) #define HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) #elif HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang, fallthrough) #define HEDLEY_FALL_THROUGH \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) #elif HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) #define HEDLEY_FALL_THROUGH \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) #elif defined(__fallthrough) /* SAL */ #define HEDLEY_FALL_THROUGH __fallthrough #else #define HEDLEY_FALL_THROUGH #endif #if defined(HEDLEY_RETURNS_NON_NULL) #undef HEDLEY_RETURNS_NON_NULL #endif #if HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || HEDLEY_GCC_VERSION_CHECK(4, 9, 0) #define HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) #elif defined(_Ret_notnull_) /* SAL */ #define HEDLEY_RETURNS_NON_NULL _Ret_notnull_ #else #define HEDLEY_RETURNS_NON_NULL #endif #if defined(HEDLEY_ARRAY_PARAM) #undef HEDLEY_ARRAY_PARAM #endif #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ !defined(__STDC_NO_VLA__) && !defined(__cplusplus) && \ !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_TINYC_VERSION) #define HEDLEY_ARRAY_PARAM(name) (name) #else #define HEDLEY_ARRAY_PARAM(name) #endif #if defined(HEDLEY_IS_CONSTANT) #undef HEDLEY_IS_CONSTANT #endif #if defined(HEDLEY_REQUIRE_CONSTEXPR) #undef HEDLEY_REQUIRE_CONSTEXPR #endif /* HEDLEY_IS_CONSTEXPR_ is for HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ #if defined(HEDLEY_IS_CONSTEXPR_) #undef HEDLEY_IS_CONSTEXPR_ #endif #if HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_TINYC_VERSION_CHECK(0, 9, 19) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \ HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) && !defined(__cplusplus)) || \ HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) #define HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) #endif #if !defined(__cplusplus) #if HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \ HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) || \ HEDLEY_ARM_VERSION_CHECK(5, 4, 0) || HEDLEY_TINYC_VERSION_CHECK(0, 9, 24) #if defined(__INTPTR_TYPE__) #define HEDLEY_IS_CONSTEXPR_(expr) \ __builtin_types_compatible_p( \ __typeof__((1 ? (void*)((__INTPTR_TYPE__)((expr)*0)) : (int*)0)), int*) #else #include #define HEDLEY_IS_CONSTEXPR_(expr) \ __builtin_types_compatible_p( \ __typeof__((1 ? (void*)((intptr_t)((expr)*0)) : (int*)0)), int*) #endif #elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ !defined(HEDLEY_SUNPRO_VERSION) && !defined(HEDLEY_PGI_VERSION) && \ !defined(HEDLEY_IAR_VERSION)) || \ HEDLEY_HAS_EXTENSION(c_generic_selections) || \ HEDLEY_GCC_VERSION_CHECK(4, 9, 0) || HEDLEY_INTEL_VERSION_CHECK(17, 0, 0) || \ HEDLEY_IBM_VERSION_CHECK(12, 1, 0) || HEDLEY_ARM_VERSION_CHECK(5, 3, 0) #if defined(__INTPTR_TYPE__) #define HEDLEY_IS_CONSTEXPR_(expr) \ _Generic((1 ? (void*)((__INTPTR_TYPE__)((expr)*0)) : (int*)0), \ int*: 1, \ void*: 0) #else #include #define HEDLEY_IS_CONSTEXPR_(expr) \ _Generic((1 ? (void*)((intptr_t)*0) : (int*)0), int*: 1, void*: 0) #endif #elif defined(HEDLEY_GCC_VERSION) || defined(HEDLEY_INTEL_VERSION) || \ defined(HEDLEY_TINYC_VERSION) || defined(HEDLEY_TI_ARMCL_VERSION) || \ HEDLEY_TI_CL430_VERSION_CHECK(18, 12, 0) || \ defined(HEDLEY_TI_CL2000_VERSION) || defined(HEDLEY_TI_CL6X_VERSION) || \ defined(HEDLEY_TI_CL7X_VERSION) || defined(HEDLEY_TI_CLPRU_VERSION) || \ defined(__clang__) #define HEDLEY_IS_CONSTEXPR_(expr) \ (sizeof(void) != sizeof(*(1 ? ((void*)((expr)*0L)) \ : ((struct { char v[sizeof(void) * 2]; }*)1)))) #endif #endif #if defined(HEDLEY_IS_CONSTEXPR_) #if !defined(HEDLEY_IS_CONSTANT) #define HEDLEY_IS_CONSTANT(expr) HEDLEY_IS_CONSTEXPR_(expr) #endif #define HEDLEY_REQUIRE_CONSTEXPR(expr) \ (HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) #else #if !defined(HEDLEY_IS_CONSTANT) #define HEDLEY_IS_CONSTANT(expr) (0) #endif #define HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) #endif #if defined(HEDLEY_BEGIN_C_DECLS) #undef HEDLEY_BEGIN_C_DECLS #endif #if defined(HEDLEY_END_C_DECLS) #undef HEDLEY_END_C_DECLS #endif #if defined(HEDLEY_C_DECL) #undef HEDLEY_C_DECL #endif #if defined(__cplusplus) #define HEDLEY_BEGIN_C_DECLS \ extern "C" \ { #define HEDLEY_END_C_DECLS } #define HEDLEY_C_DECL extern "C" #else #define HEDLEY_BEGIN_C_DECLS #define HEDLEY_END_C_DECLS #define HEDLEY_C_DECL #endif #if defined(HEDLEY_STATIC_ASSERT) #undef HEDLEY_STATIC_ASSERT #endif #if !defined(__cplusplus) && \ ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ (HEDLEY_HAS_FEATURE(c_static_assert) && \ !defined(HEDLEY_INTEL_CL_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(6, 0, 0) || \ HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || defined(_Static_assert)) #define HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) #elif (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ HEDLEY_MSVC_VERSION_CHECK(16, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_STATIC_ASSERT(expr, message) \ HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) #else #define HEDLEY_STATIC_ASSERT(expr, message) #endif #if defined(HEDLEY_NULL) #undef HEDLEY_NULL #endif #if defined(__cplusplus) #if __cplusplus >= 201103L #define HEDLEY_NULL HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) #elif defined(NULL) #define HEDLEY_NULL NULL #else #define HEDLEY_NULL HEDLEY_STATIC_CAST(void*, 0) #endif #elif defined(NULL) #define HEDLEY_NULL NULL #else #define HEDLEY_NULL ((void*)0) #endif #if defined(HEDLEY_MESSAGE) #undef HEDLEY_MESSAGE #endif #if HEDLEY_HAS_WARNING("-Wunknown-pragmas") #define HEDLEY_MESSAGE(msg) \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ HEDLEY_PRAGMA(message msg) \ HEDLEY_DIAGNOSTIC_POP #elif HEDLEY_GCC_VERSION_CHECK(4, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message msg) #elif HEDLEY_CRAY_VERSION_CHECK(5, 0, 0) #define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(_CRI message msg) #elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0) #define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg)) #elif HEDLEY_PELLES_VERSION_CHECK(2, 0, 0) #define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg)) #else #define HEDLEY_MESSAGE(msg) #endif #if defined(HEDLEY_WARNING) #undef HEDLEY_WARNING #endif #if HEDLEY_HAS_WARNING("-Wunknown-pragmas") #define HEDLEY_WARNING(msg) \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ HEDLEY_PRAGMA(clang warning msg) \ HEDLEY_DIAGNOSTIC_POP #elif HEDLEY_GCC_VERSION_CHECK(4, 8, 0) || \ HEDLEY_PGI_VERSION_CHECK(18, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) #define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(GCC warning msg) #elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(message(msg)) #else #define HEDLEY_WARNING(msg) HEDLEY_MESSAGE(msg) #endif #if defined(HEDLEY_REQUIRE) #undef HEDLEY_REQUIRE #endif #if defined(HEDLEY_REQUIRE_MSG) #undef HEDLEY_REQUIRE_MSG #endif #if HEDLEY_HAS_ATTRIBUTE(diagnose_if) #if HEDLEY_HAS_WARNING("-Wgcc-compat") #define HEDLEY_REQUIRE(expr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ __attribute__((diagnose_if(!(expr), #expr, "error"))) \ HEDLEY_DIAGNOSTIC_POP #define HEDLEY_REQUIRE_MSG(expr, msg) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ __attribute__((diagnose_if(!(expr), msg, "error"))) HEDLEY_DIAGNOSTIC_POP #else #define HEDLEY_REQUIRE(expr) \ __attribute__((diagnose_if(!(expr), #expr, "error"))) #define HEDLEY_REQUIRE_MSG(expr, msg) \ __attribute__((diagnose_if(!(expr), msg, "error"))) #endif #else #define HEDLEY_REQUIRE(expr) #define HEDLEY_REQUIRE_MSG(expr, msg) #endif #if defined(HEDLEY_FLAGS) #undef HEDLEY_FLAGS #endif #if HEDLEY_HAS_ATTRIBUTE(flag_enum) #define HEDLEY_FLAGS __attribute__((__flag_enum__)) #else #define HEDLEY_FLAGS #endif #if defined(HEDLEY_FLAGS_CAST) #undef HEDLEY_FLAGS_CAST #endif #if HEDLEY_INTEL_VERSION_CHECK(19, 0, 0) #define HEDLEY_FLAGS_CAST(T, expr) \ (__extension__({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("warning(disable:188)")((T)(expr)); \ HEDLEY_DIAGNOSTIC_POP \ })) #else #define HEDLEY_FLAGS_CAST(T, expr) HEDLEY_STATIC_CAST(T, expr) #endif #if defined(HEDLEY_EMPTY_BASES) #undef HEDLEY_EMPTY_BASES #endif #if (HEDLEY_MSVC_VERSION_CHECK(19, 0, 23918) && \ !HEDLEY_MSVC_VERSION_CHECK(20, 0, 0)) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) #define HEDLEY_EMPTY_BASES __declspec(empty_bases) #else #define HEDLEY_EMPTY_BASES #endif /* Remaining macros are deprecated. */ #if defined(HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) #undef HEDLEY_GCC_NOT_CLANG_VERSION_CHECK #endif #if defined(__clang__) #define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) (0) #else #define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) \ HEDLEY_GCC_VERSION_CHECK(major, minor, patch) #endif #if defined(HEDLEY_CLANG_HAS_ATTRIBUTE) #undef HEDLEY_CLANG_HAS_ATTRIBUTE #endif #define HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) HEDLEY_HAS_ATTRIBUTE(attribute) #if defined(HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) #undef HEDLEY_CLANG_HAS_CPP_ATTRIBUTE #endif #define HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) \ HEDLEY_HAS_CPP_ATTRIBUTE(attribute) #if defined(HEDLEY_CLANG_HAS_BUILTIN) #undef HEDLEY_CLANG_HAS_BUILTIN #endif #define HEDLEY_CLANG_HAS_BUILTIN(builtin) HEDLEY_HAS_BUILTIN(builtin) #if defined(HEDLEY_CLANG_HAS_FEATURE) #undef HEDLEY_CLANG_HAS_FEATURE #endif #define HEDLEY_CLANG_HAS_FEATURE(feature) HEDLEY_HAS_FEATURE(feature) #if defined(HEDLEY_CLANG_HAS_EXTENSION) #undef HEDLEY_CLANG_HAS_EXTENSION #endif #define HEDLEY_CLANG_HAS_EXTENSION(extension) HEDLEY_HAS_EXTENSION(extension) #if defined(HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) #undef HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE #endif #define HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) \ HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) #if defined(HEDLEY_CLANG_HAS_WARNING) #undef HEDLEY_CLANG_HAS_WARNING #endif #define HEDLEY_CLANG_HAS_WARNING(warning) HEDLEY_HAS_WARNING(warning) #endif /* !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < X) */