limits

realview22.rar

_RWSTD_NAMESPACE_END   // std


#endif   // _RWSTD_LIMITS_TEMPLATE_DEFINED


_RWSTD_NAMESPACE_BEGIN (std)


_RWSTD_CLASS_BEGIN (_RWSTD_SPECIALIZED_CLASS
                    class _RWSTD_EXPORT numeric_limits<float>)

    _RWSTD_STATIC (float, bool, is_specialized, true);

    _RWSTD_STATIC_FUN (float, min, FLT_MIN)
    _RWSTD_STATIC_FUN (float, max, FLT_MAX)

    _RWSTD_STATIC (float, int, digits,   FLT_MANT_DIG);
    _RWSTD_STATIC (float, int, digits10, FLT_DIG);

    _RWSTD_STATIC (float, bool, is_signed,  true);
    _RWSTD_STATIC (float, bool, is_integer, false);
    _RWSTD_STATIC (float, bool, is_exact,   false);
    _RWSTD_STATIC (float, int,  radix,      FLT_RADIX);

    _RWSTD_STATIC_FUN (float, epsilon,     FLT_EPSILON)
    _RWSTD_STATIC_FUN (float, round_error, _RWSTD_FLT_ROUND_ERROR)

    _RWSTD_STATIC (float, int, min_exponent,   FLT_MIN_EXP);
    _RWSTD_STATIC (float, int, min_exponent10, FLT_MIN_10_EXP);
    _RWSTD_STATIC (float, int, max_exponent,   FLT_MAX_EXP);
    _RWSTD_STATIC (float, int, max_exponent10, FLT_MAX_10_EXP);

    _RWSTD_STATIC (float, bool, has_infinity,      _RWSTD_HAS_INFINITY);
    _RWSTD_STATIC (float, bool, has_quiet_NaN,     _RWSTD_HAS_QUIET_NAN);
    _RWSTD_STATIC (float, bool, has_signaling_NaN, _RWSTD_HAS_SIG_NAN);
    _RWSTD_STATIC (float, float_denorm_style, has_denorm,
                   _RWSTD_HAS_DENORM);
    _RWSTD_STATIC (float, bool, has_denorm_loss, _RWSTD_HAS_DENORM_LOSS);

    _RWSTD_STATIC_FUN (float, infinity,      __ESCAPE__(0f_7F800000)) // VENDOR
    _RWSTD_STATIC_FUN (float, quiet_NaN,     __ESCAPE__(0f_7FC00000)) // VENDOR
    _RWSTD_STATIC_FUN (float, signaling_NaN, __ESCAPE__(0f_7F800001)) // VENDOR
    _RWSTD_STATIC_FUN (float, denorm_min,    _RWSTD_FLT_DENORM_MIN) // VENDOR

    _RWSTD_STATIC (float, bool, is_iec559,  _RWSTD_IS_IEC559);    // VENDOR
    _RWSTD_STATIC (float, bool, is_bounded, true);
    _RWSTD_STATIC (float, bool, is_modulo,  false);               // VENDOR

    _RWSTD_STATIC (float, bool, traps, true);                    // VENDOR
    _RWSTD_STATIC (float, bool, tinyness_before, false);          // VENDOR

    _RWSTD_STATIC_ROUNDS (float, float_round_style, round_style, FLT_ROUNDS);

     // extension: type converts to without loss of data
    _RWSTD_TYPEDEF (double _C_convertible)

_RWSTD_CLASS_END   // numeric_limits<float>


