sl@0: /**************************************************************** sl@0: sl@0: The author of this software is David M. Gay. sl@0: sl@0: Copyright (C) 1998-2000 by Lucent Technologies sl@0: All Rights Reserved sl@0: sl@0: Permission to use, copy, modify, and distribute this software and sl@0: its documentation for any purpose and without fee is hereby sl@0: granted, provided that the above copyright notice appear in all sl@0: copies and that both that the copyright notice and this sl@0: permission notice and warranty disclaimer appear in supporting sl@0: documentation, and that the name of Lucent or any of its entities sl@0: not be used in advertising or publicity pertaining to sl@0: distribution of the software without specific, written prior sl@0: permission. sl@0: sl@0: LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, sl@0: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. sl@0: IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY sl@0: SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES sl@0: WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER sl@0: IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, sl@0: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF sl@0: THIS SOFTWARE. sl@0: sl@0: ****************************************************************/ sl@0: sl@0: /* $FreeBSD: src/contrib/gdtoa/gdtoaimp.h,v 1.7 2005/01/18 18:56:18 das Exp $ */ sl@0: sl@0: /* This is a variation on dtoa.c that converts arbitary binary sl@0: floating-point formats to and from decimal notation. It uses sl@0: double-precision arithmetic internally, so there are still sl@0: various #ifdefs that adapt the calculations to the native sl@0: double-precision arithmetic (any of IEEE, VAX D_floating, sl@0: or IBM mainframe arithmetic). sl@0: sl@0: Please send bug reports to sl@0: David M. Gay sl@0: Bell Laboratories, Room 2C-463 sl@0: 600 Mountain Avenue sl@0: Murray Hill, NJ 07974-0636 sl@0: U.S.A. sl@0: dmg@bell-labs.com sl@0: */ sl@0: sl@0: /* On a machine with IEEE extended-precision registers, it is sl@0: * necessary to specify double-precision (53-bit) rounding precision sl@0: * before invoking strtod or dtoa. If the machine uses (the equivalent sl@0: * of) Intel 80x87 arithmetic, the call sl@0: * _control87(PC_53, MCW_PC); sl@0: * does this with many compilers. Whether this or another call is sl@0: * appropriate depends on the compiler; for this to work, it may be sl@0: * necessary to #include "float.h" or another system-dependent header sl@0: * file. sl@0: */ sl@0: sl@0: /* strtod for IEEE-, VAX-, and IBM-arithmetic machines. sl@0: * sl@0: * This strtod returns a nearest machine number to the input decimal sl@0: * string (or sets errno to ERANGE). With IEEE arithmetic, ties are sl@0: * broken by the IEEE round-even rule. Otherwise ties are broken by sl@0: * biased rounding (add half and chop). sl@0: * sl@0: * Inspired loosely by William D. Clinger's paper "How to Read Floating sl@0: * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101]. sl@0: * sl@0: * Modifications: sl@0: * sl@0: * 1. We only require IEEE, IBM, or VAX double-precision sl@0: * arithmetic (not IEEE double-extended). sl@0: * 2. We get by with floating-point arithmetic in a case that sl@0: * Clinger missed -- when we're computing d * 10^n sl@0: * for a small integer d and the integer n is not too sl@0: * much larger than 22 (the maximum integer k for which sl@0: * we can represent 10^k exactly), we may be able to sl@0: * compute (d*10^k) * 10^(e-k) with just one roundoff. sl@0: * 3. Rather than a bit-at-a-time adjustment of the binary sl@0: * result in the hard case, we use floating-point sl@0: * arithmetic to determine the adjustment to within sl@0: * one bit; only in really hard cases do we need to sl@0: * compute a second residual. sl@0: * 4. Because of 3., we don't need a large table of powers of 10 sl@0: * for ten-to-e (just some small tables, e.g. of 10^k sl@0: * for 0 <= k <= 22). sl@0: */ sl@0: sl@0: /* sl@0: * #define IEEE_8087 for IEEE-arithmetic machines where the least sl@0: * significant byte has the lowest address. sl@0: * #define IEEE_MC68k for IEEE-arithmetic machines where the most sl@0: * significant byte has the lowest address. sl@0: * #define Long int on machines with 32-bit ints and 64-bit longs. sl@0: * #define Sudden_Underflow for IEEE-format machines without gradual sl@0: * underflow (i.e., that flush to zero on underflow). sl@0: * #define IBM for IBM mainframe-style floating-point arithmetic. sl@0: * #define VAX for VAX-style floating-point arithmetic (D_floating). sl@0: * #define No_leftright to omit left-right logic in fast floating-point sl@0: * computation of dtoa. sl@0: * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3. sl@0: * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines sl@0: * that use extended-precision instructions to compute rounded sl@0: * products and quotients) with IBM. sl@0: * #define ROUND_BIASED for IEEE-format with biased rounding. sl@0: * #define Inaccurate_Divide for IEEE-format with correctly rounded sl@0: * products but inaccurate quotients, e.g., for Intel i860. sl@0: * #define NO_LONG_LONG on machines that do not have a "long long" sl@0: * integer type (of >= 64 bits). On such machines, you can sl@0: * #define Just_16 to store 16 bits per 32-bit Long when doing sl@0: * high-precision integer arithmetic. Whether this speeds things sl@0: * up or slows things down depends on the machine and the number sl@0: * being converted. If long long is available and the name is sl@0: * something other than "long long", #define Llong to be the name, sl@0: * and if "unsigned Llong" does not work as an unsigned version of sl@0: * Llong, #define #ULLong to be the corresponding unsigned type. sl@0: * #define KR_headers for old-style C function headers. sl@0: * #define Bad_float_h if your system lacks a float.h or if it does not sl@0: * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP, sl@0: * FLT_RADIX, FLT_ROUNDS, and DBL_MAX. sl@0: * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n) sl@0: * if memory is available and otherwise does something you deem sl@0: * appropriate. If MALLOC is undefined, malloc will be invoked sl@0: * directly -- and assumed always to succeed. sl@0: * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making sl@0: * memory allocations from a private pool of memory when possible. sl@0: * When used, the private pool is PRIVATE_MEM bytes long: 2304 bytes, sl@0: * unless #defined to be a different length. This default length sl@0: * suffices to get rid of MALLOC calls except for unusual cases, sl@0: * such as decimal-to-binary conversion of a very long string of sl@0: * digits. When converting IEEE double precision values, the sl@0: * longest string gdtoa can return is about 751 bytes long. For sl@0: * conversions by strtod of strings of 800 digits and all gdtoa sl@0: * conversions of IEEE doubles in single-threaded executions with sl@0: * 8-byte pointers, PRIVATE_MEM >= 7400 appears to suffice; with sl@0: * 4-byte pointers, PRIVATE_MEM >= 7112 appears adequate. sl@0: * #define INFNAN_CHECK on IEEE systems to cause strtod to check for sl@0: * Infinity and NaN (case insensitively). On some systems (e.g., sl@0: * some HP systems), it may be necessary to #define NAN_WORD0 sl@0: * appropriately -- to the most significant word of a quiet NaN. sl@0: * (On HP Series 700/800 machines, -DNAN_WORD0=0x7ff40000 works.) sl@0: * When INFNAN_CHECK is #defined and No_Hex_NaN is not #defined, sl@0: * strtodg also accepts (case insensitively) strings of the form sl@0: * NaN(x), where x is a string of hexadecimal digits and spaces; sl@0: * if there is only one string of hexadecimal digits, it is taken sl@0: * for the fraction bits of the resulting NaN; if there are two or sl@0: * more strings of hexadecimal digits, each string is assigned sl@0: * to the next available sequence of 32-bit words of fractions sl@0: * bits (starting with the most significant), right-aligned in sl@0: * each sequence. sl@0: * #define MULTIPLE_THREADS if the system offers preemptively scheduled sl@0: * multiple threads. In this case, you must provide (or suitably sl@0: * #define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed sl@0: * by FREE_DTOA_LOCK(n) for n = 0 or 1. (The second lock, accessed sl@0: * in pow5mult, ensures lazy evaluation of only one copy of high sl@0: * powers of 5; omitting this lock would introduce a small sl@0: * probability of wasting memory, but would otherwise be harmless.) sl@0: * You must also invoke freedtoa(s) to free the value s returned by sl@0: * dtoa. You may do so whether or not MULTIPLE_THREADS is #defined. sl@0: * #define IMPRECISE_INEXACT if you do not care about the setting of sl@0: * the STRTOG_Inexact bits in the special case of doing IEEE double sl@0: * precision conversions (which could also be done by the strtog in sl@0: * dtoa.c). sl@0: * #define NO_HEX_FP to disable recognition of C9x's hexadecimal sl@0: * floating-point constants. sl@0: * #define -DNO_ERRNO to suppress setting errno (in strtod.c and sl@0: * strtodg.c). sl@0: * #define NO_STRING_H to use private versions of memcpy. sl@0: * On some K&R systems, it may also be necessary to sl@0: * #define DECLARE_SIZE_T in this case. sl@0: * #define YES_ALIAS to permit aliasing certain double values with sl@0: * arrays of ULongs. This leads to slightly better code with sl@0: * some compilers and was always used prior to 19990916, but it sl@0: * is not strictly legal and can cause trouble with aggressively sl@0: * optimizing compilers (e.g., gcc 2.95.1 under -O2). sl@0: * #define USE_LOCALE to use the current locale's decimal_point value. sl@0: */ sl@0: sl@0: #ifndef GDTOAIMP_H_INCLUDED sl@0: #define GDTOAIMP_H_INCLUDED sl@0: #include "gdtoa.h" sl@0: sl@0: #ifdef DEBUG sl@0: #include "stdio.h" sl@0: #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);} sl@0: #endif sl@0: sl@0: #include "limits.h" sl@0: #include "stdlib.h" sl@0: #include "string.h" sl@0: #include "libc_private.h" sl@0: sl@0: #include "namespace.h" sl@0: #include sl@0: #include "un-namespace.h" sl@0: sl@0: #ifdef __SYMBIAN32__ sl@0: #ifdef __WINSCW__ sl@0: #pragma warn_unusedarg off sl@0: #pragma warn_possunwant off sl@0: #endif//__WINSCW__ sl@0: #endif//__SYMBIAN32__ sl@0: sl@0: #ifdef KR_headers sl@0: #define Char char sl@0: #else sl@0: #define Char void sl@0: #endif sl@0: sl@0: #ifdef MALLOC sl@0: extern Char *MALLOC ANSI((size_t)); sl@0: #else sl@0: #define MALLOC malloc sl@0: #endif sl@0: sl@0: #define INFNAN_CHECK sl@0: #define USE_LOCALE sl@0: #define Honor_FLT_ROUNDS sl@0: sl@0: #undef IEEE_Arith sl@0: #undef Avoid_Underflow sl@0: #ifdef IEEE_MC68k sl@0: #define IEEE_Arith sl@0: #endif sl@0: #ifdef IEEE_8087 sl@0: #define IEEE_Arith sl@0: #endif sl@0: sl@0: #include "errno.h" sl@0: #ifdef Bad_float_h sl@0: sl@0: #ifdef IEEE_Arith sl@0: #define DBL_DIG 15 sl@0: #define DBL_MAX_10_EXP 308 sl@0: #define DBL_MAX_EXP 1024 sl@0: #define FLT_RADIX 2 sl@0: #define DBL_MAX 1.7976931348623157e+308 sl@0: #endif sl@0: sl@0: #ifdef IBM sl@0: #define DBL_DIG 16 sl@0: #define DBL_MAX_10_EXP 75 sl@0: #define DBL_MAX_EXP 63 sl@0: #define FLT_RADIX 16 sl@0: #define DBL_MAX 7.2370055773322621e+75 sl@0: #endif sl@0: sl@0: #ifdef VAX sl@0: #define DBL_DIG 16 sl@0: #define DBL_MAX_10_EXP 38 sl@0: #define DBL_MAX_EXP 127 sl@0: #define FLT_RADIX 2 sl@0: #define DBL_MAX 1.7014118346046923e+38 sl@0: #define n_bigtens 2 sl@0: #endif sl@0: sl@0: #ifndef LONG_MAX sl@0: #define LONG_MAX 2147483647 sl@0: #endif sl@0: sl@0: #else /* ifndef Bad_float_h */ sl@0: #include "float.h" sl@0: #endif /* Bad_float_h */ sl@0: sl@0: #ifdef IEEE_Arith sl@0: #define Scale_Bit 0x10 sl@0: #define n_bigtens 5 sl@0: #endif sl@0: sl@0: #ifdef IBM sl@0: #define n_bigtens 3 sl@0: #endif sl@0: sl@0: #ifdef VAX sl@0: #define n_bigtens 2 sl@0: #endif sl@0: sl@0: #ifndef __MATH_H__ sl@0: #include "math.h" sl@0: #endif sl@0: sl@0: #ifdef __cplusplus sl@0: extern "C" { sl@0: #endif sl@0: sl@0: #if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1 sl@0: //Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined. sl@0: #endif sl@0: sl@0: typedef union { double d; ULong L[2]; } U; sl@0: sl@0: #ifdef YES_ALIAS sl@0: #define dval(x) x sl@0: #ifdef IEEE_8087 sl@0: #define word0(x) ((ULong *)&x)[1] sl@0: #define word1(x) ((ULong *)&x)[0] sl@0: #else sl@0: #define word0(x) ((ULong *)&x)[0] sl@0: #define word1(x) ((ULong *)&x)[1] sl@0: #endif sl@0: #else /* !YES_ALIAS */ sl@0: #ifdef IEEE_8087 sl@0: #define word0(x) ((U*)&x)->L[1] sl@0: #define word1(x) ((U*)&x)->L[0] sl@0: #else sl@0: #define word0(x) ((U*)&x)->L[0] sl@0: #define word1(x) ((U*)&x)->L[1] sl@0: #endif sl@0: #define dval(x) ((U*)&x)->d sl@0: #endif /* YES_ALIAS */ sl@0: sl@0: /* The following definition of Storeinc is appropriate for MIPS processors. sl@0: * An alternative that might be better on some machines is sl@0: * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff) sl@0: */ sl@0: #if defined(IEEE_8087) + defined(VAX) sl@0: #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \ sl@0: ((unsigned short *)a)[0] = (unsigned short)c, a++) sl@0: #else sl@0: #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \ sl@0: ((unsigned short *)a)[1] = (unsigned short)c, a++) sl@0: #endif sl@0: sl@0: /* #define P DBL_MANT_DIG */ sl@0: /* Ten_pmax = floor(P*log(2)/log(5)) */ sl@0: /* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */ sl@0: /* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */ sl@0: /* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */ sl@0: sl@0: #ifdef IEEE_Arith sl@0: #define Exp_shift 20 sl@0: #define Exp_shift1 20 sl@0: #define Exp_msk1 0x100000 sl@0: #define Exp_msk11 0x100000 sl@0: #define Exp_mask 0x7ff00000 sl@0: #define P 53 sl@0: #define Bias 1023 sl@0: #define Emin (-1022) sl@0: #define Exp_1 0x3ff00000 sl@0: #define Exp_11 0x3ff00000 sl@0: #define Ebits 11 sl@0: #define Frac_mask 0xfffff sl@0: #define Frac_mask1 0xfffff sl@0: #define Ten_pmax 22 sl@0: #define Bletch 0x10 sl@0: #define Bndry_mask 0xfffff sl@0: #define Bndry_mask1 0xfffff sl@0: #define LSB 1 sl@0: #define Sign_bit 0x80000000 sl@0: #define Log2P 1 sl@0: #define Tiny0 0 sl@0: #define Tiny1 1 sl@0: #define Quick_max 14 sl@0: #define Int_max 14 sl@0: sl@0: #ifndef Flt_Rounds sl@0: #ifdef FLT_ROUNDS sl@0: #define Flt_Rounds FLT_ROUNDS sl@0: #else sl@0: #define Flt_Rounds 1 sl@0: #endif sl@0: #endif /*Flt_Rounds*/ sl@0: sl@0: #else /* ifndef IEEE_Arith */ sl@0: #undef Sudden_Underflow sl@0: #define Sudden_Underflow sl@0: #ifdef IBM sl@0: #undef Flt_Rounds sl@0: #define Flt_Rounds 0 sl@0: #define Exp_shift 24 sl@0: #define Exp_shift1 24 sl@0: #define Exp_msk1 0x1000000 sl@0: #define Exp_msk11 0x1000000 sl@0: #define Exp_mask 0x7f000000 sl@0: #define P 14 sl@0: #define Bias 65 sl@0: #define Exp_1 0x41000000 sl@0: #define Exp_11 0x41000000 sl@0: #define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */ sl@0: #define Frac_mask 0xffffff sl@0: #define Frac_mask1 0xffffff sl@0: #define Bletch 4 sl@0: #define Ten_pmax 22 sl@0: #define Bndry_mask 0xefffff sl@0: #define Bndry_mask1 0xffffff sl@0: #define LSB 1 sl@0: #define Sign_bit 0x80000000 sl@0: #define Log2P 4 sl@0: #define Tiny0 0x100000 sl@0: #define Tiny1 0 sl@0: #define Quick_max 14 sl@0: #define Int_max 15 sl@0: #else /* VAX */ sl@0: #undef Flt_Rounds sl@0: #define Flt_Rounds 1 sl@0: #define Exp_shift 23 sl@0: #define Exp_shift1 7 sl@0: #define Exp_msk1 0x80 sl@0: #define Exp_msk11 0x800000 sl@0: #define Exp_mask 0x7f80 sl@0: #define P 56 sl@0: #define Bias 129 sl@0: #define Exp_1 0x40800000 sl@0: #define Exp_11 0x4080 sl@0: #define Ebits 8 sl@0: #define Frac_mask 0x7fffff sl@0: #define Frac_mask1 0xffff007f sl@0: #define Ten_pmax 24 sl@0: #define Bletch 2 sl@0: #define Bndry_mask 0xffff007f sl@0: #define Bndry_mask1 0xffff007f sl@0: #define LSB 0x10000 sl@0: #define Sign_bit 0x8000 sl@0: #define Log2P 1 sl@0: #define Tiny0 0x80 sl@0: #define Tiny1 0 sl@0: #define Quick_max 15 sl@0: #define Int_max 15 sl@0: #endif /* IBM, VAX */ sl@0: #endif /* IEEE_Arith */ sl@0: sl@0: #ifndef IEEE_Arith sl@0: #define ROUND_BIASED sl@0: #endif sl@0: sl@0: #ifdef RND_PRODQUOT sl@0: #define rounded_product(a,b) a = rnd_prod(a, b) sl@0: #define rounded_quotient(a,b) a = rnd_quot(a, b) sl@0: #ifdef KR_headers sl@0: extern double rnd_prod(), rnd_quot(); sl@0: #else sl@0: extern double rnd_prod(double, double), rnd_quot(double, double); sl@0: #endif sl@0: #else sl@0: #define rounded_product(a,b) a *= b sl@0: #define rounded_quotient(a,b) a /= b sl@0: #endif sl@0: sl@0: #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) sl@0: #define Big1 0xffffffff sl@0: sl@0: #undef Pack_16 sl@0: #ifndef Pack_32 sl@0: #define Pack_32 sl@0: #endif sl@0: sl@0: #ifdef NO_LONG_LONG sl@0: #undef ULLong sl@0: #ifdef Just_16 sl@0: #undef Pack_32 sl@0: #define Pack_16 sl@0: /* When Pack_32 is not defined, we store 16 bits per 32-bit Long. sl@0: * This makes some inner loops simpler and sometimes saves work sl@0: * during multiplications, but it often seems to make things slightly sl@0: * slower. Hence the default is now to store 32 bits per Long. sl@0: */ sl@0: #endif sl@0: #else /* long long available */ sl@0: #ifndef Llong sl@0: #define Llong long long sl@0: #endif sl@0: #ifndef ULLong sl@0: #define ULLong unsigned Llong sl@0: #endif sl@0: #endif /* NO_LONG_LONG */ sl@0: sl@0: #ifdef Pack_32 sl@0: #define ULbits 32 sl@0: #define kshift 5 sl@0: #define kmask 31 sl@0: #define ALL_ON 0xffffffff sl@0: #else sl@0: #define ULbits 16 sl@0: #define kshift 4 sl@0: #define kmask 15 sl@0: #define ALL_ON 0xffff sl@0: #endif sl@0: sl@0: #define MULTIPLE_THREADS sl@0: sl@0: #ifndef EMULATOR sl@0: extern pthread_mutex_t __gdtoa_locks[2]; sl@0: #else sl@0: #define __gdtoa_locks (RETURN_WSD_VAR(__gdtoa_locks, g)) sl@0: #endif sl@0: sl@0: #define ACQUIRE_DTOA_LOCK(n) do { \ sl@0: if (__isthreaded) \ sl@0: _pthread_mutex_lock(&__gdtoa_locks[n]); \ sl@0: }while(0) sl@0: #define FREE_DTOA_LOCK(n) do { \ sl@0: if (__isthreaded) \ sl@0: _pthread_mutex_unlock(&__gdtoa_locks[n]); \ sl@0: } while(0) sl@0: sl@0: #ifndef __SYMBIAN32__ sl@0: #define Kmax 15 sl@0: sl@0: struct sl@0: Bigint { sl@0: struct Bigint *next; sl@0: int k, maxwds, sign, wds; sl@0: ULong x[1]; sl@0: }; sl@0: sl@0: typedef struct Bigint Bigint; sl@0: sl@0: #endif sl@0: sl@0: #include "gdtoatypes.h" sl@0: sl@0: #ifdef NO_STRING_H sl@0: #ifdef DECLARE_SIZE_T sl@0: typedef unsigned int size_t; sl@0: #endif sl@0: extern void memcpy_D2A ANSI((void*, const void*, size_t)); sl@0: #define Bcopy(x,y) memcpy_D2A(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int)) sl@0: #else /* !NO_STRING_H */ sl@0: #define Bcopy(x,y) memcpy(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int)) sl@0: #endif /* NO_STRING_H */ sl@0: sl@0: /* sl@0: * Paranoia: Protect exported symbols, including ones in files we don't sl@0: * compile right now. The standard strtof and strtod survive. sl@0: */ sl@0: #define dtoa __dtoa sl@0: #define gdtoa __gdtoa sl@0: #define freedtoa __freedtoa sl@0: #define strtodg __strtodg sl@0: #define g_ddfmt __g_ddfmt sl@0: #define g_dfmt __g_dfmt sl@0: #define g_ffmt __g_ffmt sl@0: #define g_Qfmt __g_Qfmt sl@0: #define g_xfmt __g_xfmt sl@0: #define g_xLfmt __g_xLfmt sl@0: #define strtoId __strtoId sl@0: #define strtoIdd __strtoIdd sl@0: #define strtoIf __strtoIf sl@0: #define strtoIQ __strtoIQ sl@0: #define strtoIx __strtoIx sl@0: #define strtoIxL __strtoIxL sl@0: #define strtord __strtord sl@0: #define strtordd __strtordd sl@0: #define strtorf __strtorf sl@0: #define strtorQ __strtorQ sl@0: #define strtorx __strtorx sl@0: #define strtorxL __strtorxL sl@0: #define strtodI __strtodI sl@0: #define strtopd __strtopd sl@0: #define strtopdd __strtopdd sl@0: #define strtopf __strtopf sl@0: #define strtopQ __strtopQ sl@0: #define strtopx __strtopx sl@0: #define strtopxL __strtopxL sl@0: sl@0: /* Protect gdtoa-internal symbols */ sl@0: #define Balloc __Balloc_D2A sl@0: #define Bfree __Bfree_D2A sl@0: #define ULtoQ __ULtoQ_D2A sl@0: #define ULtof __ULtof_D2A sl@0: #define ULtod __ULtod_D2A sl@0: #define ULtodd __ULtodd_D2A sl@0: #define ULtox __ULtox_D2A sl@0: #define ULtoxL __ULtoxL_D2A sl@0: #define any_on __any_on_D2A sl@0: #define b2d __b2d_D2A sl@0: #define bigtens __bigtens_D2A sl@0: #define cmp __cmp_D2A sl@0: #define copybits __copybits_D2A sl@0: #define d2b __d2b_D2A sl@0: #define decrement __decrement_D2A sl@0: #define diff __diff_D2A sl@0: #define dtoa_result __dtoa_result_D2A sl@0: #define g__fmt __g__fmt_D2A sl@0: #define gethex __gethex_D2A sl@0: #define hexdig __hexdig_D2A sl@0: #define hexdig_init_D2A __hexdig_init_D2A sl@0: #define hexnan __hexnan_D2A sl@0: #define hi0bits __hi0bits_D2A sl@0: #define i2b __i2b_D2A sl@0: #define increment __increment_D2A sl@0: #define lo0bits __lo0bits_D2A sl@0: #define lshift __lshift_D2A sl@0: #define match __match_D2A sl@0: #define mult __mult_D2A sl@0: #define multadd __multadd_D2A sl@0: #define nrv_alloc __nrv_alloc_D2A sl@0: #define pow5mult __pow5mult_D2A sl@0: #define quorem __quorem_D2A sl@0: #define ratio __ratio_D2A sl@0: #define rshift __rshift_D2A sl@0: #define rv_alloc __rv_alloc_D2A sl@0: #define s2b __s2b_D2A sl@0: #define set_ones __set_ones_D2A sl@0: #define strcp __strcp_D2A sl@0: #define strcp_D2A __strcp_D2A sl@0: #define strtoIg __strtoIg_D2A sl@0: #define sum __sum_D2A sl@0: #define tens __tens_D2A sl@0: #define tinytens __tinytens_D2A sl@0: #define tinytens __tinytens_D2A sl@0: #define trailz __trailz_D2A sl@0: #define ulp __ulp_D2A sl@0: sl@0: extern char *dtoa_result; sl@0: extern CONST double bigtens[], tens[], tinytens[]; sl@0: sl@0: #ifdef __SYMBIAN32__ sl@0: extern unsigned const char hexdig[]; sl@0: #endif sl@0: sl@0: extern Bigint *Balloc ANSI((int)); sl@0: extern void Bfree ANSI((Bigint*)); sl@0: extern void ULtof ANSI((ULong*, ULong*, Long, int)); sl@0: extern void ULtod ANSI((ULong*, ULong*, Long, int)); sl@0: extern void ULtodd ANSI((ULong*, ULong*, Long, int)); sl@0: extern void ULtoQ ANSI((ULong*, ULong*, Long, int)); sl@0: extern void ULtox ANSI((UShort*, ULong*, Long, int)); sl@0: extern void ULtoxL ANSI((ULong*, ULong*, Long, int)); sl@0: extern ULong any_on ANSI((Bigint*, int)); sl@0: extern double b2d ANSI((Bigint*, int*)); sl@0: extern int cmp ANSI((Bigint*, Bigint*)); sl@0: extern void copybits ANSI((ULong*, int, Bigint*)); sl@0: extern Bigint *d2b ANSI((double, int*, int*)); sl@0: extern int decrement ANSI((Bigint*)); sl@0: extern Bigint *diff ANSI((Bigint*, Bigint*)); sl@0: extern char *dtoa ANSI((double d, int mode, int ndigits, sl@0: int *decpt, int *sign, char **rve)); sl@0: extern void freedtoa ANSI((char*)); sl@0: extern char *gdtoa ANSI((FPI *fpi, int be, ULong *bits, int *kindp, sl@0: int mode, int ndigits, int *decpt, char **rve)); sl@0: extern char *g__fmt ANSI((char*, char*, char*, int, ULong)); sl@0: extern int gethex ANSI((CONST char**, FPI*, Long*, Bigint**, int)); sl@0: extern void hexdig_init_D2A(Void); sl@0: extern int hexnan ANSI((CONST char**, FPI*, ULong*)); sl@0: extern int hi0bits ANSI((ULong)); sl@0: extern Bigint *i2b ANSI((int)); sl@0: extern Bigint *increment ANSI((Bigint*)); sl@0: extern int lo0bits ANSI((ULong*)); sl@0: extern Bigint *lshift ANSI((Bigint*, int)); sl@0: extern int match ANSI((CONST char**, char*)); sl@0: extern Bigint *mult ANSI((Bigint*, Bigint*)); sl@0: extern Bigint *multadd ANSI((Bigint*, int, int)); sl@0: extern char *nrv_alloc ANSI((char*, char **, int)); sl@0: extern Bigint *pow5mult ANSI((Bigint*, int)); sl@0: extern int quorem ANSI((Bigint*, Bigint*)); sl@0: extern double ratio ANSI((Bigint*, Bigint*)); sl@0: extern void rshift ANSI((Bigint*, int)); sl@0: extern char *rv_alloc ANSI((int)); sl@0: extern Bigint *s2b ANSI((CONST char*, int, int, ULong)); sl@0: extern Bigint *set_ones ANSI((Bigint*, int)); sl@0: extern char *strcp ANSI((char*, const char*)); sl@0: extern int strtodg ANSI((CONST char*, char**, FPI*, Long*, ULong*)); sl@0: sl@0: extern int strtoId ANSI((CONST char *, char **, double *, double *)); sl@0: extern int strtoIdd ANSI((CONST char *, char **, double *, double *)); sl@0: extern int strtoIf ANSI((CONST char *, char **, float *, float *)); sl@0: extern int strtoIg ANSI((CONST char*, char**, FPI*, Long*, Bigint**, int*)); sl@0: extern int strtoIQ ANSI((CONST char *, char **, void *, void *)); sl@0: extern int strtoIx ANSI((CONST char *, char **, void *, void *)); sl@0: extern int strtoIxL ANSI((CONST char *, char **, void *, void *)); sl@0: extern double strtod ANSI((const char *s00, char **se)); sl@0: extern int strtopQ ANSI((CONST char *, char **, Void *)); sl@0: extern int strtopf ANSI((CONST char *, char **, float *)); sl@0: extern int strtopd ANSI((CONST char *, char **, double *)); sl@0: extern int strtopdd ANSI((CONST char *, char **, double *)); sl@0: extern int strtopx ANSI((CONST char *, char **, Void *)); sl@0: extern int strtopxL ANSI((CONST char *, char **, Void *)); sl@0: extern int strtord ANSI((CONST char *, char **, int, double *)); sl@0: extern int strtordd ANSI((CONST char *, char **, int, double *)); sl@0: extern int strtorf ANSI((CONST char *, char **, int, float *)); sl@0: extern int strtorQ ANSI((CONST char *, char **, int, void *)); sl@0: extern int strtorx ANSI((CONST char *, char **, int, void *)); sl@0: extern int strtorxL ANSI((CONST char *, char **, int, void *)); sl@0: extern Bigint *sum ANSI((Bigint*, Bigint*)); sl@0: extern int trailz ANSI((Bigint*)); sl@0: extern double ulp ANSI((double)); sl@0: sl@0: #ifdef __cplusplus sl@0: } sl@0: #endif sl@0: sl@0: sl@0: #ifdef IEEE_Arith sl@0: #ifdef IEEE_MC68k sl@0: #define _0 0 sl@0: #define _1 1 sl@0: #else sl@0: #define _0 1 sl@0: #define _1 0 sl@0: #endif sl@0: #else sl@0: #undef INFNAN_CHECK sl@0: #endif sl@0: sl@0: #ifdef INFNAN_CHECK sl@0: sl@0: #ifndef NAN_WORD0 sl@0: #define NAN_WORD0 0x7ff80000 sl@0: #endif sl@0: sl@0: #ifndef NAN_WORD1 sl@0: #define NAN_WORD1 0 sl@0: #endif sl@0: #endif /* INFNAN_CHECK */ sl@0: sl@0: #undef SI sl@0: #ifdef Sudden_Underflow sl@0: #define SI 1 sl@0: #else sl@0: #define SI 0 sl@0: #endif sl@0: sl@0: #endif /* GDTOAIMP_H_INCLUDED */