[BACK]Return to gdtoaimp.h CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / gdtoa

Annotation of src/lib/libc/gdtoa/gdtoaimp.h, Revision 1.1

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

CVSweb <webmaster@jp.NetBSD.org>