_RWSTD_CLASS_BEGIN (_RWSTD_SPECIALIZED_CLASS
                    class _RWSTD_EXPORT numeric_limits<double>)

    _RWSTD_STATIC (double, bool, is_specialized, true);

    _RWSTD_STATIC_FUN (double, min, DBL_MIN)
    _RWSTD_STATIC_FUN (double, max, DBL_MAX)

    _RWSTD_STATIC (double, int, digits,   DBL_MANT_DIG);
    _RWSTD_STATIC (double, int, digits10, DBL_DIG);

    _RWSTD_STATIC (double, bool, is_signed,  true);
    _RWSTD_STATIC (double, bool, is_integer, false);
    _RWSTD_STATIC (double, bool, is_exact,   false);
    _RWSTD_STATIC (double, int,  radix,      FLT_RADIX);

    _RWSTD_STATIC_FUN (double, epsilon,     DBL_EPSILON)
    _RWSTD_STATIC_FUN (double, round_error, _RWSTD_DBL_ROUND_ERROR)

    _RWSTD_STATIC (double, int, min_exponent,   DBL_MIN_EXP);
    _RWSTD_STATIC (double, int, min_exponent10, DBL_MIN_10_EXP);
    _RWSTD_STATIC (double, int, max_exponent,   DBL_MAX_EXP);
    _RWSTD_STATIC (double, int, max_exponent10, DBL_MAX_10_EXP);

    _RWSTD_STATIC (double, bool, has_infinity,      _RWSTD_HAS_INFINITY);
    _RWSTD_STATIC (double, bool, has_quiet_NaN,     _RWSTD_HAS_QUIET_NAN);
    _RWSTD_STATIC (double, bool, has_signaling_NaN, _RWSTD_HAS_SIG_NAN);
    _RWSTD_STATIC (double, float_denorm_style, has_denorm,
                   _RWSTD_HAS_DENORM);
    _RWSTD_STATIC (double, bool, has_denorm_loss,   _RWSTD_HAS_DENORM_LOSS);

    _RWSTD_STATIC_FUN (double, infinity,      __ESCAPE__(0d_7FF0000000000000))   // VENDOR
    _RWSTD_STATIC_FUN (double, quiet_NaN,     __ESCAPE__(0d_7FF8000000000000))   // VENDOR
    _RWSTD_STATIC_FUN (double, signaling_NaN, __ESCAPE__(0d_7FF0000000000001))   // VENDOR
    _RWSTD_STATIC_FUN (double, denorm_min,    _RWSTD_DBL_DENORM_MIN)

    _RWSTD_STATIC (double, bool, is_iec559,  _RWSTD_IS_IEC559);
    _RWSTD_STATIC (double, bool, is_bounded, true);
    _RWSTD_STATIC (double, bool, is_modulo,  false);              // VENDOR

    _RWSTD_STATIC (double, bool, traps, true);                   // VENDOR
    _RWSTD_STATIC (double, bool, tinyness_before, false);         // VENDOR

    _RWSTD_STATIC_ROUNDS (double, float_round_style, round_style, FLT_ROUNDS);

     // extension: type converts to without loss of data
    _RWSTD_TYPEDEF (long double _C_convertible)

_RWSTD_CLASS_END   // numeric_limits<double>


#ifndef _RWSTD_NO_LONG_DOUBLE

_RWSTD_CLASS_BEGIN (_RWSTD_SPECIALIZED_CLASS
                    class _RWSTD_EXPORT numeric_limits<long double>)

    _RWSTD_STATIC (long double, bool, is_specialized, true);

    _RWSTD_STATIC_FUN (long double, min, LDBL_MIN) 
    _RWSTD_STATIC_FUN (long double, max, LDBL_MAX) 

    _RWSTD_STATIC (long double, int, digits,   LDBL_MANT_DIG);
    _RWSTD_STATIC (long double, int, digits10, LDBL_DIG);

    _RWSTD_STATIC (long double, bool, is_signed,  true);
    _RWSTD_STATIC (long double, bool, is_integer, false);
    _RWSTD_STATIC (long double, bool, is_exact,   false);
    _RWSTD_STATIC (long double, int,  radix,      FLT_RADIX);

    _RWSTD_STATIC_FUN (long double, epsilon,     LDBL_EPSILON) 
    _RWSTD_STATIC_FUN (long double, round_error, _RWSTD_LDBL_ROUND_ERROR)

    _RWSTD_STATIC (long double, int, min_exponent,   LDBL_MIN_EXP);
    _RWSTD_STATIC (long double, int, min_exponent10, LDBL_MIN_10_EXP);
    _RWSTD_STATIC (long double, int, max_exponent,   LDBL_MAX_EXP);
    _RWSTD_STATIC (long double, int, max_exponent10, LDBL_MAX_10_EXP);

    _RWSTD_STATIC (long double, bool, has_infinity,      _RWSTD_HAS_INFINITY);
    _RWSTD_STATIC (long double, bool, has_quiet_NaN,     _RWSTD_HAS_QUIET_NAN);
    _RWSTD_STATIC (long double, bool, has_signaling_NaN, _RWSTD_HAS_SIG_NAN);
    _RWSTD_STATIC (long double, float_denorm_style, has_denorm,
                   denorm_indeterminate);
    _RWSTD_STATIC (long double, bool, has_denorm_loss, _RWSTD_HAS_DENORM_LOSS);

    _RWSTD_STATIC_FUN (long double, infinity,      __ESCAPE__(0d_7FF0000000000000))   // VENDOR
    _RWSTD_STATIC_FUN (long double, quiet_NaN,     __ESCAPE__(0d_7FF8000000000000))   // VENDOR
    _RWSTD_STATIC_FUN (long double, signaling_NaN, __ESCAPE__(0d_7FF0000000000001))   // VENDOR
    _RWSTD_STATIC_FUN (long double, denorm_min,    _RWSTD_LDBL_DENORM_MIN)

    _RWSTD_STATIC (long double, bool, is_iec559,  _RWSTD_IS_IEC559);
    _RWSTD_STATIC (long double, bool, is_bounded, true);
    _RWSTD_STATIC (long double, bool, is_modulo,  false);         // VENDOR

    _RWSTD_STATIC (long double, bool, traps, true);              // VENDOR
    _RWSTD_STATIC (long double, bool, tinyness_before, false);    // VENDOR

    _RWSTD_STATIC_ROUNDS (long double, float_round_style, round_style,
                          FLT_ROUNDS);

     // extension: type converts to without loss of data
    _RWSTD_TYPEDEF (long double _C_convertible)

