diff options
Diffstat (limited to '')
| -rw-r--r-- | include/iprt/nocrt/limits | 494 | ||||
| -rw-r--r-- | include/iprt/nocrt/limits.h | 109 |
2 files changed, 603 insertions, 0 deletions
diff --git a/include/iprt/nocrt/limits b/include/iprt/nocrt/limits new file mode 100644 index 00000000..0d414536 --- /dev/null +++ b/include/iprt/nocrt/limits @@ -0,0 +1,494 @@ +/** @file + * IPRT / No-CRT - C++ limits header. + */ + +/* + * Copyright (C) 2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + +#ifndef VBOX_INCLUDED_SRC_nocrt_limits +#define VBOX_INCLUDED_SRC_nocrt_limits +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <iprt/nocrt/limits.h> +#include <iprt/nocrt/float.h> + +namespace std +{ + enum float_denorm_style + { + denorm_indeterminate = -1, + denorm_absent, + denorm_present, + }; + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero, + round_to_nearest, + round_toward_infinity, + round_toward_neg_infinity, + }; + + struct rtNoCrtLimitNumericBase + { + static const bool is_specialized = false; + static const bool is_integer = false; + static const bool is_signed = false; + static const bool is_exact = false; + static const bool is_bounded = false; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const bool has_denorm_loss = false; + static const bool is_iec559 = false; + static const bool is_modulo = false; + static const bool traps = false; + static const bool tinyness_before = false; + + static const int digits = 0; + static const int digits10 = 0; + static const int max_digits10 = 0; + static const int radix = 0; + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const float_denorm_style has_denorm = denorm_absent; + static const float_round_style round_style = round_toward_zero; + }; + + struct rtNoCrtLimitNumericIntBase : public rtNoCrtLimitNumericBase + { + static const bool is_specialized = true; + static const bool is_integer = true; + static const bool is_exact = true; + static const bool is_bounded = true; + static const int radix = 2; + }; + + struct rtNoCrtLimitNumericFloatBase : public rtNoCrtLimitNumericBase + { + static const bool is_specialized = true; + static const bool is_signed = true; + static const bool is_bounded = true; + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const bool is_iec559 = false; + static const int radix = FLT_RADIX; + static const float_denorm_style has_denorm = denorm_present; + static const float_round_style round_style = round_to_nearest; + }; + + /* + * Generic template. + */ + template<typename a_Type> + struct numeric_limits : public rtNoCrtLimitNumericBase + { + /** @todo need a RT_CONSTEXPR_FN etc */ + static constexpr a_Type(min)() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type(max)() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type lowest() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type epsilon() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type round_error() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type infinity() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type quiet_NaN() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type signaling_NaN() RT_NOEXCEPT { return a_Type(); } + static constexpr a_Type denorm_min() RT_NOEXCEPT { return a_Type(); } + }; + + /* const and volatile trickery: */ + template<typename a_Type> struct numeric_limits<const a_Type> : public numeric_limits<a_Type> {}; + template<typename a_Type> struct numeric_limits<volatile a_Type> : public numeric_limits<a_Type> {}; + template<typename a_Type> struct numeric_limits<const volatile a_Type> : public numeric_limits<a_Type> {}; + + /* + * Integer specializations. + */ + template<> + struct numeric_limits<bool> : public rtNoCrtLimitNumericIntBase + { + static constexpr bool(min)() RT_NOEXCEPT { return false; } + static constexpr bool(max)() RT_NOEXCEPT { return true; } + static constexpr bool lowest() RT_NOEXCEPT { return false; } + static constexpr bool epsilon() RT_NOEXCEPT { return false; } + static constexpr bool round_error() RT_NOEXCEPT { return false; } + static constexpr bool infinity() RT_NOEXCEPT { return false; } + static constexpr bool quiet_NaN() RT_NOEXCEPT { return false; } + static constexpr bool signaling_NaN() RT_NOEXCEPT { return false; } + static constexpr bool denorm_min() RT_NOEXCEPT { return false; } + static const int digits = 1; + }; + + template<> + struct numeric_limits<char> : public rtNoCrtLimitNumericIntBase + { + static constexpr char(min)() RT_NOEXCEPT { return CHAR_MIN; } + static constexpr char(max)() RT_NOEXCEPT { return CHAR_MAX; } + static constexpr char lowest() RT_NOEXCEPT { return CHAR_MIN; } + static constexpr char epsilon() RT_NOEXCEPT { return 0; } + static constexpr char round_error() RT_NOEXCEPT { return 0; } + static constexpr char infinity() RT_NOEXCEPT { return 0; } + static constexpr char quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr char signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr char denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_signed = (char)(-1) < 0; + static const bool is_modulo = (char)(-1) > 0; + static const int digits = (char)(-1) < 0 ? CHAR_BIT - 1 : CHAR_BIT; + static const int digits10 = 2; + }; + + template<> + struct numeric_limits<signed char> : public rtNoCrtLimitNumericIntBase + { + static constexpr signed char(min)() RT_NOEXCEPT { return SCHAR_MIN; } + static constexpr signed char(max)() RT_NOEXCEPT { return SCHAR_MAX; } + static constexpr signed char lowest() RT_NOEXCEPT { return SCHAR_MIN; } + static constexpr signed char epsilon() RT_NOEXCEPT { return 0; } + static constexpr signed char round_error() RT_NOEXCEPT { return 0; } + static constexpr signed char infinity() RT_NOEXCEPT { return 0; } + static constexpr signed char quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr signed char signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr signed char denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_signed = true; + static const int digits = CHAR_BIT - 1; + static const int digits10 = 2; + }; + + template<> + struct numeric_limits<unsigned char> : public rtNoCrtLimitNumericIntBase + { + static constexpr unsigned char(min)() RT_NOEXCEPT { return 0; } + static constexpr unsigned char(max)() RT_NOEXCEPT { return UCHAR_MAX; } + static constexpr unsigned char lowest() RT_NOEXCEPT { return 0; } + static constexpr unsigned char epsilon() RT_NOEXCEPT { return 0; } + static constexpr unsigned char round_error() RT_NOEXCEPT { return 0; } + static constexpr unsigned char infinity() RT_NOEXCEPT { return 0; } + static constexpr unsigned char quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned char signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned char denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT; + static const int digits10 = 2; + }; + + /** @todo wchar_t, char8_t, char16_t, char32_t */ + + template<> + struct numeric_limits<short> : public rtNoCrtLimitNumericIntBase + { + static constexpr short(min)() RT_NOEXCEPT { return SHRT_MIN; } + static constexpr short(max)() RT_NOEXCEPT { return SHRT_MAX; } + static constexpr short lowest() RT_NOEXCEPT { return SHRT_MIN; } + static constexpr short epsilon() RT_NOEXCEPT { return 0; } + static constexpr short round_error() RT_NOEXCEPT { return 0; } + static constexpr short infinity() RT_NOEXCEPT { return 0; } + static constexpr short quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr short signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr short denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_signed = true; + static const int digits = CHAR_BIT * sizeof(short) - 1; + static const int digits10 = 4; + }; + + template<> + struct numeric_limits<unsigned short> : public rtNoCrtLimitNumericIntBase + { + static constexpr unsigned short(min)() RT_NOEXCEPT { return 0; } + static constexpr unsigned short(max)() RT_NOEXCEPT { return USHRT_MAX; } + static constexpr unsigned short lowest() RT_NOEXCEPT { return 0; } + static constexpr unsigned short epsilon() RT_NOEXCEPT { return 0; } + static constexpr unsigned short round_error() RT_NOEXCEPT { return 0; } + static constexpr unsigned short infinity() RT_NOEXCEPT { return 0; } + static constexpr unsigned short quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned short signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned short denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(unsigned short); + static const int digits10 = 4; + }; + +# if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) + template<> + struct numeric_limits<wchar_t> : public rtNoCrtLimitNumericIntBase + { + static constexpr wchar_t(min)() RT_NOEXCEPT { return WCHAR_MIN; } + static constexpr wchar_t(max)() RT_NOEXCEPT { return WCHAR_MAX; } + static constexpr wchar_t lowest() RT_NOEXCEPT { return WCHAR_MIN; } + static constexpr wchar_t epsilon() RT_NOEXCEPT { return 0; } + static constexpr wchar_t round_error() RT_NOEXCEPT { return 0; } + static constexpr wchar_t infinity() RT_NOEXCEPT { return 0; } + static constexpr wchar_t quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr wchar_t signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr wchar_t denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(wchar_t); + static const int digits10 = sizeof(wchar_t) == 2 ? 4 : 9; /** @todo ASSUMES wchar_t is either 16 or 32 bits */ + }; +# endif + + template<> + struct numeric_limits<char16_t> : public rtNoCrtLimitNumericIntBase + { + static constexpr char16_t(min)() RT_NOEXCEPT { return 0; } + static constexpr char16_t(max)() RT_NOEXCEPT { return USHRT_MAX; } + static constexpr char16_t lowest() RT_NOEXCEPT { return 0; } + static constexpr char16_t epsilon() RT_NOEXCEPT { return 0; } + static constexpr char16_t round_error() RT_NOEXCEPT { return 0; } + static constexpr char16_t infinity() RT_NOEXCEPT { return 0; } + static constexpr char16_t quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr char16_t signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr char16_t denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(char16_t); + static const int digits10 = 4; + }; + + template<> + struct numeric_limits<int> : public rtNoCrtLimitNumericIntBase + { + static constexpr int(min)() RT_NOEXCEPT { return INT_MIN; } + static constexpr int(max)() RT_NOEXCEPT { return INT_MAX; } + static constexpr int lowest() RT_NOEXCEPT { return INT_MIN; } + static constexpr int epsilon() RT_NOEXCEPT { return 0; } + static constexpr int round_error() RT_NOEXCEPT { return 0; } + static constexpr int infinity() RT_NOEXCEPT { return 0; } + static constexpr int quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr int signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr int denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_signed = true; + static const int digits = CHAR_BIT * sizeof(int) - 1; + static const int digits10 = 9; + }; + + template<> + struct numeric_limits<unsigned int> : public rtNoCrtLimitNumericIntBase + { + static constexpr unsigned int(min)() RT_NOEXCEPT { return 0; } + static constexpr unsigned int(max)() RT_NOEXCEPT { return UINT_MAX; } + static constexpr unsigned int lowest() RT_NOEXCEPT { return 0; } + static constexpr unsigned int epsilon() RT_NOEXCEPT { return 0; } + static constexpr unsigned int round_error() RT_NOEXCEPT { return 0; } + static constexpr unsigned int infinity() RT_NOEXCEPT { return 0; } + static constexpr unsigned int quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned int signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned int denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(unsigned int); + static const int digits10 = 9; + }; + + template<> + struct numeric_limits<char32_t> : public rtNoCrtLimitNumericIntBase + { + static constexpr char32_t(min)() RT_NOEXCEPT { return 0; } + static constexpr char32_t(max)() RT_NOEXCEPT { return UINT_MAX; } + static constexpr char32_t lowest() RT_NOEXCEPT { return 0; } + static constexpr char32_t epsilon() RT_NOEXCEPT { return 0; } + static constexpr char32_t round_error() RT_NOEXCEPT { return 0; } + static constexpr char32_t infinity() RT_NOEXCEPT { return 0; } + static constexpr char32_t quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr char32_t signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr char32_t denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(char32_t); + static const int digits10 = 9; + }; + + template<> + struct numeric_limits<long> : public rtNoCrtLimitNumericIntBase + { + static constexpr long(min)() RT_NOEXCEPT { return LONG_MIN; } + static constexpr long(max)() RT_NOEXCEPT { return LONG_MAX; } + static constexpr long lowest() RT_NOEXCEPT { return LONG_MIN; } + static constexpr long epsilon() RT_NOEXCEPT { return 0; } + static constexpr long round_error() RT_NOEXCEPT { return 0; } + static constexpr long infinity() RT_NOEXCEPT { return 0; } + static constexpr long quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr long signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr long denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_signed = true; + static const int digits = CHAR_BIT * sizeof(long) - 1; + static const int digits10 = sizeof(long) == sizeof(int) ? 9 : 18; + }; + + template<> + struct numeric_limits<unsigned long> : public rtNoCrtLimitNumericIntBase + { + static constexpr unsigned long(min)() RT_NOEXCEPT { return 0; } + static constexpr unsigned long(max)() RT_NOEXCEPT { return ULONG_MAX; } + static constexpr unsigned long lowest() RT_NOEXCEPT { return 0; } + static constexpr unsigned long epsilon() RT_NOEXCEPT { return 0; } + static constexpr unsigned long round_error() RT_NOEXCEPT { return 0; } + static constexpr unsigned long infinity() RT_NOEXCEPT { return 0; } + static constexpr unsigned long quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned long signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned long denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(unsigned long); + static const int digits10 = sizeof(unsigned long) == sizeof(unsigned int) ? 9 : 19; + }; + + template<> + struct numeric_limits<long long> : public rtNoCrtLimitNumericIntBase + { + static constexpr long long(min)() RT_NOEXCEPT { return LLONG_MIN; } + static constexpr long long(max)() RT_NOEXCEPT { return LLONG_MAX; } + static constexpr long long lowest() RT_NOEXCEPT { return LLONG_MIN; } + static constexpr long long epsilon() RT_NOEXCEPT { return 0; } + static constexpr long long round_error() RT_NOEXCEPT { return 0; } + static constexpr long long infinity() RT_NOEXCEPT { return 0; } + static constexpr long long quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr long long signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr long long denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_signed = true; + static const int digits = CHAR_BIT * sizeof(long long) - 1; + static const int digits10 = 18; + }; + + template<> + struct numeric_limits<unsigned long long> : public rtNoCrtLimitNumericIntBase + { + static constexpr unsigned long long(min)() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long(max)() RT_NOEXCEPT { return ULLONG_MAX; } + static constexpr unsigned long long lowest() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long epsilon() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long round_error() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long infinity() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long quiet_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long signaling_NaN() RT_NOEXCEPT { return 0; } + static constexpr unsigned long long denorm_min() RT_NOEXCEPT { return 0; } + + static const bool is_modulo = true; + static const int digits = CHAR_BIT * sizeof(unsigned long long); + static const int digits10 = 19; + }; + + + /* + * Floating point. + */ + template<> + struct numeric_limits<float> : public rtNoCrtLimitNumericFloatBase + { + static constexpr float(min)() RT_NOEXCEPT { return FLT_MIN; } + static constexpr float(max)() RT_NOEXCEPT { return FLT_MAX; } + static constexpr float lowest() RT_NOEXCEPT { return -(FLT_MAX); } + static constexpr float epsilon() RT_NOEXCEPT { return FLT_EPSILON; } + static constexpr float round_error() RT_NOEXCEPT { return 0.5F; } + static constexpr float infinity() RT_NOEXCEPT { return __builtin_huge_valf(); } + static constexpr float quiet_NaN() RT_NOEXCEPT { return __builtin_nanf("0"); } + static constexpr float signaling_NaN() RT_NOEXCEPT { return __builtin_nansf("1"); } + static constexpr float denorm_min() RT_NOEXCEPT { return FLT_TRUE_MIN; } + + static const int digits = FLT_MANT_DIG; + static const int digits10 = FLT_DIG; + static const int max_digits10 = FLT_DECIMAL_DIG; + static const int max_exponent = FLT_MAX_EXP; + static const int max_exponent10 = FLT_MAX_10_EXP; + static const int min_exponent = FLT_MIN_EXP; + static const int min_exponent10 = FLT_MIN_10_EXP; + }; + + template<> + struct numeric_limits<double> : public rtNoCrtLimitNumericFloatBase + { + static constexpr double(min)() RT_NOEXCEPT { return DBL_MIN; } + static constexpr double(max)() RT_NOEXCEPT { return DBL_MAX; } + static constexpr double lowest() RT_NOEXCEPT { return -(DBL_MAX); } + static constexpr double epsilon() RT_NOEXCEPT { return DBL_EPSILON; } + static constexpr double round_error() RT_NOEXCEPT { return 0.5; } + static constexpr double infinity() RT_NOEXCEPT { return __builtin_huge_val(); } + static constexpr double quiet_NaN() RT_NOEXCEPT { return __builtin_nan("0"); } + static constexpr double signaling_NaN() RT_NOEXCEPT { return __builtin_nans("1"); } + static constexpr double denorm_min() RT_NOEXCEPT { return DBL_TRUE_MIN; } + + static const int digits = DBL_MANT_DIG; + static const int digits10 = DBL_DIG; + static const int max_digits10 = DBL_DECIMAL_DIG; + static const int max_exponent = DBL_MAX_EXP; + static const int max_exponent10 = DBL_MAX_10_EXP; + static const int min_exponent = DBL_MIN_EXP; + static const int min_exponent10 = DBL_MIN_10_EXP; + }; + + template<> + struct numeric_limits<long double> : public rtNoCrtLimitNumericFloatBase + { + static constexpr long double(min)() RT_NOEXCEPT { return LDBL_MIN; } + static constexpr long double(max)() RT_NOEXCEPT { return LDBL_MAX; } + static constexpr long double lowest() RT_NOEXCEPT { return -(LDBL_MAX); } + static constexpr long double epsilon() RT_NOEXCEPT { return LDBL_EPSILON; } + static constexpr long double round_error() RT_NOEXCEPT { return 0.5L; } +#if LDBL_DIG == DBL_DIG + static constexpr long double infinity() RT_NOEXCEPT { return __builtin_huge_val(); } + static constexpr long double quiet_NaN() RT_NOEXCEPT { return __builtin_nan("0"); } + static constexpr long double signaling_NaN() RT_NOEXCEPT { return __builtin_nans("1"); } +#else + static constexpr long double infinity() RT_NOEXCEPT { return __builtin_huge_vall(); } + static constexpr long double quiet_NaN() RT_NOEXCEPT { return __builtin_nanl("0"); } + static constexpr long double signaling_NaN() RT_NOEXCEPT { return __builtin_nansl("1"); } +#endif + static constexpr long double denorm_min() RT_NOEXCEPT { return LDBL_TRUE_MIN; } + + static const int digits = LDBL_MANT_DIG; + static const int digits10 = LDBL_DIG; + static const int max_digits10 = LDBL_DECIMAL_DIG; + static const int max_exponent = LDBL_MAX_EXP; + static const int max_exponent10 = LDBL_MAX_10_EXP; + static const int min_exponent = LDBL_MIN_EXP; + static const int min_exponent10 = LDBL_MIN_10_EXP; + }; + + /** @todo more types */ +} + +#endif /* !VBOX_INCLUDED_SRC_nocrt_limits */ + diff --git a/include/iprt/nocrt/limits.h b/include/iprt/nocrt/limits.h new file mode 100644 index 00000000..7b2e060b --- /dev/null +++ b/include/iprt/nocrt/limits.h @@ -0,0 +1,109 @@ +/** @file + * IPRT / No-CRT - Our own limits header. + */ + +/* + * Copyright (C) 2006-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + +#ifndef IPRT_INCLUDED_nocrt_limits_h +#define IPRT_INCLUDED_nocrt_limits_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <iprt/types.h> + +#define CHAR_BIT 8 +#define SCHAR_MAX 0x7f +#define SCHAR_MIN (-0x7f - 1) +#define UCHAR_MAX 0xff +#if 1 /* ASSUMES: signed char */ +# define CHAR_MAX SCHAR_MAX +# define CHAR_MIN SCHAR_MIN +#else +# define CHAR_MAX UCHAR_MAX +# define CHAR_MIN 0 +#endif + +#define WORD_BIT 16 +#define USHRT_MAX 0xffff +#define SHRT_MAX 0x7fff +#define SHRT_MIN (-0x7fff - 1) + +/* ASSUMES 32-bit int */ +#define UINT_MAX 0xffffffffU +#define INT_MAX 0x7fffffff +#define INT_MIN (-0x7fffffff - 1) + +#if defined(RT_ARCH_X86) || defined(RT_OS_WINDOWS) || defined(RT_ARCH_SPARC) || defined(RT_ARCH_ARM32) +# define LONG_BIT 32 +# define ULONG_MAX 0xffffffffU +# define LONG_MAX 0x7fffffff +# define LONG_MIN (-0x7fffffff - 1) +#elif defined(RT_ARCH_AMD64) || defined(RT_ARCH_SPARC64) || defined(RT_ARCH_ARM64) +# define LONG_BIT 64 +# define ULONG_MAX UINT64_C(0xffffffffffffffff) +# define LONG_MAX INT64_C(0x7fffffffffffffff) +# define LONG_MIN (INT64_C(-0x7fffffffffffffff) - 1) +#else +# error "PORTME" +#endif + +#define LLONG_BIT 64 +#define ULLONG_MAX UINT64_C(0xffffffffffffffff) +#define LLONG_MAX INT64_C(0x7fffffffffffffff) +#define LLONG_MIN (INT64_C(-0x7fffffffffffffff) - 1) + +#undef SIZE_MAX +#undef SIZE_T_MAX +#undef SSIZE_MAX +#undef INTPTR_MAX +#undef UINTPTR_MAX +#if ARCH_BITS == 32 +# define SIZE_T_MAX 0xffffffffU +# define SSIZE_MAX 0x7fffffff +# define INTPTR_MAX 0x7fffffff +# define UINTPTR_MAX 0xffffffffU +#elif ARCH_BITS == 64 +# define SIZE_T_MAX UINT64_C(0xffffffffffffffff) +# define SSIZE_MAX INT64_C(0x7fffffffffffffff) +# define INTPTR_MAX INT64_C(0x7fffffffffffffff) +# define UINTPTR_MAX UINT64_C(0xffffffffffffffff) +#else +# error "huh?" +#endif +#define SIZE_MAX SIZE_T_MAX + +/*#define OFF_MAX __OFF_MAX +#define OFF_MIN __OFF_MIN*/ + +#endif /* !IPRT_INCLUDED_nocrt_limits_h */ + |