reactos/include/c++/stlport/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) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
  35
  36 #  define __declare_numeric_base_member(__type, __mem) \
  37 template <class __number> \
  38   const __type _Numeric_limits_base<__number>:: __mem
  39
  40 __declare_numeric_base_member(bool, is_specialized);
  41 __declare_numeric_base_member(int, digits);
  42 __declare_numeric_base_member(int, digits10);
  43 __declare_numeric_base_member(bool, is_signed);
  44 __declare_numeric_base_member(bool, is_integer);
  45 __declare_numeric_base_member(bool, is_exact);
  46 __declare_numeric_base_member(int, radix);
  47 __declare_numeric_base_member(int, min_exponent);
  48 __declare_numeric_base_member(int, max_exponent);
  49 __declare_numeric_base_member(int, min_exponent10);
  50 __declare_numeric_base_member(int, max_exponent10);
  51 __declare_numeric_base_member(bool, has_infinity);
  52 __declare_numeric_base_member(bool, has_quiet_NaN);
  53 __declare_numeric_base_member(bool, has_signaling_NaN);
  54 __declare_numeric_base_member(float_denorm_style, has_denorm);
  55 __declare_numeric_base_member(bool, has_denorm_loss);
  56 __declare_numeric_base_member(bool, is_iec559);
  57 __declare_numeric_base_member(bool, is_bounded);
  58 __declare_numeric_base_member(bool, is_modulo);
  59 __declare_numeric_base_member(bool, traps);
  60 __declare_numeric_base_member(bool, tinyness_before);
  61 __declare_numeric_base_member(float_round_style, round_style);
  62
  63 #  undef __declare_numeric_base_member
  64
  65 #  define __declare_integer_limits_member(__type, __mem) \
  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);
  70 __declare_integer_limits_member(int, digits);
  71 __declare_integer_limits_member(int, digits10);
  72 __declare_integer_limits_member(bool, is_signed);
  73 __declare_integer_limits_member(bool, is_integer);
  74 __declare_integer_limits_member(bool, is_exact);
  75 __declare_integer_limits_member(int, radix);
  76 __declare_integer_limits_member(bool, is_bounded);
  77 __declare_integer_limits_member(bool, is_modulo);
  78 #  undef __declare_integer_limits_member
  79
  80 #  if defined (__GNUC__) && (__GNUC__ != 2 || __GNUC_MINOR__ > 96) && (__GNUC__ != 3 || __GNUC_MINOR__ == 0) && (__GNUC__ <= 3)
  81 _STLP_MOVE_TO_STD_NAMESPACE
  82
  83 #    define __declare_numeric_limits_member(__integer) \
  84   _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::digits; \
  85   _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::digits10; \
  86   _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::radix; \
  87   _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_specialized; \
  88   _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_signed; \
  89   _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_integer; \
  90   _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_exact; \
  91   _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_bounded; \
  92   _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_modulo
  93
  94 __declare_numeric_limits_member(_STLP_LONG_LONG);
  95 __declare_numeric_limits_member(unsigned _STLP_LONG_LONG);
  96
  97 #    undef __declare_numeric_limits_member
  98
  99 _STLP_MOVE_TO_PRIV_NAMESPACE
 100 #  endif
 101
 102 #  define __declare_float_limits_member(__type, __mem) \
 103 template <class __number,  \
 104          int __Digits, int __Digits10,    \
 105          int __MinExp, int __MaxExp,      \
 106          int __MinExp10, int __MaxExp10,  \
 107          bool __IsIEC559, \
 108          float_denorm_style __DenormStyle, \
 109          float_round_style __RoundStyle> \
 110 const __type _Floating_limits< __number, __Digits, __Digits10,    \
 111          __MinExp, __MaxExp, __MinExp10, __MaxExp10,  \
 112          __IsIEC559, __DenormStyle, __RoundStyle>::\
 113          __mem
 114
 115 __declare_float_limits_member(bool, is_specialized);
 116 __declare_float_limits_member(int, digits);
 117 __declare_float_limits_member(int, digits10);
 118 __declare_float_limits_member(bool, is_signed);
 119 __declare_float_limits_member(int, radix);
 120 __declare_float_limits_member(int, min_exponent);
 121 __declare_float_limits_member(int, max_exponent);
 122 __declare_float_limits_member(int, min_exponent10);
 123 __declare_float_limits_member(int, max_exponent10);
 124 __declare_float_limits_member(bool, has_infinity);
 125 __declare_float_limits_member(bool, has_quiet_NaN);
 126 __declare_float_limits_member(bool, has_signaling_NaN);
 127 __declare_float_limits_member(float_denorm_style, has_denorm);
 128 __declare_float_limits_member(bool, has_denorm_loss);
 129 __declare_float_limits_member(bool, is_iec559);
 130 __declare_float_limits_member(bool, is_bounded);
 131 __declare_float_limits_member(bool, traps);
 132 __declare_float_limits_member(bool, tinyness_before);
 133 __declare_float_limits_member(float_round_style, round_style);
 134 #  undef __declare_float_limits_member
 135
 136 #endif
 137
 138
 139 #if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
 140
 141 #  if defined (__GNUC__) || defined (__BORLANDC__)
 142 #    define _STLP_ADDITIONAL_OPEN_BRACKET {
 143 #    define _STLP_ADDITIONAL_CLOSE_BRACKET }
 144 #  else
 145 #    define _STLP_ADDITIONAL_OPEN_BRACKET
 146 #    define _STLP_ADDITIONAL_CLOSE_BRACKET
 147 #  endif
 148
 149 /* The following code has been extracted from the boost libraries (www.boost.org) and
 150  * adapted with the STLport portability macros. Advantage on previous technique is that
 151  * computation of infinity and NaN values is only based on big/little endianess, compiler
 152  * float, double or long double representation is taken into account thanks to the sizeof
 153  * operator. */
 154 template<class _Number, unsigned short _Word>
 155 struct float_helper {
 156   union _WordsNumber {
 157     unsigned short _Words[8];
 158     _Number _num;
 159   };
 160   static _Number get_word_higher() _STLP_NOTHROW {
 161     _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET _Word, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
 162     return __tmp._num;
 163   }
 164   static _Number get_word_lower() _STLP_NOTHROW {
 165     _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET 0, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
 166     __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 1] = _Word;
 167     return __tmp._num;
 168   }
 169   static _Number get_from_last_word() _STLP_NOTHROW {
 170 #  if defined (_STLP_BIG_ENDIAN)
 171     return get_word_higher();
 172 #  else /* _STLP_LITTLE_ENDIAN */
 173     return get_word_lower();
 174 #  endif
 175   }
 176   static _Number get_from_first_word() _STLP_NOTHROW {
 177 #  if defined (_STLP_BIG_ENDIAN)
 178     return get_word_lower();
 179 #  else /* _STLP_LITTLE_ENDIAN */
 180     return get_word_higher();
 181 #  endif
 182   }
 183 };
 184
 185 #  if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_BIG_ENDIAN)
 186 template<class _Number, unsigned short _Word1, unsigned short _Word2>
 187 struct float_helper2 {
 188   union _WordsNumber {
 189     unsigned short _Words[8];
 190     _Number _num;
 191   };
 192   //static _Number get_word_higher() _STLP_NOTHROW {
 193   //  _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET _Word1, _Word2, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
 194   //  return __tmp._num;
 195   //}
 196   static _Number get_word_lower() _STLP_NOTHROW {
 197     _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET 0, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
 198     __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 2] = _Word1;
 199     __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 1] = _Word2;
 200     return __tmp._num;
 201   }
 202   static _Number get_from_last_word() _STLP_NOTHROW {
 203 //#    if defined (_STLP_BIG_ENDIAN)
 204 //    return get_word_higher();
 205 //#    else /* _STLP_LITTLE_ENDIAN */
 206     return get_word_lower();
 207 //#    endif
 208   }
 209 };
 210 #  endif
 211
 212 /* Former values kept in case moving to boost code has introduce a regression on
 213  * some platform. */
 214 #if 0
 215 #  if defined (_STLP_BIG_ENDIAN)
 216 #    if defined (__OS400__)
 217 #      define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
 218 #      define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
 219 #      define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
 220 #      define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
 221 #      define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
 222 #      define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
 223 #      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
 224 #      define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
 225 #      define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
 226 #    else /* __OS400__ */
 227 #      define _STLP_FLOAT_INF_REP   { 0x7f80, 0 }
 228 #      define _STLP_FLOAT_QNAN_REP  { 0x7fc1, 0 }
 229 #      define _STLP_FLOAT_SNAN_REP  { 0x7f81, 0 }
 230 #      define _STLP_DOUBLE_INF_REP  { 0x7ff0, 0, 0, 0 }
 231 #      define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
 232 #      define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
 233 #      define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
 234 #      define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
 235 #      define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
 236 #    endif /* __OS400__ */
 237 #  else /* _STLP_LITTLE_ENDIAN */
 238 #    if defined(__DECCXX)
 239 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 240 #      define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
 241 #      define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }
 242 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 243 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
 244 #      define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }
 245 #      define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
 246 #      define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
 247 #      define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
 248 #    else
 249 #      define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
 250 #      define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
 251 #      define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
 252 #      define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
 253 #      define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
 254 #      define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
 255 #      if defined (_STLP_MSVC) || defined (__ICL)
 256 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
 257 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
 258 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
 259 #      elif defined (__BORLANDC__)
 260 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
 261 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
 262 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
 263 #      else
 264 #        define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
 265 #        define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
 266 #        define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
 267 #      endif
 268 #    endif
 269 #  endif
 270
 271 union _F_rep {
 272   unsigned short rep[2];
 273   float val;
 274 };
 275 union _D_rep {
 276   unsigned short rep[4];
 277   double val;
 278 };
 279
 280 #  ifndef _STLP_NO_LONG_DOUBLE
 281 union _LD_rep {
 282   unsigned short rep[8];
 283   long double val;
 284 };
 285 #  endif
 286 #endif
 287
 288 template <class __dummy>
 289 float _STLP_CALL _LimG<__dummy>::get_F_inf() {
 290   typedef float_helper<float, 0x7f80u> _FloatHelper;
 291   return _FloatHelper::get_from_last_word();
 292 }
 293 template <class __dummy>
 294 float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
 295   typedef float_helper<float, 0x7f81u> _FloatHelper;
 296   return _FloatHelper::get_from_last_word();
 297 }
 298 template <class __dummy>
 299 float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
 300   typedef float_helper<float, 0x7fc1u> _FloatHelper;
 301   return _FloatHelper::get_from_last_word();
 302 }
 303 template <class __dummy>
 304 float _STLP_CALL _LimG<__dummy>::get_F_denormMin() {
 305   typedef float_helper<float, 0x0001u> _FloatHelper;
 306   return _FloatHelper::get_from_first_word();
 307 }
 308
 309 template <int __use_double_limits>
 310 class _NumericLimitsAccess;
 311
 312 _STLP_TEMPLATE_NULL
 313 class _NumericLimitsAccess<1> {
 314 public:
 315   static double get_inf() {
 316     typedef float_helper<double, 0x7ff0u> _FloatHelper;
 317     return _FloatHelper::get_from_last_word();
 318   }
 319   static double get_qNaN() {
 320     typedef float_helper<double, 0x7ff1u> _FloatHelper;
 321     return _FloatHelper::get_from_last_word();
 322   }
 323   static double get_sNaN() {
 324     typedef float_helper<double, 0x7ff9u> _FloatHelper;
 325     return _FloatHelper::get_from_last_word();
 326   }
 327 };
 328
 329 template <class __dummy>
 330 double _STLP_CALL _LimG<__dummy>::get_D_inf()
 331 { return _NumericLimitsAccess<1>::get_inf(); }
 332 template <class __dummy>
 333 double _STLP_CALL _LimG<__dummy>::get_D_qNaN()
 334 { return _NumericLimitsAccess<1>::get_qNaN(); }
 335 template <class __dummy>
 336 double _STLP_CALL _LimG<__dummy>::get_D_sNaN()
 337 { return _NumericLimitsAccess<1>::get_sNaN(); }
 338 template <class __dummy>
 339 double _STLP_CALL _LimG<__dummy>::get_D_denormMin() {
 340   typedef float_helper<double, 0x0001u> _FloatHelper;
 341   return _FloatHelper::get_from_first_word();
 342 }
 343
 344 #  if !defined (_STLP_NO_LONG_DOUBLE)
 345 _STLP_TEMPLATE_NULL
 346 class _NumericLimitsAccess<0> {
 347 public:
 348   static long double get_inf() {
 349 #    if defined (_STLP_BIG_ENDIAN)
 350     typedef float_helper<long double, 0x7ff0u> _FloatHelper;
 351 #    else
 352     typedef float_helper2<long double, 0x8000u, 0x7fffu> _FloatHelper;
 353 #    endif
 354     return _FloatHelper::get_from_last_word();
 355   }
 356   static long double get_qNaN() {
 357 #    if defined (_STLP_BIG_ENDIAN)
 358     typedef float_helper<long double, 0x7ff1u> _FloatHelper;
 359 #    else
 360     typedef float_helper2<long double, 0xc000u, 0x7fffu> _FloatHelper;
 361 #    endif
 362     return _FloatHelper::get_from_last_word();
 363   }
 364   static long double get_sNaN() {
 365 #    if defined (_STLP_BIG_ENDIAN)
 366     typedef float_helper<long double, 0x7ff9u> _FloatHelper;
 367 #    else
 368     typedef float_helper2<long double, 0x9000u, 0x7fffu> _FloatHelper;
 369 #    endif
 370     return _FloatHelper::get_from_last_word();
 371   }
 372 };
 373
 374 template <class __dummy>
 375 long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
 376   const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
 377   return _NumericLimitsAccess<__use_double_limits>::get_inf();
 378 }
 379 template <class __dummy>
 380 long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
 381   const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
 382   return _NumericLimitsAccess<__use_double_limits>::get_qNaN();
 383 }
 384 template <class __dummy>
 385 long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
 386   const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
 387   return _NumericLimitsAccess<__use_double_limits>::get_sNaN();
 388 }
 389 template <class __dummy>
 390 long double _STLP_CALL _LimG<__dummy>::get_LD_denormMin() {
 391   typedef float_helper<long double, 0x0001u> _FloatHelper;
 392   return _FloatHelper::get_from_first_word();
 393 }
 394 #  endif
 395
 396 #endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
 397
 398 #undef _STLP_LIMITS_MIN_TYPE
 399 #undef _STLP_LIMITS_MAX_TYPE
 400
 401 _STLP_MOVE_TO_STD_NAMESPACE
 402
 403 _STLP_END_NAMESPACE
 404
 405 #endif /* _STLP_LIMITS_C_INCLUDED */