1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/epoc32/include/tools/stlport/stl/_limits.c Wed Mar 31 12:33:34 2010 +0100
1.3 @@ -0,0 +1,315 @@
1.4 +/*
1.5 + * Copyright (c) 1998,1999
1.6 + * Silicon Graphics Computer Systems, Inc.
1.7 + *
1.8 + * Copyright (c) 1999
1.9 + * Boris Fomitchev
1.10 + *
1.11 + * This material is provided "as is", with absolutely no warranty expressed
1.12 + * or implied. Any use is at your own risk.
1.13 + *
1.14 + * Permission to use or copy this software for any purpose is hereby granted
1.15 + * without fee, provided the above notices are retained on all copies.
1.16 + * Permission to modify the code and to distribute modified code is granted,
1.17 + * provided the above notices are retained, and a notice that the code was
1.18 + * modified is included with the above copyright notice.
1.19 + *
1.20 + */
1.21 +
1.22 +#ifndef _STLP_LIMITS_C
1.23 +#define _STLP_LIMITS_C
1.24 +
1.25 +#ifndef _STLP_INTERNAL_LIMITS
1.26 +# include <stl/_limits.h>
1.27 +#endif
1.28 +
1.29 +//==========================================================
1.30 +// numeric_limits static members
1.31 +//==========================================================
1.32 +
1.33 +_STLP_BEGIN_NAMESPACE
1.34 +
1.35 +_STLP_MOVE_TO_PRIV_NAMESPACE
1.36 +
1.37 +#if !defined (_STLP_STATIC_CONST_INIT_BUG)
1.38 +
1.39 +# define __declare_numeric_base_member(__type, __mem, _Init) \
1.40 +template <class __number> \
1.41 + const __type _Numeric_limits_base<__number>:: __mem
1.42 +
1.43 +__declare_numeric_base_member(bool, is_specialized, false);
1.44 +__declare_numeric_base_member(int, digits, 0);
1.45 +__declare_numeric_base_member(int, digits10, 0);
1.46 +__declare_numeric_base_member(bool, is_signed, false);
1.47 +__declare_numeric_base_member(bool, is_integer, false);
1.48 +__declare_numeric_base_member(bool, is_exact, false);
1.49 +__declare_numeric_base_member(int, radix, 0);
1.50 +__declare_numeric_base_member(int, min_exponent, 0);
1.51 +__declare_numeric_base_member(int, max_exponent, 0);
1.52 +__declare_numeric_base_member(int, min_exponent10, 0);
1.53 +__declare_numeric_base_member(int, max_exponent10, 0);
1.54 +__declare_numeric_base_member(bool, has_infinity, false);
1.55 +__declare_numeric_base_member(bool, has_quiet_NaN, false);
1.56 +__declare_numeric_base_member(bool, has_signaling_NaN, false);
1.57 +__declare_numeric_base_member(float_denorm_style, has_denorm, denorm_absent);
1.58 +__declare_numeric_base_member(bool, has_denorm_loss, false);
1.59 +__declare_numeric_base_member(bool, is_iec559, false);
1.60 +__declare_numeric_base_member(bool, is_bounded, false);
1.61 +__declare_numeric_base_member(bool, is_modulo, false);
1.62 +__declare_numeric_base_member(bool, traps, false);
1.63 +__declare_numeric_base_member(bool, tinyness_before, false);
1.64 +__declare_numeric_base_member(float_round_style, round_style, round_toward_zero);
1.65 +
1.66 +# undef __declare_numeric_base_member
1.67 +
1.68 +# define __declare_integer_limits_member(__type, __mem, _Init) \
1.69 +template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> \
1.70 + const __type _Integer_limits<_Int, __imin, __imax, __idigits, __ismod>:: __mem
1.71 +
1.72 +__declare_integer_limits_member(bool, is_specialized, true);
1.73 +__declare_integer_limits_member(int, digits, (__idigits < 0) ? \
1.74 + ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) \
1.75 + : (__idigits) );
1.76 +__declare_integer_limits_member(int, digits10, (int)(301UL * digits) /1000);
1.77 +__declare_integer_limits_member(bool, is_signed, __imin != 0);
1.78 +__declare_integer_limits_member(bool, is_integer, true);
1.79 +__declare_integer_limits_member(bool, is_exact, true);
1.80 +__declare_integer_limits_member(int, radix, 2);
1.81 +__declare_integer_limits_member(bool, is_bounded, true);
1.82 +__declare_integer_limits_member(bool, is_modulo, true);
1.83 +# undef __declare_integer_limits_member
1.84 +
1.85 +# define __declare_float_limits_member(__type, __mem, _Init) \
1.86 +template <class __number, \
1.87 + int __Digits, int __Digits10, \
1.88 + int __MinExp, int __MaxExp, \
1.89 + int __MinExp10, int __MaxExp10, \
1.90 + bool __IsIEC559, \
1.91 + float_round_style __RoundStyle> \
1.92 +const __type _Floating_limits< __number, __Digits, __Digits10, \
1.93 + __MinExp, __MaxExp, __MinExp10, __MaxExp10, \
1.94 + __IsIEC559, __RoundStyle>::\
1.95 + __mem
1.96 +
1.97 +__declare_float_limits_member(bool, is_specialized, true);
1.98 +__declare_float_limits_member(int, digits, __Digits);
1.99 +__declare_float_limits_member(int, digits10, __Digits10);
1.100 +__declare_float_limits_member(bool, is_signed, true);
1.101 +__declare_float_limits_member(int, radix, FLT_RADIX);
1.102 +__declare_float_limits_member(int, min_exponent, __MinExp);
1.103 +__declare_float_limits_member(int, max_exponent, __MaxExp);
1.104 +__declare_float_limits_member(int, min_exponent10, __MinExp10);
1.105 +__declare_float_limits_member(int, max_exponent10, __MaxExp10);
1.106 +__declare_float_limits_member(bool, has_infinity, true);
1.107 +__declare_float_limits_member(bool, has_quiet_NaN, true);
1.108 +__declare_float_limits_member(bool, has_signaling_NaN, true);
1.109 +__declare_float_limits_member(float_denorm_style, has_denorm, denorm_indeterminate);
1.110 +__declare_float_limits_member(bool, has_denorm_loss, false);
1.111 +__declare_float_limits_member(bool, is_iec559, __IsIEC559);
1.112 +__declare_float_limits_member(bool, is_bounded, true);
1.113 +__declare_float_limits_member(bool, traps, true);
1.114 +__declare_float_limits_member(bool, tinyness_before, false);
1.115 +__declare_float_limits_member(float_round_style, round_style, __RoundStyle);
1.116 +# undef __declare_float_limits_member
1.117 +
1.118 +#endif /* _STLP_STATIC_CONST_INIT_BUG */
1.119 +
1.120 +
1.121 +#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
1.122 +
1.123 +# if defined (_STLP_BIG_ENDIAN)
1.124 +# if defined (__OS400__)
1.125 +# define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
1.126 +# define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
1.127 +# define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
1.128 +# define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
1.129 +# define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
1.130 +# define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
1.131 +# define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
1.132 +# define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
1.133 +# define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
1.134 +# else /* __OS400__ */
1.135 +# define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
1.136 +# define _STLP_FLOAT_QNAN_REP { 0x7fc1, 0 }
1.137 +# define _STLP_FLOAT_SNAN_REP { 0x7f81, 0 }
1.138 +# define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
1.139 +# define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
1.140 +# define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
1.141 +# define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
1.142 +# define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
1.143 +# define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
1.144 +# endif /* __OS400__ */
1.145 +
1.146 +# elif defined (_STLP_LITTLE_ENDIAN)
1.147 +
1.148 +# if 0 /* defined(_STLP_MSVC) || defined(__linux__) */
1.149 +// some IA-32 platform ??
1.150 +/*
1.151 +# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
1.152 +# define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
1.153 +# define _STLP_FLOAT_SNAN_REP { 0, 0xff80 }
1.154 +
1.155 +# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
1.156 +# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
1.157 +# define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0xfff0 }
1.158 +# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 } // ????
1.159 +# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 } // ????
1.160 +# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF0, 0 } // ????
1.161 +*/
1.162 +# elif defined(__DECCXX)
1.163 +
1.164 +# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
1.165 +# define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
1.166 +# define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }
1.167 +
1.168 +# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
1.169 +# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
1.170 +# define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }
1.171 +
1.172 +# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
1.173 +# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
1.174 +# define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
1.175 +# else
1.176 +# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
1.177 +# define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
1.178 +# define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
1.179 +# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
1.180 +# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
1.181 +# define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
1.182 +# if defined (_STLP_MSVC) || defined (__ICL)
1.183 +# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
1.184 +# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
1.185 +# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
1.186 +# elif defined (__BORLANDC__)
1.187 +# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
1.188 +# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
1.189 +# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
1.190 +# else
1.191 +# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
1.192 +# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
1.193 +# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
1.194 +# endif
1.195 +# endif
1.196 +# else
1.197 +/* This is an architecture we don't know how to handle. Return some
1.198 +obviously wrong values. */
1.199 +# define _STLP_FLOAT_INF_REP { 0, 0 }
1.200 +# define _STLP_FLOAT_QNAN_REP { 0, 0 }
1.201 +# define _STLP_FLOAT_SNAN_REP { 0, 0 }
1.202 +# define _STLP_DOUBLE_INF_REP { 0, 0 }
1.203 +# define _STLP_DOUBLE_QNAN_REP { 0, 0 }
1.204 +# define _STLP_DOUBLE_SNAN_REP { 0, 0 }
1.205 +# define _STLP_LDOUBLE_INF_REP { 0 }
1.206 +# define _STLP_LDOUBLE_QNAN_REP { 0 }
1.207 +# define _STLP_LDOUBLE_SNAN_REP { 0 }
1.208 +
1.209 +# endif
1.210 +
1.211 +# if 0
1.212 +/*
1.213 +# if defined(_STLP_BIG_ENDIAN)
1.214 +
1.215 +# elif defined (_STLP_LITTLE_ENDIAN)
1.216 +# else
1.217 +
1.218 +//This is an architecture we don't know how to handle. Return some
1.219 +//obviously wrong values.
1.220 +# define _STLP_FLOAT_INF_REP { 0, 0 }
1.221 +# define _STLP_FLOAT_QNAN_REP { 0, 0 }
1.222 +# define _STLP_FLOAT_SNAN_REP { 0, 0 }
1.223 +# define _STLP_DOUBLE_INF_REP { 0, 0 }
1.224 +# define _STLP_DOUBLE_QNAN_REP { 0, 0 }
1.225 +# define _STLP_DOUBLE_SNAN_REP { 0, 0 }
1.226 +# define _STLP_LDOUBLE_INF_REP { 0 }
1.227 +# define _STLP_LDOUBLE_QNAN_REP { 0 }
1.228 +# define _STLP_LDOUBLE_SNAN_REP { 0 }
1.229 +# endif
1.230 +*/
1.231 +# endif
1.232 +
1.233 +union _F_rep {
1.234 + unsigned short rep[2];
1.235 + float val;
1.236 +};
1.237 +union _D_rep {
1.238 + unsigned short rep[4];
1.239 + double val;
1.240 +};
1.241 +
1.242 +# ifndef _STLP_NO_LONG_DOUBLE
1.243 +union _LD_rep {
1.244 + unsigned short rep[8];
1.245 + long double val;
1.246 +};
1.247 +# endif
1.248 +
1.249 +template <class __dummy>
1.250 +float _STLP_CALL _LimG<__dummy>::get_F_inf() {
1.251 + _F_rep _F_inf = {_STLP_FLOAT_INF_REP};
1.252 + return _F_inf.val;
1.253 +}
1.254 +template <class __dummy>
1.255 +float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
1.256 + _F_rep _F_qNaN = {_STLP_FLOAT_QNAN_REP};
1.257 + return _F_qNaN.val;
1.258 +}
1.259 +template <class __dummy>
1.260 +float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
1.261 + _F_rep _F_sNaN = {_STLP_FLOAT_SNAN_REP};
1.262 + return _F_sNaN.val;
1.263 +}
1.264 +
1.265 +template <class __dummy>
1.266 +double _STLP_CALL _LimG<__dummy>::get_D_inf() {
1.267 + _D_rep _D_inf = {_STLP_DOUBLE_INF_REP};
1.268 + return _D_inf.val;
1.269 +}
1.270 +template <class __dummy>
1.271 +double _STLP_CALL _LimG<__dummy>::get_D_qNaN() {
1.272 + _D_rep _D_qNaN = {_STLP_DOUBLE_QNAN_REP};
1.273 + return _D_qNaN.val;
1.274 +}
1.275 +template <class __dummy>
1.276 +double _STLP_CALL _LimG<__dummy>::get_D_sNaN() {
1.277 + _D_rep _D_sNaN = {_STLP_DOUBLE_SNAN_REP};
1.278 + return _D_sNaN.val;
1.279 +}
1.280 +
1.281 +# if !defined (_STLP_NO_LONG_DOUBLE)
1.282 +template <class __dummy>
1.283 +long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
1.284 + _LD_rep _LD_inf = {_STLP_LDOUBLE_INF_REP};
1.285 + return _LD_inf.val;
1.286 +}
1.287 +template <class __dummy>
1.288 +long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
1.289 + _LD_rep _LD_qNaN = {_STLP_LDOUBLE_QNAN_REP};
1.290 + return _LD_qNaN.val;
1.291 +}
1.292 +template <class __dummy>
1.293 +long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
1.294 + _LD_rep _LD_sNaN = {_STLP_LDOUBLE_SNAN_REP};
1.295 + return _LD_sNaN.val;
1.296 +}
1.297 +# endif /* _STLP_NO_LONG_DOUBLE */
1.298 +
1.299 +#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
1.300 +
1.301 +#undef _STLP_LIMITS_MIN_TYPE
1.302 +#undef _STLP_LIMITS_MAX_TYPE
1.303 +
1.304 +#undef _STLP_FLOAT_INF_REP
1.305 +#undef _STLP_FLOAT_QNAN_REP
1.306 +#undef _STLP_FLOAT_SNAN_REP
1.307 +#undef _STLP_DOUBLE_INF_REP
1.308 +#undef _STLP_DOUBLE_QNAN_REP
1.309 +#undef _STLP_DOUBLE_SNAN_REP
1.310 +#undef _STLP_LDOUBLE_INF_REP
1.311 +#undef _STLP_LDOUBLE_QNAN_REP
1.312 +#undef _STLP_LDOUBLE_SNAN_REP
1.313 +
1.314 +_STLP_MOVE_TO_STD_NAMESPACE
1.315 +
1.316 +_STLP_END_NAMESPACE
1.317 +
1.318 +#endif /* _STLP_LIMITS_C_INCLUDED */