ndk/sources/cxx-stl/stlport/src/num_put_float.cpp

   1 /*
   2  * Copyright (c) 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 #include "stlport_prefix.h"
  20
  21 #include <cmath>
  22 #include <ios>
  23 #include <locale>
  24
  25 #if defined (__DECCXX)
  26 #  define NDIG 400
  27 #else
  28 #  define NDIG 82
  29 #endif
  30
  31 #define todigit(x) ((x)+'0')
  32
  33 #if defined (_STLP_UNIX)
  34
  35 #  if defined (__sun)
  36 #    include <floatingpoint.h>
  37 #  endif
  38
  39 #  if defined (__sun) || defined (__digital__) || defined (__sgi) || defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR)
  40 // DEC, SGI & Solaris need this
  41 #    include <values.h>
  42 #    include <nan.h>
  43 #  endif
  44
  45 #  if defined (__QNXNTO__) || ( defined(__GNUC__) && defined(__APPLE__) ) || defined(_STLP_USE_UCLIBC) /* 0.9.26 */ || \
  46       defined(__FreeBSD__)
  47 #    define USE_SPRINTF_INSTEAD
  48 #  endif
  49
  50 #  if defined (_AIX) // JFA 3-Aug-2000
  51 #    include <math.h>
  52 #    include <float.h>
  53 #  endif
  54
  55 #  include <math.h>
  56 #endif
  57
  58 #include <cstdio>
  59 #include <cstdlib>
  60
  61 #if defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__) || defined (__DJGPP) || \
  62     defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR)
  63 #  include <float.h>
  64 #endif
  65
  66 #if defined (__MRC__) || defined (__SC__)  || defined (_CRAY)  //*TY 02/24/2000 - added support for MPW
  67 #  include <fp.h>
  68 #endif
  69
  70 #if defined (__CYGWIN__)
  71 #  include <ieeefp.h>
  72 #endif
  73
  74 #if defined (__MSL__)
  75 #  include <cstdlib>  // for atoi
  76 #  include <cstdio>  // for snprintf
  77 #  include <algorithm>
  78 #  include <cassert>
  79 #endif
  80
  81 #if defined (__ISCPP__)
  82 #  include <cfloat>
  83 #endif
  84
  85 #include <algorithm>
  86
  87 #if defined (__DMC__)
  88 #  define snprintf _snprintf
  89 #endif
  90
  91 _STLP_BEGIN_NAMESPACE
  92
  93 _STLP_MOVE_TO_PRIV_NAMESPACE
  94
  95 #if defined (__MWERKS__) || defined(__BEOS__)
  96 #  define USE_SPRINTF_INSTEAD
  97 #endif
  98
  99 template <int N>
 100 struct _Dig
 101 {
 102     enum { dig = _Dig<N/10>::dig + 1 };
 103 };
 104
 105 _STLP_TEMPLATE_NULL
 106 struct _Dig<0>
 107 {
 108     enum { dig = 0 };
 109 };
 110
 111 #ifdef _STLP_NO_LONG_DOUBLE
 112 # define MAXEDIGITS int(_Dig<DBL_MAX_10_EXP>::dig)
 113 # define MAXFSIG DBL_DIG
 114 # define MAXFCVT (DBL_DIG + 1)
 115 #else
 116 # define MAXEDIGITS int(_Dig<LDBL_MAX_10_EXP>::dig)
 117 # define MAXFSIG LDBL_DIG
 118 # define MAXFCVT (LDBL_DIG + 1)
 119 #endif
 120
 121 // Tests for infinity and NaN differ on different OSs.  We encapsulate
 122 // these differences here.
 123 #if !defined (USE_SPRINTF_INSTEAD)
 124 #  if defined (__hpux) && defined (__GNUC__)
 125 #    define _STLP_USE_SIGN_HELPER
 126 #  elif defined (__DJGPP) || (defined (_STLP_USE_GLIBC) && ! defined (__MSL__)) || \
 127       defined (__CYGWIN__) || \
 128       defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \
 129       defined (__HP_aCC)
 130 static inline bool _Stl_is_nan_or_inf(double x)
 131 #    if defined (isfinite)
 132 { return !isfinite(x); }
 133 #    else
 134 { return !finite(x); }
 135 #    endif
 136 static inline bool _Stl_is_neg_nan(double x)    { return isnan(x) && ( copysign(1., x) < 0 ); }
 137 static inline bool _Stl_is_inf(double x)        { return isinf(x); }
 138 // inline bool _Stl_is_neg_inf(double x)    { return isinf(x) < 0; }
 139 static inline bool _Stl_is_neg_inf(double x)    { return isinf(x) && x < 0; }
 140 #  elif (defined (__unix) || defined (__unix__)) && \
 141          !defined (__APPLE__) && !defined (__DJGPP) && !defined(__osf__) && \
 142          !defined (_CRAY) && !defined(__ANDROID__)
 143 static inline bool _Stl_is_nan_or_inf(double x) { return IsNANorINF(x); }
 144 static inline bool _Stl_is_inf(double x)        { return IsNANorINF(x) && IsINF(x); }
 145 static inline bool _Stl_is_neg_inf(double x)    { return (IsINF(x)) && (x < 0.0); }
 146 static inline bool _Stl_is_neg_nan(double x)    { return IsNegNAN(x); }
 147 #  elif defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__)
 148 static inline bool _Stl_is_nan_or_inf(double x) { return !_finite(x); }
 149 #    if !defined (__BORLANDC__)
 150 static inline bool _Stl_is_inf(double x)        {
 151   int fclass = _fpclass(x);
 152   return fclass == _FPCLASS_NINF || fclass == _FPCLASS_PINF;
 153 }
 154 static inline bool _Stl_is_neg_inf(double x)    { return _fpclass(x) == _FPCLASS_NINF; }
 155 #    else
 156 static inline bool _Stl_is_inf(double x)        {  return _Stl_is_nan_or_inf(x) && !_isnan(x);}
 157 static inline bool _Stl_is_neg_inf(double x)    {  return _Stl_is_inf(x) && x < 0 ; }
 158 #    endif
 159 static inline bool _Stl_is_neg_nan(double x)    { return _isnan(x) && _copysign(1., x) < 0 ; }
 160 #    if defined (__BORLANDC__)
 161 static inline bool _Stl_is_nan_or_inf(long double x) { return !_finitel(x); }
 162 static inline bool _Stl_is_inf(long double x)        {  return _Stl_is_nan_or_inf(x) && !_isnanl(x);}
 163 static inline bool _Stl_is_neg_inf(long double x)    {  return _Stl_is_inf(x) && x < 0 ; }
 164 static inline bool _Stl_is_neg_nan(long double x)    { return _isnanl(x) && _copysignl(1.l, x) < 0 ; }
 165 #    elif !defined (_STLP_NO_LONG_DOUBLE)
 166 // Simply there to avoid warning long double -> double implicit conversion:
 167 static inline bool _Stl_is_nan_or_inf(long double x) { return _Stl_is_nan_or_inf(__STATIC_CAST(double, x)); }
 168 static inline bool _Stl_is_inf(long double x)        {  return _Stl_is_inf(__STATIC_CAST(double, x));}
 169 static inline bool _Stl_is_neg_inf(long double x)    {  return _Stl_is_neg_inf(__STATIC_CAST(double, x)); }
 170 static inline bool _Stl_is_neg_nan(long double x)    { return _Stl_is_neg_nan(__STATIC_CAST(double, x)); }
 171 #    endif
 172 #  elif defined (__MRC__) || defined (__SC__) || defined (__DMC__)
 173 static bool _Stl_is_nan_or_inf(double x) { return isnan(x) || !isfinite(x); }
 174 static bool _Stl_is_inf(double x)        { return !isfinite(x); }
 175 static bool _Stl_is_neg_inf(double x)    { return !isfinite(x) && signbit(x); }
 176 static bool _Stl_is_neg_nan(double x)    { return isnan(x) && signbit(x); }
 177 #  elif /* defined(__FreeBSD__) || defined(__OpenBSD__) || */ (defined(__GNUC__) && defined(__APPLE__))
 178 static inline bool _Stl_is_nan_or_inf(double x) { return !finite(x); }
 179 static inline bool _Stl_is_inf(double x)        {   return _Stl_is_nan_or_inf(x) && ! isnan(x); }
 180 static inline bool _Stl_is_neg_inf(double x)    {   return _Stl_is_inf(x) && x < 0 ; }
 181 static inline bool _Stl_is_neg_nan(double x)    { return isnan(x) && copysign(1., x) < 0 ; }
 182 #  elif defined( _AIX ) // JFA 11-Aug-2000
 183 static bool _Stl_is_nan_or_inf(double x) { return isnan(x) || !finite(x); }
 184 static bool _Stl_is_inf(double x)        { return !finite(x); }
 185 // bool _Stl_is_neg_inf(double x)    { return _class(x) == FP_MINUS_INF; }
 186 static bool _Stl_is_neg_inf(double x)    { return _Stl_is_inf(x) && ( copysign(1., x) < 0 );  }
 187 static bool _Stl_is_neg_nan(double x)    { return isnan(x) && ( copysign(1., x) < 0 );  }
 188 #  elif defined (__ISCPP__)
 189 static inline bool _Stl_is_nan_or_inf  (double x) { return _fp_isINF(x) || _fp_isNAN(x); }
 190 static inline bool _Stl_is_inf         (double x) { return _fp_isINF(x); }
 191 static inline bool _Stl_is_neg_inf     (double x) { return _fp_isINF(x) && x < 0; }
 192 static inline bool _Stl_is_neg_nan     (double x) { return _fp_isNAN(x) && x < 0; }
 193 #  elif defined (_CRAY)
 194 #    if defined (_CRAYIEEE)
 195 static inline bool _Stl_is_nan_or_inf(double x) { return isnan(x) || isinf(x); }
 196 static inline bool _Stl_is_inf(double x)        { return isinf(x); }
 197 static inline bool _Stl_is_neg_inf(double x)    { return isinf(x) && signbit(x); }
 198 static inline bool _Stl_is_neg_nan(double x)    { return isnan(x) && signbit(x); }
 199 #    else
 200 static inline bool _Stl_is_nan_or_inf(double x) { return false; }
 201 static inline bool _Stl_is_inf(double x)        { return false; }
 202 static inline bool _Stl_is_neg_inf(double x)    { return false; }
 203 static inline bool _Stl_is_neg_nan(double x)    { return false; }
 204 #    endif
 205 #  else // nothing from above
 206 #    define USE_SPRINTF_INSTEAD
 207 #  endif
 208 #endif // !USE_SPRINTF_INSTEAD
 209
 210 #if !defined (USE_SPRINTF_INSTEAD)
 211 // Reentrant versions of floating-point conversion functions.  The argument
 212 // lists look slightly different on different operating systems, so we're
 213 // encapsulating the differences here.
 214
 215 #  if defined (__CYGWIN__) || defined(__DJGPP)
 216 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
 217 { return ecvtbuf(x, n, pt, sign, buf); }
 218 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
 219 { return fcvtbuf(x, n, pt, sign, buf); }
 220 #    if !defined (_STLP_NO_LONG_DOUBLE)
 221 #      if defined (__CYGWIN__)
 222 #        define _STLP_EMULATE_LONG_DOUBLE_CVT
 223 #      else
 224 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
 225 { return ecvtbuf(x, n, pt, sign, buf); }
 226 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
 227 { return fcvtbuf(x, n, pt, sign, buf); }
 228 #      endif
 229 #    endif
 230 #  elif defined (_STLP_USE_GLIBC)
 231 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 232 { return ecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
 233 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 234 { return fcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
 235 #    ifndef _STLP_NO_LONG_DOUBLE
 236 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 237 { return qecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
 238 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 239 { return qfcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
 240 #    endif
 241 #    define _STLP_NEED_CVT_BUFFER_SIZE
 242 #  elif defined (__sun)
 243 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
 244 { return econvert(x, n, pt, sign, buf); }
 245 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
 246 { return fconvert(x, n, pt, sign, buf); }
 247 #    ifndef _STLP_NO_LONG_DOUBLE
 248 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
 249 { return qeconvert(&x, n, pt, sign, buf); }
 250 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
 251 { return qfconvert(&x, n, pt, sign, buf); }
 252 #    endif
 253 #  elif defined (__DECCXX)
 254 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 255 { return (ecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0); }
 256 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 257 { return (fcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0); }
 258 #    ifndef _STLP_NO_LONG_DOUBLE
 259 // fbp : no "long double" conversions !
 260 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 261 { return (ecvt_r((double)x, n, pt, sign, buf, bsize) == 0 ? buf : 0) ; }
 262 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
 263 { return (fcvt_r((double)x, n, pt, sign, buf, bsize) == 0 ? buf : 0); }
 264 #    endif
 265 #    define _STLP_NEED_CVT_BUFFER_SIZE
 266 #  elif defined (__hpux)
 267 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign)
 268 { return ecvt(x, n, pt, sign); }
 269 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign)
 270 { return fcvt(x, n, pt, sign); }
 271 #    if !defined (_STLP_NO_LONG_DOUBLE)
 272 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign)
 273 { return _ldecvt(*(long_double*)&x, n, pt, sign); }
 274 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign)
 275 { return _ldfcvt(*(long_double*)&x, n, pt, sign); }
 276 #    endif
 277 #    define _STLP_CVT_NEED_SYNCHRONIZATION
 278 #  elif defined (__unix) && !defined (__APPLE__) && !defined (_CRAY)
 279 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
 280 { return ecvt_r(x, n, pt, sign, buf); }
 281 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
 282 { return fcvt_r(x, n, pt, sign, buf); }
 283 #    if !defined (_STLP_NO_LONG_DOUBLE)
 284 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
 285 { return qecvt_r(x, n, pt, sign, buf); }
 286 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
 287 { return qfcvt_r(x, n, pt, sign, buf); }
 288 #    endif
 289 #  elif defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__)
 290 #    if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
 291 #      define _STLP_APPEND(a, b) a##b
 292 #      define _STLP_BUF_PARAMS , char* buf, size_t bsize
 293 #      define _STLP_SECURE_FUN(F, X, N, PT, SIGN) _STLP_APPEND(F, _s)(buf, bsize, X, N, PT, SIGN); return buf
 294 #    else
 295 #      define _STLP_BUF_PARAMS
 296 #      define _STLP_SECURE_FUN(F, X, N, PT, SIGN) return F(X, N, PT, SIGN)
 297 #      define _STLP_CVT_NEED_SYNCHRONIZATION
 298 #    endif
 299 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
 300 { _STLP_SECURE_FUN(_ecvt, x, n, pt, sign); }
 301 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
 302 { _STLP_SECURE_FUN(_fcvt, x, n, pt, sign); }
 303 #    if !defined (_STLP_NO_LONG_DOUBLE)
 304 #      if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
 305 #        define _STLP_PARAMS , buf, bsize
 306 #      else
 307 #        define _STLP_PARAMS
 308 #      endif
 309 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
 310 { return _Stl_ecvtR(__STATIC_CAST(double, x), n, pt, sign _STLP_PARAMS); }
 311 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
 312 { return _Stl_fcvtR(__STATIC_CAST(double, x), n, pt, sign _STLP_PARAMS); }
 313 #      undef _STLP_PARAMS
 314 #    endif
 315 #    undef _STLP_SECURE_FUN
 316 #    undef _STLP_BUF_PARAMS
 317 #    undef _STLP_APPEND
 318 #    if defined (__BORLANDC__) /* || defined (__GNUC__) MinGW do not support 'L' modifier so emulation do not work */
 319 #      define _STLP_EMULATE_LONG_DOUBLE_CVT
 320 #    endif
 321 #  elif defined (__ISCPP__)
 322 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
 323 { return _fp_ecvt( x, n, pt, sign, buf); }
 324 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
 325 { return _fp_fcvt(x, n, pt, sign, buf); }
 326 #    if !defined (_STLP_NO_LONG_DOUBLE)
 327 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
 328 { return _fp_ecvt( x, n, pt, sign, buf); }
 329 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
 330 { return _fp_fcvt(x, n, pt, sign, buf); }
 331 #    endif
 332 #  elif defined (_AIX) || defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \
 333         defined (__MRC__) || defined (__SC__) || defined (_CRAY) || \
 334         defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR) || \
 335         defined (__DMC__)
 336 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign)
 337 { return ecvt(x, n, pt, sign ); }
 338 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign)
 339 { return fcvt(x, n, pt, sign); }
 340 #    if !defined (_STLP_NO_LONG_DOUBLE)
 341 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign)
 342 { return ecvt(x, n, pt, sign ); }
 343 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign)
 344 { return fcvt(x, n, pt, sign); }
 345 #    endif
 346 #    define _STLP_CVT_NEED_SYNCHRONIZATION
 347 #  else
 348 #    error Missing _Stl_ecvtR and _Stl_fcvtR implementations.
 349 #  endif
 350
 351 #if defined (_STLP_CVT_NEED_SYNCHRONIZATION)
 352 /* STLport synchronize access to *cvt functions but those methods might
 353  * be called from outside, in this case we will still have a race condition. */
 354 #  if defined (_STLP_THREADS)
 355 static _STLP_STATIC_MUTEX& put_float_mutex() {
 356   static _STLP_STATIC_MUTEX __put_float_mutex _STLP_MUTEX_INITIALIZER;
 357   return __put_float_mutex;
 358 }
 359 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) {
 360   _STLP_auto_lock lock(put_float_mutex());
 361   strcpy(buf, _Stl_ecvtR(x, n, pt, sign)); return buf;
 362 }
 363 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) {
 364   _STLP_auto_lock lock(put_float_mutex());
 365   strcpy(buf, _Stl_fcvtR(x, n, pt, sign)); return buf;
 366 }
 367 #    if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
 368 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) {
 369   _STLP_auto_lock lock(put_float_mutex());
 370   strcpy(buf, _Stl_ecvtR(x, n, pt, sign)); return buf;
 371 }
 372 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) {
 373   _STLP_auto_lock lock(put_float_mutex());
 374   strcpy(buf, _Stl_fcvtR(x, n, pt, sign)); return buf;
 375 }
 376 #    endif
 377 #  else
 378 static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char*)
 379 { return _Stl_ecvtR(x, n, pt, sign); }
 380 static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char*)
 381 { return _Stl_fcvtR(x, n, pt, sign); }
 382 #    if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
 383 static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char*)
 384 { return _Stl_ecvtR(x, n, pt, sign); }
 385 static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char*)
 386 { return _Stl_fcvtR(x, n, pt, sign); }
 387 #    endif
 388 #  endif
 389 #endif
 390
 391 #  if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS) && !defined (_STLP_NEED_CVT_BUFFER_SIZE)
 392 #    define _STLP_CVT_BUFFER(B) B
 393 #  else
 394 #    define _STLP_CVT_BUFFER(B) _STLP_ARRAY_AND_SIZE(B)
 395 #  endif
 396
 397 #  if defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
 398 static void __fill_fmtbuf(char* fmtbuf, ios_base::fmtflags flags, char long_modifier);
 399
 400 // Emulation of ecvt/fcvt functions using sprintf:
 401 static char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) {
 402   // If long double value can be safely converted to double without losing precision
 403   // we use the ecvt function for double:
 404   double y = __STATIC_CAST(double, x);
 405   if (x == y)
 406     return _Stl_ecvtR(y, n, pt, sign, buf);
 407
 408   char fmtbuf[32];
 409   __fill_fmtbuf(fmtbuf, 0, 'L');
 410   sprintf(buf, fmtbuf, n, x < 0.0l ? -x : x);
 411   /* We are waiting for something having the form x.xxxe+yyyy */
 412   *pt = 0;
 413   *sign = 0;
 414   int i = -1;
 415   int offset = 0;
 416   while (buf[++i] != 0 && n != 0) {
 417     if (buf[i] >= '0' && buf[i] <= '9') {
 418       --n;
 419       if (offset != 0)
 420         buf[i - offset] = buf[i];
 421     }
 422     else {
 423       if (offset != 0) break;
 424       ++offset;
 425       *pt = i;
 426     }
 427   }
 428   if (offset != 0)
 429     buf[i - offset] = 0;
 430   // Extract exponent part in point position:
 431   int e = 0;
 432   while (buf[++i] != 0) {
 433     if (buf[i] >= '0' && buf[i] <= '9') {
 434       e = e * 10 + (buf[i] - '0');
 435     }
 436   }
 437   *pt += e;
 438   return buf;
 439 }
 440
 441 static char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) {
 442   // If long double value can be safely converted to double without losing precision
 443   // we use the fcvt function for double:
 444   double y = __STATIC_CAST(double, x);
 445   if (x == y)
 446     return _Stl_fcvtR(y, n, pt, sign, buf);
 447
 448   char fmtbuf[32];
 449   __fill_fmtbuf(fmtbuf, ios_base::fixed, 'L');
 450   sprintf(buf, fmtbuf, n, x < 0.0l ? -x : x);
 451   *pt = 0;
 452   *sign = 0;
 453   int i = -1;
 454   int offset = 0;
 455   while (buf[++i] != 0 && (offset == 0 || n != 0)) {
 456     if (buf[i] >= '0' && buf[i] <= '9') {
 457       if (offset != 0) {
 458         --n;
 459         buf[i - offset] = buf[i];
 460       }
 461     }
 462     else {
 463       ++offset;
 464       *pt = i;
 465     }
 466   }
 467   if (offset != 0)
 468     buf[i - offset] = 0;
 469   else
 470     *pt = i;
 471   return buf;
 472 }
 473 #endif
 474
 475 //----------------------------------------------------------------------
 476 // num_put
 477
 478 // __format_float formats a mantissa and exponent as returned by
 479 // one of the conversion functions (ecvt_r, fcvt_r, qecvt_r, qfcvt_r)
 480 // according to the specified precision and format flags.  This is
 481 // based on doprnt but is much simpler since it is concerned only
 482 // with floating point input and does not consider all formats.  It
 483 // also does not deal with blank padding, which is handled by
 484 // __copy_float_and_fill.
 485
 486 static size_t __format_float_scientific( __iostring& buf, const char *bp,
 487                                          int decpt, int sign, bool is_zero,
 488                                          ios_base::fmtflags flags,
 489                                          int precision) {
 490   // sign if required
 491   if (sign)
 492     buf += '-';
 493   else if (flags & ios_base::showpos)
 494     buf += '+';
 495
 496   // first digit of mantissa
 497   buf += *bp++;
 498
 499   // start of grouping position, grouping won't occur in scientific notation
 500   // as it is impossible to have something like 1234.0e04 but we return a correct
 501   // group position for coherency with __format_float_fixed.
 502   size_t __group_pos = buf.size();
 503
 504   // decimal point if required
 505   if (precision != 0 || flags & ios_base::showpoint) {
 506     buf += '.';
 507   }
 508
 509   // rest of mantissa
 510   while (*bp != 0 && precision--)
 511     buf += *bp++;
 512
 513   // trailing 0 if needed
 514   if (precision > 0)
 515     buf.append(precision, '0');
 516
 517   // exponent size = number of digits + exponent sign + exponent symbol + trailing zero
 518   char expbuf[MAXEDIGITS + 3];
 519   //We start filling at the buffer end
 520   char *suffix = expbuf + MAXEDIGITS + 2;
 521   *suffix = 0;
 522   if (!is_zero) {
 523     int nn = decpt - 1;
 524     if (nn < 0)
 525       nn = -nn;
 526     for (; nn > 9; nn /= 10)
 527       *--suffix = (char) todigit(nn % 10);
 528     *--suffix = (char) todigit(nn);
 529   }
 530
 531   // prepend leading zeros to exponent
 532   // C89 Standard says that it should be at least 2 digits, C99 Standard says that
 533   // we stop prepend zeros if more than 3 digits. To repect both STLport prepend zeros
 534   // until it is 2 digits.
 535   while (suffix > &expbuf[MAXEDIGITS])
 536     *--suffix = '0';
 537
 538   // put in the exponent sign
 539   *--suffix = (char) ((decpt > 0 || is_zero ) ? '+' : '-');
 540
 541   // put in the e
 542   *--suffix = flags & ios_base::uppercase ? 'E' : 'e';
 543
 544   // copy the suffix
 545   buf += suffix;
 546   return __group_pos;
 547 }
 548
 549 static size_t __format_float_fixed( __iostring &buf, const char *bp,
 550                                     int decpt, int sign,
 551                                     ios_base::fmtflags flags,
 552                                     int precision) {
 553   if ( sign && (decpt > -precision) && (*bp != 0) )
 554     buf += '-';
 555   else if ( flags & ios_base::showpos )
 556     buf += '+';
 557
 558   // digits before decimal point
 559   int nnn = decpt;
 560   do {
 561     buf += (nnn <= 0 || *bp == 0) ? '0' : *bp++;
 562   } while ( --nnn > 0 );
 563
 564   // start of grouping position
 565   size_t __group_pos = buf.size();
 566
 567   // decimal point if needed
 568   if ( flags & ios_base::showpoint || precision > 0 ) {
 569     buf += '.';
 570   }
 571
 572   // digits after decimal point if any
 573   while ( *bp != 0 && --precision >= 0 ) {
 574     buf += (++decpt <= 0) ? '0' : *bp++;
 575   }
 576
 577   // trailing zeros if needed
 578   if (precision > 0)
 579     buf.append(precision, '0');
 580
 581   return __group_pos;
 582 }
 583
 584 #if defined (_STLP_USE_SIGN_HELPER)
 585 template<class _FloatT>
 586 struct float_sign_helper {
 587   float_sign_helper(_FloatT __x)
 588   { _M_number._num = __x; }
 589
 590   bool is_negative() const {
 591     const unsigned short sign_mask(1 << (sizeof(unsigned short) * CHAR_BIT - 1));
 592     return (get_sign_word() & sign_mask) != 0;
 593   }
 594 private:
 595   union {
 596     unsigned short _Words[8];
 597     _FloatT _num;
 598   } _M_number;
 599
 600   unsigned short get_word_higher() const _STLP_NOTHROW
 601   { return _M_number._Words[0]; }
 602   unsigned short get_word_lower() const _STLP_NOTHROW
 603   { return _M_number._Words[(sizeof(_FloatT) >= 12 ? 10 : sizeof(_FloatT)) / sizeof(unsigned short) - 1]; }
 604   unsigned short get_sign_word() const _STLP_NOTHROW
 605 #  if defined (_STLP_BIG_ENDIAN)
 606   { return get_word_higher(); }
 607 #  else /* _STLP_LITTLE_ENDIAN */
 608   { return get_word_lower(); }
 609 #  endif
 610 };
 611 #endif
 612
 613 template <class _FloatT>
 614 static size_t __format_nan_or_inf(__iostring& buf, _FloatT x, ios_base::fmtflags flags) {
 615   static const char* inf[2] = { "inf", "Inf" };
 616   static const char* nan[2] = { "nan", "NaN" };
 617   const char** inf_or_nan;
 618 #if !defined (_STLP_USE_SIGN_HELPER)
 619   if (_Stl_is_inf(x)) {            // Infinity
 620     inf_or_nan = inf;
 621     if (_Stl_is_neg_inf(x))
 622       buf += '-';
 623     else if (flags & ios_base::showpos)
 624       buf += '+';
 625   } else {                      // NaN
 626     inf_or_nan = nan;
 627     if (_Stl_is_neg_nan(x))
 628       buf += '-';
 629     else if (flags & ios_base::showpos)
 630       buf += '+';
 631   }
 632 #else
 633   typedef numeric_limits<_FloatT> limits;
 634   if (x == limits::infinity() || x == -limits::infinity()) {
 635     inf_or_nan = inf;
 636   } else {                    // NaN
 637     inf_or_nan = nan;
 638   }
 639   float_sign_helper<_FloatT> helper(x);
 640   if (helper.is_negative())
 641     buf += '-';
 642   else if (flags & ios_base::showpos)
 643     buf += '+';
 644 #endif
 645   size_t ret = buf.size();
 646   buf += inf_or_nan[flags & ios_base::uppercase ? 1 : 0];
 647   return ret;
 648 }
 649
 650 static inline size_t __format_float(__iostring &buf, const char * bp,
 651                                     int decpt, int sign, bool is_zero,
 652                                     ios_base::fmtflags flags,
 653                                     int precision) {
 654   size_t __group_pos = 0;
 655   switch (flags & ios_base::floatfield) {
 656     case ios_base::scientific:
 657       __group_pos = __format_float_scientific( buf, bp, decpt, sign, is_zero,
 658                                                flags, precision);
 659       break;
 660     case ios_base::fixed:
 661       __group_pos = __format_float_fixed( buf, bp, decpt, sign,
 662                                           flags, precision);
 663       break;
 664     default: // g format
 665       // establish default precision
 666       if (flags & ios_base::showpoint || precision > 0) {
 667         if (precision == 0) precision = 1;
 668       } else
 669         precision = 6;
 670
 671       // reset exponent if value is zero
 672       if (is_zero)
 673         decpt = 1;
 674
 675       int kk = precision;
 676       if (!(flags & ios_base::showpoint)) {
 677         size_t n = strlen(bp);
 678         if (n < (size_t)kk)
 679           kk = (int)n;
 680         while (kk >= 1 && bp[kk-1] == '0')
 681           --kk;
 682       }
 683
 684       if (decpt < -3 || decpt > precision) {
 685         precision = kk - 1;
 686         __group_pos = __format_float_scientific( buf, bp, decpt, sign, is_zero,
 687                                                  flags, precision);
 688       } else {
 689         precision = kk - decpt;
 690         __group_pos = __format_float_fixed( buf, bp, decpt, sign,
 691                                             flags, precision);
 692       }
 693       break;
 694   } /* switch */
 695   return __group_pos;
 696 }
 697
 698 #endif
 699
 700 #if defined (USE_SPRINTF_INSTEAD) || defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
 701 struct GroupPos {
 702   bool operator () (char __c) const {
 703     return __c == '.' ||
 704            __c == 'e' || __c == 'E';
 705   }
 706 };
 707
 708 // Creates a format string for sprintf()
 709 static void __fill_fmtbuf(char* fmtbuf, ios_base::fmtflags flags, char long_modifier) {
 710   fmtbuf[0] = '%';
 711   int i = 1;
 712
 713   if (flags & ios_base::showpos)
 714     fmtbuf[i++] = '+';
 715
 716   if (flags & ios_base::showpoint)
 717     fmtbuf[i++] = '#';
 718
 719   fmtbuf[i++] = '.';
 720   fmtbuf[i++] = '*';
 721
 722   if (long_modifier)
 723     fmtbuf[i++] = long_modifier;
 724
 725   switch (flags & ios_base::floatfield)
 726     {
 727     case ios_base::scientific:
 728       fmtbuf[i++] = (flags & ios_base::uppercase) ?  'E' : 'e';
 729       break;
 730     case ios_base::fixed:
 731 #  if defined (__FreeBSD__)
 732       fmtbuf[i++] = 'f';
 733 #  else
 734       fmtbuf[i++] = (flags & ios_base::uppercase) ? 'F' : 'f';
 735 #  endif
 736       break;
 737     default:
 738       fmtbuf[i++] = (flags & ios_base::uppercase) ?  'G' : 'g';
 739       break;
 740     }
 741
 742   fmtbuf[i] = 0;
 743 }
 744
 745 #endif  /* USE_SPRINTF_INSTEAD */
 746
 747 template <class _FloatT>
 748 static size_t  __write_floatT(__iostring &buf, ios_base::fmtflags flags, int precision,
 749                               _FloatT x
 750 #if defined (USE_SPRINTF_INSTEAD)
 751                               , char modifier) {
 752   /* In theory, if we want 'arbitrary' precision, we should use 'arbitrary'
 753    * buffer size below, but really we limited by exponent part in double.
 754    *    - ptr
 755    */
 756   typedef numeric_limits<_FloatT> limits;
 757   char static_buf[limits::max_exponent10 + 6]; // 6: -xxx.yyyE-zzz (sign, dot, E, exp sign, \0)
 758   char fmtbuf[32];
 759   __fill_fmtbuf(fmtbuf, flags, modifier);
 760   snprintf(_STLP_ARRAY_AND_SIZE(static_buf), fmtbuf, precision, x);
 761   buf = static_buf;
 762   return find_if(buf.begin(), buf.end(), GroupPos()) - buf.begin();
 763 #else
 764                               ) {
 765   typedef numeric_limits<_FloatT> limits;
 766   //If numeric_limits support is correct we use the exposed values to detect NaN and infinity:
 767   if (limits::has_infinity && limits::has_quiet_NaN) {
 768     if (!(x == x) || // NaN check
 769         (x == limits::infinity() || x == -limits::infinity())) {
 770       return __format_nan_or_inf(buf, x, flags);
 771     }
 772   }
 773   // numeric_limits support is not good enough, we rely on platform dependent function
 774   // _Stl_is_nan_or_inf that do not support long double.
 775   else if (_Stl_is_nan_or_inf(x)) {
 776     return __format_nan_or_inf(buf, x, flags);
 777   }
 778 #  if defined (__MINGW32__)
 779   //For the moment MinGW is limited to display at most numeric_limits<double>::max()
 780   if (x > numeric_limits<double>::max() ||
 781       x < -numeric_limits<double>::max()) {
 782     return __format_nan_or_inf(buf, x, flags);
 783   }
 784 #  endif
 785
 786   /* Buffer size is max number of digits which is the addition of:
 787    * - max_exponent10: max number of digits in fixed mode
 788    * - digits10 + 2: max number of significant digits
 789    * - trailing '\0'
 790    */
 791   char cvtbuf[limits::max_exponent10 + limits::digits10 + 2 + 1];
 792   char *bp;
 793   int decpt, sign;
 794
 795   switch (flags & ios_base::floatfield) {
 796   case ios_base::fixed:
 797     {
 798       /* Here, number of digits represents digits _after_ decimal point.
 799        * In order to limit static buffer size we have to give 2 different values depending on x value.
 800        * For small values (abs(x) < 1) we need as many digits as requested by precision limited by the maximum number of digits
 801        * which is min_exponent10 + digits10 + 2
 802        * For bigger values we won't have more than limits::digits10 + 2 digits after decimal point. */
 803       int digits10 = (x > -1.0 && x < 1.0 ? -limits::min_exponent10 + limits::digits10 + 2
 804                                           : limits::digits10 + 2);
 805       bp = _Stl_fcvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) );
 806     }
 807     break;
 808   case ios_base::scientific:
 809   default:
 810     /* Here, number of digits is total number of digits which is limited to digits10 + 2. */
 811     {
 812       int digits10 = limits::digits10 + 2;
 813       bp = _Stl_ecvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) );
 814     }
 815     break;
 816   }
 817   return __format_float(buf, bp, decpt, sign, x == 0.0, flags, precision);
 818 #endif
 819 }
 820
 821 size_t  _STLP_CALL
 822 __write_float(__iostring &buf, ios_base::fmtflags flags, int precision,
 823               double x) {
 824   return __write_floatT(buf, flags, precision, x
 825 #if defined (USE_SPRINTF_INSTEAD)
 826                                                , 0
 827 #endif
 828                                                   );
 829 }
 830
 831 #if !defined (_STLP_NO_LONG_DOUBLE)
 832 size_t _STLP_CALL
 833 __write_float(__iostring &buf, ios_base::fmtflags flags, int precision,
 834               long double x) {
 835   return __write_floatT(buf, flags, precision, x
 836 #if defined (USE_SPRINTF_INSTEAD)
 837                                                , 'L'
 838 #endif
 839                                                     );
 840 }
 841 #endif
 842
 843 void _STLP_CALL __get_floor_digits(__iostring &out, _STLP_LONGEST_FLOAT_TYPE __x) {
 844   typedef numeric_limits<_STLP_LONGEST_FLOAT_TYPE> limits;
 845 #if defined (USE_SPRINTF_INSTEAD)
 846   char cvtbuf[limits::max_exponent10 + 6];
 847 #  if !defined (_STLP_NO_LONG_DOUBLE)
 848   snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%Lf", __x); // check for 1234.56!
 849 #  else
 850   snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%f", __x);  // check for 1234.56!
 851 #  endif
 852   char *p = strchr( cvtbuf, '.' );
 853   if ( p == 0 ) {
 854     out.append( cvtbuf );
 855   } else {
 856     out.append( cvtbuf, p );
 857   }
 858 #else
 859   char cvtbuf[limits::max_exponent10 + 1];
 860   char * bp;
 861   int decpt, sign;
 862   bp = _Stl_fcvtR(__x, 0, &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf));
 863
 864   if (sign) {
 865     out += '-';
 866   }
 867   out.append(bp, bp + decpt);
 868 #endif
 869 }
 870
 871
 872 #if !defined (_STLP_NO_WCHAR_T)
 873 void _STLP_CALL __convert_float_buffer( __iostring const& str, __iowstring &out,
 874                                         const ctype<wchar_t>& ct, wchar_t dot, bool __check_dot) {
 875   string::const_iterator str_ite(str.begin()), str_end(str.end());
 876
 877   //First loop, check the dot char
 878   if (__check_dot) {
 879     while (str_ite != str_end) {
 880       if (*str_ite != '.') {
 881         out += ct.widen(*str_ite++);
 882       } else {
 883         out += dot;
 884         break;
 885       }
 886     }
 887   } else {
 888     if (str_ite != str_end) {
 889       out += ct.widen(*str_ite);
 890     }
 891   }
 892
 893   if (str_ite != str_end) {
 894     //Second loop, dot has been found, no check anymore
 895     while (++str_ite != str_end) {
 896       out += ct.widen(*str_ite);
 897     }
 898   }
 899 }
 900
 901 #endif
 902
 903 void _STLP_CALL
 904 __adjust_float_buffer(__iostring &str, char dot) {
 905   if ('.' != dot) {
 906     size_t __dot_pos = str.find('.');
 907     if (__dot_pos != string::npos) {
 908       str[__dot_pos] = dot;
 909     }
 910   }
 911 }
 912
 913 _STLP_MOVE_TO_STD_NAMESPACE
 914 _STLP_END_NAMESPACE
 915
 916 // Local Variables:
 917 // mode:C++
 918 // End: