gonzui

    1: /****************************************************************
    2: 
    3: The author of this software is David M. Gay.
    4: 
    5: Copyright (C) 1998-2000 by Lucent Technologies
    6: All Rights Reserved
    7: 
    8: Permission to use, copy, modify, and distribute this software and
    9: its documentation for any purpose and without fee is hereby
   10: granted, provided that the above copyright notice appear in all
   11: copies and that both that the copyright notice and this
   12: permission notice and warranty disclaimer appear in supporting
   13: documentation, and that the name of Lucent or any of its entities
   14: not be used in advertising or publicity pertaining to
   15: distribution of the software without specific, written prior
   16: permission.
   17: 
   18: LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
   19: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
   20: IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
   21: SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   22: WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
   23: IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
   24: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
   25: THIS SOFTWARE.
   26: 
   27: ****************************************************************/
   28: 
   29: /* This is a variation on dtoa.c that converts arbitary binary
   30:    floating-point formats to and from decimal notation.  It uses
   31:    double-precision arithmetic internally, so there are still
   32:    various #ifdefs that adapt the calculations to the native
   33:    double-precision arithmetic (any of IEEE, VAX D_floating,
   34:    or IBM mainframe arithmetic).
   35: 
   36:    Please send bug reports to David M. Gay (dmg at acm dot org,
   37:    with " at " changed at "@" and " dot " changed to ".").
   38:  */
   39: 
   40: /* On a machine with IEEE extended-precision registers, it is
   41:  * necessary to specify double-precision (53-bit) rounding precision
   42:  * before invoking strtod or dtoa.  If the machine uses (the equivalent
   43:  * of) Intel 80x87 arithmetic, the call
   44:  *      _control87(PC_53, MCW_PC);
   45:  * does this with many compilers.  Whether this or another call is
   46:  * appropriate depends on the compiler; for this to work, it may be
   47:  * necessary to #include "float.h" or another system-dependent header
   48:  * file.
   49:  */
   50: 
   51: /* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
   52:  *
   53:  * This strtod returns a nearest machine number to the input decimal
   54:  * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
   55:  * broken by the IEEE round-even rule.  Otherwise ties are broken by
   56:  * biased rounding (add half and chop).
   57:  *
   58:  * Inspired loosely by William D. Clinger's paper "How to Read Floating
   59:  * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 112-126].
   60:  *
   61:  * Modifications:
   62:  *
   63:  *      1. We only require IEEE, IBM, or VAX double-precision
   64:  *              arithmetic (not IEEE double-extended).
   65:  *      2. We get by with floating-point arithmetic in a case that
   66:  *              Clinger missed -- when we're computing d * 10^n
   67:  *              for a small integer d and the integer n is not too
   68:  *              much larger than 22 (the maximum integer k for which
   69:  *              we can represent 10^k exactly), we may be able to
   70:  *              compute (d*10^k) * 10^(e-k) with just one roundoff.
   71:  *      3. Rather than a bit-at-a-time adjustment of the binary
   72:  *              result in the hard case, we use floating-point
   73:  *              arithmetic to determine the adjustment to within
   74:  *              one bit; only in really hard cases do we need to
   75:  *              compute a second residual.
   76:  *      4. Because of 3., we don't need a large table of powers of 10
   77:  *              for ten-to-e (just some small tables, e.g. of 10^k
   78:  *              for 0 <= k <= 22).
   79:  */
   80: 
   81: /*
   82:  * #define IEEE_8087 for IEEE-arithmetic machines where the least
   83:  *      significant byte has the lowest address.
   84:  * #define IEEE_MC68k for IEEE-arithmetic machines where the most
   85:  *      significant byte has the lowest address.
   86:  * #define Long int on machines with 32-bit ints and 64-bit longs.
   87:  * #define Sudden_Underflow for IEEE-format machines without gradual
   88:  *      underflow (i.e., that flush to zero on underflow).
   89:  * #define IBM for IBM mainframe-style floating-point arithmetic.
   90:  * #define VAX for VAX-style floating-point arithmetic (D_floating).
   91:  * #define No_leftright to omit left-right logic in fast floating-point
   92:  *      computation of dtoa and gdtoa.  This will cause modes 4 and 5 to be
   93:  *      treated the same as modes 2 and 3 for some inputs.
   94:  * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
   95:  * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
   96:  *      that use extended-precision instructions to compute rounded
   97:  *      products and quotients) with IBM.
   98:  * #define ROUND_BIASED for IEEE-format with biased rounding and arithmetic
   99:  *      that rounds toward +Infinity.
  100:  * #define ROUND_BIASED_without_Round_Up for IEEE-format with biased
  101:  *      rounding when the underlying floating-point arithmetic uses
  102:  *      unbiased rounding.  This prevent using ordinary floating-point
  103:  *      arithmetic when the result could be computed with one rounding error.
  104:  * #define Inaccurate_Divide for IEEE-format with correctly rounded
  105:  *      products but inaccurate quotients, e.g., for Intel i860.
  106:  * #define NO_LONG_LONG on machines that do not have a "long long"
  107:  *      integer type (of >= 64 bits).  On such machines, you can
  108:  *      #define Just_16 to store 16 bits per 32-bit Long when doing
  109:  *      high-precision integer arithmetic.  Whether this speeds things
  110:  *      up or slows things down depends on the machine and the number
  111:  *      being converted.  If long long is available and the name is
  112:  *      something other than "long long", #define Llong to be the name,
  113:  *      and if "unsigned Llong" does not work as an unsigned version of
  114:  *      Llong, #define #ULLong to be the corresponding unsigned type.
  115:  * #define KR_headers for old-style C function headers.
  116:  * #define Bad_float_h if your system lacks a float.h or if it does not
  117:  *      define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
  118:  *      FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
  119:  * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
  120:  *      if memory is available and otherwise does something you deem
  121:  *      appropriate.  If MALLOC is undefined, malloc will be invoked
  122:  *      directly -- and assumed always to succeed.  Similarly, if you
  123:  *      want something other than the system's free() to be called to
  124:  *      recycle memory acquired from MALLOC, #define FREE to be the
  125:  *      name of the alternate routine.  (FREE or free is only called in
  126:  *      pathological cases, e.g., in a gdtoa call after a gdtoa return in
  127:  *      mode 3 with thousands of digits requested.)
  128:  * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
  129:  *      memory allocations from a private pool of memory when possible.
  130:  *      When used, the private pool is PRIVATE_MEM bytes long:  2304 bytes,
  131:  *      unless #defined to be a different length.  This default length
  132:  *      suffices to get rid of MALLOC calls except for unusual cases,
  133:  *      such as decimal-to-binary conversion of a very long string of
  134:  *      digits.  When converting IEEE double precision values, the
  135:  *      longest string gdtoa can return is about 751 bytes long.  For
  136:  *      conversions by strtod of strings of 800 digits and all gdtoa
  137:  *      conversions of IEEE doubles in single-threaded executions with
  138:  *      8-byte pointers, PRIVATE_MEM >= 7400 appears to suffice; with
  139:  *      4-byte pointers, PRIVATE_MEM >= 7112 appears adequate.
  140:  * #define NO_INFNAN_CHECK if you do not wish to have INFNAN_CHECK
  141:  *      #defined automatically on IEEE systems.  On such systems,
  142:  *      when INFNAN_CHECK is #defined, strtod checks
  143:  *      for Infinity and NaN (case insensitively).
  144:  *      When INFNAN_CHECK is #defined and No_Hex_NaN is not #defined,
  145:  *      strtodg also accepts (case insensitively) strings of the form
  146:  *      NaN(x), where x is a string of hexadecimal digits (optionally
  147:  *      preceded by 0x or 0X) and spaces; if there is only one string
  148:  *      of hexadecimal digits, it is taken for the fraction bits of the
  149:  *      resulting NaN; if there are two or more strings of hexadecimal
  150:  *      digits, each string is assigned to the next available sequence
  151:  *      of 32-bit words of fractions bits (starting with the most
  152:  *      significant), right-aligned in each sequence.
  153:  *      Unless GDTOA_NON_PEDANTIC_NANCHECK is #defined, input "NaN(...)"
  154:  *      is consumed even when ... has the wrong form (in which case the
  155:  *      "(...)" is consumed but ignored).
  156:  * #define MULTIPLE_THREADS if the system offers preemptively scheduled
  157:  *      multiple threads.  In this case, you must provide (or suitably
  158:  *      #define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed
  159:  *      by FREE_DTOA_LOCK(n) for n = 0 or 1.  (The second lock, accessed
  160:  *      in pow5mult, ensures lazy evaluation of only one copy of high
  161:  *      powers of 5; omitting this lock would introduce a small
  162:  *      probability of wasting memory, but would otherwise be harmless.)
  163:  *      You must also invoke freedtoa(s) to free the value s returned by
  164:  *      dtoa.  You may do so whether or not MULTIPLE_THREADS is #defined.
  165:  * #define IMPRECISE_INEXACT if you do not care about the setting of
  166:  *      the STRTOG_Inexact bits in the special case of doing IEEE double
  167:  *      precision conversions (which could also be done by the strtod in
  168:  *      dtoa.c).
  169:  * #define NO_HEX_FP to disable recognition of C9x's hexadecimal
  170:  *      floating-point constants.
  171:  * #define -DNO_ERRNO to suppress setting errno (in strtod.c and
  172:  *      strtodg.c).
  173:  * #define NO_STRING_H to use private versions of memcpy.
  174:  *      On some K&R systems, it may also be necessary to
  175:  *      #define DECLARE_SIZE_T in this case.
  176:  * #define USE_LOCALE to use the current locale's decimal_point value.
  177:  */
  178: 
  179: #ifndef GDTOAIMP_H_INCLUDED
  180: #define GDTOAIMP_H_INCLUDED
  181: #include "gdtoa.h"
  182: #include "gd_qnan.h"
  183: #ifdef Honor_FLT_ROUNDS
  184: #include <fenv.h>
  185: #endif
  186: 
  187: #ifdef DEBUG
  188: #include "stdio.h"
  189: #include "stdlib.h"
  190: #define Bug(x) {fprintf(stderr, "%s\n", x); abort()/*exit(1)*/;}
  191: #endif
  192: 
  193: #include "stdlib.h"
  194: #include "string.h"
  195: 
  196: #ifdef KR_headers
  197: #define Char char
  198: #else
  199: #define Char void
  200: #endif
  201: 
  202: #ifdef MALLOC
  203: extern Char *MALLOC ANSI((size_t));
  204: #else
  205: #define MALLOC malloc
  206: #endif
  207: 
  208: #undef IEEE_Arith
  209: #undef Avoid_Underflow
  210: #ifdef IEEE_MC68k
  211: #define IEEE_Arith
  212: #endif
  213: #ifdef IEEE_8087
  214: #define IEEE_Arith
  215: #endif
  216: 
  217: #include "errno.h"
  218: #ifdef Bad_float_h
  219: 
  220: #ifdef IEEE_Arith
  221: #define DBL_DIG 15
  222: #define DBL_MAX_10_EXP 308
  223: #define DBL_MAX_EXP 1024
  224: #define FLT_RADIX 2
  225: #define DBL_MAX 1.7976931348623157e+308
  226: #endif
  227: 
  228: #ifdef IBM
  229: #define DBL_DIG 16
  230: #define DBL_MAX_10_EXP 75
  231: #define DBL_MAX_EXP 63
  232: #define FLT_RADIX 16
  233: #define DBL_MAX 7.2370055773322621e+75
  234: #endif
  235: 
  236: #ifdef VAX
  237: #define DBL_DIG 16
  238: #define DBL_MAX_10_EXP 38
  239: #define DBL_MAX_EXP 127
  240: #define FLT_RADIX 2
  241: #define DBL_MAX 1.7014118346046923e+38
  242: #define n_bigtens 2
  243: #endif
  244: 
  245: #ifndef LONG_MAX
  246: #define LONG_MAX 2147483647
  247: #endif
  248: 
  249: #else /* ifndef Bad_float_h */
  250: #include "float.h"
  251: #endif /* Bad_float_h */
  252: 
  253: #ifdef IEEE_Arith
  254: #define Scale_Bit 0x10
  255: #define n_bigtens 5
  256: #endif
  257: 
  258: #ifdef IBM
  259: #define n_bigtens 3
  260: #endif
  261: 
  262: #ifdef VAX
  263: #define n_bigtens 2
  264: #endif
  265: 
  266: #ifndef __MATH_H__
  267: #include "math.h"
  268: #endif
  269: 
  270: #ifdef __cplusplus
  271: extern "C" {
  272: #endif
  273: 
  274: #if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
  275: Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
  276: #endif
  277: 
  278: typedef union { double d; ULong L[2]; } U;
  279: 
  280: #if defined(IEEE_8087) && _BYTE_ORDER != _BIG_ENDIAN
  281: #define word0(x) (x)->L[1]
  282: #define word1(x) (x)->L[0]
  283: #else
  284: #define word0(x) (x)->L[0]
  285: #define word1(x) (x)->L[1]
  286: #endif
  287: #define dval(x) (x)->d
  288: 
  289: /* The following definition of Storeinc is appropriate for MIPS processors.
  290:  * An alternative that might be better on some machines is
  291:  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
  292:  */
  293: #if ( defined(IEEE_8087) + defined(VAX) ) && _BYTE_ORDER != _BIG_ENDIAN
  294: #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
  295: ((unsigned short *)a)[0] = (unsigned short)c, a++)
  296: #else
  297: #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
  298: ((unsigned short *)a)[1] = (unsigned short)c, a++)
  299: #endif
  300: 
  301: /* #define P DBL_MANT_DIG */
  302: /* Ten_pmax = floor(P*log(2)/log(5)) */
  303: /* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
  304: /* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
  305: /* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
  306: 
  307: #ifdef IEEE_Arith
  308: #define Exp_shift  20
  309: #define Exp_shift1 20
  310: #define Exp_msk1    0x100000
  311: #define Exp_msk11   0x100000
  312: #define Exp_mask  0x7ff00000
  313: #define P 53
  314: #define Bias 1023
  315: #define Emin (-1022)
  316: #define Exp_1  0x3ff00000
  317: #define Exp_11 0x3ff00000
  318: #define Ebits 11
  319: #define Frac_mask  0xfffff
  320: #define Frac_mask1 0xfffff
  321: #define Ten_pmax 22
  322: #define Bletch 0x10
  323: #define Bndry_mask  0xfffff
  324: #define Bndry_mask1 0xfffff
  325: #define LSB 1
  326: #define Sign_bit 0x80000000
  327: #define Log2P 1
  328: #define Tiny0 0
  329: #define Tiny1 1
  330: #define Quick_max 14
  331: #define Int_max 14
  332: 
  333: #ifndef Flt_Rounds
  334: #ifdef FLT_ROUNDS
  335: #define Flt_Rounds FLT_ROUNDS
  336: #else
  337: #define Flt_Rounds 1
  338: #endif
  339: #endif /*Flt_Rounds*/
  340: 
  341: #else /* ifndef IEEE_Arith */
  342: #undef  Sudden_Underflow
  343: #define Sudden_Underflow
  344: #ifdef IBM
  345: #undef Flt_Rounds
  346: #define Flt_Rounds 0
  347: #define Exp_shift  24
  348: #define Exp_shift1 24
  349: #define Exp_msk1   0x1000000
  350: #define Exp_msk11  0x1000000
  351: #define Exp_mask  0x7f000000
  352: #define P 14
  353: #define Bias 65
  354: #define Exp_1  0x41000000
  355: #define Exp_11 0x41000000
  356: #define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */
  357: #define Frac_mask  0xffffff
  358: #define Frac_mask1 0xffffff
  359: #define Bletch 4
  360: #define Ten_pmax 22
  361: #define Bndry_mask  0xefffff
  362: #define Bndry_mask1 0xffffff
  363: #define LSB 1
  364: #define Sign_bit 0x80000000
  365: #define Log2P 4
  366: #define Tiny0 0x100000
  367: #define Tiny1 0
  368: #define Quick_max 14
  369: #define Int_max 15
  370: #else /* VAX */
  371: #undef Flt_Rounds
  372: #define Flt_Rounds 1
  373: #define Exp_shift  23
  374: #define Exp_shift1 7
  375: #define Exp_msk1    0x80
  376: #define Exp_msk11   0x800000
  377: #define Exp_mask  0x7f80
  378: #define P 56
  379: #define Bias 129
  380: #define Emin (-127)
  381: #define Exp_1  0x40800000
  382: #define Exp_11 0x4080
  383: #define Ebits 8
  384: #define Frac_mask  0x7fffff
  385: #define Frac_mask1 0xffff007f
  386: #define Ten_pmax 24
  387: #define Bletch 2
  388: #define Bndry_mask  0xffff007f
  389: #define Bndry_mask1 0xffff007f
  390: #define LSB 0x10000
  391: #define Sign_bit 0x8000
  392: #define Log2P 1
  393: #define Tiny0 0x80
  394: #define Tiny1 0
  395: #define Quick_max 15
  396: #define Int_max 15
  397: #endif /* IBM, VAX */
  398: #endif /* IEEE_Arith */
  399: 
  400: #ifndef IEEE_Arith
  401: #define ROUND_BIASED
  402: #else
  403: #ifdef ROUND_BIASED_without_Round_Up
  404: #undef  ROUND_BIASED
  405: #define ROUND_BIASED
  406: #endif
  407: #endif
  408: 
  409: #ifdef RND_PRODQUOT
  410: #define rounded_product(a,b) a = rnd_prod(a, b)
  411: #define rounded_quotient(a,b) a = rnd_quot(a, b)
  412: #ifdef KR_headers
  413: extern double rnd_prod(), rnd_quot();
  414: #else
  415: extern double rnd_prod(double, double), rnd_quot(double, double);
  416: #endif
  417: #else
  418: #define rounded_product(a,b) a *= b
  419: #define rounded_quotient(a,b) a /= b
  420: #endif
  421: 
  422: #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
  423: #define Big1 0xffffffff
  424: 
  425: #undef  Pack_16
  426: #ifndef Pack_32
  427: #define Pack_32
  428: #endif
  429: 
  430: #ifdef NO_LONG_LONG
  431: #undef ULLong
  432: #ifdef Just_16
  433: #undef Pack_32
  434: #define Pack_16
  435: /* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
  436:  * This makes some inner loops simpler and sometimes saves work
  437:  * during multiplications, but it often seems to make things slightly
  438:  * slower.  Hence the default is now to store 32 bits per Long.
  439:  */
  440: #endif
  441: #else   /* long long available */
  442: #ifndef Llong
  443: #define Llong long long
  444: #endif
  445: #ifndef ULLong
  446: #define ULLong unsigned Llong
  447: #endif
  448: #endif /* NO_LONG_LONG */
  449: 
  450: #ifdef Pack_32
  451: #define ULbits 32
  452: #define kshift 5
  453: #define kmask 31
  454: #define ALL_ON 0xffffffff
  455: #else
  456: #define ULbits 16
  457: #define kshift 4
  458: #define kmask 15
  459: #define ALL_ON 0xffff
  460: #endif
  461: 
  462: #ifndef MULTIPLE_THREADS
  463: #define ACQUIRE_DTOA_LOCK(n)    /*nothing*/
  464: #define FREE_DTOA_LOCK(n)       /*nothing*/
  465: #else
  466: #include "thread_private.h"
  467: extern void *__dtoa_locks[];
  468: #define ACQUIRE_DTOA_LOCK(n)    _MUTEX_LOCK(&__dtoa_locks[n])
  469: #define FREE_DTOA_LOCK(n)       _MUTEX_UNLOCK(&__dtoa_locks[n])
  470: #endif
  471: 
  472: #define Kmax 9
  473: 
  474:  struct
  475: Bigint {
  476:         struct Bigint *next;
  477:         int k, maxwds, sign, wds;
  478:         ULong x[1];
  479:         };
  480: 
  481:  typedef struct Bigint Bigint;
  482: 
  483: #ifdef NO_STRING_H
  484: #ifdef DECLARE_SIZE_T
  485: typedef unsigned int size_t;
  486: #endif
  487: extern void memcpy_D2A ANSI((void*, const void*, size_t));
  488: #define Bcopy(x,y) memcpy_D2A(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int))
  489: #else /* !NO_STRING_H */
  490: #define Bcopy(x,y) memcpy(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int))
  491: #endif /* NO_STRING_H */
  492: 
  493: #define dtoa __dtoa
  494: #define gdtoa __gdtoa
  495: #define freedtoa __freedtoa
  496: #define strtodg __strtodg
  497: #define g_ddfmt __g_ddfmt
  498: #define g_dfmt __g_dfmt
  499: #define g_ffmt __g_ffmt
  500: #define g_Qfmt __g_Qfmt
  501: #define g_xfmt __g_xfmt
  502: #define g_xLfmt __g_xLfmt
  503: #define strtoId __strtoId
  504: #define strtoIdd __strtoIdd
  505: #define strtoIf __strtoIf
  506: #define strtoIQ __strtoIQ
  507: #define strtoIx __strtoIx
  508: #define strtoIxL __strtoIxL
  509: #define strtord __strtord
  510: #define strtordd __strtordd
  511: #define strtorf __strtorf
  512: #define strtorQ __strtorQ
  513: #define strtorx __strtorx
  514: #define strtorxL __strtorxL
  515: #define strtodI __strtodI
  516: #define strtopd __strtopd
  517: #define strtopdd __strtopdd
  518: #define strtopf __strtopf
  519: #define strtopQ __strtopQ
  520: #define strtopx __strtopx
  521: #define strtopxL __strtopxL
  522: 
  523: #define Balloc __Balloc_D2A
  524: #define Bfree __Bfree_D2A
  525: #define ULtoQ __ULtoQ_D2A
  526: #define ULtof __ULtof_D2A
  527: #define ULtod __ULtod_D2A
  528: #define ULtodd __ULtodd_D2A
  529: #define ULtox __ULtox_D2A
  530: #define ULtoxL __ULtoxL_D2A
  531: #define any_on __any_on_D2A
  532: #define b2d __b2d_D2A
  533: #define bigtens __bigtens_D2A
  534: #define cmp __cmp_D2A
  535: #define copybits __copybits_D2A
  536: #define d2b __d2b_D2A
  537: #define decrement __decrement_D2A
  538: #define diff __diff_D2A
  539: #define dtoa_result __dtoa_result_D2A
  540: #define g__fmt __g__fmt_D2A
  541: #define gethex __gethex_D2A
  542: #define hexdig __hexdig_D2A
  543: #define hexnan __hexnan_D2A
  544: #define hi0bits(x) __hi0bits_D2A((ULong)(x))
  545: #define hi0bits_D2A __hi0bits_D2A
  546: #define i2b __i2b_D2A
  547: #define increment __increment_D2A
  548: #define lo0bits __lo0bits_D2A
  549: #define lshift __lshift_D2A
  550: #define match __match_D2A
  551: #define mult __mult_D2A
  552: #define multadd __multadd_D2A
  553: #define nrv_alloc __nrv_alloc_D2A
  554: #define pow5mult __pow5mult_D2A
  555: #define quorem __quorem_D2A
  556: #define ratio __ratio_D2A
  557: #define rshift __rshift_D2A
  558: #define rv_alloc __rv_alloc_D2A
  559: #define s2b __s2b_D2A
  560: #define set_ones __set_ones_D2A
  561: #define strcp __strcp_D2A
  562: #define strtoIg __strtoIg_D2A
  563: #define sulp __sulp_D2A
  564: #define sum __sum_D2A
  565: #define tens __tens_D2A
  566: #define tinytens __tinytens_D2A
  567: #define tinytens __tinytens_D2A
  568: #define trailz __trailz_D2A
  569: #define ulp __ulp_D2A
  570: 
  571:  extern char *dtoa_result;
  572:  extern CONST double bigtens[], tens[], tinytens[];
  573:  extern unsigned char hexdig[];
  574: 
  575:  extern Bigint *Balloc ANSI((int));
  576:  extern void Bfree ANSI((Bigint*));
  577:  extern void ULtof ANSI((ULong*, ULong*, Long, int));
  578:  extern void ULtod ANSI((ULong*, ULong*, Long, int));
  579:  extern void ULtodd ANSI((ULong*, ULong*, Long, int));
  580:  extern void ULtoQ ANSI((ULong*, ULong*, Long, int));
  581:  extern void ULtox ANSI((UShort*, ULong*, Long, int));
  582:  extern void ULtoxL ANSI((ULong*, ULong*, Long, int));
  583:  extern ULong any_on ANSI((Bigint*, int));
  584:  extern double b2d ANSI((Bigint*, int*));
  585:  extern int cmp ANSI((Bigint*, Bigint*));
  586:  extern void copybits ANSI((ULong*, int, Bigint*));
  587:  extern Bigint *d2b ANSI((double, int*, int*));
  588:  extern void decrement ANSI((Bigint*));
  589:  extern Bigint *diff ANSI((Bigint*, Bigint*));
  590:  extern char *dtoa ANSI((double d, int mode, int ndigits,
  591:                         int *decpt, int *sign, char **rve));
  592:  extern char *g__fmt ANSI((char*, char*, char*, int, ULong, size_t));
  593:  extern int gethex ANSI((CONST char**, FPI*, Long*, Bigint**, int));
  594:  extern void hexdig_init_D2A(Void);
  595:  extern int hexnan ANSI((CONST char**, FPI*, ULong*));
  596:  extern int hi0bits_D2A ANSI((ULong));
  597:  extern Bigint *i2b ANSI((int));
  598:  extern Bigint *increment ANSI((Bigint*));
  599:  extern int lo0bits ANSI((ULong*));
  600:  extern Bigint *lshift ANSI((Bigint*, int));
  601:  extern int match ANSI((CONST char**, char*));
  602:  extern Bigint *mult ANSI((Bigint*, Bigint*));
  603:  extern Bigint *multadd ANSI((Bigint*, int, int));
  604:  extern char *nrv_alloc ANSI((char*, char **, int));
  605:  extern Bigint *pow5mult ANSI((Bigint*, int));
  606:  extern int quorem ANSI((Bigint*, Bigint*));
  607:  extern double ratio ANSI((Bigint*, Bigint*));
  608:  extern void rshift ANSI((Bigint*, int));
  609:  extern char *rv_alloc ANSI((int));
  610:  extern Bigint *s2b ANSI((CONST char*, int, int, ULong, int));
  611:  extern Bigint *set_ones ANSI((Bigint*, int));
  612:  extern char *strcp ANSI((char*, const char*));
  613:  extern int strtoIg ANSI((CONST char*, char**, FPI*, Long*, Bigint**, int*));
  614:  extern double strtod ANSI((const char *s00, char **se));
  615:  extern Bigint *sum ANSI((Bigint*, Bigint*));
  616:  extern int trailz ANSI((Bigint*));
  617:  extern double ulp ANSI((U*));
  618: 
  619: #ifdef __cplusplus
  620: }
  621: #endif
  622: /*
  623:  * NAN_WORD0 and NAN_WORD1 are only referenced in strtod.c.  Prior to
  624:  * 20050115, they used to be hard-wired here (to 0x7ff80000 and 0,
  625:  * respectively), but now are determined by compiling and running
  626:  * qnan.c to generate gd_qnan.h, which specifies d_QNAN0 and d_QNAN1.
  627:  * Formerly gdtoaimp.h recommended supplying suitable -DNAN_WORD0=...
  628:  * and -DNAN_WORD1=...  values if necessary.  This should still work.
  629:  * (On HP Series 700/800 machines, -DNAN_WORD0=0x7ff40000 works.)
  630:  */
  631: #ifdef IEEE_Arith
  632: #ifndef NO_INFNAN_CHECK
  633: #undef INFNAN_CHECK
  634: #define INFNAN_CHECK
  635: #endif
  636: #ifdef IEEE_MC68k
  637: #define _0 0
  638: #define _1 1
  639: #ifndef NAN_WORD0
  640: #define NAN_WORD0 d_QNAN0
  641: #endif
  642: #ifndef NAN_WORD1
  643: #define NAN_WORD1 d_QNAN1
  644: #endif
  645: #else
  646: #define _0 1
  647: #define _1 0
  648: #ifndef NAN_WORD0
  649: #define NAN_WORD0 d_QNAN1
  650: #endif
  651: #ifndef NAN_WORD1
  652: #define NAN_WORD1 d_QNAN0
  653: #endif
  654: #endif
  655: #else
  656: #undef INFNAN_CHECK
  657: #endif
  658: 
  659: #undef SI
  660: #ifdef Sudden_Underflow
  661: #define SI 1
  662: #else
  663: #define SI 0
  664: #endif
  665: 
  666: #ifdef _T2EX
  667: /* For T2EX, memory resource is very important.
  668:    Hence, private memory for Balloc only shall be removed */
  669: #define Omit_Private_Memory
  670: #endif
  671: 
  672: #endif /* GDTOAIMP_H_INCLUDED */