home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / INC.PAK / LIMITS.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  36.0 KB  |  1,065 lines
  1. /*  limits.h
  2.  
  3.     Defines implementation specific limits on type values.
  4.  
  5. */
  6.  
  7. /*
  8.  *      C/C++ Run Time Library - Version 8.0
  9.  *
  10.  *      Copyright (c) 1987, 1997 by Borland International
  11.  *      All Rights Reserved.
  12.  *
  13.  */
  14.  
  15. #if !defined(__USING_STD_NAMES__)
  16.  
  17. #ifndef __LIMITS_H
  18. #define __LIMITS_H
  19.  
  20. #if !defined(___DEFS_H)
  21. #include <_defs.h>
  22. #endif
  23.  
  24. #define CHAR_BIT        8               /* number of bits in a char */
  25. #define MB_LEN_MAX      2               /* max. # bytes in multibyte char */
  26.  
  27. #define SCHAR_MIN     (-128)            /* minimum signed   char value */
  28. #define SCHAR_MAX       127             /* maximum signed   char value */
  29. #define UCHAR_MAX       255             /* maximum unsigned char value */
  30.  
  31. #if ('\x80' < 0)
  32. #define CHAR_MIN        SCHAR_MIN       /* minimum char value */
  33. #define CHAR_MAX        SCHAR_MAX       /* maximum char value */
  34. #else
  35. #define CHAR_MIN        0
  36. #define CHAR_MAX        UCHAR_MAX
  37. #endif
  38.  
  39. #define SHRT_MIN      (-32767-1)        /* minimum signed   short value */
  40. #define SHRT_MAX        32767           /* maximum signed   short value */
  41. #define USHRT_MAX       65535U          /* maximum unsigned short value */
  42.  
  43. #define LONG_MIN      (-2147483647L-1)  /* minimum signed   long value */
  44. #define LONG_MAX        2147483647L     /* maximum signed   long value */
  45. #define ULONG_MAX       4294967295UL    /* maximum unsigned long value */
  46.  
  47. #if defined(__FLAT__) && defined (_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS >= 64)
  48. #define _I64_MIN      (-9223372036854775807i64-1) /* minimum signed   __int64 value */
  49. #define _I64_MAX        9223372036854775807i64    /* maximum signed   __int64 value */
  50. #define _UI64_MAX       18446744073709551615ui64  /* maximum unsigned __int64 value */
  51. #endif
  52.  
  53. #if !defined(__FLAT__)
  54. #define INT_MIN         SHRT_MIN        /* minimum signed   int value */
  55. #define INT_MAX         SHRT_MAX        /* maximum signed   int value */
  56. #define UINT_MAX        USHRT_MAX       /* maximum unsigned int value */
  57. #else
  58. #define INT_MIN         LONG_MIN
  59. #define INT_MAX         LONG_MAX
  60. #define UINT_MAX        ULONG_MAX
  61. #endif
  62.  
  63.  
  64. #if defined(__FLAT__) && defined(_POSIX_)
  65.  
  66. #define _POSIX_ARG_MAX          4096
  67. #define _POSIX_CHILD_MAX        6
  68. #define _POSIX_LINK_MAX         8
  69. #define _POSIX_MAX_CANON        255
  70. #define _POSIX_MAX_INPUT        255
  71. #define _POSIX_NAME_MAX         14
  72. #define _POSIX_NGROUPS_MAX      0
  73. #define _POSIX_OPEN_MAX         16
  74. #define _POSIX_PATH_MAX         255
  75. #define _POSIX_PIPE_BUF         512
  76. #define _POSIX_SSIZE_MAX        32767
  77. #define _POSIX_STREAM_MAX       8
  78. #define _POSIX_TZNAME_MAX       3
  79.  
  80. #define ARG_MAX                 (16384 - 256)   /* 16k-(heap overhead+safety) */
  81. #define CHILD_MAX               32
  82. #define LINK_MAX                _POSIX_LINK_MAX
  83. #define MAX_CANON               _POSIX_MAX_CANON
  84. #define MAX_INPUT               _POSIX_MAX_INPUT
  85. #define NAME_MAX                255
  86. #define NGROUPS_MAX             16
  87. #define OPEN_MAX                32
  88. #define PATH_MAX                512
  89. #define PIPE_BUF                _POSIX_PIPE_BUF
  90. #define SSIZE_MAX               _POSIX_SSIZE_MAX
  91. #define STREAM_MAX              20
  92. #define TZNAME_MAX              10
  93.  
  94. #endif /* POSIX */
  95.  
  96. #endif  /* __LIMITS_H */
  97.  
  98. #else   /* __USING_STD_NAMES__ */
  99.  
  100. #ifndef __STD_LIMITS
  101. #define __STD_LIMITS
  102.  
  103. /***************************************************************************
  104.  *
  105.  * limits - Declarations for the Standard Library limits class
  106.  *
  107.  * $Id: limits,v 1.42 1995/09/29 01:06:31 smithey Exp $
  108.  *
  109.  ***************************************************************************
  110.  *
  111.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  112.  * ALL RIGHTS RESERVED
  113.  *
  114.  * The software and information contained herein are proprietary to, and
  115.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  116.  * intends to preserve as trade secrets such software and information.
  117.  * This software is furnished pursuant to a written license agreement and
  118.  * may be used, copied, transmitted, and stored only in accordance with
  119.  * the terms of such license and with the inclusion of the above copyright
  120.  * notice.  This software and information or any other copies thereof may
  121.  * not be provided or otherwise made available to any other person.
  122.  *
  123.  * Notwithstanding any other lease or license that may pertain to, or
  124.  * accompany the delivery of, this computer software and information, the
  125.  * rights of the Government regarding its use, reproduction and disclosure
  126.  * are as set forth in Section 52.227-19 of the FARS Computer
  127.  * Software-Restricted Rights clause.
  128.  *
  129.  * Use, duplication, or disclosure by the Government is subject to
  130.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  131.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  132.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  133.  * P.O. Box 2328, Corvallis, Oregon 97339.
  134.  *
  135.  * This computer software and information is distributed with "restricted
  136.  * rights."  Use, duplication or disclosure is subject to restrictions as
  137.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  138.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  139.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  140.  * then the "Alternate III" clause applies.
  141.  *
  142.  **************************************************************************/
  143.  
  144. #include <stdcomp.h>
  145. #include <stddefs.h>
  146.  
  147. #ifndef RWSTD_NO_NEW_HEADER
  148. #include <cfloat>
  149. #include <climits>
  150. #else
  151. #include <float.h>
  152. #include <limits.h>
  153. #endif
  154.  
  155. //
  156. // Hack to get around some <math.h>s defining an exception structure.
  157. //
  158. #define exception math_exception
  159.  
  160. #ifndef RWSTD_NO_NEW_HEADER
  161. #include <cmath>
  162. #else
  163. #include <math.h>
  164. #endif
  165.  
  166. //
  167. // Undo the hack.
  168. //
  169. #undef exception
  170.  
  171. //
  172. // WARNING: this is a hack to get around MSVC's complex
  173. //
  174. #ifdef _MSC_VER
  175. #ifdef complex
  176. #undef complex
  177. #endif
  178. #endif
  179.  
  180. #ifndef RWSTD_NO_NAMESPACE
  181. namespace std {
  182. #endif
  183.  
  184. enum float_round_style
  185. {
  186.     round_indeterminable      = -1,
  187.     round_toward_zero         =  0,
  188.     round_to_nearest          =  1,
  189.     round_toward_infinity     =  2,
  190.     round_toward_neg_infinity =  3
  191. };
  192.  
  193. template <class T>
  194. class numeric_limits
  195. {
  196.   public:
  197.  
  198.     static const bool is_specialized;
  199.  
  200.     static inline T min () { return (T) 0; }
  201.     static inline T max () { return (T) 0; }
  202.  
  203.     static const int digits;
  204.     static const int digits10;
  205.  
  206.     static const bool is_signed;
  207.     static const bool is_integer;
  208.     static const bool is_exact;
  209.  
  210.     static const int radix;
  211.     static inline T  epsilon     () { return (T) 0; }
  212.     static inline T  round_error () { return (T) 0; }
  213.  
  214.     static const int min_exponent;
  215.     static const int min_exponent10;
  216.     static const int max_exponent;
  217.     static const int max_exponent10;
  218.  
  219.     static const bool has_infinity;
  220.     static const bool has_quiet_NaN;
  221.     static const bool has_signaling_NaN;
  222.     static const bool has_denorm;
  223.  
  224.     static inline T infinity      () { return (T) 0; }
  225.     static inline T quiet_NaN     () { return (T) 0; }
  226.     static inline T signaling_NaN () { return (T) 0; }
  227.     static inline T denorm_min    () { return min(); }
  228.  
  229.     static const bool is_iec559;
  230.     static const bool is_bounded;
  231.     static const bool is_modulo;
  232.  
  233.     static const bool traps;
  234.     static const bool tinyness_before;
  235.  
  236.     static const float_round_style round_style;
  237. };
  238.  
  239. #ifndef RWSTD_NO_TEMPLATE_SPECIALIZATION
  240. template <class T>
  241. const bool numeric_limits<T>::is_specialized = false;
  242.  
  243. template <class T>
  244. const int numeric_limits<T>::digits = 0;
  245.  
  246. template <class T>
  247. const int numeric_limits<T>::digits10 = 0;
  248.  
  249. template <class T>
  250. const bool numeric_limits<T>::is_signed = false;
  251.  
  252. template <class T>
  253. const bool numeric_limits<T>::is_integer = false;
  254.  
  255. template <class T>
  256. const bool numeric_limits<T>::is_exact = false;
  257.  
  258. template <class T>
  259. const int numeric_limits<T>::radix = 0;
  260.  
  261. template <class T>
  262. const int numeric_limits<T>::min_exponent10 =0;
  263.  
  264. template <class T>
  265. const int numeric_limits<T>::max_exponent10 = 0;
  266.  
  267. template <class T>
  268. const int numeric_limits<T>::min_exponent = 0;
  269.  
  270. template <class T>
  271. const int numeric_limits<T>::max_exponent = 0;
  272.  
  273. template <class T>
  274. const bool numeric_limits<T>::has_infinity = false;
  275.  
  276. template <class T>
  277. const bool numeric_limits<T>::has_quiet_NaN = false;
  278.  
  279. template <class T>
  280. const bool numeric_limits<T>::has_signaling_NaN = false;
  281.  
  282. template <class T>
  283. const bool numeric_limits<T>::is_iec559 = false;
  284.  
  285. template <class T>
  286. const bool numeric_limits<T>::is_bounded = false;
  287.  
  288. template <class T>
  289. const bool numeric_limits<T>::is_modulo = false;
  290.  
  291. template <class T>
  292. const bool numeric_limits<T>::has_denorm = false;
  293.  
  294. template <class T>
  295. const bool numeric_limits<T>::traps = false;
  296.  
  297. template <class T>
  298. const bool numeric_limits<T>::tinyness_before = false;
  299.  
  300. template <class T>
  301. const float_round_style numeric_limits<T>::round_style = round_toward_zero;
  302. #endif
  303.  
  304.  
  305. #ifndef RWSTD_NO_STI_SIMPLE
  306. #define __RW_INIT(n) = n
  307. #else
  308. #define __RW_INIT(n) /**/
  309. #endif
  310.  
  311.  
  312. //**********************************************************************
  313. //
  314. // Assumptions made in this implementation:
  315. //
  316. //   1) numeric_limits<int>::radix equals numeric_limits<T>::radix
  317. //      for all integral T specialized in this file.
  318. //
  319. //   2) numeric_limits<int>::is_modulo equals numeric_limits<T>::is_modulo
  320. //      for all signed integral T specialized in this file, except
  321. //      numeric_limits<bool>::is_modulo, which is assumed to be false.
  322. //
  323. //   3) numeric_limts<T>::traps == false for all builtin integral T.
  324. //
  325. // Does there exist a machine for which these aren't true?
  326. //
  327. //**********************************************************************
  328.  
  329.  
  330. //**********************************************************************
  331. //
  332. // If your compiler allows in-class initialization of static const data
  333. // members of integral type, then look for all lines having a comment of
  334. // the form
  335. //
  336. //       // VENDOR
  337. //
  338. // and set the value on that line to the proper one for your environment.
  339. //
  340. // If your compiler does NOT allow in-class initialization of static const
  341. // data members of integral type, then you'll need to set the values in
  342. // stdlib/src/limits/limits.cpp so they're properly archived into the
  343. // Standard Library.
  344. //
  345. //**********************************************************************
  346.  
  347.  
  348. //
  349. // Specialization for float.
  350. //
  351.  
  352. class RWSTDExport numeric_limits<float>
  353. {
  354.   public:
  355.  
  356.     static const bool is_specialized __RW_INIT(true);
  357.  
  358.     static inline float min () { return FLT_MIN; }
  359.     static inline float max () { return FLT_MAX; }
  360.  
  361.     static const int digits   __RW_INIT(FLT_MANT_DIG);
  362.     static const int digits10 __RW_INIT(FLT_DIG);
  363.  
  364.     static const bool is_signed  __RW_INIT(true);
  365.     static const bool is_integer __RW_INIT(false);
  366.     static const bool is_exact   __RW_INIT(false);
  367.  
  368.     static const  int radix __RW_INIT(FLT_RADIX);
  369.  
  370.     static inline float epsilon () { return FLT_EPSILON; }
  371.     static float round_error    ();
  372.  
  373.     static const int min_exponent   __RW_INIT(FLT_MIN_EXP);
  374.     static const int min_exponent10 __RW_INIT(FLT_MIN_10_EXP);
  375.     static const int max_exponent   __RW_INIT(FLT_MAX_EXP);
  376.     static const int max_exponent10 __RW_INIT(FLT_MAX_10_EXP);
  377.  
  378.     static const bool has_infinity      __RW_INIT(false);            // VENDOR
  379.     static const bool has_quiet_NaN     __RW_INIT(false);            // VENDOR
  380.     static const bool has_signaling_NaN __RW_INIT(false);            // VENDOR
  381.     static const bool has_denorm        __RW_INIT(false);            // VENDOR
  382.  
  383.     static float infinity      ();
  384.     static float quiet_NaN     ();
  385.     static float signaling_NaN ();
  386.     static float denorm_min    ();
  387.  
  388.     static const bool is_iec559  __RW_INIT(false);                   // VENDOR
  389.     static const bool is_bounded __RW_INIT(true);
  390.     static const bool is_modulo  __RW_INIT(false);                   // VENDOR
  391.  
  392.     static const bool traps           __RW_INIT(false);              // VENDOR
  393.     static const bool tinyness_before __RW_INIT(false);              // VENDOR
  394.  
  395.     static const float_round_style round_style __RW_INIT((float_round_style)FLT_ROUNDS);
  396. };
  397.  
  398. //
  399. // Specialization for double.
  400. //
  401.  
  402. class RWSTDExport numeric_limits<double>
  403. {
  404.   public:
  405.  
  406.     static const bool is_specialized  __RW_INIT(true);
  407.  
  408.     static inline double min () { return DBL_MIN; }
  409.     static inline double max () { return DBL_MAX; }
  410.  
  411.     static const int digits   __RW_INIT(DBL_MANT_DIG);
  412.     static const int digits10 __RW_INIT(DBL_DIG);
  413.  
  414.     static const bool is_signed  __RW_INIT(true);
  415.     static const bool is_integer __RW_INIT(false);
  416.     static const bool is_exact   __RW_INIT(false);
  417.  
  418.     static const int radix __RW_INIT(FLT_RADIX);
  419.  
  420.     static inline double epsilon () { return DBL_EPSILON; }
  421.     static double round_error    ();
  422.  
  423.     static const int min_exponent   __RW_INIT(DBL_MIN_EXP);
  424.     static const int min_exponent10 __RW_INIT(DBL_MIN_10_EXP);
  425.     static const int max_exponent   __RW_INIT(DBL_MAX_EXP);
  426.     static const int max_exponent10 __RW_INIT(DBL_MAX_10_EXP);
  427.  
  428.     static const bool has_infinity      __RW_INIT(false);            // VENDOR
  429.     static const bool has_quiet_NaN     __RW_INIT(false);            // VENDOR
  430.     static const bool has_signaling_NaN __RW_INIT(false);            // VENDOR
  431.     static const bool has_denorm        __RW_INIT(false);            // VENDOR
  432.  
  433.     static double infinity      ();
  434.     static double quiet_NaN     ();
  435.     static double signaling_NaN ();
  436.     static double denorm_min    ();
  437.  
  438.     static const bool is_iec559  __RW_INIT(false);                   // VENDOR
  439.     static const bool is_bounded __RW_INIT(true);
  440.     static const bool is_modulo  __RW_INIT(false);                   // VENDOR
  441.  
  442.     static const bool traps           __RW_INIT(false);              // VENDOR
  443.     static const bool tinyness_before __RW_INIT(false);              // VENDOR
  444.  
  445.     static const float_round_style round_style __RW_INIT((float_round_style)FLT_ROUNDS);
  446. };
  447.  
  448. //
  449. // Specialization for long double.
  450. //
  451.  
  452. class RWSTDExport numeric_limits<long double>
  453. {
  454.   public:
  455.  
  456.     static const bool is_specialized __RW_INIT(true);
  457.  
  458.     static inline long double min () { return LDBL_MIN; }
  459.     static inline long double max () { return LDBL_MAX; }
  460.  
  461.     static const int digits   __RW_INIT(LDBL_MANT_DIG);
  462.     static const int digits10 __RW_INIT(LDBL_DIG);
  463.  
  464.     static const bool is_signed  __RW_INIT(true);
  465.     static const bool is_integer __RW_INIT(false);
  466.     static const bool is_exact   __RW_INIT(false);
  467.  
  468.     static const int radix __RW_INIT(FLT_RADIX);
  469.  
  470.     static inline long double epsilon () { return LDBL_EPSILON; }
  471.     static long double round_error    ();
  472.  
  473.     static const int min_exponent   __RW_INIT(LDBL_MIN_EXP);
  474.     static const int min_exponent10 __RW_INIT(LDBL_MIN_10_EXP);
  475.     static const int max_exponent   __RW_INIT(LDBL_MAX_EXP);
  476.     static const int max_exponent10 __RW_INIT(LDBL_MAX_10_EXP);
  477.  
  478.     static const bool has_infinity      __RW_INIT(false);            // VENDOR
  479.     static const bool has_quiet_NaN     __RW_INIT(false);            // VENDOR
  480.     static const bool has_signaling_NaN __RW_INIT(false);            // VENDOR
  481.     static const bool has_denorm        __RW_INIT(false);            // VENDOR
  482.  
  483.     static long double infinity      ();
  484.     static long double quiet_NaN     ();
  485.     static long double signaling_NaN ();
  486.     static long double denorm_min    ();
  487.  
  488.     static const bool is_iec559  __RW_INIT(false);                   // VENDOR
  489.     static const bool is_bounded __RW_INIT(true);
  490.     static const bool is_modulo  __RW_INIT(false);                   // VENDOR
  491.  
  492.     static const bool traps           __RW_INIT(false);              // VENDOR
  493.     static const bool tinyness_before __RW_INIT(false);              // VENDOR
  494.  
  495.     static const float_round_style round_style __RW_INIT((float_round_style)FLT_ROUNDS);
  496. };
  497.  
  498. //
  499. // Specialization for int.
  500. //
  501.  
  502. class RWSTDExport numeric_limits<int>
  503. {
  504.   public:
  505.  
  506.     static const bool is_specialized __RW_INIT(true);
  507.  
  508.     static inline int min () { return INT_MIN; }
  509.     static inline int max () { return INT_MAX; }
  510.  
  511.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(int)-1);
  512.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  513.  
  514.     static const bool is_signed  __RW_INIT(true);
  515.     static const bool is_integer __RW_INIT(true);
  516.     static const bool is_exact   __RW_INIT(true);
  517.  
  518.     static const int radix __RW_INIT(2);                             // VENDOR
  519.  
  520.     static inline int epsilon     () { return 0; }
  521.     static inline int round_error () { return 0; }
  522.  
  523.     static const int min_exponent   __RW_INIT(0);
  524.     static const int min_exponent10 __RW_INIT(0);
  525.     static const int max_exponent   __RW_INIT(0);
  526.     static const int max_exponent10 __RW_INIT(0);
  527.  
  528.     static const bool has_infinity      __RW_INIT(false);
  529.     static const bool has_quiet_NaN     __RW_INIT(false);
  530.     static const bool has_signaling_NaN __RW_INIT(false);
  531.     static const bool has_denorm        __RW_INIT(false);
  532.  
  533.     static inline int infinity      () { return 0;     }
  534.     static inline int quiet_NaN     () { return 0;     }
  535.     static inline int signaling_NaN () { return 0;     }
  536.     static inline int denorm_min    () { return min(); }
  537.  
  538.     static const bool is_iec559  __RW_INIT(false);
  539.     static const bool is_bounded __RW_INIT(true);
  540.     static const bool is_modulo  __RW_INIT(false);                   // VENDOR
  541.  
  542.     static const bool traps           __RW_INIT(false);
  543.     static const bool tinyness_before __RW_INIT(false);
  544.  
  545.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  546. };
  547.  
  548. #ifndef RWSTD_NO_OVERLOAD_WCHAR
  549. class RWSTDExport numeric_limits<wchar_t>
  550. {
  551.   public:
  552.  
  553.     static const bool is_specialized __RW_INIT(true);
  554.  
  555.     static wchar_t min ();
  556.     static wchar_t max ();
  557.  
  558.     static const bool is_signed  __RW_INIT(true);                    // VENDOR
  559.  
  560.     static const int digits   __RW_INIT(is_signed ? CHAR_BIT*sizeof(wchar_t) - 1 : CHAR_BIT*sizeof(wchar_t));
  561.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  562.  
  563.     static const bool is_integer __RW_INIT(true);
  564.     static const bool is_exact   __RW_INIT(true);
  565.  
  566.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  567.  
  568.     static inline wchar_t epsilon     () { return 0; }
  569.     static inline wchar_t round_error () { return 0; }
  570.  
  571.     static const int min_exponent   __RW_INIT(0);
  572.     static const int min_exponent10 __RW_INIT(0);
  573.     static const int max_exponent   __RW_INIT(0);
  574.     static const int max_exponent10 __RW_INIT(0);
  575.  
  576.     static const bool has_infinity      __RW_INIT(false);
  577.     static const bool has_quiet_NaN     __RW_INIT(false);
  578.     static const bool has_signaling_NaN __RW_INIT(false);
  579.     static const bool has_denorm        __RW_INIT(false);
  580.  
  581.     static inline wchar_t infinity      () { return 0;     }
  582.     static inline wchar_t quiet_NaN     () { return 0;     }
  583.     static inline wchar_t signaling_NaN () { return 0;     }
  584.     static inline wchar_t denorm_min    () { return min(); }
  585.  
  586.     static const bool is_iec559  __RW_INIT(false);
  587.     static const bool is_bounded __RW_INIT(true);
  588.     static const bool is_modulo  __RW_INIT(is_signed ? numeric_limits<int>::is_modulo : true);
  589.  
  590.     static const bool traps           __RW_INIT(false);
  591.     static const bool tinyness_before __RW_INIT(false);
  592.  
  593.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  594. };
  595. #endif /*!RWSTD_NO_OVERLOAD_WCHAR*/
  596.  
  597. //**********************************************************************
  598. //
  599. // There are no VENDOR-settable values beyond this point.
  600. //
  601. //**********************************************************************
  602.  
  603. //
  604. // Specialization for short.
  605. //
  606.  
  607. class RWSTDExport numeric_limits<short>
  608. {
  609.   public:
  610.  
  611.     static const bool is_specialized __RW_INIT(true);
  612.  
  613.     static inline short min () { return SHRT_MIN; }
  614.     static inline short max () { return SHRT_MAX; }
  615.  
  616.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(short)-1);
  617.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  618.  
  619.     static const bool is_signed  __RW_INIT(true);
  620.     static const bool is_integer __RW_INIT(true);
  621.     static const bool is_exact   __RW_INIT(true);
  622.  
  623.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  624.  
  625.     static inline short epsilon     () { return 0; }
  626.     static inline short round_error () { return 0; }
  627.  
  628.     static const int min_exponent   __RW_INIT(0);
  629.     static const int min_exponent10 __RW_INIT(0);
  630.     static const int max_exponent   __RW_INIT(0);
  631.     static const int max_exponent10 __RW_INIT(0);
  632.  
  633.     static const bool has_infinity      __RW_INIT(false);
  634.     static const bool has_quiet_NaN     __RW_INIT(false);
  635.     static const bool has_signaling_NaN __RW_INIT(false);
  636.     static const bool has_denorm        __RW_INIT(false);
  637.  
  638.     static inline short infinity      () { return 0;     }
  639.     static inline short quiet_NaN     () { return 0;     }
  640.     static inline short signaling_NaN () { return 0;     }
  641.     static inline short denorm_min    () { return min(); }
  642.  
  643.     static const bool is_iec559  __RW_INIT(false);
  644.     static const bool is_bounded __RW_INIT(true);
  645.     static const bool is_modulo  __RW_INIT(numeric_limits<int>::is_modulo);
  646.  
  647.     static const bool traps           __RW_INIT(false);
  648.     static const bool tinyness_before __RW_INIT(false);
  649.  
  650.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  651. };
  652.  
  653. //
  654. // Specialization for unsigned short.
  655. //
  656.  
  657. class RWSTDExport numeric_limits<unsigned short>
  658. {
  659.   public:
  660.  
  661.     static const bool is_specialized __RW_INIT(true);
  662.  
  663.     static inline unsigned short min () { return 0;         }
  664.     static inline unsigned short max () { return USHRT_MAX; }
  665.  
  666.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(unsigned short));
  667.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  668.  
  669.     static const bool is_signed  __RW_INIT(false);
  670.     static const bool is_integer __RW_INIT(true);
  671.     static const bool is_exact   __RW_INIT(true);
  672.  
  673.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  674.  
  675.     static inline unsigned short epsilon     () { return 0; }
  676.     static inline unsigned short round_error () { return 0; }
  677.  
  678.     static const int min_exponent   __RW_INIT(0);
  679.     static const int min_exponent10 __RW_INIT(0);
  680.     static const int max_exponent   __RW_INIT(0);
  681.     static const int max_exponent10 __RW_INIT(0);
  682.  
  683.     static const bool has_infinity      __RW_INIT(false);
  684.     static const bool has_quiet_NaN     __RW_INIT(false);
  685.     static const bool has_signaling_NaN __RW_INIT(false);
  686.     static const bool has_denorm        __RW_INIT(false);
  687.  
  688.     static inline unsigned short infinity      () { return 0;     }
  689.     static inline unsigned short quiet_NaN     () { return 0;     }
  690.     static inline unsigned short signaling_NaN () { return 0;     }
  691.     static inline unsigned short denorm_min    () { return min(); }
  692.  
  693.     static const bool is_iec559  __RW_INIT(false);
  694.     static const bool is_bounded __RW_INIT(true);
  695.     static const bool is_modulo  __RW_INIT(true);
  696.  
  697.     static const bool traps           __RW_INIT(false);
  698.     static const bool tinyness_before __RW_INIT(false);
  699.  
  700.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  701. };
  702.  
  703. //
  704. // Specialization for unsigned int.
  705. //
  706.  
  707. class RWSTDExport numeric_limits<unsigned int>
  708. {
  709.   public:
  710.  
  711.     static const bool is_specialized __RW_INIT(true);
  712.  
  713.     static inline unsigned int min () { return 0;        }
  714.     static inline unsigned int max () { return UINT_MAX; }
  715.  
  716.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(unsigned int));
  717.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  718.  
  719.     static const bool is_signed  __RW_INIT(false);
  720.     static const bool is_integer __RW_INIT(true);
  721.     static const bool is_exact   __RW_INIT(true);
  722.  
  723.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  724.  
  725.     static inline unsigned int epsilon     () { return 0; }
  726.     static inline unsigned int round_error () { return 0; }
  727.  
  728.     static const int min_exponent   __RW_INIT(0);
  729.     static const int min_exponent10 __RW_INIT(0);
  730.     static const int max_exponent   __RW_INIT(0);
  731.     static const int max_exponent10 __RW_INIT(0);
  732.  
  733.     static const bool has_infinity      __RW_INIT(false);
  734.     static const bool has_quiet_NaN     __RW_INIT(false);
  735.     static const bool has_signaling_NaN __RW_INIT(false);
  736.     static const bool has_denorm        __RW_INIT(false);
  737.  
  738.     static inline unsigned int infinity      () { return 0;     }
  739.     static inline unsigned int quiet_NaN     () { return 0;     }
  740.     static inline unsigned int signaling_NaN () { return 0;     }
  741.     static inline unsigned int denorm_min    () { return min(); }
  742.  
  743.     static const bool is_iec559  __RW_INIT(false);
  744.     static const bool is_bounded __RW_INIT(true);
  745.     static const bool is_modulo  __RW_INIT(true);
  746.  
  747.     static const bool traps           __RW_INIT(false);
  748.     static const bool tinyness_before __RW_INIT(false);
  749.  
  750.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  751. };
  752.  
  753. //
  754. // Specialization for long.
  755. //
  756.  
  757. class RWSTDExport numeric_limits<long>
  758. {
  759.   public:
  760.  
  761.     static const bool is_specialized __RW_INIT(true);
  762.  
  763.     static inline long min () { return LONG_MIN; }
  764.     static inline long max () { return LONG_MAX; }
  765.  
  766.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(long)-1);
  767.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  768.  
  769.     static const bool is_signed  __RW_INIT(true);
  770.     static const bool is_integer __RW_INIT(true);
  771.     static const bool is_exact   __RW_INIT(true);
  772.  
  773.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  774.  
  775.     static inline long epsilon     () { return 0; }
  776.     static inline long round_error () { return 0; }
  777.  
  778.     static const int min_exponent   __RW_INIT(0);
  779.     static const int min_exponent10 __RW_INIT(0);
  780.     static const int max_exponent   __RW_INIT(0);
  781.     static const int max_exponent10 __RW_INIT(0);
  782.  
  783.     static const bool has_infinity      __RW_INIT(false);
  784.     static const bool has_quiet_NaN     __RW_INIT(false);
  785.     static const bool has_signaling_NaN __RW_INIT(false);
  786.     static const bool has_denorm        __RW_INIT(false);
  787.  
  788.     static inline long infinity      () { return 0;     }
  789.     static inline long quiet_NaN     () { return 0;     }
  790.     static inline long signaling_NaN () { return 0;     }
  791.     static inline long denorm_min    () { return min(); }
  792.  
  793.     static const bool is_iec559  __RW_INIT(false);
  794.     static const bool is_bounded __RW_INIT(true);
  795.     static const bool is_modulo  __RW_INIT(numeric_limits<int>::is_modulo);
  796.  
  797.     static const bool traps           __RW_INIT(false);
  798.     static const bool tinyness_before __RW_INIT(false);
  799.  
  800.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  801. };
  802.  
  803. //
  804. // Specialization for unsigned long.
  805. //
  806.  
  807. class RWSTDExport numeric_limits<unsigned long>
  808. {
  809.   public:
  810.  
  811.     static const bool is_specialized __RW_INIT(true);
  812.  
  813.     static inline unsigned long min () { return 0;         }
  814.     static inline unsigned long max () { return ULONG_MAX; }
  815.  
  816.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(unsigned long));
  817.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  818.  
  819.     static const bool is_signed  __RW_INIT(false);
  820.     static const bool is_integer __RW_INIT(true);
  821.     static const bool is_exact   __RW_INIT(true);
  822.  
  823.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  824.  
  825.     static inline unsigned long epsilon     () { return 0; }
  826.     static inline unsigned long round_error () { return 0; }
  827.  
  828.     static const int min_exponent   __RW_INIT(0);
  829.     static const int min_exponent10 __RW_INIT(0);
  830.     static const int max_exponent   __RW_INIT(0);
  831.     static const int max_exponent10 __RW_INIT(0);
  832.  
  833.     static const bool has_infinity      __RW_INIT(false);
  834.     static const bool has_quiet_NaN     __RW_INIT(false);
  835.     static const bool has_signaling_NaN __RW_INIT(false);
  836.     static const bool has_denorm        __RW_INIT(false);
  837.  
  838.     static inline unsigned long infinity      () { return 0;     }
  839.     static inline unsigned long quiet_NaN     () { return 0;     }
  840.     static inline unsigned long signaling_NaN () { return 0;     }
  841.     static inline unsigned long denorm_min    () { return min(); }
  842.  
  843.     static const bool is_iec559  __RW_INIT(false);
  844.     static const bool is_bounded __RW_INIT(true);
  845.     static const bool is_modulo  __RW_INIT(true);
  846.  
  847.     static const bool traps           __RW_INIT(false);
  848.     static const bool tinyness_before __RW_INIT(false);
  849.  
  850.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  851. };
  852.  
  853. //
  854. // Specialization for char.
  855. //
  856.  
  857. class RWSTDExport numeric_limits<char>
  858. {
  859.   public:
  860.  
  861.     static const bool is_specialized __RW_INIT(true);
  862.  
  863.     static inline char min () { return CHAR_MIN; }
  864.     static inline char max () { return CHAR_MAX; }
  865.  
  866.     static const bool is_signed  __RW_INIT(CHAR_MAX == SCHAR_MAX ? true : false);
  867.  
  868.     static const int digits   __RW_INIT(is_signed ? CHAR_BIT*sizeof(char) -1 : CHAR_BIT*sizeof(char));
  869.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  870.  
  871.     static const bool is_integer __RW_INIT(true);
  872.     static const bool is_exact   __RW_INIT(true);
  873.  
  874.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  875.  
  876.     static inline char epsilon     () { return 0; }
  877.     static inline char round_error () { return 0; }
  878.  
  879.     static const int min_exponent   __RW_INIT(0);
  880.     static const int min_exponent10 __RW_INIT(0);
  881.     static const int max_exponent   __RW_INIT(0);
  882.     static const int max_exponent10 __RW_INIT(0);
  883.  
  884.     static const bool has_infinity      __RW_INIT(false);
  885.     static const bool has_quiet_NaN     __RW_INIT(false);
  886.     static const bool has_signaling_NaN __RW_INIT(false);
  887.     static const bool has_denorm        __RW_INIT(false);
  888.  
  889.     static inline char infinity      () { return 0;     }
  890.     static inline char quiet_NaN     () { return 0;     }
  891.     static inline char signaling_NaN () { return 0;     }
  892.     static inline char denorm_min    () { return min(); }
  893.  
  894.     static const bool is_iec559  __RW_INIT(false);
  895.     static const bool is_bounded __RW_INIT(true);
  896.     static const bool is_modulo  __RW_INIT(is_signed ? numeric_limits<int>::is_modulo : true);
  897.  
  898.     static const bool traps           __RW_INIT(false);
  899.     static const bool tinyness_before __RW_INIT(false);
  900.  
  901.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  902. };
  903.  
  904. //
  905. // Specialization for unsigned char.
  906. //
  907.  
  908. class RWSTDExport numeric_limits<unsigned char>
  909. {
  910.   public:
  911.  
  912.     static const bool is_specialized __RW_INIT(true);
  913.  
  914.     static inline unsigned char min () { return 0;         }
  915.     static inline unsigned char max () { return UCHAR_MAX; }
  916.  
  917.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(unsigned char));
  918.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  919.  
  920.     static const bool is_signed  __RW_INIT(false);
  921.     static const bool is_integer __RW_INIT(true);
  922.     static const bool is_exact   __RW_INIT(true);
  923.  
  924.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  925.  
  926.     static inline unsigned char epsilon     () { return 0; }
  927.     static inline unsigned char round_error () { return 0; }
  928.  
  929.     static const int min_exponent   __RW_INIT(0);
  930.     static const int min_exponent10 __RW_INIT(0);
  931.     static const int max_exponent   __RW_INIT(0);
  932.     static const int max_exponent10 __RW_INIT(0);
  933.  
  934.     static const bool has_infinity      __RW_INIT(false);
  935.     static const bool has_quiet_NaN     __RW_INIT(false);
  936.     static const bool has_signaling_NaN __RW_INIT(false);
  937.     static const bool has_denorm        __RW_INIT(false);
  938.  
  939.     static inline unsigned char infinity      () { return 0;     }
  940.     static inline unsigned char quiet_NaN     () { return 0;     }
  941.     static inline unsigned char signaling_NaN () { return 0;     }
  942.     static inline unsigned char denorm_min    () { return min(); }
  943.  
  944.     static const bool is_iec559  __RW_INIT(false);
  945.     static const bool is_bounded __RW_INIT(true);
  946.     static const bool is_modulo  __RW_INIT(true);
  947.  
  948.     static const bool traps           __RW_INIT(false);
  949.     static const bool tinyness_before __RW_INIT(false);
  950.  
  951.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  952. };
  953.  
  954. //
  955. // Specialization for signed char.
  956. //
  957.  
  958. class RWSTDExport numeric_limits<signed char>
  959. {
  960.   public:
  961.  
  962.     static const bool is_specialized __RW_INIT(true);
  963.  
  964.     static inline signed char min () { return SCHAR_MIN; }
  965.     static inline signed char max () { return SCHAR_MAX; }
  966.  
  967.     static const int digits   __RW_INIT(CHAR_BIT*sizeof(signed char)-1);
  968.     static const int digits10 __RW_INIT(int(digits/3.321928095));
  969.  
  970.     static const bool is_signed  __RW_INIT(true);
  971.     static const bool is_integer __RW_INIT(true);
  972.     static const bool is_exact   __RW_INIT(true);
  973.  
  974.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  975.  
  976.     static inline signed char epsilon     () { return 0; }
  977.     static inline signed char round_error () { return 0; }
  978.  
  979.     static const int min_exponent   __RW_INIT(0);
  980.     static const int min_exponent10 __RW_INIT(0);
  981.     static const int max_exponent   __RW_INIT(0);
  982.     static const int max_exponent10 __RW_INIT(0);
  983.  
  984.     static const bool has_infinity      __RW_INIT(false);
  985.     static const bool has_quiet_NaN     __RW_INIT(false);
  986.     static const bool has_signaling_NaN __RW_INIT(false);
  987.     static const bool has_denorm        __RW_INIT(false);
  988.  
  989.     static inline signed char infinity      () { return 0;     }
  990.     static inline signed char quiet_NaN     () { return 0;     }
  991.     static inline signed char signaling_NaN () { return 0;     }
  992.     static inline signed char denorm_min    () { return min(); }
  993.  
  994.     static const bool is_iec559  __RW_INIT(false);
  995.     static const bool is_bounded __RW_INIT(true);
  996.     static const bool is_modulo  __RW_INIT(numeric_limits<int>::is_modulo);
  997.  
  998.     static const bool traps           __RW_INIT(false);
  999.     static const bool tinyness_before __RW_INIT(false);
  1000.  
  1001.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  1002. };
  1003.  
  1004. #ifndef RWSTD_NO_BOOL
  1005. //
  1006. // Specialization for bool.
  1007. //
  1008.  
  1009. class RWSTDExport numeric_limits<bool>
  1010. {
  1011.   public:
  1012.  
  1013.     static const bool is_specialized __RW_INIT(true);
  1014.  
  1015.     static inline bool min () { return false; }
  1016.     static inline bool max () { return true;  }
  1017.  
  1018.     static const int digits   __RW_INIT(1);
  1019.     static const int digits10 __RW_INIT(0);
  1020.  
  1021.     static const bool is_signed  __RW_INIT(false);
  1022.     static const bool is_integer __RW_INIT(true);
  1023.     static const bool is_exact   __RW_INIT(true);
  1024.  
  1025.     static const int radix __RW_INIT(numeric_limits<int>::radix);
  1026.  
  1027.     static inline bool epsilon     () { return 0; }
  1028.     static inline bool round_error () { return 0; }
  1029.  
  1030.     static const int min_exponent   __RW_INIT(0);
  1031.     static const int min_exponent10 __RW_INIT(0);
  1032.     static const int max_exponent   __RW_INIT(0);
  1033.     static const int max_exponent10 __RW_INIT(0);
  1034.  
  1035.     static const bool has_infinity      __RW_INIT(false);
  1036.     static const bool has_quiet_NaN     __RW_INIT(false);
  1037.     static const bool has_signaling_NaN __RW_INIT(false);
  1038.     static const bool has_denorm        __RW_INIT(false);
  1039.  
  1040.     static inline int infinity      () { return 0;     }
  1041.     static inline int quiet_NaN     () { return 0;     }
  1042.     static inline int signaling_NaN () { return 0;     }
  1043.     static inline int denorm_min    () { return min(); }
  1044.  
  1045.     static const bool is_iec559  __RW_INIT(false);
  1046.     static const bool is_bounded __RW_INIT(true);
  1047.     static const bool is_modulo  __RW_INIT(false);
  1048.  
  1049.     static const bool traps           __RW_INIT(false);
  1050.     static const bool tinyness_before __RW_INIT(false);
  1051.  
  1052.     static const float_round_style round_style __RW_INIT(round_toward_zero);
  1053. };
  1054. #endif /*!RWSTD_NO_BOOL*/
  1055.  
  1056. #undef __RW_INIT
  1057.  
  1058. #ifndef RWSTD_NO_NAMESPACE
  1059. }
  1060. #endif
  1061.  
  1062. #endif /*__STD_LIMITS*/
  1063.  
  1064. #endif /* __USING_STD_NAMES__ */
  1065.