_RWSTD_CLASS_END    // numeric_limits<long double>

#endif   // _RWSTD_NO_LONG_DOUBLE


#define _RWSTD_UCHAR_MIN 0
#define _RWSTD_USHRT_MIN 0
#define _RWSTD_UINT_MIN  0
#define _RWSTD_ULONG_MIN 0

#define _RWSTD_UCHAR_MAX UCHAR_MAX
#define _RWSTD_USHRT_MAX USHRT_MAX
#define _RWSTD_UINT_MAX  UINT_MAX
#define _RWSTD_ULONG_MAX ULONG_MAX


// types each integral type converts to with no loss of precision (if possible)
#ifdef _RWSTD_LONG_LONG
#  if UINT_MAX < ULONG_MAX
#    define _RWSTD_INT_CONVERTIBLE long
#  else
#    define _RWSTD_INT_CONVERTIBLE _RWSTD_LONG_LONG
#  endif
#  define _RWSTD_LONG_CONVERTIBLE  _RWSTD_LONG_LONG
#else   // if !defined (_RWSTD_LONG_LONG)
#  define _RWSTD_INT_CONVERTIBLE  long
#  define _RWSTD_LONG_CONVERTIBLE long
#endif   // _RWSTD_LONG_LONG


#if UCHAR_MAX < UINT_MAX
#  define _RWSTD_CHAR_CONVERTIBLE int
#else
#  define _RWSTD_CHAR_CONVERTIBLE _RWSTD_INT_CONVERTIBLE
#endif   // UCHAR_MAX < UINT_MAX


#if USHRT_MAX < UINT_MAX
#  define _RWSTD_SHORT_CONVERTIBLE int
#else
#  define _RWSTD_SHORT_CONVERTIBLE _RWSTD_INT_CONVERTIBLE
#endif   // USHRT_MAX < UINT_MAX


// define numeric_limits<> integral specializations
_RWSTD_SPECIALIZE_LIMITS (char, _RWSTD_CHAR_CONVERTIBLE, CHAR)

_RWSTD_SPECIALIZE_LIMITS (unsigned char,
                          unsigned _RWSTD_CHAR_CONVERTIBLE, _RWSTD_UCHAR)

_RWSTD_SPECIALIZE_LIMITS (signed char, _RWSTD_CHAR_CONVERTIBLE, SCHAR)

_RWSTD_SPECIALIZE_LIMITS (short int, _RWSTD_SHORT_CONVERTIBLE, SHRT)

_RWSTD_SPECIALIZE_LIMITS (unsigned short,
                          unsigned _RWSTD_SHORT_CONVERTIBLE, _RWSTD_USHRT)

_RWSTD_SPECIALIZE_LIMITS (int, _RWSTD_INT_CONVERTIBLE, INT)

_RWSTD_SPECIALIZE_LIMITS (unsigned int,
                          unsigned _RWSTD_INT_CONVERTIBLE, _RWSTD_UINT)

_RWSTD_SPECIALIZE_LIMITS (long int, _RWSTD_LONG_CONVERTIBLE, LONG)

_RWSTD_SPECIALIZE_LIMITS (unsigned long int,
                          unsigned _RWSTD_LONG_CONVERTIBLE, _RWSTD_ULONG)


