// -*- C++ -*-
/***************************************************************************
 *
 * <limits> - definitions of the numeric_limits template and specializations
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 1994-2007 Rogue Wave Software, Inc.
 * 
 **************************************************************************/

#include <rw/_defs.h>


// quiet NAN (QNAN) supported?
#ifndef _RWSTD_NO_QUIET_NAN
#  define _RWSTD_HAS_QUIET_NAN true
#else   // if defined (_RWSTD_NO_QUIET_NAN)
#  define _RWSTD_HAS_QUIET_NAN false
#endif   // _RWSTD_NO_QUIET_NAN


// does integer arithmetic trap?
#ifndef _RWSTD_NO_INT_TRAPS
#  define _RWSTD_INT_TRAPS true
#else   // if defined (_RWSTD_NO_INT_TRAPS)
#  define _RWSTD_INT_TRAPS false
#endif   // _RWSTD_NO_INT_TRAPS

// does floating point arithmetic (such as 0.0/0.0) trap?
#ifndef _RWSTD_NO_DBL_TRAPS
#  define _RWSTD_FLT_TRAPS  true
#  define _RWSTD_DBL_TRAPS  true
#  define _RWSTD_LDBL_TRAPS true
#else   // if defined (_RWSTD_NO_DBL_TRAPS)
   // invalid operations return QNAN
#  define _RWSTD_FLT_TRAPS  false
#  define _RWSTD_DBL_TRAPS  false
#  define _RWSTD_LDBL_TRAPS false
#endif   // _RWSTD_NO_DBL_TRAPS


#ifndef _RWSTD_FLT_HAS_DENORM
#  define _RWSTD_FLT_HAS_DENORM  false
#endif   // _RWSTD_FLT_HAS_DENORM

#ifndef _RWSTD_DBL_HAS_DENORM
#  define _RWSTD_DBL_HAS_DENORM  false
#endif   // _RWSTD_DBL_HAS_DENORM

#ifndef _RWSTD_LDBL_HAS_DENORM
#  define _RWSTD_LDBL_HAS_DENORM false
#endif   // _RWSTD_LDBL_HAS_DENORM

#ifndef _RWSTD_HAS_DENORM_LOSS
#  define _RWSTD_HAS_DENORM_LOSS false
#endif   // _RWSTD_HAS_DENORM_LOSS

#ifndef _RWSTD_HAS_INFINITY
#  define _RWSTD_HAS_INFINITY    true
#endif


#ifndef _RWSTD_IS_IEC559
   // assume conforming environment unless autodetected otherwise
   // or unless overridden in <rw/_config.h>
#  define _RWSTD_IS_IEC559   true
#endif   // _RWSTD_IS_IEC559


