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