#undef _RWSTD_UCHAR_MIN
#undef _RWSTD_USHRT_MIN
#undef _RWSTD_UINT_MIN
#undef _RWSTD_ULONG_MIN

#undef _RWSTD_UCHAR_MAX
#undef _RWSTD_USHRT_MAX
#undef _RWSTD_UINT_MAX
#undef _RWSTD_ULONG_MAX

#ifndef _RWSTD_NO_NATIVE_WCHAR_T

#  define _RWSTD_WCHAR_MIN                                   \
          (  wchar_t (-1) > 0 ? 0                            \
           : sizeof (wchar_t) == sizeof (short) ? SHRT_MIN   \
           : sizeof (wchar_t) == sizeof (int)   ? INT_MIN    \
           : sizeof (wchar_t) == sizeof (long)  ? LONG_MIN   \
           : SCHAR_MIN)
                        
#  define _RWSTD_WCHAR_MAX                                       \
          (  wchar_t (-1) > 0 ?                                  \
             (  sizeof (wchar_t) == sizeof (short) ? USHRT_MAX   \
              : sizeof (wchar_t) == sizeof (int)   ? UINT_MAX    \
              : sizeof (wchar_t) == sizeof (long)  ? ULONG_MAX   \
              : SCHAR_MAX)                                       \
           : (  sizeof (wchar_t) == sizeof (short) ? SHRT_MAX    \
              : sizeof (wchar_t) == sizeof (int)   ? INT_MAX     \
              : sizeof (wchar_t) == sizeof (long)  ? LONG_MAX    \
              : UCHAR_MAX))


_RWSTD_SPECIALIZE_LIMITS (wchar_t, _RWSTD_INT_CONVERTIBLE, _RWSTD_WCHAR)

#  undef _RWSTD_WCHAR_MIN
#  undef _RWSTD_WCHAR_MAX

#endif   // _RWSTD_NO_NATIVE_WCHAR_T


#ifndef _RWSTD_NO_BOOL

#  define _RWSTD_BOOL_MIN   false
#  define _RWSTD_BOOL_MAX   true

_RWSTD_SPECIALIZE_LIMITS (bool, int, _RWSTD_BOOL)

#  undef _RWSTD_BOOL_MIN
#  undef _RWSTD_BOOL_MAX

#endif   // _RWSTD_NO_BOOL


#ifdef _RWSTD_LONG_LONG                                             // VENDOR

#  if defined (_WIN32) && defined (_MSC_VER)
#    define LONG_LONG_MIN   _I64_MIN
#    define LONG_LONG_MAX   _I64_MAX
#    define ULONG_LONG_MAX  _UI64_MAX
#  else   // if !(defined (_WIN32) && defined (_MSC_VER))

#  ifndef LONG_LONG_MIN
#    ifndef LLONG_MIN
       // assuming modulo 2 representation and a working shift
#      define LONG_LONG_MIN \
          (((_RWSTD_LONG_LONG)1) << (sizeof (_RWSTD_LONG_LONG) * CHAR_BIT - 1))
#      define LONG_LONG_MAX   (~LONG_LONG_MIN)
#      define ULONG_LONG_MAX  (~(unsigned _RWSTD_LONG_LONG)0)
#    else   // if defined (LLONG_MIN)
       // e.g., Sun libc 
#      define LONG_LONG_MIN   LLONG_MIN
#      define LONG_LONG_MAX   LLONG_MAX
#      define ULONG_LONG_MAX  ULLONG_MAX
#    endif   // LLONG_MIN
#  endif   // LONG_LONG_MIN

#endif   // _WIN32 && _MSC_VER

#  define ULONG_LONG_MIN   0

_RWSTD_SPECIALIZE_LIMITS (_RWSTD_LONG_LONG, _RWSTD_LONG_LONG, LONG_LONG)

_RWSTD_SPECIALIZE_LIMITS (unsigned _RWSTD_LONG_LONG,
                          unsigned _RWSTD_LONG_LONG, ULONG_LONG)

#  undef ULONG_LONG_MIN 

#endif   // _RWSTD_LONG_LONG


#undef _RWSTD_CHAR_CONVERTIBLE
#undef _RWSTD_SHORT_CONVERTIBLE
#undef _RWSTD_INT_CONVERTIBLE


_RWSTD_NAMESPACE_END   // std


#ifdef _RWSTD_COMPILE_INSTANTIATE
#  include <limits.cc>
#endif

#endif   // _RWSTD_LIMITS_INCLUDED