_RWSTD_NAMESPACE (__rw) {

#ifndef _RWSTD_NO_OBJECT_MANGLING

extern "C" {

#else   // if defined (_RWSTD_NO_OBJECT_MANGLING)

extern "C++" {

#endif   // _RWSTD_NO_OBJECT_MANGLING


_RWSTD_EXPORT extern const float       __rw_flt_infinity;
_RWSTD_EXPORT extern const double      __rw_dbl_infinity;

_RWSTD_EXPORT extern const float       __rw_flt_qNaN;
_RWSTD_EXPORT extern const double      __rw_dbl_qNaN;

_RWSTD_EXPORT extern const float       __rw_flt_sNaN;
_RWSTD_EXPORT extern const double      __rw_dbl_sNaN;

_RWSTD_EXPORT extern const float       __rw_flt_denorm_min;
_RWSTD_EXPORT extern const double      __rw_dbl_denorm_min;

#ifndef _RWSTD_NO_LONG_DOUBLE

_RWSTD_EXPORT extern const long double __rw_ldbl_infinity;
_RWSTD_EXPORT extern const long double __rw_ldbl_qNaN;
_RWSTD_EXPORT extern const long double __rw_ldbl_sNaN;
_RWSTD_EXPORT extern const long double __rw_ldbl_denorm_min;

#endif   // _RWSTD_NO_LONG_DOUBLE


}   // extern "C"/"C++"

}   // namespace __rw


#ifndef _RWSTD_NO_SIGNALING_NAN
#  define _RWSTD_HAS_SIG_NAN true
#else
#  define _RWSTD_HAS_SIG_NAN false
#endif   // _RWSTD_NO_SIGNALING_NAN


#undef _RWSTD_CLASS_BEGIN
#undef _RWSTD_CLASS_END
#undef _RWSTD_TYPEDEF
#undef _RWSTD_STATIC
#undef _RWSTD_STATIC_FUN


#ifndef _RWSTD_DEFINE_EXPORTS

// declarations - expanded in every translation unit
// that #includes <limits>

#  define _RWSTD_CLASS_BEGIN(name)                            \
   _RWSTD_SPECIALIZED_CLASS struct _RWSTD_EXPORT name {
#  define _RWSTD_CLASS_END              };
#  define _RWSTD_TYPEDEF(def)           typedef def;
#  define _RWSTD_STATIC(ignore, type, name, value)            \
          _RWSTD_STATIC_CONST (type, name = value)
#  define _RWSTD_STATIC_FUN(type, name, value)                \
          static type name () _THROWS (()) { return value; }

#else   // defined (_RWSTD_DEFINE_EXPORTS)

// definitions - expanded in a single translation unit that defines
// static const data members outside of each numeric_limits<> specialization

#  define _RWSTD_CLASS_BEGIN(ignore)
#  define _RWSTD_CLASS_END
#  define _RWSTD_TYPEDEF(ignore)
#  define _RWSTD_STATIC(limtype, type, name, value)           \
     _RWSTD_DEFINE_STATIC_CONST (const type numeric_limits<limtype>::name)
#  define _RWSTD_STATIC_FUN(ign1, ign2, ign3)

#endif   // _RWSTD_DEFINE_EXPORTS


// 18.2.1.2, p6 - 7
#define _RWSTD_DIGITS(type, min, max) \
  (1 == (max) ? 1 : (_RWSTD_CHAR_BIT * int (sizeof (type)) - int ((min) != 0)))

// 18.2.1.2, p9
#define _RWSTD_DIGITS10(digits)   (((digits) * 301) / 1000)


#undef _RWSTD_LIMITS_BODY

#define _RWSTD_LIMITS_BODY(type, cpfx)                                      \
    _RWSTD_STATIC (type, bool, is_specialized, true);                       \
                                                                            \
    _RWSTD_STATIC_FUN (type, (min), (type)(cpfx##_MIN))                     \
    _RWSTD_STATIC_FUN (type, (max), (type)(cpfx##_MAX))                     \
                                                                            \
    _RWSTD_STATIC (type, bool, is_signed,  cpfx##_MIN != 0);                \
    _RWSTD_STATIC (type, bool, is_integer, true);                           \
    _RWSTD_STATIC (type, bool, is_exact,   true);                           \
                                                                            \
    _RWSTD_STATIC (type, int, digits,                                       \
                   _RWSTD_DIGITS (type, cpfx##_MIN, cpfx##_MAX));           \
                                                                            \
    /* spelled out to work around a bug in IBM xlC 5.0 */                   \
    _RWSTD_STATIC (type, int, digits10,                                     \
                   _RWSTD_DIGITS10 (_RWSTD_DIGITS (type, cpfx##_MIN,        \
                                                         cpfx##_MAX)));     \
                                                                            \
    _RWSTD_STATIC (type, int, radix, 2);                                    \
                                                                            \
    _RWSTD_STATIC_FUN (type, epsilon,     0)                                \
    _RWSTD_STATIC_FUN (type, round_error, 0)                                \
                                                                            \
    _RWSTD_STATIC (type, int, min_exponent,   0);                           \
    _RWSTD_STATIC (type, int, min_exponent10, 0);                           \
    _RWSTD_STATIC (type, int, max_exponent,   0);                           \
    _RWSTD_STATIC (type, int, max_exponent10, 0);                           \
                                                                            \
    _RWSTD_STATIC (type, bool, has_infinity,             false);            \
    _RWSTD_STATIC (type, bool, has_quiet_NaN,            false);            \
    _RWSTD_STATIC (type, bool, has_signaling_NaN,        false);            \
    _RWSTD_STATIC (type, float_denorm_style, has_denorm, denorm_absent);    \
    _RWSTD_STATIC (type, bool, has_denorm_loss,          false);            \
                                                                            \
    _RWSTD_STATIC_FUN (type, infinity,      0)                              \
    _RWSTD_STATIC_FUN (type, quiet_NaN,     0)                              \
    _RWSTD_STATIC_FUN (type, signaling_NaN, 0)                              \
    _RWSTD_STATIC_FUN (type, denorm_min,    0)                              \
                                                                            \
    _RWSTD_STATIC (type, bool, is_iec559,  false);                          \
    _RWSTD_STATIC (type, bool, is_bounded, true);                           \
    _RWSTD_STATIC (type, bool, is_modulo,  1 != cpfx##_MAX);                \
                                                                            \
    _RWSTD_STATIC (type, bool, traps,           _RWSTD_INT_TRAPS);          \
    _RWSTD_STATIC (type, bool, tinyness_before, false);                     \
    _RWSTD_STATIC (type, float_round_style, round_style, round_toward_zero);


#undef _RWSTD_SPECIALIZE_LIMITS

#if    !defined (_RWSTD_NO_CLASS_PARTIAL_SPEC) \
    || defined (_RWSTD_NO_EXT_CV_QUALIFIED_LIMITS)
#  define _RWSTD_SPECIALIZE_LIMITS(T, cpfx)  \
  _RWSTD_CLASS_BEGIN (numeric_limits<T>)     \
      _RWSTD_LIMITS_BODY (T, cpfx)           \
  _RWSTD_CLASS_END
#else   // if defined (_RWSTD_NO_CLASS_PARTIAL_SPEC)
    // define specializations for all cv-qualified types
#  define _RWSTD_SPECIALIZE_LIMITS(T, cpfx)                                \
  _RWSTD_CLASS_BEGIN (numeric_limits<T>)                                   \
      _RWSTD_LIMITS_BODY (T, cpfx)                                         \
  _RWSTD_CLASS_END                                                         \
  _RWSTD_CLASS_BEGIN (numeric_limits<const T>: numeric_limits<T>)          \
  _RWSTD_CLASS_END                                                         \
  _RWSTD_CLASS_BEGIN (numeric_limits<volatile T>: numeric_limits<T>)       \
  _RWSTD_CLASS_END                                                         \
  _RWSTD_CLASS_BEGIN (numeric_limits<const volatile T>: numeric_limits<T>) \
  _RWSTD_CLASS_END
#endif   // _RWSTD_NO_CLASS_PARTIAL_SPEC


#ifndef _RWSTD_LIMITS_PRIMARY_TEMPLATE_DEFINED
#  define _RWSTD_LIMITS_PRIMARY_TEMPLATE_DEFINED


_RWSTD_NAMESPACE (std) { 


enum float_round_style
{
    round_indeterminate       = -1,
    round_toward_zero         =  0,
    round_to_nearest          =  1,
    round_toward_infinity     =  2,
    round_toward_neg_infinity =  3
};

#ifdef _RWSTD_FLT_ROUNDS
#  define _RWSTD_ROUND_STYLE                                  \
         0 == _RWSTD_FLT_ROUNDS ? round_toward_zero           \
      :  1 == _RWSTD_FLT_ROUNDS ? round_to_nearest            \
      :  2 == _RWSTD_FLT_ROUNDS ? round_toward_infinity       \
      :  3 == _RWSTD_FLT_ROUNDS ? round_toward_neg_infinity   \
      :  round_indeterminate
#else   // if !defined (_RWSTD_FLT_ROUNDS)
#  define _RWSTD_ROUND_STYLE   round_indeterminate
#endif   // _RWSTD_FLT_ROUNDS


enum float_denorm_style
{
    denorm_indeterminate = -1,
    denorm_absent        =  0,
    denorm_present       =  1
};

template <class _TypeT>
struct numeric_limits
{
    // static consts below must be initialized in class so that
    // they can be used where const expressions are required (such
    // as in template parameters)

    _RWSTD_STATIC_CONST (bool, is_specialized = false);

    static _TypeT (min)() _THROWS (()) { return _TypeT (); }
    static _TypeT (max)() _THROWS (()) { return _TypeT (); }

    _RWSTD_STATIC_CONST (int, digits   = 0);
    _RWSTD_STATIC_CONST (int, digits10 = 0);

    _RWSTD_STATIC_CONST (bool, is_signed  = false);
    _RWSTD_STATIC_CONST (bool, is_integer = false);
    _RWSTD_STATIC_CONST (bool, is_exact   = false);

    _RWSTD_STATIC_CONST (int, radix = 0);

    static _TypeT epsilon () _THROWS (())     { return _TypeT (); }
    static _TypeT round_error () _THROWS (()) { return _TypeT (); }

    _RWSTD_STATIC_CONST (int, min_exponent   = 0);
    _RWSTD_STATIC_CONST (int, min_exponent10 = 0);
    _RWSTD_STATIC_CONST (int, max_exponent   = 0);
    _RWSTD_STATIC_CONST (int, max_exponent10 = 0);

    _RWSTD_STATIC_CONST (bool, has_infinity             = false);
    _RWSTD_STATIC_CONST (bool, has_quiet_NaN            = false);
    _RWSTD_STATIC_CONST (bool, has_signaling_NaN        = false);
    _RWSTD_STATIC_CONST (float_denorm_style, has_denorm = denorm_absent);
    _RWSTD_STATIC_CONST (bool, has_denorm_loss          = false);

    static _TypeT infinity () _THROWS (())      { return _TypeT (); }
    static _TypeT quiet_NaN () _THROWS (())     { return _TypeT (); }
    static _TypeT signaling_NaN () _THROWS (()) { return _TypeT (); }
    static _TypeT denorm_min () _THROWS (())    { return _TypeT (); }

    _RWSTD_STATIC_CONST (bool, is_iec559        = false);
    _RWSTD_STATIC_CONST (bool, is_bounded       = false);
    _RWSTD_STATIC_CONST (bool, is_modulo        = false);
    _RWSTD_STATIC_CONST (bool, traps            = false);
    _RWSTD_STATIC_CONST (bool, tinyness_before  = false);
    _RWSTD_STATIC_CONST (float_round_style, round_style = round_toward_zero);
};

}   // namespace std


#endif   // _RWSTD_LIMITS_PRIMARY_TEMPLATE_DEFINED


#ifndef _RWSTD_LIMITS_INCLUDED
#define _RWSTD_LIMITS_INCLUDED


_RWSTD_NAMESPACE (std) { 


_RWSTD_CLASS_BEGIN (numeric_limits<float>)

    _RWSTD_STATIC (float, bool, is_specialized, true);

    _RWSTD_STATIC_FUN (float, (min), _RWSTD_FLT_MIN)
    _RWSTD_STATIC_FUN (float, (max), _RWSTD_FLT_MAX)

    _RWSTD_STATIC (float, int, digits,   _RWSTD_FLT_MANT_DIG);
    _RWSTD_STATIC (float, int, digits10, _RWSTD_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,      _RWSTD_FLT_RADIX);

    _RWSTD_STATIC_FUN (float, epsilon,     _RWSTD_FLT_EPSILON)
    _RWSTD_STATIC_FUN (float, round_error, 0.5f)

    _RWSTD_STATIC (float, int, min_exponent,   _RWSTD_FLT_MIN_EXP);
    _RWSTD_STATIC (float, int, min_exponent10, _RWSTD_FLT_MIN_10_EXP);
    _RWSTD_STATIC (float, int, max_exponent,   _RWSTD_FLT_MAX_EXP);
    _RWSTD_STATIC (float, int, max_exponent10, _RWSTD_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,
                   float_denorm_style (_RWSTD_FLT_HAS_DENORM));
    _RWSTD_STATIC (float, bool, has_denorm_loss, _RWSTD_HAS_DENORM_LOSS);

    _RWSTD_STATIC_FUN (float, infinity,      _RW::__rw_flt_infinity)
    _RWSTD_STATIC_FUN (float, quiet_NaN,     _RW::__rw_flt_qNaN)
    _RWSTD_STATIC_FUN (float, signaling_NaN, _RW::__rw_flt_sNaN)
    _RWSTD_STATIC_FUN (float, denorm_min,    _RW::__rw_flt_denorm_min)

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

    _RWSTD_STATIC (float, bool, traps, _RWSTD_FLT_TRAPS);
    _RWSTD_STATIC (float, bool, tinyness_before, false);

    _RWSTD_STATIC (float, float_round_style, round_style, _RWSTD_ROUND_STYLE);

_RWSTD_CLASS_END   // numeric_limits<float>


_RWSTD_CLASS_BEGIN (numeric_limits<double>)

    _RWSTD_STATIC (double, bool, is_specialized, true);

    _RWSTD_STATIC_FUN (double, (min), _RWSTD_DBL_MIN)
    _RWSTD_STATIC_FUN (double, (max), _RWSTD_DBL_MAX)

    _RWSTD_STATIC (double, int, digits,   _RWSTD_DBL_MANT_DIG);
    _RWSTD_STATIC (double, int, digits10, _RWSTD_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,      _RWSTD_FLT_RADIX);

    _RWSTD_STATIC_FUN (double, epsilon,     _RWSTD_DBL_EPSILON)
    _RWSTD_STATIC_FUN (double, round_error, 0.5)

    _RWSTD_STATIC (double, int, min_exponent,   _RWSTD_DBL_MIN_EXP);
    _RWSTD_STATIC (double, int, min_exponent10, _RWSTD_DBL_MIN_10_EXP);
    _RWSTD_STATIC (double, int, max_exponent,   _RWSTD_DBL_MAX_EXP);
    _RWSTD_STATIC (double, int, max_exponent10, _RWSTD_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,
                   float_denorm_style (_RWSTD_DBL_HAS_DENORM));
    _RWSTD_STATIC (double, bool, has_denorm_loss,   _RWSTD_HAS_DENORM_LOSS);

    _RWSTD_STATIC_FUN (double, infinity,      _RW::__rw_dbl_infinity)
    _RWSTD_STATIC_FUN (double, quiet_NaN,     _RW::__rw_dbl_qNaN)
    _RWSTD_STATIC_FUN (double, signaling_NaN, _RW::__rw_dbl_sNaN)
    _RWSTD_STATIC_FUN (double, denorm_min,    _RW::__rw_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);

    _RWSTD_STATIC (double, bool, traps, _RWSTD_DBL_TRAPS);
    _RWSTD_STATIC (double, bool, tinyness_before, false);

    _RWSTD_STATIC (double, float_round_style, round_style, _RWSTD_ROUND_STYLE);

_RWSTD_CLASS_END   // numeric_limits<double>


#ifndef _RWSTD_NO_LONG_DOUBLE

_RWSTD_CLASS_BEGIN (numeric_limits<long double>)

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

    _RWSTD_STATIC_FUN (long double, (min), _RWSTD_LDBL_MIN) 
    _RWSTD_STATIC_FUN (long double, (max), _RWSTD_LDBL_MAX) 

    _RWSTD_STATIC (long double, int, digits,   _RWSTD_LDBL_MANT_DIG);
    _RWSTD_STATIC (long double, int, digits10, _RWSTD_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,      _RWSTD_FLT_RADIX);

    _RWSTD_STATIC_FUN (long double, epsilon,     _RWSTD_LDBL_EPSILON) 
    _RWSTD_STATIC_FUN (long double, round_error, 0.5L) 

    _RWSTD_STATIC (long double, int, min_exponent,   _RWSTD_LDBL_MIN_EXP);
    _RWSTD_STATIC (long double, int, min_exponent10, _RWSTD_LDBL_MIN_10_EXP);
    _RWSTD_STATIC (long double, int, max_exponent,   _RWSTD_LDBL_MAX_EXP);
    _RWSTD_STATIC (long double, int, max_exponent10, _RWSTD_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,
                   float_denorm_style (_RWSTD_LDBL_HAS_DENORM));
    _RWSTD_STATIC (long double, bool, has_denorm_loss, _RWSTD_HAS_DENORM_LOSS);

    _RWSTD_STATIC_FUN (long double, infinity,      _RW::__rw_ldbl_infinity)
    _RWSTD_STATIC_FUN (long double, quiet_NaN,     _RW::__rw_ldbl_qNaN)
    _RWSTD_STATIC_FUN (long double, signaling_NaN, _RW::__rw_ldbl_sNaN)
    _RWSTD_STATIC_FUN (long double, denorm_min,    _RW::__rw_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);

    _RWSTD_STATIC (long double, bool, traps, _RWSTD_LDBL_TRAPS);
    _RWSTD_STATIC (long double, bool, tinyness_before, false);

    _RWSTD_STATIC (long double, float_round_style, round_style,
                   _RWSTD_ROUND_STYLE);

_RWSTD_CLASS_END    // numeric_limits<long double>

#endif   // _RWSTD_NO_LONG_DOUBLE


// define numeric_limits<> integral specializations
_RWSTD_SPECIALIZE_LIMITS (char,              _RWSTD_CHAR)
_RWSTD_SPECIALIZE_LIMITS (unsigned char,     _RWSTD_UCHAR)
_RWSTD_SPECIALIZE_LIMITS (signed char,       _RWSTD_SCHAR)
_RWSTD_SPECIALIZE_LIMITS (short int,         _RWSTD_SHRT)
_RWSTD_SPECIALIZE_LIMITS (unsigned short,    _RWSTD_USHRT)
_RWSTD_SPECIALIZE_LIMITS (int,               _RWSTD_INT)
_RWSTD_SPECIALIZE_LIMITS (unsigned int,      _RWSTD_UINT)
_RWSTD_SPECIALIZE_LIMITS (long int,          _RWSTD_LONG)
_RWSTD_SPECIALIZE_LIMITS (unsigned long int, _RWSTD_ULONG)


#ifndef _RWSTD_NO_WCHAR_T
#  ifndef _RWSTD_NO_NATIVE_WCHAR_T

_RWSTD_SPECIALIZE_LIMITS (wchar_t, _RWSTD_WCHAR)

#  endif   // _RWSTD_NO_NATIVE_WCHAR_T
#endif   // _RWSTD_NO_WCHAR_T


#ifndef _RWSTD_NO_BOOL
#  ifndef _RWSTD_NO_NATIVE_BOOL

_RWSTD_SPECIALIZE_LIMITS (bool, _RWSTD_BOOL)

#  endif   // _RWSTD_NO_NATIVE_BOOL
#endif   // _RWSTD_NO_BOOL


#ifdef _RWSTD_LONG_LONG

_RWSTD_SPECIALIZE_LIMITS (_RWSTD_LONG_LONG, _RWSTD_LLONG)
_RWSTD_SPECIALIZE_LIMITS (unsigned _RWSTD_LONG_LONG, _RWSTD_ULLONG)

#endif   // _RWSTD_LONG_LONG


#ifndef _RWSTD_LIMITS_PARTIAL_SPEC_DEFINED
#  define _RWSTD_LIMITS_PARTIAL_SPEC_DEFINED

#  ifndef _RWSTD_NO_EXT_CV_QUALIFIED_LIMITS
#    ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC

template <class _TypeT>
struct numeric_limits<const _TypeT>: numeric_limits<_TypeT> { };

template <class _TypeT>
struct numeric_limits<volatile _TypeT>: numeric_limits<_TypeT> { };

template <class _TypeT>
struct numeric_limits<const volatile _TypeT>: numeric_limits<_TypeT> { };

#    endif   // _RWSTD_NO_CLASS_PARTIAL_SPEC
#  endif   // _RWSTD_NO_EXT_CV_QUALIFIED_LIMITS
#endif   // _RWSTD_LIMITS_PARTIAL_SPEC_DEFINED

}   // namespace std


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

#endif   // _RWSTD_LIMITS_INCLUDED