diff options
author | Jason Merrill <jason@gcc.gnu.org> | 1998-09-02 08:28:14 -0400 |
---|---|---|
committer | Jason Merrill <jason@gcc.gnu.org> | 1998-09-02 08:28:14 -0400 |
commit | 38fcba265cae3cb9656a3d1a211194560836cf6e (patch) | |
tree | 4ccc5ddb33a38d06639679070617c3f9892f0f2e /libstdc++ | |
parent | 70126bf6730b22f344059a0690fab2a788621132 (diff) | |
download | gcc-38fcba265cae3cb9656a3d1a211194560836cf6e.zip gcc-38fcba265cae3cb9656a3d1a211194560836cf6e.tar.gz gcc-38fcba265cae3cb9656a3d1a211194560836cf6e.tar.bz2 |
Initial revision
From-SVN: r22173
Diffstat (limited to 'libstdc++')
-rw-r--r-- | libstdc++/stl/limits | 404 |
1 files changed, 404 insertions, 0 deletions
diff --git a/libstdc++/stl/limits b/libstdc++/stl/limits new file mode 100644 index 0000000..b28cedc --- /dev/null +++ b/libstdc++/stl/limits @@ -0,0 +1,404 @@ +/* + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/* NOTE: This is not portable code. Parts of numeric_limits<> are + * inherently machine-dependent, and this file is written for the MIPS + * architecture and the SGI MIPSpro C++ compiler. Parts of it (in + * particular, some of the characteristics of floating-point types) + * are almost certainly incorrect for any other platform. + */ + +#ifndef __SGI_CPP_LIMITS +#define __SGI_CPP_LIMITS + +#include <limits.h> +#include <float.h> +#include <stl_config.h> + +__STL_BEGIN_NAMESPACE + +enum float_round_style { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 +}; + + +// Base class for all specializations of numeric_limits. + +template <class Number> +class __numeric_limits_base { +public: + static const bool is_specialized = false; + + static Number min() __STL_NOTHROW { return Number(); } + static Number max() __STL_NOTHROW { return Number(); } + + static const int digits = 0; + static const int digits10 = 0; + + static const bool is_signed = false; + static const bool is_integer = false; + static const bool is_exact = false; + + static const int radix = 0; + + static Number epsilon() __STL_NOTHROW { return Number(); } + static Number round_error() __STL_NOTHROW { return Number(); } + + 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 bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const bool has_denorm = false; + static const bool has_denorm_loss = false; + + static Number infinity() __STL_NOTHROW { return Number(); } + static Number quiet_NaN() __STL_NOTHROW { return Number(); } + static Number signaling_NaN() __STL_NOTHROW { return Number(); } + static Number denorm_min() __STL_NOTHROW { return Number(); } + + static const bool is_iec559 = false; + static const bool is_bounded = false; + static const bool is_modulo = false; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; +}; + +#define __declare_numeric_base_member(__type, __mem) \ +template <class Number> \ + const __type __numeric_limits_base<Number>:: __mem + +__declare_numeric_base_member(bool, is_specialized); +__declare_numeric_base_member(int, digits); +__declare_numeric_base_member(int, digits10); +__declare_numeric_base_member(bool, is_signed); +__declare_numeric_base_member(bool, is_integer); +__declare_numeric_base_member(bool, is_exact); +__declare_numeric_base_member(int, radix); +__declare_numeric_base_member(int, min_exponent); +__declare_numeric_base_member(int, max_exponent); +__declare_numeric_base_member(int, min_exponent10); +__declare_numeric_base_member(int, max_exponent10); +__declare_numeric_base_member(bool, has_infinity); +__declare_numeric_base_member(bool, has_quiet_NaN); +__declare_numeric_base_member(bool, has_signaling_NaN); +__declare_numeric_base_member(bool, has_denorm); +__declare_numeric_base_member(bool, has_denorm_loss); +__declare_numeric_base_member(bool, is_iec559); +__declare_numeric_base_member(bool, is_bounded); +__declare_numeric_base_member(bool, is_modulo); +__declare_numeric_base_member(bool, traps); +__declare_numeric_base_member(bool, tinyness_before); +__declare_numeric_base_member(float_round_style, round_style); + +#undef __declare_numeric_base_member + +// Base class for integers. + +template <class __Int, + __Int IMin, + __Int IMax, + int IDigits = -1> +class __integer_limits : public __numeric_limits_base<__Int> +{ +public: + static const bool is_specialized = true; + + static __Int min() __STL_NOTHROW { return IMin; } + static __Int max() __STL_NOTHROW { return IMax; } + + static const int digits = + (IDigits < 0) ? sizeof(__Int) * CHAR_BIT - (IMin == 0 ? 0 : 1) : IDigits; + static const int digits10 = (digits * 301) / 1000; + // log 2 = 0.301029995664... + + static const bool is_signed = IMin != 0; + static const bool is_integer = true; + static const bool is_exact = true; + static const int radix = 2; + + + static const bool is_bounded = true; + static const bool is_modulo = true; +}; + +#define __declare_integer_limits_member(__type, __mem) \ +template <class __Int, __Int IMin, __Int IMax, int IDigits> \ + const __type __integer_limits<__Int, IMin, IMax, IDigits>:: __mem + +__declare_integer_limits_member(bool, is_specialized); +__declare_integer_limits_member(int, digits); +__declare_integer_limits_member(int, digits10); +__declare_integer_limits_member(bool, is_signed); +__declare_integer_limits_member(bool, is_integer); +__declare_integer_limits_member(bool, is_exact); +__declare_integer_limits_member(int, radix); +__declare_integer_limits_member(bool, is_bounded); +__declare_integer_limits_member(bool, is_modulo); + +#undef __declare_integer_limits_member + +// Base class for floating-point numbers. +template <class Number, + int FDigits, int FDigits10, + int FMinExp, int FMaxExp, + int FMinExp10, int FMaxExp10, + unsigned int FInfinityWord, + unsigned int FQNaNWord, unsigned int FSNaNWord, + bool FIsIEC559, + float_round_style FRoundStyle> +class __floating_limits : public __numeric_limits_base<Number> +{ +public: + static const bool is_specialized = true; + + static const int digits = FDigits; + static const int digits10 = FDigits10; + + static const bool is_signed = true; + + static const int radix = 2; + + static const int min_exponent = FMinExp; + static const int max_exponent = FMaxExp; + static const int min_exponent10 = FMinExp10; + static const int max_exponent10 = FMaxExp10; + + static const bool has_infinity = true; + static const bool has_quiet_NaN = true; + static const bool has_signaling_NaN = true; + static const bool has_denorm = false; + static const bool has_denorm_loss = false; + + static Number infinity() __STL_NOTHROW { + static unsigned int inf[sizeof(Number) / sizeof(int)] = { FInfinityWord }; + return *reinterpret_cast<Number*>(&inf); + } + static Number quiet_NaN() __STL_NOTHROW { + static unsigned int nan[sizeof(Number) / sizeof(int)] = { FQNaNWord }; + return *reinterpret_cast<Number*>(&nan); + } + static Number signaling_NaN() __STL_NOTHROW { + static unsigned int nan[sizeof(Number) / sizeof(int)] = { FSNaNWord }; + return *reinterpret_cast<Number*>(&nan); + } + + static const bool is_iec559 = FIsIEC559; + static const bool is_bounded = true; + static const bool traps = true; + static const bool tinyness_before = false; + + static const float_round_style round_style = FRoundStyle; +}; + +#define __declare_float_limits_member(__type, __mem) \ +template <class __Num, int __Dig, int __Dig10, \ + int __MnX, int __MxX, int __MnX10, int __MxX10, \ + unsigned int __Inf, unsigned int __QNaN, unsigned int __SNaN, \ + bool __IsIEEE, float_round_style __Sty> \ +const __type __floating_limits<__Num, __Dig, __Dig10, \ + __MnX, __MxX, __MnX10, __MxX10, \ + __Inf, __QNaN, __SNaN,__IsIEEE, __Sty>:: __mem + +__declare_float_limits_member(bool, is_specialized); +__declare_float_limits_member(int, digits); +__declare_float_limits_member(int, digits10); +__declare_float_limits_member(bool, is_signed); +__declare_float_limits_member(int, radix); +__declare_float_limits_member(int, min_exponent); +__declare_float_limits_member(int, max_exponent); +__declare_float_limits_member(int, min_exponent10); +__declare_float_limits_member(int, max_exponent10); +__declare_float_limits_member(bool, has_infinity); +__declare_float_limits_member(bool, has_quiet_NaN); +__declare_float_limits_member(bool, has_signaling_NaN); +__declare_float_limits_member(bool, has_denorm); +__declare_float_limits_member(bool, has_denorm_loss); +__declare_float_limits_member(bool, is_iec559); +__declare_float_limits_member(bool, is_bounded); +__declare_float_limits_member(bool, traps); +__declare_float_limits_member(bool, tinyness_before); +__declare_float_limits_member(float_round_style, round_style); + +#undef __declare_float_limits_member + +// Class numeric_limits + +// The unspecialized class. + +template<class T> +class numeric_limits : public __numeric_limits_base<T> {}; + +// Specializations for all built-in integral types. + +#ifndef __STL_NEED_BOOL + +template<> +class numeric_limits<bool> + : public __integer_limits<bool, false, true, 0> +{}; + +#endif /* __STL_NEED_BOOL */ + +template<> +class numeric_limits<char> + : public __integer_limits<char, CHAR_MIN, CHAR_MAX> +{}; + +template<> +class numeric_limits<signed char> + : public __integer_limits<signed char, SCHAR_MIN, SCHAR_MAX> +{}; + +template<> +class numeric_limits<unsigned char> + : public __integer_limits<unsigned char, 0, UCHAR_MAX> +{}; + +#ifdef _WCHAR_T_IS_KEYWORD + +template<> +class numeric_limits<wchar_t> + : public __integer_limits<wchar_t, INT_MIN, INT_MAX> +{}; + +#endif + +template<> +class numeric_limits<short> + : public __integer_limits<short, SHRT_MIN, SHRT_MAX> +{}; + +template<> +class numeric_limits<unsigned short> + : public __integer_limits<unsigned short, 0, USHRT_MAX> +{}; + +template<> +class numeric_limits<int> + : public __integer_limits<int, INT_MIN, INT_MAX> +{}; + +template<> +class numeric_limits<unsigned int> + : public __integer_limits<unsigned int, 0, UINT_MAX> +{}; + +template<> +class numeric_limits<long> + : public __integer_limits<long, LONG_MIN, LONG_MAX> +{}; + +template<> +class numeric_limits<unsigned long> + : public __integer_limits<unsigned long, 0, ULONG_MAX> +{}; + +#if defined(_LONGLONG) && _SGIAPI + +template<> +class numeric_limits<long long> + : public __integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX> +{}; + +template<> +class numeric_limits<unsigned long long> + : public __integer_limits<unsigned long long, 0, ULONGLONG_MAX> +{}; + +#endif /* _LONGLONG && _SGIAPI */ + +// Specializations for all built-in floating-point type. + +template<> class numeric_limits<float> + : public __floating_limits<float, + FLT_MANT_DIG, // Binary digits of precision + FLT_DIG, // Decimal digits of precision + FLT_MIN_EXP, // Minimum exponent + FLT_MAX_EXP, // Maximum exponent + FLT_MIN_10_EXP, // Minimum base 10 exponent + FLT_MAX_10_EXP, // Maximum base 10 exponent + 0x7f800000u, // First word of +infinity + 0x7f810000u, // First word of quiet NaN + 0x7fc10000u, // First word of signaling NaN + true, // conforms to iec559 + round_to_nearest> +{ +public: + static float min() __STL_NOTHROW { return FLT_MIN; } + static float denorm_min() __STL_NOTHROW { return FLT_MIN; } + static float max() __STL_NOTHROW { return FLT_MAX; } + static float epsilon() __STL_NOTHROW { return FLT_EPSILON; } + static float round_error() __STL_NOTHROW { return 0.5f; } // Units: ulps. +}; + +template<> class numeric_limits<double> + : public __floating_limits<double, + DBL_MANT_DIG, // Binary digits of precision + DBL_DIG, // Decimal digits of precision + DBL_MIN_EXP, // Minimum exponent + DBL_MAX_EXP, // Maximum exponent + DBL_MIN_10_EXP, // Minimum base 10 exponent + DBL_MAX_10_EXP, // Maximum base 10 exponent + 0x7ff00000u, // First word of +infinity + 0x7ff10000u, // First word of quiet NaN + 0x7ff90000u, // First word of signaling NaN + true, // conforms to iec559 + round_to_nearest> +{ +public: + static double min() __STL_NOTHROW { return DBL_MIN; } + static double denorm_min() __STL_NOTHROW { return DBL_MIN; } + static double max() __STL_NOTHROW { return DBL_MAX; } + static double epsilon() __STL_NOTHROW { return DBL_EPSILON; } + static double round_error() __STL_NOTHROW { return 0.5; } // Units: ulps. +}; + +template<> class numeric_limits<long double> + : public __floating_limits<long double, + LDBL_MANT_DIG, // Binary digits of precision + LDBL_DIG, // Decimal digits of precision + LDBL_MIN_EXP, // Minimum exponent + LDBL_MAX_EXP, // Maximum exponent + LDBL_MIN_10_EXP,// Minimum base 10 exponent + LDBL_MAX_10_EXP,// Maximum base 10 exponent + 0x7ff00000u, // First word of +infinity + 0x7ff10000u, // First word of quiet NaN + 0x7ff90000u, // First word of signaling NaN + false, // Doesn't conform to iec559 + round_to_nearest> +{ +public: + static long double min() __STL_NOTHROW { return LDBL_MIN; } + static long double denorm_min() __STL_NOTHROW { return LDBL_MIN; } + static long double max() __STL_NOTHROW { return LDBL_MAX; } + static long double epsilon() __STL_NOTHROW { return LDBL_EPSILON; } + static long double round_error() __STL_NOTHROW { return 4; } // Units: ulps. +}; + +__STL_END_NAMESPACE + +#endif /* __SGI_CPP_LIMITS */ + +// Local Variables: +// mode:C++ +// End: |