stl/_limits.c - platform/external/stlport - Git at Google

 /*
  * Copyright (c) 1998,1999
  * Silicon Graphics Computer Systems, Inc.
  *
  * Copyright (c) 1999
  * Boris Fomitchev
  *
  * This material is provided "as is", with absolutely no warranty expressed
  * or implied. Any use is at your own risk.
  *
  * Permission to use or copy this software for any purpose is hereby granted
  * without fee, provided the above notices are retained on all copies.
  * Permission to modify the code and to distribute modified code is granted,
  * provided the above notices are retained, and a notice that the code was
  * modified is included with the above copyright notice.
  *
  */

 #ifndef _STLP_LIMITS_C
 #define _STLP_LIMITS_C

 #ifndef _STLP_INTERNAL_LIMITS
 #  include <stl/_limits.h>
 #endif

 //==========================================================
 //  numeric_limits static members
 //==========================================================

 _STLP_BEGIN_NAMESPACE

 _STLP_MOVE_TO_PRIV_NAMESPACE

 #if !defined (_STLP_STATIC_CONST_INIT_BUG)

 #  define __declare_numeric_base_member(__type, __mem, _Init) \
 template <class __number> \
   const __type _Numeric_limits_base<__number>:: __mem

 __declare_numeric_base_member(bool, is_specialized, false);
 __declare_numeric_base_member(int, digits, 0);
 __declare_numeric_base_member(int, digits10, 0);
 __declare_numeric_base_member(bool, is_signed, false);
 __declare_numeric_base_member(bool, is_integer, false);
 __declare_numeric_base_member(bool, is_exact, false);
 __declare_numeric_base_member(int, radix, 0);
 __declare_numeric_base_member(int, min_exponent, 0);
 __declare_numeric_base_member(int, max_exponent, 0);
 __declare_numeric_base_member(int, min_exponent10, 0);
 __declare_numeric_base_member(int, max_exponent10, 0);
 __declare_numeric_base_member(bool, has_infinity, false);
 __declare_numeric_base_member(bool, has_quiet_NaN, false);
 __declare_numeric_base_member(bool, has_signaling_NaN, false);
 __declare_numeric_base_member(float_denorm_style, has_denorm, denorm_absent);
 __declare_numeric_base_member(bool, has_denorm_loss, false);
 __declare_numeric_base_member(bool, is_iec559, false);
 __declare_numeric_base_member(bool, is_bounded, false);
 __declare_numeric_base_member(bool, is_modulo, false);
 __declare_numeric_base_member(bool, traps, false);
 __declare_numeric_base_member(bool, tinyness_before, false);
 __declare_numeric_base_member(float_round_style, round_style, round_toward_zero);

 #  undef __declare_numeric_base_member

 #  define __declare_integer_limits_member(__type, __mem, _Init) \
 template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> \
   const __type _Integer_limits<_Int, __imin, __imax, __idigits, __ismod>:: __mem

 __declare_integer_limits_member(bool, is_specialized, true);
 __declare_integer_limits_member(int, digits, (__idigits < 0) ? \
           ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) \
                             : (__idigits) );
 __declare_integer_limits_member(int, digits10, (int)(301UL * digits) /1000);
 __declare_integer_limits_member(bool, is_signed, __imin != 0);
 __declare_integer_limits_member(bool, is_integer, true);
 __declare_integer_limits_member(bool, is_exact, true);
 __declare_integer_limits_member(int, radix, 2);
 __declare_integer_limits_member(bool, is_bounded, true);
 __declare_integer_limits_member(bool, is_modulo, true);
 #  undef __declare_integer_limits_member

 #  define __declare_float_limits_member(__type, __mem, _Init) \
 template <class __number,  \
          int __Digits, int __Digits10,    \
          int __MinExp, int __MaxExp,      \
          int __MinExp10, int __MaxExp10,  \
          bool __IsIEC559, \
          float_round_style __RoundStyle> \
 const __type _Floating_limits< __number, __Digits, __Digits10,    \
          __MinExp, __MaxExp, __MinExp10, __MaxExp10,  \
          __IsIEC559, __RoundStyle>::\
          __mem

 __declare_float_limits_member(bool, is_specialized, true);
 __declare_float_limits_member(int, digits, __Digits);
 __declare_float_limits_member(int, digits10, __Digits10);
 __declare_float_limits_member(bool, is_signed, true);
 __declare_float_limits_member(int, radix, FLT_RADIX);
 __declare_float_limits_member(int, min_exponent, __MinExp);
 __declare_float_limits_member(int, max_exponent, __MaxExp);
 __declare_float_limits_member(int, min_exponent10, __MinExp10);
 __declare_float_limits_member(int, max_exponent10, __MaxExp10);
 __declare_float_limits_member(bool, has_infinity, true);
 __declare_float_limits_member(bool, has_quiet_NaN, true);
 __declare_float_limits_member(bool, has_signaling_NaN, true);
 __declare_float_limits_member(float_denorm_style, has_denorm, denorm_indeterminate);
 __declare_float_limits_member(bool, has_denorm_loss, false);
 __declare_float_limits_member(bool, is_iec559, __IsIEC559);
 __declare_float_limits_member(bool, is_bounded, true);
 __declare_float_limits_member(bool, traps, true);
 __declare_float_limits_member(bool, tinyness_before, false);
 __declare_float_limits_member(float_round_style, round_style, __RoundStyle);
 #  undef __declare_float_limits_member

 #endif /* _STLP_STATIC_CONST_INIT_BUG */


 #if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)

 #  if defined (_STLP_BIG_ENDIAN)
 #    if defined (__OS400__)
 #      define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
 #      define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
 #      define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
 #      define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
 #      define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
 #      define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
 #      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
 #      define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
 #      define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
 #    else /* __OS400__ */
 #      define _STLP_FLOAT_INF_REP   { 0x7f80, 0 }
 #      define _STLP_FLOAT_QNAN_REP  { 0x7fc1, 0 }
 #      define _STLP_FLOAT_SNAN_REP  { 0x7f81, 0 }
 #      define _STLP_DOUBLE_INF_REP  { 0x7ff0, 0, 0, 0 }
 #      define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
 #      define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
 #      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
 #      define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
 #      define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
 #    endif /* __OS400__ */

 #  elif defined (_STLP_LITTLE_ENDIAN)

 #    if 0 /* defined(_STLP_MSVC) || defined(__linux__) */
 // some IA-32 platform ??
 /*
 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 #      define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
 #      define _STLP_FLOAT_SNAN_REP { 0, 0xff80 }

 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
 #      define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0xfff0 }
 #      define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 } // ????
 #      define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 } // ????
 #      define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF0, 0 } // ????
 */
 #    elif defined(__DECCXX)

 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 #      define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
 #      define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }

 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
 #      define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }

 #      define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
 #      define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
 #      define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
 #    else
 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 #      define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
 #      define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
 #      define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
 #      if defined (_STLP_MSVC) || defined (__ICL)
 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
 #      elif defined (__BORLANDC__)
 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
 #      else
 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
 #      endif
 #    endif
 #  else
 /* This is an architecture we don't know how to handle. Return some
 obviously wrong values. */
 #    define _STLP_FLOAT_INF_REP { 0, 0 }
 #    define _STLP_FLOAT_QNAN_REP { 0, 0 }
 #    define _STLP_FLOAT_SNAN_REP { 0, 0 }
 #    define _STLP_DOUBLE_INF_REP { 0, 0 }
 #    define _STLP_DOUBLE_QNAN_REP { 0, 0 }
 #    define _STLP_DOUBLE_SNAN_REP { 0, 0 }
 #    define _STLP_LDOUBLE_INF_REP { 0 }
 #    define _STLP_LDOUBLE_QNAN_REP { 0 }
 #    define _STLP_LDOUBLE_SNAN_REP { 0 }

 #  endif

 #  if 0
 /*
 #    if defined(_STLP_BIG_ENDIAN)

 #    elif defined (_STLP_LITTLE_ENDIAN)
 #    else

 //This is an architecture we don't know how to handle.  Return some
 //obviously wrong values.
 #      define _STLP_FLOAT_INF_REP  { 0, 0 }
 #      define _STLP_FLOAT_QNAN_REP { 0, 0 }
 #      define _STLP_FLOAT_SNAN_REP { 0, 0 }
 #      define _STLP_DOUBLE_INF_REP  { 0, 0 }
 #      define _STLP_DOUBLE_QNAN_REP { 0, 0 }
 #      define _STLP_DOUBLE_SNAN_REP { 0, 0 }
 #      define _STLP_LDOUBLE_INF_REP  { 0 }
 #      define _STLP_LDOUBLE_QNAN_REP { 0 }
 #      define _STLP_LDOUBLE_SNAN_REP { 0 }
 #    endif
 */
 #  endif

 union _F_rep {
   unsigned short rep[2];
   float val;
 };
 union _D_rep {
   unsigned short rep[4];
   double val;
 };

 #  ifndef _STLP_NO_LONG_DOUBLE
 union _LD_rep {
   unsigned short rep[8];
   long double val;
 };
 #  endif

 template <class __dummy>
 float _STLP_CALL _LimG<__dummy>::get_F_inf() {
   _F_rep _F_inf = {_STLP_FLOAT_INF_REP};
   return _F_inf.val;
 }
 template <class __dummy>
 float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
   _F_rep _F_qNaN = {_STLP_FLOAT_QNAN_REP};
   return _F_qNaN.val;
 }
 template <class __dummy>
 float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
   _F_rep _F_sNaN = {_STLP_FLOAT_SNAN_REP};
   return _F_sNaN.val;
 }

 template <class __dummy>
 double _STLP_CALL _LimG<__dummy>::get_D_inf() {
   _D_rep _D_inf = {_STLP_DOUBLE_INF_REP};
   return _D_inf.val;
 }
 template <class __dummy>
 double _STLP_CALL _LimG<__dummy>::get_D_qNaN() {
   _D_rep _D_qNaN = {_STLP_DOUBLE_QNAN_REP};
   return _D_qNaN.val;
 }
 template <class __dummy>
 double _STLP_CALL _LimG<__dummy>::get_D_sNaN() {
   _D_rep _D_sNaN = {_STLP_DOUBLE_SNAN_REP};
   return _D_sNaN.val;
 }

 #  if !defined (_STLP_NO_LONG_DOUBLE)
 template <class __dummy>
 long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
   _LD_rep _LD_inf = {_STLP_LDOUBLE_INF_REP};
   return _LD_inf.val;
 }
 template <class __dummy>
 long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
   _LD_rep _LD_qNaN = {_STLP_LDOUBLE_QNAN_REP};
   return _LD_qNaN.val;
 }
 template <class __dummy>
 long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
   _LD_rep _LD_sNaN = {_STLP_LDOUBLE_SNAN_REP};
   return _LD_sNaN.val;
 }
 #  endif /* _STLP_NO_LONG_DOUBLE */

 #endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */

 #undef _STLP_LIMITS_MIN_TYPE
 #undef _STLP_LIMITS_MAX_TYPE

 #undef _STLP_FLOAT_INF_REP
 #undef _STLP_FLOAT_QNAN_REP
 #undef _STLP_FLOAT_SNAN_REP
 #undef _STLP_DOUBLE_INF_REP
 #undef _STLP_DOUBLE_QNAN_REP
 #undef _STLP_DOUBLE_SNAN_REP
 #undef _STLP_LDOUBLE_INF_REP
 #undef _STLP_LDOUBLE_QNAN_REP
 #undef _STLP_LDOUBLE_SNAN_REP

 _STLP_MOVE_TO_STD_NAMESPACE

 _STLP_END_NAMESPACE

 #endif /* _STLP_LIMITS_C_INCLUDED */
	/*
	* Copyright (c) 1998,1999
	* Silicon Graphics Computer Systems, Inc.
	*
	* Copyright (c) 1999
	* Boris Fomitchev
	*
	* This material is provided "as is", with absolutely no warranty expressed
	* or implied. Any use is at your own risk.
	*
	* Permission to use or copy this software for any purpose is hereby granted
	* without fee, provided the above notices are retained on all copies.
	* Permission to modify the code and to distribute modified code is granted,
	* provided the above notices are retained, and a notice that the code was
	* modified is included with the above copyright notice.
	*
	*/

	#ifndef _STLP_LIMITS_C
	#define _STLP_LIMITS_C

	#ifndef _STLP_INTERNAL_LIMITS
	# include <stl/_limits.h>
	#endif

	//==========================================================
	// numeric_limits static members
	//==========================================================

	_STLP_BEGIN_NAMESPACE

	_STLP_MOVE_TO_PRIV_NAMESPACE

	#if !defined (_STLP_STATIC_CONST_INIT_BUG)

	# define __declare_numeric_base_member(__type, __mem, _Init) \
	template <class __number> \
	const __type _Numeric_limits_base<__number>:: __mem

	__declare_numeric_base_member(bool, is_specialized, false);
	__declare_numeric_base_member(int, digits, 0);
	__declare_numeric_base_member(int, digits10, 0);
	__declare_numeric_base_member(bool, is_signed, false);
	__declare_numeric_base_member(bool, is_integer, false);
	__declare_numeric_base_member(bool, is_exact, false);
	__declare_numeric_base_member(int, radix, 0);
	__declare_numeric_base_member(int, min_exponent, 0);
	__declare_numeric_base_member(int, max_exponent, 0);
	__declare_numeric_base_member(int, min_exponent10, 0);
	__declare_numeric_base_member(int, max_exponent10, 0);
	__declare_numeric_base_member(bool, has_infinity, false);
	__declare_numeric_base_member(bool, has_quiet_NaN, false);
	__declare_numeric_base_member(bool, has_signaling_NaN, false);
	__declare_numeric_base_member(float_denorm_style, has_denorm, denorm_absent);
	__declare_numeric_base_member(bool, has_denorm_loss, false);
	__declare_numeric_base_member(bool, is_iec559, false);
	__declare_numeric_base_member(bool, is_bounded, false);
	__declare_numeric_base_member(bool, is_modulo, false);
	__declare_numeric_base_member(bool, traps, false);
	__declare_numeric_base_member(bool, tinyness_before, false);
	__declare_numeric_base_member(float_round_style, round_style, round_toward_zero);

	# undef __declare_numeric_base_member

	# define __declare_integer_limits_member(__type, __mem, _Init) \
	template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> \
	const __type _Integer_limits<_Int, __imin, __imax, __idigits, __ismod>:: __mem

	__declare_integer_limits_member(bool, is_specialized, true);
	__declare_integer_limits_member(int, digits, (__idigits < 0) ? \
	((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) \
	: (__idigits) );
	__declare_integer_limits_member(int, digits10, (int)(301UL * digits) /1000);
	__declare_integer_limits_member(bool, is_signed, __imin != 0);
	__declare_integer_limits_member(bool, is_integer, true);
	__declare_integer_limits_member(bool, is_exact, true);
	__declare_integer_limits_member(int, radix, 2);
	__declare_integer_limits_member(bool, is_bounded, true);
	__declare_integer_limits_member(bool, is_modulo, true);
	# undef __declare_integer_limits_member

	# define __declare_float_limits_member(__type, __mem, _Init) \
	template <class __number, \
	int __Digits, int __Digits10, \
	int __MinExp, int __MaxExp, \
	int __MinExp10, int __MaxExp10, \
	bool __IsIEC559, \
	float_round_style __RoundStyle> \
	const __type _Floating_limits< __number, __Digits, __Digits10, \
	__MinExp, __MaxExp, __MinExp10, __MaxExp10, \
	__IsIEC559, __RoundStyle>::\
	__mem

	__declare_float_limits_member(bool, is_specialized, true);
	__declare_float_limits_member(int, digits, __Digits);
	__declare_float_limits_member(int, digits10, __Digits10);
	__declare_float_limits_member(bool, is_signed, true);
	__declare_float_limits_member(int, radix, FLT_RADIX);
	__declare_float_limits_member(int, min_exponent, __MinExp);
	__declare_float_limits_member(int, max_exponent, __MaxExp);
	__declare_float_limits_member(int, min_exponent10, __MinExp10);
	__declare_float_limits_member(int, max_exponent10, __MaxExp10);
	__declare_float_limits_member(bool, has_infinity, true);
	__declare_float_limits_member(bool, has_quiet_NaN, true);
	__declare_float_limits_member(bool, has_signaling_NaN, true);
	__declare_float_limits_member(float_denorm_style, has_denorm, denorm_indeterminate);
	__declare_float_limits_member(bool, has_denorm_loss, false);
	__declare_float_limits_member(bool, is_iec559, __IsIEC559);
	__declare_float_limits_member(bool, is_bounded, true);
	__declare_float_limits_member(bool, traps, true);
	__declare_float_limits_member(bool, tinyness_before, false);
	__declare_float_limits_member(float_round_style, round_style, __RoundStyle);
	# undef __declare_float_limits_member

	#endif /* _STLP_STATIC_CONST_INIT_BUG */


	#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)

	# if defined (_STLP_BIG_ENDIAN)
	# if defined (__OS400__)
	# define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
	# define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
	# define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
	# define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
	# define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
	# define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
	# define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
	# define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
	# define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
	# else /* __OS400__ */
	# define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
	# define _STLP_FLOAT_QNAN_REP { 0x7fc1, 0 }
	# define _STLP_FLOAT_SNAN_REP { 0x7f81, 0 }
	# define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
	# define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
	# define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
	# define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
	# define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
	# define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
	# endif /* __OS400__ */

	# elif defined (_STLP_LITTLE_ENDIAN)

	# if 0 /* defined(_STLP_MSVC) \|\| defined(__linux__) */
	// some IA-32 platform ??
	/*
	# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
	# define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
	# define _STLP_FLOAT_SNAN_REP { 0, 0xff80 }

	# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
	# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
	# define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0xfff0 }
	# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 } // ????
	# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 } // ????
	# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF0, 0 } // ????
	*/
	# elif defined(__DECCXX)

	# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
	# define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
	# define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }

	# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
	# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
	# define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }

	# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
	# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
	# define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
	# else
	# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
	# define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
	# define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
	# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
	# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
	# define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
	# if defined (_STLP_MSVC) \|\| defined (__ICL)
	# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
	# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
	# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
	# elif defined (__BORLANDC__)
	# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
	# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
	# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
	# else
	# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
	# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
	# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
	# endif
	# endif
	# else
	/* This is an architecture we don't know how to handle. Return some
	obviously wrong values. */
	# define _STLP_FLOAT_INF_REP { 0, 0 }
	# define _STLP_FLOAT_QNAN_REP { 0, 0 }
	# define _STLP_FLOAT_SNAN_REP { 0, 0 }
	# define _STLP_DOUBLE_INF_REP { 0, 0 }
	# define _STLP_DOUBLE_QNAN_REP { 0, 0 }
	# define _STLP_DOUBLE_SNAN_REP { 0, 0 }
	# define _STLP_LDOUBLE_INF_REP { 0 }
	# define _STLP_LDOUBLE_QNAN_REP { 0 }
	# define _STLP_LDOUBLE_SNAN_REP { 0 }

	# endif

	# if 0
	/*
	# if defined(_STLP_BIG_ENDIAN)

	# elif defined (_STLP_LITTLE_ENDIAN)
	# else

	//This is an architecture we don't know how to handle. Return some
	//obviously wrong values.
	# define _STLP_FLOAT_INF_REP { 0, 0 }
	# define _STLP_FLOAT_QNAN_REP { 0, 0 }
	# define _STLP_FLOAT_SNAN_REP { 0, 0 }
	# define _STLP_DOUBLE_INF_REP { 0, 0 }
	# define _STLP_DOUBLE_QNAN_REP { 0, 0 }
	# define _STLP_DOUBLE_SNAN_REP { 0, 0 }
	# define _STLP_LDOUBLE_INF_REP { 0 }
	# define _STLP_LDOUBLE_QNAN_REP { 0 }
	# define _STLP_LDOUBLE_SNAN_REP { 0 }
	# endif
	*/
	# endif

	union _F_rep {
	unsigned short rep[2];
	float val;
	};
	union _D_rep {
	unsigned short rep[4];
	double val;
	};

	# ifndef _STLP_NO_LONG_DOUBLE
	union _LD_rep {
	unsigned short rep[8];
	long double val;
	};
	# endif

	template <class __dummy>
	float _STLP_CALL _LimG<__dummy>::get_F_inf() {
	_F_rep _F_inf = {_STLP_FLOAT_INF_REP};
	return _F_inf.val;
	}
	template <class __dummy>
	float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
	_F_rep _F_qNaN = {_STLP_FLOAT_QNAN_REP};
	return _F_qNaN.val;
	}
	template <class __dummy>
	float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
	_F_rep _F_sNaN = {_STLP_FLOAT_SNAN_REP};
	return _F_sNaN.val;
	}

	template <class __dummy>
	double _STLP_CALL _LimG<__dummy>::get_D_inf() {
	_D_rep _D_inf = {_STLP_DOUBLE_INF_REP};
	return _D_inf.val;
	}
	template <class __dummy>
	double _STLP_CALL _LimG<__dummy>::get_D_qNaN() {
	_D_rep _D_qNaN = {_STLP_DOUBLE_QNAN_REP};
	return _D_qNaN.val;
	}
	template <class __dummy>
	double _STLP_CALL _LimG<__dummy>::get_D_sNaN() {
	_D_rep _D_sNaN = {_STLP_DOUBLE_SNAN_REP};
	return _D_sNaN.val;
	}

	# if !defined (_STLP_NO_LONG_DOUBLE)
	template <class __dummy>
	long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
	_LD_rep _LD_inf = {_STLP_LDOUBLE_INF_REP};
	return _LD_inf.val;
	}
	template <class __dummy>
	long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
	_LD_rep _LD_qNaN = {_STLP_LDOUBLE_QNAN_REP};
	return _LD_qNaN.val;
	}
	template <class __dummy>
	long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
	_LD_rep _LD_sNaN = {_STLP_LDOUBLE_SNAN_REP};
	return _LD_sNaN.val;
	}
	# endif /* _STLP_NO_LONG_DOUBLE */

	#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */

	#undef _STLP_LIMITS_MIN_TYPE
	#undef _STLP_LIMITS_MAX_TYPE

	#undef _STLP_FLOAT_INF_REP
	#undef _STLP_FLOAT_QNAN_REP
	#undef _STLP_FLOAT_SNAN_REP
	#undef _STLP_DOUBLE_INF_REP
	#undef _STLP_DOUBLE_QNAN_REP
	#undef _STLP_DOUBLE_SNAN_REP
	#undef _STLP_LDOUBLE_INF_REP
	#undef _STLP_LDOUBLE_QNAN_REP
	#undef _STLP_LDOUBLE_SNAN_REP

	_STLP_MOVE_TO_STD_NAMESPACE

	_STLP_END_NAMESPACE

	#endif /* _STLP_LIMITS_C_INCLUDED */