aboutsummaryrefslogtreecommitdiff
path: root/dtoa.c
diff options
context:
space:
mode:
authorlijunlong <lijunlong@openresty.com>2023-02-22 21:34:30 +0800
committerGitHub <noreply@github.com>2023-02-22 21:34:30 +0800
commit41eee7406b0f048392168515b09e7d8bdd000624 (patch)
tree987f37890364caf90a1229113b7ba80a9c8ca185 /dtoa.c
parentde93a78d3002ee72bb1c7e3a629d67e19623a4ae (diff)
downloadlua-cjson-41eee7406b0f048392168515b09e7d8bdd000624.tar.gz
lua-cjson-41eee7406b0f048392168515b09e7d8bdd000624.tar.bz2
lua-cjson-41eee7406b0f048392168515b09e7d8bdd000624.zip
Add updated netlib dtoa.c from https://netlib.sandia.gov/fp/dtoa.c
Co-authored-by: Jesper Lundgren <jesperlundgren@exosite.com>
Diffstat (limited to 'dtoa.c')
-rw-r--r--dtoa.c2863
1 files changed, 2353 insertions, 510 deletions
diff --git a/dtoa.c b/dtoa.c
index 4067e5b..8dac7b8 100644
--- a/dtoa.c
+++ b/dtoa.c
@@ -32,6 +32,7 @@
32 */ 32 */
33 33
34/* strtod for IEEE-, VAX-, and IBM-arithmetic machines. 34/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
35 * (Note that IEEE arithmetic is disabled by gcc's -ffast-math flag.)
35 * 36 *
36 * This strtod returns a nearest machine number to the input decimal 37 * This strtod returns a nearest machine number to the input decimal
37 * string (or sets errno to ERANGE). With IEEE arithmetic, ties are 38 * string (or sets errno to ERANGE). With IEEE arithmetic, ties are
@@ -102,7 +103,6 @@
102 * something other than "long long", #define Llong to be the name, 103 * something other than "long long", #define Llong to be the name,
103 * and if "unsigned Llong" does not work as an unsigned version of 104 * and if "unsigned Llong" does not work as an unsigned version of
104 * Llong, #define #ULLong to be the corresponding unsigned type. 105 * Llong, #define #ULLong to be the corresponding unsigned type.
105 * #define KR_headers for old-style C function headers.
106 * #define Bad_float_h if your system lacks a float.h or if it does not 106 * #define Bad_float_h if your system lacks a float.h or if it does not
107 * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP, 107 * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
108 * FLT_RADIX, FLT_ROUNDS, and DBL_MAX. 108 * FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
@@ -152,6 +152,25 @@
152 * probability of wasting memory, but would otherwise be harmless.) 152 * probability of wasting memory, but would otherwise be harmless.)
153 * You must also invoke freedtoa(s) to free the value s returned by 153 * You must also invoke freedtoa(s) to free the value s returned by
154 * dtoa. You may do so whether or not MULTIPLE_THREADS is #defined. 154 * dtoa. You may do so whether or not MULTIPLE_THREADS is #defined.
155
156 * When MULTIPLE_THREADS is #defined, this source file provides
157 * void set_max_dtoa_threads(unsigned int n);
158 * and expects
159 * unsigned int dtoa_get_threadno(void);
160 * to be available (possibly provided by
161 * #define dtoa_get_threadno omp_get_thread_num
162 * if OpenMP is in use or by
163 * #define dtoa_get_threadno pthread_self
164 * if Pthreads is in use), to return the current thread number.
165 * If set_max_dtoa_threads(n) was called and the current thread
166 * number is k with k < n, then calls on ACQUIRE_DTOA_LOCK(...) and
167 * FREE_DTOA_LOCK(...) are avoided; instead each thread with thread
168 * number < n has a separate copy of relevant data structures.
169 * After set_max_dtoa_threads(n), a call set_max_dtoa_threads(m)
170 * with m <= n has has no effect, but a call with m > n is honored.
171 * Such a call invokes REALLOC (assumed to be "realloc" if REALLOC
172 * is not #defined) to extend the size of the relevant array.
173
155 * #define NO_IEEE_Scale to disable new (Feb. 1997) logic in strtod that 174 * #define NO_IEEE_Scale to disable new (Feb. 1997) logic in strtod that
156 * avoids underflows on inputs whose result does not underflow. 175 * avoids underflows on inputs whose result does not underflow.
157 * If you #define NO_IEEE_Scale on a machine that uses IEEE-format 176 * If you #define NO_IEEE_Scale on a machine that uses IEEE-format
@@ -175,6 +194,11 @@
175 * inexact or when it is a numeric value rounded to +-infinity). 194 * inexact or when it is a numeric value rounded to +-infinity).
176 * #define NO_ERRNO if strtod should not assign errno = ERANGE when 195 * #define NO_ERRNO if strtod should not assign errno = ERANGE when
177 * the result overflows to +-Infinity or underflows to 0. 196 * the result overflows to +-Infinity or underflows to 0.
197 * When errno should be assigned, under seemingly rare conditions
198 * it may be necessary to define Set_errno(x) suitably, e.g., in
199 * a local errno.h, such as
200 * #include <errno.h>
201 * #define Set_errno(x) _set_errno(x)
178 * #define NO_HEX_FP to omit recognition of hexadecimal floating-point 202 * #define NO_HEX_FP to omit recognition of hexadecimal floating-point
179 * values by strtod. 203 * values by strtod.
180 * #define NO_STRTOD_BIGCOMP (on IEEE-arithmetic systems only for now) 204 * #define NO_STRTOD_BIGCOMP (on IEEE-arithmetic systems only for now)
@@ -188,15 +212,21 @@
188#include "dtoa_config.h" 212#include "dtoa_config.h"
189 213
190#ifndef Long 214#ifndef Long
191#define Long long 215#define Long int
192#endif 216#endif
193#ifndef ULong 217#ifndef ULong
194typedef unsigned Long ULong; 218typedef unsigned Long ULong;
195#endif 219#endif
196 220
197#ifdef DEBUG 221#ifdef DEBUG
222#include <assert.h>
198#include "stdio.h" 223#include "stdio.h"
199#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);} 224#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
225#define Debug(x) x
226int dtoa_stats[7]; /* strtod_{64,96,bigcomp},dtoa_{exact,64,96,bigcomp} */
227#else
228#define assert(x) /*nothing*/
229#define Debug(x) /*nothing*/
200#endif 230#endif
201 231
202#include "stdlib.h" 232#include "stdlib.h"
@@ -212,16 +242,29 @@ typedef unsigned Long ULong;
212#endif 242#endif
213#endif 243#endif
214 244
245#ifdef __cplusplus
246extern "C" {
247#endif
215#ifdef MALLOC 248#ifdef MALLOC
216#ifdef KR_headers
217extern char *MALLOC();
218#else
219extern void *MALLOC(size_t); 249extern void *MALLOC(size_t);
220#endif
221#else 250#else
222#define MALLOC malloc 251#define MALLOC malloc
223#endif 252#endif
224 253
254#ifdef REALLOC
255extern void *REALLOC(void*,size_t);
256#else
257#define REALLOC realloc
258#endif
259
260#ifndef FREE
261#define FREE free
262#endif
263
264#ifdef __cplusplus
265 }
266#endif
267
225#ifndef Omit_Private_Memory 268#ifndef Omit_Private_Memory
226#ifndef PRIVATE_MEM 269#ifndef PRIVATE_MEM
227#define PRIVATE_MEM 2304 270#define PRIVATE_MEM 2304
@@ -251,6 +294,15 @@ static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
251 294
252#include "errno.h" 295#include "errno.h"
253 296
297#ifdef NO_ERRNO /*{*/
298#undef Set_errno
299#define Set_errno(x)
300#else
301#ifndef Set_errno
302#define Set_errno(x) errno = x
303#endif
304#endif /*}*/
305
254#ifdef Bad_float_h 306#ifdef Bad_float_h
255 307
256#ifdef IEEE_Arith 308#ifdef IEEE_Arith
@@ -292,19 +344,966 @@ static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
292extern "C" { 344extern "C" {
293#endif 345#endif
294 346
295#ifndef CONST
296#ifdef KR_headers
297#define CONST /* blank */
298#else
299#define CONST const
300#endif
301#endif
302
303#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1 347#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
304Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined. 348Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
305#endif 349#endif
306 350
307typedef union { double d; ULong L[2]; } U; 351#undef USE_BF96
352
353#ifdef NO_LONG_LONG /*{{*/
354#undef ULLong
355#ifdef Just_16
356#undef Pack_32
357/* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
358 * This makes some inner loops simpler and sometimes saves work
359 * during multiplications, but it often seems to make things slightly
360 * slower. Hence the default is now to store 32 bits per Long.
361 */
362#endif
363#else /*}{ long long available */
364#ifndef Llong
365#define Llong long long
366#endif
367#ifndef ULLong
368#define ULLong unsigned Llong
369#endif
370#ifndef NO_BF96 /*{*/
371#define USE_BF96
372
373#ifdef SET_INEXACT
374#define dtoa_divmax 27
375#else
376int dtoa_divmax = 2; /* Permit experimenting: on some systems, 64-bit integer */
377 /* division is slow enough that we may sometimes want to */
378 /* avoid using it. We assume (but do not check) that */
379 /* dtoa_divmax <= 27.*/
380#endif
381
382typedef struct BF96 { /* Normalized 96-bit software floating point numbers */
383 unsigned int b0,b1,b2; /* b0 = most significant, binary point just to its left */
384 int e; /* number represented = b * 2^e, with .5 <= b < 1 */
385 } BF96;
386
387 static BF96 pten[667] = {
388 { 0xeef453d6, 0x923bd65a, 0x113faa29, -1136 },
389 { 0x9558b466, 0x1b6565f8, 0x4ac7ca59, -1132 },
390 { 0xbaaee17f, 0xa23ebf76, 0x5d79bcf0, -1129 },
391 { 0xe95a99df, 0x8ace6f53, 0xf4d82c2c, -1126 },
392 { 0x91d8a02b, 0xb6c10594, 0x79071b9b, -1122 },
393 { 0xb64ec836, 0xa47146f9, 0x9748e282, -1119 },
394 { 0xe3e27a44, 0x4d8d98b7, 0xfd1b1b23, -1116 },
395 { 0x8e6d8c6a, 0xb0787f72, 0xfe30f0f5, -1112 },
396 { 0xb208ef85, 0x5c969f4f, 0xbdbd2d33, -1109 },
397 { 0xde8b2b66, 0xb3bc4723, 0xad2c7880, -1106 },
398 { 0x8b16fb20, 0x3055ac76, 0x4c3bcb50, -1102 },
399 { 0xaddcb9e8, 0x3c6b1793, 0xdf4abe24, -1099 },
400 { 0xd953e862, 0x4b85dd78, 0xd71d6dad, -1096 },
401 { 0x87d4713d, 0x6f33aa6b, 0x8672648c, -1092 },
402 { 0xa9c98d8c, 0xcb009506, 0x680efdaf, -1089 },
403 { 0xd43bf0ef, 0xfdc0ba48, 0x0212bd1b, -1086 },
404 { 0x84a57695, 0xfe98746d, 0x014bb630, -1082 },
405 { 0xa5ced43b, 0x7e3e9188, 0x419ea3bd, -1079 },
406 { 0xcf42894a, 0x5dce35ea, 0x52064cac, -1076 },
407 { 0x818995ce, 0x7aa0e1b2, 0x7343efeb, -1072 },
408 { 0xa1ebfb42, 0x19491a1f, 0x1014ebe6, -1069 },
409 { 0xca66fa12, 0x9f9b60a6, 0xd41a26e0, -1066 },
410 { 0xfd00b897, 0x478238d0, 0x8920b098, -1063 },
411 { 0x9e20735e, 0x8cb16382, 0x55b46e5f, -1059 },
412 { 0xc5a89036, 0x2fddbc62, 0xeb2189f7, -1056 },
413 { 0xf712b443, 0xbbd52b7b, 0xa5e9ec75, -1053 },
414 { 0x9a6bb0aa, 0x55653b2d, 0x47b233c9, -1049 },
415 { 0xc1069cd4, 0xeabe89f8, 0x999ec0bb, -1046 },
416 { 0xf148440a, 0x256e2c76, 0xc00670ea, -1043 },
417 { 0x96cd2a86, 0x5764dbca, 0x38040692, -1039 },
418 { 0xbc807527, 0xed3e12bc, 0xc6050837, -1036 },
419 { 0xeba09271, 0xe88d976b, 0xf7864a44, -1033 },
420 { 0x93445b87, 0x31587ea3, 0x7ab3ee6a, -1029 },
421 { 0xb8157268, 0xfdae9e4c, 0x5960ea05, -1026 },
422 { 0xe61acf03, 0x3d1a45df, 0x6fb92487, -1023 },
423 { 0x8fd0c162, 0x06306bab, 0xa5d3b6d4, -1019 },
424 { 0xb3c4f1ba, 0x87bc8696, 0x8f48a489, -1016 },
425 { 0xe0b62e29, 0x29aba83c, 0x331acdab, -1013 },
426 { 0x8c71dcd9, 0xba0b4925, 0x9ff0c08b, -1009 },
427 { 0xaf8e5410, 0x288e1b6f, 0x07ecf0ae, -1006 },
428 { 0xdb71e914, 0x32b1a24a, 0xc9e82cd9, -1003 },
429 { 0x892731ac, 0x9faf056e, 0xbe311c08, -999 },
430 { 0xab70fe17, 0xc79ac6ca, 0x6dbd630a, -996 },
431 { 0xd64d3d9d, 0xb981787d, 0x092cbbcc, -993 },
432 { 0x85f04682, 0x93f0eb4e, 0x25bbf560, -989 },
433 { 0xa76c5823, 0x38ed2621, 0xaf2af2b8, -986 },
434 { 0xd1476e2c, 0x07286faa, 0x1af5af66, -983 },
435 { 0x82cca4db, 0x847945ca, 0x50d98d9f, -979 },
436 { 0xa37fce12, 0x6597973c, 0xe50ff107, -976 },
437 { 0xcc5fc196, 0xfefd7d0c, 0x1e53ed49, -973 },
438 { 0xff77b1fc, 0xbebcdc4f, 0x25e8e89c, -970 },
439 { 0x9faacf3d, 0xf73609b1, 0x77b19161, -966 },
440 { 0xc795830d, 0x75038c1d, 0xd59df5b9, -963 },
441 { 0xf97ae3d0, 0xd2446f25, 0x4b057328, -960 },
442 { 0x9becce62, 0x836ac577, 0x4ee367f9, -956 },
443 { 0xc2e801fb, 0x244576d5, 0x229c41f7, -953 },
444 { 0xf3a20279, 0xed56d48a, 0x6b435275, -950 },
445 { 0x9845418c, 0x345644d6, 0x830a1389, -946 },
446 { 0xbe5691ef, 0x416bd60c, 0x23cc986b, -943 },
447 { 0xedec366b, 0x11c6cb8f, 0x2cbfbe86, -940 },
448 { 0x94b3a202, 0xeb1c3f39, 0x7bf7d714, -936 },
449 { 0xb9e08a83, 0xa5e34f07, 0xdaf5ccd9, -933 },
450 { 0xe858ad24, 0x8f5c22c9, 0xd1b3400f, -930 },
451 { 0x91376c36, 0xd99995be, 0x23100809, -926 },
452 { 0xb5854744, 0x8ffffb2d, 0xabd40a0c, -923 },
453 { 0xe2e69915, 0xb3fff9f9, 0x16c90c8f, -920 },
454 { 0x8dd01fad, 0x907ffc3b, 0xae3da7d9, -916 },
455 { 0xb1442798, 0xf49ffb4a, 0x99cd11cf, -913 },
456 { 0xdd95317f, 0x31c7fa1d, 0x40405643, -910 },
457 { 0x8a7d3eef, 0x7f1cfc52, 0x482835ea, -906 },
458 { 0xad1c8eab, 0x5ee43b66, 0xda324365, -903 },
459 { 0xd863b256, 0x369d4a40, 0x90bed43e, -900 },
460 { 0x873e4f75, 0xe2224e68, 0x5a7744a6, -896 },
461 { 0xa90de353, 0x5aaae202, 0x711515d0, -893 },
462 { 0xd3515c28, 0x31559a83, 0x0d5a5b44, -890 },
463 { 0x8412d999, 0x1ed58091, 0xe858790a, -886 },
464 { 0xa5178fff, 0x668ae0b6, 0x626e974d, -883 },
465 { 0xce5d73ff, 0x402d98e3, 0xfb0a3d21, -880 },
466 { 0x80fa687f, 0x881c7f8e, 0x7ce66634, -876 },
467 { 0xa139029f, 0x6a239f72, 0x1c1fffc1, -873 },
468 { 0xc9874347, 0x44ac874e, 0xa327ffb2, -870 },
469 { 0xfbe91419, 0x15d7a922, 0x4bf1ff9f, -867 },
470 { 0x9d71ac8f, 0xada6c9b5, 0x6f773fc3, -863 },
471 { 0xc4ce17b3, 0x99107c22, 0xcb550fb4, -860 },
472 { 0xf6019da0, 0x7f549b2b, 0x7e2a53a1, -857 },
473 { 0x99c10284, 0x4f94e0fb, 0x2eda7444, -853 },
474 { 0xc0314325, 0x637a1939, 0xfa911155, -850 },
475 { 0xf03d93ee, 0xbc589f88, 0x793555ab, -847 },
476 { 0x96267c75, 0x35b763b5, 0x4bc1558b, -843 },
477 { 0xbbb01b92, 0x83253ca2, 0x9eb1aaed, -840 },
478 { 0xea9c2277, 0x23ee8bcb, 0x465e15a9, -837 },
479 { 0x92a1958a, 0x7675175f, 0x0bfacd89, -833 },
480 { 0xb749faed, 0x14125d36, 0xcef980ec, -830 },
481 { 0xe51c79a8, 0x5916f484, 0x82b7e127, -827 },
482 { 0x8f31cc09, 0x37ae58d2, 0xd1b2ecb8, -823 },
483 { 0xb2fe3f0b, 0x8599ef07, 0x861fa7e6, -820 },
484 { 0xdfbdcece, 0x67006ac9, 0x67a791e0, -817 },
485 { 0x8bd6a141, 0x006042bd, 0xe0c8bb2c, -813 },
486 { 0xaecc4991, 0x4078536d, 0x58fae9f7, -810 },
487 { 0xda7f5bf5, 0x90966848, 0xaf39a475, -807 },
488 { 0x888f9979, 0x7a5e012d, 0x6d8406c9, -803 },
489 { 0xaab37fd7, 0xd8f58178, 0xc8e5087b, -800 },
490 { 0xd5605fcd, 0xcf32e1d6, 0xfb1e4a9a, -797 },
491 { 0x855c3be0, 0xa17fcd26, 0x5cf2eea0, -793 },
492 { 0xa6b34ad8, 0xc9dfc06f, 0xf42faa48, -790 },
493 { 0xd0601d8e, 0xfc57b08b, 0xf13b94da, -787 },
494 { 0x823c1279, 0x5db6ce57, 0x76c53d08, -783 },
495 { 0xa2cb1717, 0xb52481ed, 0x54768c4b, -780 },
496 { 0xcb7ddcdd, 0xa26da268, 0xa9942f5d, -777 },
497 { 0xfe5d5415, 0x0b090b02, 0xd3f93b35, -774 },
498 { 0x9efa548d, 0x26e5a6e1, 0xc47bc501, -770 },
499 { 0xc6b8e9b0, 0x709f109a, 0x359ab641, -767 },
500 { 0xf867241c, 0x8cc6d4c0, 0xc30163d2, -764 },
501 { 0x9b407691, 0xd7fc44f8, 0x79e0de63, -760 },
502 { 0xc2109436, 0x4dfb5636, 0x985915fc, -757 },
503 { 0xf294b943, 0xe17a2bc4, 0x3e6f5b7b, -754 },
504 { 0x979cf3ca, 0x6cec5b5a, 0xa705992c, -750 },
505 { 0xbd8430bd, 0x08277231, 0x50c6ff78, -747 },
506 { 0xece53cec, 0x4a314ebd, 0xa4f8bf56, -744 },
507 { 0x940f4613, 0xae5ed136, 0x871b7795, -740 },
508 { 0xb9131798, 0x99f68584, 0x28e2557b, -737 },
509 { 0xe757dd7e, 0xc07426e5, 0x331aeada, -734 },
510 { 0x9096ea6f, 0x3848984f, 0x3ff0d2c8, -730 },
511 { 0xb4bca50b, 0x065abe63, 0x0fed077a, -727 },
512 { 0xe1ebce4d, 0xc7f16dfb, 0xd3e84959, -724 },
513 { 0x8d3360f0, 0x9cf6e4bd, 0x64712dd7, -720 },
514 { 0xb080392c, 0xc4349dec, 0xbd8d794d, -717 },
515 { 0xdca04777, 0xf541c567, 0xecf0d7a0, -714 },
516 { 0x89e42caa, 0xf9491b60, 0xf41686c4, -710 },
517 { 0xac5d37d5, 0xb79b6239, 0x311c2875, -707 },
518 { 0xd77485cb, 0x25823ac7, 0x7d633293, -704 },
519 { 0x86a8d39e, 0xf77164bc, 0xae5dff9c, -700 },
520 { 0xa8530886, 0xb54dbdeb, 0xd9f57f83, -697 },
521 { 0xd267caa8, 0x62a12d66, 0xd072df63, -694 },
522 { 0x8380dea9, 0x3da4bc60, 0x4247cb9e, -690 },
523 { 0xa4611653, 0x8d0deb78, 0x52d9be85, -687 },
524 { 0xcd795be8, 0x70516656, 0x67902e27, -684 },
525 { 0x806bd971, 0x4632dff6, 0x00ba1cd8, -680 },
526 { 0xa086cfcd, 0x97bf97f3, 0x80e8a40e, -677 },
527 { 0xc8a883c0, 0xfdaf7df0, 0x6122cd12, -674 },
528 { 0xfad2a4b1, 0x3d1b5d6c, 0x796b8057, -671 },
529 { 0x9cc3a6ee, 0xc6311a63, 0xcbe33036, -667 },
530 { 0xc3f490aa, 0x77bd60fc, 0xbedbfc44, -664 },
531 { 0xf4f1b4d5, 0x15acb93b, 0xee92fb55, -661 },
532 { 0x99171105, 0x2d8bf3c5, 0x751bdd15, -657 },
533 { 0xbf5cd546, 0x78eef0b6, 0xd262d45a, -654 },
534 { 0xef340a98, 0x172aace4, 0x86fb8971, -651 },
535 { 0x9580869f, 0x0e7aac0e, 0xd45d35e6, -647 },
536 { 0xbae0a846, 0xd2195712, 0x89748360, -644 },
537 { 0xe998d258, 0x869facd7, 0x2bd1a438, -641 },
538 { 0x91ff8377, 0x5423cc06, 0x7b6306a3, -637 },
539 { 0xb67f6455, 0x292cbf08, 0x1a3bc84c, -634 },
540 { 0xe41f3d6a, 0x7377eeca, 0x20caba5f, -631 },
541 { 0x8e938662, 0x882af53e, 0x547eb47b, -627 },
542 { 0xb23867fb, 0x2a35b28d, 0xe99e619a, -624 },
543 { 0xdec681f9, 0xf4c31f31, 0x6405fa00, -621 },
544 { 0x8b3c113c, 0x38f9f37e, 0xde83bc40, -617 },
545 { 0xae0b158b, 0x4738705e, 0x9624ab50, -614 },
546 { 0xd98ddaee, 0x19068c76, 0x3badd624, -611 },
547 { 0x87f8a8d4, 0xcfa417c9, 0xe54ca5d7, -607 },
548 { 0xa9f6d30a, 0x038d1dbc, 0x5e9fcf4c, -604 },
549 { 0xd47487cc, 0x8470652b, 0x7647c320, -601 },
550 { 0x84c8d4df, 0xd2c63f3b, 0x29ecd9f4, -597 },
551 { 0xa5fb0a17, 0xc777cf09, 0xf4681071, -594 },
552 { 0xcf79cc9d, 0xb955c2cc, 0x7182148d, -591 },
553 { 0x81ac1fe2, 0x93d599bf, 0xc6f14cd8, -587 },
554 { 0xa21727db, 0x38cb002f, 0xb8ada00e, -584 },
555 { 0xca9cf1d2, 0x06fdc03b, 0xa6d90811, -581 },
556 { 0xfd442e46, 0x88bd304a, 0x908f4a16, -578 },
557 { 0x9e4a9cec, 0x15763e2e, 0x9a598e4e, -574 },
558 { 0xc5dd4427, 0x1ad3cdba, 0x40eff1e1, -571 },
559 { 0xf7549530, 0xe188c128, 0xd12bee59, -568 },
560 { 0x9a94dd3e, 0x8cf578b9, 0x82bb74f8, -564 },
561 { 0xc13a148e, 0x3032d6e7, 0xe36a5236, -561 },
562 { 0xf18899b1, 0xbc3f8ca1, 0xdc44e6c3, -558 },
563 { 0x96f5600f, 0x15a7b7e5, 0x29ab103a, -554 },
564 { 0xbcb2b812, 0xdb11a5de, 0x7415d448, -551 },
565 { 0xebdf6617, 0x91d60f56, 0x111b495b, -548 },
566 { 0x936b9fce, 0xbb25c995, 0xcab10dd9, -544 },
567 { 0xb84687c2, 0x69ef3bfb, 0x3d5d514f, -541 },
568 { 0xe65829b3, 0x046b0afa, 0x0cb4a5a3, -538 },
569 { 0x8ff71a0f, 0xe2c2e6dc, 0x47f0e785, -534 },
570 { 0xb3f4e093, 0xdb73a093, 0x59ed2167, -531 },
571 { 0xe0f218b8, 0xd25088b8, 0x306869c1, -528 },
572 { 0x8c974f73, 0x83725573, 0x1e414218, -524 },
573 { 0xafbd2350, 0x644eeacf, 0xe5d1929e, -521 },
574 { 0xdbac6c24, 0x7d62a583, 0xdf45f746, -518 },
575 { 0x894bc396, 0xce5da772, 0x6b8bba8c, -514 },
576 { 0xab9eb47c, 0x81f5114f, 0x066ea92f, -511 },
577 { 0xd686619b, 0xa27255a2, 0xc80a537b, -508 },
578 { 0x8613fd01, 0x45877585, 0xbd06742c, -504 },
579 { 0xa798fc41, 0x96e952e7, 0x2c481138, -501 },
580 { 0xd17f3b51, 0xfca3a7a0, 0xf75a1586, -498 },
581 { 0x82ef8513, 0x3de648c4, 0x9a984d73, -494 },
582 { 0xa3ab6658, 0x0d5fdaf5, 0xc13e60d0, -491 },
583 { 0xcc963fee, 0x10b7d1b3, 0x318df905, -488 },
584 { 0xffbbcfe9, 0x94e5c61f, 0xfdf17746, -485 },
585 { 0x9fd561f1, 0xfd0f9bd3, 0xfeb6ea8b, -481 },
586 { 0xc7caba6e, 0x7c5382c8, 0xfe64a52e, -478 },
587 { 0xf9bd690a, 0x1b68637b, 0x3dfdce7a, -475 },
588 { 0x9c1661a6, 0x51213e2d, 0x06bea10c, -471 },
589 { 0xc31bfa0f, 0xe5698db8, 0x486e494f, -468 },
590 { 0xf3e2f893, 0xdec3f126, 0x5a89dba3, -465 },
591 { 0x986ddb5c, 0x6b3a76b7, 0xf8962946, -461 },
592 { 0xbe895233, 0x86091465, 0xf6bbb397, -458 },
593 { 0xee2ba6c0, 0x678b597f, 0x746aa07d, -455 },
594 { 0x94db4838, 0x40b717ef, 0xa8c2a44e, -451 },
595 { 0xba121a46, 0x50e4ddeb, 0x92f34d62, -448 },
596 { 0xe896a0d7, 0xe51e1566, 0x77b020ba, -445 },
597 { 0x915e2486, 0xef32cd60, 0x0ace1474, -441 },
598 { 0xb5b5ada8, 0xaaff80b8, 0x0d819992, -438 },
599 { 0xe3231912, 0xd5bf60e6, 0x10e1fff6, -435 },
600 { 0x8df5efab, 0xc5979c8f, 0xca8d3ffa, -431 },
601 { 0xb1736b96, 0xb6fd83b3, 0xbd308ff8, -428 },
602 { 0xddd0467c, 0x64bce4a0, 0xac7cb3f6, -425 },
603 { 0x8aa22c0d, 0xbef60ee4, 0x6bcdf07a, -421 },
604 { 0xad4ab711, 0x2eb3929d, 0x86c16c98, -418 },
605 { 0xd89d64d5, 0x7a607744, 0xe871c7bf, -415 },
606 { 0x87625f05, 0x6c7c4a8b, 0x11471cd7, -411 },
607 { 0xa93af6c6, 0xc79b5d2d, 0xd598e40d, -408 },
608 { 0xd389b478, 0x79823479, 0x4aff1d10, -405 },
609 { 0x843610cb, 0x4bf160cb, 0xcedf722a, -401 },
610 { 0xa54394fe, 0x1eedb8fe, 0xc2974eb4, -398 },
611 { 0xce947a3d, 0xa6a9273e, 0x733d2262, -395 },
612 { 0x811ccc66, 0x8829b887, 0x0806357d, -391 },
613 { 0xa163ff80, 0x2a3426a8, 0xca07c2dc, -388 },
614 { 0xc9bcff60, 0x34c13052, 0xfc89b393, -385 },
615 { 0xfc2c3f38, 0x41f17c67, 0xbbac2078, -382 },
616 { 0x9d9ba783, 0x2936edc0, 0xd54b944b, -378 },
617 { 0xc5029163, 0xf384a931, 0x0a9e795e, -375 },
618 { 0xf64335bc, 0xf065d37d, 0x4d4617b5, -372 },
619 { 0x99ea0196, 0x163fa42e, 0x504bced1, -368 },
620 { 0xc06481fb, 0x9bcf8d39, 0xe45ec286, -365 },
621 { 0xf07da27a, 0x82c37088, 0x5d767327, -362 },
622 { 0x964e858c, 0x91ba2655, 0x3a6a07f8, -358 },
623 { 0xbbe226ef, 0xb628afea, 0x890489f7, -355 },
624 { 0xeadab0ab, 0xa3b2dbe5, 0x2b45ac74, -352 },
625 { 0x92c8ae6b, 0x464fc96f, 0x3b0b8bc9, -348 },
626 { 0xb77ada06, 0x17e3bbcb, 0x09ce6ebb, -345 },
627 { 0xe5599087, 0x9ddcaabd, 0xcc420a6a, -342 },
628 { 0x8f57fa54, 0xc2a9eab6, 0x9fa94682, -338 },
629 { 0xb32df8e9, 0xf3546564, 0x47939822, -335 },
630 { 0xdff97724, 0x70297ebd, 0x59787e2b, -332 },
631 { 0x8bfbea76, 0xc619ef36, 0x57eb4edb, -328 },
632 { 0xaefae514, 0x77a06b03, 0xede62292, -325 },
633 { 0xdab99e59, 0x958885c4, 0xe95fab36, -322 },
634 { 0x88b402f7, 0xfd75539b, 0x11dbcb02, -318 },
635 { 0xaae103b5, 0xfcd2a881, 0xd652bdc2, -315 },
636 { 0xd59944a3, 0x7c0752a2, 0x4be76d33, -312 },
637 { 0x857fcae6, 0x2d8493a5, 0x6f70a440, -308 },
638 { 0xa6dfbd9f, 0xb8e5b88e, 0xcb4ccd50, -305 },
639 { 0xd097ad07, 0xa71f26b2, 0x7e2000a4, -302 },
640 { 0x825ecc24, 0xc873782f, 0x8ed40066, -298 },
641 { 0xa2f67f2d, 0xfa90563b, 0x72890080, -295 },
642 { 0xcbb41ef9, 0x79346bca, 0x4f2b40a0, -292 },
643 { 0xfea126b7, 0xd78186bc, 0xe2f610c8, -289 },
644 { 0x9f24b832, 0xe6b0f436, 0x0dd9ca7d, -285 },
645 { 0xc6ede63f, 0xa05d3143, 0x91503d1c, -282 },
646 { 0xf8a95fcf, 0x88747d94, 0x75a44c63, -279 },
647 { 0x9b69dbe1, 0xb548ce7c, 0xc986afbe, -275 },
648 { 0xc24452da, 0x229b021b, 0xfbe85bad, -272 },
649 { 0xf2d56790, 0xab41c2a2, 0xfae27299, -269 },
650 { 0x97c560ba, 0x6b0919a5, 0xdccd879f, -265 },
651 { 0xbdb6b8e9, 0x05cb600f, 0x5400e987, -262 },
652 { 0xed246723, 0x473e3813, 0x290123e9, -259 },
653 { 0x9436c076, 0x0c86e30b, 0xf9a0b672, -255 },
654 { 0xb9447093, 0x8fa89bce, 0xf808e40e, -252 },
655 { 0xe7958cb8, 0x7392c2c2, 0xb60b1d12, -249 },
656 { 0x90bd77f3, 0x483bb9b9, 0xb1c6f22b, -245 },
657 { 0xb4ecd5f0, 0x1a4aa828, 0x1e38aeb6, -242 },
658 { 0xe2280b6c, 0x20dd5232, 0x25c6da63, -239 },
659 { 0x8d590723, 0x948a535f, 0x579c487e, -235 },
660 { 0xb0af48ec, 0x79ace837, 0x2d835a9d, -232 },
661 { 0xdcdb1b27, 0x98182244, 0xf8e43145, -229 },
662 { 0x8a08f0f8, 0xbf0f156b, 0x1b8e9ecb, -225 },
663 { 0xac8b2d36, 0xeed2dac5, 0xe272467e, -222 },
664 { 0xd7adf884, 0xaa879177, 0x5b0ed81d, -219 },
665 { 0x86ccbb52, 0xea94baea, 0x98e94712, -215 },
666 { 0xa87fea27, 0xa539e9a5, 0x3f2398d7, -212 },
667 { 0xd29fe4b1, 0x8e88640e, 0x8eec7f0d, -209 },
668 { 0x83a3eeee, 0xf9153e89, 0x1953cf68, -205 },
669 { 0xa48ceaaa, 0xb75a8e2b, 0x5fa8c342, -202 },
670 { 0xcdb02555, 0x653131b6, 0x3792f412, -199 },
671 { 0x808e1755, 0x5f3ebf11, 0xe2bbd88b, -195 },
672 { 0xa0b19d2a, 0xb70e6ed6, 0x5b6aceae, -192 },
673 { 0xc8de0475, 0x64d20a8b, 0xf245825a, -189 },
674 { 0xfb158592, 0xbe068d2e, 0xeed6e2f0, -186 },
675 { 0x9ced737b, 0xb6c4183d, 0x55464dd6, -182 },
676 { 0xc428d05a, 0xa4751e4c, 0xaa97e14c, -179 },
677 { 0xf5330471, 0x4d9265df, 0xd53dd99f, -176 },
678 { 0x993fe2c6, 0xd07b7fab, 0xe546a803, -172 },
679 { 0xbf8fdb78, 0x849a5f96, 0xde985204, -169 },
680 { 0xef73d256, 0xa5c0f77c, 0x963e6685, -166 },
681 { 0x95a86376, 0x27989aad, 0xdde70013, -162 },
682 { 0xbb127c53, 0xb17ec159, 0x5560c018, -159 },
683 { 0xe9d71b68, 0x9dde71af, 0xaab8f01e, -156 },
684 { 0x92267121, 0x62ab070d, 0xcab39613, -152 },
685 { 0xb6b00d69, 0xbb55c8d1, 0x3d607b97, -149 },
686 { 0xe45c10c4, 0x2a2b3b05, 0x8cb89a7d, -146 },
687 { 0x8eb98a7a, 0x9a5b04e3, 0x77f3608e, -142 },
688 { 0xb267ed19, 0x40f1c61c, 0x55f038b2, -139 },
689 { 0xdf01e85f, 0x912e37a3, 0x6b6c46de, -136 },
690 { 0x8b61313b, 0xbabce2c6, 0x2323ac4b, -132 },
691 { 0xae397d8a, 0xa96c1b77, 0xabec975e, -129 },
692 { 0xd9c7dced, 0x53c72255, 0x96e7bd35, -126 },
693 { 0x881cea14, 0x545c7575, 0x7e50d641, -122 },
694 { 0xaa242499, 0x697392d2, 0xdde50bd1, -119 },
695 { 0xd4ad2dbf, 0xc3d07787, 0x955e4ec6, -116 },
696 { 0x84ec3c97, 0xda624ab4, 0xbd5af13b, -112 },
697 { 0xa6274bbd, 0xd0fadd61, 0xecb1ad8a, -109 },
698 { 0xcfb11ead, 0x453994ba, 0x67de18ed, -106 },
699 { 0x81ceb32c, 0x4b43fcf4, 0x80eacf94, -102 },
700 { 0xa2425ff7, 0x5e14fc31, 0xa1258379, -99 },
701 { 0xcad2f7f5, 0x359a3b3e, 0x096ee458, -96 },
702 { 0xfd87b5f2, 0x8300ca0d, 0x8bca9d6e, -93 },
703 { 0x9e74d1b7, 0x91e07e48, 0x775ea264, -89 },
704 { 0xc6120625, 0x76589dda, 0x95364afe, -86 },
705 { 0xf79687ae, 0xd3eec551, 0x3a83ddbd, -83 },
706 { 0x9abe14cd, 0x44753b52, 0xc4926a96, -79 },
707 { 0xc16d9a00, 0x95928a27, 0x75b7053c, -76 },
708 { 0xf1c90080, 0xbaf72cb1, 0x5324c68b, -73 },
709 { 0x971da050, 0x74da7bee, 0xd3f6fc16, -69 },
710 { 0xbce50864, 0x92111aea, 0x88f4bb1c, -66 },
711 { 0xec1e4a7d, 0xb69561a5, 0x2b31e9e3, -63 },
712 { 0x9392ee8e, 0x921d5d07, 0x3aff322e, -59 },
713 { 0xb877aa32, 0x36a4b449, 0x09befeb9, -56 },
714 { 0xe69594be, 0xc44de15b, 0x4c2ebe68, -53 },
715 { 0x901d7cf7, 0x3ab0acd9, 0x0f9d3701, -49 },
716 { 0xb424dc35, 0x095cd80f, 0x538484c1, -46 },
717 { 0xe12e1342, 0x4bb40e13, 0x2865a5f2, -43 },
718 { 0x8cbccc09, 0x6f5088cb, 0xf93f87b7, -39 },
719 { 0xafebff0b, 0xcb24aafe, 0xf78f69a5, -36 },
720 { 0xdbe6fece, 0xbdedd5be, 0xb573440e, -33 },
721 { 0x89705f41, 0x36b4a597, 0x31680a88, -29 },
722 { 0xabcc7711, 0x8461cefc, 0xfdc20d2b, -26 },
723 { 0xd6bf94d5, 0xe57a42bc, 0x3d329076, -23 },
724 { 0x8637bd05, 0xaf6c69b5, 0xa63f9a49, -19 },
725 { 0xa7c5ac47, 0x1b478423, 0x0fcf80dc, -16 },
726 { 0xd1b71758, 0xe219652b, 0xd3c36113, -13 },
727 { 0x83126e97, 0x8d4fdf3b, 0x645a1cac, -9 },
728 { 0xa3d70a3d, 0x70a3d70a, 0x3d70a3d7, -6 },
729 { 0xcccccccc, 0xcccccccc, 0xcccccccc, -3 },
730 { 0x80000000, 0x00000000, 0x00000000, 1 },
731 { 0xa0000000, 0x00000000, 0x00000000, 4 },
732 { 0xc8000000, 0x00000000, 0x00000000, 7 },
733 { 0xfa000000, 0x00000000, 0x00000000, 10 },
734 { 0x9c400000, 0x00000000, 0x00000000, 14 },
735 { 0xc3500000, 0x00000000, 0x00000000, 17 },
736 { 0xf4240000, 0x00000000, 0x00000000, 20 },
737 { 0x98968000, 0x00000000, 0x00000000, 24 },
738 { 0xbebc2000, 0x00000000, 0x00000000, 27 },
739 { 0xee6b2800, 0x00000000, 0x00000000, 30 },
740 { 0x9502f900, 0x00000000, 0x00000000, 34 },
741 { 0xba43b740, 0x00000000, 0x00000000, 37 },
742 { 0xe8d4a510, 0x00000000, 0x00000000, 40 },
743 { 0x9184e72a, 0x00000000, 0x00000000, 44 },
744 { 0xb5e620f4, 0x80000000, 0x00000000, 47 },
745 { 0xe35fa931, 0xa0000000, 0x00000000, 50 },
746 { 0x8e1bc9bf, 0x04000000, 0x00000000, 54 },
747 { 0xb1a2bc2e, 0xc5000000, 0x00000000, 57 },
748 { 0xde0b6b3a, 0x76400000, 0x00000000, 60 },
749 { 0x8ac72304, 0x89e80000, 0x00000000, 64 },
750 { 0xad78ebc5, 0xac620000, 0x00000000, 67 },
751 { 0xd8d726b7, 0x177a8000, 0x00000000, 70 },
752 { 0x87867832, 0x6eac9000, 0x00000000, 74 },
753 { 0xa968163f, 0x0a57b400, 0x00000000, 77 },
754 { 0xd3c21bce, 0xcceda100, 0x00000000, 80 },
755 { 0x84595161, 0x401484a0, 0x00000000, 84 },
756 { 0xa56fa5b9, 0x9019a5c8, 0x00000000, 87 },
757 { 0xcecb8f27, 0xf4200f3a, 0x00000000, 90 },
758 { 0x813f3978, 0xf8940984, 0x40000000, 94 },
759 { 0xa18f07d7, 0x36b90be5, 0x50000000, 97 },
760 { 0xc9f2c9cd, 0x04674ede, 0xa4000000, 100 },
761 { 0xfc6f7c40, 0x45812296, 0x4d000000, 103 },
762 { 0x9dc5ada8, 0x2b70b59d, 0xf0200000, 107 },
763 { 0xc5371912, 0x364ce305, 0x6c280000, 110 },
764 { 0xf684df56, 0xc3e01bc6, 0xc7320000, 113 },
765 { 0x9a130b96, 0x3a6c115c, 0x3c7f4000, 117 },
766 { 0xc097ce7b, 0xc90715b3, 0x4b9f1000, 120 },
767 { 0xf0bdc21a, 0xbb48db20, 0x1e86d400, 123 },
768 { 0x96769950, 0xb50d88f4, 0x13144480, 127 },
769 { 0xbc143fa4, 0xe250eb31, 0x17d955a0, 130 },
770 { 0xeb194f8e, 0x1ae525fd, 0x5dcfab08, 133 },
771 { 0x92efd1b8, 0xd0cf37be, 0x5aa1cae5, 137 },
772 { 0xb7abc627, 0x050305ad, 0xf14a3d9e, 140 },
773 { 0xe596b7b0, 0xc643c719, 0x6d9ccd05, 143 },
774 { 0x8f7e32ce, 0x7bea5c6f, 0xe4820023, 147 },
775 { 0xb35dbf82, 0x1ae4f38b, 0xdda2802c, 150 },
776 { 0xe0352f62, 0xa19e306e, 0xd50b2037, 153 },
777 { 0x8c213d9d, 0xa502de45, 0x4526f422, 157 },
778 { 0xaf298d05, 0x0e4395d6, 0x9670b12b, 160 },
779 { 0xdaf3f046, 0x51d47b4c, 0x3c0cdd76, 163 },
780 { 0x88d8762b, 0xf324cd0f, 0xa5880a69, 167 },
781 { 0xab0e93b6, 0xefee0053, 0x8eea0d04, 170 },
782 { 0xd5d238a4, 0xabe98068, 0x72a49045, 173 },
783 { 0x85a36366, 0xeb71f041, 0x47a6da2b, 177 },
784 { 0xa70c3c40, 0xa64e6c51, 0x999090b6, 180 },
785 { 0xd0cf4b50, 0xcfe20765, 0xfff4b4e3, 183 },
786 { 0x82818f12, 0x81ed449f, 0xbff8f10e, 187 },
787 { 0xa321f2d7, 0x226895c7, 0xaff72d52, 190 },
788 { 0xcbea6f8c, 0xeb02bb39, 0x9bf4f8a6, 193 },
789 { 0xfee50b70, 0x25c36a08, 0x02f236d0, 196 },
790 { 0x9f4f2726, 0x179a2245, 0x01d76242, 200 },
791 { 0xc722f0ef, 0x9d80aad6, 0x424d3ad2, 203 },
792 { 0xf8ebad2b, 0x84e0d58b, 0xd2e08987, 206 },
793 { 0x9b934c3b, 0x330c8577, 0x63cc55f4, 210 },
794 { 0xc2781f49, 0xffcfa6d5, 0x3cbf6b71, 213 },
795 { 0xf316271c, 0x7fc3908a, 0x8bef464e, 216 },
796 { 0x97edd871, 0xcfda3a56, 0x97758bf0, 220 },
797 { 0xbde94e8e, 0x43d0c8ec, 0x3d52eeed, 223 },
798 { 0xed63a231, 0xd4c4fb27, 0x4ca7aaa8, 226 },
799 { 0x945e455f, 0x24fb1cf8, 0x8fe8caa9, 230 },
800 { 0xb975d6b6, 0xee39e436, 0xb3e2fd53, 233 },
801 { 0xe7d34c64, 0xa9c85d44, 0x60dbbca8, 236 },
802 { 0x90e40fbe, 0xea1d3a4a, 0xbc8955e9, 240 },
803 { 0xb51d13ae, 0xa4a488dd, 0x6babab63, 243 },
804 { 0xe264589a, 0x4dcdab14, 0xc696963c, 246 },
805 { 0x8d7eb760, 0x70a08aec, 0xfc1e1de5, 250 },
806 { 0xb0de6538, 0x8cc8ada8, 0x3b25a55f, 253 },
807 { 0xdd15fe86, 0xaffad912, 0x49ef0eb7, 256 },
808 { 0x8a2dbf14, 0x2dfcc7ab, 0x6e356932, 260 },
809 { 0xacb92ed9, 0x397bf996, 0x49c2c37f, 263 },
810 { 0xd7e77a8f, 0x87daf7fb, 0xdc33745e, 266 },
811 { 0x86f0ac99, 0xb4e8dafd, 0x69a028bb, 270 },
812 { 0xa8acd7c0, 0x222311bc, 0xc40832ea, 273 },
813 { 0xd2d80db0, 0x2aabd62b, 0xf50a3fa4, 276 },
814 { 0x83c7088e, 0x1aab65db, 0x792667c6, 280 },
815 { 0xa4b8cab1, 0xa1563f52, 0x577001b8, 283 },
816 { 0xcde6fd5e, 0x09abcf26, 0xed4c0226, 286 },
817 { 0x80b05e5a, 0xc60b6178, 0x544f8158, 290 },
818 { 0xa0dc75f1, 0x778e39d6, 0x696361ae, 293 },
819 { 0xc913936d, 0xd571c84c, 0x03bc3a19, 296 },
820 { 0xfb587849, 0x4ace3a5f, 0x04ab48a0, 299 },
821 { 0x9d174b2d, 0xcec0e47b, 0x62eb0d64, 303 },
822 { 0xc45d1df9, 0x42711d9a, 0x3ba5d0bd, 306 },
823 { 0xf5746577, 0x930d6500, 0xca8f44ec, 309 },
824 { 0x9968bf6a, 0xbbe85f20, 0x7e998b13, 313 },
825 { 0xbfc2ef45, 0x6ae276e8, 0x9e3fedd8, 316 },
826 { 0xefb3ab16, 0xc59b14a2, 0xc5cfe94e, 319 },
827 { 0x95d04aee, 0x3b80ece5, 0xbba1f1d1, 323 },
828 { 0xbb445da9, 0xca61281f, 0x2a8a6e45, 326 },
829 { 0xea157514, 0x3cf97226, 0xf52d09d7, 329 },
830 { 0x924d692c, 0xa61be758, 0x593c2626, 333 },
831 { 0xb6e0c377, 0xcfa2e12e, 0x6f8b2fb0, 336 },
832 { 0xe498f455, 0xc38b997a, 0x0b6dfb9c, 339 },
833 { 0x8edf98b5, 0x9a373fec, 0x4724bd41, 343 },
834 { 0xb2977ee3, 0x00c50fe7, 0x58edec91, 346 },
835 { 0xdf3d5e9b, 0xc0f653e1, 0x2f2967b6, 349 },
836 { 0x8b865b21, 0x5899f46c, 0xbd79e0d2, 353 },
837 { 0xae67f1e9, 0xaec07187, 0xecd85906, 356 },
838 { 0xda01ee64, 0x1a708de9, 0xe80e6f48, 359 },
839 { 0x884134fe, 0x908658b2, 0x3109058d, 363 },
840 { 0xaa51823e, 0x34a7eede, 0xbd4b46f0, 366 },
841 { 0xd4e5e2cd, 0xc1d1ea96, 0x6c9e18ac, 369 },
842 { 0x850fadc0, 0x9923329e, 0x03e2cf6b, 373 },
843 { 0xa6539930, 0xbf6bff45, 0x84db8346, 376 },
844 { 0xcfe87f7c, 0xef46ff16, 0xe6126418, 379 },
845 { 0x81f14fae, 0x158c5f6e, 0x4fcb7e8f, 383 },
846 { 0xa26da399, 0x9aef7749, 0xe3be5e33, 386 },
847 { 0xcb090c80, 0x01ab551c, 0x5cadf5bf, 389 },
848 { 0xfdcb4fa0, 0x02162a63, 0x73d9732f, 392 },
849 { 0x9e9f11c4, 0x014dda7e, 0x2867e7fd, 396 },
850 { 0xc646d635, 0x01a1511d, 0xb281e1fd, 399 },
851 { 0xf7d88bc2, 0x4209a565, 0x1f225a7c, 402 },
852 { 0x9ae75759, 0x6946075f, 0x3375788d, 406 },
853 { 0xc1a12d2f, 0xc3978937, 0x0052d6b1, 409 },
854 { 0xf209787b, 0xb47d6b84, 0xc0678c5d, 412 },
855 { 0x9745eb4d, 0x50ce6332, 0xf840b7ba, 416 },
856 { 0xbd176620, 0xa501fbff, 0xb650e5a9, 419 },
857 { 0xec5d3fa8, 0xce427aff, 0xa3e51f13, 422 },
858 { 0x93ba47c9, 0x80e98cdf, 0xc66f336c, 426 },
859 { 0xb8a8d9bb, 0xe123f017, 0xb80b0047, 429 },
860 { 0xe6d3102a, 0xd96cec1d, 0xa60dc059, 432 },
861 { 0x9043ea1a, 0xc7e41392, 0x87c89837, 436 },
862 { 0xb454e4a1, 0x79dd1877, 0x29babe45, 439 },
863 { 0xe16a1dc9, 0xd8545e94, 0xf4296dd6, 442 },
864 { 0x8ce2529e, 0x2734bb1d, 0x1899e4a6, 446 },
865 { 0xb01ae745, 0xb101e9e4, 0x5ec05dcf, 449 },
866 { 0xdc21a117, 0x1d42645d, 0x76707543, 452 },
867 { 0x899504ae, 0x72497eba, 0x6a06494a, 456 },
868 { 0xabfa45da, 0x0edbde69, 0x0487db9d, 459 },
869 { 0xd6f8d750, 0x9292d603, 0x45a9d284, 462 },
870 { 0x865b8692, 0x5b9bc5c2, 0x0b8a2392, 466 },
871 { 0xa7f26836, 0xf282b732, 0x8e6cac77, 469 },
872 { 0xd1ef0244, 0xaf2364ff, 0x3207d795, 472 },
873 { 0x8335616a, 0xed761f1f, 0x7f44e6bd, 476 },
874 { 0xa402b9c5, 0xa8d3a6e7, 0x5f16206c, 479 },
875 { 0xcd036837, 0x130890a1, 0x36dba887, 482 },
876 { 0x80222122, 0x6be55a64, 0xc2494954, 486 },
877 { 0xa02aa96b, 0x06deb0fd, 0xf2db9baa, 489 },
878 { 0xc83553c5, 0xc8965d3d, 0x6f928294, 492 },
879 { 0xfa42a8b7, 0x3abbf48c, 0xcb772339, 495 },
880 { 0x9c69a972, 0x84b578d7, 0xff2a7604, 499 },
881 { 0xc38413cf, 0x25e2d70d, 0xfef51385, 502 },
882 { 0xf46518c2, 0xef5b8cd1, 0x7eb25866, 505 },
883 { 0x98bf2f79, 0xd5993802, 0xef2f773f, 509 },
884 { 0xbeeefb58, 0x4aff8603, 0xaafb550f, 512 },
885 { 0xeeaaba2e, 0x5dbf6784, 0x95ba2a53, 515 },
886 { 0x952ab45c, 0xfa97a0b2, 0xdd945a74, 519 },
887 { 0xba756174, 0x393d88df, 0x94f97111, 522 },
888 { 0xe912b9d1, 0x478ceb17, 0x7a37cd56, 525 },
889 { 0x91abb422, 0xccb812ee, 0xac62e055, 529 },
890 { 0xb616a12b, 0x7fe617aa, 0x577b986b, 532 },
891 { 0xe39c4976, 0x5fdf9d94, 0xed5a7e85, 535 },
892 { 0x8e41ade9, 0xfbebc27d, 0x14588f13, 539 },
893 { 0xb1d21964, 0x7ae6b31c, 0x596eb2d8, 542 },
894 { 0xde469fbd, 0x99a05fe3, 0x6fca5f8e, 545 },
895 { 0x8aec23d6, 0x80043bee, 0x25de7bb9, 549 },
896 { 0xada72ccc, 0x20054ae9, 0xaf561aa7, 552 },
897 { 0xd910f7ff, 0x28069da4, 0x1b2ba151, 555 },
898 { 0x87aa9aff, 0x79042286, 0x90fb44d2, 559 },
899 { 0xa99541bf, 0x57452b28, 0x353a1607, 562 },
900 { 0xd3fa922f, 0x2d1675f2, 0x42889b89, 565 },
901 { 0x847c9b5d, 0x7c2e09b7, 0x69956135, 569 },
902 { 0xa59bc234, 0xdb398c25, 0x43fab983, 572 },
903 { 0xcf02b2c2, 0x1207ef2e, 0x94f967e4, 575 },
904 { 0x8161afb9, 0x4b44f57d, 0x1d1be0ee, 579 },
905 { 0xa1ba1ba7, 0x9e1632dc, 0x6462d92a, 582 },
906 { 0xca28a291, 0x859bbf93, 0x7d7b8f75, 585 },
907 { 0xfcb2cb35, 0xe702af78, 0x5cda7352, 588 },
908 { 0x9defbf01, 0xb061adab, 0x3a088813, 592 },
909 { 0xc56baec2, 0x1c7a1916, 0x088aaa18, 595 },
910 { 0xf6c69a72, 0xa3989f5b, 0x8aad549e, 598 },
911 { 0x9a3c2087, 0xa63f6399, 0x36ac54e2, 602 },
912 { 0xc0cb28a9, 0x8fcf3c7f, 0x84576a1b, 605 },
913 { 0xf0fdf2d3, 0xf3c30b9f, 0x656d44a2, 608 },
914 { 0x969eb7c4, 0x7859e743, 0x9f644ae5, 612 },
915 { 0xbc4665b5, 0x96706114, 0x873d5d9f, 615 },
916 { 0xeb57ff22, 0xfc0c7959, 0xa90cb506, 618 },
917 { 0x9316ff75, 0xdd87cbd8, 0x09a7f124, 622 },
918 { 0xb7dcbf53, 0x54e9bece, 0x0c11ed6d, 625 },
919 { 0xe5d3ef28, 0x2a242e81, 0x8f1668c8, 628 },
920 { 0x8fa47579, 0x1a569d10, 0xf96e017d, 632 },
921 { 0xb38d92d7, 0x60ec4455, 0x37c981dc, 635 },
922 { 0xe070f78d, 0x3927556a, 0x85bbe253, 638 },
923 { 0x8c469ab8, 0x43b89562, 0x93956d74, 642 },
924 { 0xaf584166, 0x54a6babb, 0x387ac8d1, 645 },
925 { 0xdb2e51bf, 0xe9d0696a, 0x06997b05, 648 },
926 { 0x88fcf317, 0xf22241e2, 0x441fece3, 652 },
927 { 0xab3c2fdd, 0xeeaad25a, 0xd527e81c, 655 },
928 { 0xd60b3bd5, 0x6a5586f1, 0x8a71e223, 658 },
929 { 0x85c70565, 0x62757456, 0xf6872d56, 662 },
930 { 0xa738c6be, 0xbb12d16c, 0xb428f8ac, 665 },
931 { 0xd106f86e, 0x69d785c7, 0xe13336d7, 668 },
932 { 0x82a45b45, 0x0226b39c, 0xecc00246, 672 },
933 { 0xa34d7216, 0x42b06084, 0x27f002d7, 675 },
934 { 0xcc20ce9b, 0xd35c78a5, 0x31ec038d, 678 },
935 { 0xff290242, 0xc83396ce, 0x7e670471, 681 },
936 { 0x9f79a169, 0xbd203e41, 0x0f0062c6, 685 },
937 { 0xc75809c4, 0x2c684dd1, 0x52c07b78, 688 },
938 { 0xf92e0c35, 0x37826145, 0xa7709a56, 691 },
939 { 0x9bbcc7a1, 0x42b17ccb, 0x88a66076, 695 },
940 { 0xc2abf989, 0x935ddbfe, 0x6acff893, 698 },
941 { 0xf356f7eb, 0xf83552fe, 0x0583f6b8, 701 },
942 { 0x98165af3, 0x7b2153de, 0xc3727a33, 705 },
943 { 0xbe1bf1b0, 0x59e9a8d6, 0x744f18c0, 708 },
944 { 0xeda2ee1c, 0x7064130c, 0x1162def0, 711 },
945 { 0x9485d4d1, 0xc63e8be7, 0x8addcb56, 715 },
946 { 0xb9a74a06, 0x37ce2ee1, 0x6d953e2b, 718 },
947 { 0xe8111c87, 0xc5c1ba99, 0xc8fa8db6, 721 },
948 { 0x910ab1d4, 0xdb9914a0, 0x1d9c9892, 725 },
949 { 0xb54d5e4a, 0x127f59c8, 0x2503beb6, 728 },
950 { 0xe2a0b5dc, 0x971f303a, 0x2e44ae64, 731 },
951 { 0x8da471a9, 0xde737e24, 0x5ceaecfe, 735 },
952 { 0xb10d8e14, 0x56105dad, 0x7425a83e, 738 },
953 { 0xdd50f199, 0x6b947518, 0xd12f124e, 741 },
954 { 0x8a5296ff, 0xe33cc92f, 0x82bd6b70, 745 },
955 { 0xace73cbf, 0xdc0bfb7b, 0x636cc64d, 748 },
956 { 0xd8210bef, 0xd30efa5a, 0x3c47f7e0, 751 },
957 { 0x8714a775, 0xe3e95c78, 0x65acfaec, 755 },
958 { 0xa8d9d153, 0x5ce3b396, 0x7f1839a7, 758 },
959 { 0xd31045a8, 0x341ca07c, 0x1ede4811, 761 },
960 { 0x83ea2b89, 0x2091e44d, 0x934aed0a, 765 },
961 { 0xa4e4b66b, 0x68b65d60, 0xf81da84d, 768 },
962 { 0xce1de406, 0x42e3f4b9, 0x36251260, 771 },
963 { 0x80d2ae83, 0xe9ce78f3, 0xc1d72b7c, 775 },
964 { 0xa1075a24, 0xe4421730, 0xb24cf65b, 778 },
965 { 0xc94930ae, 0x1d529cfc, 0xdee033f2, 781 },
966 { 0xfb9b7cd9, 0xa4a7443c, 0x169840ef, 784 },
967 { 0x9d412e08, 0x06e88aa5, 0x8e1f2895, 788 },
968 { 0xc491798a, 0x08a2ad4e, 0xf1a6f2ba, 791 },
969 { 0xf5b5d7ec, 0x8acb58a2, 0xae10af69, 794 },
970 { 0x9991a6f3, 0xd6bf1765, 0xacca6da1, 798 },
971 { 0xbff610b0, 0xcc6edd3f, 0x17fd090a, 801 },
972 { 0xeff394dc, 0xff8a948e, 0xddfc4b4c, 804 },
973 { 0x95f83d0a, 0x1fb69cd9, 0x4abdaf10, 808 },
974 { 0xbb764c4c, 0xa7a4440f, 0x9d6d1ad4, 811 },
975 { 0xea53df5f, 0xd18d5513, 0x84c86189, 814 },
976 { 0x92746b9b, 0xe2f8552c, 0x32fd3cf5, 818 },
977 { 0xb7118682, 0xdbb66a77, 0x3fbc8c33, 821 },
978 { 0xe4d5e823, 0x92a40515, 0x0fabaf3f, 824 },
979 { 0x8f05b116, 0x3ba6832d, 0x29cb4d87, 828 },
980 { 0xb2c71d5b, 0xca9023f8, 0x743e20e9, 831 },
981 { 0xdf78e4b2, 0xbd342cf6, 0x914da924, 834 },
982 { 0x8bab8eef, 0xb6409c1a, 0x1ad089b6, 838 },
983 { 0xae9672ab, 0xa3d0c320, 0xa184ac24, 841 },
984 { 0xda3c0f56, 0x8cc4f3e8, 0xc9e5d72d, 844 },
985 { 0x88658996, 0x17fb1871, 0x7e2fa67c, 848 },
986 { 0xaa7eebfb, 0x9df9de8d, 0xddbb901b, 851 },
987 { 0xd51ea6fa, 0x85785631, 0x552a7422, 854 },
988 { 0x8533285c, 0x936b35de, 0xd53a8895, 858 },
989 { 0xa67ff273, 0xb8460356, 0x8a892aba, 861 },
990 { 0xd01fef10, 0xa657842c, 0x2d2b7569, 864 },
991 { 0x8213f56a, 0x67f6b29b, 0x9c3b2962, 868 },
992 { 0xa298f2c5, 0x01f45f42, 0x8349f3ba, 871 },
993 { 0xcb3f2f76, 0x42717713, 0x241c70a9, 874 },
994 { 0xfe0efb53, 0xd30dd4d7, 0xed238cd3, 877 },
995 { 0x9ec95d14, 0x63e8a506, 0xf4363804, 881 },
996 { 0xc67bb459, 0x7ce2ce48, 0xb143c605, 884 },
997 { 0xf81aa16f, 0xdc1b81da, 0xdd94b786, 887 },
998 { 0x9b10a4e5, 0xe9913128, 0xca7cf2b4, 891 },
999 { 0xc1d4ce1f, 0x63f57d72, 0xfd1c2f61, 894 },
1000 { 0xf24a01a7, 0x3cf2dccf, 0xbc633b39, 897 },
1001 { 0x976e4108, 0x8617ca01, 0xd5be0503, 901 },
1002 { 0xbd49d14a, 0xa79dbc82, 0x4b2d8644, 904 },
1003 { 0xec9c459d, 0x51852ba2, 0xddf8e7d6, 907 },
1004 { 0x93e1ab82, 0x52f33b45, 0xcabb90e5, 911 },
1005 { 0xb8da1662, 0xe7b00a17, 0x3d6a751f, 914 },
1006 { 0xe7109bfb, 0xa19c0c9d, 0x0cc51267, 917 },
1007 { 0x906a617d, 0x450187e2, 0x27fb2b80, 921 },
1008 { 0xb484f9dc, 0x9641e9da, 0xb1f9f660, 924 },
1009 { 0xe1a63853, 0xbbd26451, 0x5e7873f8, 927 },
1010 { 0x8d07e334, 0x55637eb2, 0xdb0b487b, 931 },
1011 { 0xb049dc01, 0x6abc5e5f, 0x91ce1a9a, 934 },
1012 { 0xdc5c5301, 0xc56b75f7, 0x7641a140, 937 },
1013 { 0x89b9b3e1, 0x1b6329ba, 0xa9e904c8, 941 },
1014 { 0xac2820d9, 0x623bf429, 0x546345fa, 944 },
1015 { 0xd732290f, 0xbacaf133, 0xa97c1779, 947 },
1016 { 0x867f59a9, 0xd4bed6c0, 0x49ed8eab, 951 },
1017 { 0xa81f3014, 0x49ee8c70, 0x5c68f256, 954 },
1018 { 0xd226fc19, 0x5c6a2f8c, 0x73832eec, 957 },
1019 { 0x83585d8f, 0xd9c25db7, 0xc831fd53, 961 },
1020 { 0xa42e74f3, 0xd032f525, 0xba3e7ca8, 964 },
1021 { 0xcd3a1230, 0xc43fb26f, 0x28ce1bd2, 967 },
1022 { 0x80444b5e, 0x7aa7cf85, 0x7980d163, 971 },
1023 { 0xa0555e36, 0x1951c366, 0xd7e105bc, 974 },
1024 { 0xc86ab5c3, 0x9fa63440, 0x8dd9472b, 977 },
1025 { 0xfa856334, 0x878fc150, 0xb14f98f6, 980 },
1026 { 0x9c935e00, 0xd4b9d8d2, 0x6ed1bf9a, 984 },
1027 { 0xc3b83581, 0x09e84f07, 0x0a862f80, 987 },
1028 { 0xf4a642e1, 0x4c6262c8, 0xcd27bb61, 990 },
1029 { 0x98e7e9cc, 0xcfbd7dbd, 0x8038d51c, 994 },
1030 { 0xbf21e440, 0x03acdd2c, 0xe0470a63, 997 },
1031 { 0xeeea5d50, 0x04981478, 0x1858ccfc, 1000 },
1032 { 0x95527a52, 0x02df0ccb, 0x0f37801e, 1004 },
1033 { 0xbaa718e6, 0x8396cffd, 0xd3056025, 1007 },
1034 { 0xe950df20, 0x247c83fd, 0x47c6b82e, 1010 },
1035 { 0x91d28b74, 0x16cdd27e, 0x4cdc331d, 1014 },
1036 { 0xb6472e51, 0x1c81471d, 0xe0133fe4, 1017 },
1037 { 0xe3d8f9e5, 0x63a198e5, 0x58180fdd, 1020 },
1038 { 0x8e679c2f, 0x5e44ff8f, 0x570f09ea, 1024 },
1039 { 0xb201833b, 0x35d63f73, 0x2cd2cc65, 1027 },
1040 { 0xde81e40a, 0x034bcf4f, 0xf8077f7e, 1030 },
1041 { 0x8b112e86, 0x420f6191, 0xfb04afaf, 1034 },
1042 { 0xadd57a27, 0xd29339f6, 0x79c5db9a, 1037 },
1043 { 0xd94ad8b1, 0xc7380874, 0x18375281, 1040 },
1044 { 0x87cec76f, 0x1c830548, 0x8f229391, 1044 },
1045 { 0xa9c2794a, 0xe3a3c69a, 0xb2eb3875, 1047 },
1046 { 0xd433179d, 0x9c8cb841, 0x5fa60692, 1050 },
1047 { 0x849feec2, 0x81d7f328, 0xdbc7c41b, 1054 },
1048 { 0xa5c7ea73, 0x224deff3, 0x12b9b522, 1057 },
1049 { 0xcf39e50f, 0xeae16bef, 0xd768226b, 1060 },
1050 { 0x81842f29, 0xf2cce375, 0xe6a11583, 1064 },
1051 { 0xa1e53af4, 0x6f801c53, 0x60495ae3, 1067 },
1052 { 0xca5e89b1, 0x8b602368, 0x385bb19c, 1070 },
1053 { 0xfcf62c1d, 0xee382c42, 0x46729e03, 1073 },
1054 { 0x9e19db92, 0xb4e31ba9, 0x6c07a2c2, 1077 }
1055 };
1056 static short int Lhint[2098] = {
1057 /*18,*/19, 19, 19, 19, 20, 20, 20, 21, 21,
1058 21, 22, 22, 22, 23, 23, 23, 23, 24, 24,
1059 24, 25, 25, 25, 26, 26, 26, 26, 27, 27,
1060 27, 28, 28, 28, 29, 29, 29, 29, 30, 30,
1061 30, 31, 31, 31, 32, 32, 32, 32, 33, 33,
1062 33, 34, 34, 34, 35, 35, 35, 35, 36, 36,
1063 36, 37, 37, 37, 38, 38, 38, 38, 39, 39,
1064 39, 40, 40, 40, 41, 41, 41, 41, 42, 42,
1065 42, 43, 43, 43, 44, 44, 44, 44, 45, 45,
1066 45, 46, 46, 46, 47, 47, 47, 47, 48, 48,
1067 48, 49, 49, 49, 50, 50, 50, 51, 51, 51,
1068 51, 52, 52, 52, 53, 53, 53, 54, 54, 54,
1069 54, 55, 55, 55, 56, 56, 56, 57, 57, 57,
1070 57, 58, 58, 58, 59, 59, 59, 60, 60, 60,
1071 60, 61, 61, 61, 62, 62, 62, 63, 63, 63,
1072 63, 64, 64, 64, 65, 65, 65, 66, 66, 66,
1073 66, 67, 67, 67, 68, 68, 68, 69, 69, 69,
1074 69, 70, 70, 70, 71, 71, 71, 72, 72, 72,
1075 72, 73, 73, 73, 74, 74, 74, 75, 75, 75,
1076 75, 76, 76, 76, 77, 77, 77, 78, 78, 78,
1077 78, 79, 79, 79, 80, 80, 80, 81, 81, 81,
1078 82, 82, 82, 82, 83, 83, 83, 84, 84, 84,
1079 85, 85, 85, 85, 86, 86, 86, 87, 87, 87,
1080 88, 88, 88, 88, 89, 89, 89, 90, 90, 90,
1081 91, 91, 91, 91, 92, 92, 92, 93, 93, 93,
1082 94, 94, 94, 94, 95, 95, 95, 96, 96, 96,
1083 97, 97, 97, 97, 98, 98, 98, 99, 99, 99,
1084 100, 100, 100, 100, 101, 101, 101, 102, 102, 102,
1085 103, 103, 103, 103, 104, 104, 104, 105, 105, 105,
1086 106, 106, 106, 106, 107, 107, 107, 108, 108, 108,
1087 109, 109, 109, 110, 110, 110, 110, 111, 111, 111,
1088 112, 112, 112, 113, 113, 113, 113, 114, 114, 114,
1089 115, 115, 115, 116, 116, 116, 116, 117, 117, 117,
1090 118, 118, 118, 119, 119, 119, 119, 120, 120, 120,
1091 121, 121, 121, 122, 122, 122, 122, 123, 123, 123,
1092 124, 124, 124, 125, 125, 125, 125, 126, 126, 126,
1093 127, 127, 127, 128, 128, 128, 128, 129, 129, 129,
1094 130, 130, 130, 131, 131, 131, 131, 132, 132, 132,
1095 133, 133, 133, 134, 134, 134, 134, 135, 135, 135,
1096 136, 136, 136, 137, 137, 137, 137, 138, 138, 138,
1097 139, 139, 139, 140, 140, 140, 141, 141, 141, 141,
1098 142, 142, 142, 143, 143, 143, 144, 144, 144, 144,
1099 145, 145, 145, 146, 146, 146, 147, 147, 147, 147,
1100 148, 148, 148, 149, 149, 149, 150, 150, 150, 150,
1101 151, 151, 151, 152, 152, 152, 153, 153, 153, 153,
1102 154, 154, 154, 155, 155, 155, 156, 156, 156, 156,
1103 157, 157, 157, 158, 158, 158, 159, 159, 159, 159,
1104 160, 160, 160, 161, 161, 161, 162, 162, 162, 162,
1105 163, 163, 163, 164, 164, 164, 165, 165, 165, 165,
1106 166, 166, 166, 167, 167, 167, 168, 168, 168, 169,
1107 169, 169, 169, 170, 170, 170, 171, 171, 171, 172,
1108 172, 172, 172, 173, 173, 173, 174, 174, 174, 175,
1109 175, 175, 175, 176, 176, 176, 177, 177, 177, 178,
1110 178, 178, 178, 179, 179, 179, 180, 180, 180, 181,
1111 181, 181, 181, 182, 182, 182, 183, 183, 183, 184,
1112 184, 184, 184, 185, 185, 185, 186, 186, 186, 187,
1113 187, 187, 187, 188, 188, 188, 189, 189, 189, 190,
1114 190, 190, 190, 191, 191, 191, 192, 192, 192, 193,
1115 193, 193, 193, 194, 194, 194, 195, 195, 195, 196,
1116 196, 196, 197, 197, 197, 197, 198, 198, 198, 199,
1117 199, 199, 200, 200, 200, 200, 201, 201, 201, 202,
1118 202, 202, 203, 203, 203, 203, 204, 204, 204, 205,
1119 205, 205, 206, 206, 206, 206, 207, 207, 207, 208,
1120 208, 208, 209, 209, 209, 209, 210, 210, 210, 211,
1121 211, 211, 212, 212, 212, 212, 213, 213, 213, 214,
1122 214, 214, 215, 215, 215, 215, 216, 216, 216, 217,
1123 217, 217, 218, 218, 218, 218, 219, 219, 219, 220,
1124 220, 220, 221, 221, 221, 221, 222, 222, 222, 223,
1125 223, 223, 224, 224, 224, 224, 225, 225, 225, 226,
1126 226, 226, 227, 227, 227, 228, 228, 228, 228, 229,
1127 229, 229, 230, 230, 230, 231, 231, 231, 231, 232,
1128 232, 232, 233, 233, 233, 234, 234, 234, 234, 235,
1129 235, 235, 236, 236, 236, 237, 237, 237, 237, 238,
1130 238, 238, 239, 239, 239, 240, 240, 240, 240, 241,
1131 241, 241, 242, 242, 242, 243, 243, 243, 243, 244,
1132 244, 244, 245, 245, 245, 246, 246, 246, 246, 247,
1133 247, 247, 248, 248, 248, 249, 249, 249, 249, 250,
1134 250, 250, 251, 251, 251, 252, 252, 252, 252, 253,
1135 253, 253, 254, 254, 254, 255, 255, 255, 256, 256,
1136 256, 256, 257, 257, 257, 258, 258, 258, 259, 259,
1137 259, 259, 260, 260, 260, 261, 261, 261, 262, 262,
1138 262, 262, 263, 263, 263, 264, 264, 264, 265, 265,
1139 265, 265, 266, 266, 266, 267, 267, 267, 268, 268,
1140 268, 268, 269, 269, 269, 270, 270, 270, 271, 271,
1141 271, 271, 272, 272, 272, 273, 273, 273, 274, 274,
1142 274, 274, 275, 275, 275, 276, 276, 276, 277, 277,
1143 277, 277, 278, 278, 278, 279, 279, 279, 280, 280,
1144 280, 280, 281, 281, 281, 282, 282, 282, 283, 283,
1145 283, 283, 284, 284, 284, 285, 285, 285, 286, 286,
1146 286, 287, 287, 287, 287, 288, 288, 288, 289, 289,
1147 289, 290, 290, 290, 290, 291, 291, 291, 292, 292,
1148 292, 293, 293, 293, 293, 294, 294, 294, 295, 295,
1149 295, 296, 296, 296, 296, 297, 297, 297, 298, 298,
1150 298, 299, 299, 299, 299, 300, 300, 300, 301, 301,
1151 301, 302, 302, 302, 302, 303, 303, 303, 304, 304,
1152 304, 305, 305, 305, 305, 306, 306, 306, 307, 307,
1153 307, 308, 308, 308, 308, 309, 309, 309, 310, 310,
1154 310, 311, 311, 311, 311, 312, 312, 312, 313, 313,
1155 313, 314, 314, 314, 315, 315, 315, 315, 316, 316,
1156 316, 317, 317, 317, 318, 318, 318, 318, 319, 319,
1157 319, 320, 320, 320, 321, 321, 321, 321, 322, 322,
1158 322, 323, 323, 323, 324, 324, 324, 324, 325, 325,
1159 325, 326, 326, 326, 327, 327, 327, 327, 328, 328,
1160 328, 329, 329, 329, 330, 330, 330, 330, 331, 331,
1161 331, 332, 332, 332, 333, 333, 333, 333, 334, 334,
1162 334, 335, 335, 335, 336, 336, 336, 336, 337, 337,
1163 337, 338, 338, 338, 339, 339, 339, 339, 340, 340,
1164 340, 341, 341, 341, 342, 342, 342, 342, 343, 343,
1165 343, 344, 344, 344, 345, 345, 345, 346, 346, 346,
1166 346, 347, 347, 347, 348, 348, 348, 349, 349, 349,
1167 349, 350, 350, 350, 351, 351, 351, 352, 352, 352,
1168 352, 353, 353, 353, 354, 354, 354, 355, 355, 355,
1169 355, 356, 356, 356, 357, 357, 357, 358, 358, 358,
1170 358, 359, 359, 359, 360, 360, 360, 361, 361, 361,
1171 361, 362, 362, 362, 363, 363, 363, 364, 364, 364,
1172 364, 365, 365, 365, 366, 366, 366, 367, 367, 367,
1173 367, 368, 368, 368, 369, 369, 369, 370, 370, 370,
1174 370, 371, 371, 371, 372, 372, 372, 373, 373, 373,
1175 374, 374, 374, 374, 375, 375, 375, 376, 376, 376,
1176 377, 377, 377, 377, 378, 378, 378, 379, 379, 379,
1177 380, 380, 380, 380, 381, 381, 381, 382, 382, 382,
1178 383, 383, 383, 383, 384, 384, 384, 385, 385, 385,
1179 386, 386, 386, 386, 387, 387, 387, 388, 388, 388,
1180 389, 389, 389, 389, 390, 390, 390, 391, 391, 391,
1181 392, 392, 392, 392, 393, 393, 393, 394, 394, 394,
1182 395, 395, 395, 395, 396, 396, 396, 397, 397, 397,
1183 398, 398, 398, 398, 399, 399, 399, 400, 400, 400,
1184 401, 401, 401, 402, 402, 402, 402, 403, 403, 403,
1185 404, 404, 404, 405, 405, 405, 405, 406, 406, 406,
1186 407, 407, 407, 408, 408, 408, 408, 409, 409, 409,
1187 410, 410, 410, 411, 411, 411, 411, 412, 412, 412,
1188 413, 413, 413, 414, 414, 414, 414, 415, 415, 415,
1189 416, 416, 416, 417, 417, 417, 417, 418, 418, 418,
1190 419, 419, 419, 420, 420, 420, 420, 421, 421, 421,
1191 422, 422, 422, 423, 423, 423, 423, 424, 424, 424,
1192 425, 425, 425, 426, 426, 426, 426, 427, 427, 427,
1193 428, 428, 428, 429, 429, 429, 429, 430, 430, 430,
1194 431, 431, 431, 432, 432, 432, 433, 433, 433, 433,
1195 434, 434, 434, 435, 435, 435, 436, 436, 436, 436,
1196 437, 437, 437, 438, 438, 438, 439, 439, 439, 439,
1197 440, 440, 440, 441, 441, 441, 442, 442, 442, 442,
1198 443, 443, 443, 444, 444, 444, 445, 445, 445, 445,
1199 446, 446, 446, 447, 447, 447, 448, 448, 448, 448,
1200 449, 449, 449, 450, 450, 450, 451, 451, 451, 451,
1201 452, 452, 452, 453, 453, 453, 454, 454, 454, 454,
1202 455, 455, 455, 456, 456, 456, 457, 457, 457, 457,
1203 458, 458, 458, 459, 459, 459, 460, 460, 460, 461,
1204 461, 461, 461, 462, 462, 462, 463, 463, 463, 464,
1205 464, 464, 464, 465, 465, 465, 466, 466, 466, 467,
1206 467, 467, 467, 468, 468, 468, 469, 469, 469, 470,
1207 470, 470, 470, 471, 471, 471, 472, 472, 472, 473,
1208 473, 473, 473, 474, 474, 474, 475, 475, 475, 476,
1209 476, 476, 476, 477, 477, 477, 478, 478, 478, 479,
1210 479, 479, 479, 480, 480, 480, 481, 481, 481, 482,
1211 482, 482, 482, 483, 483, 483, 484, 484, 484, 485,
1212 485, 485, 485, 486, 486, 486, 487, 487, 487, 488,
1213 488, 488, 488, 489, 489, 489, 490, 490, 490, 491,
1214 491, 491, 492, 492, 492, 492, 493, 493, 493, 494,
1215 494, 494, 495, 495, 495, 495, 496, 496, 496, 497,
1216 497, 497, 498, 498, 498, 498, 499, 499, 499, 500,
1217 500, 500, 501, 501, 501, 501, 502, 502, 502, 503,
1218 503, 503, 504, 504, 504, 504, 505, 505, 505, 506,
1219 506, 506, 507, 507, 507, 507, 508, 508, 508, 509,
1220 509, 509, 510, 510, 510, 510, 511, 511, 511, 512,
1221 512, 512, 513, 513, 513, 513, 514, 514, 514, 515,
1222 515, 515, 516, 516, 516, 516, 517, 517, 517, 518,
1223 518, 518, 519, 519, 519, 520, 520, 520, 520, 521,
1224 521, 521, 522, 522, 522, 523, 523, 523, 523, 524,
1225 524, 524, 525, 525, 525, 526, 526, 526, 526, 527,
1226 527, 527, 528, 528, 528, 529, 529, 529, 529, 530,
1227 530, 530, 531, 531, 531, 532, 532, 532, 532, 533,
1228 533, 533, 534, 534, 534, 535, 535, 535, 535, 536,
1229 536, 536, 537, 537, 537, 538, 538, 538, 538, 539,
1230 539, 539, 540, 540, 540, 541, 541, 541, 541, 542,
1231 542, 542, 543, 543, 543, 544, 544, 544, 544, 545,
1232 545, 545, 546, 546, 546, 547, 547, 547, 548, 548,
1233 548, 548, 549, 549, 549, 550, 550, 550, 551, 551,
1234 551, 551, 552, 552, 552, 553, 553, 553, 554, 554,
1235 554, 554, 555, 555, 555, 556, 556, 556, 557, 557,
1236 557, 557, 558, 558, 558, 559, 559, 559, 560, 560,
1237 560, 560, 561, 561, 561, 562, 562, 562, 563, 563,
1238 563, 563, 564, 564, 564, 565, 565, 565, 566, 566,
1239 566, 566, 567, 567, 567, 568, 568, 568, 569, 569,
1240 569, 569, 570, 570, 570, 571, 571, 571, 572, 572,
1241 572, 572, 573, 573, 573, 574, 574, 574, 575, 575,
1242 575, 575, 576, 576, 576, 577, 577, 577, 578, 578,
1243 578, 579, 579, 579, 579, 580, 580, 580, 581, 581,
1244 581, 582, 582, 582, 582, 583, 583, 583, 584, 584,
1245 584, 585, 585, 585, 585, 586, 586, 586, 587, 587,
1246 587, 588, 588, 588, 588, 589, 589, 589, 590, 590,
1247 590, 591, 591, 591, 591, 592, 592, 592, 593, 593,
1248 593, 594, 594, 594, 594, 595, 595, 595, 596, 596,
1249 596, 597, 597, 597, 597, 598, 598, 598, 599, 599,
1250 599, 600, 600, 600, 600, 601, 601, 601, 602, 602,
1251 602, 603, 603, 603, 603, 604, 604, 604, 605, 605,
1252 605, 606, 606, 606, 607, 607, 607, 607, 608, 608,
1253 608, 609, 609, 609, 610, 610, 610, 610, 611, 611,
1254 611, 612, 612, 612, 613, 613, 613, 613, 614, 614,
1255 614, 615, 615, 615, 616, 616, 616, 616, 617, 617,
1256 617, 618, 618, 618, 619, 619, 619, 619, 620, 620,
1257 620, 621, 621, 621, 622, 622, 622, 622, 623, 623,
1258 623, 624, 624, 624, 625, 625, 625, 625, 626, 626,
1259 626, 627, 627, 627, 628, 628, 628, 628, 629, 629,
1260 629, 630, 630, 630, 631, 631, 631, 631, 632, 632,
1261 632, 633, 633, 633, 634, 634, 634, 634, 635, 635,
1262 635, 636, 636, 636, 637, 637, 637, 638, 638, 638,
1263 638, 639, 639, 639, 640, 640, 640, 641, 641, 641,
1264 641, 642, 642, 642, 643, 643, 643, 644, 644, 644,
1265 644, 645, 645, 645, 646, 646, 646, 647, 647, 647,
1266 647, 648, 648, 648, 649, 649, 649, 650, 650 };
1267 static ULLong pfive[27] = {
1268 5ll,
1269 25ll,
1270 125ll,
1271 625ll,
1272 3125ll,
1273 15625ll,
1274 78125ll,
1275 390625ll,
1276 1953125ll,
1277 9765625ll,
1278 48828125ll,
1279 244140625ll,
1280 1220703125ll,
1281 6103515625ll,
1282 30517578125ll,
1283 152587890625ll,
1284 762939453125ll,
1285 3814697265625ll,
1286 19073486328125ll,
1287 95367431640625ll,
1288 476837158203125ll,
1289 2384185791015625ll,
1290 11920928955078125ll,
1291 59604644775390625ll,
1292 298023223876953125ll,
1293 1490116119384765625ll,
1294 7450580596923828125ll
1295 };
1296
1297 static int pfivebits[25] = {3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31,
1298 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59};
1299#endif /*}*/
1300#endif /*}} NO_LONG_LONG */
1301
1302typedef union { double d; ULong L[2];
1303#ifdef USE_BF96
1304 ULLong LL;
1305#endif
1306 } U;
308 1307
309#ifdef IEEE_8087 1308#ifdef IEEE_8087
310#define word0(x) (x)->L[1] 1309#define word0(x) (x)->L[1]
@@ -314,6 +1313,7 @@ typedef union { double d; ULong L[2]; } U;
314#define word1(x) (x)->L[1] 1313#define word1(x) (x)->L[1]
315#endif 1314#endif
316#define dval(x) (x)->d 1315#define dval(x) (x)->d
1316#define LLval(x) (x)->LL
317 1317
318#ifndef STRTOD_DIGLIM 1318#ifndef STRTOD_DIGLIM
319#define STRTOD_DIGLIM 40 1319#define STRTOD_DIGLIM 40
@@ -471,11 +1471,7 @@ extern int strtod_diglim;
471#ifdef RND_PRODQUOT 1471#ifdef RND_PRODQUOT
472#define rounded_product(a,b) a = rnd_prod(a, b) 1472#define rounded_product(a,b) a = rnd_prod(a, b)
473#define rounded_quotient(a,b) a = rnd_quot(a, b) 1473#define rounded_quotient(a,b) a = rnd_quot(a, b)
474#ifdef KR_headers
475extern double rnd_prod(), rnd_quot();
476#else
477extern double rnd_prod(double, double), rnd_quot(double, double); 1474extern double rnd_prod(double, double), rnd_quot(double, double);
478#endif
479#else 1475#else
480#define rounded_product(a,b) a *= b 1476#define rounded_product(a,b) a *= b
481#define rounded_quotient(a,b) a /= b 1477#define rounded_quotient(a,b) a /= b
@@ -492,34 +1488,17 @@ typedef struct BCinfo BCinfo;
492 struct 1488 struct
493BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflchk; }; 1489BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflchk; };
494 1490
495#ifdef KR_headers
496#define FFFFFFFF ((((unsigned long)0xffff)<<16)|(unsigned long)0xffff)
497#else
498#define FFFFFFFF 0xffffffffUL 1491#define FFFFFFFF 0xffffffffUL
499#endif
500
501#ifdef NO_LONG_LONG
502#undef ULLong
503#ifdef Just_16
504#undef Pack_32
505/* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
506 * This makes some inner loops simpler and sometimes saves work
507 * during multiplications, but it often seems to make things slightly
508 * slower. Hence the default is now to store 32 bits per Long.
509 */
510#endif
511#else /* long long available */
512#ifndef Llong
513#define Llong long long
514#endif
515#ifndef ULLong
516#define ULLong unsigned Llong
517#endif
518#endif /* NO_LONG_LONG */
519 1492
520#ifndef MULTIPLE_THREADS 1493#ifdef MULTIPLE_THREADS
521#define ACQUIRE_DTOA_LOCK(n) /*nothing*/ 1494#define MTa , PTI
522#define FREE_DTOA_LOCK(n) /*nothing*/ 1495#define MTb , &TI
1496#define MTd , ThInfo **PTI
1497static unsigned int maxthreads = 0;
1498#else
1499#define MTa /*nothing*/
1500#define MTb /*nothing*/
1501#define MTd /*nothing*/
523#endif 1502#endif
524 1503
525#define Kmax 7 1504#define Kmax 7
@@ -538,24 +1517,77 @@ Bigint {
538 }; 1517 };
539 1518
540 typedef struct Bigint Bigint; 1519 typedef struct Bigint Bigint;
1520 typedef struct
1521ThInfo {
1522 Bigint *Freelist[Kmax+1];
1523 Bigint *P5s;
1524 } ThInfo;
541 1525
542 static Bigint *freelist[Kmax+1]; 1526 static ThInfo TI0;
543 1527
544 static Bigint * 1528#ifdef MULTIPLE_THREADS
545Balloc 1529 static ThInfo *TI1;
546#ifdef KR_headers 1530 static int TI0_used;
547 (k) int k; 1531
1532 void
1533set_max_dtoa_threads(unsigned int n)
1534{
1535 size_t L;
1536
1537 if (n > maxthreads) {
1538 L = n*sizeof(ThInfo);
1539 if (TI1) {
1540 TI1 = (ThInfo*)REALLOC(TI1, L);
1541 memset(TI1 + maxthreads, 0, (n-maxthreads)*sizeof(ThInfo));
1542 }
1543 else {
1544 TI1 = (ThInfo*)MALLOC(L);
1545 if (TI0_used) {
1546 memcpy(TI1, &TI0, sizeof(ThInfo));
1547 if (n > 1)
1548 memset(TI1 + 1, 0, L - sizeof(ThInfo));
1549 memset(&TI0, 0, sizeof(ThInfo));
1550 }
1551 else
1552 memset(TI1, 0, L);
1553 }
1554 maxthreads = n;
1555 }
1556 }
1557
1558 static ThInfo*
1559get_TI(void)
1560{
1561 unsigned int thno = dtoa_get_threadno();
1562 if (thno < maxthreads)
1563 return TI1 + thno;
1564 if (thno == 0)
1565 TI0_used = 1;
1566 return &TI0;
1567 }
1568#define freelist TI->Freelist
1569#define p5s TI->P5s
548#else 1570#else
549 (int k) 1571#define freelist TI0.Freelist
1572#define p5s TI0.P5s
550#endif 1573#endif
1574
1575 static Bigint *
1576Balloc(int k MTd)
551{ 1577{
552 int x; 1578 int x;
553 Bigint *rv; 1579 Bigint *rv;
554#ifndef Omit_Private_Memory 1580#ifndef Omit_Private_Memory
555 unsigned int len; 1581 unsigned int len;
556#endif 1582#endif
1583#ifdef MULTIPLE_THREADS
1584 ThInfo *TI;
557 1585
558 ACQUIRE_DTOA_LOCK(0); 1586 if (!(TI = *PTI))
1587 *PTI = TI = get_TI();
1588 if (TI == &TI0)
1589 ACQUIRE_DTOA_LOCK(0);
1590#endif
559 /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */ 1591 /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
560 /* but this case seems very unlikely. */ 1592 /* but this case seems very unlikely. */
561 if (k <= Kmax && (rv = freelist[k])) 1593 if (k <= Kmax && (rv = freelist[k]))
@@ -567,7 +1599,11 @@ Balloc
567#else 1599#else
568 len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1) 1600 len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
569 /sizeof(double); 1601 /sizeof(double);
570 if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) { 1602 if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem
1603#ifdef MULTIPLE_THREADS
1604 && TI == TI1
1605#endif
1606 ) {
571 rv = (Bigint*)pmem_next; 1607 rv = (Bigint*)pmem_next;
572 pmem_next += len; 1608 pmem_next += len;
573 } 1609 }
@@ -577,31 +1613,36 @@ Balloc
577 rv->k = k; 1613 rv->k = k;
578 rv->maxwds = x; 1614 rv->maxwds = x;
579 } 1615 }
580 FREE_DTOA_LOCK(0); 1616#ifdef MULTIPLE_THREADS
1617 if (TI == &TI0)
1618 FREE_DTOA_LOCK(0);
1619#endif
581 rv->sign = rv->wds = 0; 1620 rv->sign = rv->wds = 0;
582 return rv; 1621 return rv;
583 } 1622 }
584 1623
585 static void 1624 static void
586Bfree 1625Bfree(Bigint *v MTd)
587#ifdef KR_headers
588 (v) Bigint *v;
589#else
590 (Bigint *v)
591#endif
592{ 1626{
1627#ifdef MULTIPLE_THREADS
1628 ThInfo *TI;
1629#endif
593 if (v) { 1630 if (v) {
594 if (v->k > Kmax) 1631 if (v->k > Kmax)
595#ifdef FREE
596 FREE((void*)v); 1632 FREE((void*)v);
597#else
598 free((void*)v);
599#endif
600 else { 1633 else {
601 ACQUIRE_DTOA_LOCK(0); 1634#ifdef MULTIPLE_THREADS
1635 if (!(TI = *PTI))
1636 *PTI = TI = get_TI();
1637 if (TI == &TI0)
1638 ACQUIRE_DTOA_LOCK(0);
1639#endif
602 v->next = freelist[v->k]; 1640 v->next = freelist[v->k];
603 freelist[v->k] = v; 1641 freelist[v->k] = v;
604 FREE_DTOA_LOCK(0); 1642#ifdef MULTIPLE_THREADS
1643 if (TI == &TI0)
1644 FREE_DTOA_LOCK(0);
1645#endif
605 } 1646 }
606 } 1647 }
607 } 1648 }
@@ -610,12 +1651,7 @@ Bfree
610y->wds*sizeof(Long) + 2*sizeof(int)) 1651y->wds*sizeof(Long) + 2*sizeof(int))
611 1652
612 static Bigint * 1653 static Bigint *
613multadd 1654multadd(Bigint *b, int m, int a MTd) /* multiply by m and add a */
614#ifdef KR_headers
615 (b, m, a) Bigint *b; int m, a;
616#else
617 (Bigint *b, int m, int a) /* multiply by m and add a */
618#endif
619{ 1655{
620 int i, wds; 1656 int i, wds;
621#ifdef ULLong 1657#ifdef ULLong
@@ -655,9 +1691,9 @@ multadd
655 while(++i < wds); 1691 while(++i < wds);
656 if (carry) { 1692 if (carry) {
657 if (wds >= b->maxwds) { 1693 if (wds >= b->maxwds) {
658 b1 = Balloc(b->k+1); 1694 b1 = Balloc(b->k+1 MTa);
659 Bcopy(b1, b); 1695 Bcopy(b1, b);
660 Bfree(b); 1696 Bfree(b MTa);
661 b = b1; 1697 b = b1;
662 } 1698 }
663 b->x[wds++] = carry; 1699 b->x[wds++] = carry;
@@ -667,12 +1703,7 @@ multadd
667 } 1703 }
668 1704
669 static Bigint * 1705 static Bigint *
670s2b 1706s2b(const char *s, int nd0, int nd, ULong y9, int dplen MTd)
671#ifdef KR_headers
672 (s, nd0, nd, y9, dplen) CONST char *s; int nd0, nd, dplen; ULong y9;
673#else
674 (const char *s, int nd0, int nd, ULong y9, int dplen)
675#endif
676{ 1707{
677 Bigint *b; 1708 Bigint *b;
678 int i, k; 1709 int i, k;
@@ -681,11 +1712,11 @@ s2b
681 x = (nd + 8) / 9; 1712 x = (nd + 8) / 9;
682 for(k = 0, y = 1; x > y; y <<= 1, k++) ; 1713 for(k = 0, y = 1; x > y; y <<= 1, k++) ;
683#ifdef Pack_32 1714#ifdef Pack_32
684 b = Balloc(k); 1715 b = Balloc(k MTa);
685 b->x[0] = y9; 1716 b->x[0] = y9;
686 b->wds = 1; 1717 b->wds = 1;
687#else 1718#else
688 b = Balloc(k+1); 1719 b = Balloc(k+1 MTa);
689 b->x[0] = y9 & 0xffff; 1720 b->x[0] = y9 & 0xffff;
690 b->wds = (b->x[1] = y9 >> 16) ? 2 : 1; 1721 b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
691#endif 1722#endif
@@ -693,24 +1724,19 @@ s2b
693 i = 9; 1724 i = 9;
694 if (9 < nd0) { 1725 if (9 < nd0) {
695 s += 9; 1726 s += 9;
696 do b = multadd(b, 10, *s++ - '0'); 1727 do b = multadd(b, 10, *s++ - '0' MTa);
697 while(++i < nd0); 1728 while(++i < nd0);
698 s += dplen; 1729 s += dplen;
699 } 1730 }
700 else 1731 else
701 s += dplen + 9; 1732 s += dplen + 9;
702 for(; i < nd; i++) 1733 for(; i < nd; i++)
703 b = multadd(b, 10, *s++ - '0'); 1734 b = multadd(b, 10, *s++ - '0' MTa);
704 return b; 1735 return b;
705 } 1736 }
706 1737
707 static int 1738 static int
708hi0bits 1739hi0bits(ULong x)
709#ifdef KR_headers
710 (x) ULong x;
711#else
712 (ULong x)
713#endif
714{ 1740{
715 int k = 0; 1741 int k = 0;
716 1742
@@ -739,12 +1765,7 @@ hi0bits
739 } 1765 }
740 1766
741 static int 1767 static int
742lo0bits 1768lo0bits(ULong *y)
743#ifdef KR_headers
744 (y) ULong *y;
745#else
746 (ULong *y)
747#endif
748{ 1769{
749 int k; 1770 int k;
750 ULong x = *y; 1771 ULong x = *y;
@@ -787,28 +1808,18 @@ lo0bits
787 } 1808 }
788 1809
789 static Bigint * 1810 static Bigint *
790i2b 1811i2b(int i MTd)
791#ifdef KR_headers
792 (i) int i;
793#else
794 (int i)
795#endif
796{ 1812{
797 Bigint *b; 1813 Bigint *b;
798 1814
799 b = Balloc(1); 1815 b = Balloc(1 MTa);
800 b->x[0] = i; 1816 b->x[0] = i;
801 b->wds = 1; 1817 b->wds = 1;
802 return b; 1818 return b;
803 } 1819 }
804 1820
805 static Bigint * 1821 static Bigint *
806mult 1822mult(Bigint *a, Bigint *b MTd)
807#ifdef KR_headers
808 (a, b) Bigint *a, *b;
809#else
810 (Bigint *a, Bigint *b)
811#endif
812{ 1823{
813 Bigint *c; 1824 Bigint *c;
814 int k, wa, wb, wc; 1825 int k, wa, wb, wc;
@@ -834,7 +1845,7 @@ mult
834 wc = wa + wb; 1845 wc = wa + wb;
835 if (wc > a->maxwds) 1846 if (wc > a->maxwds)
836 k++; 1847 k++;
837 c = Balloc(k); 1848 c = Balloc(k MTa);
838 for(x = c->x, xa = x + wc; x < xa; x++) 1849 for(x = c->x, xa = x + wc; x < xa; x++)
839 *x = 0; 1850 *x = 0;
840 xa = a->x; 1851 xa = a->x;
@@ -912,55 +1923,63 @@ mult
912 return c; 1923 return c;
913 } 1924 }
914 1925
915 static Bigint *p5s;
916
917 static Bigint * 1926 static Bigint *
918pow5mult 1927pow5mult(Bigint *b, int k MTd)
919#ifdef KR_headers
920 (b, k) Bigint *b; int k;
921#else
922 (Bigint *b, int k)
923#endif
924{ 1928{
925 Bigint *b1, *p5, *p51; 1929 Bigint *b1, *p5, *p51;
1930#ifdef MULTIPLE_THREADS
1931 ThInfo *TI;
1932#endif
926 int i; 1933 int i;
927 static int p05[3] = { 5, 25, 125 }; 1934 static int p05[3] = { 5, 25, 125 };
928 1935
929 if ((i = k & 3)) 1936 if ((i = k & 3))
930 b = multadd(b, p05[i-1], 0); 1937 b = multadd(b, p05[i-1], 0 MTa);
931 1938
932 if (!(k >>= 2)) 1939 if (!(k >>= 2))
933 return b; 1940 return b;
1941#ifdef MULTIPLE_THREADS
1942 if (!(TI = *PTI))
1943 *PTI = TI = get_TI();
1944#endif
934 if (!(p5 = p5s)) { 1945 if (!(p5 = p5s)) {
935 /* first time */ 1946 /* first time */
936#ifdef MULTIPLE_THREADS 1947#ifdef MULTIPLE_THREADS
937 ACQUIRE_DTOA_LOCK(1); 1948 if (!(TI = *PTI))
1949 *PTI = TI = get_TI();
1950 if (TI == &TI0)
1951 ACQUIRE_DTOA_LOCK(1);
938 if (!(p5 = p5s)) { 1952 if (!(p5 = p5s)) {
939 p5 = p5s = i2b(625); 1953 p5 = p5s = i2b(625 MTa);
940 p5->next = 0; 1954 p5->next = 0;
941 } 1955 }
942 FREE_DTOA_LOCK(1); 1956 if (TI == &TI0)
1957 FREE_DTOA_LOCK(1);
943#else 1958#else
944 p5 = p5s = i2b(625); 1959 p5 = p5s = i2b(625 MTa);
945 p5->next = 0; 1960 p5->next = 0;
946#endif 1961#endif
947 } 1962 }
948 for(;;) { 1963 for(;;) {
949 if (k & 1) { 1964 if (k & 1) {
950 b1 = mult(b, p5); 1965 b1 = mult(b, p5 MTa);
951 Bfree(b); 1966 Bfree(b MTa);
952 b = b1; 1967 b = b1;
953 } 1968 }
954 if (!(k >>= 1)) 1969 if (!(k >>= 1))
955 break; 1970 break;
956 if (!(p51 = p5->next)) { 1971 if (!(p51 = p5->next)) {
957#ifdef MULTIPLE_THREADS 1972#ifdef MULTIPLE_THREADS
958 ACQUIRE_DTOA_LOCK(1); 1973 if (!TI && !(TI = *PTI))
1974 *PTI = TI = get_TI();
1975 if (TI == &TI0)
1976 ACQUIRE_DTOA_LOCK(1);
959 if (!(p51 = p5->next)) { 1977 if (!(p51 = p5->next)) {
960 p51 = p5->next = mult(p5,p5); 1978 p51 = p5->next = mult(p5,p5 MTa);
961 p51->next = 0; 1979 p51->next = 0;
962 } 1980 }
963 FREE_DTOA_LOCK(1); 1981 if (TI == &TI0)
1982 FREE_DTOA_LOCK(1);
964#else 1983#else
965 p51 = p5->next = mult(p5,p5); 1984 p51 = p5->next = mult(p5,p5);
966 p51->next = 0; 1985 p51->next = 0;
@@ -972,12 +1991,7 @@ pow5mult
972 } 1991 }
973 1992
974 static Bigint * 1993 static Bigint *
975lshift 1994lshift(Bigint *b, int k MTd)
976#ifdef KR_headers
977 (b, k) Bigint *b; int k;
978#else
979 (Bigint *b, int k)
980#endif
981{ 1995{
982 int i, k1, n, n1; 1996 int i, k1, n, n1;
983 Bigint *b1; 1997 Bigint *b1;
@@ -992,7 +2006,7 @@ lshift
992 n1 = n + b->wds + 1; 2006 n1 = n + b->wds + 1;
993 for(i = b->maxwds; n1 > i; i <<= 1) 2007 for(i = b->maxwds; n1 > i; i <<= 1)
994 k1++; 2008 k1++;
995 b1 = Balloc(k1); 2009 b1 = Balloc(k1 MTa);
996 x1 = b1->x; 2010 x1 = b1->x;
997 for(i = 0; i < n; i++) 2011 for(i = 0; i < n; i++)
998 *x1++ = 0; 2012 *x1++ = 0;
@@ -1027,17 +2041,12 @@ lshift
1027 *x1++ = *x++; 2041 *x1++ = *x++;
1028 while(x < xe); 2042 while(x < xe);
1029 b1->wds = n1 - 1; 2043 b1->wds = n1 - 1;
1030 Bfree(b); 2044 Bfree(b MTa);
1031 return b1; 2045 return b1;
1032 } 2046 }
1033 2047
1034 static int 2048 static int
1035cmp 2049cmp(Bigint *a, Bigint *b)
1036#ifdef KR_headers
1037 (a, b) Bigint *a, *b;
1038#else
1039 (Bigint *a, Bigint *b)
1040#endif
1041{ 2050{
1042 ULong *xa, *xa0, *xb, *xb0; 2051 ULong *xa, *xa0, *xb, *xb0;
1043 int i, j; 2052 int i, j;
@@ -1066,12 +2075,7 @@ cmp
1066 } 2075 }
1067 2076
1068 static Bigint * 2077 static Bigint *
1069diff 2078diff(Bigint *a, Bigint *b MTd)
1070#ifdef KR_headers
1071 (a, b) Bigint *a, *b;
1072#else
1073 (Bigint *a, Bigint *b)
1074#endif
1075{ 2079{
1076 Bigint *c; 2080 Bigint *c;
1077 int i, wa, wb; 2081 int i, wa, wb;
@@ -1087,7 +2091,7 @@ diff
1087 2091
1088 i = cmp(a,b); 2092 i = cmp(a,b);
1089 if (!i) { 2093 if (!i) {
1090 c = Balloc(0); 2094 c = Balloc(0 MTa);
1091 c->wds = 1; 2095 c->wds = 1;
1092 c->x[0] = 0; 2096 c->x[0] = 0;
1093 return c; 2097 return c;
@@ -1100,7 +2104,7 @@ diff
1100 } 2104 }
1101 else 2105 else
1102 i = 0; 2106 i = 0;
1103 c = Balloc(a->k); 2107 c = Balloc(a->k MTa);
1104 c->sign = i; 2108 c->sign = i;
1105 wa = a->wds; 2109 wa = a->wds;
1106 xa = a->x; 2110 xa = a->x;
@@ -1160,12 +2164,7 @@ diff
1160 } 2164 }
1161 2165
1162 static double 2166 static double
1163ulp 2167ulp(U *x)
1164#ifdef KR_headers
1165 (x) U *x;
1166#else
1167 (U *x)
1168#endif
1169{ 2168{
1170 Long L; 2169 Long L;
1171 U u; 2170 U u;
@@ -1202,12 +2201,7 @@ ulp
1202 } 2201 }
1203 2202
1204 static double 2203 static double
1205b2d 2204b2d(Bigint *a, int *e)
1206#ifdef KR_headers
1207 (a, e) Bigint *a; int *e;
1208#else
1209 (Bigint *a, int *e)
1210#endif
1211{ 2205{
1212 ULong *xa, *xa0, w, y, z; 2206 ULong *xa, *xa0, w, y, z;
1213 int k; 2207 int k;
@@ -1272,12 +2266,7 @@ b2d
1272 } 2266 }
1273 2267
1274 static Bigint * 2268 static Bigint *
1275d2b 2269d2b(U *d, int *e, int *bits MTd)
1276#ifdef KR_headers
1277 (d, e, bits) U *d; int *e, *bits;
1278#else
1279 (U *d, int *e, int *bits)
1280#endif
1281{ 2270{
1282 Bigint *b; 2271 Bigint *b;
1283 int de, k; 2272 int de, k;
@@ -1295,9 +2284,9 @@ d2b
1295#endif 2284#endif
1296 2285
1297#ifdef Pack_32 2286#ifdef Pack_32
1298 b = Balloc(1); 2287 b = Balloc(1 MTa);
1299#else 2288#else
1300 b = Balloc(2); 2289 b = Balloc(2 MTa);
1301#endif 2290#endif
1302 x = b->x; 2291 x = b->x;
1303 2292
@@ -1406,12 +2395,7 @@ d2b
1406#undef d1 2395#undef d1
1407 2396
1408 static double 2397 static double
1409ratio 2398ratio(Bigint *a, Bigint *b)
1410#ifdef KR_headers
1411 (a, b) Bigint *a, *b;
1412#else
1413 (Bigint *a, Bigint *b)
1414#endif
1415{ 2399{
1416 U da, db; 2400 U da, db;
1417 int k, ka, kb; 2401 int k, ka, kb;
@@ -1446,7 +2430,7 @@ ratio
1446 return dval(&da) / dval(&db); 2430 return dval(&da) / dval(&db);
1447 } 2431 }
1448 2432
1449 static CONST double 2433 static const double
1450tens[] = { 2434tens[] = {
1451 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 2435 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1452 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 2436 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
@@ -1456,10 +2440,10 @@ tens[] = {
1456#endif 2440#endif
1457 }; 2441 };
1458 2442
1459 static CONST double 2443 static const double
1460#ifdef IEEE_Arith 2444#ifdef IEEE_Arith
1461bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 }; 2445bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
1462static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 2446static const double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
1463#ifdef Avoid_Underflow 2447#ifdef Avoid_Underflow
1464 9007199254740992.*9007199254740992.e-256 2448 9007199254740992.*9007199254740992.e-256
1465 /* = 2^106 * 1e-256 */ 2449 /* = 2^106 * 1e-256 */
@@ -1474,11 +2458,11 @@ static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
1474#else 2458#else
1475#ifdef IBM 2459#ifdef IBM
1476bigtens[] = { 1e16, 1e32, 1e64 }; 2460bigtens[] = { 1e16, 1e32, 1e64 };
1477static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 }; 2461static const double tinytens[] = { 1e-16, 1e-32, 1e-64 };
1478#define n_bigtens 3 2462#define n_bigtens 3
1479#else 2463#else
1480bigtens[] = { 1e16, 1e32 }; 2464bigtens[] = { 1e16, 1e32 };
1481static CONST double tinytens[] = { 1e-16, 1e-32 }; 2465static const double tinytens[] = { 1e-16, 1e-32 };
1482#define n_bigtens 2 2466#define n_bigtens 2
1483#endif 2467#endif
1484#endif 2468#endif
@@ -1497,14 +2481,11 @@ static CONST double tinytens[] = { 1e-16, 1e-32 };
1497#endif 2481#endif
1498 2482
1499#ifdef Need_Hexdig /*{*/ 2483#ifdef Need_Hexdig /*{*/
2484#if 0
1500static unsigned char hexdig[256]; 2485static unsigned char hexdig[256];
1501 2486
1502 static void 2487 static void
1503#ifdef KR_headers
1504htinit(h, s, inc) unsigned char *h; unsigned char *s; int inc;
1505#else
1506htinit(unsigned char *h, unsigned char *s, int inc) 2488htinit(unsigned char *h, unsigned char *s, int inc)
1507#endif
1508{ 2489{
1509 int i, j; 2490 int i, j;
1510 for(i = 0; (j = s[i]) !=0; i++) 2491 for(i = 0; (j = s[i]) !=0; i++)
@@ -1512,17 +2493,34 @@ htinit(unsigned char *h, unsigned char *s, int inc)
1512 } 2493 }
1513 2494
1514 static void 2495 static void
1515#ifdef KR_headers 2496hexdig_init(void) /* Use of hexdig_init omitted 20121220 to avoid a */
1516hexdig_init() 2497 /* race condition when multiple threads are used. */
1517#else
1518hexdig_init(void)
1519#endif
1520{ 2498{
1521#define USC (unsigned char *) 2499#define USC (unsigned char *)
1522 htinit(hexdig, USC "0123456789", 0x10); 2500 htinit(hexdig, USC "0123456789", 0x10);
1523 htinit(hexdig, USC "abcdef", 0x10 + 10); 2501 htinit(hexdig, USC "abcdef", 0x10 + 10);
1524 htinit(hexdig, USC "ABCDEF", 0x10 + 10); 2502 htinit(hexdig, USC "ABCDEF", 0x10 + 10);
1525 } 2503 }
2504#else
2505static unsigned char hexdig[256] = {
2506 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2507 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2508 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2509 16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,0,
2510 0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,
2511 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2512 0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,
2513 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2514 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2515 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2516 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2517 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2518 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2519 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2520 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2521 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
2522 };
2523#endif
1526#endif /* } Need_Hexdig */ 2524#endif /* } Need_Hexdig */
1527 2525
1528#ifdef INFNAN_CHECK 2526#ifdef INFNAN_CHECK
@@ -1536,15 +2534,10 @@ hexdig_init(void)
1536#endif 2534#endif
1537 2535
1538 static int 2536 static int
1539match 2537match(const char **sp, const char *t)
1540#ifdef KR_headers
1541 (sp, t) char **sp, *t;
1542#else
1543 (const char **sp, const char *t)
1544#endif
1545{ 2538{
1546 int c, d; 2539 int c, d;
1547 CONST char *s = *sp; 2540 const char *s = *sp;
1548 2541
1549 while((d = *t++)) { 2542 while((d = *t++)) {
1550 if ((c = *++s) >= 'A' && c <= 'Z') 2543 if ((c = *++s) >= 'A' && c <= 'Z')
@@ -1558,29 +2551,23 @@ match
1558 2551
1559#ifndef No_Hex_NaN 2552#ifndef No_Hex_NaN
1560 static void 2553 static void
1561hexnan 2554hexnan(U *rvp, const char **sp)
1562#ifdef KR_headers
1563 (rvp, sp) U *rvp; CONST char **sp;
1564#else
1565 (U *rvp, const char **sp)
1566#endif
1567{ 2555{
1568 ULong c, x[2]; 2556 ULong c, x[2];
1569 CONST char *s; 2557 const char *s;
1570 int c1, havedig, udx0, xshift; 2558 int c1, havedig, udx0, xshift;
1571 2559
1572 if (!hexdig['0']) 2560 /**** if (!hexdig['0']) hexdig_init(); ****/
1573 hexdig_init();
1574 x[0] = x[1] = 0; 2561 x[0] = x[1] = 0;
1575 havedig = xshift = 0; 2562 havedig = xshift = 0;
1576 udx0 = 1; 2563 udx0 = 1;
1577 s = *sp; 2564 s = *sp;
1578 /* allow optional initial 0x or 0X */ 2565 /* allow optional initial 0x or 0X */
1579 while((c = *(CONST unsigned char*)(s+1)) && c <= ' ') 2566 while((c = *(const unsigned char*)(s+1)) && c <= ' ')
1580 ++s; 2567 ++s;
1581 if (s[1] == '0' && (s[2] == 'x' || s[2] == 'X')) 2568 if (s[1] == '0' && (s[2] == 'x' || s[2] == 'X'))
1582 s += 2; 2569 s += 2;
1583 while((c = *(CONST unsigned char*)++s)) { 2570 while((c = *(const unsigned char*)++s)) {
1584 if ((c1 = hexdig[c])) 2571 if ((c1 = hexdig[c]))
1585 c = c1 & 0xf; 2572 c = c1 & 0xf;
1586 else if (c <= ' ') { 2573 else if (c <= ' ') {
@@ -1638,11 +2625,7 @@ hexnan
1638 2625
1639#if !defined(NO_HEX_FP) || defined(Honor_FLT_ROUNDS) /*{*/ 2626#if !defined(NO_HEX_FP) || defined(Honor_FLT_ROUNDS) /*{*/
1640 static Bigint * 2627 static Bigint *
1641#ifdef KR_headers 2628increment(Bigint *b MTd)
1642increment(b) Bigint *b;
1643#else
1644increment(Bigint *b)
1645#endif
1646{ 2629{
1647 ULong *x, *xe; 2630 ULong *x, *xe;
1648 Bigint *b1; 2631 Bigint *b1;
@@ -1658,9 +2641,9 @@ increment(Bigint *b)
1658 } while(x < xe); 2641 } while(x < xe);
1659 { 2642 {
1660 if (b->wds >= b->maxwds) { 2643 if (b->wds >= b->maxwds) {
1661 b1 = Balloc(b->k+1); 2644 b1 = Balloc(b->k+1 MTa);
1662 Bcopy(b1,b); 2645 Bcopy(b1,b);
1663 Bfree(b); 2646 Bfree(b MTa);
1664 b = b1; 2647 b = b1;
1665 } 2648 }
1666 b->x[b->wds++] = 1; 2649 b->x[b->wds++] = 1;
@@ -1673,11 +2656,7 @@ increment(Bigint *b)
1673#ifndef NO_HEX_FP /*{*/ 2656#ifndef NO_HEX_FP /*{*/
1674 2657
1675 static void 2658 static void
1676#ifdef KR_headers
1677rshift(b, k) Bigint *b; int k;
1678#else
1679rshift(Bigint *b, int k) 2659rshift(Bigint *b, int k)
1680#endif
1681{ 2660{
1682 ULong *x, *x1, *xe, y; 2661 ULong *x, *x1, *xe, y;
1683 int n; 2662 int n;
@@ -1706,11 +2685,7 @@ rshift(Bigint *b, int k)
1706 } 2685 }
1707 2686
1708 static ULong 2687 static ULong
1709#ifdef KR_headers
1710any_on(b, k) Bigint *b; int k;
1711#else
1712any_on(Bigint *b, int k) 2688any_on(Bigint *b, int k)
1713#endif
1714{ 2689{
1715 int n, nwds; 2690 int n, nwds;
1716 ULong *x, *x0, x1, x2; 2691 ULong *x, *x0, x1, x2;
@@ -1743,15 +2718,10 @@ enum { /* rounding values: same as FLT_ROUNDS */
1743 }; 2718 };
1744 2719
1745 void 2720 void
1746#ifdef KR_headers 2721gethex( const char **sp, U *rvp, int rounding, int sign MTd)
1747gethex(sp, rvp, rounding, sign)
1748 CONST char **sp; U *rvp; int rounding, sign;
1749#else
1750gethex( CONST char **sp, U *rvp, int rounding, int sign)
1751#endif
1752{ 2722{
1753 Bigint *b; 2723 Bigint *b;
1754 CONST unsigned char *decpt, *s0, *s, *s1; 2724 const unsigned char *decpt, *s0, *s, *s1;
1755 Long e, e1; 2725 Long e, e1;
1756 ULong L, lostbits, *x; 2726 ULong L, lostbits, *x;
1757 int big, denorm, esign, havedig, k, n, nbits, up, zret; 2727 int big, denorm, esign, havedig, k, n, nbits, up, zret;
@@ -1783,8 +2753,8 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
1783 if (!(s0 = decimalpoint_cache)) { 2753 if (!(s0 = decimalpoint_cache)) {
1784 s0 = (unsigned char*)localeconv()->decimal_point; 2754 s0 = (unsigned char*)localeconv()->decimal_point;
1785 if ((decimalpoint_cache = (unsigned char*) 2755 if ((decimalpoint_cache = (unsigned char*)
1786 MALLOC(strlen((CONST char*)s0) + 1))) { 2756 MALLOC(strlen((const char*)s0) + 1))) {
1787 strcpy((char*)decimalpoint_cache, (CONST char*)s0); 2757 strcpy((char*)decimalpoint_cache, (const char*)s0);
1788 s0 = decimalpoint_cache; 2758 s0 = decimalpoint_cache;
1789 } 2759 }
1790 } 2760 }
@@ -1792,10 +2762,9 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
1792#endif 2762#endif
1793#endif 2763#endif
1794 2764
1795 if (!hexdig['0']) 2765 /**** if (!hexdig['0']) hexdig_init(); ****/
1796 hexdig_init();
1797 havedig = 0; 2766 havedig = 0;
1798 s0 = *(CONST unsigned char **)sp + 2; 2767 s0 = *(const unsigned char **)sp + 2;
1799 while(s0[havedig] == '0') 2768 while(s0[havedig] == '0')
1800 havedig++; 2769 havedig++;
1801 s0 += havedig; 2770 s0 += havedig;
@@ -1893,10 +2862,10 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
1893#endif 2862#endif
1894 goto retz; 2863 goto retz;
1895#ifdef IEEE_Arith 2864#ifdef IEEE_Arith
2865 ret_tinyf:
2866 Bfree(b MTa);
1896 ret_tiny: 2867 ret_tiny:
1897#ifndef NO_ERRNO 2868 Set_errno(ERANGE);
1898 errno = ERANGE;
1899#endif
1900 word0(rvp) = 0; 2869 word0(rvp) = 0;
1901 word1(rvp) = 1; 2870 word1(rvp) = 1;
1902 return; 2871 return;
@@ -1922,7 +2891,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
1922 n = s1 - s0 - 1; 2891 n = s1 - s0 - 1;
1923 for(k = 0; n > (1 << (kshift-2)) - 1; n >>= 1) 2892 for(k = 0; n > (1 << (kshift-2)) - 1; n >>= 1)
1924 k++; 2893 k++;
1925 b = Balloc(k); 2894 b = Balloc(k MTa);
1926 x = b->x; 2895 x = b->x;
1927 n = 0; 2896 n = 0;
1928 L = 0; 2897 L = 0;
@@ -1969,16 +2938,27 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
1969 } 2938 }
1970 else if (n < nbits) { 2939 else if (n < nbits) {
1971 n = nbits - n; 2940 n = nbits - n;
1972 b = lshift(b, n); 2941 b = lshift(b, n MTa);
1973 e -= n; 2942 e -= n;
1974 x = b->x; 2943 x = b->x;
1975 } 2944 }
1976 if (e > Emax) { 2945 if (e > emax) {
1977 ovfl: 2946 ovfl:
1978 Bfree(b); 2947 Bfree(b MTa);
1979 ovfl1: 2948 ovfl1:
1980#ifndef NO_ERRNO 2949 Set_errno(ERANGE);
1981 errno = ERANGE; 2950#ifdef Honor_FLT_ROUNDS
2951 switch (rounding) {
2952 case Round_zero:
2953 goto ret_big;
2954 case Round_down:
2955 if (!sign)
2956 goto ret_big;
2957 break;
2958 case Round_up:
2959 if (sign)
2960 goto ret_big;
2961 }
1982#endif 2962#endif
1983 word0(rvp) = Exp_mask; 2963 word0(rvp) = Exp_mask;
1984 word1(rvp) = 0; 2964 word1(rvp) = 0;
@@ -1992,23 +2972,21 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
1992#ifdef IEEE_Arith /*{*/ 2972#ifdef IEEE_Arith /*{*/
1993 switch (rounding) { 2973 switch (rounding) {
1994 case Round_near: 2974 case Round_near:
1995 if (n == nbits && (n < 2 || any_on(b,n-1))) 2975 if (n == nbits && (n < 2 || lostbits || any_on(b,n-1)))
1996 goto ret_tiny; 2976 goto ret_tinyf;
1997 break; 2977 break;
1998 case Round_up: 2978 case Round_up:
1999 if (!sign) 2979 if (!sign)
2000 goto ret_tiny; 2980 goto ret_tinyf;
2001 break; 2981 break;
2002 case Round_down: 2982 case Round_down:
2003 if (sign) 2983 if (sign)
2004 goto ret_tiny; 2984 goto ret_tinyf;
2005 } 2985 }
2006#endif /* } IEEE_Arith */ 2986#endif /* } IEEE_Arith */
2007 Bfree(b); 2987 Bfree(b MTa);
2008 retz: 2988 retz:
2009#ifndef NO_ERRNO 2989 Set_errno(ERANGE);
2010 errno = ERANGE;
2011#endif
2012 retz1: 2990 retz1:
2013 rvp->d = 0.; 2991 rvp->d = 0.;
2014 return; 2992 return;
@@ -2042,7 +3020,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
2042 } 3020 }
2043 if (up) { 3021 if (up) {
2044 k = b->wds; 3022 k = b->wds;
2045 b = increment(b); 3023 b = increment(b MTa);
2046 x = b->x; 3024 x = b->x;
2047 if (denorm) { 3025 if (denorm) {
2048#if 0 3026#if 0
@@ -2099,16 +3077,12 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
2099 word0(rvp) = ((b->x[1] & ~0x800000) >> 16) | ((e + 129 + 55) << 7) | (b->x[1] << 16); 3077 word0(rvp) = ((b->x[1] & ~0x800000) >> 16) | ((e + 129 + 55) << 7) | (b->x[1] << 16);
2100 word1(rvp) = (b->x[0] >> 16) | (b->x[0] << 16); 3078 word1(rvp) = (b->x[0] >> 16) | (b->x[0] << 16);
2101#endif 3079#endif
2102 Bfree(b); 3080 Bfree(b MTa);
2103 } 3081 }
2104#endif /*!NO_HEX_FP}*/ 3082#endif /*!NO_HEX_FP}*/
2105 3083
2106 static int 3084 static int
2107#ifdef KR_headers
2108dshift(b, p2) Bigint *b; int p2;
2109#else
2110dshift(Bigint *b, int p2) 3085dshift(Bigint *b, int p2)
2111#endif
2112{ 3086{
2113 int rv = hi0bits(b->x[b->wds-1]) - 4; 3087 int rv = hi0bits(b->x[b->wds-1]) - 4;
2114 if (p2 > 0) 3088 if (p2 > 0)
@@ -2117,12 +3091,7 @@ dshift(Bigint *b, int p2)
2117 } 3091 }
2118 3092
2119 static int 3093 static int
2120quorem 3094quorem(Bigint *b, Bigint *S)
2121#ifdef KR_headers
2122 (b, S) Bigint *b, *S;
2123#else
2124 (Bigint *b, Bigint *S)
2125#endif
2126{ 3095{
2127 int n; 3096 int n;
2128 ULong *bx, *bxe, q, *sx, *sxe; 3097 ULong *bx, *bxe, q, *sx, *sxe;
@@ -2242,12 +3211,7 @@ quorem
2242 3211
2243#if defined(Avoid_Underflow) || !defined(NO_STRTOD_BIGCOMP) /*{*/ 3212#if defined(Avoid_Underflow) || !defined(NO_STRTOD_BIGCOMP) /*{*/
2244 static double 3213 static double
2245sulp 3214sulp(U *x, BCinfo *bc)
2246#ifdef KR_headers
2247 (x, bc) U *x; BCinfo *bc;
2248#else
2249 (U *x, BCinfo *bc)
2250#endif
2251{ 3215{
2252 U u; 3216 U u;
2253 double rv; 3217 double rv;
@@ -2264,13 +3228,7 @@ sulp
2264 3228
2265#ifndef NO_STRTOD_BIGCOMP 3229#ifndef NO_STRTOD_BIGCOMP
2266 static void 3230 static void
2267bigcomp 3231bigcomp(U *rv, const char *s0, BCinfo *bc MTd)
2268#ifdef KR_headers
2269 (rv, s0, bc)
2270 U *rv; CONST char *s0; BCinfo *bc;
2271#else
2272 (U *rv, const char *s0, BCinfo *bc)
2273#endif
2274{ 3232{
2275 Bigint *b, *d; 3233 Bigint *b, *d;
2276 int b2, bbits, d2, dd, dig, dsign, i, j, nd, nd0, p2, p5, speccase; 3234 int b2, bbits, d2, dd, dig, dsign, i, j, nd, nd0, p2, p5, speccase;
@@ -2283,7 +3241,7 @@ bigcomp
2283#ifndef Sudden_Underflow 3241#ifndef Sudden_Underflow
2284 if (rv->d == 0.) { /* special case: value near underflow-to-zero */ 3242 if (rv->d == 0.) { /* special case: value near underflow-to-zero */
2285 /* threshold was rounded to zero */ 3243 /* threshold was rounded to zero */
2286 b = i2b(1); 3244 b = i2b(1 MTa);
2287 p2 = Emin - P + 1; 3245 p2 = Emin - P + 1;
2288 bbits = 1; 3246 bbits = 1;
2289#ifdef Avoid_Underflow 3247#ifdef Avoid_Underflow
@@ -2304,7 +3262,7 @@ bigcomp
2304 } 3262 }
2305 else 3263 else
2306#endif 3264#endif
2307 b = d2b(rv, &p2, &bbits); 3265 b = d2b(rv, &p2, &bbits MTa);
2308#ifdef Avoid_Underflow 3266#ifdef Avoid_Underflow
2309 p2 -= bc->scale; 3267 p2 -= bc->scale;
2310#endif 3268#endif
@@ -2313,8 +3271,8 @@ bigcomp
2313 i = P - bbits; 3271 i = P - bbits;
2314 if (i > (j = P - Emin - 1 + p2)) { 3272 if (i > (j = P - Emin - 1 + p2)) {
2315#ifdef Sudden_Underflow 3273#ifdef Sudden_Underflow
2316 Bfree(b); 3274 Bfree(b MTa);
2317 b = i2b(1); 3275 b = i2b(1 MTa);
2318 p2 = Emin; 3276 p2 = Emin;
2319 i = P - 1; 3277 i = P - 1;
2320#ifdef Avoid_Underflow 3278#ifdef Avoid_Underflow
@@ -2330,28 +3288,28 @@ bigcomp
2330#ifdef Honor_FLT_ROUNDS 3288#ifdef Honor_FLT_ROUNDS
2331 if (bc->rounding != 1) { 3289 if (bc->rounding != 1) {
2332 if (i > 0) 3290 if (i > 0)
2333 b = lshift(b, i); 3291 b = lshift(b, i MTa);
2334 if (dsign) 3292 if (dsign)
2335 b = increment(b); 3293 b = increment(b MTa);
2336 } 3294 }
2337 else 3295 else
2338#endif 3296#endif
2339 { 3297 {
2340 b = lshift(b, ++i); 3298 b = lshift(b, ++i MTa);
2341 b->x[0] |= 1; 3299 b->x[0] |= 1;
2342 } 3300 }
2343#ifndef Sudden_Underflow 3301#ifndef Sudden_Underflow
2344 have_i: 3302 have_i:
2345#endif 3303#endif
2346 p2 -= p5 + i; 3304 p2 -= p5 + i;
2347 d = i2b(1); 3305 d = i2b(1 MTa);
2348 /* Arrange for convenient computation of quotients: 3306 /* Arrange for convenient computation of quotients:
2349 * shift left if necessary so divisor has 4 leading 0 bits. 3307 * shift left if necessary so divisor has 4 leading 0 bits.
2350 */ 3308 */
2351 if (p5 > 0) 3309 if (p5 > 0)
2352 d = pow5mult(d, p5); 3310 d = pow5mult(d, p5 MTa);
2353 else if (p5 < 0) 3311 else if (p5 < 0)
2354 b = pow5mult(b, -p5); 3312 b = pow5mult(b, -p5 MTa);
2355 if (p2 > 0) { 3313 if (p2 > 0) {
2356 b2 = p2; 3314 b2 = p2;
2357 d2 = 0; 3315 d2 = 0;
@@ -2362,15 +3320,15 @@ bigcomp
2362 } 3320 }
2363 i = dshift(d, d2); 3321 i = dshift(d, d2);
2364 if ((b2 += i) > 0) 3322 if ((b2 += i) > 0)
2365 b = lshift(b, b2); 3323 b = lshift(b, b2 MTa);
2366 if ((d2 += i) > 0) 3324 if ((d2 += i) > 0)
2367 d = lshift(d, d2); 3325 d = lshift(d, d2 MTa);
2368 3326
2369 /* Now b/d = exactly half-way between the two floating-point values */ 3327 /* Now b/d = exactly half-way between the two floating-point values */
2370 /* on either side of the input string. Compute first digit of b/d. */ 3328 /* on either side of the input string. Compute first digit of b/d. */
2371 3329
2372 if (!(dig = quorem(b,d))) { 3330 if (!(dig = quorem(b,d))) {
2373 b = multadd(b, 10, 0); /* very unlikely */ 3331 b = multadd(b, 10, 0 MTa); /* very unlikely */
2374 dig = quorem(b,d); 3332 dig = quorem(b,d);
2375 } 3333 }
2376 3334
@@ -2384,7 +3342,7 @@ bigcomp
2384 dd = 1; 3342 dd = 1;
2385 goto ret; 3343 goto ret;
2386 } 3344 }
2387 b = multadd(b, 10, 0); 3345 b = multadd(b, 10, 0 MTa);
2388 dig = quorem(b,d); 3346 dig = quorem(b,d);
2389 } 3347 }
2390 for(j = bc->dp1; i++ < nd;) { 3348 for(j = bc->dp1; i++ < nd;) {
@@ -2395,14 +3353,14 @@ bigcomp
2395 dd = 1; 3353 dd = 1;
2396 goto ret; 3354 goto ret;
2397 } 3355 }
2398 b = multadd(b, 10, 0); 3356 b = multadd(b, 10, 0 MTa);
2399 dig = quorem(b,d); 3357 dig = quorem(b,d);
2400 } 3358 }
2401 if (b->x[0] || b->wds > 1) 3359 if (dig > 0 || b->x[0] || b->wds > 1)
2402 dd = -1; 3360 dd = -1;
2403 ret: 3361 ret:
2404 Bfree(b); 3362 Bfree(b MTa);
2405 Bfree(d); 3363 Bfree(d MTa);
2406#ifdef Honor_FLT_ROUNDS 3364#ifdef Honor_FLT_ROUNDS
2407 if (bc->rounding != 1) { 3365 if (bc->rounding != 1) {
2408 if (dd < 0) { 3366 if (dd < 0) {
@@ -2451,10 +3409,10 @@ retlow1:
2451 if ((j = ((word0(rv) & Exp_mask) >> Exp_shift) - bc->scale) <= 0) { 3409 if ((j = ((word0(rv) & Exp_mask) >> Exp_shift) - bc->scale) <= 0) {
2452 i = 1 - j; 3410 i = 1 - j;
2453 if (i <= 31) { 3411 if (i <= 31) {
2454 if (word1(rv) & (0x1U << i)) 3412 if (word1(rv) & (0x1 << i))
2455 goto odd; 3413 goto odd;
2456 } 3414 }
2457 else if (word0(rv) & (0x1U << (i-32))) 3415 else if (word0(rv) & (0x1 << (i-32)))
2458 goto odd; 3416 goto odd;
2459 } 3417 }
2460 else if (word1(rv) & 1) { 3418 else if (word1(rv) & 1) {
@@ -2473,26 +3431,22 @@ retlow1:
2473#endif /* NO_STRTOD_BIGCOMP */ 3431#endif /* NO_STRTOD_BIGCOMP */
2474 3432
2475 double 3433 double
2476fpconv_strtod 3434fpconv_strtod(const char *s00, char **se)
2477#ifdef KR_headers
2478 (s00, se) CONST char *s00; char **se;
2479#else
2480 (const char *s00, char **se)
2481#endif
2482{ 3435{
2483 int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1; 3436 int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
2484 int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign; 3437 int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign;
2485 CONST char *s, *s0, *s1; 3438 const char *s, *s0, *s1;
2486 double aadj, aadj1; 3439 double aadj, aadj1;
2487 Long L; 3440 Long L;
2488 U aadj2, adj, rv, rv0; 3441 U aadj2, adj, rv, rv0;
2489 ULong y, z; 3442 ULong y, z;
2490 BCinfo bc; 3443 BCinfo bc;
2491 Bigint *bb1, *bd0; 3444 Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
2492 Bigint *bb = NULL; 3445#ifdef USE_BF96
2493 Bigint *bd = NULL; 3446 ULLong bhi, blo, brv, t00, t01, t02, t10, t11, terv, tg, tlo, yz;
2494 Bigint *bs = NULL; 3447 const BF96 *p10;
2495 Bigint *delta = NULL; 3448 int bexact, erv;
3449#endif
2496#ifdef Avoid_Underflow 3450#ifdef Avoid_Underflow
2497 ULong Lsb, Lsb1; 3451 ULong Lsb, Lsb1;
2498#endif 3452#endif
@@ -2502,6 +3456,9 @@ fpconv_strtod
2502#ifndef NO_STRTOD_BIGCOMP 3456#ifndef NO_STRTOD_BIGCOMP
2503 int req_bigcomp = 0; 3457 int req_bigcomp = 0;
2504#endif 3458#endif
3459#ifdef MULTIPLE_THREADS
3460 ThInfo *TI = 0;
3461#endif
2505#ifdef Honor_FLT_ROUNDS /*{*/ 3462#ifdef Honor_FLT_ROUNDS /*{*/
2506#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */ 3463#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
2507 bc.rounding = Flt_Rounds; 3464 bc.rounding = Flt_Rounds;
@@ -2515,7 +3472,7 @@ fpconv_strtod
2515#endif /*}}*/ 3472#endif /*}}*/
2516#endif /*}*/ 3473#endif /*}*/
2517#ifdef USE_LOCALE 3474#ifdef USE_LOCALE
2518 CONST char *s2; 3475 const char *s2;
2519#endif 3476#endif
2520 3477
2521 sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0; 3478 sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0;
@@ -2547,9 +3504,9 @@ fpconv_strtod
2547 case 'x': 3504 case 'x':
2548 case 'X': 3505 case 'X':
2549#ifdef Honor_FLT_ROUNDS 3506#ifdef Honor_FLT_ROUNDS
2550 gethex(&s, &rv, bc.rounding, sign); 3507 gethex(&s, &rv, bc.rounding, sign MTb);
2551#else 3508#else
2552 gethex(&s, &rv, 1, sign); 3509 gethex(&s, &rv, 1, sign MTb);
2553#endif 3510#endif
2554 goto ret; 3511 goto ret;
2555 } 3512 }
@@ -2560,12 +3517,20 @@ fpconv_strtod
2560 goto ret; 3517 goto ret;
2561 } 3518 }
2562 s0 = s; 3519 s0 = s;
3520 nd = nf = 0;
3521#ifdef USE_BF96
3522 yz = 0;
3523 for(; (c = *s) >= '0' && c <= '9'; nd++, s++)
3524 if (nd < 19)
3525 yz = 10*yz + c - '0';
3526#else
2563 y = z = 0; 3527 y = z = 0;
2564 for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++) 3528 for(; (c = *s) >= '0' && c <= '9'; nd++, s++)
2565 if (nd < 9) 3529 if (nd < 9)
2566 y = 10*y + c - '0'; 3530 y = 10*y + c - '0';
2567 else if (nd < 16) 3531 else if (nd < DBL_DIG + 2)
2568 z = 10*z + c - '0'; 3532 z = 10*z + c - '0';
3533#endif
2569 nd0 = nd; 3534 nd0 = nd;
2570 bc.dp0 = bc.dp1 = s - s0; 3535 bc.dp0 = bc.dp1 = s - s0;
2571 for(s1 = s; s1 > s0 && *--s1 == '0'; ) 3536 for(s1 = s; s1 > s0 && *--s1 == '0'; )
@@ -2611,15 +3576,26 @@ fpconv_strtod
2611 nz++; 3576 nz++;
2612 if (c -= '0') { 3577 if (c -= '0') {
2613 nf += nz; 3578 nf += nz;
2614 for(i = 1; i < nz; i++) 3579 i = 1;
3580#ifdef USE_BF96
3581 for(; i < nz; ++i) {
3582 if (++nd <= 19)
3583 yz *= 10;
3584 }
3585 if (++nd <= 19)
3586 yz = 10*yz + c;
3587#else
3588 for(; i < nz; ++i) {
2615 if (nd++ < 9) 3589 if (nd++ < 9)
2616 y *= 10; 3590 y *= 10;
2617 else if (nd <= DBL_DIG + 1) 3591 else if (nd <= DBL_DIG + 2)
2618 z *= 10; 3592 z *= 10;
3593 }
2619 if (nd++ < 9) 3594 if (nd++ < 9)
2620 y = 10*y + c; 3595 y = 10*y + c;
2621 else if (nd <= DBL_DIG + 1) 3596 else if (nd <= DBL_DIG + 2)
2622 z = 10*z + c; 3597 z = 10*z + c;
3598#endif
2623 nz = nz1 = 0; 3599 nz = nz1 = 0;
2624 } 3600 }
2625 } 3601 }
@@ -2664,7 +3640,7 @@ fpconv_strtod
2664 } 3640 }
2665 if (!nd) { 3641 if (!nd) {
2666 if (!nz && !nz0) { 3642 if (!nz && !nz0) {
2667#ifdef INFNAN_CHECK 3643#ifdef INFNAN_CHECK /*{*/
2668 /* Check for Nan and Infinity */ 3644 /* Check for Nan and Infinity */
2669 if (!bc.dplen) 3645 if (!bc.dplen)
2670 switch(c) { 3646 switch(c) {
@@ -2691,7 +3667,7 @@ fpconv_strtod
2691 goto ret; 3667 goto ret;
2692 } 3668 }
2693 } 3669 }
2694#endif /* INFNAN_CHECK */ 3670#endif /*} INFNAN_CHECK */
2695 ret0: 3671 ret0:
2696 s = s00; 3672 s = s00;
2697 sign = 0; 3673 sign = 0;
@@ -2707,7 +3683,8 @@ fpconv_strtod
2707 3683
2708 if (!nd0) 3684 if (!nd0)
2709 nd0 = nd; 3685 nd0 = nd;
2710 k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1; 3686#ifndef USE_BF96
3687 k = nd < DBL_DIG + 2 ? nd : DBL_DIG + 2;
2711 dval(&rv) = y; 3688 dval(&rv) = y;
2712 if (k > 9) { 3689 if (k > 9) {
2713#ifdef SET_INEXACT 3690#ifdef SET_INEXACT
@@ -2716,6 +3693,7 @@ fpconv_strtod
2716#endif 3693#endif
2717 dval(&rv) = tens[k - 9] * dval(&rv) + z; 3694 dval(&rv) = tens[k - 9] * dval(&rv) + z;
2718 } 3695 }
3696#endif
2719 bd0 = 0; 3697 bd0 = 0;
2720 if (nd <= DBL_DIG 3698 if (nd <= DBL_DIG
2721#ifndef RND_PRODQUOT 3699#ifndef RND_PRODQUOT
@@ -2724,11 +3702,18 @@ fpconv_strtod
2724#endif 3702#endif
2725#endif 3703#endif
2726 ) { 3704 ) {
3705#ifdef USE_BF96
3706 dval(&rv) = yz;
3707#endif
2727 if (!e) 3708 if (!e)
2728 goto ret; 3709 goto ret;
2729#ifndef ROUND_BIASED_without_Round_Up 3710#ifndef ROUND_BIASED_without_Round_Up
2730 if (e > 0) { 3711 if (e > 0) {
2731 if (e <= Ten_pmax) { 3712 if (e <= Ten_pmax) {
3713#ifdef SET_INEXACT
3714 bc.inexact = 0;
3715 oldinexact = 1;
3716#endif
2732#ifdef VAX 3717#ifdef VAX
2733 goto vax_ovfl_check; 3718 goto vax_ovfl_check;
2734#else 3719#else
@@ -2748,6 +3733,10 @@ fpconv_strtod
2748 /* A fancier test would sometimes let us do 3733 /* A fancier test would sometimes let us do
2749 * this for larger i values. 3734 * this for larger i values.
2750 */ 3735 */
3736#ifdef SET_INEXACT
3737 bc.inexact = 0;
3738 oldinexact = 1;
3739#endif
2751#ifdef Honor_FLT_ROUNDS 3740#ifdef Honor_FLT_ROUNDS
2752 /* round correctly FLT_ROUNDS = 2 or 3 */ 3741 /* round correctly FLT_ROUNDS = 2 or 3 */
2753 if (sign) { 3742 if (sign) {
@@ -2776,6 +3765,10 @@ fpconv_strtod
2776 } 3765 }
2777#ifndef Inaccurate_Divide 3766#ifndef Inaccurate_Divide
2778 else if (e >= -Ten_pmax) { 3767 else if (e >= -Ten_pmax) {
3768#ifdef SET_INEXACT
3769 bc.inexact = 0;
3770 oldinexact = 1;
3771#endif
2779#ifdef Honor_FLT_ROUNDS 3772#ifdef Honor_FLT_ROUNDS
2780 /* round correctly FLT_ROUNDS = 2 or 3 */ 3773 /* round correctly FLT_ROUNDS = 2 or 3 */
2781 if (sign) { 3774 if (sign) {
@@ -2789,16 +3782,18 @@ fpconv_strtod
2789#endif 3782#endif
2790#endif /* ROUND_BIASED_without_Round_Up */ 3783#endif /* ROUND_BIASED_without_Round_Up */
2791 } 3784 }
2792 e1 += nd - k; 3785#ifdef USE_BF96
3786 k = nd < 19 ? nd : 19;
3787#endif
3788 e1 += nd - k; /* scale factor = 10^e1 */
2793 3789
2794#ifdef IEEE_Arith 3790#ifdef IEEE_Arith
2795#ifdef SET_INEXACT 3791#ifdef SET_INEXACT
2796 bc.inexact = 1; 3792 bc.inexact = 1;
3793#ifndef USE_BF96
2797 if (k <= DBL_DIG) 3794 if (k <= DBL_DIG)
2798 oldinexact = get_inexact();
2799#endif 3795#endif
2800#ifdef Avoid_Underflow 3796 oldinexact = get_inexact();
2801 bc.scale = 0;
2802#endif 3797#endif
2803#ifdef Honor_FLT_ROUNDS 3798#ifdef Honor_FLT_ROUNDS
2804 if (bc.rounding >= 2) { 3799 if (bc.rounding >= 2) {
@@ -2811,6 +3806,315 @@ fpconv_strtod
2811#endif 3806#endif
2812#endif /*IEEE_Arith*/ 3807#endif /*IEEE_Arith*/
2813 3808
3809#ifdef USE_BF96 /*{*/
3810 Debug(++dtoa_stats[0]);
3811 i = e1 + 342;
3812 if (i < 0)
3813 goto undfl;
3814 if (i > 650)
3815 goto ovfl;
3816 p10 = &pten[i];
3817 brv = yz;
3818 /* shift brv left, with i = number of bits shifted */
3819 i = 0;
3820 if (!(brv & 0xffffffff00000000ull)) {
3821 i = 32;
3822 brv <<= 32;
3823 }
3824 if (!(brv & 0xffff000000000000ull)) {
3825 i += 16;
3826 brv <<= 16;
3827 }
3828 if (!(brv & 0xff00000000000000ull)) {
3829 i += 8;
3830 brv <<= 8;
3831 }
3832 if (!(brv & 0xf000000000000000ull)) {
3833 i += 4;
3834 brv <<= 4;
3835 }
3836 if (!(brv & 0xc000000000000000ull)) {
3837 i += 2;
3838 brv <<= 2;
3839 }
3840 if (!(brv & 0x8000000000000000ull)) {
3841 i += 1;
3842 brv <<= 1;
3843 }
3844 erv = (64 + 0x3fe) + p10->e - i;
3845 if (erv <= 0 && nd > 19)
3846 goto many_digits; /* denormal: may need to look at all digits */
3847 bhi = brv >> 32;
3848 blo = brv & 0xffffffffull;
3849 /* Unsigned 32-bit ints lie in [0,2^32-1] and */
3850 /* unsigned 64-bit ints lie in [0, 2^64-1]. The product of two unsigned */
3851 /* 32-bit ints is <= 2^64 - 2*2^32-1 + 1 = 2^64 - 1 - 2*(2^32 - 1), so */
3852 /* we can add two unsigned 32-bit ints to the product of two such ints, */
3853 /* and 64 bits suffice to contain the result. */
3854 t01 = bhi * p10->b1;
3855 t10 = blo * p10->b0 + (t01 & 0xffffffffull);
3856 t00 = bhi * p10->b0 + (t01 >> 32) + (t10 >> 32);
3857 if (t00 & 0x8000000000000000ull) {
3858 if ((t00 & 0x3ff) && (~t00 & 0x3fe)) { /* unambiguous result? */
3859 if (nd > 19 && ((t00 + (1<<i) + 2) & 0x400) ^ (t00 & 0x400))
3860 goto many_digits;
3861 if (erv <= 0)
3862 goto denormal;
3863#ifdef Honor_FLT_ROUNDS
3864 switch(bc.rounding) {
3865 case 0: goto noround;
3866 case 2: goto roundup;
3867 }
3868#endif
3869 if (t00 & 0x400 && t00 & 0xbff)
3870 goto roundup;
3871 goto noround;
3872 }
3873 }
3874 else {
3875 if ((t00 & 0x1ff) && (~t00 & 0x1fe)) { /* unambiguous result? */
3876 if (nd > 19 && ((t00 + (1<<i) + 2) & 0x200) ^ (t00 & 0x200))
3877 goto many_digits;
3878 if (erv <= 1)
3879 goto denormal1;
3880#ifdef Honor_FLT_ROUNDS
3881 switch(bc.rounding) {
3882 case 0: goto noround1;
3883 case 2: goto roundup1;
3884 }
3885#endif
3886 if (t00 & 0x200)
3887 goto roundup1;
3888 goto noround1;
3889 }
3890 }
3891 /* 3 multiplies did not suffice; try a 96-bit approximation */
3892 Debug(++dtoa_stats[1]);
3893 t02 = bhi * p10->b2;
3894 t11 = blo * p10->b1 + (t02 & 0xffffffffull);
3895 bexact = 1;
3896 if (e1 < 0 || e1 > 41 || (t10 | t11) & 0xffffffffull || nd > 19)
3897 bexact = 0;
3898 tlo = (t10 & 0xffffffffull) + (t02 >> 32) + (t11 >> 32);
3899 if (!bexact && (tlo + 0x10) >> 32 > tlo >> 32)
3900 goto many_digits;
3901 t00 += tlo >> 32;
3902 if (t00 & 0x8000000000000000ull) {
3903 if (erv <= 0) { /* denormal result */
3904 if (nd >= 20 || !((tlo & 0xfffffff0) | (t00 & 0x3ff)))
3905 goto many_digits;
3906 denormal:
3907 if (erv <= -52) {
3908#ifdef Honor_FLT_ROUNDS
3909 switch(bc.rounding) {
3910 case 0: goto undfl;
3911 case 2: goto tiniest;
3912 }
3913#endif
3914 if (erv < -52 || !(t00 & 0x7fffffffffffffffull))
3915 goto undfl;
3916 goto tiniest;
3917 }
3918 tg = 1ull << (11 - erv);
3919 t00 &= ~(tg - 1); /* clear low bits */
3920#ifdef Honor_FLT_ROUNDS
3921 switch(bc.rounding) {
3922 case 0: goto noround_den;
3923 case 2: goto roundup_den;
3924 }
3925#endif
3926 if (t00 & tg) {
3927#ifdef Honor_FLT_ROUNDS
3928 roundup_den:
3929#endif
3930 t00 += tg << 1;
3931 if (!(t00 & 0x8000000000000000ull)) {
3932 if (++erv > 0)
3933 goto smallest_normal;
3934 t00 = 0x8000000000000000ull;
3935 }
3936 }
3937#ifdef Honor_FLT_ROUNDS
3938 noround_den:
3939#endif
3940 LLval(&rv) = t00 >> (12 - erv);
3941 Set_errno(ERANGE);
3942 goto ret;
3943 }
3944 if (bexact) {
3945#ifdef SET_INEXACT
3946 if (!(t00 & 0x7ff) && !(tlo & 0xffffffffull)) {
3947 bc.inexact = 0;
3948 goto noround;
3949 }
3950#endif
3951#ifdef Honor_FLT_ROUNDS
3952 switch(bc.rounding) {
3953 case 2:
3954 if (t00 & 0x7ff)
3955 goto roundup;
3956 case 0: goto noround;
3957 }
3958#endif
3959 if (t00 & 0x400 && (tlo & 0xffffffff) | (t00 & 0xbff))
3960 goto roundup;
3961 goto noround;
3962 }
3963 if ((tlo & 0xfffffff0) | (t00 & 0x3ff)
3964 && (nd <= 19 || ((t00 + (1ull << i)) & 0xfffffffffffffc00ull)
3965 == (t00 & 0xfffffffffffffc00ull))) {
3966 /* Unambiguous result. */
3967 /* If nd > 19, then incrementing the 19th digit */
3968 /* does not affect rv. */
3969#ifdef Honor_FLT_ROUNDS
3970 switch(bc.rounding) {
3971 case 0: goto noround;
3972 case 2: goto roundup;
3973 }
3974#endif
3975 if (t00 & 0x400) { /* round up */
3976 roundup:
3977 t00 += 0x800;
3978 if (!(t00 & 0x8000000000000000ull)) {
3979 /* rounded up to a power of 2 */
3980 if (erv >= 0x7fe)
3981 goto ovfl;
3982 terv = erv + 1;
3983 LLval(&rv) = terv << 52;
3984 goto ret;
3985 }
3986 }
3987 noround:
3988 if (erv >= 0x7ff)
3989 goto ovfl;
3990 terv = erv;
3991 LLval(&rv) = (terv << 52) | ((t00 & 0x7ffffffffffff800ull) >> 11);
3992 goto ret;
3993 }
3994 }
3995 else {
3996 if (erv <= 1) { /* denormal result */
3997 if (nd >= 20 || !((tlo & 0xfffffff0) | (t00 & 0x1ff)))
3998 goto many_digits;
3999 denormal1:
4000 if (erv <= -51) {
4001#ifdef Honor_FLT_ROUNDS
4002 switch(bc.rounding) {
4003 case 0: goto undfl;
4004 case 2: goto tiniest;
4005 }
4006#endif
4007 if (erv < -51 || !(t00 & 0x3fffffffffffffffull))
4008 goto undfl;
4009 tiniest:
4010 LLval(&rv) = 1;
4011 Set_errno(ERANGE);
4012 goto ret;
4013 }
4014 tg = 1ull << (11 - erv);
4015#ifdef Honor_FLT_ROUNDS
4016 switch(bc.rounding) {
4017 case 0: goto noround1_den;
4018 case 2: goto roundup1_den;
4019 }
4020#endif
4021 if (t00 & tg) {
4022#ifdef Honor_FLT_ROUNDS
4023 roundup1_den:
4024#endif
4025 if (0x8000000000000000ull & (t00 += (tg<<1)) && erv == 1) {
4026
4027 smallest_normal:
4028 LLval(&rv) = 0x0010000000000000ull;
4029 goto ret;
4030 }
4031 }
4032#ifdef Honor_FLT_ROUNDS
4033 noround1_den:
4034#endif
4035 if (erv <= -52)
4036 goto undfl;
4037 LLval(&rv) = t00 >> (12 - erv);
4038 Set_errno(ERANGE);
4039 goto ret;
4040 }
4041 if (bexact) {
4042#ifdef SET_INEXACT
4043 if (!(t00 & 0x3ff) && !(tlo & 0xffffffffull)) {
4044 bc.inexact = 0;
4045 goto noround1;
4046 }
4047#endif
4048#ifdef Honor_FLT_ROUNDS
4049 switch(bc.rounding) {
4050 case 2:
4051 if (t00 & 0x3ff)
4052 goto roundup1;
4053 case 0: goto noround1;
4054 }
4055#endif
4056 if (t00 & 0x200 && (t00 & 0x5ff || tlo))
4057 goto roundup1;
4058 goto noround1;
4059 }
4060 if ((tlo & 0xfffffff0) | (t00 & 0x1ff)
4061 && (nd <= 19 || ((t00 + (1ull << i)) & 0x7ffffffffffffe00ull)
4062 == (t00 & 0x7ffffffffffffe00ull))) {
4063 /* Unambiguous result. */
4064#ifdef Honor_FLT_ROUNDS
4065 switch(bc.rounding) {
4066 case 0: goto noround1;
4067 case 2: goto roundup1;
4068 }
4069#endif
4070 if (t00 & 0x200) { /* round up */
4071 roundup1:
4072 t00 += 0x400;
4073 if (!(t00 & 0x4000000000000000ull)) {
4074 /* rounded up to a power of 2 */
4075 if (erv >= 0x7ff)
4076 goto ovfl;
4077 terv = erv;
4078 LLval(&rv) = terv << 52;
4079 goto ret;
4080 }
4081 }
4082 noround1:
4083 if (erv >= 0x800)
4084 goto ovfl;
4085 terv = erv - 1;
4086 LLval(&rv) = (terv << 52) | ((t00 & 0x3ffffffffffffc00ull) >> 10);
4087 goto ret;
4088 }
4089 }
4090 many_digits:
4091 Debug(++dtoa_stats[2]);
4092 if (nd > 17) {
4093 if (nd > 18) {
4094 yz /= 100;
4095 e1 += 2;
4096 }
4097 else {
4098 yz /= 10;
4099 e1 += 1;
4100 }
4101 y = yz / 100000000;
4102 }
4103 else if (nd > 9) {
4104 i = nd - 9;
4105 y = (yz >> i) / pfive[i-1];
4106 }
4107 else
4108 y = yz;
4109 dval(&rv) = yz;
4110#endif /*}*/
4111
4112#ifdef IEEE_Arith
4113#ifdef Avoid_Underflow
4114 bc.scale = 0;
4115#endif
4116#endif /*IEEE_Arith*/
4117
2814 /* Get starting approximation = rv * 10**e1 */ 4118 /* Get starting approximation = rv * 10**e1 */
2815 4119
2816 if (e1 > 0) { 4120 if (e1 > 0) {
@@ -2847,15 +4151,13 @@ fpconv_strtod
2847#endif /*IEEE_Arith*/ 4151#endif /*IEEE_Arith*/
2848 range_err: 4152 range_err:
2849 if (bd0) { 4153 if (bd0) {
2850 Bfree(bb); 4154 Bfree(bb MTb);
2851 Bfree(bd); 4155 Bfree(bd MTb);
2852 Bfree(bs); 4156 Bfree(bs MTb);
2853 Bfree(bd0); 4157 Bfree(bd0 MTb);
2854 Bfree(delta); 4158 Bfree(delta MTb);
2855 } 4159 }
2856#ifndef NO_ERRNO 4160 Set_errno(ERANGE);
2857 errno = ERANGE;
2858#endif
2859 goto ret; 4161 goto ret;
2860 } 4162 }
2861 e1 >>= 4; 4163 e1 >>= 4;
@@ -2920,6 +4222,10 @@ fpconv_strtod
2920 if (!dval(&rv)) { 4222 if (!dval(&rv)) {
2921 undfl: 4223 undfl:
2922 dval(&rv) = 0.; 4224 dval(&rv) = 0.;
4225#ifdef Honor_FLT_ROUNDS
4226 if (bc.rounding == 2)
4227 word1(&rv) = 1;
4228#endif
2923 goto range_err; 4229 goto range_err;
2924 } 4230 }
2925#ifndef Avoid_Underflow 4231#ifndef Avoid_Underflow
@@ -2969,13 +4275,13 @@ fpconv_strtod
2969 } 4275 }
2970 } 4276 }
2971#endif 4277#endif
2972 bd0 = s2b(s0, nd0, nd, y, bc.dplen); 4278 bd0 = s2b(s0, nd0, nd, y, bc.dplen MTb);
2973 4279
2974 for(;;) { 4280 for(;;) {
2975 bd = Balloc(bd0->k); 4281 bd = Balloc(bd0->k MTb);
2976 Bcopy(bd, bd0); 4282 Bcopy(bd, bd0);
2977 bb = d2b(&rv, &bbe, &bbbits); /* rv = bb * 2^bbe */ 4283 bb = d2b(&rv, &bbe, &bbbits MTb); /* rv = bb * 2^bbe */
2978 bs = i2b(1); 4284 bs = i2b(1 MTb);
2979 4285
2980 if (e >= 0) { 4286 if (e >= 0) {
2981 bb2 = bb5 = 0; 4287 bb2 = bb5 = 0;
@@ -3040,20 +4346,20 @@ fpconv_strtod
3040 bs2 -= i; 4346 bs2 -= i;
3041 } 4347 }
3042 if (bb5 > 0) { 4348 if (bb5 > 0) {
3043 bs = pow5mult(bs, bb5); 4349 bs = pow5mult(bs, bb5 MTb);
3044 bb1 = mult(bs, bb); 4350 bb1 = mult(bs, bb MTb);
3045 Bfree(bb); 4351 Bfree(bb MTb);
3046 bb = bb1; 4352 bb = bb1;
3047 } 4353 }
3048 if (bb2 > 0) 4354 if (bb2 > 0)
3049 bb = lshift(bb, bb2); 4355 bb = lshift(bb, bb2 MTb);
3050 if (bd5 > 0) 4356 if (bd5 > 0)
3051 bd = pow5mult(bd, bd5); 4357 bd = pow5mult(bd, bd5 MTb);
3052 if (bd2 > 0) 4358 if (bd2 > 0)
3053 bd = lshift(bd, bd2); 4359 bd = lshift(bd, bd2 MTb);
3054 if (bs2 > 0) 4360 if (bs2 > 0)
3055 bs = lshift(bs, bs2); 4361 bs = lshift(bs, bs2 MTb);
3056 delta = diff(bb, bd); 4362 delta = diff(bb, bd MTb);
3057 bc.dsign = delta->sign; 4363 bc.dsign = delta->sign;
3058 delta->sign = 0; 4364 delta->sign = 0;
3059 i = cmp(delta, bs); 4365 i = cmp(delta, bs);
@@ -3104,7 +4410,7 @@ fpconv_strtod
3104 if (y) 4410 if (y)
3105#endif 4411#endif
3106 { 4412 {
3107 delta = lshift(delta,Log2P); 4413 delta = lshift(delta,Log2P MTb);
3108 if (cmp(delta, bs) <= 0) 4414 if (cmp(delta, bs) <= 0)
3109 adj.d = -0.5; 4415 adj.d = -0.5;
3110 } 4416 }
@@ -3196,7 +4502,7 @@ fpconv_strtod
3196#endif 4502#endif
3197 break; 4503 break;
3198 } 4504 }
3199 delta = lshift(delta,Log2P); 4505 delta = lshift(delta,Log2P MTb);
3200 if (cmp(delta, bs) > 0) 4506 if (cmp(delta, bs) > 0)
3201 goto drop_down; 4507 goto drop_down;
3202 break; 4508 break;
@@ -3406,8 +4712,7 @@ fpconv_strtod
3406 goto undfl; 4712 goto undfl;
3407#else 4713#else
3408 { 4714 {
3409 if (bc.nd > nd) 4715 req_bigcomp = 1;
3410 bc.dsign = 1;
3411 break; 4716 break;
3412 } 4717 }
3413#endif 4718#endif
@@ -3487,21 +4792,21 @@ fpconv_strtod
3487 } 4792 }
3488#endif 4793#endif
3489 cont: 4794 cont:
3490 Bfree(bb); 4795 Bfree(bb MTb);
3491 Bfree(bd); 4796 Bfree(bd MTb);
3492 Bfree(bs); 4797 Bfree(bs MTb);
3493 Bfree(delta); 4798 Bfree(delta MTb);
3494 } 4799 }
3495 Bfree(bb); 4800 Bfree(bb MTb);
3496 Bfree(bd); 4801 Bfree(bd MTb);
3497 Bfree(bs); 4802 Bfree(bs MTb);
3498 Bfree(bd0); 4803 Bfree(bd0 MTb);
3499 Bfree(delta); 4804 Bfree(delta MTb);
3500#ifndef NO_STRTOD_BIGCOMP 4805#ifndef NO_STRTOD_BIGCOMP
3501 if (req_bigcomp) { 4806 if (req_bigcomp) {
3502 bd0 = 0; 4807 bd0 = 0;
3503 bc.e0 += nz1; 4808 bc.e0 += nz1;
3504 bigcomp(&rv, s0, &bc); 4809 bigcomp(&rv, s0, &bc MTb);
3505 y = word0(&rv) & Exp_mask; 4810 y = word0(&rv) & Exp_mask;
3506 if (y == Exp_mask) 4811 if (y == Exp_mask)
3507 goto ovfl; 4812 goto ovfl;
@@ -3509,17 +4814,6 @@ fpconv_strtod
3509 goto undfl; 4814 goto undfl;
3510 } 4815 }
3511#endif 4816#endif
3512#ifdef SET_INEXACT
3513 if (bc.inexact) {
3514 if (!oldinexact) {
3515 word0(&rv0) = Exp_1 + (70 << Exp_shift);
3516 word1(&rv0) = 0;
3517 dval(&rv0) += 1.;
3518 }
3519 }
3520 else if (!oldinexact)
3521 clear_inexact();
3522#endif
3523#ifdef Avoid_Underflow 4817#ifdef Avoid_Underflow
3524 if (bc.scale) { 4818 if (bc.scale) {
3525 word0(&rv0) = Exp_1 - 2*P*Exp_msk1; 4819 word0(&rv0) = Exp_1 - 2*P*Exp_msk1;
@@ -3532,18 +4826,27 @@ fpconv_strtod
3532#else 4826#else
3533 if (word0(&rv) == 0 && word1(&rv) == 0) 4827 if (word0(&rv) == 0 && word1(&rv) == 0)
3534#endif 4828#endif
3535 errno = ERANGE; 4829 Set_errno(ERANGE);
3536#endif 4830#endif
3537 } 4831 }
3538#endif /* Avoid_Underflow */ 4832#endif /* Avoid_Underflow */
4833 ret:
3539#ifdef SET_INEXACT 4834#ifdef SET_INEXACT
3540 if (bc.inexact && !(word0(&rv) & Exp_mask)) { 4835 if (bc.inexact) {
3541 /* set underflow bit */ 4836 if (!(word0(&rv) & Exp_mask)) {
3542 dval(&rv0) = 1e-300; 4837 /* set underflow and inexact bits */
3543 dval(&rv0) *= dval(&rv0); 4838 dval(&rv0) = 1e-300;
4839 dval(&rv0) *= dval(&rv0);
4840 }
4841 else if (!oldinexact) {
4842 word0(&rv0) = Exp_1 + (70 << Exp_shift);
4843 word1(&rv0) = 0;
4844 dval(&rv0) += 1.;
4845 }
3544 } 4846 }
4847 else if (!oldinexact)
4848 clear_inexact();
3545#endif 4849#endif
3546 ret:
3547 if (se) 4850 if (se)
3548 *se = (char *)s; 4851 *se = (char *)s;
3549 return sign ? -dval(&rv) : dval(&rv); 4852 return sign ? -dval(&rv) : dval(&rv);
@@ -3554,11 +4857,7 @@ fpconv_strtod
3554#endif 4857#endif
3555 4858
3556 static char * 4859 static char *
3557#ifdef KR_headers 4860rv_alloc(int i MTd)
3558rv_alloc(i) int i;
3559#else
3560rv_alloc(int i)
3561#endif
3562{ 4861{
3563 int j, k, *r; 4862 int j, k, *r;
3564 4863
@@ -3567,7 +4866,7 @@ rv_alloc(int i)
3567 sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i; 4866 sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
3568 j <<= 1) 4867 j <<= 1)
3569 k++; 4868 k++;
3570 r = (int*)Balloc(k); 4869 r = (int*)Balloc(k MTa);
3571 *r = k; 4870 *r = k;
3572 return 4871 return
3573#ifndef MULTIPLE_THREADS 4872#ifndef MULTIPLE_THREADS
@@ -3577,16 +4876,21 @@ rv_alloc(int i)
3577 } 4876 }
3578 4877
3579 static char * 4878 static char *
3580#ifdef KR_headers 4879nrv_alloc(const char *s, char *s0, size_t s0len, char **rve, int n MTd)
3581nrv_alloc(s, rve, n) char *s, **rve; int n;
3582#else
3583nrv_alloc(const char *s, char **rve, int n)
3584#endif
3585{ 4880{
3586 char *rv, *t; 4881 char *rv, *t;
3587 4882
3588 t = rv = rv_alloc(n); 4883 if (!s0)
3589 while((*t = *s++)) t++; 4884 s0 = rv_alloc(n MTa);
4885 else if (s0len <= n) {
4886 rv = 0;
4887 t = rv + n;
4888 goto rve_chk;
4889 }
4890 t = rv = s0;
4891 while((*t = *s++))
4892 ++t;
4893 rve_chk:
3590 if (rve) 4894 if (rve)
3591 *rve = t; 4895 *rve = t;
3592 return rv; 4896 return rv;
@@ -3599,15 +4903,14 @@ nrv_alloc(const char *s, char **rve, int n)
3599 */ 4903 */
3600 4904
3601 void 4905 void
3602#ifdef KR_headers
3603freedtoa(s) char *s;
3604#else
3605freedtoa(char *s) 4906freedtoa(char *s)
3606#endif
3607{ 4907{
4908#ifdef MULTIPLE_THREADS
4909 ThInfo *TI = 0;
4910#endif
3608 Bigint *b = (Bigint *)((int *)s - 1); 4911 Bigint *b = (Bigint *)((int *)s - 1);
3609 b->maxwds = 1 << (b->k = *(int*)b); 4912 b->maxwds = 1 << (b->k = *(int*)b);
3610 Bfree(b); 4913 Bfree(b MTb);
3611#ifndef MULTIPLE_THREADS 4914#ifndef MULTIPLE_THREADS
3612 if (s == dtoa_result) 4915 if (s == dtoa_result)
3613 dtoa_result = 0; 4916 dtoa_result = 0;
@@ -3649,13 +4952,7 @@ freedtoa(char *s)
3649 */ 4952 */
3650 4953
3651 char * 4954 char *
3652dtoa 4955dtoa_r(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve, char *buf, size_t blen)
3653#ifdef KR_headers
3654 (dd, mode, ndigits, decpt, sign, rve)
3655 double dd; int mode, ndigits, *decpt, *sign; char **rve;
3656#else
3657 (double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
3658#endif
3659{ 4956{
3660 /* Arguments ndigits, decpt, sign are similar to those 4957 /* Arguments ndigits, decpt, sign are similar to those
3661 of ecvt and fcvt; trailing zeros are suppressed from 4958 of ecvt and fcvt; trailing zeros are suppressed from
@@ -3687,30 +4984,52 @@ dtoa
3687 4984
3688 Values of mode other than 0-9 are treated as mode 0. 4985 Values of mode other than 0-9 are treated as mode 0.
3689 4986
3690 Sufficient space is allocated to the return value 4987 When not NULL, buf is an output buffer of length blen, which must
3691 to hold the suppressed trailing zeros. 4988 be large enough to accommodate suppressed trailing zeros and a trailing
4989 null byte. If blen is too small, rv = NULL is returned, in which case
4990 if rve is not NULL, a subsequent call with blen >= (*rve - rv) + 1
4991 should succeed in returning buf.
4992
4993 When buf is NULL, sufficient space is allocated for the return value,
4994 which, when done using, the caller should pass to freedtoa().
4995
4996 USE_BF is automatically defined when neither NO_LONG_LONG nor NO_BF96
4997 is defined.
3692 */ 4998 */
3693 4999
3694 int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1, 5000#ifdef MULTIPLE_THREADS
3695 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5, 5001 ThInfo *TI = 0;
3696 spec_case, try_quick; 5002#endif
3697 Long L; 5003 int bbits, b2, b5, be, dig, i, ilim, ilim1,
3698#ifndef Sudden_Underflow 5004 j, j1, k, leftright, m2, m5, s2, s5, spec_case;
5005#if !defined(Sudden_Underflow) || defined(USE_BF96)
3699 int denorm; 5006 int denorm;
3700 ULong x;
3701#endif 5007#endif
3702 Bigint *b, *b1, *delta, *mlo, *mhi, *S; 5008 Bigint *b, *b1, *delta, *mlo, *mhi, *S;
3703 U d2, eps, u; 5009 U u;
5010 char *s;
5011#ifdef SET_INEXACT
5012 int inexact, oldinexact;
5013#endif
5014#ifdef USE_BF96 /*{{*/
5015 BF96 *p10;
5016 ULLong dbhi, dbits, dblo, den, hb, rb, rblo, res, res0, res3, reslo, sres,
5017 sulp, tv0, tv1, tv2, tv3, ulp, ulplo, ulpmask, ures, ureslo, zb;
5018 int eulp, k1, n2, ulpadj, ulpshift;
5019#else /*}{*/
5020#ifndef Sudden_Underflow
5021 ULong x;
5022#endif
5023 Long L;
5024 U d2, eps;
3704 double ds; 5025 double ds;
3705 char *s, *s0; 5026 int ieps, ilim0, k0, k_check, try_quick;
3706#ifndef No_leftright 5027#ifndef No_leftright
3707#ifdef IEEE_Arith 5028#ifdef IEEE_Arith
3708 U eps1; 5029 U eps1;
3709#endif 5030#endif
3710#endif 5031#endif
3711#ifdef SET_INEXACT 5032#endif /*}}*/
3712 int inexact, oldinexact;
3713#endif
3714#ifdef Honor_FLT_ROUNDS /*{*/ 5033#ifdef Honor_FLT_ROUNDS /*{*/
3715 int Rounding; 5034 int Rounding;
3716#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */ 5035#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
@@ -3725,13 +5044,6 @@ dtoa
3725#endif /*}}*/ 5044#endif /*}}*/
3726#endif /*}*/ 5045#endif /*}*/
3727 5046
3728#ifndef MULTIPLE_THREADS
3729 if (dtoa_result) {
3730 freedtoa(dtoa_result);
3731 dtoa_result = 0;
3732 }
3733#endif
3734
3735 u.d = dd; 5047 u.d = dd;
3736 if (word0(&u) & Sign_bit) { 5048 if (word0(&u) & Sign_bit) {
3737 /* set sign for everything, including 0's and NaNs */ 5049 /* set sign for everything, including 0's and NaNs */
@@ -3752,9 +5064,9 @@ dtoa
3752 *decpt = 9999; 5064 *decpt = 9999;
3753#ifdef IEEE_Arith 5065#ifdef IEEE_Arith
3754 if (!word1(&u) && !(word0(&u) & 0xfffff)) 5066 if (!word1(&u) && !(word0(&u) & 0xfffff))
3755 return nrv_alloc("Infinity", rve, 8); 5067 return nrv_alloc("Infinity", buf, blen, rve, 8 MTb);
3756#endif 5068#endif
3757 return nrv_alloc("NaN", rve, 3); 5069 return nrv_alloc("NaN", buf, blen, rve, 3 MTb);
3758 } 5070 }
3759#endif 5071#endif
3760#ifdef IBM 5072#ifdef IBM
@@ -3762,11 +5074,14 @@ dtoa
3762#endif 5074#endif
3763 if (!dval(&u)) { 5075 if (!dval(&u)) {
3764 *decpt = 1; 5076 *decpt = 1;
3765 return nrv_alloc("0", rve, 1); 5077 return nrv_alloc("0", buf, blen, rve, 1 MTb);
3766 } 5078 }
3767 5079
3768#ifdef SET_INEXACT 5080#ifdef SET_INEXACT
3769 try_quick = oldinexact = get_inexact(); 5081#ifndef USE_BF96
5082 try_quick =
5083#endif
5084 oldinexact = get_inexact();
3770 inexact = 1; 5085 inexact = 1;
3771#endif 5086#endif
3772#ifdef Honor_FLT_ROUNDS 5087#ifdef Honor_FLT_ROUNDS
@@ -3778,8 +5093,58 @@ dtoa
3778 Rounding = 0; 5093 Rounding = 0;
3779 } 5094 }
3780#endif 5095#endif
5096#ifdef USE_BF96 /*{{*/
5097 dbits = (u.LL & 0xfffffffffffffull) << 11; /* fraction bits */
5098 if ((be = u.LL >> 52)) /* biased exponent; nonzero ==> normal */ {
5099 dbits |= 0x8000000000000000ull;
5100 denorm = ulpadj = 0;
5101 }
5102 else {
5103 denorm = 1;
5104 ulpadj = be + 1;
5105 dbits <<= 1;
5106 if (!(dbits & 0xffffffff00000000ull)) {
5107 dbits <<= 32;
5108 be -= 32;
5109 }
5110 if (!(dbits & 0xffff000000000000ull)) {
5111 dbits <<= 16;
5112 be -= 16;
5113 }
5114 if (!(dbits & 0xff00000000000000ull)) {
5115 dbits <<= 8;
5116 be -= 8;
5117 }
5118 if (!(dbits & 0xf000000000000000ull)) {
5119 dbits <<= 4;
5120 be -= 4;
5121 }
5122 if (!(dbits & 0xc000000000000000ull)) {
5123 dbits <<= 2;
5124 be -= 2;
5125 }
5126 if (!(dbits & 0x8000000000000000ull)) {
5127 dbits <<= 1;
5128 be -= 1;
5129 }
5130 assert(be >= -51);
5131 ulpadj -= be;
5132 }
5133 j = Lhint[be + 51];
5134 p10 = &pten[j];
5135 dbhi = dbits >> 32;
5136 dblo = dbits & 0xffffffffull;
5137 i = be - 0x3fe;
5138 if (i < p10->e
5139 || (i == p10->e && (dbhi < p10->b0 || (dbhi == p10->b0 && dblo < p10->b1))))
5140 --j;
5141 k = j - 342;
5142
5143 /* now 10^k <= dd < 10^(k+1) */
3781 5144
3782 b = d2b(&u, &be, &bbits); 5145#else /*}{*/
5146
5147 b = d2b(&u, &be, &bbits MTb);
3783#ifdef Sudden_Underflow 5148#ifdef Sudden_Underflow
3784 i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)); 5149 i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
3785#else 5150#else
@@ -3864,20 +5229,23 @@ dtoa
3864 b5 = -k; 5229 b5 = -k;
3865 s5 = 0; 5230 s5 = 0;
3866 } 5231 }
5232#endif /*}}*/
3867 if (mode < 0 || mode > 9) 5233 if (mode < 0 || mode > 9)
3868 mode = 0; 5234 mode = 0;
3869 5235
5236#ifndef USE_BF96
3870#ifndef SET_INEXACT 5237#ifndef SET_INEXACT
3871#ifdef Check_FLT_ROUNDS 5238#ifdef Check_FLT_ROUNDS
3872 try_quick = Rounding == 1; 5239 try_quick = Rounding == 1;
3873#else
3874 try_quick = 1;
3875#endif 5240#endif
3876#endif /*SET_INEXACT*/ 5241#endif /*SET_INEXACT*/
5242#endif
3877 5243
3878 if (mode > 5) { 5244 if (mode > 5) {
3879 mode -= 4; 5245 mode -= 4;
5246#ifndef USE_BF96
3880 try_quick = 0; 5247 try_quick = 0;
5248#endif
3881 } 5249 }
3882 leftright = 1; 5250 leftright = 1;
3883 ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */ 5251 ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */
@@ -3906,20 +5274,490 @@ dtoa
3906 if (i <= 0) 5274 if (i <= 0)
3907 i = 1; 5275 i = 1;
3908 } 5276 }
3909 s = s0 = rv_alloc(i); 5277 if (!buf) {
5278 buf = rv_alloc(i MTb);
5279 blen = sizeof(Bigint) + ((1 << ((int*)buf)[-1]) - 1)*sizeof(ULong) - sizeof(int);
5280 }
5281 else if (blen <= i) {
5282 buf = 0;
5283 if (rve)
5284 *rve = buf + i;
5285 return buf;
5286 }
5287 s = buf;
5288
5289 /* Check for special case that d is a normalized power of 2. */
5290
5291 spec_case = 0;
5292 if (mode < 2 || (leftright
5293#ifdef Honor_FLT_ROUNDS
5294 && Rounding == 1
5295#endif
5296 )) {
5297 if (!word1(&u) && !(word0(&u) & Bndry_mask)
5298#ifndef Sudden_Underflow
5299 && word0(&u) & (Exp_mask & ~Exp_msk1)
5300#endif
5301 ) {
5302 /* The special case */
5303 spec_case = 1;
5304 }
5305 }
5306
5307#ifdef USE_BF96 /*{*/
5308 b = 0;
5309 if (ilim < 0 && (mode == 3 || mode == 5)) {
5310 S = mhi = 0;
5311 goto no_digits;
5312 }
5313 i = 1;
5314 j = 52 + 0x3ff - be;
5315 ulpshift = 0;
5316 ulplo = 0;
5317 /* Can we do an exact computation with 64-bit integer arithmetic? */
5318 if (k < 0) {
5319 if (k < -25)
5320 goto toobig;
5321 res = dbits >> 11;
5322 n2 = pfivebits[k1 = -(k + 1)] + 53;
5323 j1 = j;
5324 if (n2 > 61) {
5325 ulpshift = n2 - 61;
5326 if (res & (ulpmask = (1ull << ulpshift) - 1))
5327 goto toobig;
5328 j -= ulpshift;
5329 res >>= ulpshift;
5330 }
5331 /* Yes. */
5332 res *= ulp = pfive[k1];
5333 if (ulpshift) {
5334 ulplo = ulp;
5335 ulp >>= ulpshift;
5336 }
5337 j += k;
5338 if (ilim == 0) {
5339 S = mhi = 0;
5340 if (res > (5ull << j))
5341 goto one_digit;
5342 goto no_digits;
5343 }
5344 goto no_div;
5345 }
5346 if (ilim == 0 && j + k >= 0) {
5347 S = mhi = 0;
5348 if ((dbits >> 11) > (pfive[k-1] << j))
5349 goto one_digit;
5350 goto no_digits;
5351 }
5352 if (k <= dtoa_divmax && j + k >= 0) {
5353 /* Another "yes" case -- we will use exact integer arithmetic. */
5354 use_exact:
5355 Debug(++dtoa_stats[3]);
5356 res = dbits >> 11; /* residual */
5357 ulp = 1;
5358 if (k <= 0)
5359 goto no_div;
5360 j1 = j + k + 1;
5361 den = pfive[k-i] << (j1 - i);
5362 for(;;) {
5363 dig = res / den;
5364 *s++ = '0' + dig;
5365 if (!(res -= dig*den)) {
5366#ifdef SET_INEXACT
5367 inexact = 0;
5368 oldinexact = 1;
5369#endif
5370 goto retc;
5371 }
5372 if (ilim < 0) {
5373 ures = den - res;
5374 if (2*res <= ulp
5375 && (spec_case ? 4*res <= ulp : (2*res < ulp || dig & 1)))
5376 goto ulp_reached;
5377 if (2*ures < ulp)
5378 goto Roundup;
5379 }
5380 else if (i == ilim) {
5381 switch(Rounding) {
5382 case 0: goto retc;
5383 case 2: goto Roundup;
5384 }
5385 ures = 2*res;
5386 if (ures > den
5387 || (ures == den && dig & 1)
5388 || (spec_case && res <= ulp && 2*res >= ulp))
5389 goto Roundup;
5390 goto retc;
5391 }
5392 if (j1 < ++i) {
5393 res *= 10;
5394 ulp *= 10;
5395 }
5396 else {
5397 if (i > k)
5398 break;
5399 den = pfive[k-i] << (j1 - i);
5400 }
5401 }
5402 no_div:
5403 for(;;) {
5404 dig = den = res >> j;
5405 *s++ = '0' + dig;
5406 if (!(res -= den << j)) {
5407#ifdef SET_INEXACT
5408 inexact = 0;
5409 oldinexact = 1;
5410#endif
5411 goto retc;
5412 }
5413 if (ilim < 0) {
5414 ures = (1ull << j) - res;
5415 if (2*res <= ulp
5416 && (spec_case ? 4*res <= ulp : (2*res < ulp || dig & 1))) {
5417 ulp_reached:
5418 if (ures < res
5419 || (ures == res && dig & 1))
5420 goto Roundup;
5421 goto retc;
5422 }
5423 if (2*ures < ulp)
5424 goto Roundup;
5425 }
5426 --j;
5427 if (i == ilim) {
5428#ifdef Honor_FLT_ROUNDS
5429 switch(Rounding) {
5430 case 0: goto retc;
5431 case 2: goto Roundup;
5432 }
5433#endif
5434 hb = 1ull << j;
5435 if (res & hb && (dig & 1 || res & (hb-1)))
5436 goto Roundup;
5437 if (spec_case && res <= ulp && 2*res >= ulp) {
5438 Roundup:
5439 while(*--s == '9')
5440 if (s == buf) {
5441 ++k;
5442 *s++ = '1';
5443 goto ret1;
5444 }
5445 ++*s++;
5446 goto ret1;
5447 }
5448 goto retc;
5449 }
5450 ++i;
5451 res *= 5;
5452 if (ulpshift) {
5453 ulplo = 5*(ulplo & ulpmask);
5454 ulp = 5*ulp + (ulplo >> ulpshift);
5455 }
5456 else
5457 ulp *= 5;
5458 }
5459 }
5460 toobig:
5461 if (ilim > 28)
5462 goto Fast_failed1;
5463 /* Scale by 10^-k */
5464 p10 = &pten[342-k];
5465 tv0 = p10->b2 * dblo; /* rarely matters, but does, e.g., for 9.862818194192001e18 */
5466 tv1 = p10->b1 * dblo + (tv0 >> 32);
5467 tv2 = p10->b2 * dbhi + (tv1 & 0xffffffffull);
5468 tv3 = p10->b0 * dblo + (tv1>>32) + (tv2>>32);
5469 res3 = p10->b1 * dbhi + (tv3 & 0xffffffffull);
5470 res = p10->b0 * dbhi + (tv3>>32) + (res3>>32);
5471 be += p10->e - 0x3fe;
5472 eulp = j1 = be - 54 + ulpadj;
5473 if (!(res & 0x8000000000000000ull)) {
5474 --be;
5475 res3 <<= 1;
5476 res = (res << 1) | ((res3 & 0x100000000ull) >> 32);
5477 }
5478 res0 = res; /* save for Fast_failed */
5479#if !defined(SET_INEXACT) && !defined(NO_DTOA_64) /*{*/
5480 if (ilim > 19)
5481 goto Fast_failed;
5482 Debug(++dtoa_stats[4]);
5483 assert(be >= 0 && be <= 4); /* be = 0 is rare, but possible, e.g., for 1e20 */
5484 res >>= 4 - be;
5485 ulp = p10->b0; /* ulp */
5486 ulp = (ulp << 29) | (p10->b1 >> 3);
5487 /* scaled ulp = ulp * 2^(eulp - 60) */
5488 /* We maintain 61 bits of the scaled ulp. */
5489 if (ilim == 0) {
5490 if (!(res & 0x7fffffffffffffeull)
5491 || !((~res) & 0x7fffffffffffffeull))
5492 goto Fast_failed1;
5493 S = mhi = 0;
5494 if (res >= 0x5000000000000000ull)
5495 goto one_digit;
5496 goto no_digits;
5497 }
5498 rb = 1; /* upper bound on rounding error */
5499 for(;;++i) {
5500 dig = res >> 60;
5501 *s++ = '0' + dig;
5502 res &= 0xfffffffffffffffull;
5503 if (ilim < 0) {
5504 ures = 0x1000000000000000ull - res;
5505 if (eulp > 0) {
5506 assert(eulp <= 4);
5507 sulp = ulp << (eulp - 1);
5508 if (res <= ures) {
5509 if (res + rb > ures - rb)
5510 goto Fast_failed;
5511 if (res < sulp)
5512 goto retc;
5513 }
5514 else {
5515 if (res - rb <= ures + rb)
5516 goto Fast_failed;
5517 if (ures < sulp)
5518 goto Roundup;
5519 }
5520 }
5521 else {
5522 zb = -(1ull << (eulp + 63));
5523 if (!(zb & res)) {
5524 sres = res << (1 - eulp);
5525 if (sres < ulp && (!spec_case || 2*sres < ulp)) {
5526 if ((res+rb) << (1 - eulp) >= ulp)
5527 goto Fast_failed;
5528 if (ures < res) {
5529 if (ures + rb >= res - rb)
5530 goto Fast_failed;
5531 goto Roundup;
5532 }
5533 if (ures - rb < res + rb)
5534 goto Fast_failed;
5535 goto retc;
5536 }
5537 }
5538 if (!(zb & ures) && ures << -eulp < ulp) {
5539 if (ures << (1 - eulp) < ulp)
5540 goto Roundup;
5541 goto Fast_failed;
5542 }
5543 }
5544 }
5545 else if (i == ilim) {
5546 ures = 0x1000000000000000ull - res;
5547 if (ures < res) {
5548 if (ures <= rb || res - rb <= ures + rb) {
5549 if (j + k >= 0 && k >= 0 && k <= 27)
5550 goto use_exact1;
5551 goto Fast_failed;
5552 }
5553#ifdef Honor_FLT_ROUNDS
5554 if (Rounding == 0)
5555 goto retc;
5556#endif
5557 goto Roundup;
5558 }
5559 if (res <= rb || ures - rb <= res + rb) {
5560 if (j + k >= 0 && k >= 0 && k <= 27) {
5561 use_exact1:
5562 s = buf;
5563 i = 1;
5564 goto use_exact;
5565 }
5566 goto Fast_failed;
5567 }
5568#ifdef Honor_FLT_ROUNDS
5569 if (Rounding == 2)
5570 goto Roundup;
5571#endif
5572 goto retc;
5573 }
5574 rb *= 10;
5575 if (rb >= 0x1000000000000000ull)
5576 goto Fast_failed;
5577 res *= 10;
5578 ulp *= 5;
5579 if (ulp & 0x8000000000000000ull) {
5580 eulp += 4;
5581 ulp >>= 3;
5582 }
5583 else {
5584 eulp += 3;
5585 ulp >>= 2;
5586 }
5587 }
5588#endif /*}*/
5589#ifndef NO_BF96
5590 Fast_failed:
5591#endif
5592 Debug(++dtoa_stats[5]);
5593 s = buf;
5594 i = 4 - be;
5595 res = res0 >> i;
5596 reslo = 0xffffffffull & res3;
5597 if (i)
5598 reslo = (res0 << (64 - i)) >> 32 | (reslo >> i);
5599 rb = 0;
5600 rblo = 4; /* roundoff bound */
5601 ulp = p10->b0; /* ulp */
5602 ulp = (ulp << 29) | (p10->b1 >> 3);
5603 eulp = j1;
5604 for(i = 1;;++i) {
5605 dig = res >> 60;
5606 *s++ = '0' + dig;
5607 res &= 0xfffffffffffffffull;
5608#ifdef SET_INEXACT
5609 if (!res && !reslo) {
5610 if (!(res3 & 0xffffffffull)) {
5611 inexact = 0;
5612 oldinexact = 1;
5613 }
5614 goto retc;
5615 }
5616#endif
5617 if (ilim < 0) {
5618 ures = 0x1000000000000000ull - res;
5619 ureslo = 0;
5620 if (reslo) {
5621 ureslo = 0x100000000ull - reslo;
5622 --ures;
5623 }
5624 if (eulp > 0) {
5625 assert(eulp <= 4);
5626 sulp = (ulp << (eulp - 1)) - rb;
5627 if (res <= ures) {
5628 if (res < sulp) {
5629 if (res+rb < ures-rb)
5630 goto retc;
5631 }
5632 }
5633 else if (ures < sulp) {
5634 if (res-rb > ures+rb)
5635 goto Roundup;
5636 }
5637 goto Fast_failed1;
5638 }
5639 else {
5640 zb = -(1ull << (eulp + 60));
5641 if (!(zb & (res + rb))) {
5642 sres = (res - rb) << (1 - eulp);
5643 if (sres < ulp && (!spec_case || 2*sres < ulp)) {
5644 sres = res << (1 - eulp);
5645 if ((j = eulp + 31) > 0)
5646 sres += (rblo + reslo) >> j;
5647 else
5648 sres += (rblo + reslo) << -j;
5649 if (sres + (rb << (1 - eulp)) >= ulp)
5650 goto Fast_failed1;
5651 if (sres >= ulp)
5652 goto more96;
5653 if (ures < res
5654 || (ures == res && ureslo < reslo)) {
5655 if (ures + rb >= res - rb)
5656 goto Fast_failed1;
5657 goto Roundup;
5658 }
5659 if (ures - rb <= res + rb)
5660 goto Fast_failed1;
5661 goto retc;
5662 }
5663 }
5664 if (!(zb & ures) && (ures-rb) << (1 - eulp) < ulp) {
5665 if ((ures + rb) << (1 - eulp) < ulp)
5666 goto Roundup;
5667 goto Fast_failed1;
5668 }
5669 }
5670 }
5671 else if (i == ilim) {
5672 ures = 0x1000000000000000ull - res;
5673 sres = ureslo = 0;
5674 if (reslo) {
5675 ureslo = 0x100000000ull - reslo;
5676 --ures;
5677 sres = (reslo + rblo) >> 31;
5678 }
5679 sres += 2*rb;
5680 if (ures <= res) {
5681 if (ures <=sres || res - ures <= sres)
5682 goto Fast_failed1;
5683#ifdef Honor_FLT_ROUNDS
5684 if (Rounding == 0)
5685 goto retc;
5686#endif
5687 goto Roundup;
5688 }
5689 if (res <= sres || ures - res <= sres)
5690 goto Fast_failed1;
5691#ifdef Honor_FLT_ROUNDS
5692 if (Rounding == 2)
5693 goto Roundup;
5694#endif
5695 goto retc;
5696 }
5697 more96:
5698 rblo *= 10;
5699 rb = 10*rb + (rblo >> 32);
5700 rblo &= 0xffffffffull;
5701 if (rb >= 0x1000000000000000ull)
5702 goto Fast_failed1;
5703 reslo *= 10;
5704 res = 10*res + (reslo >> 32);
5705 reslo &= 0xffffffffull;
5706 ulp *= 5;
5707 if (ulp & 0x8000000000000000ull) {
5708 eulp += 4;
5709 ulp >>= 3;
5710 }
5711 else {
5712 eulp += 3;
5713 ulp >>= 2;
5714 }
5715 }
5716 Fast_failed1:
5717 Debug(++dtoa_stats[6]);
5718 S = mhi = mlo = 0;
5719#ifdef USE_BF96
5720 b = d2b(&u, &be, &bbits MTb);
5721#endif
5722 s = buf;
5723 i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
5724 i -= Bias;
5725 if (ulpadj)
5726 i -= ulpadj - 1;
5727 j = bbits - i - 1;
5728 if (j >= 0) {
5729 b2 = 0;
5730 s2 = j;
5731 }
5732 else {
5733 b2 = -j;
5734 s2 = 0;
5735 }
5736 if (k >= 0) {
5737 b5 = 0;
5738 s5 = k;
5739 s2 += k;
5740 }
5741 else {
5742 b2 -= k;
5743 b5 = -k;
5744 s5 = 0;
5745 }
5746#endif /*}*/
3910 5747
3911#ifdef Honor_FLT_ROUNDS 5748#ifdef Honor_FLT_ROUNDS
3912 if (mode > 1 && Rounding != 1) 5749 if (mode > 1 && Rounding != 1)
3913 leftright = 0; 5750 leftright = 0;
3914#endif 5751#endif
3915 5752
5753#ifndef USE_BF96 /*{*/
3916 if (ilim >= 0 && ilim <= Quick_max && try_quick) { 5754 if (ilim >= 0 && ilim <= Quick_max && try_quick) {
3917 5755
3918 /* Try to get by with floating-point arithmetic. */ 5756 /* Try to get by with floating-point arithmetic. */
3919 5757
3920 i = 0; 5758 i = 0;
3921 dval(&d2) = dval(&u); 5759 dval(&d2) = dval(&u);
3922 k0 = k; 5760 j1 = -(k0 = k);
3923 ilim0 = ilim; 5761 ilim0 = ilim;
3924 ieps = 2; /* conservative */ 5762 ieps = 2; /* conservative */
3925 if (k > 0) { 5763 if (k > 0) {
@@ -3938,7 +5776,7 @@ dtoa
3938 } 5776 }
3939 dval(&u) /= ds; 5777 dval(&u) /= ds;
3940 } 5778 }
3941 else if ((j1 = -k)) { 5779 else if (j1 > 0) {
3942 dval(&u) *= tens[j1 & 0xf]; 5780 dval(&u) *= tens[j1 & 0xf];
3943 for(j = j1 >> 4; j; j >>= 1, i++) 5781 for(j = j1 >> 4; j; j >>= 1, i++)
3944 if (j & 1) { 5782 if (j & 1) {
@@ -3972,7 +5810,7 @@ dtoa
3972 */ 5810 */
3973 dval(&eps) = 0.5/tens[ilim-1] - dval(&eps); 5811 dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
3974#ifdef IEEE_Arith 5812#ifdef IEEE_Arith
3975 if (k0 < 0 && j1 >= 307) { 5813 if (j1 >= 307) {
3976 eps1.d = 1.01e256; /* 1.01 allows roundoff in the next few lines */ 5814 eps1.d = 1.01e256; /* 1.01 allows roundoff in the next few lines */
3977 word0(&eps1) -= Exp_msk1 * (Bias+P-1); 5815 word0(&eps1) -= Exp_msk1 * (Bias+P-1);
3978 dval(&eps1) *= tens[j1 & 0xf]; 5816 dval(&eps1) *= tens[j1 & 0xf];
@@ -3981,6 +5819,12 @@ dtoa
3981 dval(&eps1) *= bigtens[i]; 5819 dval(&eps1) *= bigtens[i];
3982 if (eps.d < eps1.d) 5820 if (eps.d < eps1.d)
3983 eps.d = eps1.d; 5821 eps.d = eps1.d;
5822 if (10. - u.d < 10.*eps.d && eps.d < 1.) {
5823 /* eps.d < 1. excludes trouble with the tiniest denormal */
5824 *s++ = '1';
5825 ++k;
5826 goto ret1;
5827 }
3984 } 5828 }
3985#endif 5829#endif
3986 for(i = 0;;) { 5830 for(i = 0;;) {
@@ -3990,7 +5834,7 @@ dtoa
3990 if (1. - dval(&u) < dval(&eps)) 5834 if (1. - dval(&u) < dval(&eps))
3991 goto bump_up; 5835 goto bump_up;
3992 if (dval(&u) < dval(&eps)) 5836 if (dval(&u) < dval(&eps))
3993 goto ret1; 5837 goto retc;
3994 if (++i >= ilim) 5838 if (++i >= ilim)
3995 break; 5839 break;
3996 dval(&eps) *= 10.; 5840 dval(&eps) *= 10.;
@@ -4009,11 +5853,8 @@ dtoa
4009 if (i == ilim) { 5853 if (i == ilim) {
4010 if (dval(&u) > 0.5 + dval(&eps)) 5854 if (dval(&u) > 0.5 + dval(&eps))
4011 goto bump_up; 5855 goto bump_up;
4012 else if (dval(&u) < 0.5 - dval(&eps)) { 5856 else if (dval(&u) < 0.5 - dval(&eps))
4013 while(*--s == '0'); 5857 goto retc;
4014 s++;
4015 goto ret1;
4016 }
4017 break; 5858 break;
4018 } 5859 }
4019 } 5860 }
@@ -4021,7 +5862,7 @@ dtoa
4021 } 5862 }
4022#endif 5863#endif
4023 fast_failed: 5864 fast_failed:
4024 s = s0; 5865 s = buf;
4025 dval(&u) = dval(&d2); 5866 dval(&u) = dval(&d2);
4026 k = k0; 5867 k = k0;
4027 ilim = ilim0; 5868 ilim = ilim0;
@@ -4059,7 +5900,7 @@ dtoa
4059#ifdef Honor_FLT_ROUNDS 5900#ifdef Honor_FLT_ROUNDS
4060 if (mode > 1) 5901 if (mode > 1)
4061 switch(Rounding) { 5902 switch(Rounding) {
4062 case 0: goto ret1; 5903 case 0: goto retc;
4063 case 2: goto bump_up; 5904 case 2: goto bump_up;
4064 } 5905 }
4065#endif 5906#endif
@@ -4072,7 +5913,7 @@ dtoa
4072 { 5913 {
4073 bump_up: 5914 bump_up:
4074 while(*--s == '9') 5915 while(*--s == '9')
4075 if (s == s0) { 5916 if (s == buf) {
4076 k++; 5917 k++;
4077 *s = '0'; 5918 *s = '0';
4078 break; 5919 break;
@@ -4082,9 +5923,10 @@ dtoa
4082 break; 5923 break;
4083 } 5924 }
4084 } 5925 }
4085 goto ret1; 5926 goto retc;
4086 } 5927 }
4087 5928
5929#endif /*}*/
4088 m2 = b2; 5930 m2 = b2;
4089 m5 = b5; 5931 m5 = b5;
4090 mhi = mlo = 0; 5932 mhi = mlo = 0;
@@ -4100,7 +5942,7 @@ dtoa
4100#endif 5942#endif
4101 b2 += i; 5943 b2 += i;
4102 s2 += i; 5944 s2 += i;
4103 mhi = i2b(1); 5945 mhi = i2b(1 MTb);
4104 } 5946 }
4105 if (m2 > 0 && s2 > 0) { 5947 if (m2 > 0 && s2 > 0) {
4106 i = m2 < s2 ? m2 : s2; 5948 i = m2 < s2 ? m2 : s2;
@@ -4111,39 +5953,24 @@ dtoa
4111 if (b5 > 0) { 5953 if (b5 > 0) {
4112 if (leftright) { 5954 if (leftright) {
4113 if (m5 > 0) { 5955 if (m5 > 0) {
4114 mhi = pow5mult(mhi, m5); 5956 mhi = pow5mult(mhi, m5 MTb);
4115 b1 = mult(mhi, b); 5957 b1 = mult(mhi, b MTb);
4116 Bfree(b); 5958 Bfree(b MTb);
4117 b = b1; 5959 b = b1;
4118 } 5960 }
4119 if ((j = b5 - m5)) 5961 if ((j = b5 - m5))
4120 b = pow5mult(b, j); 5962 b = pow5mult(b, j MTb);
4121 } 5963 }
4122 else 5964 else
4123 b = pow5mult(b, b5); 5965 b = pow5mult(b, b5 MTb);
4124 } 5966 }
4125 S = i2b(1); 5967 S = i2b(1 MTb);
4126 if (s5 > 0) 5968 if (s5 > 0)
4127 S = pow5mult(S, s5); 5969 S = pow5mult(S, s5 MTb);
4128 5970
4129 /* Check for special case that d is a normalized power of 2. */ 5971 if (spec_case) {
4130 5972 b2 += Log2P;
4131 spec_case = 0; 5973 s2 += Log2P;
4132 if ((mode < 2 || leftright)
4133#ifdef Honor_FLT_ROUNDS
4134 && Rounding == 1
4135#endif
4136 ) {
4137 if (!word1(&u) && !(word0(&u) & Bndry_mask)
4138#ifndef Sudden_Underflow
4139 && word0(&u) & (Exp_mask & ~Exp_msk1)
4140#endif
4141 ) {
4142 /* The special case */
4143 b2 += Log2P;
4144 s2 += Log2P;
4145 spec_case = 1;
4146 }
4147 } 5974 }
4148 5975
4149 /* Arrange for convenient computation of quotients: 5976 /* Arrange for convenient computation of quotients:
@@ -4158,20 +5985,22 @@ dtoa
4158 m2 += i; 5985 m2 += i;
4159 s2 += i; 5986 s2 += i;
4160 if (b2 > 0) 5987 if (b2 > 0)
4161 b = lshift(b, b2); 5988 b = lshift(b, b2 MTb);
4162 if (s2 > 0) 5989 if (s2 > 0)
4163 S = lshift(S, s2); 5990 S = lshift(S, s2 MTb);
5991#ifndef USE_BF96
4164 if (k_check) { 5992 if (k_check) {
4165 if (cmp(b,S) < 0) { 5993 if (cmp(b,S) < 0) {
4166 k--; 5994 k--;
4167 b = multadd(b, 10, 0); /* we botched the k estimate */ 5995 b = multadd(b, 10, 0 MTb); /* we botched the k estimate */
4168 if (leftright) 5996 if (leftright)
4169 mhi = multadd(mhi, 10, 0); 5997 mhi = multadd(mhi, 10, 0 MTb);
4170 ilim = ilim1; 5998 ilim = ilim1;
4171 } 5999 }
4172 } 6000 }
6001#endif
4173 if (ilim <= 0 && (mode == 3 || mode == 5)) { 6002 if (ilim <= 0 && (mode == 3 || mode == 5)) {
4174 if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) { 6003 if (ilim < 0 || cmp(b,S = multadd(S,5,0 MTb)) <= 0) {
4175 /* no digits, fcvt style */ 6004 /* no digits, fcvt style */
4176 no_digits: 6005 no_digits:
4177 k = -1 - ndigits; 6006 k = -1 - ndigits;
@@ -4179,12 +6008,12 @@ dtoa
4179 } 6008 }
4180 one_digit: 6009 one_digit:
4181 *s++ = '1'; 6010 *s++ = '1';
4182 k++; 6011 ++k;
4183 goto ret; 6012 goto ret;
4184 } 6013 }
4185 if (leftright) { 6014 if (leftright) {
4186 if (m2 > 0) 6015 if (m2 > 0)
4187 mhi = lshift(mhi, m2); 6016 mhi = lshift(mhi, m2 MTb);
4188 6017
4189 /* Compute mlo -- check for special case 6018 /* Compute mlo -- check for special case
4190 * that d is a normalized power of 2. 6019 * that d is a normalized power of 2.
@@ -4192,9 +6021,9 @@ dtoa
4192 6021
4193 mlo = mhi; 6022 mlo = mhi;
4194 if (spec_case) { 6023 if (spec_case) {
4195 mhi = Balloc(mhi->k); 6024 mhi = Balloc(mhi->k MTb);
4196 Bcopy(mhi, mlo); 6025 Bcopy(mhi, mlo);
4197 mhi = lshift(mhi, Log2P); 6026 mhi = lshift(mhi, Log2P MTb);
4198 } 6027 }
4199 6028
4200 for(i = 1;;i++) { 6029 for(i = 1;;i++) {
@@ -4203,13 +6032,13 @@ dtoa
4203 * that will round to d? 6032 * that will round to d?
4204 */ 6033 */
4205 j = cmp(b, mlo); 6034 j = cmp(b, mlo);
4206 delta = diff(S, mhi); 6035 delta = diff(S, mhi MTb);
4207 j1 = delta->sign ? 1 : cmp(b, delta); 6036 j1 = delta->sign ? 1 : cmp(b, delta);
4208 Bfree(delta); 6037 Bfree(delta MTb);
4209#ifndef ROUND_BIASED 6038#ifndef ROUND_BIASED
4210 if (j1 == 0 && mode != 1 && !(word1(&u) & 1) 6039 if (j1 == 0 && mode != 1 && !(word1(&u) & 1)
4211#ifdef Honor_FLT_ROUNDS 6040#ifdef Honor_FLT_ROUNDS
4212 && Rounding >= 1 6041 && (mode <= 1 || Rounding >= 1)
4213#endif 6042#endif
4214 ) { 6043 ) {
4215 if (dig == '9') 6044 if (dig == '9')
@@ -4243,7 +6072,7 @@ dtoa
4243 } 6072 }
4244#endif /*Honor_FLT_ROUNDS*/ 6073#endif /*Honor_FLT_ROUNDS*/
4245 if (j1 > 0) { 6074 if (j1 > 0) {
4246 b = lshift(b, 1); 6075 b = lshift(b, 1 MTb);
4247 j1 = cmp(b, S); 6076 j1 = cmp(b, S);
4248#ifdef ROUND_BIASED 6077#ifdef ROUND_BIASED
4249 if (j1 >= 0 /*)*/ 6078 if (j1 >= 0 /*)*/
@@ -4259,7 +6088,7 @@ dtoa
4259 } 6088 }
4260 if (j1 > 0) { 6089 if (j1 > 0) {
4261#ifdef Honor_FLT_ROUNDS 6090#ifdef Honor_FLT_ROUNDS
4262 if (!Rounding) 6091 if (!Rounding && mode > 1)
4263 goto accept_dig; 6092 goto accept_dig;
4264#endif 6093#endif
4265 if (dig == '9') { /* possible if i == 1 */ 6094 if (dig == '9') { /* possible if i == 1 */
@@ -4276,18 +6105,19 @@ dtoa
4276 *s++ = dig; 6105 *s++ = dig;
4277 if (i == ilim) 6106 if (i == ilim)
4278 break; 6107 break;
4279 b = multadd(b, 10, 0); 6108 b = multadd(b, 10, 0 MTb);
4280 if (mlo == mhi) 6109 if (mlo == mhi)
4281 mlo = mhi = multadd(mhi, 10, 0); 6110 mlo = mhi = multadd(mhi, 10, 0 MTb);
4282 else { 6111 else {
4283 mlo = multadd(mlo, 10, 0); 6112 mlo = multadd(mlo, 10, 0 MTb);
4284 mhi = multadd(mhi, 10, 0); 6113 mhi = multadd(mhi, 10, 0 MTb);
4285 } 6114 }
4286 } 6115 }
4287 } 6116 }
4288 else 6117 else
4289 for(i = 1;; i++) { 6118 for(i = 1;; i++) {
4290 *s++ = dig = quorem(b,S) + '0'; 6119 dig = quorem(b,S) + '0';
6120 *s++ = dig;
4291 if (!b->x[0] && b->wds <= 1) { 6121 if (!b->x[0] && b->wds <= 1) {
4292#ifdef SET_INEXACT 6122#ifdef SET_INEXACT
4293 inexact = 0; 6123 inexact = 0;
@@ -4296,18 +6126,19 @@ dtoa
4296 } 6126 }
4297 if (i >= ilim) 6127 if (i >= ilim)
4298 break; 6128 break;
4299 b = multadd(b, 10, 0); 6129 b = multadd(b, 10, 0 MTb);
4300 } 6130 }
4301 6131
4302 /* Round off last digit */ 6132 /* Round off last digit */
4303 6133
4304#ifdef Honor_FLT_ROUNDS 6134#ifdef Honor_FLT_ROUNDS
4305 switch(Rounding) { 6135 if (mode > 1)
4306 case 0: goto trimzeros; 6136 switch(Rounding) {
4307 case 2: goto roundoff; 6137 case 0: goto ret;
4308 } 6138 case 2: goto roundoff;
6139 }
4309#endif 6140#endif
4310 b = lshift(b, 1); 6141 b = lshift(b, 1 MTb);
4311 j = cmp(b, S); 6142 j = cmp(b, S);
4312#ifdef ROUND_BIASED 6143#ifdef ROUND_BIASED
4313 if (j >= 0) 6144 if (j >= 0)
@@ -4317,28 +6148,30 @@ dtoa
4317 { 6148 {
4318 roundoff: 6149 roundoff:
4319 while(*--s == '9') 6150 while(*--s == '9')
4320 if (s == s0) { 6151 if (s == buf) {
4321 k++; 6152 k++;
4322 *s++ = '1'; 6153 *s++ = '1';
4323 goto ret; 6154 goto ret;
4324 } 6155 }
4325 ++*s++; 6156 ++*s++;
4326 } 6157 }
4327 else {
4328#ifdef Honor_FLT_ROUNDS
4329 trimzeros:
4330#endif
4331 while(*--s == '0');
4332 s++;
4333 }
4334 ret: 6158 ret:
4335 Bfree(S); 6159 Bfree(S MTb);
4336 if (mhi) { 6160 if (mhi) {
4337 if (mlo && mlo != mhi) 6161 if (mlo && mlo != mhi)
4338 Bfree(mlo); 6162 Bfree(mlo MTb);
4339 Bfree(mhi); 6163 Bfree(mhi MTb);
4340 } 6164 }
6165 retc:
6166 while(s > buf && s[-1] == '0')
6167 --s;
4341 ret1: 6168 ret1:
6169 if (b)
6170 Bfree(b MTb);
6171 *s = 0;
6172 *decpt = k + 1;
6173 if (rve)
6174 *rve = s;
4342#ifdef SET_INEXACT 6175#ifdef SET_INEXACT
4343 if (inexact) { 6176 if (inexact) {
4344 if (!oldinexact) { 6177 if (!oldinexact) {
@@ -4350,13 +6183,23 @@ dtoa
4350 else if (!oldinexact) 6183 else if (!oldinexact)
4351 clear_inexact(); 6184 clear_inexact();
4352#endif 6185#endif
4353 Bfree(b); 6186 return buf;
4354 *s = 0; 6187 }
4355 *decpt = k + 1; 6188
4356 if (rve) 6189 char *
4357 *rve = s; 6190dtoa(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
4358 return s0; 6191{
6192 /* Sufficient space is allocated to the return value
6193 to hold the suppressed trailing zeros.
6194 See dtoa_r() above for details on the other arguments.
6195 */
6196#ifndef MULTIPLE_THREADS
6197 if (dtoa_result)
6198 freedtoa(dtoa_result);
6199#endif
6200 return dtoa_r(dd, mode, ndigits, decpt, sign, rve, 0, 0);
4359 } 6201 }
6202
4360#ifdef __cplusplus 6203#ifdef __cplusplus
4361} 6204}
4362#endif 6205#endif
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-15 21:24:05 +0000