[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.9

1.9     ! christos    1: /* $NetBSD: gdtoaimp.h,v 1.8 2011/01/21 23:36:49 christos Exp $ */
1.1       kleink      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: /*
1.2       kleink     84:  * #define IEEE_LITTLE_ENDIAN for IEEE-arithmetic machines where the least
1.1       kleink     85:  *     significant byte has the lowest address.
1.2       kleink     86:  * #define IEEE_BIG_ENDIAN for IEEE-arithmetic machines where the most
1.1       kleink     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.
1.9     ! christos   99:  * #define ROUND_BIASED for IEEE-format with biased rounding and arithmetic
        !           100:  *     that rounds toward +Infinity.
        !           101:  * #define ROUND_BIASED_without_Round_Up for IEEE-format with biased
        !           102:  *     rounding when the underlying floating-point arithmetic uses
        !           103:  *     unbiased rounding.  This prevent using ordinary floating-point
        !           104:  *     arithmetic when the result could be computed with one rounding error.
1.1       kleink    105:  * #define Inaccurate_Divide for IEEE-format with correctly rounded
                    106:  *     products but inaccurate quotients, e.g., for Intel i860.
                    107:  * #define NO_LONG_LONG on machines that do not have a "long long"
                    108:  *     integer type (of >= 64 bits).  On such machines, you can
                    109:  *     #define Just_16 to store 16 bits per 32-bit Long when doing
                    110:  *     high-precision integer arithmetic.  Whether this speeds things
                    111:  *     up or slows things down depends on the machine and the number
                    112:  *     being converted.  If long long is available and the name is
                    113:  *     something other than "long long", #define Llong to be the name,
                    114:  *     and if "unsigned Llong" does not work as an unsigned version of
                    115:  *     Llong, #define #ULLong to be the corresponding unsigned type.
                    116:  * #define KR_headers for old-style C function headers.
                    117:  * #define Bad_float_h if your system lacks a float.h or if it does not
                    118:  *     define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
                    119:  *     FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
                    120:  * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
                    121:  *     if memory is available and otherwise does something you deem
                    122:  *     appropriate.  If MALLOC is undefined, malloc will be invoked
1.9     ! christos  123:  *     directly -- and assumed always to succeed.  Similarly, if you
        !           124:  *     want something other than the system's free() to be called to
        !           125:  *     recycle memory acquired from MALLOC, #define FREE to be the
        !           126:  *     name of the alternate routine.  (FREE or free is only called in
        !           127:  *     pathological cases, e.g., in a gdtoa call after a gdtoa return in
        !           128:  *     mode 3 with thousands of digits requested.)
1.1       kleink    129:  * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
                    130:  *     memory allocations from a private pool of memory when possible.
                    131:  *     When used, the private pool is PRIVATE_MEM bytes long:  2304 bytes,
                    132:  *     unless #defined to be a different length.  This default length
                    133:  *     suffices to get rid of MALLOC calls except for unusual cases,
                    134:  *     such as decimal-to-binary conversion of a very long string of
                    135:  *     digits.  When converting IEEE double precision values, the
                    136:  *     longest string gdtoa can return is about 751 bytes long.  For
                    137:  *     conversions by strtod of strings of 800 digits and all gdtoa
                    138:  *     conversions of IEEE doubles in single-threaded executions with
                    139:  *     8-byte pointers, PRIVATE_MEM >= 7400 appears to suffice; with
                    140:  *     4-byte pointers, PRIVATE_MEM >= 7112 appears adequate.
1.9     ! christos  141:  * #define NO_INFNAN_CHECK if you do not wish to have INFNAN_CHECK
        !           142:  *     #defined automatically on IEEE systems.  On such systems,
        !           143:  *     when INFNAN_CHECK is #defined, strtod checks
        !           144:  *     for Infinity and NaN (case insensitively).
1.1       kleink    145:  *     When INFNAN_CHECK is #defined and No_Hex_NaN is not #defined,
                    146:  *     strtodg also accepts (case insensitively) strings of the form
1.9     ! christos  147:  *     NaN(x), where x is a string of hexadecimal digits (optionally
        !           148:  *     preceded by 0x or 0X) and spaces; if there is only one string
        !           149:  *     of hexadecimal digits, it is taken for the fraction bits of the
        !           150:  *     resulting NaN; if there are two or more strings of hexadecimal
        !           151:  *     digits, each string is assigned to the next available sequence
        !           152:  *     of 32-bit words of fractions bits (starting with the most
        !           153:  *     significant), right-aligned in each sequence.
        !           154:  *     Unless GDTOA_NON_PEDANTIC_NANCHECK is #defined, input "NaN(...)"
        !           155:  *     is consumed even when ... has the wrong form (in which case the
        !           156:  *     "(...)" is consumed but ignored).
1.1       kleink    157:  * #define MULTIPLE_THREADS if the system offers preemptively scheduled
                    158:  *     multiple threads.  In this case, you must provide (or suitably
                    159:  *     #define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed
                    160:  *     by FREE_DTOA_LOCK(n) for n = 0 or 1.  (The second lock, accessed
                    161:  *     in pow5mult, ensures lazy evaluation of only one copy of high
                    162:  *     powers of 5; omitting this lock would introduce a small
                    163:  *     probability of wasting memory, but would otherwise be harmless.)
                    164:  *     You must also invoke freedtoa(s) to free the value s returned by
                    165:  *     dtoa.  You may do so whether or not MULTIPLE_THREADS is #defined.
                    166:  * #define IMPRECISE_INEXACT if you do not care about the setting of
                    167:  *     the STRTOG_Inexact bits in the special case of doing IEEE double
1.9     ! christos  168:  *     precision conversions (which could also be done by the strtod in
1.1       kleink    169:  *     dtoa.c).
                    170:  * #define NO_HEX_FP to disable recognition of C9x's hexadecimal
                    171:  *     floating-point constants.
                    172:  * #define -DNO_ERRNO to suppress setting errno (in strtod.c and
                    173:  *     strtodg.c).
                    174:  * #define NO_STRING_H to use private versions of memcpy.
                    175:  *     On some K&R systems, it may also be necessary to
                    176:  *     #define DECLARE_SIZE_T in this case.
                    177:  * #define USE_LOCALE to use the current locale's decimal_point value.
                    178:  */
                    179:
1.2       kleink    180: /* #define IEEE_{BIG,LITTLE}_ENDIAN in ${ARCHDIR}/gdtoa/arith.h */
                    181:
                    182: #include <stdint.h>
1.5       christos  183: #define Short   int16_t
                    184: #define UShort uint16_t
1.2       kleink    185: #define Long    int32_t
                    186: #define ULong  uint32_t
                    187: #define LLong   int64_t
                    188: #define ULLong uint64_t
                    189:
                    190: #define INFNAN_CHECK
1.4       christos  191: #ifdef _REENTRANT
1.2       kleink    192: #define MULTIPLE_THREADS
1.4       christos  193: #endif
1.2       kleink    194: #define USE_LOCALE
                    195:
1.1       kleink    196: #ifndef GDTOAIMP_H_INCLUDED
                    197: #define GDTOAIMP_H_INCLUDED
                    198: #include "gdtoa.h"
                    199: #include "gd_qnan.h"
1.9     ! christos  200: #ifdef Honor_FLT_ROUNDS
        !           201: #include <fenv.h>
        !           202: #endif
1.1       kleink    203:
                    204: #ifdef DEBUG
                    205: #include "stdio.h"
                    206: #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
                    207: #endif
                    208:
                    209: #include "stdlib.h"
                    210: #include "string.h"
                    211:
                    212: #ifdef KR_headers
                    213: #define Char char
                    214: #else
                    215: #define Char void
                    216: #endif
                    217:
                    218: #ifdef MALLOC
                    219: extern Char *MALLOC ANSI((size_t));
                    220: #else
                    221: #define MALLOC malloc
                    222: #endif
                    223:
                    224: #undef IEEE_Arith
                    225: #undef Avoid_Underflow
1.2       kleink    226: #ifdef IEEE_BIG_ENDIAN
1.1       kleink    227: #define IEEE_Arith
                    228: #endif
1.2       kleink    229: #ifdef IEEE_LITTLE_ENDIAN
1.1       kleink    230: #define IEEE_Arith
                    231: #endif
                    232:
                    233: #include "errno.h"
                    234: #ifdef Bad_float_h
                    235:
                    236: #ifdef IEEE_Arith
                    237: #define DBL_DIG 15
                    238: #define DBL_MAX_10_EXP 308
                    239: #define DBL_MAX_EXP 1024
                    240: #define FLT_RADIX 2
                    241: #define DBL_MAX 1.7976931348623157e+308
                    242: #endif
                    243:
                    244: #ifdef IBM
                    245: #define DBL_DIG 16
                    246: #define DBL_MAX_10_EXP 75
                    247: #define DBL_MAX_EXP 63
                    248: #define FLT_RADIX 16
                    249: #define DBL_MAX 7.2370055773322621e+75
                    250: #endif
                    251:
                    252: #ifdef VAX
                    253: #define DBL_DIG 16
                    254: #define DBL_MAX_10_EXP 38
                    255: #define DBL_MAX_EXP 127
                    256: #define FLT_RADIX 2
                    257: #define DBL_MAX 1.7014118346046923e+38
                    258: #define n_bigtens 2
                    259: #endif
                    260:
                    261: #ifndef LONG_MAX
                    262: #define LONG_MAX 2147483647
                    263: #endif
                    264:
                    265: #else /* ifndef Bad_float_h */
                    266: #include "float.h"
                    267: #endif /* Bad_float_h */
                    268:
                    269: #ifdef IEEE_Arith
                    270: #define Scale_Bit 0x10
                    271: #define n_bigtens 5
                    272: #endif
                    273:
                    274: #ifdef IBM
                    275: #define n_bigtens 3
                    276: #endif
                    277:
                    278: #ifdef VAX
                    279: #define n_bigtens 2
                    280: #endif
                    281:
                    282: #include "math.h"
                    283:
                    284: #ifdef __cplusplus
                    285: extern "C" {
                    286: #endif
                    287:
1.2       kleink    288: #if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN) + defined(VAX) + defined(IBM) != 1
                    289: Exactly one of IEEE_LITTLE_ENDIAN, IEEE_BIG_ENDIAN, VAX, or IBM should be defined.
1.1       kleink    290: #endif
                    291:
1.8       christos  292: typedef union { double d; ULong L[2]; } __attribute__((__may_alias__)) U;
1.1       kleink    293:
                    294: #ifdef YES_ALIAS
                    295: #define dval(x) x
1.2       kleink    296: #ifdef IEEE_LITTLE_ENDIAN
1.9     ! christos  297: #define word0(x) ((ULong *)x)[1]
        !           298: #define word1(x) ((ULong *)x)[0]
1.1       kleink    299: #else
1.9     ! christos  300: #define word0(x) ((ULong *)x)[0]
        !           301: #define word1(x) ((ULong *)x)[1]
1.1       kleink    302: #endif
                    303: #else /* !YES_ALIAS */
1.2       kleink    304: #ifdef IEEE_LITTLE_ENDIAN
1.9     ! christos  305: #define word0(x) ( /* LINTED */ (U*)x)->L[1]
        !           306: #define word1(x) ( /* LINTED */ (U*)x)->L[0]
1.1       kleink    307: #else
1.9     ! christos  308: #define word0(x) ( /* LINTED */ (U*)x)->L[0]
        !           309: #define word1(x) ( /* LINTED */ (U*)x)->L[1]
1.1       kleink    310: #endif
1.9     ! christos  311: #define dval(x) ( /* LINTED */ (U*)x)->d
1.1       kleink    312: #endif /* YES_ALIAS */
                    313:
                    314: /* The following definition of Storeinc is appropriate for MIPS processors.
                    315:  * An alternative that might be better on some machines is
                    316:  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
                    317:  */
1.2       kleink    318: #if defined(IEEE_LITTLE_ENDIAN) + defined(VAX)
                    319: #define Storeinc(a,b,c) \
                    320:  (((unsigned short *)(void *)a)[1] = (unsigned short)b, \
                    321:   ((unsigned short *)(void *)a)[0] = (unsigned short)c, \
                    322:   a++)
                    323: #else
                    324: #define Storeinc(a,b,c) \
                    325:  (((unsigned short *)(void *)a)[0] = (unsigned short)b, \
                    326:   ((unsigned short *)(void *)a)[1] = (unsigned short)c, \
                    327:   a++)
1.1       kleink    328: #endif
                    329:
                    330: /* #define P DBL_MANT_DIG */
                    331: /* Ten_pmax = floor(P*log(2)/log(5)) */
                    332: /* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
                    333: /* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
                    334: /* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
                    335:
                    336: #ifdef IEEE_Arith
                    337: #define Exp_shift  20
                    338: #define Exp_shift1 20
                    339: #define Exp_msk1    0x100000
                    340: #define Exp_msk11   0x100000
                    341: #define Exp_mask  0x7ff00000
                    342: #define P 53
                    343: #define Bias 1023
                    344: #define Emin (-1022)
                    345: #define Exp_1  0x3ff00000
                    346: #define Exp_11 0x3ff00000
                    347: #define Ebits 11
                    348: #define Frac_mask  0xfffff
                    349: #define Frac_mask1 0xfffff
                    350: #define Ten_pmax 22
                    351: #define Bletch 0x10
                    352: #define Bndry_mask  0xfffff
                    353: #define Bndry_mask1 0xfffff
                    354: #define LSB 1
                    355: #define Sign_bit 0x80000000
                    356: #define Log2P 1
                    357: #define Tiny0 0
                    358: #define Tiny1 1
                    359: #define Quick_max 14
                    360: #define Int_max 14
                    361:
                    362: #ifndef Flt_Rounds
                    363: #ifdef FLT_ROUNDS
                    364: #define Flt_Rounds FLT_ROUNDS
                    365: #else
                    366: #define Flt_Rounds 1
                    367: #endif
                    368: #endif /*Flt_Rounds*/
                    369:
                    370: #else /* ifndef IEEE_Arith */
                    371: #undef  Sudden_Underflow
                    372: #define Sudden_Underflow
                    373: #ifdef IBM
                    374: #undef Flt_Rounds
                    375: #define Flt_Rounds 0
                    376: #define Exp_shift  24
                    377: #define Exp_shift1 24
                    378: #define Exp_msk1   0x1000000
                    379: #define Exp_msk11  0x1000000
                    380: #define Exp_mask  0x7f000000
                    381: #define P 14
                    382: #define Bias 65
                    383: #define Exp_1  0x41000000
                    384: #define Exp_11 0x41000000
                    385: #define Ebits 8        /* exponent has 7 bits, but 8 is the right value in b2d */
                    386: #define Frac_mask  0xffffff
                    387: #define Frac_mask1 0xffffff
                    388: #define Bletch 4
                    389: #define Ten_pmax 22
                    390: #define Bndry_mask  0xefffff
                    391: #define Bndry_mask1 0xffffff
                    392: #define LSB 1
                    393: #define Sign_bit 0x80000000
                    394: #define Log2P 4
                    395: #define Tiny0 0x100000
                    396: #define Tiny1 0
                    397: #define Quick_max 14
                    398: #define Int_max 15
                    399: #else /* VAX */
                    400: #undef Flt_Rounds
                    401: #define Flt_Rounds 1
                    402: #define Exp_shift  23
                    403: #define Exp_shift1 7
                    404: #define Exp_msk1    0x80
                    405: #define Exp_msk11   0x800000
                    406: #define Exp_mask  0x7f80
                    407: #define P 56
                    408: #define Bias 129
                    409: #define Exp_1  0x40800000
                    410: #define Exp_11 0x4080
                    411: #define Ebits 8
                    412: #define Frac_mask  0x7fffff
                    413: #define Frac_mask1 0xffff007f
                    414: #define Ten_pmax 24
                    415: #define Bletch 2
                    416: #define Bndry_mask  0xffff007f
                    417: #define Bndry_mask1 0xffff007f
                    418: #define LSB 0x10000
                    419: #define Sign_bit 0x8000
                    420: #define Log2P 1
                    421: #define Tiny0 0x80
                    422: #define Tiny1 0
                    423: #define Quick_max 15
                    424: #define Int_max 15
                    425: #endif /* IBM, VAX */
                    426: #endif /* IEEE_Arith */
                    427:
                    428: #ifndef IEEE_Arith
                    429: #define ROUND_BIASED
1.9     ! christos  430: #else
        !           431: #ifdef ROUND_BIASED_without_Round_Up
        !           432: #undef  ROUND_BIASED
        !           433: #define ROUND_BIASED
        !           434: #endif
1.1       kleink    435: #endif
                    436:
                    437: #ifdef RND_PRODQUOT
                    438: #define rounded_product(a,b) a = rnd_prod(a, b)
                    439: #define rounded_quotient(a,b) a = rnd_quot(a, b)
                    440: #ifdef KR_headers
                    441: extern double rnd_prod(), rnd_quot();
                    442: #else
                    443: extern double rnd_prod(double, double), rnd_quot(double, double);
                    444: #endif
                    445: #else
                    446: #define rounded_product(a,b) a *= b
                    447: #define rounded_quotient(a,b) a /= b
                    448: #endif
                    449:
                    450: #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
                    451: #define Big1 0xffffffff
                    452:
                    453: #undef  Pack_16
                    454: #ifndef Pack_32
                    455: #define Pack_32
                    456: #endif
                    457:
                    458: #ifdef NO_LONG_LONG
                    459: #undef ULLong
                    460: #ifdef Just_16
                    461: #undef Pack_32
                    462: #define Pack_16
                    463: /* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
                    464:  * This makes some inner loops simpler and sometimes saves work
                    465:  * during multiplications, but it often seems to make things slightly
                    466:  * slower.  Hence the default is now to store 32 bits per Long.
                    467:  */
                    468: #endif
                    469: #else  /* long long available */
                    470: #ifndef Llong
                    471: #define Llong long long
                    472: #endif
                    473: #ifndef ULLong
                    474: #define ULLong unsigned Llong
                    475: #endif
                    476: #endif /* NO_LONG_LONG */
                    477:
                    478: #ifdef Pack_32
                    479: #define ULbits 32
                    480: #define kshift 5
                    481: #define kmask 31
                    482: #define ALL_ON 0xffffffff
                    483: #else
                    484: #define ULbits 16
                    485: #define kshift 4
                    486: #define kmask 15
                    487: #define ALL_ON 0xffff
                    488: #endif
                    489:
                    490: #ifndef MULTIPLE_THREADS
                    491: #define ACQUIRE_DTOA_LOCK(n)   /*nothing*/
                    492: #define FREE_DTOA_LOCK(n)      /*nothing*/
1.2       kleink    493: #else
                    494: #include "reentrant.h"
                    495:
                    496: extern mutex_t __gdtoa_locks[2];
                    497:
                    498: #define ACQUIRE_DTOA_LOCK(n)   \
                    499:        do {                                                    \
                    500:                if (__isthreaded)                               \
                    501:                        mutex_lock(&__gdtoa_locks[n]);          \
                    502:        } while (/* CONSTCOND */ 0)
                    503: #define FREE_DTOA_LOCK(n)      \
                    504:        do {                                                    \
                    505:                if (__isthreaded)                               \
                    506:                        mutex_unlock(&__gdtoa_locks[n]);        \
                    507:        } while (/* CONSTCOND */ 0)
1.1       kleink    508: #endif
                    509:
1.7       christos  510: #define Kmax (sizeof(size_t) << 3)
1.1       kleink    511:
                    512:  struct
                    513: Bigint {
                    514:        struct Bigint *next;
                    515:        int k, maxwds, sign, wds;
                    516:        ULong x[1];
                    517:        };
                    518:
                    519:  typedef struct Bigint Bigint;
                    520:
                    521: #ifdef NO_STRING_H
                    522: #ifdef DECLARE_SIZE_T
                    523: typedef unsigned int size_t;
                    524: #endif
                    525: extern void memcpy_D2A ANSI((void*, const void*, size_t));
                    526: #define Bcopy(x,y) memcpy_D2A(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int))
                    527: #else /* !NO_STRING_H */
                    528: #define Bcopy(x,y) memcpy(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int))
                    529: #endif /* NO_STRING_H */
                    530:
1.2       kleink    531: #define Balloc         __Balloc_D2A
                    532: #define Bfree          __Bfree_D2A
                    533: #define ULtoQ          __ULtoQ_D2A
                    534: #define ULtof          __ULtof_D2A
                    535: #define ULtod          __ULtod_D2A
                    536: #define ULtodd         __ULtodd_D2A
                    537: #define ULtox          __ULtox_D2A
                    538: #define ULtoxL         __ULtoxL_D2A
                    539: #define any_on                 __any_on_D2A
                    540: #define b2d            __b2d_D2A
                    541: #define bigtens        __bigtens_D2A
                    542: #define cmp            __cmp_D2A
                    543: #define copybits       __copybits_D2A
                    544: #define d2b            __d2b_D2A
                    545: #define decrement      __decrement_D2A
                    546: #define diff           __diff_D2A
                    547: #define dtoa_result    __dtoa_result_D2A
                    548: #define g__fmt                 __g__fmt_D2A
                    549: #define gethex                 __gethex_D2A
                    550: #define hexdig                 __hexdig_D2A
                    551: #define hexdig_init_D2A        __hexdig_init_D2A
                    552: #define hexnan         __hexnan_D2A
                    553: #define hi0bits                __hi0bits_D2A
                    554: #define hi0bits_D2A    __hi0bits_D2A
                    555: #define i2b            __i2b_D2A
                    556: #define increment      __increment_D2A
                    557: #define lo0bits                __lo0bits_D2A
                    558: #define lshift         __lshift_D2A
                    559: #define match          __match_D2A
                    560: #define mult           __mult_D2A
                    561: #define multadd                __multadd_D2A
                    562: #define nrv_alloc      __nrv_alloc_D2A
                    563: #define pow5mult       __pow5mult_D2A
                    564: #define quorem         __quorem_D2A
                    565: #define ratio          __ratio_D2A
                    566: #define rshift         __rshift_D2A
                    567: #define rv_alloc       __rv_alloc_D2A
                    568: #define s2b            __s2b_D2A
                    569: #define set_ones       __set_ones_D2A
                    570: #define strcp          __strcp_D2A
                    571: #define strcp_D2A      __strcp_D2A
                    572: #define strtoIg                __strtoIg_D2A
                    573: #define sum            __sum_D2A
                    574: #define tens           __tens_D2A
                    575: #define tinytens       __tinytens_D2A
                    576: #define tinytens       __tinytens_D2A
                    577: #define trailz         __trailz_D2A
                    578: #define ulp            __ulp_D2A
1.1       kleink    579:
                    580:  extern char *dtoa_result;
                    581:  extern CONST double bigtens[], tens[], tinytens[];
                    582:  extern unsigned char hexdig[];
                    583:
1.9     ! christos  584:  extern Bigint *Balloc ANSI((size_t));
1.1       kleink    585:  extern void Bfree ANSI((Bigint*));
                    586:  extern void ULtof ANSI((ULong*, ULong*, Long, int));
                    587:  extern void ULtod ANSI((ULong*, ULong*, Long, int));
                    588:  extern void ULtodd ANSI((ULong*, ULong*, Long, int));
                    589:  extern void ULtoQ ANSI((ULong*, ULong*, Long, int));
                    590:  extern void ULtox ANSI((UShort*, ULong*, Long, int));
                    591:  extern void ULtoxL ANSI((ULong*, ULong*, Long, int));
                    592:  extern ULong any_on ANSI((Bigint*, int));
                    593:  extern double b2d ANSI((Bigint*, int*));
                    594:  extern int cmp ANSI((Bigint*, Bigint*));
                    595:  extern void copybits ANSI((ULong*, int, Bigint*));
                    596:  extern Bigint *d2b ANSI((double, int*, int*));
1.9     ! christos  597:  extern void decrement ANSI((Bigint*));
1.1       kleink    598:  extern Bigint *diff ANSI((Bigint*, Bigint*));
                    599:  extern char *dtoa ANSI((double d, int mode, int ndigits,
                    600:                        int *decpt, int *sign, char **rve));
1.9     ! christos  601:  extern char *g__fmt ANSI((char*, char*, char*, int, ULong, size_t));
1.3       kleink    602:  extern int gethex ANSI((CONST char**, CONST FPI*, Long*, Bigint**, int));
1.1       kleink    603:  extern void hexdig_init_D2A(Void);
1.3       kleink    604:  extern int hexnan ANSI((CONST char**, CONST FPI*, ULong*));
1.1       kleink    605:  extern int hi0bits_D2A ANSI((ULong));
                    606:  extern Bigint *i2b ANSI((int));
                    607:  extern Bigint *increment ANSI((Bigint*));
                    608:  extern int lo0bits ANSI((ULong*));
                    609:  extern Bigint *lshift ANSI((Bigint*, int));
1.2       kleink    610:  extern int match ANSI((CONST char**, CONST char*));
1.1       kleink    611:  extern Bigint *mult ANSI((Bigint*, Bigint*));
                    612:  extern Bigint *multadd ANSI((Bigint*, int, int));
1.6       christos  613:  extern char *nrv_alloc ANSI((CONST char*, char **, size_t));
1.1       kleink    614:  extern Bigint *pow5mult ANSI((Bigint*, int));
                    615:  extern int quorem ANSI((Bigint*, Bigint*));
                    616:  extern double ratio ANSI((Bigint*, Bigint*));
                    617:  extern void rshift ANSI((Bigint*, int));
1.6       christos  618:  extern char *rv_alloc ANSI((size_t));
1.9     ! christos  619:  extern Bigint *s2b ANSI((CONST char*, int, int, ULong, int));
1.1       kleink    620:  extern Bigint *set_ones ANSI((Bigint*, int));
                    621:  extern char *strcp ANSI((char*, const char*));
                    622:  extern int strtoIg ANSI((CONST char*, char**, FPI*, Long*, Bigint**, int*));
                    623:  extern double strtod ANSI((const char *s00, char **se));
                    624:  extern Bigint *sum ANSI((Bigint*, Bigint*));
1.3       kleink    625:  extern int trailz ANSI((CONST Bigint*));
1.9     ! christos  626: /*###626 [lint] syntax error '*' [249]%%%*/
        !           627: /*###626 [lint] incomplete or misplaced function definition [22]%%%*/
        !           628:  extern double ulp ANSI((U*));
1.1       kleink    629:
                    630: #ifdef __cplusplus
                    631: }
                    632: #endif
                    633: /*
                    634:  * NAN_WORD0 and NAN_WORD1 are only referenced in strtod.c.  Prior to
                    635:  * 20050115, they used to be hard-wired here (to 0x7ff80000 and 0,
                    636:  * respectively), but now are determined by compiling and running
                    637:  * qnan.c to generate gd_qnan.h, which specifies d_QNAN0 and d_QNAN1.
                    638:  * Formerly gdtoaimp.h recommended supplying suitable -DNAN_WORD0=...
                    639:  * and -DNAN_WORD1=...  values if necessary.  This should still work.
                    640:  * (On HP Series 700/800 machines, -DNAN_WORD0=0x7ff40000 works.)
                    641:  */
                    642: #ifdef IEEE_Arith
1.9     ! christos  643: #ifndef NO_INFNAN_CHECK
        !           644: #undef INFNAN_CHECK
        !           645: #define INFNAN_CHECK
        !           646: #endif
1.2       kleink    647: #ifdef IEEE_BIG_ENDIAN
1.1       kleink    648: #define _0 0
                    649: #define _1 1
                    650: #ifndef NAN_WORD0
                    651: #define NAN_WORD0 d_QNAN0
                    652: #endif
                    653: #ifndef NAN_WORD1
                    654: #define NAN_WORD1 d_QNAN1
                    655: #endif
                    656: #else
                    657: #define _0 1
                    658: #define _1 0
                    659: #ifndef NAN_WORD0
                    660: #define NAN_WORD0 d_QNAN1
                    661: #endif
                    662: #ifndef NAN_WORD1
                    663: #define NAN_WORD1 d_QNAN0
                    664: #endif
                    665: #endif
                    666: #else
                    667: #undef INFNAN_CHECK
                    668: #endif
                    669:
                    670: #undef SI
                    671: #ifdef Sudden_Underflow
                    672: #define SI 1
                    673: #else
                    674: #define SI 0
                    675: #endif
                    676:
                    677: #endif /* GDTOAIMP_H_INCLUDED */

CVSweb <webmaster@jp.NetBSD.org>