PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - Zend - zend_strtod.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 1002 1291 77.6 %
Date: 2015-05-21 Functions: 31 33 93.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /****************************************************************
       2             :  *
       3             :  * The author of this software is David M. Gay.
       4             :  *
       5             :  * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
       6             :  *
       7             :  * Permission to use, copy, modify, and distribute this software for any
       8             :  * purpose without fee is hereby granted, provided that this entire notice
       9             :  * is included in all copies of any software which is or includes a copy
      10             :  * or modification of this software and in all copies of the supporting
      11             :  * documentation for such software.
      12             :  *
      13             :  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
      14             :  * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
      15             :  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
      16             :  * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
      17             :  *
      18             :  ***************************************************************/
      19             : 
      20             : /* Please send bug reports to David M. Gay (dmg at acm dot org,
      21             :  * with " at " changed at "@" and " dot " changed to ".").      */
      22             : 
      23             : /* On a machine with IEEE extended-precision registers, it is
      24             :  * necessary to specify double-precision (53-bit) rounding precision
      25             :  * before invoking strtod or dtoa.  If the machine uses (the equivalent
      26             :  * of) Intel 80x87 arithmetic, the call
      27             :  *      _control87(PC_53, MCW_PC);
      28             :  * does this with many compilers.  Whether this or another call is
      29             :  * appropriate depends on the compiler; for this to work, it may be
      30             :  * necessary to #include "float.h" or another system-dependent header
      31             :  * file.
      32             :  */
      33             : 
      34             : /* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
      35             :  * (Note that IEEE arithmetic is disabled by gcc's -ffast-math flag.)
      36             :  *
      37             :  * This strtod returns a nearest machine number to the input decimal
      38             :  * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
      39             :  * broken by the IEEE round-even rule.  Otherwise ties are broken by
      40             :  * biased rounding (add half and chop).
      41             :  *
      42             :  * Inspired loosely by William D. Clinger's paper "How to Read Floating
      43             :  * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
      44             :  *
      45             :  * Modifications:
      46             :  *
      47             :  *      1. We only require IEEE, IBM, or VAX double-precision
      48             :  *              arithmetic (not IEEE double-extended).
      49             :  *      2. We get by with floating-point arithmetic in a case that
      50             :  *              Clinger missed -- when we're computing d * 10^n
      51             :  *              for a small integer d and the integer n is not too
      52             :  *              much larger than 22 (the maximum integer k for which
      53             :  *              we can represent 10^k exactly), we may be able to
      54             :  *              compute (d*10^k) * 10^(e-k) with just one roundoff.
      55             :  *      3. Rather than a bit-at-a-time adjustment of the binary
      56             :  *              result in the hard case, we use floating-point
      57             :  *              arithmetic to determine the adjustment to within
      58             :  *              one bit; only in really hard cases do we need to
      59             :  *              compute a second residual.
      60             :  *      4. Because of 3., we don't need a large table of powers of 10
      61             :  *              for ten-to-e (just some small tables, e.g. of 10^k
      62             :  *              for 0 <= k <= 22).
      63             :  */
      64             : 
      65             : /*
      66             :  * #define IEEE_8087 for IEEE-arithmetic machines where the least
      67             :  *      significant byte has the lowest address.
      68             :  * #define IEEE_MC68k for IEEE-arithmetic machines where the most
      69             :  *      significant byte has the lowest address.
      70             :  * #define Long int on machines with 32-bit ints and 64-bit longs.
      71             :  * #define IBM for IBM mainframe-style floating-point arithmetic.
      72             :  * #define VAX for VAX-style floating-point arithmetic (D_floating).
      73             :  * #define No_leftright to omit left-right logic in fast floating-point
      74             :  *      computation of dtoa.  This will cause dtoa modes 4 and 5 to be
      75             :  *      treated the same as modes 2 and 3 for some inputs.
      76             :  * #define Honor_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3
      77             :  *      and strtod and dtoa should round accordingly.  Unless Trust_FLT_ROUNDS
      78             :  *      is also #defined, fegetround() will be queried for the rounding mode.
      79             :  *      Note that both FLT_ROUNDS and fegetround() are specified by the C99
      80             :  *      standard (and are specified to be consistent, with fesetround()
      81             :  *      affecting the value of FLT_ROUNDS), but that some (Linux) systems
      82             :  *      do not work correctly in this regard, so using fegetround() is more
      83             :  *      portable than using FLT_ROUNDS directly.
      84             :  * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3
      85             :  *      and Honor_FLT_ROUNDS is not #defined.
      86             :  * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
      87             :  *      that use extended-precision instructions to compute rounded
      88             :  *      products and quotients) with IBM.
      89             :  * #define ROUND_BIASED for IEEE-format with biased rounding and arithmetic
      90             :  *      that rounds toward +Infinity.
      91             :  * #define ROUND_BIASED_without_Round_Up for IEEE-format with biased
      92             :  *      rounding when the underlying floating-point arithmetic uses
      93             :  *      unbiased rounding.  This prevent using ordinary floating-point
      94             :  *      arithmetic when the result could be computed with one rounding error.
      95             :  * #define Inaccurate_Divide for IEEE-format with correctly rounded
      96             :  *      products but inaccurate quotients, e.g., for Intel i860.
      97             :  * #define NO_LONG_LONG on machines that do not have a "long long"
      98             :  *      integer type (of >= 64 bits).  On such machines, you can
      99             :  *      #define Just_16 to store 16 bits per 32-bit Long when doing
     100             :  *      high-precision integer arithmetic.  Whether this speeds things
     101             :  *      up or slows things down depends on the machine and the number
     102             :  *      being converted.  If long long is available and the name is
     103             :  *      something other than "long long", #define Llong to be the name,
     104             :  *      and if "unsigned Llong" does not work as an unsigned version of
     105             :  *      Llong, #define #ULLong to be the corresponding unsigned type.
     106             :  * #define KR_headers for old-style C function headers.
     107             :  * #define Bad_float_h if your system lacks a float.h or if it does not
     108             :  *      define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
     109             :  *      FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
     110             :  * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
     111             :  *      if memory is available and otherwise does something you deem
     112             :  *      appropriate.  If MALLOC is undefined, malloc will be invoked
     113             :  *      directly -- and assumed always to succeed.  Similarly, if you
     114             :  *      want something other than the system's free() to be called to
     115             :  *      recycle memory acquired from MALLOC, #define FREE to be the
     116             :  *      name of the alternate routine.  (FREE or free is only called in
     117             :  *      pathological cases, e.g., in a dtoa call after a dtoa return in
     118             :  *      mode 3 with thousands of digits requested.)
     119             :  * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
     120             :  *      memory allocations from a private pool of memory when possible.
     121             :  *      When used, the private pool is PRIVATE_MEM bytes long:  2304 bytes,
     122             :  *      unless #defined to be a different length.  This default length
     123             :  *      suffices to get rid of MALLOC calls except for unusual cases,
     124             :  *      such as decimal-to-binary conversion of a very long string of
     125             :  *      digits.  The longest string dtoa can return is about 751 bytes
     126             :  *      long.  For conversions by strtod of strings of 800 digits and
     127             :  *      all dtoa conversions in single-threaded executions with 8-byte
     128             :  *      pointers, PRIVATE_MEM >= 7400 appears to suffice; with 4-byte
     129             :  *      pointers, PRIVATE_MEM >= 7112 appears adequate.
     130             :  * #define NO_INFNAN_CHECK if you do not wish to have INFNAN_CHECK
     131             :  *      #defined automatically on IEEE systems.  On such systems,
     132             :  *      when INFNAN_CHECK is #defined, strtod checks
     133             :  *      for Infinity and NaN (case insensitively).  On some systems
     134             :  *      (e.g., some HP systems), it may be necessary to #define NAN_WORD0
     135             :  *      appropriately -- to the most significant word of a quiet NaN.
     136             :  *      (On HP Series 700/800 machines, -DNAN_WORD0=0x7ff40000 works.)
     137             :  *      When INFNAN_CHECK is #defined and No_Hex_NaN is not #defined,
     138             :  *      strtod also accepts (case insensitively) strings of the form
     139             :  *      NaN(x), where x is a string of hexadecimal digits and spaces;
     140             :  *      if there is only one string of hexadecimal digits, it is taken
     141             :  *      for the 52 fraction bits of the resulting NaN; if there are two
     142             :  *      or more strings of hex digits, the first is for the high 20 bits,
     143             :  *      the second and subsequent for the low 32 bits, with intervening
     144             :  *      white space ignored; but if this results in none of the 52
     145             :  *      fraction bits being on (an IEEE Infinity symbol), then NAN_WORD0
     146             :  *      and NAN_WORD1 are used instead.
     147             :  * #define MULTIPLE_THREADS if the system offers preemptively scheduled
     148             :  *      multiple threads.  In this case, you must provide (or suitably
     149             :  *      #define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed
     150             :  *      by FREE_DTOA_LOCK(n) for n = 0 or 1.  (The second lock, accessed
     151             :  *      in pow5mult, ensures lazy evaluation of only one copy of high
     152             :  *      powers of 5; omitting this lock would introduce a small
     153             :  *      probability of wasting memory, but would otherwise be harmless.)
     154             :  *      You must also invoke freedtoa(s) to free the value s returned by
     155             :  *      dtoa.  You may do so whether or not MULTIPLE_THREADS is #defined.
     156             :  * #define NO_IEEE_Scale to disable new (Feb. 1997) logic in strtod that
     157             :  *      avoids underflows on inputs whose result does not underflow.
     158             :  *      If you #define NO_IEEE_Scale on a machine that uses IEEE-format
     159             :  *      floating-point numbers and flushes underflows to zero rather
     160             :  *      than implementing gradual underflow, then you must also #define
     161             :  *      Sudden_Underflow.
     162             :  * #define USE_LOCALE to use the current locale's decimal_point value.
     163             :  * #define SET_INEXACT if IEEE arithmetic is being used and extra
     164             :  *      computation should be done to set the inexact flag when the
     165             :  *      result is inexact and avoid setting inexact when the result
     166             :  *      is exact.  In this case, dtoa.c must be compiled in
     167             :  *      an environment, perhaps provided by #include "dtoa.c" in a
     168             :  *      suitable wrapper, that defines two functions,
     169             :  *              int get_inexact(void);
     170             :  *              void clear_inexact(void);
     171             :  *      such that get_inexact() returns a nonzero value if the
     172             :  *      inexact bit is already set, and clear_inexact() sets the
     173             :  *      inexact bit to 0.  When SET_INEXACT is #defined, strtod
     174             :  *      also does extra computations to set the underflow and overflow
     175             :  *      flags when appropriate (i.e., when the result is tiny and
     176             :  *      inexact or when it is a numeric value rounded to +-infinity).
     177             :  * #define NO_ERRNO if strtod should not assign errno = ERANGE when
     178             :  *      the result overflows to +-Infinity or underflows to 0.
     179             :  * #define NO_HEX_FP to omit recognition of hexadecimal floating-point
     180             :  *      values by strtod.
     181             :  * #define NO_STRTOD_BIGCOMP (on IEEE-arithmetic systems only for now)
     182             :  *      to disable logic for "fast" testing of very long input strings
     183             :  *      to strtod.  This testing proceeds by initially truncating the
     184             :  *      input string, then if necessary comparing the whole string with
     185             :  *      a decimal expansion to decide close cases. This logic is only
     186             :  *      used for input more than STRTOD_DIGLIM digits long (default 40).
     187             :  */
     188             : 
     189             : #include <zend_operators.h>
     190             : #include <zend_strtod.h>
     191             : #include "zend_strtod_int.h"
     192             : 
     193             : #ifndef Long
     194             : #define Long int32_t
     195             : #endif
     196             : #ifndef ULong
     197             : #define ULong uint32_t
     198             : #endif
     199             : 
     200             : #ifdef DEBUG
     201             : static void Bug(const char *message) {
     202             :         fprintf(stderr, "%s\n", message);
     203             : }
     204             : #endif
     205             : 
     206             : #include "stdlib.h"
     207             : #include "string.h"
     208             : 
     209             : #ifdef USE_LOCALE
     210             : #include "locale.h"
     211             : #endif
     212             : 
     213             : #ifdef Honor_FLT_ROUNDS
     214             : #ifndef Trust_FLT_ROUNDS
     215             : #include <fenv.h>
     216             : #endif
     217             : #endif
     218             : 
     219             : #ifdef MALLOC
     220             : #ifdef KR_headers
     221             : extern char *MALLOC();
     222             : #else
     223             : extern void *MALLOC(size_t);
     224             : #endif
     225             : #else
     226             : #define MALLOC malloc
     227             : #endif
     228             : 
     229             : #ifndef Omit_Private_Memory
     230             : #ifndef PRIVATE_MEM
     231             : #define PRIVATE_MEM 2304
     232             : #endif
     233             : #define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
     234             : static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
     235             : #endif
     236             : 
     237             : #undef IEEE_Arith
     238             : #undef Avoid_Underflow
     239             : #ifdef IEEE_MC68k
     240             : #define IEEE_Arith
     241             : #endif
     242             : #ifdef IEEE_8087
     243             : #define IEEE_Arith
     244             : #endif
     245             : 
     246             : #ifdef IEEE_Arith
     247             : #ifndef NO_INFNAN_CHECK
     248             : #undef INFNAN_CHECK
     249             : #define INFNAN_CHECK
     250             : #endif
     251             : #else
     252             : #undef INFNAN_CHECK
     253             : #define NO_STRTOD_BIGCOMP
     254             : #endif
     255             : 
     256             : #include "errno.h"
     257             : 
     258             : #ifdef Bad_float_h
     259             : 
     260             : #ifdef IEEE_Arith
     261             : #define DBL_DIG 15
     262             : #define DBL_MAX_10_EXP 308
     263             : #define DBL_MAX_EXP 1024
     264             : #define FLT_RADIX 2
     265             : #endif /*IEEE_Arith*/
     266             : 
     267             : #ifdef IBM
     268             : #define DBL_DIG 16
     269             : #define DBL_MAX_10_EXP 75
     270             : #define DBL_MAX_EXP 63
     271             : #define FLT_RADIX 16
     272             : #define DBL_MAX 7.2370055773322621e+75
     273             : #endif
     274             : 
     275             : #ifdef VAX
     276             : #define DBL_DIG 16
     277             : #define DBL_MAX_10_EXP 38
     278             : #define DBL_MAX_EXP 127
     279             : #define FLT_RADIX 2
     280             : #define DBL_MAX 1.7014118346046923e+38
     281             : #endif
     282             : 
     283             : #ifndef LONG_MAX
     284             : #define LONG_MAX 2147483647
     285             : #endif
     286             : 
     287             : #else /* ifndef Bad_float_h */
     288             : #include "float.h"
     289             : #endif /* Bad_float_h */
     290             : 
     291             : #ifndef __MATH_H__
     292             : #include "math.h"
     293             : #endif
     294             : 
     295             : #ifdef __cplusplus
     296             : extern "C" {
     297             : #endif
     298             : 
     299             : #ifndef CONST
     300             : #ifdef KR_headers
     301             : #define CONST /* blank */
     302             : #else
     303             : #define CONST const
     304             : #endif
     305             : #endif
     306             : 
     307             : #if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
     308             : Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
     309             : #endif
     310             : 
     311             : typedef union { double d; ULong L[2]; } U;
     312             : 
     313             : #ifdef IEEE_8087
     314             : #define word0(x) (x)->L[1]
     315             : #define word1(x) (x)->L[0]
     316             : #else
     317             : #define word0(x) (x)->L[0]
     318             : #define word1(x) (x)->L[1]
     319             : #endif
     320             : #define dval(x) (x)->d
     321             : 
     322             : #ifndef STRTOD_DIGLIM
     323             : #define STRTOD_DIGLIM 40
     324             : #endif
     325             : 
     326             : #ifdef DIGLIM_DEBUG
     327             : extern int strtod_diglim;
     328             : #else
     329             : #define strtod_diglim STRTOD_DIGLIM
     330             : #endif
     331             : 
     332             : /* The following definition of Storeinc is appropriate for MIPS processors.
     333             :  * An alternative that might be better on some machines is
     334             :  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
     335             :  */
     336             : #if defined(IEEE_8087) + defined(VAX) + defined(__arm__)
     337             : #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
     338             : ((unsigned short *)a)[0] = (unsigned short)c, a++)
     339             : #else
     340             : #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
     341             : ((unsigned short *)a)[1] = (unsigned short)c, a++)
     342             : #endif
     343             : 
     344             : /* #define P DBL_MANT_DIG */
     345             : /* Ten_pmax = floor(P*log(2)/log(5)) */
     346             : /* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
     347             : /* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
     348             : /* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
     349             : 
     350             : #ifdef IEEE_Arith
     351             : #define Exp_shift  20
     352             : #define Exp_shift1 20
     353             : #define Exp_msk1    0x100000
     354             : #define Exp_msk11   0x100000
     355             : #define Exp_mask  0x7ff00000
     356             : #define P 53
     357             : #define Nbits 53
     358             : #define Bias 1023
     359             : #define Emax 1023
     360             : #define Emin (-1022)
     361             : #define Exp_1  0x3ff00000
     362             : #define Exp_11 0x3ff00000
     363             : #define Ebits 11
     364             : #define Frac_mask  0xfffff
     365             : #define Frac_mask1 0xfffff
     366             : #define Ten_pmax 22
     367             : #define Bletch 0x10
     368             : #define Bndry_mask  0xfffff
     369             : #define Bndry_mask1 0xfffff
     370             : #define LSB 1
     371             : #define Sign_bit 0x80000000
     372             : #define Log2P 1
     373             : #define Tiny0 0
     374             : #define Tiny1 1
     375             : #define Quick_max 14
     376             : #define Int_max 14
     377             : #ifndef NO_IEEE_Scale
     378             : #define Avoid_Underflow
     379             : #ifdef Flush_Denorm     /* debugging option */
     380             : #undef Sudden_Underflow
     381             : #endif
     382             : #endif
     383             : 
     384             : #ifndef Flt_Rounds
     385             : #ifdef FLT_ROUNDS
     386             : #define Flt_Rounds FLT_ROUNDS
     387             : #else
     388             : #define Flt_Rounds 1
     389             : #endif
     390             : #endif /*Flt_Rounds*/
     391             : 
     392             : #ifdef Honor_FLT_ROUNDS
     393             : #undef Check_FLT_ROUNDS
     394             : #define Check_FLT_ROUNDS
     395             : #else
     396             : #define Rounding Flt_Rounds
     397             : #endif
     398             : 
     399             : #else /* ifndef IEEE_Arith */
     400             : #undef Check_FLT_ROUNDS
     401             : #undef Honor_FLT_ROUNDS
     402             : #undef SET_INEXACT
     403             : #undef  Sudden_Underflow
     404             : #define Sudden_Underflow
     405             : #ifdef IBM
     406             : #undef Flt_Rounds
     407             : #define Flt_Rounds 0
     408             : #define Exp_shift  24
     409             : #define Exp_shift1 24
     410             : #define Exp_msk1   0x1000000
     411             : #define Exp_msk11  0x1000000
     412             : #define Exp_mask  0x7f000000
     413             : #define P 14
     414             : #define Nbits 56
     415             : #define Bias 65
     416             : #define Emax 248
     417             : #define Emin (-260)
     418             : #define Exp_1  0x41000000
     419             : #define Exp_11 0x41000000
     420             : #define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */
     421             : #define Frac_mask  0xffffff
     422             : #define Frac_mask1 0xffffff
     423             : #define Bletch 4
     424             : #define Ten_pmax 22
     425             : #define Bndry_mask  0xefffff
     426             : #define Bndry_mask1 0xffffff
     427             : #define LSB 1
     428             : #define Sign_bit 0x80000000
     429             : #define Log2P 4
     430             : #define Tiny0 0x100000
     431             : #define Tiny1 0
     432             : #define Quick_max 14
     433             : #define Int_max 15
     434             : #else /* VAX */
     435             : #undef Flt_Rounds
     436             : #define Flt_Rounds 1
     437             : #define Exp_shift  23
     438             : #define Exp_shift1 7
     439             : #define Exp_msk1    0x80
     440             : #define Exp_msk11   0x800000
     441             : #define Exp_mask  0x7f80
     442             : #define P 56
     443             : #define Nbits 56
     444             : #define Bias 129
     445             : #define Emax 126
     446             : #define Emin (-129)
     447             : #define Exp_1  0x40800000
     448             : #define Exp_11 0x4080
     449             : #define Ebits 8
     450             : #define Frac_mask  0x7fffff
     451             : #define Frac_mask1 0xffff007f
     452             : #define Ten_pmax 24
     453             : #define Bletch 2
     454             : #define Bndry_mask  0xffff007f
     455             : #define Bndry_mask1 0xffff007f
     456             : #define LSB 0x10000
     457             : #define Sign_bit 0x8000
     458             : #define Log2P 1
     459             : #define Tiny0 0x80
     460             : #define Tiny1 0
     461             : #define Quick_max 15
     462             : #define Int_max 15
     463             : #endif /* IBM, VAX */
     464             : #endif /* IEEE_Arith */
     465             : 
     466             : #ifndef IEEE_Arith
     467             : #define ROUND_BIASED
     468             : #else
     469             : #ifdef ROUND_BIASED_without_Round_Up
     470             : #undef  ROUND_BIASED
     471             : #define ROUND_BIASED
     472             : #endif
     473             : #endif
     474             : 
     475             : #ifdef RND_PRODQUOT
     476             : #define rounded_product(a,b) a = rnd_prod(a, b)
     477             : #define rounded_quotient(a,b) a = rnd_quot(a, b)
     478             : #ifdef KR_headers
     479             : extern double rnd_prod(), rnd_quot();
     480             : #else
     481             : extern double rnd_prod(double, double), rnd_quot(double, double);
     482             : #endif
     483             : #else
     484             : #define rounded_product(a,b) a *= b
     485             : #define rounded_quotient(a,b) a /= b
     486             : #endif
     487             : 
     488             : #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
     489             : #define Big1 0xffffffff
     490             : 
     491             : #ifndef Pack_32
     492             : #define Pack_32
     493             : #endif
     494             : 
     495             : typedef struct BCinfo BCinfo;
     496             :  struct
     497             : BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflchk; };
     498             : 
     499             : #ifdef KR_headers
     500             : #define FFFFFFFF ((((unsigned long)0xffff)<<16)|(unsigned long)0xffff)
     501             : #else
     502             : #define FFFFFFFF 0xffffffffUL
     503             : #endif
     504             : 
     505             : #ifdef NO_LONG_LONG
     506             : #undef ULLong
     507             : #ifdef Just_16
     508             : #undef Pack_32
     509             : /* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
     510             :  * This makes some inner loops simpler and sometimes saves work
     511             :  * during multiplications, but it often seems to make things slightly
     512             :  * slower.  Hence the default is now to store 32 bits per Long.
     513             :  */
     514             : #endif
     515             : #else   /* long long available */
     516             : #ifndef Llong
     517             : #define Llong long long
     518             : #endif
     519             : #ifndef ULLong
     520             : #define ULLong unsigned Llong
     521             : #endif
     522             : #endif /* NO_LONG_LONG */
     523             : 
     524             : #ifndef MULTIPLE_THREADS
     525             : #define ACQUIRE_DTOA_LOCK(n)    /*nothing*/
     526             : #define FREE_DTOA_LOCK(n)       /*nothing*/
     527             : #endif
     528             : 
     529             : #define Kmax 7
     530             : 
     531             : #ifdef __cplusplus
     532             : extern "C" double strtod(const char *s00, char **se);
     533             : extern "C" char *dtoa(double d, int mode, int ndigits,
     534             :                         int *decpt, int *sign, char **rve);
     535             : #endif
     536             : 
     537             :  struct
     538             : Bigint {
     539             :         struct Bigint *next;
     540             :         int k, maxwds, sign, wds;
     541             :         ULong x[1];
     542             :         };
     543             : 
     544             :  typedef struct Bigint Bigint;
     545             : 
     546             :  static Bigint *freelist[Kmax+1];
     547             : 
     548             : static void destroy_freelist(void);
     549             : 
     550             : #ifdef ZTS
     551             : static MUTEX_T dtoa_mutex;
     552             : static MUTEX_T pow5mult_mutex;
     553             : #endif /* ZTS */
     554             : 
     555       20916 : ZEND_API int zend_startup_strtod(void) /* {{{ */
     556             : {
     557             : #ifdef ZTS
     558             :         dtoa_mutex = tsrm_mutex_alloc();
     559             :         pow5mult_mutex = tsrm_mutex_alloc();
     560             : #endif
     561       20916 :         return 1;
     562             : }
     563             : /* }}} */
     564       20952 : ZEND_API int zend_shutdown_strtod(void) /* {{{ */
     565             : {
     566       20952 :         destroy_freelist();
     567             : #ifdef ZTS
     568             :         tsrm_mutex_free(dtoa_mutex);
     569             :         dtoa_mutex = NULL;
     570             : 
     571             :         tsrm_mutex_free(pow5mult_mutex);
     572             :         pow5mult_mutex = NULL;
     573             : #endif
     574       20952 :         return 1;
     575             : }
     576             : /* }}} */
     577             : 
     578             :  static Bigint *
     579      268139 : Balloc
     580             : #ifdef KR_headers
     581             :         (k) int k;
     582             : #else
     583             :         (int k)
     584             : #endif
     585             : {
     586             :         int x;
     587             :         Bigint *rv;
     588             : #ifndef Omit_Private_Memory
     589             :         unsigned int len;
     590             : #endif
     591             : 
     592             :         ACQUIRE_DTOA_LOCK(0);
     593             :         /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
     594             :         /* but this case seems very unlikely. */
     595      532420 :         if (k <= Kmax && (rv = freelist[k]))
     596      264281 :                 freelist[k] = rv->next;
     597             :         else {
     598        3858 :                 x = 1 << k;
     599             : #ifdef Omit_Private_Memory
     600        3858 :                 rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
     601        3858 :                 if (!rv) {
     602             :                         FREE_DTOA_LOCK(0);
     603           0 :                         zend_error_noreturn(E_ERROR, "Balloc() failed to allocate memory");
     604             :                 }
     605             : #else
     606             :                 len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
     607             :                         /sizeof(double);
     608             :                 if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
     609             :                         rv = (Bigint*)pmem_next;
     610             :                         pmem_next += len;
     611             :                         }
     612             :                 else
     613             :                         rv = (Bigint*)MALLOC(len*sizeof(double));
     614             :                         if (!rv) {
     615             :                                 FREE_DTOA_LOCK(0);
     616             :                                 zend_error_noreturn(E_ERROR, "Balloc() failed to allocate memory");
     617             :                         }
     618             : #endif
     619        3858 :                 rv->k = k;
     620        3858 :                 rv->maxwds = x;
     621             :                 }
     622             :         FREE_DTOA_LOCK(0);
     623      268139 :         rv->sign = rv->wds = 0;
     624      268139 :         return rv;
     625             :         }
     626             : 
     627             :  static void
     628      267816 : Bfree
     629             : #ifdef KR_headers
     630             :         (v) Bigint *v;
     631             : #else
     632             :         (Bigint *v)
     633             : #endif
     634             : {
     635      267816 :         if (v) {
     636      267808 :                 if (v->k > Kmax)
     637             : #ifdef FREE
     638             :                         FREE((void*)v);
     639             : #else
     640           1 :                         free((void*)v);
     641             : #endif
     642             :                 else {
     643             :                         ACQUIRE_DTOA_LOCK(0);
     644      267807 :                         v->next = freelist[v->k];
     645      267807 :                         freelist[v->k] = v;
     646             :                         FREE_DTOA_LOCK(0);
     647             :                         }
     648             :                 }
     649      267816 :         }
     650             : 
     651             : #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
     652             : y->wds*sizeof(Long) + 2*sizeof(int))
     653             : 
     654             :  static Bigint *
     655      347915 : multadd
     656             : #ifdef KR_headers
     657             :         (b, m, a) Bigint *b; int m, a;
     658             : #else
     659             :         (Bigint *b, int m, int a)       /* multiply by m and add a */
     660             : #endif
     661             : {
     662             :         int i, wds;
     663             : #ifdef ULLong
     664             :         ULong *x;
     665             :         ULLong carry, y;
     666             : #else
     667             :         ULong carry, *x, y;
     668             : #ifdef Pack_32
     669             :         ULong xi, z;
     670             : #endif
     671             : #endif
     672             :         Bigint *b1;
     673             : 
     674      347915 :         wds = b->wds;
     675      347915 :         x = b->x;
     676      347915 :         i = 0;
     677      347915 :         carry = a;
     678             :         do {
     679             : #ifdef ULLong
     680     7124621 :                 y = *x * (ULLong)m + carry;
     681     7124621 :                 carry = y >> 32;
     682     7124621 :                 *x++ = y & FFFFFFFF;
     683             : #else
     684             : #ifdef Pack_32
     685             :                 xi = *x;
     686             :                 y = (xi & 0xffff) * m + carry;
     687             :                 z = (xi >> 16) * m + (y >> 16);
     688             :                 carry = z >> 16;
     689             :                 *x++ = (z << 16) + (y & 0xffff);
     690             : #else
     691             :                 y = *x * m + carry;
     692             :                 carry = y >> 16;
     693             :                 *x++ = y & 0xffff;
     694             : #endif
     695             : #endif
     696             :                 }
     697     7124621 :                 while(++i < wds);
     698      347915 :         if (carry) {
     699        5673 :                 if (wds >= b->maxwds) {
     700           0 :                         b1 = Balloc(b->k+1);
     701           0 :                         Bcopy(b1, b);
     702           0 :                         Bfree(b);
     703           0 :                         b = b1;
     704             :                         }
     705        5673 :                 b->x[wds++] = carry;
     706        5673 :                 b->wds = wds;
     707             :                 }
     708      347915 :         return b;
     709             :         }
     710             : 
     711             :  static Bigint *
     712        2530 : s2b
     713             : #ifdef KR_headers
     714             :         (s, nd0, nd, y9, dplen) CONST char *s; int nd0, nd, dplen; ULong y9;
     715             : #else
     716             :         (const char *s, int nd0, int nd, ULong y9, int dplen)
     717             : #endif
     718             : {
     719             :         Bigint *b;
     720             :         int i, k;
     721             :         Long x, y;
     722             : 
     723        2530 :         x = (nd + 8) / 9;
     724        2530 :         for(k = 0, y = 1; x > y; y <<= 1, k++) ;
     725             : #ifdef Pack_32
     726        2530 :         b = Balloc(k);
     727        2530 :         b->x[0] = y9;
     728        2530 :         b->wds = 1;
     729             : #else
     730             :         b = Balloc(k+1);
     731             :         b->x[0] = y9 & 0xffff;
     732             :         b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
     733             : #endif
     734             : 
     735        2530 :         i = 9;
     736        2530 :         if (9 < nd0) {
     737        2328 :                 s += 9;
     738       45230 :                 do b = multadd(b, 10, *s++ - '0');
     739       45230 :                         while(++i < nd0);
     740        2328 :                 s += dplen;
     741             :                 }
     742             :         else
     743         202 :                 s += dplen + 9;
     744        3565 :         for(; i < nd; i++)
     745        1035 :                 b = multadd(b, 10, *s++ - '0');
     746        2530 :         return b;
     747             :         }
     748             : 
     749             :  static int
     750        3758 : hi0bits
     751             : #ifdef KR_headers
     752             :         (x) ULong x;
     753             : #else
     754             :         (ULong x)
     755             : #endif
     756             : {
     757        3758 :         int k = 0;
     758             : 
     759        3758 :         if (!(x & 0xffff0000)) {
     760        2492 :                 k = 16;
     761        2492 :                 x <<= 16;
     762             :                 }
     763        3758 :         if (!(x & 0xff000000)) {
     764        2264 :                 k += 8;
     765        2264 :                 x <<= 8;
     766             :                 }
     767        3758 :         if (!(x & 0xf0000000)) {
     768        2572 :                 k += 4;
     769        2572 :                 x <<= 4;
     770             :                 }
     771        3758 :         if (!(x & 0xc0000000)) {
     772        2508 :                 k += 2;
     773        2508 :                 x <<= 2;
     774             :                 }
     775        3758 :         if (!(x & 0x80000000)) {
     776        2762 :                 k++;
     777        2762 :                 if (!(x & 0x40000000))
     778           0 :                         return 32;
     779             :                 }
     780        3758 :         return k;
     781             :         }
     782             : 
     783             :  static int
     784      121896 : lo0bits
     785             : #ifdef KR_headers
     786             :         (y) ULong *y;
     787             : #else
     788             :         (ULong *y)
     789             : #endif
     790             : {
     791             :         int k;
     792      121896 :         ULong x = *y;
     793             : 
     794      121896 :         if (x & 7) {
     795       98047 :                 if (x & 1)
     796       55774 :                         return 0;
     797       42273 :                 if (x & 2) {
     798       28350 :                         *y = x >> 1;
     799       28350 :                         return 1;
     800             :                         }
     801       13923 :                 *y = x >> 2;
     802       13923 :                 return 2;
     803             :                 }
     804       23849 :         k = 0;
     805       23849 :         if (!(x & 0xffff)) {
     806        6743 :                 k = 16;
     807        6743 :                 x >>= 16;
     808             :                 }
     809       23849 :         if (!(x & 0xff)) {
     810        3954 :                 k += 8;
     811        3954 :                 x >>= 8;
     812             :                 }
     813       23849 :         if (!(x & 0xf)) {
     814       11955 :                 k += 4;
     815       11955 :                 x >>= 4;
     816             :                 }
     817       23849 :         if (!(x & 0x3)) {
     818       11793 :                 k += 2;
     819       11793 :                 x >>= 2;
     820             :                 }
     821       23849 :         if (!(x & 1)) {
     822       12677 :                 k++;
     823       12677 :                 x >>= 1;
     824       12677 :                 if (!x)
     825           0 :                         return 32;
     826             :                 }
     827       23849 :         *y = x;
     828       23849 :         return k;
     829             :         }
     830             : 
     831             :  static Bigint *
     832        4233 : i2b
     833             : #ifdef KR_headers
     834             :         (i) int i;
     835             : #else
     836             :         (int i)
     837             : #endif
     838             : {
     839             :         Bigint *b;
     840             : 
     841        4233 :         b = Balloc(1);
     842        4233 :         b->x[0] = i;
     843        4233 :         b->wds = 1;
     844        4233 :         return b;
     845             :         }
     846             : 
     847             :  static Bigint *
     848        4787 : mult
     849             : #ifdef KR_headers
     850             :         (a, b) Bigint *a, *b;
     851             : #else
     852             :         (Bigint *a, Bigint *b)
     853             : #endif
     854             : {
     855             :         Bigint *c;
     856             :         int k, wa, wb, wc;
     857             :         ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
     858             :         ULong y;
     859             : #ifdef ULLong
     860             :         ULLong carry, z;
     861             : #else
     862             :         ULong carry, z;
     863             : #ifdef Pack_32
     864             :         ULong z2;
     865             : #endif
     866             : #endif
     867             : 
     868        4787 :         if (a->wds < b->wds) {
     869        1825 :                 c = a;
     870        1825 :                 a = b;
     871        1825 :                 b = c;
     872             :                 }
     873        4787 :         k = a->k;
     874        4787 :         wa = a->wds;
     875        4787 :         wb = b->wds;
     876        4787 :         wc = wa + wb;
     877        4787 :         if (wc > a->maxwds)
     878        1794 :                 k++;
     879        4787 :         c = Balloc(k);
     880       36049 :         for(x = c->x, xa = x + wc; x < xa; x++)
     881       31262 :                 *x = 0;
     882        4787 :         xa = a->x;
     883        4787 :         xae = xa + wa;
     884        4787 :         xb = b->x;
     885        4787 :         xbe = xb + wb;
     886        4787 :         xc0 = c->x;
     887             : #ifdef ULLong
     888       13255 :         for(; xb < xbe; xc0++) {
     889        8468 :                 if ((y = *xb++)) {
     890        8468 :                         x = xa;
     891        8468 :                         xc = xc0;
     892        8468 :                         carry = 0;
     893             :                         do {
     894       75214 :                                 z = *x++ * (ULLong)y + *xc + carry;
     895       75214 :                                 carry = z >> 32;
     896       75214 :                                 *xc++ = z & FFFFFFFF;
     897             :                                 }
     898       75214 :                                 while(x < xae);
     899        8468 :                         *xc = carry;
     900             :                         }
     901             :                 }
     902             : #else
     903             : #ifdef Pack_32
     904             :         for(; xb < xbe; xb++, xc0++) {
     905             :                 if (y = *xb & 0xffff) {
     906             :                         x = xa;
     907             :                         xc = xc0;
     908             :                         carry = 0;
     909             :                         do {
     910             :                                 z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
     911             :                                 carry = z >> 16;
     912             :                                 z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
     913             :                                 carry = z2 >> 16;
     914             :                                 Storeinc(xc, z2, z);
     915             :                                 }
     916             :                                 while(x < xae);
     917             :                         *xc = carry;
     918             :                         }
     919             :                 if (y = *xb >> 16) {
     920             :                         x = xa;
     921             :                         xc = xc0;
     922             :                         carry = 0;
     923             :                         z2 = *xc;
     924             :                         do {
     925             :                                 z = (*x & 0xffff) * y + (*xc >> 16) + carry;
     926             :                                 carry = z >> 16;
     927             :                                 Storeinc(xc, z, z2);
     928             :                                 z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
     929             :                                 carry = z2 >> 16;
     930             :                                 }
     931             :                                 while(x < xae);
     932             :                         *xc = z2;
     933             :                         }
     934             :                 }
     935             : #else
     936             :         for(; xb < xbe; xc0++) {
     937             :                 if (y = *xb++) {
     938             :                         x = xa;
     939             :                         xc = xc0;
     940             :                         carry = 0;
     941             :                         do {
     942             :                                 z = *x++ * y + *xc + carry;
     943             :                                 carry = z >> 16;
     944             :                                 *xc++ = z & 0xffff;
     945             :                                 }
     946             :                                 while(x < xae);
     947             :                         *xc = carry;
     948             :                         }
     949             :                 }
     950             : #endif
     951             : #endif
     952        4787 :         for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
     953        4787 :         c->wds = wc;
     954        4787 :         return c;
     955             :         }
     956             : 
     957             :  static Bigint *p5s;
     958             : 
     959             :  static Bigint *
     960        1981 : pow5mult
     961             : #ifdef KR_headers
     962             :         (b, k) Bigint *b; int k;
     963             : #else
     964             :         (Bigint *b, int k)
     965             : #endif
     966             : {
     967             :         Bigint *b1, *p5, *p51;
     968             :         int i;
     969             :         static int p05[3] = { 5, 25, 125 };
     970             : 
     971        1981 :         if ((i = k & 3))
     972        1004 :                 b = multadd(b, p05[i-1], 0);
     973             : 
     974        1981 :         if (!(k >>= 2))
     975         106 :                 return b;
     976        1875 :         if (!(p5 = p5s)) {
     977             :                 /* first time */
     978             : #ifdef MULTIPLE_THREADS
     979             :                 ACQUIRE_DTOA_LOCK(1);
     980             :                 if (!(p5 = p5s)) {
     981             :                         p5 = p5s = i2b(625);
     982             :                         p5->next = 0;
     983             :                         }
     984             :                 FREE_DTOA_LOCK(1);
     985             : #else
     986          93 :                 p5 = p5s = i2b(625);
     987          93 :                 p5->next = 0;
     988             : #endif
     989             :                 }
     990             :         for(;;) {
     991        8487 :                 if (k & 1) {
     992        4370 :                         b1 = mult(b, p5);
     993        4370 :                         Bfree(b);
     994        4370 :                         b = b1;
     995             :                         }
     996        8487 :                 if (!(k >>= 1))
     997        1875 :                         break;
     998        6612 :                 if (!(p51 = p5->next)) {
     999             : #ifdef MULTIPLE_THREADS
    1000             :                         ACQUIRE_DTOA_LOCK(1);
    1001             :                         if (!(p51 = p5->next)) {
    1002             :                                 p51 = p5->next = mult(p5,p5);
    1003             :                                 p51->next = 0;
    1004             :                                 }
    1005             :                         FREE_DTOA_LOCK(1);
    1006             : #else
    1007         238 :                         p51 = p5->next = mult(p5,p5);
    1008         238 :                         p51->next = 0;
    1009             : #endif
    1010             :                         }
    1011        6612 :                 p5 = p51;
    1012        6612 :                 }
    1013        1875 :         return b;
    1014             :         }
    1015             : 
    1016             :  static Bigint *
    1017        9272 : lshift
    1018             : #ifdef KR_headers
    1019             :         (b, k) Bigint *b; int k;
    1020             : #else
    1021             :         (Bigint *b, int k)
    1022             : #endif
    1023             : {
    1024             :         int i, k1, n, n1;
    1025             :         Bigint *b1;
    1026             :         ULong *x, *x1, *xe, z;
    1027             : 
    1028             : #ifdef Pack_32
    1029        9272 :         n = k >> 5;
    1030             : #else
    1031             :         n = k >> 4;
    1032             : #endif
    1033        9272 :         k1 = b->k;
    1034        9272 :         n1 = n + b->wds + 1;
    1035       19272 :         for(i = b->maxwds; n1 > i; i <<= 1)
    1036       10000 :                 k1++;
    1037        9272 :         b1 = Balloc(k1);
    1038        9272 :         x1 = b1->x;
    1039       31673 :         for(i = 0; i < n; i++)
    1040       22401 :                 *x1++ = 0;
    1041        9272 :         x = b->x;
    1042        9272 :         xe = x + b->wds;
    1043             : #ifdef Pack_32
    1044        9272 :         if (k &= 0x1f) {
    1045        9086 :                 k1 = 32 - k;
    1046        9086 :                 z = 0;
    1047             :                 do {
    1048       42473 :                         *x1++ = *x << k | z;
    1049       42473 :                         z = *x++ >> k1;
    1050             :                         }
    1051       42473 :                         while(x < xe);
    1052        9086 :                 if ((*x1 = z))
    1053        2105 :                         ++n1;
    1054             :                 }
    1055             : #else
    1056             :         if (k &= 0xf) {
    1057             :                 k1 = 16 - k;
    1058             :                 z = 0;
    1059             :                 do {
    1060             :                         *x1++ = *x << k  & 0xffff | z;
    1061             :                         z = *x++ >> k1;
    1062             :                         }
    1063             :                         while(x < xe);
    1064             :                 if (*x1 = z)
    1065             :                         ++n1;
    1066             :                 }
    1067             : #endif
    1068             :         else do
    1069         334 :                 *x1++ = *x++;
    1070         334 :                 while(x < xe);
    1071        9272 :         b1->wds = n1 - 1;
    1072        9272 :         Bfree(b);
    1073        9272 :         return b1;
    1074             :         }
    1075             : 
    1076             :  static int
    1077      308813 : cmp
    1078             : #ifdef KR_headers
    1079             :         (a, b) Bigint *a, *b;
    1080             : #else
    1081             :         (Bigint *a, Bigint *b)
    1082             : #endif
    1083             : {
    1084             :         ULong *xa, *xa0, *xb, *xb0;
    1085             :         int i, j;
    1086             : 
    1087      308813 :         i = a->wds;
    1088      308813 :         j = b->wds;
    1089             : #ifdef DEBUG
    1090             :         if (i > 1 && !a->x[i-1])
    1091             :                 Bug("cmp called with a->x[a->wds-1] == 0");
    1092             :         if (j > 1 && !b->x[j-1])
    1093             :                 Bug("cmp called with b->x[b->wds-1] == 0");
    1094             : #endif
    1095      308813 :         if (i -= j)
    1096         115 :                 return i;
    1097      308698 :         xa0 = a->x;
    1098      308698 :         xa = xa0 + j;
    1099      308698 :         xb0 = b->x;
    1100      308698 :         xb = xb0 + j;
    1101             :         for(;;) {
    1102      314205 :                 if (*--xa != *--xb)
    1103      308582 :                         return *xa < *xb ? -1 : 1;
    1104        5623 :                 if (xa <= xa0)
    1105         116 :                         break;
    1106        5507 :                 }
    1107         116 :         return 0;
    1108             :         }
    1109             : 
    1110             :  static Bigint *
    1111        3035 : diff
    1112             : #ifdef KR_headers
    1113             :         (a, b) Bigint *a, *b;
    1114             : #else
    1115             :         (Bigint *a, Bigint *b)
    1116             : #endif
    1117             : {
    1118             :         Bigint *c;
    1119             :         int i, wa, wb;
    1120             :         ULong *xa, *xae, *xb, *xbe, *xc;
    1121             : #ifdef ULLong
    1122             :         ULLong borrow, y;
    1123             : #else
    1124             :         ULong borrow, y;
    1125             : #ifdef Pack_32
    1126             :         ULong z;
    1127             : #endif
    1128             : #endif
    1129             : 
    1130        3035 :         i = cmp(a,b);
    1131        3035 :         if (!i) {
    1132          19 :                 c = Balloc(0);
    1133          19 :                 c->wds = 1;
    1134          19 :                 c->x[0] = 0;
    1135          19 :                 return c;
    1136             :                 }
    1137        3016 :         if (i < 0) {
    1138        1373 :                 c = a;
    1139        1373 :                 a = b;
    1140        1373 :                 b = c;
    1141        1373 :                 i = 1;
    1142             :                 }
    1143             :         else
    1144        1643 :                 i = 0;
    1145        3016 :         c = Balloc(a->k);
    1146        3016 :         c->sign = i;
    1147        3016 :         wa = a->wds;
    1148        3016 :         xa = a->x;
    1149        3016 :         xae = xa + wa;
    1150        3016 :         wb = b->wds;
    1151        3016 :         xb = b->x;
    1152        3016 :         xbe = xb + wb;
    1153        3016 :         xc = c->x;
    1154        3016 :         borrow = 0;
    1155             : #ifdef ULLong
    1156             :         do {
    1157       12082 :                 y = (ULLong)*xa++ - *xb++ - borrow;
    1158       12082 :                 borrow = y >> 32 & (ULong)1;
    1159       12082 :                 *xc++ = y & FFFFFFFF;
    1160             :                 }
    1161       12082 :                 while(xb < xbe);
    1162        6056 :         while(xa < xae) {
    1163          24 :                 y = *xa++ - borrow;
    1164          24 :                 borrow = y >> 32 & (ULong)1;
    1165          24 :                 *xc++ = y & FFFFFFFF;
    1166             :                 }
    1167             : #else
    1168             : #ifdef Pack_32
    1169             :         do {
    1170             :                 y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
    1171             :                 borrow = (y & 0x10000) >> 16;
    1172             :                 z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
    1173             :                 borrow = (z & 0x10000) >> 16;
    1174             :                 Storeinc(xc, z, y);
    1175             :                 }
    1176             :                 while(xb < xbe);
    1177             :         while(xa < xae) {
    1178             :                 y = (*xa & 0xffff) - borrow;
    1179             :                 borrow = (y & 0x10000) >> 16;
    1180             :                 z = (*xa++ >> 16) - borrow;
    1181             :                 borrow = (z & 0x10000) >> 16;
    1182             :                 Storeinc(xc, z, y);
    1183             :                 }
    1184             : #else
    1185             :         do {
    1186             :                 y = *xa++ - *xb++ - borrow;
    1187             :                 borrow = (y & 0x10000) >> 16;
    1188             :                 *xc++ = y & 0xffff;
    1189             :                 }
    1190             :                 while(xb < xbe);
    1191             :         while(xa < xae) {
    1192             :                 y = *xa++ - borrow;
    1193             :                 borrow = (y & 0x10000) >> 16;
    1194             :                 *xc++ = y & 0xffff;
    1195             :                 }
    1196             : #endif
    1197             : #endif
    1198       11341 :         while(!*--xc)
    1199        5309 :                 wa--;
    1200        3016 :         c->wds = wa;
    1201        3016 :         return c;
    1202             :         }
    1203             : 
    1204             :  static double
    1205        1029 : ulp
    1206             : #ifdef KR_headers
    1207             :         (x) U *x;
    1208             : #else
    1209             :         (U *x)
    1210             : #endif
    1211             : {
    1212             :         Long L;
    1213             :         U u;
    1214             : 
    1215        1029 :         L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
    1216             : #ifndef Avoid_Underflow
    1217             : #ifndef Sudden_Underflow
    1218             :         if (L > 0) {
    1219             : #endif
    1220             : #endif
    1221             : #ifdef IBM
    1222             :                 L |= Exp_msk1 >> 4;
    1223             : #endif
    1224        1029 :                 word0(&u) = L;
    1225        1029 :                 word1(&u) = 0;
    1226             : #ifndef Avoid_Underflow
    1227             : #ifndef Sudden_Underflow
    1228             :                 }
    1229             :         else {
    1230             :                 L = -L >> Exp_shift;
    1231             :                 if (L < Exp_shift) {
    1232             :                         word0(&u) = 0x80000 >> L;
    1233             :                         word1(&u) = 0;
    1234             :                         }
    1235             :                 else {
    1236             :                         word0(&u) = 0;
    1237             :                         L -= Exp_shift;
    1238             :                         word1(&u) = L >= 31 ? 1 : 1 << 31 - L;
    1239             :                         }
    1240             :                 }
    1241             : #endif
    1242             : #endif
    1243        1029 :         return dval(&u);
    1244             :         }
    1245             : 
    1246             :  static double
    1247        2058 : b2d
    1248             : #ifdef KR_headers
    1249             :         (a, e) Bigint *a; int *e;
    1250             : #else
    1251             :         (Bigint *a, int *e)
    1252             : #endif
    1253             : {
    1254             :         ULong *xa, *xa0, w, y, z;
    1255             :         int k;
    1256             :         U d;
    1257             : #ifdef VAX
    1258             :         ULong d0, d1;
    1259             : #else
    1260             : #define d0 word0(&d)
    1261             : #define d1 word1(&d)
    1262             : #endif
    1263             : 
    1264        2058 :         xa0 = a->x;
    1265        2058 :         xa = xa0 + a->wds;
    1266        2058 :         y = *--xa;
    1267             : #ifdef DEBUG
    1268             :         if (!y) Bug("zero y in b2d");
    1269             : #endif
    1270        2058 :         k = hi0bits(y);
    1271        2058 :         *e = 32 - k;
    1272             : #ifdef Pack_32
    1273        2058 :         if (k < Ebits) {
    1274         910 :                 d0 = Exp_1 | y >> (Ebits - k);
    1275         910 :                 w = xa > xa0 ? *--xa : 0;
    1276         910 :                 d1 = y << ((32-Ebits) + k) | w >> (Ebits - k);
    1277         910 :                 goto ret_d;
    1278             :                 }
    1279        1148 :         z = xa > xa0 ? *--xa : 0;
    1280        1148 :         if (k -= Ebits) {
    1281        1119 :                 d0 = Exp_1 | y << k | z >> (32 - k);
    1282        1119 :                 y = xa > xa0 ? *--xa : 0;
    1283        1119 :                 d1 = z << k | y >> (32 - k);
    1284             :                 }
    1285             :         else {
    1286          29 :                 d0 = Exp_1 | y;
    1287          29 :                 d1 = z;
    1288             :                 }
    1289             : #else
    1290             :         if (k < Ebits + 16) {
    1291             :                 z = xa > xa0 ? *--xa : 0;
    1292             :                 d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
    1293             :                 w = xa > xa0 ? *--xa : 0;
    1294             :                 y = xa > xa0 ? *--xa : 0;
    1295             :                 d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
    1296             :                 goto ret_d;
    1297             :                 }
    1298             :         z = xa > xa0 ? *--xa : 0;
    1299             :         w = xa > xa0 ? *--xa : 0;
    1300             :         k -= Ebits + 16;
    1301             :         d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
    1302             :         y = xa > xa0 ? *--xa : 0;
    1303             :         d1 = w << k + 16 | y << k;
    1304             : #endif
    1305             :  ret_d:
    1306             : #ifdef VAX
    1307             :         word0(&d) = d0 >> 16 | d0 << 16;
    1308             :         word1(&d) = d1 >> 16 | d1 << 16;
    1309             : #else
    1310             : #undef d0
    1311             : #undef d1
    1312             : #endif
    1313        2058 :         return dval(&d);
    1314             :         }
    1315             : 
    1316             :  static Bigint *
    1317      121896 : d2b
    1318             : #ifdef KR_headers
    1319             :         (d, e, bits) U *d; int *e, *bits;
    1320             : #else
    1321             :         (U *d, int *e, int *bits)
    1322             : #endif
    1323             : {
    1324             :         Bigint *b;
    1325             :         int de, k;
    1326             :         ULong *x, y, z;
    1327             : #ifndef Sudden_Underflow
    1328             :         int i;
    1329             : #endif
    1330             : #ifdef VAX
    1331             :         ULong d0, d1;
    1332             :         d0 = word0(d) >> 16 | word0(d) << 16;
    1333             :         d1 = word1(d) >> 16 | word1(d) << 16;
    1334             : #else
    1335             : #define d0 word0(d)
    1336             : #define d1 word1(d)
    1337             : #endif
    1338             : 
    1339             : #ifdef Pack_32
    1340      121896 :         b = Balloc(1);
    1341             : #else
    1342             :         b = Balloc(2);
    1343             : #endif
    1344      121896 :         x = b->x;
    1345             : 
    1346      121896 :         z = d0 & Frac_mask;
    1347      121896 :         d0 &= 0x7fffffff;   /* clear sign bit, which we ignore */
    1348             : #ifdef Sudden_Underflow
    1349             :         de = (int)(d0 >> Exp_shift);
    1350             : #ifndef IBM
    1351             :         z |= Exp_msk11;
    1352             : #endif
    1353             : #else
    1354      121896 :         if ((de = (int)(d0 >> Exp_shift)))
    1355      121300 :                 z |= Exp_msk1;
    1356             : #endif
    1357             : #ifdef Pack_32
    1358      121896 :         if ((y = d1)) {
    1359      113105 :                 if ((k = lo0bits(&y))) {
    1360       57422 :                         x[0] = y | z << (32 - k);
    1361       57422 :                         z >>= k;
    1362             :                         }
    1363             :                 else
    1364       55683 :                         x[0] = y;
    1365             : #ifndef Sudden_Underflow
    1366      113105 :                 i =
    1367             : #endif
    1368      113105 :                     b->wds = (x[1] = z) ? 2 : 1;
    1369             :                 }
    1370             :         else {
    1371        8791 :                 k = lo0bits(&z);
    1372        8791 :                 x[0] = z;
    1373             : #ifndef Sudden_Underflow
    1374        8791 :                 i =
    1375             : #endif
    1376             :                     b->wds = 1;
    1377        8791 :                 k += 32;
    1378             :                 }
    1379             : #else
    1380             :         if (y = d1) {
    1381             :                 if (k = lo0bits(&y))
    1382             :                         if (k >= 16) {
    1383             :                                 x[0] = y | z << 32 - k & 0xffff;
    1384             :                                 x[1] = z >> k - 16 & 0xffff;
    1385             :                                 x[2] = z >> k;
    1386             :                                 i = 2;
    1387             :                                 }
    1388             :                         else {
    1389             :                                 x[0] = y & 0xffff;
    1390             :                                 x[1] = y >> 16 | z << 16 - k & 0xffff;
    1391             :                                 x[2] = z >> k & 0xffff;
    1392             :                                 x[3] = z >> k+16;
    1393             :                                 i = 3;
    1394             :                                 }
    1395             :                 else {
    1396             :                         x[0] = y & 0xffff;
    1397             :                         x[1] = y >> 16;
    1398             :                         x[2] = z & 0xffff;
    1399             :                         x[3] = z >> 16;
    1400             :                         i = 3;
    1401             :                         }
    1402             :                 }
    1403             :         else {
    1404             : #ifdef DEBUG
    1405             :                 if (!z)
    1406             :                         Bug("Zero passed to d2b");
    1407             : #endif
    1408             :                 k = lo0bits(&z);
    1409             :                 if (k >= 16) {
    1410             :                         x[0] = z;
    1411             :                         i = 0;
    1412             :                         }
    1413             :                 else {
    1414             :                         x[0] = z & 0xffff;
    1415             :                         x[1] = z >> 16;
    1416             :                         i = 1;
    1417             :                         }
    1418             :                 k += 32;
    1419             :                 }
    1420             :         while(!x[i])
    1421             :                 --i;
    1422             :         b->wds = i + 1;
    1423             : #endif
    1424             : #ifndef Sudden_Underflow
    1425      121896 :         if (de) {
    1426             : #endif
    1427             : #ifdef IBM
    1428             :                 *e = (de - Bias - (P-1) << 2) + k;
    1429             :                 *bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask);
    1430             : #else
    1431      121300 :                 *e = de - Bias - (P-1) + k;
    1432      121300 :                 *bits = P - k;
    1433             : #endif
    1434             : #ifndef Sudden_Underflow
    1435             :                 }
    1436             :         else {
    1437         596 :                 *e = de - Bias - (P-1) + 1 + k;
    1438             : #ifdef Pack_32
    1439         596 :                 *bits = 32*i - hi0bits(x[i-1]);
    1440             : #else
    1441             :                 *bits = (i+2)*16 - hi0bits(x[i]);
    1442             : #endif
    1443             :                 }
    1444             : #endif
    1445      121896 :         return b;
    1446             :         }
    1447             : #undef d0
    1448             : #undef d1
    1449             : 
    1450             :  static double
    1451        1029 : ratio
    1452             : #ifdef KR_headers
    1453             :         (a, b) Bigint *a, *b;
    1454             : #else
    1455             :         (Bigint *a, Bigint *b)
    1456             : #endif
    1457             : {
    1458             :         U da, db;
    1459             :         int k, ka, kb;
    1460             : 
    1461        1029 :         dval(&da) = b2d(a, &ka);
    1462        1029 :         dval(&db) = b2d(b, &kb);
    1463             : #ifdef Pack_32
    1464        1029 :         k = ka - kb + 32*(a->wds - b->wds);
    1465             : #else
    1466             :         k = ka - kb + 16*(a->wds - b->wds);
    1467             : #endif
    1468             : #ifdef IBM
    1469             :         if (k > 0) {
    1470             :                 word0(&da) += (k >> 2)*Exp_msk1;
    1471             :                 if (k &= 3)
    1472             :                         dval(&da) *= 1 << k;
    1473             :                 }
    1474             :         else {
    1475             :                 k = -k;
    1476             :                 word0(&db) += (k >> 2)*Exp_msk1;
    1477             :                 if (k &= 3)
    1478             :                         dval(&db) *= 1 << k;
    1479             :                 }
    1480             : #else
    1481        1029 :         if (k > 0)
    1482         276 :                 word0(&da) += k*Exp_msk1;
    1483             :         else {
    1484         753 :                 k = -k;
    1485         753 :                 word0(&db) += k*Exp_msk1;
    1486             :                 }
    1487             : #endif
    1488        1029 :         return dval(&da) / dval(&db);
    1489             :         }
    1490             : 
    1491             :  static CONST double
    1492             : tens[] = {
    1493             :                 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
    1494             :                 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
    1495             :                 1e20, 1e21, 1e22
    1496             : #ifdef VAX
    1497             :                 , 1e23, 1e24
    1498             : #endif
    1499             :                 };
    1500             : 
    1501             :  static CONST double
    1502             : #ifdef IEEE_Arith
    1503             : bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
    1504             : static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
    1505             : #ifdef Avoid_Underflow
    1506             :                 9007199254740992.*9007199254740992.e-256
    1507             :                 /* = 2^106 * 1e-256 */
    1508             : #else
    1509             :                 1e-256
    1510             : #endif
    1511             :                 };
    1512             : /* The factor of 2^53 in tinytens[4] helps us avoid setting the underflow */
    1513             : /* flag unnecessarily.  It leads to a song and dance at the end of strtod. */
    1514             : #define Scale_Bit 0x10
    1515             : #define n_bigtens 5
    1516             : #else
    1517             : #ifdef IBM
    1518             : bigtens[] = { 1e16, 1e32, 1e64 };
    1519             : static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 };
    1520             : #define n_bigtens 3
    1521             : #else
    1522             : bigtens[] = { 1e16, 1e32 };
    1523             : static CONST double tinytens[] = { 1e-16, 1e-32 };
    1524             : #define n_bigtens 2
    1525             : #endif
    1526             : #endif
    1527             : 
    1528             : #undef Need_Hexdig
    1529             : #ifdef INFNAN_CHECK
    1530             : #ifndef No_Hex_NaN
    1531             : #define Need_Hexdig
    1532             : #endif
    1533             : #endif
    1534             : 
    1535             : #ifndef Need_Hexdig
    1536             : #ifndef NO_HEX_FP
    1537             : #define Need_Hexdig
    1538             : #endif
    1539             : #endif
    1540             : 
    1541             : #ifdef Need_Hexdig /*{*/
    1542             : #if 0
    1543             : static unsigned char hexdig[256];
    1544             : 
    1545             :  static void
    1546             : htinit(unsigned char *h, unsigned char *s, int inc)
    1547             : {
    1548             :         int i, j;
    1549             :         for(i = 0; (j = s[i]) !=0; i++)
    1550             :                 h[j] = i + inc;
    1551             :         }
    1552             : 
    1553             :  static void
    1554             : hexdig_init(void)       /* Use of hexdig_init omitted 20121220 to avoid a */
    1555             :                         /* race condition when multiple threads are used. */
    1556             : {
    1557             : #define USC (unsigned char *)
    1558             :         htinit(hexdig, USC "0123456789", 0x10);
    1559             :         htinit(hexdig, USC "abcdef", 0x10 + 10);
    1560             :         htinit(hexdig, USC "ABCDEF", 0x10 + 10);
    1561             :         }
    1562             : #else
    1563             : static unsigned char hexdig[256] = {
    1564             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1565             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1566             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1567             :         16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,0,
    1568             :         0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,
    1569             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1570             :         0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,
    1571             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1572             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1573             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1574             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1575             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1576             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1577             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1578             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1579             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    1580             :         };
    1581             : #endif
    1582             : #endif /* } Need_Hexdig */
    1583             : 
    1584             : #ifdef INFNAN_CHECK
    1585             : 
    1586             : #ifndef NAN_WORD0
    1587             : #define NAN_WORD0 0x7ff80000
    1588             : #endif
    1589             : 
    1590             : #ifndef NAN_WORD1
    1591             : #define NAN_WORD1 0
    1592             : #endif
    1593             : 
    1594             :  static int
    1595          38 : match
    1596             : #ifdef KR_headers
    1597             :         (sp, t) char **sp, *t;
    1598             : #else
    1599             :         (const char **sp, const char *t)
    1600             : #endif
    1601             : {
    1602             :         int c, d;
    1603          38 :         CONST char *s = *sp;
    1604             : 
    1605          76 :         while((d = *t++)) {
    1606          38 :                 if ((c = *++s) >= 'A' && c <= 'Z')
    1607          22 :                         c += 'a' - 'A';
    1608          38 :                 if (c != d)
    1609          38 :                         return 0;
    1610             :                 }
    1611           0 :         *sp = s + 1;
    1612           0 :         return 1;
    1613             :         }
    1614             : 
    1615             : #ifndef No_Hex_NaN
    1616             :  static void
    1617           0 : hexnan
    1618             : #ifdef KR_headers
    1619             :         (rvp, sp) U *rvp; CONST char **sp;
    1620             : #else
    1621             :         (U *rvp, const char **sp)
    1622             : #endif
    1623             : {
    1624             :         ULong c, x[2];
    1625             :         CONST char *s;
    1626             :         int c1, havedig, udx0, xshift;
    1627             : 
    1628             :         /**** if (!hexdig['0']) hexdig_init(); ****/
    1629           0 :         x[0] = x[1] = 0;
    1630           0 :         havedig = xshift = 0;
    1631           0 :         udx0 = 1;
    1632           0 :         s = *sp;
    1633             :         /* allow optional initial 0x or 0X */
    1634           0 :         while((c = *(CONST unsigned char*)(s+1)) && c <= ' ')
    1635           0 :                 ++s;
    1636           0 :         if (s[1] == '0' && (s[2] == 'x' || s[2] == 'X'))
    1637           0 :                 s += 2;
    1638           0 :         while((c = *(CONST unsigned char*)++s)) {
    1639           0 :                 if ((c1 = hexdig[c]))
    1640           0 :                         c  = c1 & 0xf;
    1641           0 :                 else if (c <= ' ') {
    1642           0 :                         if (udx0 && havedig) {
    1643           0 :                                 udx0 = 0;
    1644           0 :                                 xshift = 1;
    1645             :                                 }
    1646           0 :                         continue;
    1647             :                         }
    1648             : #ifdef GDTOA_NON_PEDANTIC_NANCHECK
    1649             :                 else if (/*(*/ c == ')' && havedig) {
    1650             :                         *sp = s + 1;
    1651             :                         break;
    1652             :                         }
    1653             :                 else
    1654             :                         return; /* invalid form: don't change *sp */
    1655             : #else
    1656             :                 else {
    1657             :                         do {
    1658           0 :                                 if (/*(*/ c == ')') {
    1659           0 :                                         *sp = s + 1;
    1660           0 :                                         break;
    1661             :                                         }
    1662           0 :                                 } while((c = *++s));
    1663           0 :                         break;
    1664             :                         }
    1665             : #endif
    1666           0 :                 havedig = 1;
    1667           0 :                 if (xshift) {
    1668           0 :                         xshift = 0;
    1669           0 :                         x[0] = x[1];
    1670           0 :                         x[1] = 0;
    1671             :                         }
    1672           0 :                 if (udx0)
    1673           0 :                         x[0] = (x[0] << 4) | (x[1] >> 28);
    1674           0 :                 x[1] = (x[1] << 4) | c;
    1675             :                 }
    1676           0 :         if ((x[0] &= 0xfffff) || x[1]) {
    1677           0 :                 word0(rvp) = Exp_mask | x[0];
    1678           0 :                 word1(rvp) = x[1];
    1679             :                 }
    1680           0 :         }
    1681             : #endif /*No_Hex_NaN*/
    1682             : #endif /* INFNAN_CHECK */
    1683             : 
    1684             : #ifdef Pack_32
    1685             : #define ULbits 32
    1686             : #define kshift 5
    1687             : #define kmask 31
    1688             : #else
    1689             : #define ULbits 16
    1690             : #define kshift 4
    1691             : #define kmask 15
    1692             : #endif
    1693             : 
    1694             : #if !defined(NO_HEX_FP) || defined(Honor_FLT_ROUNDS) /*{*/
    1695             :  static Bigint *
    1696             : #ifdef KR_headers
    1697             : increment(b) Bigint *b;
    1698             : #else
    1699             : increment(Bigint *b)
    1700             : #endif
    1701             : {
    1702             :         ULong *x, *xe;
    1703             :         Bigint *b1;
    1704             : 
    1705             :         x = b->x;
    1706             :         xe = x + b->wds;
    1707             :         do {
    1708             :                 if (*x < (ULong)0xffffffffL) {
    1709             :                         ++*x;
    1710             :                         return b;
    1711             :                         }
    1712             :                 *x++ = 0;
    1713             :                 } while(x < xe);
    1714             :         {
    1715             :                 if (b->wds >= b->maxwds) {
    1716             :                         b1 = Balloc(b->k+1);
    1717             :                         Bcopy(b1,b);
    1718             :                         Bfree(b);
    1719             :                         b = b1;
    1720             :                         }
    1721             :                 b->x[b->wds++] = 1;
    1722             :                 }
    1723             :         return b;
    1724             :         }
    1725             : 
    1726             : #endif /*}*/
    1727             : 
    1728             : #ifndef NO_HEX_FP /*{*/
    1729             : 
    1730             :  static void
    1731             : #ifdef KR_headers
    1732             : rshift(b, k) Bigint *b; int k;
    1733             : #else
    1734             : rshift(Bigint *b, int k)
    1735             : #endif
    1736             : {
    1737             :         ULong *x, *x1, *xe, y;
    1738             :         int n;
    1739             : 
    1740             :         x = x1 = b->x;
    1741             :         n = k >> kshift;
    1742             :         if (n < b->wds) {
    1743             :                 xe = x + b->wds;
    1744             :                 x += n;
    1745             :                 if (k &= kmask) {
    1746             :                         n = 32 - k;
    1747             :                         y = *x++ >> k;
    1748             :                         while(x < xe) {
    1749             :                                 *x1++ = (y | (*x << n)) & 0xffffffff;
    1750             :                                 y = *x++ >> k;
    1751             :                                 }
    1752             :                         if ((*x1 = y) !=0)
    1753             :                                 x1++;
    1754             :                         }
    1755             :                 else
    1756             :                         while(x < xe)
    1757             :                                 *x1++ = *x++;
    1758             :                 }
    1759             :         if ((b->wds = x1 - b->x) == 0)
    1760             :                 b->x[0] = 0;
    1761             :         }
    1762             : 
    1763             :  static ULong
    1764             : #ifdef KR_headers
    1765             : any_on(b, k) Bigint *b; int k;
    1766             : #else
    1767             : any_on(Bigint *b, int k)
    1768             : #endif
    1769             : {
    1770             :         int n, nwds;
    1771             :         ULong *x, *x0, x1, x2;
    1772             : 
    1773             :         x = b->x;
    1774             :         nwds = b->wds;
    1775             :         n = k >> kshift;
    1776             :         if (n > nwds)
    1777             :                 n = nwds;
    1778             :         else if (n < nwds && (k &= kmask)) {
    1779             :                 x1 = x2 = x[n];
    1780             :                 x1 >>= k;
    1781             :                 x1 <<= k;
    1782             :                 if (x1 != x2)
    1783             :                         return 1;
    1784             :                 }
    1785             :         x0 = x;
    1786             :         x += n;
    1787             :         while(x > x0)
    1788             :                 if (*--x)
    1789             :                         return 1;
    1790             :         return 0;
    1791             :         }
    1792             : 
    1793             : enum {  /* rounding values: same as FLT_ROUNDS */
    1794             :         Round_zero = 0,
    1795             :         Round_near = 1,
    1796             :         Round_up = 2,
    1797             :         Round_down = 3
    1798             :         };
    1799             : 
    1800             :  void
    1801             : #ifdef KR_headers
    1802             : gethex(sp, rvp, rounding, sign)
    1803             :         CONST char **sp; U *rvp; int rounding, sign;
    1804             : #else
    1805             : gethex( CONST char **sp, U *rvp, int rounding, int sign)
    1806             : #endif
    1807             : {
    1808             :         Bigint *b;
    1809             :         CONST unsigned char *decpt, *s0, *s, *s1;
    1810             :         Long e, e1;
    1811             :         ULong L, lostbits, *x;
    1812             :         int big, denorm, esign, havedig, k, n, nbits, up, zret;
    1813             : #ifdef IBM
    1814             :         int j;
    1815             : #endif
    1816             :         enum {
    1817             : #ifdef IEEE_Arith /*{{*/
    1818             :                 emax = 0x7fe - Bias - P + 1,
    1819             :                 emin = Emin - P + 1
    1820             : #else /*}{*/
    1821             :                 emin = Emin - P,
    1822             : #ifdef VAX
    1823             :                 emax = 0x7ff - Bias - P + 1
    1824             : #endif
    1825             : #ifdef IBM
    1826             :                 emax = 0x7f - Bias - P
    1827             : #endif
    1828             : #endif /*}}*/
    1829             :                 };
    1830             : #ifdef USE_LOCALE
    1831             :         int i;
    1832             : #ifdef NO_LOCALE_CACHE
    1833             :         const unsigned char *decimalpoint = (unsigned char*)
    1834             :                 localeconv()->decimal_point;
    1835             : #else
    1836             :         const unsigned char *decimalpoint;
    1837             :         static unsigned char *decimalpoint_cache;
    1838             :         if (!(s0 = decimalpoint_cache)) {
    1839             :                 s0 = (unsigned char*)localeconv()->decimal_point;
    1840             :                 if ((decimalpoint_cache = (unsigned char*)
    1841             :                                 MALLOC(strlen((CONST char*)s0) + 1))) {
    1842             :                         strcpy((char*)decimalpoint_cache, (CONST char*)s0);
    1843             :                         s0 = decimalpoint_cache;
    1844             :                         }
    1845             :                 }
    1846             :         decimalpoint = s0;
    1847             : #endif
    1848             : #endif
    1849             : 
    1850             :         /**** if (!hexdig['0']) hexdig_init(); ****/
    1851             :         havedig = 0;
    1852             :         s0 = *(CONST unsigned char **)sp + 2;
    1853             :         while(s0[havedig] == '0')
    1854             :                 havedig++;
    1855             :         s0 += havedig;
    1856             :         s = s0;
    1857             :         decpt = 0;
    1858             :         zret = 0;
    1859             :         e = 0;
    1860             :         if (hexdig[*s])
    1861             :                 havedig++;
    1862             :         else {
    1863             :                 zret = 1;
    1864             : #ifdef USE_LOCALE
    1865             :                 for(i = 0; decimalpoint[i]; ++i) {
    1866             :                         if (s[i] != decimalpoint[i])
    1867             :                                 goto pcheck;
    1868             :                         }
    1869             :                 decpt = s += i;
    1870             : #else
    1871             :                 if (*s != '.')
    1872             :                         goto pcheck;
    1873             :                 decpt = ++s;
    1874             : #endif
    1875             :                 if (!hexdig[*s])
    1876             :                         goto pcheck;
    1877             :                 while(*s == '0')
    1878             :                         s++;
    1879             :                 if (hexdig[*s])
    1880             :                         zret = 0;
    1881             :                 havedig = 1;
    1882             :                 s0 = s;
    1883             :                 }
    1884             :         while(hexdig[*s])
    1885             :                 s++;
    1886             : #ifdef USE_LOCALE
    1887             :         if (*s == *decimalpoint && !decpt) {
    1888             :                 for(i = 1; decimalpoint[i]; ++i) {
    1889             :                         if (s[i] != decimalpoint[i])
    1890             :                                 goto pcheck;
    1891             :                         }
    1892             :                 decpt = s += i;
    1893             : #else
    1894             :         if (*s == '.' && !decpt) {
    1895             :                 decpt = ++s;
    1896             : #endif
    1897             :                 while(hexdig[*s])
    1898             :                         s++;
    1899             :                 }/*}*/
    1900             :         if (decpt)
    1901             :                 e = -(((Long)(s-decpt)) << 2);
    1902             :  pcheck:
    1903             :         s1 = s;
    1904             :         big = esign = 0;
    1905             :         switch(*s) {
    1906             :           case 'p':
    1907             :           case 'P':
    1908             :                 switch(*++s) {
    1909             :                   case '-':
    1910             :                         esign = 1;
    1911             :                         /* no break */
    1912             :                   case '+':
    1913             :                         s++;
    1914             :                   }
    1915             :                 if ((n = hexdig[*s]) == 0 || n > 0x19) {
    1916             :                         s = s1;
    1917             :                         break;
    1918             :                         }
    1919             :                 e1 = n - 0x10;
    1920             :                 while((n = hexdig[*++s]) !=0 && n <= 0x19) {
    1921             :                         if (e1 & 0xf8000000)
    1922             :                                 big = 1;
    1923             :                         e1 = 10*e1 + n - 0x10;
    1924             :                         }
    1925             :                 if (esign)
    1926             :                         e1 = -e1;
    1927             :                 e += e1;
    1928             :           }
    1929             :         *sp = (char*)s;
    1930             :         if (!havedig)
    1931             :                 *sp = (char*)s0 - 1;
    1932             :         if (zret)
    1933             :                 goto retz1;
    1934             :         if (big) {
    1935             :                 if (esign) {
    1936             : #ifdef IEEE_Arith
    1937             :                         switch(rounding) {
    1938             :                           case Round_up:
    1939             :                                 if (sign)
    1940             :                                         break;
    1941             :                                 goto ret_tiny;
    1942             :                           case Round_down:
    1943             :                                 if (!sign)
    1944             :                                         break;
    1945             :                                 goto ret_tiny;
    1946             :                           }
    1947             : #endif
    1948             :                         goto retz;
    1949             : #ifdef IEEE_Arith
    1950             :  ret_tinyf:
    1951             :                         Bfree(b);
    1952             :  ret_tiny:
    1953             : #ifndef NO_ERRNO
    1954             :                         errno = ERANGE;
    1955             : #endif
    1956             :                         word0(rvp) = 0;
    1957             :                         word1(rvp) = 1;
    1958             :                         return;
    1959             : #endif /* IEEE_Arith */
    1960             :                         }
    1961             :                 switch(rounding) {
    1962             :                   case Round_near:
    1963             :                         goto ovfl1;
    1964             :                   case Round_up:
    1965             :                         if (!sign)
    1966             :                                 goto ovfl1;
    1967             :                         goto ret_big;
    1968             :                   case Round_down:
    1969             :                         if (sign)
    1970             :                                 goto ovfl1;
    1971             :                         goto ret_big;
    1972             :                   }
    1973             :  ret_big:
    1974             :                 word0(rvp) = Big0;
    1975             :                 word1(rvp) = Big1;
    1976             :                 return;
    1977             :                 }
    1978             :         n = s1 - s0 - 1;
    1979             :         for(k = 0; n > (1 << (kshift-2)) - 1; n >>= 1)
    1980             :                 k++;
    1981             :         b = Balloc(k);
    1982             :         x = b->x;
    1983             :         n = 0;
    1984             :         L = 0;
    1985             : #ifdef USE_LOCALE
    1986             :         for(i = 0; decimalpoint[i+1]; ++i);
    1987             : #endif
    1988             :         while(s1 > s0) {
    1989             : #ifdef USE_LOCALE
    1990             :                 if (*--s1 == decimalpoint[i]) {
    1991             :                         s1 -= i;
    1992             :                         continue;
    1993             :                         }
    1994             : #else
    1995             :                 if (*--s1 == '.')
    1996             :                         continue;
    1997             : #endif
    1998             :                 if (n == ULbits) {
    1999             :                         *x++ = L;
    2000             :                         L = 0;
    2001             :                         n = 0;
    2002             :                         }
    2003             :                 L |= (hexdig[*s1] & 0x0f) << n;
    2004             :                 n += 4;
    2005             :                 }
    2006             :         *x++ = L;
    2007             :         b->wds = n = x - b->x;
    2008             :         n = ULbits*n - hi0bits(L);
    2009             :         nbits = Nbits;
    2010             :         lostbits = 0;
    2011             :         x = b->x;
    2012             :         if (n > nbits) {
    2013             :                 n -= nbits;
    2014             :                 if (any_on(b,n)) {
    2015             :                         lostbits = 1;
    2016             :                         k = n - 1;
    2017             :                         if (x[k>>kshift] & 1 << (k & kmask)) {
    2018             :                                 lostbits = 2;
    2019             :                                 if (k > 0 && any_on(b,k))
    2020             :                                         lostbits = 3;
    2021             :                                 }
    2022             :                         }
    2023             :                 rshift(b, n);
    2024             :                 e += n;
    2025             :                 }
    2026             :         else if (n < nbits) {
    2027             :                 n = nbits - n;
    2028             :                 b = lshift(b, n);
    2029             :                 e -= n;
    2030             :                 x = b->x;
    2031             :                 }
    2032             :         if (e > Emax) {
    2033             :  ovfl:
    2034             :                 Bfree(b);
    2035             :  ovfl1:
    2036             : #ifndef NO_ERRNO
    2037             :                 errno = ERANGE;
    2038             : #endif
    2039             :                 word0(rvp) = Exp_mask;
    2040             :                 word1(rvp) = 0;
    2041             :                 return;
    2042             :                 }
    2043             :         denorm = 0;
    2044             :         if (e < emin) {
    2045             :                 denorm = 1;
    2046             :                 n = emin - e;
    2047             :                 if (n >= nbits) {
    2048             : #ifdef IEEE_Arith /*{*/
    2049             :                         switch (rounding) {
    2050             :                           case Round_near:
    2051             :                                 if (n == nbits && (n < 2 || any_on(b,n-1)))
    2052             :                                         goto ret_tinyf;
    2053             :                                 break;
    2054             :                           case Round_up:
    2055             :                                 if (!sign)
    2056             :                                         goto ret_tinyf;
    2057             :                                 break;
    2058             :                           case Round_down:
    2059             :                                 if (sign)
    2060             :                                         goto ret_tinyf;
    2061             :                           }
    2062             : #endif /* } IEEE_Arith */
    2063             :                         Bfree(b);
    2064             :  retz:
    2065             : #ifndef NO_ERRNO
    2066             :                         errno = ERANGE;
    2067             : #endif
    2068             :  retz1:
    2069             :                         rvp->d = 0.;
    2070             :                         return;
    2071             :                         }
    2072             :                 k = n - 1;
    2073             :                 if (lostbits)
    2074             :                         lostbits = 1;
    2075             :                 else if (k > 0)
    2076             :                         lostbits = any_on(b,k);
    2077             :                 if (x[k>>kshift] & 1 << (k & kmask))
    2078             :                         lostbits |= 2;
    2079             :                 nbits -= n;
    2080             :                 rshift(b,n);
    2081             :                 e = emin;
    2082             :                 }
    2083             :         if (lostbits) {
    2084             :                 up = 0;
    2085             :                 switch(rounding) {
    2086             :                   case Round_zero:
    2087             :                         break;
    2088             :                   case Round_near:
    2089             :                         if (lostbits & 2
    2090             :                          && (lostbits & 1) | (x[0] & 1))
    2091             :                                 up = 1;
    2092             :                         break;
    2093             :                   case Round_up:
    2094             :                         up = 1 - sign;
    2095             :                         break;
    2096             :                   case Round_down:
    2097             :                         up = sign;
    2098             :                   }
    2099             :                 if (up) {
    2100             :                         k = b->wds;
    2101             :                         b = increment(b);
    2102             :                         x = b->x;
    2103             :                         if (denorm) {
    2104             : #if 0
    2105             :                                 if (nbits == Nbits - 1
    2106             :                                  && x[nbits >> kshift] & 1 << (nbits & kmask))
    2107             :                                         denorm = 0; /* not currently used */
    2108             : #endif
    2109             :                                 }
    2110             :                         else if (b->wds > k
    2111             :                          || ((n = nbits & kmask) !=0
    2112             :                              && hi0bits(x[k-1]) < 32-n)) {
    2113             :                                 rshift(b,1);
    2114             :                                 if (++e > Emax)
    2115             :                                         goto ovfl;
    2116             :                                 }
    2117             :                         }
    2118             :                 }
    2119             : #ifdef IEEE_Arith
    2120             :         if (denorm)
    2121             :                 word0(rvp) = b->wds > 1 ? b->x[1] & ~0x100000 : 0;
    2122             :         else
    2123             :                 word0(rvp) = (b->x[1] & ~0x100000) | ((e + 0x3ff + 52) << 20);
    2124             :         word1(rvp) = b->x[0];
    2125             : #endif
    2126             : #ifdef IBM
    2127             :         if ((j = e & 3)) {
    2128             :                 k = b->x[0] & ((1 << j) - 1);
    2129             :                 rshift(b,j);
    2130             :                 if (k) {
    2131             :                         switch(rounding) {
    2132             :                           case Round_up:
    2133             :                                 if (!sign)
    2134             :                                         increment(b);
    2135             :                                 break;
    2136             :                           case Round_down:
    2137             :                                 if (sign)
    2138             :                                         increment(b);
    2139             :                                 break;
    2140             :                           case Round_near:
    2141             :                                 j = 1 << (j-1);
    2142             :                                 if (k & j && ((k & (j-1)) | lostbits))
    2143             :                                         increment(b);
    2144             :                           }
    2145             :                         }
    2146             :                 }
    2147             :         e >>= 2;
    2148             :         word0(rvp) = b->x[1] | ((e + 65 + 13) << 24);
    2149             :         word1(rvp) = b->x[0];
    2150             : #endif
    2151             : #ifdef VAX
    2152             :         /* The next two lines ignore swap of low- and high-order 2 bytes. */
    2153             :         /* word0(rvp) = (b->x[1] & ~0x800000) | ((e + 129 + 55) << 23); */
    2154             :         /* word1(rvp) = b->x[0]; */
    2155             :         word0(rvp) = ((b->x[1] & ~0x800000) >> 16) | ((e + 129 + 55) << 7) | (b->x[1] << 16);
    2156             :         word1(rvp) = (b->x[0] >> 16) | (b->x[0] << 16);
    2157             : #endif
    2158             :         Bfree(b);
    2159             :         }
    2160             : #endif /*!NO_HEX_FP}*/
    2161             : 
    2162             :  static int
    2163             : #ifdef KR_headers
    2164             : dshift(b, p2) Bigint *b; int p2;
    2165             : #else
    2166        1104 : dshift(Bigint *b, int p2)
    2167             : #endif
    2168             : {
    2169        1104 :         int rv = hi0bits(b->x[b->wds-1]) - 4;
    2170        1104 :         if (p2 > 0)
    2171         823 :                 rv -= p2;
    2172        1104 :         return rv & kmask;
    2173             :         }
    2174             : 
    2175             :  static int
    2176      301703 : quorem
    2177             : #ifdef KR_headers
    2178             :         (b, S) Bigint *b, *S;
    2179             : #else
    2180             :         (Bigint *b, Bigint *S)
    2181             : #endif
    2182             : {
    2183             :         int n;
    2184             :         ULong *bx, *bxe, q, *sx, *sxe;
    2185             : #ifdef ULLong
    2186             :         ULLong borrow, carry, y, ys;
    2187             : #else
    2188             :         ULong borrow, carry, y, ys;
    2189             : #ifdef Pack_32
    2190             :         ULong si, z, zs;
    2191             : #endif
    2192             : #endif
    2193             : 
    2194      301703 :         n = S->wds;
    2195             : #ifdef DEBUG
    2196             :         /*debug*/ if (b->wds > n)
    2197             :         /*debug*/       Bug("oversize b in quorem");
    2198             : #endif
    2199      301703 :         if (b->wds < n)
    2200         527 :                 return 0;
    2201      301176 :         sx = S->x;
    2202      301176 :         sxe = sx + --n;
    2203      301176 :         bx = b->x;
    2204      301176 :         bxe = bx + n;
    2205      301176 :         q = *bxe / (*sxe + 1);  /* ensure q <= true quotient */
    2206             : #ifdef DEBUG
    2207             : #ifdef NO_STRTOD_BIGCOMP
    2208             :         /*debug*/ if (q > 9)
    2209             : #else
    2210             :         /* An oversized q is possible when quorem is called from bigcomp and */
    2211             :         /* the input is near, e.g., twice the smallest denormalized number. */
    2212             :         /*debug*/ if (q > 15)
    2213             : #endif
    2214             :         /*debug*/       Bug("oversized quotient in quorem");
    2215             : #endif
    2216      301176 :         if (q) {
    2217      269877 :                 borrow = 0;
    2218      269877 :                 carry = 0;
    2219             :                 do {
    2220             : #ifdef ULLong
    2221     6328745 :                         ys = *sx++ * (ULLong)q + carry;
    2222     6328745 :                         carry = ys >> 32;
    2223     6328745 :                         y = *bx - (ys & FFFFFFFF) - borrow;
    2224     6328745 :                         borrow = y >> 32 & (ULong)1;
    2225     6328745 :                         *bx++ = y & FFFFFFFF;
    2226             : #else
    2227             : #ifdef Pack_32
    2228             :                         si = *sx++;
    2229             :                         ys = (si & 0xffff) * q + carry;
    2230             :                         zs = (si >> 16) * q + (ys >> 16);
    2231             :                         carry = zs >> 16;
    2232             :                         y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
    2233             :                         borrow = (y & 0x10000) >> 16;
    2234             :                         z = (*bx >> 16) - (zs & 0xffff) - borrow;
    2235             :                         borrow = (z & 0x10000) >> 16;
    2236             :                         Storeinc(bx, z, y);
    2237             : #else
    2238             :                         ys = *sx++ * q + carry;
    2239             :                         carry = ys >> 16;
    2240             :                         y = *bx - (ys & 0xffff) - borrow;
    2241             :                         borrow = (y & 0x10000) >> 16;
    2242             :                         *bx++ = y & 0xffff;
    2243             : #endif
    2244             : #endif
    2245             :                         }
    2246     6328745 :                         while(sx <= sxe);
    2247      269877 :                 if (!*bxe) {
    2248           0 :                         bx = b->x;
    2249           0 :                         while(--bxe > bx && !*bxe)
    2250           0 :                                 --n;
    2251           0 :                         b->wds = n;
    2252             :                         }
    2253             :                 }
    2254      301176 :         if (cmp(b, S) >= 0) {
    2255         190 :                 q++;
    2256         190 :                 borrow = 0;
    2257         190 :                 carry = 0;
    2258         190 :                 bx = b->x;
    2259         190 :                 sx = S->x;
    2260             :                 do {
    2261             : #ifdef ULLong
    2262         732 :                         ys = *sx++ + carry;
    2263         732 :                         carry = ys >> 32;
    2264         732 :                         y = *bx - (ys & FFFFFFFF) - borrow;
    2265         732 :                         borrow = y >> 32 & (ULong)1;
    2266         732 :                         *bx++ = y & FFFFFFFF;
    2267             : #else
    2268             : #ifdef Pack_32
    2269             :                         si = *sx++;
    2270             :                         ys = (si & 0xffff) + carry;
    2271             :                         zs = (si >> 16) + (ys >> 16);
    2272             :                         carry = zs >> 16;
    2273             :                         y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
    2274             :                         borrow = (y & 0x10000) >> 16;
    2275             :                         z = (*bx >> 16) - (zs & 0xffff) - borrow;
    2276             :                         borrow = (z & 0x10000) >> 16;
    2277             :                         Storeinc(bx, z, y);
    2278             : #else
    2279             :                         ys = *sx++ + carry;
    2280             :                         carry = ys >> 16;
    2281             :                         y = *bx - (ys & 0xffff) - borrow;
    2282             :                         borrow = (y & 0x10000) >> 16;
    2283             :                         *bx++ = y & 0xffff;
    2284             : #endif
    2285             : #endif
    2286             :                         }
    2287         732 :                         while(sx <= sxe);
    2288         190 :                 bx = b->x;
    2289         190 :                 bxe = bx + n;
    2290         190 :                 if (!*bxe) {
    2291         566 :                         while(--bxe > bx && !*bxe)
    2292         190 :                                 --n;
    2293         188 :                         b->wds = n;
    2294             :                         }
    2295             :                 }
    2296      301176 :         return q;
    2297             :         }
    2298             : 
    2299             : #if defined(Avoid_Underflow) || !defined(NO_STRTOD_BIGCOMP) /*{*/
    2300             :  static double
    2301           0 : sulp
    2302             : #ifdef KR_headers
    2303             :         (x, bc) U *x; BCinfo *bc;
    2304             : #else
    2305             :         (U *x, BCinfo *bc)
    2306             : #endif
    2307             : {
    2308             :         U u;
    2309             :         double rv;
    2310             :         int i;
    2311             : 
    2312           0 :         rv = ulp(x);
    2313           0 :         if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0)
    2314           0 :                 return rv; /* Is there an example where i <= 0 ? */
    2315           0 :         word0(&u) = Exp_1 + (i << Exp_shift);
    2316           0 :         word1(&u) = 0;
    2317           0 :         return rv * u.d;
    2318             :         }
    2319             : #endif /*}*/
    2320             : 
    2321             : #ifndef NO_STRTOD_BIGCOMP
    2322             :  static void
    2323         202 : bigcomp
    2324             : #ifdef KR_headers
    2325             :         (rv, s0, bc)
    2326             :         U *rv; CONST char *s0; BCinfo *bc;
    2327             : #else
    2328             :         (U *rv, const char *s0, BCinfo *bc)
    2329             : #endif
    2330             : {
    2331             :         Bigint *b, *d;
    2332             :         int b2, bbits, d2, dd, dig, dsign, i, j, nd, nd0, p2, p5, speccase;
    2333             : 
    2334         202 :         dsign = bc->dsign;
    2335         202 :         nd = bc->nd;
    2336         202 :         nd0 = bc->nd0;
    2337         202 :         p5 = nd + bc->e0 - 1;
    2338         202 :         speccase = 0;
    2339             : #ifndef Sudden_Underflow
    2340         202 :         if (rv->d == 0.) {   /* special case: value near underflow-to-zero */
    2341             :                                 /* threshold was rounded to zero */
    2342           1 :                 b = i2b(1);
    2343           1 :                 p2 = Emin - P + 1;
    2344           1 :                 bbits = 1;
    2345             : #ifdef Avoid_Underflow
    2346           1 :                 word0(rv) = (P+2) << Exp_shift;
    2347             : #else
    2348             :                 word1(rv) = 1;
    2349             : #endif
    2350           1 :                 i = 0;
    2351             : #ifdef Honor_FLT_ROUNDS
    2352             :                 if (bc->rounding == 1)
    2353             : #endif
    2354             :                         {
    2355           1 :                         speccase = 1;
    2356           1 :                         --p2;
    2357           1 :                         dsign = 0;
    2358           1 :                         goto have_i;
    2359             :                         }
    2360             :                 }
    2361             :         else
    2362             : #endif
    2363         201 :                 b = d2b(rv, &p2, &bbits);
    2364             : #ifdef Avoid_Underflow
    2365         201 :         p2 -= bc->scale;
    2366             : #endif
    2367             :         /* floor(log2(rv)) == bbits - 1 + p2 */
    2368             :         /* Check for denormal case. */
    2369         201 :         i = P - bbits;
    2370         201 :         if (i > (j = P - Emin - 1 + p2)) {
    2371             : #ifdef Sudden_Underflow
    2372             :                 Bfree(b);
    2373             :                 b = i2b(1);
    2374             :                 p2 = Emin;
    2375             :                 i = P - 1;
    2376             : #ifdef Avoid_Underflow
    2377             :                 word0(rv) = (1 + bc->scale) << Exp_shift;
    2378             : #else
    2379             :                 word0(rv) = Exp_msk1;
    2380             : #endif
    2381             :                 word1(rv) = 0;
    2382             : #else
    2383           0 :                 i = j;
    2384             : #endif
    2385             :                 }
    2386             : #ifdef Honor_FLT_ROUNDS
    2387             :         if (bc->rounding != 1) {
    2388             :                 if (i > 0)
    2389             :                         b = lshift(b, i);
    2390             :                 if (dsign)
    2391             :                         b = increment(b);
    2392             :                 }
    2393             :         else
    2394             : #endif
    2395             :                 {
    2396         201 :                 b = lshift(b, ++i);
    2397         201 :                 b->x[0] |= 1;
    2398             :                 }
    2399             : #ifndef Sudden_Underflow
    2400             :  have_i:
    2401             : #endif
    2402         202 :         p2 -= p5 + i;
    2403         202 :         d = i2b(1);
    2404             :         /* Arrange for convenient computation of quotients:
    2405             :          * shift left if necessary so divisor has 4 leading 0 bits.
    2406             :          */
    2407         202 :         if (p5 > 0)
    2408         200 :                 d = pow5mult(d, p5);
    2409           2 :         else if (p5 < 0)
    2410           1 :                 b = pow5mult(b, -p5);
    2411         202 :         if (p2 > 0) {
    2412         200 :                 b2 = p2;
    2413         200 :                 d2 = 0;
    2414             :                 }
    2415             :         else {
    2416           2 :                 b2 = 0;
    2417           2 :                 d2 = -p2;
    2418             :                 }
    2419         202 :         i = dshift(d, d2);
    2420         202 :         if ((b2 += i) > 0)
    2421         202 :                 b = lshift(b, b2);
    2422         202 :         if ((d2 += i) > 0)
    2423         202 :                 d = lshift(d, d2);
    2424             : 
    2425             :         /* Now b/d = exactly half-way between the two floating-point values */
    2426             :         /* on either side of the input string.  Compute first digit of b/d. */
    2427             : 
    2428         202 :         if (!(dig = quorem(b,d))) {
    2429           0 :                 b = multadd(b, 10, 0);  /* very unlikely */
    2430           0 :                 dig = quorem(b,d);
    2431             :                 }
    2432             : 
    2433             :         /* Compare b/d with s0 */
    2434             : 
    2435        3837 :         for(i = 0; i < nd0; ) {
    2436        3634 :                 if ((dd = s0[i++] - '0' - dig))
    2437         201 :                         goto ret;
    2438        3433 :                 if (!b->x[0] && b->wds == 1) {
    2439           0 :                         if (i < nd)
    2440           0 :                                 dd = 1;
    2441           0 :                         goto ret;
    2442             :                         }
    2443        3433 :                 b = multadd(b, 10, 0);
    2444        3433 :                 dig = quorem(b,d);
    2445             :                 }
    2446          17 :         for(j = bc->dp1; i++ < nd;) {
    2447          16 :                 if ((dd = s0[j++] - '0' - dig))
    2448           1 :                         goto ret;
    2449          15 :                 if (!b->x[0] && b->wds == 1) {
    2450           0 :                         if (i < nd)
    2451           0 :                                 dd = 1;
    2452           0 :                         goto ret;
    2453             :                         }
    2454          15 :                 b = multadd(b, 10, 0);
    2455          15 :                 dig = quorem(b,d);
    2456             :                 }
    2457           0 :         if (dig > 0 || b->x[0] || b->wds > 1)
    2458           0 :                 dd = -1;
    2459             :  ret:
    2460         202 :         Bfree(b);
    2461         202 :         Bfree(d);
    2462             : #ifdef Honor_FLT_ROUNDS
    2463             :         if (bc->rounding != 1) {
    2464             :                 if (dd < 0) {
    2465             :                         if (bc->rounding == 0) {
    2466             :                                 if (!dsign)
    2467             :                                         goto retlow1;
    2468             :                                 }
    2469             :                         else if (dsign)
    2470             :                                 goto rethi1;
    2471             :                         }
    2472             :                 else if (dd > 0) {
    2473             :                         if (bc->rounding == 0) {
    2474             :                                 if (dsign)
    2475             :                                         goto rethi1;
    2476             :                                 goto ret1;
    2477             :                                 }
    2478             :                         if (!dsign)
    2479             :                                 goto rethi1;
    2480             :                         dval(rv) += 2.*sulp(rv,bc);
    2481             :                         }
    2482             :                 else {
    2483             :                         bc->inexact = 0;
    2484             :                         if (dsign)
    2485             :                                 goto rethi1;
    2486             :                         }
    2487             :                 }
    2488             :         else
    2489             : #endif
    2490         202 :         if (speccase) {
    2491           1 :                 if (dd <= 0)
    2492           1 :                         rv->d = 0.;
    2493             :                 }
    2494         201 :         else if (dd < 0) {
    2495         201 :                 if (!dsign)     /* does not happen for round-near */
    2496             : retlow1:
    2497           0 :                         dval(rv) -= sulp(rv,bc);
    2498             :                 }
    2499           0 :         else if (dd > 0) {
    2500           0 :                 if (dsign) {
    2501             :  rethi1:
    2502           0 :                         dval(rv) += sulp(rv,bc);
    2503             :                         }
    2504             :                 }
    2505             :         else {
    2506             :                 /* Exact half-way case:  apply round-even rule. */
    2507           0 :                 if ((j = ((word0(rv) & Exp_mask) >> Exp_shift) - bc->scale) <= 0) {
    2508           0 :                         i = 1 - j;
    2509           0 :                         if (i <= 31) {
    2510           0 :                                 if (word1(rv) & (0x1 << i))
    2511           0 :                                         goto odd;
    2512             :                                 }
    2513           0 :                         else if (word0(rv) & (0x1 << (i-32)))
    2514           0 :                                 goto odd;
    2515             :                         }
    2516           0 :                 else if (word1(rv) & 1) {
    2517             :  odd:
    2518           0 :                         if (dsign)
    2519           0 :                                 goto rethi1;
    2520           0 :                         goto retlow1;
    2521             :                         }
    2522             :                 }
    2523             : 
    2524             : #ifdef Honor_FLT_ROUNDS
    2525             :  ret1:
    2526             : #endif
    2527         202 :         return;
    2528             :         }
    2529             : #endif /* NO_STRTOD_BIGCOMP */
    2530             : 
    2531             : ZEND_API double
    2532      234825 : zend_strtod
    2533             : #ifdef KR_headers
    2534             :         (s00, se) CONST char *s00; char **se;
    2535             : #else
    2536             :         (const char *s00, const char **se)
    2537             : #endif
    2538             : {
    2539             :         int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
    2540             :         int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign;
    2541             :         CONST char *s, *s0, *s1;
    2542             :         volatile double aadj, aadj1;
    2543             :         Long L;
    2544             :         U aadj2, adj, rv, rv0;
    2545             :         ULong y, z;
    2546             :         BCinfo bc;
    2547             :         Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
    2548             : #ifdef Avoid_Underflow
    2549             :         ULong Lsb, Lsb1;
    2550             : #endif
    2551             : #ifdef SET_INEXACT
    2552             :         int oldinexact;
    2553             : #endif
    2554             : #ifndef NO_STRTOD_BIGCOMP
    2555      234825 :         int req_bigcomp = 0;
    2556             : #endif
    2557             : #ifdef Honor_FLT_ROUNDS /*{*/
    2558             : #ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
    2559             :         bc.rounding = Flt_Rounds;
    2560             : #else /*}{*/
    2561             :         bc.rounding = 1;
    2562             :         switch(fegetround()) {
    2563             :           case FE_TOWARDZERO:   bc.rounding = 0; break;
    2564             :           case FE_UPWARD:       bc.rounding = 2; break;
    2565             :           case FE_DOWNWARD:     bc.rounding = 3;
    2566             :           }
    2567             : #endif /*}}*/
    2568             : #endif /*}*/
    2569             : #ifdef USE_LOCALE
    2570             :         CONST char *s2;
    2571             : #endif
    2572             : 
    2573      234825 :         sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0;
    2574      234825 :         dval(&rv) = 0.;
    2575      234913 :         for(s = s00;;s++) switch(*s) {
    2576             :                 case '-':
    2577         862 :                         sign = 1;
    2578             :                         /* no break */
    2579             :                 case '+':
    2580         876 :                         if (*++s)
    2581         876 :                                 goto break2;
    2582             :                         /* no break */
    2583             :                 case 0:
    2584          86 :                         goto ret0;
    2585             :                 case '\t':
    2586             :                 case '\n':
    2587             :                 case '\v':
    2588             :                 case '\f':
    2589             :                 case '\r':
    2590             :                 case ' ':
    2591          88 :                         continue;
    2592             :                 default:
    2593      233863 :                         goto break2;
    2594          88 :                 }
    2595             :  break2:
    2596      234739 :         if (*s == '0') {
    2597             : #ifndef NO_HEX_FP /*{*/
    2598             :                 switch(s[1]) {
    2599             :                   case 'x':
    2600             :                   case 'X':
    2601             : #ifdef Honor_FLT_ROUNDS
    2602             :                         gethex(&s, &rv, bc.rounding, sign);
    2603             : #else
    2604             :                         gethex(&s, &rv, 1, sign);
    2605             : #endif
    2606             :                         goto ret;
    2607             :                   }
    2608             : #endif /*}*/
    2609      201345 :                 nz0 = 1;
    2610      202041 :                 while(*++s == '0') ;
    2611      201345 :                 if (!*s)
    2612         110 :                         goto ret;
    2613             :                 }
    2614      234629 :         s0 = s;
    2615      234629 :         y = z = 0;
    2616      353722 :         for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
    2617      119093 :                 if (nd < 9)
    2618       61886 :                         y = 10*y + c - '0';
    2619       57207 :                 else if (nd < DBL_DIG + 2)
    2620       18766 :                         z = 10*z + c - '0';
    2621      234629 :         nd0 = nd;
    2622      234629 :         bc.dp0 = bc.dp1 = s - s0;
    2623      474836 :         for(s1 = s; s1 > s0 && *--s1 == '0'; )
    2624        5578 :                 ++nz1;
    2625             : #ifdef USE_LOCALE
    2626      234629 :         s1 = localeconv()->decimal_point;
    2627      234629 :         if (c == *s1) {
    2628      209726 :                 c = '.';
    2629      209726 :                 if (*++s1) {
    2630           0 :                         s2 = s;
    2631             :                         for(;;) {
    2632           0 :                                 if (*++s2 != *s1) {
    2633           0 :                                         c = 0;
    2634           0 :                                         break;
    2635             :                                         }
    2636           0 :                                 if (!*++s1) {
    2637           0 :                                         s = s2;
    2638           0 :                                         break;
    2639             :                                         }
    2640           0 :                                 }
    2641             :                         }
    2642             :                 }
    2643             : #endif
    2644      234629 :         if (c == '.') {
    2645      209731 :                 c = *++s;
    2646      209731 :                 bc.dp1 = s - s0;
    2647      209731 :                 bc.dplen = bc.dp1 - bc.dp0;
    2648      209731 :                 if (!nd) {
    2649      223976 :                         for(; c == '0'; c = *++s)
    2650       22311 :                                 nz++;
    2651      201665 :                         if (c > '0' && c <= '9') {
    2652      201497 :                                 bc.dp0 = s0 - s;
    2653      201497 :                                 bc.dp1 = bc.dp0 + bc.dplen;
    2654      201497 :                                 s0 = s;
    2655      201497 :                                 nf += nz;
    2656      201497 :                                 nz = 0;
    2657      201497 :                                 goto have_dig;
    2658             :                                 }
    2659         168 :                         goto dig_done;
    2660             :                         }
    2661     1613629 :                 for(; c >= '0' && c <= '9'; c = *++s) {
    2662             :  have_dig:
    2663     1605563 :                         nz++;
    2664     1605563 :                         if (c -= '0') {
    2665     1105850 :                                 nf += nz;
    2666     1180696 :                                 for(i = 1; i < nz; i++)
    2667       74846 :                                         if (nd++ < 9)
    2668       74133 :                                                 y *= 10;
    2669         713 :                                         else if (nd <= DBL_DIG + 2)
    2670         541 :                                                 z *= 10;
    2671     1105850 :                                 if (nd++ < 9)
    2672     1103374 :                                         y = 10*y + c;
    2673        2476 :                                 else if (nd <= DBL_DIG + 2)
    2674        1332 :                                         z = 10*z + c;
    2675     1105850 :                                 nz = nz1 = 0;
    2676             :                                 }
    2677             :                         }
    2678             :                 }
    2679             :  dig_done:
    2680      234629 :         e = 0;
    2681      234629 :         if (c == 'e' || c == 'E') {
    2682        2558 :                 if (!nd && !nz && !nz0) {
    2683           0 :                         goto ret0;
    2684             :                         }
    2685        2558 :                 s00 = s;
    2686        2558 :                 esign = 0;
    2687        2558 :                 switch(c = *++s) {
    2688             :                         case '-':
    2689         659 :                                 esign = 1;
    2690             :                         case '+':
    2691         855 :                                 c = *++s;
    2692             :                         }
    2693        5097 :                 if (c >= '0' && c <= '9') {
    2694        5100 :                         while(c == '0')
    2695          22 :                                 c = *++s;
    2696        5062 :                         if (c > '0' && c <= '9') {
    2697        2523 :                                 L = c - '0';
    2698        2523 :                                 s1 = s;
    2699        6513 :                                 while((c = *++s) >= '0' && c <= '9')
    2700        1467 :                                         L = 10*L + c - '0';
    2701        2534 :                                 if (s - s1 > 8 || L > 19999)
    2702             :                                         /* Avoid confusion from exponents
    2703             :                                          * so large that e might overflow.
    2704             :                                          */
    2705          11 :                                         e = 19999; /* safe for 16 bit ints */
    2706             :                                 else
    2707        2512 :                                         e = (int)L;
    2708        2523 :                                 if (esign)
    2709         659 :                                         e = -e;
    2710             :                                 }
    2711             :                         else
    2712          16 :                                 e = 0;
    2713             :                         }
    2714             :                 else
    2715          19 :                         s = s00;
    2716             :                 }
    2717      234629 :         if (!nd) {
    2718         504 :                 if (!nz && !nz0) {
    2719             : #ifdef INFNAN_CHECK
    2720             :                         /* Check for Nan and Infinity */
    2721         331 :                         if (!bc.dplen)
    2722         330 :                          switch(c) {
    2723             :                           case 'i':
    2724             :                           case 'I':
    2725           0 :                                 if (match(&s,"nf")) {
    2726           0 :                                         --s;
    2727           0 :                                         if (!match(&s,"inity"))
    2728           0 :                                                 ++s;
    2729           0 :                                         word0(&rv) = 0x7ff00000;
    2730           0 :                                         word1(&rv) = 0;
    2731           0 :                                         goto ret;
    2732             :                                         }
    2733           0 :                                 break;
    2734             :                           case 'n':
    2735             :                           case 'N':
    2736          38 :                                 if (match(&s, "an")) {
    2737           0 :                                         word0(&rv) = NAN_WORD0;
    2738           0 :                                         word1(&rv) = NAN_WORD1;
    2739             : #ifndef No_Hex_NaN
    2740           0 :                                         if (*s == '(') /*)*/
    2741           0 :                                                 hexnan(&rv, &s);
    2742             : #endif
    2743           0 :                                         goto ret;
    2744             :                                         }
    2745             :                           }
    2746             : #endif /* INFNAN_CHECK */
    2747             :  ret0:
    2748         417 :                         s = s00;
    2749         417 :                         sign = 0;
    2750             :                         }
    2751         590 :                 goto ret;
    2752             :                 }
    2753      234125 :         bc.e0 = e1 = e -= nf;
    2754             : 
    2755             :         /* Now we have nd0 digits, starting at s0, followed by a
    2756             :          * decimal point, followed by nd-nd0 digits.  The number we're
    2757             :          * after is the integer represented by those digits times
    2758             :          * 10**e */
    2759             : 
    2760      234125 :         if (!nd0)
    2761      201497 :                 nd0 = nd;
    2762      234125 :         k = nd < DBL_DIG + 2 ? nd : DBL_DIG + 2;
    2763      234125 :         dval(&rv) = y;
    2764      234125 :         if (k > 9) {
    2765             : #ifdef SET_INEXACT
    2766             :                 if (k > DBL_DIG)
    2767             :                         oldinexact = get_inexact();
    2768             : #endif
    2769        3084 :                 dval(&rv) = tens[k - 9] * dval(&rv) + z;
    2770             :                 }
    2771      234125 :         bd0 = 0;
    2772      234125 :         if (nd <= DBL_DIG
    2773             : #ifndef RND_PRODQUOT
    2774             : #ifndef Honor_FLT_ROUNDS
    2775             :                 && Flt_Rounds == 1
    2776             : #endif
    2777             : #endif
    2778             :                         ) {
    2779      231709 :                 if (!e)
    2780       23028 :                         goto ret;
    2781             : #ifndef ROUND_BIASED_without_Round_Up
    2782      208681 :                 if (e > 0) {
    2783        1505 :                         if (e <= Ten_pmax) {
    2784             : #ifdef VAX
    2785             :                                 goto vax_ovfl_check;
    2786             : #else
    2787             : #ifdef Honor_FLT_ROUNDS
    2788             :                                 /* round correctly FLT_ROUNDS = 2 or 3 */
    2789             :                                 if (sign) {
    2790             :                                         rv.d = -rv.d;
    2791             :                                         sign = 0;
    2792             :                                         }
    2793             : #endif
    2794        1379 :                                 /* rv = */ rounded_product(dval(&rv), tens[e]);
    2795        1379 :                                 goto ret;
    2796             : #endif
    2797             :                                 }
    2798         126 :                         i = DBL_DIG - nd;
    2799         126 :                         if (e <= Ten_pmax + i) {
    2800             :                                 /* A fancier test would sometimes let us do
    2801             :                                  * this for larger i values.
    2802             :                                  */
    2803             : #ifdef Honor_FLT_ROUNDS
    2804             :                                 /* round correctly FLT_ROUNDS = 2 or 3 */
    2805             :                                 if (sign) {
    2806             :                                         rv.d = -rv.d;
    2807             :                                         sign = 0;
    2808             :                                         }
    2809             : #endif
    2810          26 :                                 e -= i;
    2811          26 :                                 dval(&rv) *= tens[i];
    2812             : #ifdef VAX
    2813             :                                 /* VAX exponent range is so narrow we must
    2814             :                                  * worry about overflow here...
    2815             :                                  */
    2816             :  vax_ovfl_check:
    2817             :                                 word0(&rv) -= P*Exp_msk1;
    2818             :                                 /* rv = */ rounded_product(dval(&rv), tens[e]);
    2819             :                                 if ((word0(&rv) & Exp_mask)
    2820             :                                  > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
    2821             :                                         goto ovfl;
    2822             :                                 word0(&rv) += P*Exp_msk1;
    2823             : #else
    2824          26 :                                 /* rv = */ rounded_product(dval(&rv), tens[e]);
    2825             : #endif
    2826          26 :                                 goto ret;
    2827             :                                 }
    2828             :                         }
    2829             : #ifndef Inaccurate_Divide
    2830      207176 :                 else if (e >= -Ten_pmax) {
    2831             : #ifdef Honor_FLT_ROUNDS
    2832             :                         /* round correctly FLT_ROUNDS = 2 or 3 */
    2833             :                         if (sign) {
    2834             :                                 rv.d = -rv.d;
    2835             :                                 sign = 0;
    2836             :                                 }
    2837             : #endif
    2838      207119 :                         /* rv = */ rounded_quotient(dval(&rv), tens[-e]);
    2839      207119 :                         goto ret;
    2840             :                         }
    2841             : #endif
    2842             : #endif /* ROUND_BIASED_without_Round_Up */
    2843             :                 }
    2844        2573 :         e1 += nd - k;
    2845             : 
    2846             : #ifdef IEEE_Arith
    2847             : #ifdef SET_INEXACT
    2848             :         bc.inexact = 1;
    2849             :         if (k <= DBL_DIG)
    2850             :                 oldinexact = get_inexact();
    2851             : #endif
    2852             : #ifdef Avoid_Underflow
    2853        2573 :         bc.scale = 0;
    2854             : #endif
    2855             : #ifdef Honor_FLT_ROUNDS
    2856             :         if (bc.rounding >= 2) {
    2857             :                 if (sign)
    2858             :                         bc.rounding = bc.rounding == 2 ? 0 : 2;
    2859             :                 else
    2860             :                         if (bc.rounding != 2)
    2861             :                                 bc.rounding = 0;
    2862             :                 }
    2863             : #endif
    2864             : #endif /*IEEE_Arith*/
    2865             : 
    2866             :         /* Get starting approximation = rv * 10**e1 */
    2867             : 
    2868        2573 :         if (e1 > 0) {
    2869        2408 :                 if ((i = e1 & 15))
    2870        2305 :                         dval(&rv) *= tens[i];
    2871        2408 :                 if (e1 &= ~15) {
    2872        1440 :                         if (e1 > DBL_MAX_10_EXP) {
    2873             :  ovfl:
    2874             :                                 /* Can't trust HUGE_VAL */
    2875             : #ifdef IEEE_Arith
    2876             : #ifdef Honor_FLT_ROUNDS
    2877             :                                 switch(bc.rounding) {
    2878             :                                   case 0: /* toward 0 */
    2879             :                                   case 3: /* toward -infinity */
    2880             :                                         word0(&rv) = Big0;
    2881             :                                         word1(&rv) = Big1;
    2882             :                                         break;
    2883             :                                   default:
    2884             :                                         word0(&rv) = Exp_mask;
    2885             :                                         word1(&rv) = 0;
    2886             :                                   }
    2887             : #else /*Honor_FLT_ROUNDS*/
    2888          41 :                                 word0(&rv) = Exp_mask;
    2889          41 :                                 word1(&rv) = 0;
    2890             : #endif /*Honor_FLT_ROUNDS*/
    2891             : #ifdef SET_INEXACT
    2892             :                                 /* set overflow bit */
    2893             :                                 dval(&rv0) = 1e300;
    2894             :                                 dval(&rv0) *= dval(&rv0);
    2895             : #endif
    2896             : #else /*IEEE_Arith*/
    2897             :                                 word0(&rv) = Big0;
    2898             :                                 word1(&rv) = Big1;
    2899             : #endif /*IEEE_Arith*/
    2900             :  range_err:
    2901          44 :                                 if (bd0) {
    2902           0 :                                         Bfree(bb);
    2903           0 :                                         Bfree(bd);
    2904           0 :                                         Bfree(bs);
    2905           0 :                                         Bfree(bd0);
    2906           0 :                                         Bfree(delta);
    2907             :                                         }
    2908             : #ifndef NO_ERRNO
    2909          44 :                                 errno = ERANGE;
    2910             : #endif
    2911          44 :                                 goto ret;
    2912             :                                 }
    2913        1402 :                         e1 >>= 4;
    2914        1525 :                         for(j = 0; e1 > 1; j++, e1 >>= 1)
    2915         123 :                                 if (e1 & 1)
    2916          35 :                                         dval(&rv) *= bigtens[j];
    2917             :                 /* The last multiplication could overflow. */
    2918        1402 :                         word0(&rv) -= P*Exp_msk1;
    2919        1402 :                         dval(&rv) *= bigtens[j];
    2920        1402 :                         if ((z = word0(&rv) & Exp_mask)
    2921             :                          > Exp_msk1*(DBL_MAX_EXP+Bias-P))
    2922           3 :                                 goto ovfl;
    2923        1399 :                         if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
    2924             :                                 /* set to largest number */
    2925             :                                 /* (Can't trust DBL_MAX) */
    2926           2 :                                 word0(&rv) = Big0;
    2927           2 :                                 word1(&rv) = Big1;
    2928             :                                 }
    2929             :                         else
    2930        1397 :                                 word0(&rv) += P*Exp_msk1;
    2931             :                         }
    2932             :                 }
    2933         165 :         else if (e1 < 0) {
    2934         164 :                 e1 = -e1;
    2935         164 :                 if ((i = e1 & 15))
    2936         142 :                         dval(&rv) /= tens[i];
    2937         164 :                 if (e1 >>= 4) {
    2938         101 :                         if (e1 >= 1 << n_bigtens)
    2939           1 :                                 goto undfl;
    2940             : #ifdef Avoid_Underflow
    2941         100 :                         if (e1 & Scale_Bit)
    2942          16 :                                 bc.scale = 2*P;
    2943         304 :                         for(j = 0; e1 > 0; j++, e1 >>= 1)
    2944         204 :                                 if (e1 & 1)
    2945         123 :                                         dval(&rv) *= tinytens[j];
    2946         100 :                         if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask)
    2947             :                                                 >> Exp_shift)) > 0) {
    2948             :                                 /* scaled rv is denormal; clear j low bits */
    2949          11 :                                 if (j >= 32) {
    2950           9 :                                         if (j > 54)
    2951           1 :                                                 goto undfl;
    2952           8 :                                         word1(&rv) = 0;
    2953           8 :                                         if (j >= 53)
    2954           1 :                                          word0(&rv) = (P+2)*Exp_msk1;
    2955             :                                         else
    2956           7 :                                          word0(&rv) &= 0xffffffff << (j-32);
    2957             :                                         }
    2958             :                                 else
    2959           2 :                                         word1(&rv) &= 0xffffffff << j;
    2960             :                                 }
    2961             : #else
    2962             :                         for(j = 0; e1 > 1; j++, e1 >>= 1)
    2963             :                                 if (e1 & 1)
    2964             :                                         dval(&rv) *= tinytens[j];
    2965             :                         /* The last multiplication could underflow. */
    2966             :                         dval(&rv0) = dval(&rv);
    2967             :                         dval(&rv) *= tinytens[j];
    2968             :                         if (!dval(&rv)) {
    2969             :                                 dval(&rv) = 2.*dval(&rv0);
    2970             :                                 dval(&rv) *= tinytens[j];
    2971             : #endif
    2972          99 :                                 if (!dval(&rv)) {
    2973             :  undfl:
    2974           3 :                                         dval(&rv) = 0.;
    2975           3 :                                         goto range_err;
    2976             :                                         }
    2977             : #ifndef Avoid_Underflow
    2978             :                                 word0(&rv) = Tiny0;
    2979             :                                 word1(&rv) = Tiny1;
    2980             :                                 /* The refinement below will clean
    2981             :                                  * this approximation up.
    2982             :                                  */
    2983             :                                 }
    2984             : #endif
    2985             :                         }
    2986             :                 }
    2987             : 
    2988             :         /* Now the hard part -- adjusting rv to the correct value.*/
    2989             : 
    2990             :         /* Put digits into bd: true value = bd * 10^e */
    2991             : 
    2992        2530 :         bc.nd = nd - nz1;
    2993             : #ifndef NO_STRTOD_BIGCOMP
    2994        2530 :         bc.nd0 = nd0;   /* Only needed if nd > strtod_diglim, but done here */
    2995             :                         /* to silence an erroneous warning about bc.nd0 */
    2996             :                         /* possibly not being initialized. */
    2997        2530 :         if (nd > strtod_diglim) {
    2998             :                 /* ASSERT(strtod_diglim >= 18); 18 == one more than the */
    2999             :                 /* minimum number of decimal digits to distinguish double values */
    3000             :                 /* in IEEE arithmetic. */
    3001         482 :                 i = j = 18;
    3002         482 :                 if (i > nd0)
    3003          20 :                         j += bc.dplen;
    3004             :                 for(;;) {
    3005         907 :                         if (--j < bc.dp1 && j >= bc.dp0)
    3006           0 :                                 j = bc.dp0 - 1;
    3007         907 :                         if (s0[j] != '0')
    3008         482 :                                 break;
    3009         425 :                         --i;
    3010         425 :                         }
    3011         482 :                 e += nd - i;
    3012         482 :                 nd = i;
    3013         482 :                 if (nd0 > nd)
    3014         462 :                         nd0 = nd;
    3015         482 :                 if (nd < 9) { /* must recompute y */
    3016           1 :                         y = 0;
    3017           2 :                         for(i = 0; i < nd0; ++i)
    3018           1 :                                 y = 10*y + s0[i] - '0';
    3019           1 :                         for(j = bc.dp1; i < nd; ++i)
    3020           0 :                                 y = 10*y + s0[j++] - '0';
    3021             :                         }
    3022             :                 }
    3023             : #endif
    3024        2530 :         bd0 = s2b(s0, nd0, nd, y, bc.dplen);
    3025             : 
    3026             :         for(;;) {
    3027        3035 :                 bd = Balloc(bd0->k);
    3028        3035 :                 Bcopy(bd, bd0);
    3029        3035 :                 bb = d2b(&rv, &bbe, &bbbits);       /* rv = bb * 2^bbe */
    3030        3035 :                 bs = i2b(1);
    3031             : 
    3032        3035 :                 if (e >= 0) {
    3033        2856 :                         bb2 = bb5 = 0;
    3034        2856 :                         bd2 = bd5 = e;
    3035             :                         }
    3036             :                 else {
    3037         179 :                         bb2 = bb5 = -e;
    3038         179 :                         bd2 = bd5 = 0;
    3039             :                         }
    3040        3035 :                 if (bbe >= 0)
    3041        2886 :                         bb2 += bbe;
    3042             :                 else
    3043         149 :                         bd2 -= bbe;
    3044        3035 :                 bs2 = bb2;
    3045             : #ifdef Honor_FLT_ROUNDS
    3046             :                 if (bc.rounding != 1)
    3047             :                         bs2++;
    3048             : #endif
    3049             : #ifdef Avoid_Underflow
    3050        3035 :                 Lsb = LSB;
    3051        3035 :                 Lsb1 = 0;
    3052        3035 :                 j = bbe - bc.scale;
    3053        3035 :                 i = j + bbbits - 1;     /* logb(rv) */
    3054        3035 :                 j = P + 1 - bbbits;
    3055        3035 :                 if (i < Emin) {      /* denormal */
    3056          11 :                         i = Emin - i;
    3057          11 :                         j -= i;
    3058          11 :                         if (i < 32)
    3059           2 :                                 Lsb <<= i;
    3060           9 :                         else if (i < 52)
    3061           7 :                                 Lsb1 = Lsb << (i-32);
    3062             :                         else
    3063           2 :                                 Lsb1 = Exp_mask;
    3064             :                         }
    3065             : #else /*Avoid_Underflow*/
    3066             : #ifdef Sudden_Underflow
    3067             : #ifdef IBM
    3068             :                 j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
    3069             : #else
    3070             :                 j = P + 1 - bbbits;
    3071             : #endif
    3072             : #else /*Sudden_Underflow*/
    3073             :                 j = bbe;
    3074             :                 i = j + bbbits - 1;     /* logb(rv) */
    3075             :                 if (i < Emin)        /* denormal */
    3076             :                         j += P - Emin;
    3077             :                 else
    3078             :                         j = P + 1 - bbbits;
    3079             : #endif /*Sudden_Underflow*/
    3080             : #endif /*Avoid_Underflow*/
    3081        3035 :                 bb2 += j;
    3082        3035 :                 bd2 += j;
    3083             : #ifdef Avoid_Underflow
    3084        3035 :                 bd2 += bc.scale;
    3085             : #endif
    3086        3035 :                 i = bb2 < bd2 ? bb2 : bd2;
    3087        3035 :                 if (i > bs2)
    3088         172 :                         i = bs2;
    3089        3035 :                 if (i > 0) {
    3090        3035 :                         bb2 -= i;
    3091        3035 :                         bd2 -= i;
    3092        3035 :                         bs2 -= i;
    3093             :                         }
    3094        3035 :                 if (bb5 > 0) {
    3095         179 :                         bs = pow5mult(bs, bb5);
    3096         179 :                         bb1 = mult(bs, bb);
    3097         179 :                         Bfree(bb);
    3098         179 :                         bb = bb1;
    3099             :                         }
    3100        3035 :                 if (bb2 > 0)
    3101        3035 :                         bb = lshift(bb, bb2);
    3102        3035 :                 if (bd5 > 0)
    3103         724 :                         bd = pow5mult(bd, bd5);
    3104        3035 :                 if (bd2 > 0)
    3105         172 :                         bd = lshift(bd, bd2);
    3106        3035 :                 if (bs2 > 0)
    3107        2862 :                         bs = lshift(bs, bs2);
    3108        3035 :                 delta = diff(bb, bd);
    3109        3035 :                 bc.dsign = delta->sign;
    3110        3035 :                 delta->sign = 0;
    3111        3035 :                 i = cmp(delta, bs);
    3112             : #ifndef NO_STRTOD_BIGCOMP /*{*/
    3113        3035 :                 if (bc.nd > nd && i <= 0) {
    3114         481 :                         if (bc.dsign) {
    3115             :                                 /* Must use bigcomp(). */
    3116         201 :                                 req_bigcomp = 1;
    3117         201 :                                 break;
    3118             :                                 }
    3119             : #ifdef Honor_FLT_ROUNDS
    3120             :                         if (bc.rounding != 1) {
    3121             :                                 if (i < 0) {
    3122             :                                         req_bigcomp = 1;
    3123             :                                         break;
    3124             :                                         }
    3125             :                                 }
    3126             :                         else
    3127             : #endif
    3128         280 :                                 i = -1; /* Discarded digits make delta smaller. */
    3129             :                         }
    3130             : #endif /*}*/
    3131             : #ifdef Honor_FLT_ROUNDS /*{*/
    3132             :                 if (bc.rounding != 1) {
    3133             :                         if (i < 0) {
    3134             :                                 /* Error is less than an ulp */
    3135             :                                 if (!delta->x[0] && delta->wds <= 1) {
    3136             :                                         /* exact */
    3137             : #ifdef SET_INEXACT
    3138             :                                         bc.inexact = 0;
    3139             : #endif
    3140             :                                         break;
    3141             :                                         }
    3142             :                                 if (bc.rounding) {
    3143             :                                         if (bc.dsign) {
    3144             :                                                 adj.d = 1.;
    3145             :                                                 goto apply_adj;
    3146             :                                                 }
    3147             :                                         }
    3148             :                                 else if (!bc.dsign) {
    3149             :                                         adj.d = -1.;
    3150             :                                         if (!word1(&rv)
    3151             :                                          && !(word0(&rv) & Frac_mask)) {
    3152             :                                                 y = word0(&rv) & Exp_mask;
    3153             : #ifdef Avoid_Underflow
    3154             :                                                 if (!bc.scale || y > 2*P*Exp_msk1)
    3155             : #else
    3156             :                                                 if (y)
    3157             : #endif
    3158             :                                                   {
    3159             :                                                   delta = lshift(delta,Log2P);
    3160             :                                                   if (cmp(delta, bs) <= 0)
    3161             :                                                         adj.d = -0.5;
    3162             :                                                   }
    3163             :                                                 }
    3164             :  apply_adj:
    3165             : #ifdef Avoid_Underflow /*{*/
    3166             :                                         if (bc.scale && (y = word0(&rv) & Exp_mask)
    3167             :                                                 <= 2*P*Exp_msk1)
    3168             :                                           word0(&adj) += (2*P+1)*Exp_msk1 - y;
    3169             : #else
    3170             : #ifdef Sudden_Underflow
    3171             :                                         if ((word0(&rv) & Exp_mask) <=
    3172             :                                                         P*Exp_msk1) {
    3173             :                                                 word0(&rv) += P*Exp_msk1;
    3174             :                                                 dval(&rv) += adj.d*ulp(dval(&rv));
    3175             :                                                 word0(&rv) -= P*Exp_msk1;
    3176             :                                                 }
    3177             :                                         else
    3178             : #endif /*Sudden_Underflow*/
    3179             : #endif /*Avoid_Underflow}*/
    3180             :                                         dval(&rv) += adj.d*ulp(&rv);
    3181             :                                         }
    3182             :                                 break;
    3183             :                                 }
    3184             :                         adj.d = ratio(delta, bs);
    3185             :                         if (adj.d < 1.)
    3186             :                                 adj.d = 1.;
    3187             :                         if (adj.d <= 0x7ffffffe) {
    3188             :                                 /* adj = rounding ? ceil(adj) : floor(adj); */
    3189             :                                 y = adj.d;
    3190             :                                 if (y != adj.d) {
    3191             :                                         if (!((bc.rounding>>1) ^ bc.dsign))
    3192             :                                                 y++;
    3193             :                                         adj.d = y;
    3194             :                                         }
    3195             :                                 }
    3196             : #ifdef Avoid_Underflow /*{*/
    3197             :                         if (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1)
    3198             :                                 word0(&adj) += (2*P+1)*Exp_msk1 - y;
    3199             : #else
    3200             : #ifdef Sudden_Underflow
    3201             :                         if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
    3202             :                                 word0(&rv) += P*Exp_msk1;
    3203             :                                 adj.d *= ulp(dval(&rv));
    3204             :                                 if (bc.dsign)
    3205             :                                         dval(&rv) += adj.d;
    3206             :                                 else
    3207             :                                         dval(&rv) -= adj.d;
    3208             :                                 word0(&rv) -= P*Exp_msk1;
    3209             :                                 goto cont;
    3210             :                                 }
    3211             : #endif /*Sudden_Underflow*/
    3212             : #endif /*Avoid_Underflow}*/
    3213             :                         adj.d *= ulp(&rv);
    3214             :                         if (bc.dsign) {
    3215             :                                 if (word0(&rv) == Big0 && word1(&rv) == Big1)
    3216             :                                         goto ovfl;
    3217             :                                 dval(&rv) += adj.d;
    3218             :                                 }
    3219             :                         else
    3220             :                                 dval(&rv) -= adj.d;
    3221             :                         goto cont;
    3222             :                         }
    3223             : #endif /*}Honor_FLT_ROUNDS*/
    3224             : 
    3225        2834 :                 if (i < 0) {
    3226             :                         /* Error is less than half an ulp -- check for
    3227             :                          * special case of mantissa a power of two.
    3228             :                          */
    3229        1886 :                         if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask
    3230             : #ifdef IEEE_Arith /*{*/
    3231             : #ifdef Avoid_Underflow
    3232          81 :                          || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1
    3233             : #else
    3234             :                          || (word0(&rv) & Exp_mask) <= Exp_msk1
    3235             : #endif
    3236             : #endif /*}*/
    3237             :                                 ) {
    3238             : #ifdef SET_INEXACT
    3239             :                                 if (!delta->x[0] && delta->wds <= 1)
    3240             :                                         bc.inexact = 0;
    3241             : #endif
    3242             :                                 break;
    3243             :                                 }
    3244          38 :                         if (!delta->x[0] && delta->wds <= 1) {
    3245             :                                 /* exact result */
    3246             : #ifdef SET_INEXACT
    3247             :                                 bc.inexact = 0;
    3248             : #endif
    3249          14 :                                 break;
    3250             :                                 }
    3251          24 :                         delta = lshift(delta,Log2P);
    3252          24 :                         if (cmp(delta, bs) > 0)
    3253           0 :                                 goto drop_down;
    3254          24 :                         break;
    3255             :                         }
    3256        1029 :                 if (i == 0) {
    3257             :                         /* exactly half-way between */
    3258           0 :                         if (bc.dsign) {
    3259           0 :                                 if ((word0(&rv) & Bndry_mask1) == Bndry_mask1
    3260           0 :                                  &&  word1(&rv) == (
    3261             : #ifdef Avoid_Underflow
    3262           0 :                         (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1)
    3263           0 :                 ? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
    3264             : #endif
    3265             :                                                    0xffffffff)) {
    3266             :                                         /*boundary case -- increment exponent*/
    3267           0 :                                         if (word0(&rv) == Big0 && word1(&rv) == Big1)
    3268           0 :                                                 goto ovfl;
    3269           0 :                                         word0(&rv) = (word0(&rv) & Exp_mask)
    3270             :                                                 + Exp_msk1
    3271             : #ifdef IBM
    3272             :                                                 | Exp_msk1 >> 4
    3273             : #endif
    3274             :                                                 ;
    3275           0 :                                         word1(&rv) = 0;
    3276             : #ifdef Avoid_Underflow
    3277           0 :                                         bc.dsign = 0;
    3278             : #endif
    3279           0 :                                         break;
    3280             :                                         }
    3281             :                                 }
    3282           0 :                         else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) {
    3283             :  drop_down:
    3284             :                                 /* boundary case -- decrement exponent */
    3285             : #ifdef Sudden_Underflow /*{{*/
    3286             :                                 L = word0(&rv) & Exp_mask;
    3287             : #ifdef IBM
    3288             :                                 if (L <  Exp_msk1)
    3289             : #else
    3290             : #ifdef Avoid_Underflow
    3291             :                                 if (L <= (bc.scale ? (2*P+1)*Exp_msk1 : Exp_msk1))
    3292             : #else
    3293             :                                 if (L <= Exp_msk1)
    3294             : #endif /*Avoid_Underflow*/
    3295             : #endif /*IBM*/
    3296             :                                         {
    3297             :                                         if (bc.nd >nd) {
    3298             :                                                 bc.uflchk = 1;
    3299             :                                                 break;
    3300             :                                                 }
    3301             :                                         goto undfl;
    3302             :                                         }
    3303             :                                 L -= Exp_msk1;
    3304             : #else /*Sudden_Underflow}{*/
    3305             : #ifdef Avoid_Underflow
    3306           0 :                                 if (bc.scale) {
    3307           0 :                                         L = word0(&rv) & Exp_mask;
    3308           0 :                                         if (L <= (2*P+1)*Exp_msk1) {
    3309           0 :                                                 if (L > (P+2)*Exp_msk1)
    3310             :                                                         /* round even ==> */
    3311             :                                                         /* accept rv */
    3312           0 :                                                         break;
    3313             :                                                 /* rv = smallest denormal */
    3314           0 :                                                 if (bc.nd >nd) {
    3315           0 :                                                         bc.uflchk = 1;
    3316           0 :                                                         break;
    3317             :                                                         }
    3318           0 :                                                 goto undfl;
    3319             :                                                 }
    3320             :                                         }
    3321             : #endif /*Avoid_Underflow*/
    3322           0 :                                 L = (word0(&rv) & Exp_mask) - Exp_msk1;
    3323             : #endif /*Sudden_Underflow}}*/
    3324           0 :                                 word0(&rv) = L | Bndry_mask1;
    3325           0 :                                 word1(&rv) = 0xffffffff;
    3326             : #ifdef IBM
    3327             :                                 goto cont;
    3328             : #else
    3329             : #ifndef NO_STRTOD_BIGCOMP
    3330           0 :                                 if (bc.nd > nd)
    3331           0 :                                         goto cont;
    3332             : #endif
    3333           0 :                                 break;
    3334             : #endif
    3335             :                                 }
    3336             : #ifndef ROUND_BIASED
    3337             : #ifdef Avoid_Underflow
    3338           0 :                         if (Lsb1) {
    3339           0 :                                 if (!(word0(&rv) & Lsb1))
    3340           0 :                                         break;
    3341             :                                 }
    3342           0 :                         else if (!(word1(&rv) & Lsb))
    3343           0 :                                 break;
    3344             : #else
    3345             :                         if (!(word1(&rv) & LSB))
    3346             :                                 break;
    3347             : #endif
    3348             : #endif
    3349           0 :                         if (bc.dsign)
    3350             : #ifdef Avoid_Underflow
    3351           0 :                                 dval(&rv) += sulp(&rv, &bc);
    3352             : #else
    3353             :                                 dval(&rv) += ulp(&rv);
    3354             : #endif
    3355             : #ifndef ROUND_BIASED
    3356             :                         else {
    3357             : #ifdef Avoid_Underflow
    3358           0 :                                 dval(&rv) -= sulp(&rv, &bc);
    3359             : #else
    3360             :                                 dval(&rv) -= ulp(&rv);
    3361             : #endif
    3362             : #ifndef Sudden_Underflow
    3363           0 :                                 if (!dval(&rv)) {
    3364           0 :                                         if (bc.nd >nd) {
    3365           0 :                                                 bc.uflchk = 1;
    3366           0 :                                                 break;
    3367             :                                                 }
    3368           0 :                                         goto undfl;
    3369             :                                         }
    3370             : #endif
    3371             :                                 }
    3372             : #ifdef Avoid_Underflow
    3373           0 :                         bc.dsign = 1 - bc.dsign;
    3374             : #endif
    3375             : #endif
    3376           0 :                         break;
    3377             :                         }
    3378        1029 :                 if ((aadj = ratio(delta, bs)) <= 2.) {
    3379         770 :                         if (bc.dsign)
    3380         344 :                                 aadj = aadj1 = 1.;
    3381         851 :                         else if (word1(&rv) || word0(&rv) & Bndry_mask) {
    3382             : #ifndef Sudden_Underflow
    3383         425 :                                 if (word1(&rv) == Tiny1 && !word0(&rv)) {
    3384           0 :                                         if (bc.nd >nd) {
    3385           0 :                                                 bc.uflchk = 1;
    3386           0 :                                                 break;
    3387             :                                                 }
    3388           0 :                                         goto undfl;
    3389             :                                         }
    3390             : #endif
    3391         425 :                                 aadj = 1.;
    3392         425 :                                 aadj1 = -1.;
    3393             :                                 }
    3394             :                         else {
    3395             :                                 /* special case -- power of FLT_RADIX to be */
    3396             :                                 /* rounded down... */
    3397             : 
    3398           1 :                                 if (aadj < 2./FLT_RADIX)
    3399           0 :                                         aadj = 1./FLT_RADIX;
    3400             :                                 else
    3401           1 :                                         aadj *= 0.5;
    3402           1 :                                 aadj1 = -aadj;
    3403             :                                 }
    3404             :                         }
    3405             :                 else {
    3406         259 :                         aadj *= 0.5;
    3407         259 :                         aadj1 = bc.dsign ? aadj : -aadj;
    3408             : #ifdef Check_FLT_ROUNDS
    3409             :                         switch(bc.rounding) {
    3410             :                                 case 2: /* towards +infinity */
    3411             :                                         aadj1 -= 0.5;
    3412             :                                         break;
    3413             :                                 case 0: /* towards 0 */
    3414             :                                 case 3: /* towards -infinity */
    3415             :                                         aadj1 += 0.5;
    3416             :                                 }
    3417             : #else
    3418         259 :                         if (Flt_Rounds == 0)
    3419             :                                 aadj1 += 0.5;
    3420             : #endif /*Check_FLT_ROUNDS*/
    3421             :                         }
    3422        1029 :                 y = word0(&rv) & Exp_mask;
    3423             : 
    3424             :                 /* Check for overflow */
    3425             : 
    3426        1029 :                 if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
    3427           1 :                         dval(&rv0) = dval(&rv);
    3428           1 :                         word0(&rv) -= P*Exp_msk1;
    3429           1 :                         adj.d = aadj1 * ulp(&rv);
    3430           1 :                         dval(&rv) += adj.d;
    3431           1 :                         if ((word0(&rv) & Exp_mask) >=
    3432             :                                         Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
    3433           0 :                                 if (word0(&rv0) == Big0 && word1(&rv0) == Big1)
    3434           0 :                                         goto ovfl;
    3435           0 :                                 word0(&rv) = Big0;
    3436           0 :                                 word1(&rv) = Big1;
    3437           0 :                                 goto cont;
    3438             :                                 }
    3439             :                         else
    3440           1 :                                 word0(&rv) += P*Exp_msk1;
    3441             :                         }
    3442             :                 else {
    3443             : #ifdef Avoid_Underflow
    3444        1030 :                         if (bc.scale && y <= 2*P*Exp_msk1) {
    3445           3 :                                 if (aadj <= 0x7fffffff) {
    3446           3 :                                         if ((z = aadj) <= 0)
    3447           1 :                                                 z = 1;
    3448           3 :                                         aadj = z;
    3449           3 :                                         aadj1 = bc.dsign ? aadj : -aadj;
    3450             :                                         }
    3451           3 :                                 dval(&aadj2) = aadj1;
    3452           3 :                                 word0(&aadj2) += (2*P+1)*Exp_msk1 - y;
    3453           3 :                                 aadj1 = dval(&aadj2);
    3454           3 :                                 adj.d = aadj1 * ulp(&rv);
    3455           3 :                                 dval(&rv) += adj.d;
    3456           3 :                                 if (rv.d == 0.)
    3457             : #ifdef NO_STRTOD_BIGCOMP
    3458             :                                         goto undfl;
    3459             : #else
    3460             :                                         {
    3461           1 :                                         req_bigcomp = 1;
    3462           1 :                                         break;
    3463             :                                         }
    3464             : #endif
    3465             :                                 }
    3466             :                         else {
    3467        1025 :                                 adj.d = aadj1 * ulp(&rv);
    3468        1025 :                                 dval(&rv) += adj.d;
    3469             :                                 }
    3470             : #else
    3471             : #ifdef Sudden_Underflow
    3472             :                         if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
    3473             :                                 dval(&rv0) = dval(&rv);
    3474             :                                 word0(&rv) += P*Exp_msk1;
    3475             :                                 adj.d = aadj1 * ulp(&rv);
    3476             :                                 dval(&rv) += adj.d;
    3477             : #ifdef IBM
    3478             :                                 if ((word0(&rv) & Exp_mask) <  P*Exp_msk1)
    3479             : #else
    3480             :                                 if ((word0(&rv) & Exp_mask) <= P*Exp_msk1)
    3481             : #endif
    3482             :                                         {
    3483             :                                         if (word0(&rv0) == Tiny0
    3484             :                                          && word1(&rv0) == Tiny1) {
    3485             :                                                 if (bc.nd >nd) {
    3486             :                                                         bc.uflchk = 1;
    3487             :                                                         break;
    3488             :                                                         }
    3489             :                                                 goto undfl;
    3490             :                                                 }
    3491             :                                         word0(&rv) = Tiny0;
    3492             :                                         word1(&rv) = Tiny1;
    3493             :                                         goto cont;
    3494             :                                         }
    3495             :                                 else
    3496             :                                         word0(&rv) -= P*Exp_msk1;
    3497             :                                 }
    3498             :                         else {
    3499             :                                 adj.d = aadj1 * ulp(&rv);
    3500             :                                 dval(&rv) += adj.d;
    3501             :                                 }
    3502             : #else /*Sudden_Underflow*/
    3503             :                         /* Compute adj so that the IEEE rounding rules will
    3504             :                          * correctly round rv + adj in some half-way cases.
    3505             :                          * If rv * ulp(rv) is denormalized (i.e.,
    3506             :                          * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
    3507             :                          * trouble from bits lost to denormalization;
    3508             :                          * example: 1.2e-307 .
    3509             :                          */
    3510             :                         if (y <= (P-1)*Exp_msk1 && aadj > 1.) {
    3511             :                                 aadj1 = (double)(int)(aadj + 0.5);
    3512             :                                 if (!bc.dsign)
    3513             :                                         aadj1 = -aadj1;
    3514             :                                 }
    3515             :                         adj.d = aadj1 * ulp(&rv);
    3516             :                         dval(&rv) += adj.d;
    3517             : #endif /*Sudden_Underflow*/
    3518             : #endif /*Avoid_Underflow*/
    3519             :                         }
    3520        1028 :                 z = word0(&rv) & Exp_mask;
    3521             : #ifndef SET_INEXACT
    3522        1028 :                 if (bc.nd == nd) {
    3523             : #ifdef Avoid_Underflow
    3524         527 :                 if (!bc.scale)
    3525             : #endif
    3526         523 :                 if (y == z) {
    3527             :                         /* Can we stop now? */
    3528         523 :                         L = (Long)aadj;
    3529         523 :                         aadj -= L;
    3530             :                         /* The tolerances below are conservative. */
    3531         523 :                         if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) {
    3532         522 :                                 if (aadj < .4999999 || aadj > .5000001)
    3533             :                                         break;
    3534             :                                 }
    3535           1 :                         else if (aadj < .4999999/FLT_RADIX)
    3536           1 :                                 break;
    3537             :                         }
    3538             :                 }
    3539             : #endif
    3540             :  cont:
    3541         505 :                 Bfree(bb);
    3542         505 :                 Bfree(bd);
    3543         505 :                 Bfree(bs);
    3544         505 :                 Bfree(delta);
    3545         505 :                 }
    3546        2530 :         Bfree(bb);
    3547        2530 :         Bfree(bd);
    3548        2530 :         Bfree(bs);
    3549        2530 :         Bfree(bd0);
    3550        2530 :         Bfree(delta);
    3551             : #ifndef NO_STRTOD_BIGCOMP
    3552        2530 :         if (req_bigcomp) {
    3553         202 :                 bd0 = 0;
    3554         202 :                 bc.e0 += nz1;
    3555         202 :                 bigcomp(&rv, s0, &bc);
    3556         202 :                 y = word0(&rv) & Exp_mask;
    3557         202 :                 if (y == Exp_mask)
    3558           0 :                         goto ovfl;
    3559         202 :                 if (y == 0 && rv.d == 0.)
    3560           1 :                         goto undfl;
    3561             :                 }
    3562             : #endif
    3563             : #ifdef SET_INEXACT
    3564             :         if (bc.inexact) {
    3565             :                 if (!oldinexact) {
    3566             :                         word0(&rv0) = Exp_1 + (70 << Exp_shift);
    3567             :                         word1(&rv0) = 0;
    3568             :                         dval(&rv0) += 1.;
    3569             :                         }
    3570             :                 }
    3571             :         else if (!oldinexact)
    3572             :                 clear_inexact();
    3573             : #endif
    3574             : #ifdef Avoid_Underflow
    3575        2529 :         if (bc.scale) {
    3576          14 :                 word0(&rv0) = Exp_1 - 2*P*Exp_msk1;
    3577          14 :                 word1(&rv0) = 0;
    3578          14 :                 dval(&rv) *= dval(&rv0);
    3579             : #ifndef NO_ERRNO
    3580             :                 /* try to avoid the bug of testing an 8087 register value */
    3581             : #ifdef IEEE_Arith
    3582          14 :                 if (!(word0(&rv) & Exp_mask))
    3583             : #else
    3584             :                 if (word0(&rv) == 0 && word1(&rv) == 0)
    3585             : #endif
    3586           8 :                         errno = ERANGE;
    3587             : #endif
    3588             :                 }
    3589             : #endif /* Avoid_Underflow */
    3590             : #ifdef SET_INEXACT
    3591             :         if (bc.inexact && !(word0(&rv) & Exp_mask)) {
    3592             :                 /* set underflow bit */
    3593             :                 dval(&rv0) = 1e-300;
    3594             :                 dval(&rv0) *= dval(&rv0);
    3595             :                 }
    3596             : #endif
    3597             :  ret:
    3598      234825 :         if (se)
    3599      212118 :                 *se = (char *)s;
    3600      234825 :         return sign ? -dval(&rv) : dval(&rv);
    3601             :         }
    3602             : 
    3603             : #ifndef MULTIPLE_THREADS
    3604             :  static char *dtoa_result;
    3605             : #endif
    3606             : 
    3607             :  static char *
    3608             : #ifdef KR_headers
    3609             : rv_alloc(i) int i;
    3610             : #else
    3611      119351 : rv_alloc(int i)
    3612             : #endif
    3613             : {
    3614             :         int j, k, *r;
    3615             : 
    3616      119351 :         j = sizeof(ULong);
    3617      243152 :         for(k = 0;
    3618      123801 :                 sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
    3619        4450 :                 j <<= 1)
    3620        4450 :                         k++;
    3621      119351 :         r = (int*)Balloc(k);
    3622      119351 :         *r = k;
    3623      119351 :         return
    3624             : #ifndef MULTIPLE_THREADS
    3625             :         dtoa_result =
    3626             : #endif
    3627      119351 :                 (char *)(r+1);
    3628             :         }
    3629             : 
    3630             :  static char *
    3631             : #ifdef KR_headers
    3632             : nrv_alloc(s, rve, n) char *s, **rve; int n;
    3633             : #else
    3634         691 : nrv_alloc(const char *s, char **rve, int n)
    3635             : #endif
    3636             : {
    3637             :         char *rv, *t;
    3638             : 
    3639         691 :         t = rv = rv_alloc(n);
    3640         691 :         while((*t = *s++)) t++;
    3641         691 :         if (rve)
    3642           0 :                 *rve = t;
    3643         691 :         return rv;
    3644             :         }
    3645             : 
    3646             : /* freedtoa(s) must be used to free values s returned by dtoa
    3647             :  * when MULTIPLE_THREADS is #defined.  It should be used in all cases,
    3648             :  * but for consistency with earlier versions of dtoa, it is optional
    3649             :  * when MULTIPLE_THREADS is not defined.
    3650             :  */
    3651             : 
    3652             : ZEND_API void
    3653             : #ifdef KR_headers
    3654             : zend_freedtoa(s) char *s;
    3655             : #else
    3656      119351 : zend_freedtoa(char *s)
    3657             : #endif
    3658             : {
    3659      119351 :         Bigint *b = (Bigint *)((int *)s - 1);
    3660      119351 :         b->maxwds = 1 << (b->k = *(int*)b);
    3661      119351 :         Bfree(b);
    3662             : #ifndef MULTIPLE_THREADS
    3663      119351 :         if (s == dtoa_result)
    3664      119351 :                 dtoa_result = 0;
    3665             : #endif
    3666      119351 :         }
    3667             : 
    3668             : /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
    3669             :  *
    3670             :  * Inspired by "How to Print Floating-Point Numbers Accurately" by
    3671             :  * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126].
    3672             :  *
    3673             :  * Modifications:
    3674             :  *      1. Rather than iterating, we use a simple numeric overestimate
    3675             :  *         to determine k = floor(log10(d)).  We scale relevant
    3676             :  *         quantities using O(log2(k)) rather than O(k) multiplications.
    3677             :  *      2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
    3678             :  *         try to generate digits strictly left to right.  Instead, we
    3679             :  *         compute with fewer bits and propagate the carry if necessary
    3680             :  *         when rounding the final digit up.  This is often faster.
    3681             :  *      3. Under the assumption that input will be rounded nearest,
    3682             :  *         mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
    3683             :  *         That is, we allow equality in stopping tests when the
    3684             :  *         round-nearest rule will give the same floating-point value
    3685             :  *         as would satisfaction of the stopping test with strict
    3686             :  *         inequality.
    3687             :  *      4. We remove common factors of powers of 2 from relevant
    3688             :  *         quantities.
    3689             :  *      5. When converting floating-point integers less than 1e16,
    3690             :  *         we use floating-point arithmetic rather than resorting
    3691             :  *         to multiple-precision integers.
    3692             :  *      6. When asked to produce fewer than 15 digits, we first try
    3693             :  *         to get by with floating-point arithmetic; we resort to
    3694             :  *         multiple-precision integer arithmetic only if we cannot
    3695             :  *         guarantee that the floating-point calculation has given
    3696             :  *         the correctly rounded result.  For k requested digits and
    3697             :  *         "uniformly" distributed input, the probability is
    3698             :  *         something like 10^(k-15) that we must resort to the Long
    3699             :  *         calculation.
    3700             :  */
    3701             : 
    3702             : ZEND_API char *
    3703      119351 : zend_dtoa
    3704             : #ifdef KR_headers
    3705             :         (dd, mode, ndigits, decpt, sign, rve)
    3706             :         double dd; int mode, ndigits, *decpt, *sign; char **rve;
    3707             : #else
    3708             :         (double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
    3709             : #endif
    3710             : {
    3711             :  /*     Arguments ndigits, decpt, sign are similar to those
    3712             :         of ecvt and fcvt; trailing zeros are suppressed from
    3713             :         the returned string.  If not null, *rve is set to point
    3714             :         to the end of the return value.  If d is +-Infinity or NaN,
    3715             :         then *decpt is set to 9999.
    3716             : 
    3717             :         mode:
    3718             :                 0 ==> shortest string that yields d when read in
    3719             :                         and rounded to nearest.
    3720             :                 1 ==> like 0, but with Steele & White stopping rule;
    3721             :                         e.g. with IEEE P754 arithmetic , mode 0 gives
    3722             :                         1e23 whereas mode 1 gives 9.999999999999999e22.
    3723             :                 2 ==> max(1,ndigits) significant digits.  This gives a
    3724             :                         return value similar to that of ecvt, except
    3725             :                         that trailing zeros are suppressed.
    3726             :                 3 ==> through ndigits past the decimal point.  This
    3727             :                         gives a return value similar to that from fcvt,
    3728             :                         except that trailing zeros are suppressed, and
    3729             :                         ndigits can be negative.
    3730             :                 4,5 ==> similar to 2 and 3, respectively, but (in
    3731             :                         round-nearest mode) with the tests of mode 0 to
    3732             :                         possibly return a shorter string that rounds to d.
    3733             :                         With IEEE arithmetic and compilation with
    3734             :                         -DHonor_FLT_ROUNDS, modes 4 and 5 behave the same
    3735             :                         as modes 2 and 3 when FLT_ROUNDS != 1.
    3736             :                 6-9 ==> Debugging modes similar to mode - 4:  don't try
    3737             :                         fast floating-point estimate (if applicable).
    3738             : 
    3739             :                 Values of mode other than 0-9 are treated as mode 0.
    3740             : 
    3741             :                 Sufficient space is allocated to the return value
    3742             :                 to hold the suppressed trailing zeros.
    3743             :         */
    3744             : 
    3745      119351 :         int bbits, b2, b5, be, dig, i, ieps, ilim = 0, ilim0, ilim1,
    3746             :                 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
    3747      119351 :                 spec_case = 0, try_quick;
    3748             :         Long L;
    3749             : #ifndef Sudden_Underflow
    3750             :         int denorm;
    3751             :         ULong x;
    3752             : #endif
    3753             :         Bigint *b, *b1, *delta, *mlo, *mhi, *S;
    3754             :         U d2, eps, u;
    3755             :         double ds;
    3756             :         char *s, *s0;
    3757             : #ifndef No_leftright
    3758             : #ifdef IEEE_Arith
    3759             :         U eps1;
    3760             : #endif
    3761             : #endif
    3762             : #ifdef SET_INEXACT
    3763             :         int inexact, oldinexact;
    3764             : #endif
    3765             : #ifdef Honor_FLT_ROUNDS /*{*/
    3766             :         int Rounding;
    3767             : #ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
    3768             :         Rounding = Flt_Rounds;
    3769             : #else /*}{*/
    3770             :         Rounding = 1;
    3771             :         switch(fegetround()) {
    3772             :           case FE_TOWARDZERO:   Rounding = 0; break;
    3773             :           case FE_UPWARD:       Rounding = 2; break;
    3774             :           case FE_DOWNWARD:     Rounding = 3;
    3775             :           }
    3776             : #endif /*}}*/
    3777             : #endif /*}*/
    3778             : 
    3779             : #ifndef MULTIPLE_THREADS
    3780      119351 :         if (dtoa_result) {
    3781           0 :                 zend_freedtoa(dtoa_result);
    3782           0 :                 dtoa_result = 0;
    3783             :                 }
    3784             : #endif
    3785             : 
    3786      119351 :         u.d = dd;
    3787      119351 :         if (word0(&u) & Sign_bit) {
    3788             :                 /* set sign for everything, including 0's and NaNs */
    3789        4097 :                 *sign = 1;
    3790        4097 :                 word0(&u) &= ~Sign_bit; /* clear sign bit */
    3791             :                 }
    3792             :         else
    3793      115254 :                 *sign = 0;
    3794             : 
    3795             : #if defined(IEEE_Arith) + defined(VAX)
    3796             : #ifdef IEEE_Arith
    3797      119351 :         if ((word0(&u) & Exp_mask) == Exp_mask)
    3798             : #else
    3799             :         if (word0(&u)  == 0x8000)
    3800             : #endif
    3801             :                 {
    3802             :                 /* Infinity or NaN */
    3803          12 :                 *decpt = 9999;
    3804             : #ifdef IEEE_Arith
    3805          12 :                 if (!word1(&u) && !(word0(&u) & 0xfffff))
    3806           8 :                         return nrv_alloc("Infinity", rve, 8);
    3807             : #endif
    3808           4 :                 return nrv_alloc("NaN", rve, 3);
    3809             :                 }
    3810             : #endif
    3811             : #ifdef IBM
    3812             :         dval(&u) += 0; /* normalize */
    3813             : #endif
    3814      119339 :         if (!dval(&u)) {
    3815         679 :                 *decpt = 1;
    3816         679 :                 return nrv_alloc("0", rve, 1);
    3817             :                 }
    3818             : 
    3819             : #ifdef SET_INEXACT
    3820             :         try_quick = oldinexact = get_inexact();
    3821             :         inexact = 1;
    3822             : #endif
    3823             : #ifdef Honor_FLT_ROUNDS
    3824             :         if (Rounding >= 2) {
    3825             :                 if (*sign)
    3826             :                         Rounding = Rounding == 2 ? 0 : 2;
    3827             :                 else
    3828             :                         if (Rounding != 2)
    3829             :                                 Rounding = 0;
    3830             :                 }
    3831             : #endif
    3832             : 
    3833      118660 :         b = d2b(&u, &be, &bbits);
    3834             : #ifdef Sudden_Underflow
    3835             :         i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
    3836             : #else
    3837      118660 :         if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) {
    3838             : #endif
    3839      118064 :                 dval(&d2) = dval(&u);
    3840      118064 :                 word0(&d2) &= Frac_mask1;
    3841      118064 :                 word0(&d2) |= Exp_11;
    3842             : #ifdef IBM
    3843             :                 if (j = 11 - hi0bits(word0(&d2) & Frac_mask))
    3844             :                         dval(&d2) /= 1 << j;
    3845             : #endif
    3846             : 
    3847             :                 /* log(x)       ~=~ log(1.5) + (x-1.5)/1.5
    3848             :                  * log10(x)      =  log(x) / log(10)
    3849             :                  *              ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
    3850             :                  * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
    3851             :                  *
    3852             :                  * This suggests computing an approximation k to log10(d) by
    3853             :                  *
    3854             :                  * k = (i - Bias)*0.301029995663981
    3855             :                  *      + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
    3856             :                  *
    3857             :                  * We want k to be too large rather than too small.
    3858             :                  * The error in the first-order Taylor series approximation
    3859             :                  * is in our favor, so we just round up the constant enough
    3860             :                  * to compensate for any error in the multiplication of
    3861             :                  * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
    3862             :                  * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
    3863             :                  * adding 1e-13 to the constant term more than suffices.
    3864             :                  * Hence we adjust the constant term to 0.1760912590558.
    3865             :                  * (We could get a more accurate k by invoking log10,
    3866             :                  *  but this is probably not worthwhile.)
    3867             :                  */
    3868             : 
    3869      118064 :                 i -= Bias;
    3870             : #ifdef IBM
    3871             :                 i <<= 2;
    3872             :                 i += j;
    3873             : #endif
    3874             : #ifndef Sudden_Underflow
    3875      118064 :                 denorm = 0;
    3876             :                 }
    3877             :         else {
    3878             :                 /* d is denormalized */
    3879             : 
    3880         596 :                 i = bbits + be + (Bias + (P-1) - 1);
    3881        1192 :                 x = i > 32  ? word0(&u) << (64 - i) | word1(&u) >> (i - 32)
    3882         596 :                             : word1(&u) << (32 - i);
    3883         596 :                 dval(&d2) = x;
    3884         596 :                 word0(&d2) -= 31*Exp_msk1; /* adjust exponent */
    3885         596 :                 i -= (Bias + (P-1) - 1) + 1;
    3886         596 :                 denorm = 1;
    3887             :                 }
    3888             : #endif
    3889      118660 :         ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
    3890      118660 :         k = (int)ds;
    3891      118660 :         if (ds < 0. && ds != k)
    3892       99253 :                 k--;    /* want k = floor(ds) */
    3893      118660 :         k_check = 1;
    3894      118660 :         if (k >= 0 && k <= Ten_pmax) {
    3895       19196 :                 if (dval(&u) < tens[k])
    3896        3494 :                         k--;
    3897       19196 :                 k_check = 0;
    3898             :                 }
    3899      118660 :         j = bbits - i - 1;
    3900      118660 :         if (j >= 0) {
    3901      114029 :                 b2 = 0;
    3902      114029 :                 s2 = j;
    3903             :                 }
    3904             :         else {
    3905        4631 :                 b2 = -j;
    3906        4631 :                 s2 = 0;
    3907             :                 }
    3908      118660 :         if (k >= 0) {
    3909       15994 :                 b5 = 0;
    3910       15994 :                 s5 = k;
    3911       15994 :                 s2 += k;
    3912             :                 }
    3913             :         else {
    3914      102666 :                 b2 -= k;
    3915      102666 :                 b5 = -k;
    3916      102666 :                 s5 = 0;
    3917             :                 }
    3918      118660 :         if (mode < 0 || mode > 9)
    3919           0 :                 mode = 0;
    3920             : 
    3921             : #ifndef SET_INEXACT
    3922             : #ifdef Check_FLT_ROUNDS
    3923             :         try_quick = Rounding == 1;
    3924             : #else
    3925      118660 :         try_quick = 1;
    3926             : #endif
    3927             : #endif /*SET_INEXACT*/
    3928             : 
    3929      118660 :         if (mode > 5) {
    3930           0 :                 mode -= 4;
    3931           0 :                 try_quick = 0;
    3932             :                 }
    3933      118660 :         leftright = 1;
    3934      118660 :         ilim = ilim1 = -1;      /* Values for cases 0 and 1; done here to */
    3935             :                                 /* silence erroneous "gcc -Wall" warning. */
    3936      118660 :         switch(mode) {
    3937             :                 case 0:
    3938             :                 case 1:
    3939           0 :                         i = 18;
    3940           0 :                         ndigits = 0;
    3941           0 :                         break;
    3942             :                 case 2:
    3943       14477 :                         leftright = 0;
    3944             :                         /* no break */
    3945             :                 case 4:
    3946       14477 :                         if (ndigits <= 0)
    3947           0 :                                 ndigits = 1;
    3948       14477 :                         ilim = ilim1 = i = ndigits;
    3949       14477 :                         break;
    3950             :                 case 3:
    3951      104183 :                         leftright = 0;
    3952             :                         /* no break */
    3953             :                 case 5:
    3954      104183 :                         i = ndigits + k + 1;
    3955      104183 :                         ilim = i;
    3956      104183 :                         ilim1 = i - 1;
    3957      104183 :                         if (i <= 0)
    3958          43 :                                 i = 1;
    3959             :                 }
    3960      118660 :         s = s0 = rv_alloc(i);
    3961             : 
    3962             : #ifdef Honor_FLT_ROUNDS
    3963             :         if (mode > 1 && Rounding != 1)
    3964             :                 leftright = 0;
    3965             : #endif
    3966             : 
    3967      118660 :         if (ilim >= 0 && ilim <= Quick_max && try_quick) {
    3968             : 
    3969             :                 /* Try to get by with floating-point arithmetic. */
    3970             : 
    3971      117700 :                 i = 0;
    3972      117700 :                 dval(&d2) = dval(&u);
    3973      117700 :                 k0 = k;
    3974      117700 :                 ilim0 = ilim;
    3975      117700 :                 ieps = 2; /* conservative */
    3976      117700 :                 if (k > 0) {
    3977        9881 :                         ds = tens[k&0xf];
    3978        9881 :                         j = k >> 4;
    3979        9881 :                         if (j & Bletch) {
    3980             :                                 /* prevent overflows */
    3981           3 :                                 j &= Bletch - 1;
    3982           3 :                                 dval(&u) /= bigtens[n_bigtens-1];
    3983           3 :                                 ieps++;
    3984             :                                 }
    3985       11192 :                         for(; j; j >>= 1, i++)
    3986        1311 :                                 if (j & 1) {
    3987        1174 :                                         ieps++;
    3988        1174 :                                         ds *= bigtens[i];
    3989             :                                         }
    3990        9881 :                         dval(&u) /= ds;
    3991             :                         }
    3992      107819 :                 else if ((j1 = -k)) {
    3993      101989 :                         dval(&u) *= tens[j1 & 0xf];
    3994      102214 :                         for(j = j1 >> 4; j; j >>= 1, i++)
    3995         225 :                                 if (j & 1) {
    3996         157 :                                         ieps++;
    3997         157 :                                         dval(&u) *= bigtens[i];
    3998             :                                         }
    3999             :                         }
    4000      117700 :                 if (k_check && dval(&u) < 1. && ilim > 0) {
    4001          58 :                         if (ilim1 <= 0)
    4002           0 :                                 goto fast_failed;
    4003          58 :                         ilim = ilim1;
    4004          58 :                         k--;
    4005          58 :                         dval(&u) *= 10.;
    4006          58 :                         ieps++;
    4007             :                         }
    4008      117700 :                 dval(&eps) = ieps*dval(&u) + 7.;
    4009      117700 :                 word0(&eps) -= (P-1)*Exp_msk1;
    4010      117700 :                 if (ilim == 0) {
    4011           8 :                         S = mhi = 0;
    4012           8 :                         dval(&u) -= 5.;
    4013           8 :                         if (dval(&u) > dval(&eps))
    4014           0 :                                 goto one_digit;
    4015           8 :                         if (dval(&u) < -dval(&eps))
    4016           8 :                                 goto no_digits;
    4017           0 :                         goto fast_failed;
    4018             :                         }
    4019             : #ifndef No_leftright
    4020      117692 :                 if (leftright) {
    4021             :                         /* Use Steele & White method of only
    4022             :                          * generating digits needed.
    4023             :                          */
    4024           0 :                         dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
    4025             : #ifdef IEEE_Arith
    4026           0 :                         if (k0 < 0 && j1 >= 307) {
    4027           0 :                                 eps1.d = 1.01e256; /* 1.01 allows roundoff in the next few lines */
    4028           0 :                                 word0(&eps1) -= Exp_msk1 * (Bias+P-1);
    4029           0 :                                 dval(&eps1) *= tens[j1 & 0xf];
    4030           0 :                                 for(i = 0, j = (j1-256) >> 4; j; j >>= 1, i++)
    4031           0 :                                         if (j & 1)
    4032           0 :                                                 dval(&eps1) *= bigtens[i];
    4033           0 :                                 if (eps.d < eps1.d)
    4034           0 :                                         eps.d = eps1.d;
    4035             :                                 }
    4036             : #endif
    4037           0 :                         for(i = 0;;) {
    4038           0 :                                 L = dval(&u);
    4039           0 :                                 dval(&u) -= L;
    4040           0 :                                 *s++ = '0' + (int)L;
    4041           0 :                                 if (1. - dval(&u) < dval(&eps))
    4042           0 :                                         goto bump_up;
    4043           0 :                                 if (dval(&u) < dval(&eps))
    4044           0 :                                         goto ret1;
    4045           0 :                                 if (++i >= ilim)
    4046           0 :                                         break;
    4047           0 :                                 dval(&eps) *= 10.;
    4048           0 :                                 dval(&u) *= 10.;
    4049           0 :                                 }
    4050             :                         }
    4051             :                 else {
    4052             : #endif
    4053             :                         /* Generate ilim digits, then fix them up. */
    4054      117692 :                         dval(&eps) *= tens[ilim-1];
    4055      958703 :                         for(i = 1;; i++, dval(&u) *= 10.) {
    4056      958703 :                                 L = (Long)(dval(&u));
    4057      958703 :                                 if (!(dval(&u) -= L))
    4058        3987 :                                         ilim = i;
    4059      958703 :                                 *s++ = '0' + (int)L;
    4060      958703 :                                 if (i == ilim) {
    4061      117692 :                                         if (dval(&u) > 0.5 + dval(&eps))
    4062       56960 :                                                 goto bump_up;
    4063       60732 :                                         else if (dval(&u) < 0.5 - dval(&eps)) {
    4064      214171 :                                                 while(*--s == '0');
    4065       60629 :                                                 s++;
    4066       60629 :                                                 goto ret1;
    4067             :                                                 }
    4068         103 :                                         break;
    4069             :                                         }
    4070      841011 :                                 }
    4071             : #ifndef No_leftright
    4072             :                         }
    4073             : #endif
    4074             :  fast_failed:
    4075         103 :                 s = s0;
    4076         103 :                 dval(&u) = dval(&d2);
    4077         103 :                 k = k0;
    4078         103 :                 ilim = ilim0;
    4079             :                 }
    4080             : 
    4081             :         /* Do we have a "small" integer? */
    4082             : 
    4083        1063 :         if (be >= 0 && k <= Int_max) {
    4084             :                 /* Yes. */
    4085         161 :                 ds = tens[k];
    4086         161 :                 if (ndigits < 0 && ilim <= 0) {
    4087           0 :                         S = mhi = 0;
    4088           0 :                         if (ilim < 0 || dval(&u) <= 5*ds)
    4089             :                                 goto no_digits;
    4090           0 :                         goto one_digit;
    4091             :                         }
    4092        1374 :                 for(i = 1;; i++, dval(&u) *= 10.) {
    4093        1374 :                         L = (Long)(dval(&u) / ds);
    4094        1374 :                         dval(&u) -= L*ds;
    4095             : #ifdef Check_FLT_ROUNDS
    4096             :                         /* If FLT_ROUNDS == 2, L will usually be high by 1 */
    4097             :                         if (dval(&u) < 0) {
    4098             :                                 L--;
    4099             :                                 dval(&u) += ds;
    4100             :                                 }
    4101             : #endif
    4102        1374 :                         *s++ = '0' + (int)L;
    4103        1374 :                         if (!dval(&u)) {
    4104             : #ifdef SET_INEXACT
    4105             :                                 inexact = 0;
    4106             : #endif
    4107         161 :                                 break;
    4108             :                                 }
    4109        1213 :                         if (i == ilim) {
    4110             : #ifdef Honor_FLT_ROUNDS
    4111             :                                 if (mode > 1)
    4112             :                                 switch(Rounding) {
    4113             :                                   case 0: goto ret1;
    4114             :                                   case 2: goto bump_up;
    4115             :                                   }
    4116             : #endif
    4117           0 :                                 dval(&u) += dval(&u);
    4118             : #ifdef ROUND_BIASED
    4119             :                                 if (dval(&u) >= ds)
    4120             : #else
    4121           0 :                                 if (dval(&u) > ds || (dval(&u) == ds && L & 1))
    4122             : #endif
    4123             :                                         {
    4124             :  bump_up:
    4125      251079 :                                         while(*--s == '9')
    4126      137170 :                                                 if (s == s0) {
    4127          11 :                                                         k++;
    4128          11 :                                                         *s = '0';
    4129          11 :                                                         break;
    4130             :                                                         }
    4131       56960 :                                         ++*s++;
    4132             :                                         }
    4133       56960 :                                 break;
    4134             :                                 }
    4135        1213 :                         }
    4136       57121 :                 goto ret1;
    4137             :                 }
    4138             : 
    4139         902 :         m2 = b2;
    4140         902 :         m5 = b5;
    4141         902 :         mhi = mlo = 0;
    4142         902 :         if (leftright) {
    4143           0 :                 i =
    4144             : #ifndef Sudden_Underflow
    4145           0 :                         denorm ? be + (Bias + (P-1) - 1 + 1) :
    4146             : #endif
    4147             : #ifdef IBM
    4148             :                         1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3);
    4149             : #else
    4150           0 :                         1 + P - bbits;
    4151             : #endif
    4152           0 :                 b2 += i;
    4153           0 :                 s2 += i;
    4154           0 :                 mhi = i2b(1);
    4155             :                 }
    4156         902 :         if (m2 > 0 && s2 > 0) {
    4157         789 :                 i = m2 < s2 ? m2 : s2;
    4158         789 :                 b2 -= i;
    4159         789 :                 m2 -= i;
    4160         789 :                 s2 -= i;
    4161             :                 }
    4162         902 :         if (b5 > 0) {
    4163         707 :                 if (leftright) {
    4164           0 :                         if (m5 > 0) {
    4165           0 :                                 mhi = pow5mult(mhi, m5);
    4166           0 :                                 b1 = mult(mhi, b);
    4167           0 :                                 Bfree(b);
    4168           0 :                                 b = b1;
    4169             :                                 }
    4170           0 :                         if ((j = b5 - m5))
    4171           0 :                                 b = pow5mult(b, j);
    4172             :                         }
    4173             :                 else
    4174         707 :                         b = pow5mult(b, b5);
    4175             :                 }
    4176         902 :         S = i2b(1);
    4177         902 :         if (s5 > 0)
    4178         170 :                 S = pow5mult(S, s5);
    4179             : 
    4180             :         /* Check for special case that d is a normalized power of 2. */
    4181             : 
    4182         902 :         spec_case = 0;
    4183         902 :         if ((mode < 2 || leftright)
    4184             : #ifdef Honor_FLT_ROUNDS
    4185             :                         && Rounding == 1
    4186             : #endif
    4187             :                                 ) {
    4188           0 :                 if (!word1(&u) && !(word0(&u) & Bndry_mask)
    4189             : #ifndef Sudden_Underflow
    4190           0 :                  && word0(&u) & (Exp_mask & ~Exp_msk1)
    4191             : #endif
    4192             :                                 ) {
    4193             :                         /* The special case */
    4194           0 :                         b2 += Log2P;
    4195           0 :                         s2 += Log2P;
    4196           0 :                         spec_case = 1;
    4197             :                         }
    4198             :                 }
    4199             : 
    4200             :         /* Arrange for convenient computation of quotients:
    4201             :          * shift left if necessary so divisor has 4 leading 0 bits.
    4202             :          *
    4203             :          * Perhaps we should just compute leading 28 bits of S once
    4204             :          * and for all and pass them and a shift to quorem, so it
    4205             :          * can do shifts and ors to compute the numerator for q.
    4206             :          */
    4207         902 :         i = dshift(S, s2);
    4208         902 :         b2 += i;
    4209         902 :         m2 += i;
    4210         902 :         s2 += i;
    4211         902 :         if (b2 > 0)
    4212         902 :                 b = lshift(b, b2);
    4213         902 :         if (s2 > 0)
    4214         901 :                 S = lshift(S, s2);
    4215         902 :         if (k_check) {
    4216         772 :                 if (cmp(b,S) < 0) {
    4217          12 :                         k--;
    4218          12 :                         b = multadd(b, 10, 0);  /* we botched the k estimate */
    4219          12 :                         if (leftright)
    4220           0 :                                 mhi = multadd(mhi, 10, 0);
    4221          12 :                         ilim = ilim1;
    4222             :                         }
    4223             :                 }
    4224         902 :         if (ilim <= 0 && (mode == 3 || mode == 5)) {
    4225          35 :                 if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
    4226             :                         /* no digits, fcvt style */
    4227             :  no_digits:
    4228          43 :                         k = -1 - ndigits;
    4229          43 :                         goto ret;
    4230             :                         }
    4231             :  one_digit:
    4232           0 :                 *s++ = '1';
    4233           0 :                 k++;
    4234           0 :                 goto ret;
    4235             :                 }
    4236         867 :         if (leftright) {
    4237           0 :                 if (m2 > 0)
    4238           0 :                         mhi = lshift(mhi, m2);
    4239             : 
    4240             :                 /* Compute mlo -- check for special case
    4241             :                  * that d is a normalized power of 2.
    4242             :                  */
    4243             : 
    4244           0 :                 mlo = mhi;
    4245           0 :                 if (spec_case) {
    4246           0 :                         mhi = Balloc(mhi->k);
    4247           0 :                         Bcopy(mhi, mlo);
    4248           0 :                         mhi = lshift(mhi, Log2P);
    4249             :                         }
    4250             : 
    4251           0 :                 for(i = 1;;i++) {
    4252           0 :                         dig = quorem(b,S) + '0';
    4253             :                         /* Do we yet have the shortest decimal string
    4254             :                          * that will round to d?
    4255             :                          */
    4256           0 :                         j = cmp(b, mlo);
    4257           0 :                         delta = diff(S, mhi);
    4258           0 :                         j1 = delta->sign ? 1 : cmp(b, delta);
    4259           0 :                         Bfree(delta);
    4260             : #ifndef ROUND_BIASED
    4261           0 :                         if (j1 == 0 && mode != 1 && !(word1(&u) & 1)
    4262             : #ifdef Honor_FLT_ROUNDS
    4263             :                                 && Rounding >= 1
    4264             : #endif
    4265             :                                                                    ) {
    4266           0 :                                 if (dig == '9')
    4267           0 :                                         goto round_9_up;
    4268           0 :                                 if (j > 0)
    4269           0 :                                         dig++;
    4270             : #ifdef SET_INEXACT
    4271             :                                 else if (!b->x[0] && b->wds <= 1)
    4272             :                                         inexact = 0;
    4273             : #endif
    4274           0 :                                 *s++ = dig;
    4275           0 :                                 goto ret;
    4276             :                                 }
    4277             : #endif
    4278           0 :                         if (j < 0 || (j == 0 && mode != 1
    4279             : #ifndef ROUND_BIASED
    4280           0 :                                                         && !(word1(&u) & 1)
    4281             : #endif
    4282             :                                         )) {
    4283           0 :                                 if (!b->x[0] && b->wds <= 1) {
    4284             : #ifdef SET_INEXACT
    4285             :                                         inexact = 0;
    4286             : #endif
    4287           0 :                                         goto accept_dig;
    4288             :                                         }
    4289             : #ifdef Honor_FLT_ROUNDS
    4290             :                                 if (mode > 1)
    4291             :                                  switch(Rounding) {
    4292             :                                   case 0: goto accept_dig;
    4293             :                                   case 2: goto keep_dig;
    4294             :                                   }
    4295             : #endif /*Honor_FLT_ROUNDS*/
    4296           0 :                                 if (j1 > 0) {
    4297           0 :                                         b = lshift(b, 1);
    4298           0 :                                         j1 = cmp(b, S);
    4299             : #ifdef ROUND_BIASED
    4300             :                                         if (j1 >= 0 /*)*/
    4301             : #else
    4302           0 :                                         if ((j1 > 0 || (j1 == 0 && dig & 1))
    4303             : #endif
    4304           0 :                                         && dig++ == '9')
    4305           0 :                                                 goto round_9_up;
    4306             :                                         }
    4307             :  accept_dig:
    4308           0 :                                 *s++ = dig;
    4309           0 :                                 goto ret;
    4310             :                                 }
    4311           0 :                         if (j1 > 0) {
    4312             : #ifdef Honor_FLT_ROUNDS
    4313             :                                 if (!Rounding)
    4314             :                                         goto accept_dig;
    4315             : #endif
    4316           0 :                                 if (dig == '9') { /* possible if i == 1 */
    4317             :  round_9_up:
    4318           0 :                                         *s++ = '9';
    4319           0 :                                         goto roundoff;
    4320             :                                         }
    4321           0 :                                 *s++ = dig + 1;
    4322           0 :                                 goto ret;
    4323             :                                 }
    4324             : #ifdef Honor_FLT_ROUNDS
    4325             :  keep_dig:
    4326             : #endif
    4327           0 :                         *s++ = dig;
    4328           0 :                         if (i == ilim)
    4329           0 :                                 break;
    4330           0 :                         b = multadd(b, 10, 0);
    4331           0 :                         if (mlo == mhi)
    4332           0 :                                 mlo = mhi = multadd(mhi, 10, 0);
    4333             :                         else {
    4334           0 :                                 mlo = multadd(mlo, 10, 0);
    4335           0 :                                 mhi = multadd(mhi, 10, 0);
    4336             :                                 }
    4337           0 :                         }
    4338             :                 }
    4339             :         else
    4340      298053 :                 for(i = 1;; i++) {
    4341      298053 :                         *s++ = dig = quorem(b,S) + '0';
    4342      298053 :                         if (!b->x[0] && b->wds <= 1) {
    4343             : #ifdef SET_INEXACT
    4344             :                                 inexact = 0;
    4345             : #endif
    4346          96 :                                 goto ret;
    4347             :                                 }
    4348      297957 :                         if (i >= ilim)
    4349         771 :                                 break;
    4350      297186 :                         b = multadd(b, 10, 0);
    4351      297186 :                         }
    4352             : 
    4353             :         /* Round off last digit */
    4354             : 
    4355             : #ifdef Honor_FLT_ROUNDS
    4356             :         switch(Rounding) {
    4357             :           case 0: goto trimzeros;
    4358             :           case 2: goto roundoff;
    4359             :           }
    4360             : #endif
    4361         771 :         b = lshift(b, 1);
    4362         771 :         j = cmp(b, S);
    4363             : #ifdef ROUND_BIASED
    4364             :         if (j >= 0)
    4365             : #else
    4366        1454 :         if (j > 0 || (j == 0 && dig & 1))
    4367             : #endif
    4368             :                 {
    4369             :  roundoff:
    4370        1414 :                 while(*--s == '9')
    4371          48 :                         if (s == s0) {
    4372           0 :                                 k++;
    4373           0 :                                 *s++ = '1';
    4374           0 :                                 goto ret;
    4375             :                                 }
    4376         683 :                 ++*s++;
    4377             :                 }
    4378             :         else {
    4379             : #ifdef Honor_FLT_ROUNDS
    4380             :  trimzeros:
    4381             : #endif
    4382         317 :                 while(*--s == '0');
    4383          88 :                 s++;
    4384             :                 }
    4385             :  ret:
    4386         910 :         Bfree(S);
    4387         910 :         if (mhi) {
    4388           0 :                 if (mlo && mlo != mhi)
    4389           0 :                         Bfree(mlo);
    4390           0 :                 Bfree(mhi);
    4391             :                 }
    4392             :  ret1:
    4393             : #ifdef SET_INEXACT
    4394             :         if (inexact) {
    4395             :                 if (!oldinexact) {
    4396             :                         word0(&u) = Exp_1 + (70 << Exp_shift);
    4397             :                         word1(&u) = 0;
    4398             :                         dval(&u) += 1.;
    4399             :                         }
    4400             :                 }
    4401             :         else if (!oldinexact)
    4402             :                 clear_inexact();
    4403             : #endif
    4404      118660 :         Bfree(b);
    4405      118660 :         *s = 0;
    4406      118660 :         *decpt = k + 1;
    4407      118660 :         if (rve)
    4408      104935 :                 *rve = s;
    4409      118660 :         return s0;
    4410             :         }
    4411             : 
    4412           8 : ZEND_API double zend_hex_strtod(const char *str, const char **endptr)
    4413             : {
    4414           8 :         const char *s = str;
    4415             :         char c;
    4416           8 :         int any = 0;
    4417           8 :         double value = 0;
    4418             : 
    4419           8 :         if (strlen(str) < 2) {
    4420           0 :                 *endptr = str;
    4421           0 :                 return 0.0;
    4422             :         }
    4423             : 
    4424           8 :         if (*s == '0' && (s[1] == 'x' || s[1] == 'X')) {
    4425           0 :                 s += 2;
    4426             :         }
    4427             : 
    4428         144 :         while ((c = *s++)) {
    4429         264 :                 if (c >= '0' && c <= '9') {
    4430         128 :                         c -= '0';
    4431           8 :                 } else if (c >= 'A' && c <= 'F') {
    4432           0 :                         c -= 'A' - 10;
    4433           8 :                 } else if (c >= 'a' && c <= 'f') {
    4434           0 :                         c -= 'a' - 10;
    4435             :                 } else {
    4436             :                         break;
    4437             :                 }
    4438             : 
    4439         128 :                 any = 1;
    4440         128 :                 value = value * 16 + c;
    4441             :         }
    4442             : 
    4443           8 :         if (endptr != NULL) {
    4444           8 :                 *endptr = any ? s - 1 : str;
    4445             :         }
    4446             : 
    4447           8 :         return value;
    4448             : }
    4449             : 
    4450           1 : ZEND_API double zend_oct_strtod(const char *str, const char **endptr)
    4451             : {
    4452           1 :         const char *s = str;
    4453             :         char c;
    4454           1 :         double value = 0;
    4455           1 :         int any = 0;
    4456             : 
    4457           1 :         if (strlen(str) < 1) {
    4458           0 :                 *endptr = str;
    4459           0 :                 return 0.0;
    4460             :         }
    4461             : 
    4462             :         /* skip leading zero */
    4463           1 :         s++;
    4464             : 
    4465          24 :         while ((c = *s++)) {
    4466          23 :                 if (c < '0' || c > '7') {
    4467             :                         /* break and return the current value if the number is not well-formed
    4468             :                          * that's what Linux strtol() does
    4469             :                          */
    4470             :                         break;
    4471             :                 }
    4472          22 :                 value = value * 8 + c - '0';
    4473          22 :                 any = 1;
    4474             :         }
    4475             : 
    4476           1 :         if (endptr != NULL) {
    4477           1 :                 *endptr = any ? s - 1 : str;
    4478             :         }
    4479             : 
    4480           1 :         return value;
    4481             : }
    4482             : 
    4483           5 : ZEND_API double zend_bin_strtod(const char *str, const char **endptr)
    4484             : {
    4485           5 :         const char *s = str;
    4486             :         char            c;
    4487           5 :         double          value = 0;
    4488           5 :         int             any = 0;
    4489             : 
    4490           5 :         if (strlen(str) < 2) {
    4491           0 :                 *endptr = str;
    4492           0 :                 return 0.0;
    4493             :         }
    4494             : 
    4495           5 :         if ('0' == *s && ('b' == s[1] || 'B' == s[1])) {
    4496           0 :                 s += 2;
    4497             :         }
    4498             : 
    4499         332 :         while ((c = *s++)) {
    4500             :                 /*
    4501             :                  * Verify the validity of the current character as a base-2 digit.  In
    4502             :                  * the event that an invalid digit is found, halt the conversion and
    4503             :                  * return the portion which has been converted thus far.
    4504             :                  */
    4505         327 :                 if ('0' == c || '1' == c)
    4506         322 :                         value = value * 2 + c - '0';
    4507             :                 else
    4508             :                         break;
    4509             : 
    4510         322 :                 any = 1;
    4511             :         }
    4512             : 
    4513             :         /*
    4514             :          * As with many strtoX implementations, should the subject sequence be
    4515             :          * empty or not well-formed, no conversion is performed and the original
    4516             :          * value of str is stored in *endptr, provided that endptr is not a null
    4517             :          * pointer.
    4518             :          */
    4519           5 :         if (NULL != endptr) {
    4520           5 :                 *endptr = (char *)(any ? s - 1 : str);
    4521             :         }
    4522             : 
    4523           5 :         return value;
    4524             : }
    4525             : 
    4526       20952 : static void destroy_freelist(void)
    4527             : {
    4528             :         int i;
    4529             :         Bigint *tmp;
    4530             : 
    4531             :         ACQUIRE_DTOA_LOCK(0)
    4532      188568 :         for (i = 0; i <= Kmax; i++) {
    4533      167616 :                 Bigint **listp = &freelist[i];
    4534      338758 :                 while ((tmp = *listp) != NULL) {
    4535        3526 :                         *listp = tmp->next;
    4536        3526 :                         free(tmp);
    4537             :                 }
    4538      167616 :                 freelist[i] = NULL;
    4539             :         }
    4540             :         FREE_DTOA_LOCK(0) 
    4541       20952 : }
    4542             : 
    4543             : #ifdef __cplusplus
    4544             : }
    4545             : #endif
    4546             : /*
    4547             :  * Local variables:
    4548             :  * tab-width: 4
    4549             :  * c-basic-offset: 4
    4550             :  * End:
    4551             :  * vim600: sw=4 ts=4 fdm=marker
    4552             :  * vim<600: sw=4 ts=4
    4553             :  */

Generated by: LCOV version 1.10

Generated at Thu, 21 May 2015 19:58:51 +0000 (7 days ago)

Copyright © 2005-2015 The PHP Group
All rights reserved.