111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (c) 1999 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Silicon Graphics Computer Systems, Inc. 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (c) 1999 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Boris Fomitchev 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * This material is provided "as is", with absolutely no warranty expressed 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * or implied. Any use is at your own risk. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to use or copy this software for any purpose is hereby granted 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * without fee, provided the above notices are retained on all copies. 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to modify the code and to distribute modified code is granted, 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * provided the above notices are retained, and a notice that the code was 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * modified is included with the above copyright notice. 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "stlport_prefix.h" 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <cmath> 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <ios> 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <locale> 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__DECCXX) 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define NDIG 400 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define NDIG 82 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define todigit(x) ((x)+'0') 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (_STLP_UNIX) 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__sun) 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <floatingpoint.h> 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__sun) || defined (__digital__) || defined (__sgi) || defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR) 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DEC, SGI & Solaris need this 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <values.h> 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <nan.h> 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__QNXNTO__) || ( defined(__GNUC__) && defined(__APPLE__) ) || defined(_STLP_USE_UCLIBC) /* 0.9.26 */ || \ 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined(__FreeBSD__) 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define USE_SPRINTF_INSTEAD 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_AIX) // JFA 3-Aug-2000 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <math.h> 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <float.h> 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <math.h> 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <cstdio> 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <cstdlib> 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__) || defined (__DJGPP) || \ 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR) 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <float.h> 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__MRC__) || defined (__SC__) || defined (_CRAY) //*TY 02/24/2000 - added support for MPW 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <fp.h> 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__CYGWIN__) 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <ieeefp.h> 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__MSL__) 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <cstdlib> // for atoi 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <cstdio> // for snprintf 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <algorithm> 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <cassert> 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__ISCPP__) 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <cfloat> 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <algorithm> 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__DMC__) 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define snprintf _snprintf 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_BEGIN_NAMESPACE 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_PRIV_NAMESPACE 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (__MWERKS__) || defined(__BEOS__) 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define USE_SPRINTF_INSTEAD 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <int N> 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Dig 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert enum { dig = _Dig<N/10>::dig + 1 }; 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_TEMPLATE_NULL 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Dig<0> 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert enum { dig = 0 }; 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _STLP_NO_LONG_DOUBLE 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define MAXEDIGITS int(_Dig<DBL_MAX_10_EXP>::dig) 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define MAXFSIG DBL_DIG 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define MAXFCVT (DBL_DIG + 1) 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define MAXEDIGITS int(_Dig<LDBL_MAX_10_EXP>::dig) 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define MAXFSIG LDBL_DIG 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define MAXFCVT (LDBL_DIG + 1) 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for infinity and NaN differ on different OSs. We encapsulate 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// these differences here. 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (USE_SPRINTF_INSTEAD) 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__hpux) && defined (__GNUC__) 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_USE_SIGN_HELPER 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__DJGPP) || (defined (_STLP_USE_GLIBC) && ! defined (__MSL__)) || \ 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (__CYGWIN__) || \ 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \ 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (__HP_aCC) 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(double x) 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (isfinite) 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return !isfinite(x); } 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return !finite(x); } 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(double x) { return isnan(x) && ( copysign(1., x) < 0 ); } 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { return isinf(x); } 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// inline bool _Stl_is_neg_inf(double x) { return isinf(x) < 0; } 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return isinf(x) && x < 0; } 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif (defined (__unix) || defined (__unix__)) && \ 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert !defined (__APPLE__) && !defined (__DJGPP) && !defined(__osf__) && \ 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert !defined (_CRAY) && !defined (__ANDROID__) 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(double x) { return IsNANorINF(x); } 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { return IsNANorINF(x) && IsINF(x); } 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return (IsINF(x)) && (x < 0.0); } 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(double x) { return IsNegNAN(x); } 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__) 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(double x) { return !_finite(x); } 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (__BORLANDC__) 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int fclass = _fpclass(x); 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return fclass == _FPCLASS_NINF || fclass == _FPCLASS_PINF; 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return _fpclass(x) == _FPCLASS_NINF; } 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { return _Stl_is_nan_or_inf(x) && !_isnan(x);} 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return _Stl_is_inf(x) && x < 0 ; } 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(double x) { return _isnan(x) && _copysign(1., x) < 0 ; } 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__BORLANDC__) 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(long double x) { return !_finitel(x); } 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(long double x) { return _Stl_is_nan_or_inf(x) && !_isnanl(x);} 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(long double x) { return _Stl_is_inf(x) && x < 0 ; } 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(long double x) { return _isnanl(x) && _copysignl(1.l, x) < 0 ; } 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif !defined (_STLP_NO_LONG_DOUBLE) 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Simply there to avoid warning long double -> double implicit conversion: 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(long double x) { return _Stl_is_nan_or_inf(__STATIC_CAST(double, x)); } 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(long double x) { return _Stl_is_inf(__STATIC_CAST(double, x));} 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(long double x) { return _Stl_is_neg_inf(__STATIC_CAST(double, x)); } 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(long double x) { return _Stl_is_neg_nan(__STATIC_CAST(double, x)); } 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__MRC__) || defined (__SC__) || defined (__DMC__) 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_nan_or_inf(double x) { return isnan(x) || !isfinite(x); } 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_inf(double x) { return !isfinite(x); } 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_neg_inf(double x) { return !isfinite(x) && signbit(x); } 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_neg_nan(double x) { return isnan(x) && signbit(x); } 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif /* defined(__FreeBSD__) || defined(__OpenBSD__) || */ (defined(__GNUC__) && defined(__APPLE__)) 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(double x) { return !finite(x); } 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { return _Stl_is_nan_or_inf(x) && ! isnan(x); } 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return _Stl_is_inf(x) && x < 0 ; } 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(double x) { return isnan(x) && copysign(1., x) < 0 ; } 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined( _AIX ) // JFA 11-Aug-2000 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_nan_or_inf(double x) { return isnan(x) || !finite(x); } 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_inf(double x) { return !finite(x); } 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// bool _Stl_is_neg_inf(double x) { return _class(x) == FP_MINUS_INF; } 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_neg_inf(double x) { return _Stl_is_inf(x) && ( copysign(1., x) < 0 ); } 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool _Stl_is_neg_nan(double x) { return isnan(x) && ( copysign(1., x) < 0 ); } 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__ISCPP__) 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf (double x) { return _fp_isINF(x) || _fp_isNAN(x); } 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf (double x) { return _fp_isINF(x); } 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf (double x) { return _fp_isINF(x) && x < 0; } 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan (double x) { return _fp_isNAN(x) && x < 0; } 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (_CRAY) 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_CRAYIEEE) 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(double x) { return isnan(x) || isinf(x); } 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { return isinf(x); } 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return isinf(x) && signbit(x); } 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(double x) { return isnan(x) && signbit(x); } 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_nan_or_inf(double x) { return false; } 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_inf(double x) { return false; } 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_inf(double x) { return false; } 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline bool _Stl_is_neg_nan(double x) { return false; } 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else // nothing from above 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define USE_SPRINTF_INSTEAD 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !USE_SPRINTF_INSTEAD 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (USE_SPRINTF_INSTEAD) 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Reentrant versions of floating-point conversion functions. The argument 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// lists look slightly different on different operating systems, so we're 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// encapsulating the differences here. 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__CYGWIN__) || defined(__DJGPP) 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvtbuf(x, n, pt, sign, buf); } 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvtbuf(x, n, pt, sign, buf); } 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__CYGWIN__) 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_EMULATE_LONG_DOUBLE_CVT 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvtbuf(x, n, pt, sign, buf); } 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvtbuf(x, n, pt, sign, buf); } 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (_STLP_USE_GLIBC) 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize) 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; } 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize) 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; } 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef _STLP_NO_LONG_DOUBLE 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize) 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return qecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; } 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize) 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return qfcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; } 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_NEED_CVT_BUFFER_SIZE 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__sun) 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return econvert(x, n, pt, sign, buf); } 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fconvert(x, n, pt, sign, buf); } 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef _STLP_NO_LONG_DOUBLE 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return qeconvert(&x, n, pt, sign, buf); } 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return qfconvert(&x, n, pt, sign, buf); } 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__DECCXX) 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize) 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return (ecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0); } 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize) 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return (fcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0); } 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef _STLP_NO_LONG_DOUBLE 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// fbp : no "long double" conversions ! 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize) 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return (ecvt_r((double)x, n, pt, sign, buf, bsize) == 0 ? buf : 0) ; } 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize) 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return (fcvt_r((double)x, n, pt, sign, buf, bsize) == 0 ? buf : 0); } 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_NEED_CVT_BUFFER_SIZE 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__hpux) 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign) 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvt(x, n, pt, sign); } 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign) 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvt(x, n, pt, sign); } 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign) 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _ldecvt(*(long_double*)&x, n, pt, sign); } 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign) 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _ldfcvt(*(long_double*)&x, n, pt, sign); } 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_CVT_NEED_SYNCHRONIZATION 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__unix) && !defined (__APPLE__) && !defined (_CRAY) && \ 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert !defined (__ANDROID__) 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvt_r(x, n, pt, sign, buf); } 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvt_r(x, n, pt, sign, buf); } 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return qecvt_r(x, n, pt, sign, buf); } 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return qfcvt_r(x, n, pt, sign, buf); } 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__) 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_STLP_USE_SAFE_STRING_FUNCTIONS) 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_APPEND(a, b) a##b 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_BUF_PARAMS , char* buf, size_t bsize 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_SECURE_FUN(F, X, N, PT, SIGN) _STLP_APPEND(F, _s)(buf, bsize, X, N, PT, SIGN); return buf 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_BUF_PARAMS 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_SECURE_FUN(F, X, N, PT, SIGN) return F(X, N, PT, SIGN) 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_CVT_NEED_SYNCHRONIZATION 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign _STLP_BUF_PARAMS) 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ _STLP_SECURE_FUN(_ecvt, x, n, pt, sign); } 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign _STLP_BUF_PARAMS) 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ _STLP_SECURE_FUN(_fcvt, x, n, pt, sign); } 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_STLP_USE_SAFE_STRING_FUNCTIONS) 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_PARAMS , buf, bsize 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_PARAMS 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign _STLP_BUF_PARAMS) 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _Stl_ecvtR(__STATIC_CAST(double, x), n, pt, sign _STLP_PARAMS); } 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign _STLP_BUF_PARAMS) 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _Stl_fcvtR(__STATIC_CAST(double, x), n, pt, sign _STLP_PARAMS); } 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef _STLP_PARAMS 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef _STLP_SECURE_FUN 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef _STLP_BUF_PARAMS 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef _STLP_APPEND 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__BORLANDC__) /* || defined (__GNUC__) MinGW do not support 'L' modifier so emulation do not work */ 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_EMULATE_LONG_DOUBLE_CVT 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (__ISCPP__) 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _fp_ecvt( x, n, pt, sign, buf); } 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _fp_fcvt(x, n, pt, sign, buf); } 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _fp_ecvt( x, n, pt, sign, buf); } 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _fp_fcvt(x, n, pt, sign, buf); } 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined (_AIX) || defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \ 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (__MRC__) || defined (__SC__) || defined (_CRAY) || \ 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR) || \ 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined (__DMC__) 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign) 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvt(x, n, pt, sign ); } 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign) 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvt(x, n, pt, sign); } 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign) 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return ecvt(x, n, pt, sign ); } 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign) 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return fcvt(x, n, pt, sign); } 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_CVT_NEED_SYNCHRONIZATION 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# error Missing _Stl_ecvtR and _Stl_fcvtR implementations. 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (_STLP_CVT_NEED_SYNCHRONIZATION) 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* STLport synchronize access to *cvt functions but those methods might 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * be called from outside, in this case we will still have a race condition. */ 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_STLP_THREADS) 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic _STLP_STATIC_MUTEX& put_float_mutex() { 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static _STLP_STATIC_MUTEX __put_float_mutex _STLP_MUTEX_INITIALIZER; 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __put_float_mutex; 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) { 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_auto_lock lock(put_float_mutex()); 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert strcpy(buf, _Stl_ecvtR(x, n, pt, sign)); return buf; 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) { 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_auto_lock lock(put_float_mutex()); 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert strcpy(buf, _Stl_fcvtR(x, n, pt, sign)); return buf; 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_EMULATE_LONG_DOUBLE_CVT) 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) { 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_auto_lock lock(put_float_mutex()); 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert strcpy(buf, _Stl_ecvtR(x, n, pt, sign)); return buf; 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) { 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_auto_lock lock(put_float_mutex()); 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert strcpy(buf, _Stl_fcvtR(x, n, pt, sign)); return buf; 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char*) 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _Stl_ecvtR(x, n, pt, sign); } 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char*) 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _Stl_fcvtR(x, n, pt, sign); } 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_EMULATE_LONG_DOUBLE_CVT) 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char*) 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _Stl_ecvtR(x, n, pt, sign); } 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char*) 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return _Stl_fcvtR(x, n, pt, sign); } 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS) && !defined (_STLP_NEED_CVT_BUFFER_SIZE) 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_CVT_BUFFER(B) B 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _STLP_CVT_BUFFER(B) _STLP_ARRAY_AND_SIZE(B) 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_STLP_EMULATE_LONG_DOUBLE_CVT) 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void __fill_fmtbuf(char* fmtbuf, ios_base::fmtflags flags, char long_modifier); 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Emulation of ecvt/fcvt functions using sprintf: 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) { 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If long double value can be safely converted to double without losing precision 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we use the ecvt function for double: 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double y = __STATIC_CAST(double, x); 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (x == y) 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _Stl_ecvtR(y, n, pt, sign, buf); 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char fmtbuf[32]; 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __fill_fmtbuf(fmtbuf, 0, 'L'); 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sprintf(buf, fmtbuf, n, x < 0.0l ? -x : x); 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* We are waiting for something having the form x.xxxe+yyyy */ 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *pt = 0; 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *sign = 0; 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int i = -1; 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int offset = 0; 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (buf[++i] != 0 && n != 0) { 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (buf[i] >= '0' && buf[i] <= '9') { 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert --n; 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (offset != 0) 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf[i - offset] = buf[i]; 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (offset != 0) break; 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++offset; 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *pt = i; 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (offset != 0) 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf[i - offset] = 0; 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Extract exponent part in point position: 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int e = 0; 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (buf[++i] != 0) { 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (buf[i] >= '0' && buf[i] <= '9') { 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert e = e * 10 + (buf[i] - '0'); 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *pt += e; 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return buf; 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) { 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If long double value can be safely converted to double without losing precision 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we use the fcvt function for double: 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double y = __STATIC_CAST(double, x); 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (x == y) 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _Stl_fcvtR(y, n, pt, sign, buf); 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char fmtbuf[32]; 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __fill_fmtbuf(fmtbuf, ios_base::fixed, 'L'); 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sprintf(buf, fmtbuf, n, x < 0.0l ? -x : x); 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *pt = 0; 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *sign = 0; 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int i = -1; 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int offset = 0; 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (buf[++i] != 0 && (offset == 0 || n != 0)) { 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (buf[i] >= '0' && buf[i] <= '9') { 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (offset != 0) { 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert --n; 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf[i - offset] = buf[i]; 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++offset; 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *pt = i; 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (offset != 0) 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf[i - offset] = 0; 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *pt = i; 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return buf; 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// num_put 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __format_float formats a mantissa and exponent as returned by 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// one of the conversion functions (ecvt_r, fcvt_r, qecvt_r, qfcvt_r) 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// according to the specified precision and format flags. This is 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// based on doprnt but is much simpler since it is concerned only 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// with floating point input and does not consider all formats. It 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// also does not deal with blank padding, which is handled by 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __copy_float_and_fill. 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic size_t __format_float_scientific( __iostring& buf, const char *bp, 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int decpt, int sign, bool is_zero, 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::fmtflags flags, 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int precision) { 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // sign if required 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (sign) 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '-'; 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (flags & ios_base::showpos) 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '+'; 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // first digit of mantissa 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += *bp++; 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // start of grouping position, grouping won't occur in scientific notation 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // as it is impossible to have something like 1234.0e04 but we return a correct 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // group position for coherency with __format_float_fixed. 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __group_pos = buf.size(); 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // decimal point if required 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (precision != 0 || flags & ios_base::showpoint) { 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '.'; 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // rest of mantissa 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (*bp != 0 && precision--) 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += *bp++; 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // trailing 0 if needed 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (precision > 0) 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf.append(precision, '0'); 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // exponent size = number of digits + exponent sign + exponent symbol + trailing zero 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char expbuf[MAXEDIGITS + 3]; 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //We start filling at the buffer end 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char *suffix = expbuf + MAXEDIGITS + 2; 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *suffix = 0; 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!is_zero) { 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int nn = decpt - 1; 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (nn < 0) 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert nn = -nn; 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (; nn > 9; nn /= 10) 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *--suffix = (char) todigit(nn % 10); 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *--suffix = (char) todigit(nn); 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // prepend leading zeros to exponent 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C89 Standard says that it should be at least 2 digits, C99 Standard says that 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we stop prepend zeros if more than 3 digits. To repect both STLport prepend zeros 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // until it is 2 digits. 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (suffix > &expbuf[MAXEDIGITS]) 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *--suffix = '0'; 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // put in the exponent sign 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *--suffix = (char) ((decpt > 0 || is_zero ) ? '+' : '-'); 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // put in the e 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *--suffix = flags & ios_base::uppercase ? 'E' : 'e'; 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // copy the suffix 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += suffix; 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __group_pos; 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic size_t __format_float_fixed( __iostring &buf, const char *bp, 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int decpt, int sign, 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::fmtflags flags, 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int precision) { 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ( sign && (decpt > -precision) && (*bp != 0) ) 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '-'; 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if ( flags & ios_base::showpos ) 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '+'; 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // digits before decimal point 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int nnn = decpt; 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do { 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += (nnn <= 0 || *bp == 0) ? '0' : *bp++; 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } while ( --nnn > 0 ); 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // start of grouping position 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __group_pos = buf.size(); 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // decimal point if needed 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ( flags & ios_base::showpoint || precision > 0 ) { 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '.'; 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // digits after decimal point if any 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while ( *bp != 0 && --precision >= 0 ) { 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += (++decpt <= 0) ? '0' : *bp++; 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // trailing zeros if needed 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (precision > 0) 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf.append(precision, '0'); 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __group_pos; 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (_STLP_USE_SIGN_HELPER) 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate<class _FloatT> 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct float_sign_helper { 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert float_sign_helper(_FloatT __x) 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { _M_number._num = __x; } 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_negative() const { 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const unsigned short sign_mask(1 << (sizeof(unsigned short) * CHAR_BIT - 1)); 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (get_sign_word() & sign_mask) != 0; 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert union { 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned short _Words[8]; 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _FloatT _num; 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } _M_number; 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned short get_word_higher() const _STLP_NOTHROW 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { return _M_number._Words[0]; } 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned short get_word_lower() const _STLP_NOTHROW 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { return _M_number._Words[(sizeof(_FloatT) >= 12 ? 10 : sizeof(_FloatT)) / sizeof(unsigned short) - 1]; } 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned short get_sign_word() const _STLP_NOTHROW 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (_STLP_BIG_ENDIAN) 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { return get_word_higher(); } 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else /* _STLP_LITTLE_ENDIAN */ 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { return get_word_lower(); } 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _FloatT> 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic size_t __format_nan_or_inf(__iostring& buf, _FloatT x, ios_base::fmtflags flags) { 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* inf[2] = { "inf", "Inf" }; 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* nan[2] = { "nan", "NaN" }; 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char** inf_or_nan; 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (_STLP_USE_SIGN_HELPER) 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_Stl_is_inf(x)) { // Infinity 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert inf_or_nan = inf; 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_Stl_is_neg_inf(x)) 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '-'; 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (flags & ios_base::showpos) 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '+'; 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { // NaN 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert inf_or_nan = nan; 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_Stl_is_neg_nan(x)) 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '-'; 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (flags & ios_base::showpos) 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '+'; 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef numeric_limits<_FloatT> limits; 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (x == limits::infinity() || x == -limits::infinity()) { 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert inf_or_nan = inf; 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { // NaN 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert inf_or_nan = nan; 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert float_sign_helper<_FloatT> helper(x); 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (helper.is_negative()) 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '-'; 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (flags & ios_base::showpos) 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += '+'; 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t ret = buf.size(); 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf += inf_or_nan[flags & ios_base::uppercase ? 1 : 0]; 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return ret; 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic inline size_t __format_float(__iostring &buf, const char * bp, 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int decpt, int sign, bool is_zero, 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::fmtflags flags, 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int precision) { 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __group_pos = 0; 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (flags & ios_base::floatfield) { 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case ios_base::scientific: 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __group_pos = __format_float_scientific( buf, bp, decpt, sign, is_zero, 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags, precision); 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case ios_base::fixed: 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __group_pos = __format_float_fixed( buf, bp, decpt, sign, 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags, precision); 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: // g format 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // establish default precision 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (flags & ios_base::showpoint || precision > 0) { 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (precision == 0) precision = 1; 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert precision = 6; 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // reset exponent if value is zero 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (is_zero) 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert decpt = 1; 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int kk = precision; 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!(flags & ios_base::showpoint)) { 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t n = strlen(bp); 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (n < (size_t)kk) 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kk = (int)n; 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (kk >= 1 && bp[kk-1] == '0') 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert --kk; 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (decpt < -3 || decpt > precision) { 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert precision = kk - 1; 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __group_pos = __format_float_scientific( buf, bp, decpt, sign, is_zero, 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags, precision); 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert precision = kk - decpt; 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __group_pos = __format_float_fixed( buf, bp, decpt, sign, 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags, precision); 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } /* switch */ 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __group_pos; 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (USE_SPRINTF_INSTEAD) || defined (_STLP_EMULATE_LONG_DOUBLE_CVT) 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct GroupPos { 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator () (char __c) const { 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __c == '.' || 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __c == 'e' || __c == 'E'; 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Creates a format string for sprintf() 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void __fill_fmtbuf(char* fmtbuf, ios_base::fmtflags flags, char long_modifier) { 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[0] = '%'; 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int i = 1; 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (flags & ios_base::showpos) 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = '+'; 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (flags & ios_base::showpoint) 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = '#'; 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = '.'; 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = '*'; 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (long_modifier) 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = long_modifier; 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (flags & ios_base::floatfield) 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case ios_base::scientific: 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = (flags & ios_base::uppercase) ? 'E' : 'e'; 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case ios_base::fixed: 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__FreeBSD__) 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = 'f'; 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = (flags & ios_base::uppercase) ? 'F' : 'f'; 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i++] = (flags & ios_base::uppercase) ? 'G' : 'g'; 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fmtbuf[i] = 0; 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* USE_SPRINTF_INSTEAD */ 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _FloatT> 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic size_t __write_floatT(__iostring &buf, ios_base::fmtflags flags, int precision, 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _FloatT x 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (USE_SPRINTF_INSTEAD) 75211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert , char modifier) { 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* In theory, if we want 'arbitrary' precision, we should use 'arbitrary' 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * buffer size below, but really we limited by exponent part in double. 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * - ptr 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef numeric_limits<_FloatT> limits; 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char static_buf[limits::max_exponent10 + 6]; // 6: -xxx.yyyE-zzz (sign, dot, E, exp sign, \0) 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char fmtbuf[32]; 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __fill_fmtbuf(fmtbuf, flags, modifier); 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert snprintf(_STLP_ARRAY_AND_SIZE(static_buf), fmtbuf, precision, x); 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert buf = static_buf; 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return find_if(buf.begin(), buf.end(), GroupPos()) - buf.begin(); 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ) { 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef numeric_limits<_FloatT> limits; 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //If numeric_limits support is correct we use the exposed values to detect NaN and infinity: 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (limits::has_infinity && limits::has_quiet_NaN) { 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!(x == x) || // NaN check 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (x == limits::infinity() || x == -limits::infinity())) { 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __format_nan_or_inf(buf, x, flags); 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 77311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // numeric_limits support is not good enough, we rely on platform dependent function 77511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // _Stl_is_nan_or_inf that do not support long double. 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (_Stl_is_nan_or_inf(x)) { 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __format_nan_or_inf(buf, x, flags); 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined (__MINGW32__) 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //For the moment MinGW is limited to display at most numeric_limits<double>::max() 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (x > numeric_limits<double>::max() || 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert x < -numeric_limits<double>::max()) { 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __format_nan_or_inf(buf, x, flags); 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 78611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* Buffer size is max number of digits which is the addition of: 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * - max_exponent10: max number of digits in fixed mode 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * - digits10 + 2: max number of significant digits 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * - trailing '\0' 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char cvtbuf[limits::max_exponent10 + limits::digits10 + 2 + 1]; 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char *bp; 79411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int decpt, sign; 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (flags & ios_base::floatfield) { 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case ios_base::fixed: 79811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* Here, number of digits represents digits _after_ decimal point. 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * In order to limit static buffer size we have to give 2 different values depending on x value. 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * For small values (abs(x) < 1) we need as many digits as requested by precision limited by the maximum number of digits 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * which is min_exponent10 + digits10 + 2 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * For bigger values we won't have more than limits::digits10 + 2 digits after decimal point. */ 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int digits10 = (x > -1.0 && x < 1.0 ? -limits::min_exponent10 + limits::digits10 + 2 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : limits::digits10 + 2); 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bp = _Stl_fcvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) ); 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 80911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case ios_base::scientific: 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert /* Here, number of digits is total number of digits which is limited to digits10 + 2. */ 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 81311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int digits10 = limits::digits10 + 2; 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bp = _Stl_ecvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) ); 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __format_float(buf, bp, decpt, sign, x == 0.0, flags, precision); 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertsize_t _STLP_CALL 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__write_float(__iostring &buf, ios_base::fmtflags flags, int precision, 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double x) { 82511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __write_floatT(buf, flags, precision, x 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (USE_SPRINTF_INSTEAD) 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert , 0 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ); 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (_STLP_NO_LONG_DOUBLE) 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertsize_t _STLP_CALL 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__write_float(__iostring &buf, ios_base::fmtflags flags, int precision, 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long double x) { 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __write_floatT(buf, flags, precision, x 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (USE_SPRINTF_INSTEAD) 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert , 'L' 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ); 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid _STLP_CALL __get_floor_digits(__iostring &out, _STLP_LONGEST_FLOAT_TYPE __x) { 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef numeric_limits<_STLP_LONGEST_FLOAT_TYPE> limits; 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (USE_SPRINTF_INSTEAD) 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char cvtbuf[limits::max_exponent10 + 6]; 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_NO_LONG_DOUBLE) 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%Lf", __x); // check for 1234.56! 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%f", __x); // check for 1234.56! 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char *p = strchr( cvtbuf, '.' ); 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ( p == 0 ) { 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out.append( cvtbuf ); 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out.append( cvtbuf, p ); 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char cvtbuf[limits::max_exponent10 + 1]; 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char * bp; 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int decpt, sign; 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bp = _Stl_fcvtR(__x, 0, &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf)); 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (sign) { 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out += '-'; 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out.append(bp, bp + decpt); 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (_STLP_NO_WCHAR_T) 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid _STLP_CALL __convert_float_buffer( __iostring const& str, __iowstring &out, 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ctype<wchar_t>& ct, wchar_t dot, bool __check_dot) { 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert string::const_iterator str_ite(str.begin()), str_end(str.end()); 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //First loop, check the dot char 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__check_dot) { 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (str_ite != str_end) { 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (*str_ite != '.') { 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out += ct.widen(*str_ite++); 88311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out += dot; 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (str_ite != str_end) { 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out += ct.widen(*str_ite); 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (str_ite != str_end) { 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //Second loop, dot has been found, no check anymore 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (++str_ite != str_end) { 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert out += ct.widen(*str_ite); 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid _STLP_CALL 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__adjust_float_buffer(__iostring &str, char dot) { 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ('.' != dot) { 90711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __dot_pos = str.find('.'); 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__dot_pos != string::npos) { 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert str[__dot_pos] = dot; 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_STD_NAMESPACE 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_END_NAMESPACE 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Local Variables: 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mode:C++ 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// End: 920