include/c++/stl/stl/_limits.c

   1 /*
   2  * Copyright (c) 1998,1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18
  19 #ifndef _STLP_LIMITS_C
  20 #define _STLP_LIMITS_C
  21
  22 #ifndef _STLP_INTERNAL_LIMITS
  23 #  include <stl/_limits.h>
  24 #endif
  25
  26 //==========================================================
  27 //  numeric_limits static members
  28 //==========================================================
  29
  30 _STLP_BEGIN_NAMESPACE
  31
  32 _STLP_MOVE_TO_PRIV_NAMESPACE
  33
  34 #if !defined (_STLP_STATIC_CONST_INIT_BUG)
  35
  36 #  define __declare_numeric_base_member(__type, __mem, _Init) \
  37 template <class __number> \
  38   const __type _Numeric_limits_base<__number>:: __mem
  39
  40 __declare_numeric_base_member(bool, is_specialized, false);
  41 __declare_numeric_base_member(int, digits, 0);
  42 __declare_numeric_base_member(int, digits10, 0);
  43 __declare_numeric_base_member(bool, is_signed, false);
  44 __declare_numeric_base_member(bool, is_integer, false);
  45 __declare_numeric_base_member(bool, is_exact, false);
  46 __declare_numeric_base_member(int, radix, 0);
  47 __declare_numeric_base_member(int, min_exponent, 0);
  48 __declare_numeric_base_member(int, max_exponent, 0);
  49 __declare_numeric_base_member(int, min_exponent10, 0);
  50 __declare_numeric_base_member(int, max_exponent10, 0);
  51 __declare_numeric_base_member(bool, has_infinity, false);
  52 __declare_numeric_base_member(bool, has_quiet_NaN, false);
  53 __declare_numeric_base_member(bool, has_signaling_NaN, false);
  54 __declare_numeric_base_member(float_denorm_style, has_denorm, denorm_absent);
  55 __declare_numeric_base_member(bool, has_denorm_loss, false);
  56 __declare_numeric_base_member(bool, is_iec559, false);
  57 __declare_numeric_base_member(bool, is_bounded, false);
  58 __declare_numeric_base_member(bool, is_modulo, false);
  59 __declare_numeric_base_member(bool, traps, false);
  60 __declare_numeric_base_member(bool, tinyness_before, false);
  61 __declare_numeric_base_member(float_round_style, round_style, round_toward_zero);
  62
  63 #  undef __declare_numeric_base_member
  64
  65 #  define __declare_integer_limits_member(__type, __mem, _Init) \
  66 template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> \
  67   const __type _Integer_limits<_Int, __imin, __imax, __idigits, __ismod>:: __mem
  68
  69 __declare_integer_limits_member(bool, is_specialized, true);
  70 __declare_integer_limits_member(int, digits, (__idigits < 0) ? \
  71           ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) \
  72                             : (__idigits) );
  73 __declare_integer_limits_member(int, digits10, (int)(301UL * digits) /1000);
  74 __declare_integer_limits_member(bool, is_signed, __imin != 0);
  75 __declare_integer_limits_member(bool, is_integer, true);
  76 __declare_integer_limits_member(bool, is_exact, true);
  77 __declare_integer_limits_member(int, radix, 2);
  78 __declare_integer_limits_member(bool, is_bounded, true);
  79 __declare_integer_limits_member(bool, is_modulo, true);
  80 #  undef __declare_integer_limits_member
  81
  82 #  define __declare_float_limits_member(__type, __mem, _Init) \
  83 template <class __number,  \
  84          int __Digits, int __Digits10,    \
  85          int __MinExp, int __MaxExp,      \
  86          int __MinExp10, int __MaxExp10,  \
  87          bool __IsIEC559, \
  88          float_round_style __RoundStyle> \
  89 const __type _Floating_limits< __number, __Digits, __Digits10,    \
  90          __MinExp, __MaxExp, __MinExp10, __MaxExp10,  \
  91          __IsIEC559, __RoundStyle>::\
  92          __mem
  93
  94 __declare_float_limits_member(bool, is_specialized, true);
  95 __declare_float_limits_member(int, digits, __Digits);
  96 __declare_float_limits_member(int, digits10, __Digits10);
  97 __declare_float_limits_member(bool, is_signed, true);
  98 __declare_float_limits_member(int, radix, FLT_RADIX);
  99 __declare_float_limits_member(int, min_exponent, __MinExp);
 100 __declare_float_limits_member(int, max_exponent, __MaxExp);
 101 __declare_float_limits_member(int, min_exponent10, __MinExp10);
 102 __declare_float_limits_member(int, max_exponent10, __MaxExp10);
 103 __declare_float_limits_member(bool, has_infinity, true);
 104 __declare_float_limits_member(bool, has_quiet_NaN, true);
 105 __declare_float_limits_member(bool, has_signaling_NaN, true);
 106 __declare_float_limits_member(float_denorm_style, has_denorm, denorm_indeterminate);
 107 __declare_float_limits_member(bool, has_denorm_loss, false);
 108 __declare_float_limits_member(bool, is_iec559, __IsIEC559);
 109 __declare_float_limits_member(bool, is_bounded, true);
 110 __declare_float_limits_member(bool, traps, true);
 111 __declare_float_limits_member(bool, tinyness_before, false);
 112 __declare_float_limits_member(float_round_style, round_style, __RoundStyle);
 113 #  undef __declare_float_limits_member
 114
 115 #endif /* _STLP_STATIC_CONST_INIT_BUG */
 116
 117
 118 #if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
 119
 120 #  if defined (_STLP_BIG_ENDIAN)
 121 #    if defined (__OS400__)
 122 #      define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
 123 #      define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
 124 #      define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
 125 #      define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
 126 #      define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
 127 #      define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
 128 #      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
 129 #      define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
 130 #      define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
 131 #    else /* __OS400__ */
 132 #      define _STLP_FLOAT_INF_REP   { 0x7f80, 0 }
 133 #      define _STLP_FLOAT_QNAN_REP  { 0x7fc1, 0 }
 134 #      define _STLP_FLOAT_SNAN_REP  { 0x7f81, 0 }
 135 #      define _STLP_DOUBLE_INF_REP  { 0x7ff0, 0, 0, 0 }
 136 #      define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
 137 #      define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
 138 #      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
 139 #      define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
 140 #      define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
 141 #    endif /* __OS400__ */
 142
 143 #  elif defined (_STLP_LITTLE_ENDIAN)
 144
 145 #    if 0 /* defined(_STLP_MSVC) || defined(__linux__) */
 146 // some IA-32 platform ??
 147 /*
 148 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 149 #      define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
 150 #      define _STLP_FLOAT_SNAN_REP { 0, 0xff80 }
 151
 152 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 153 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
 154 #      define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0xfff0 }
 155 #      define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 } // ????
 156 #      define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 } // ????
 157 #      define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF0, 0 } // ????
 158 */
 159 #    elif defined(__DECCXX)
 160
 161 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 162 #      define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
 163 #      define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }
 164
 165 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 166 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
 167 #      define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }
 168
 169 #      define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
 170 #      define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
 171 #      define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
 172 #    else
 173 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 174 #      define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
 175 #      define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
 176 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 177 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
 178 #      define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
 179 #      if defined (_STLP_MSVC) || defined (__ICL)
 180 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
 181 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
 182 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
 183 #      elif defined (__BORLANDC__)
 184 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
 185 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
 186 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
 187 #      else
 188 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
 189 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
 190 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
 191 #      endif
 192 #    endif
 193 #  else
 194 /* This is an architecture we don't know how to handle. Return some
 195 obviously wrong values. */
 196 #    define _STLP_FLOAT_INF_REP { 0, 0 }
 197 #    define _STLP_FLOAT_QNAN_REP { 0, 0 }
 198 #    define _STLP_FLOAT_SNAN_REP { 0, 0 }
 199 #    define _STLP_DOUBLE_INF_REP { 0, 0 }
 200 #    define _STLP_DOUBLE_QNAN_REP { 0, 0 }
 201 #    define _STLP_DOUBLE_SNAN_REP { 0, 0 }
 202 #    define _STLP_LDOUBLE_INF_REP { 0 }
 203 #    define _STLP_LDOUBLE_QNAN_REP { 0 }
 204 #    define _STLP_LDOUBLE_SNAN_REP { 0 }
 205
 206 #  endif
 207
 208 #  if 0
 209 /*
 210 #    if defined(_STLP_BIG_ENDIAN)
 211
 212 #    elif defined (_STLP_LITTLE_ENDIAN)
 213 #    else
 214
 215 //This is an architecture we don't know how to handle.  Return some
 216 //obviously wrong values.
 217 #      define _STLP_FLOAT_INF_REP  { 0, 0 }
 218 #      define _STLP_FLOAT_QNAN_REP { 0, 0 }
 219 #      define _STLP_FLOAT_SNAN_REP { 0, 0 }
 220 #      define _STLP_DOUBLE_INF_REP  { 0, 0 }
 221 #      define _STLP_DOUBLE_QNAN_REP { 0, 0 }
 222 #      define _STLP_DOUBLE_SNAN_REP { 0, 0 }
 223 #      define _STLP_LDOUBLE_INF_REP  { 0 }
 224 #      define _STLP_LDOUBLE_QNAN_REP { 0 }
 225 #      define _STLP_LDOUBLE_SNAN_REP { 0 }
 226 #    endif
 227 */
 228 #  endif
 229
 230 union _F_rep {
 231   unsigned short rep[2];
 232   float val;
 233 };
 234 union _D_rep {
 235   unsigned short rep[4];
 236   double val;
 237 };
 238
 239 #  ifndef _STLP_NO_LONG_DOUBLE
 240 union _LD_rep {
 241   unsigned short rep[8];
 242   long double val;
 243 };
 244 #  endif
 245
 246 template <class __dummy>
 247 float _STLP_CALL _LimG<__dummy>::get_F_inf() {
 248   _F_rep _F_inf = {_STLP_FLOAT_INF_REP};
 249   return _F_inf.val;
 250 }
 251 template <class __dummy>
 252 float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
 253   _F_rep _F_qNaN = {_STLP_FLOAT_QNAN_REP};
 254   return _F_qNaN.val;
 255 }
 256 template <class __dummy>
 257 float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
 258   _F_rep _F_sNaN = {_STLP_FLOAT_SNAN_REP};
 259   return _F_sNaN.val;
 260 }
 261
 262 template <class __dummy>
 263 double _STLP_CALL _LimG<__dummy>::get_D_inf() {
 264   _D_rep _D_inf = {_STLP_DOUBLE_INF_REP};
 265   return _D_inf.val;
 266 }
 267 template <class __dummy>
 268 double _STLP_CALL _LimG<__dummy>::get_D_qNaN() {
 269   _D_rep _D_qNaN = {_STLP_DOUBLE_QNAN_REP};
 270   return _D_qNaN.val;
 271 }
 272 template <class __dummy>
 273 double _STLP_CALL _LimG<__dummy>::get_D_sNaN() {
 274   _D_rep _D_sNaN = {_STLP_DOUBLE_SNAN_REP};
 275   return _D_sNaN.val;
 276 }
 277
 278 #  if !defined (_STLP_NO_LONG_DOUBLE)
 279 template <class __dummy>
 280 long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
 281   _LD_rep _LD_inf = {_STLP_LDOUBLE_INF_REP};
 282   return _LD_inf.val;
 283 }
 284 template <class __dummy>
 285 long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
 286   _LD_rep _LD_qNaN = {_STLP_LDOUBLE_QNAN_REP};
 287   return _LD_qNaN.val;
 288 }
 289 template <class __dummy>
 290 long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
 291   _LD_rep _LD_sNaN = {_STLP_LDOUBLE_SNAN_REP};
 292   return _LD_sNaN.val;
 293 }
 294 #  endif /* _STLP_NO_LONG_DOUBLE */
 295
 296 #endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
 297
 298 #undef _STLP_LIMITS_MIN_TYPE
 299 #undef _STLP_LIMITS_MAX_TYPE
 300
 301 #undef _STLP_FLOAT_INF_REP
 302 #undef _STLP_FLOAT_QNAN_REP
 303 #undef _STLP_FLOAT_SNAN_REP
 304 #undef _STLP_DOUBLE_INF_REP
 305 #undef _STLP_DOUBLE_QNAN_REP
 306 #undef _STLP_DOUBLE_SNAN_REP
 307 #undef _STLP_LDOUBLE_INF_REP
 308 #undef _STLP_LDOUBLE_QNAN_REP
 309 #undef _STLP_LDOUBLE_SNAN_REP
 310
 311 _STLP_MOVE_TO_STD_NAMESPACE
 312
 313 _STLP_END_NAMESPACE
 314
 315 #endif /* _STLP_LIMITS_C_INCLUDED */