gecko-dev/js/js2/numerics.cpp

// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
//
// The contents of this file are subject to the Netscape Public
// License Version 1.1 (the "License"); you may not use this file
// except in compliance with the License. You may obtain a copy of
// the License at http://www.mozilla.org/NPL/
//
// Software distributed under the License is distributed on an "AS
// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
// implied. See the License for the specific language governing
// rights and limitations under the License.
//
// The Original Code is the JavaScript 2 Prototype.
//
// The Initial Developer of the Original Code is Netscape
// Communications Corporation.  Portions created by Netscape are
// Copyright (C) 1998 Netscape Communications Corporation. All
// Rights Reserved.


#include <cstdlib>
#include <cstring>
#include <cfloat>
#include "numerics.h"
#include "jstypes.h"

namespace JS = JavaScript;
using namespace JavaScript;
using namespace JSTypes;


//
// Portable double-precision floating point to string and back conversions
//

// ****************************************************************
//
// The author of this software is David M. Gay.
//
// Copyright (c) 1991 by Lucent Technologies.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose without fee is hereby granted, provided that this entire notice
// is included in all copies of any software which is or includes a copy
// or modification of this software and in all copies of the supporting
// documentation for such software.
//
// THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
// WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
// REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
// OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
//
// ***************************************************************

/* Please send bug reports to
    David M. Gay
    Bell Laboratories, Room 2C-463
    600 Mountain Avenue
    Murray Hill, NJ 07974-0636
    U.S.A.
    dmg@bell-labs.com
 */

// On a machine with IEEE extended-precision registers, it is
// necessary to specify double-precision (53-bit) rounding precision
// before invoking strToDouble or doubleToAscii.  If the machine uses (the equivalent
// of) Intel 80x87 arithmetic, the call
//  _control87(PC_53, MCW_PC);
// does this with many compilers.  Whether this or another call is
// appropriate depends on the compiler; for this to work, it may be
// necessary to #include "float.h" or another system-dependent header
// file.


// strToDouble for IEEE-arithmetic machines.
//
// This strToDouble returns a nearest machine number to the input decimal
// string.  With IEEE arithmetic, ties are broken by the IEEE round-even
// rule.  Otherwise ties are broken by biased rounding (add half and chop).
//
// Inspired loosely by William D. Clinger's paper "How to Read Floating
// Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
//
// Modifications:
//
//  1. We only require IEEE double-precision
//      arithmetic (not IEEE double-extended).
//  2. We get by with floating-point arithmetic in a case that
//      Clinger missed -- when we're computing d * 10^n
//      for a small integer d and the integer n is not too
//      much larger than 22 (the maximum integer k for which
//      we can represent 10^k exactly), we may be able to
//      compute (d*10^k) * 10^(e-k) with just one roundoff.
//  3. Rather than a bit-at-a-time adjustment of the binary
//      result in the hard case, we use floating-point
//      arithmetic to determine the adjustment to within
//      one bit; only in really hard cases do we need to
//      compute a second residual.
//  4. Because of 3., we don't need a large table of powers of 10
//      for ten-to-e (just some small tables, e.g. of 10^k
//      for 0 <= k <= 22).


// #define IEEE_8087 for IEEE-arithmetic machines where the least
//  significant byte has the lowest address.
// #define IEEE_MC68k for IEEE-arithmetic machines where the most
//  significant byte has the lowest address.
// #define Sudden_Underflow for IEEE-format machines without gradual
//  underflow (i.e., that flush to zero on underflow).
// #define No_leftright to omit left-right logic in fast floating-point
//  computation of doubleToAscii.
// #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
// #define ROUND_BIASED for IEEE-format with biased rounding.
// #define Inaccurate_Divide for IEEE-format with correctly rounded
//  products but inaccurate quotients, e.g., for Intel i860.
// #define NATIVE_INT64 on machines that have "long long"
//  64-bit integer types int64 and uint64.
// #define JS_THREADSAFE if the system offers preemptively scheduled
//  multiple threads.  In this case, you must provide (or suitably
//  #define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed
//  by FREE_DTOA_LOCK(n) for n = 0 or 1.  (The second lock, accessed
//  in pow5Mul, ensures lazy evaluation of only one copy of high
//  powers of 5; omitting this lock would introduce a small
//  probability of wasting memory, but would otherwise be harmless.)
//  You must also invoke freeDToA(s) to free the value s returned by
//  doubleToAscii.  You may do so whether or not JS_THREADSAFE is #defined.
// #define NO_IEEE_Scale to disable new (Feb. 1997) logic in strToDouble that
//  avoids underflows on inputs whose result does not underflow.

#ifdef IS_LITTLE_ENDIAN
 #define IEEE_8087
#else
 #define IEEE_MC68k
#endif


// Stefan Hanske <sh990154@mail.uni-greifswald.de> reports:
//  ARM is a little endian architecture but 64 bit double words are stored
// differently: the 32 bit words are in little endian byte order, the two words
// are stored in big endian`s way.
#if defined (IEEE_8087) && !defined(__arm)
 #define word0(x) ((uint32 *)&x)[1]
 #define word1(x) ((uint32 *)&x)[0]
#else
 #define word0(x) ((uint32 *)&x)[0]
 #define word1(x) ((uint32 *)&x)[1]
#endif

// The following definition of Storeinc is appropriate for MIPS processors.
// An alternative that might be better on some machines is
// #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
#if defined(IEEE_8087)
 #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
 ((unsigned short *)a)[0] = (unsigned short)c, a++)
#else
 #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
 ((unsigned short *)a)[1] = (unsigned short)c, a++)
#endif

// #define P DBL_MANT_DIG
// Ten_pmax = floor(P*log(2)/log(5))
// Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16
// Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1)
// Int_max = floor(P*log(FLT_RADIX)/log(10) - 1)

#define Exp_shift  20
#define Exp_shift1 20
#define Exp_msk1    0x100000
#define Exp_msk11   0x100000
#define Exp_mask  0x7ff00000
#define P 53
#define Bias 1023
#define Emin (-1022)
#define Exp_1  0x3ff00000
#define Exp_11 0x3ff00000
#define Ebits 11
#define Frac_mask  0xfffff
#define Frac_mask1 0xfffff
#define Ten_pmax 22
#define Bletch 0x10
#define Bndry_mask  0xfffff
#define Bndry_mask1 0xfffff
#define LSB 1
#define Sign_bit 0x80000000
#define Log2P 1
#define Tiny0 0
#define Tiny1 1
#define Quick_max 14
#define Int_max 14
#define Infinite(x) (word0(x) == 0x7ff00000) // sufficient test for here
#ifndef NO_IEEE_Scale
 #define Avoid_Underflow
#endif

#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
#define Big1 0xffffffff

#ifdef JS_THREADSAFE
 static PRLock *freelist_lock;
 #define ACQUIRE_DTOA_LOCK(n) PR_Lock(freelist_lock)
 #define FREE_DTOA_LOCK(n) PR_Unlock(freelist_lock)
#else
 #define ACQUIRE_DTOA_LOCK(n)
 #define FREE_DTOA_LOCK(n)
#endif


//
// Double-precision constants
//


double JS::positiveInfinity;
double JS::negativeInfinity;
double JS::nan;

struct InitNumerics {InitNumerics();};
static InitNumerics initNumerics;

InitNumerics::InitNumerics()
{
	word0(positiveInfinity) = Exp_mask;
	word1(positiveInfinity) = 0;
	word0(negativeInfinity) = Exp_mask | Sign_bit;
	word1(negativeInfinity) = 0;
	word0(nan) = 0x7FFFFFFF;
	word1(nan) = 0xFFFFFFFF;
}

const JSValue JSTypes::kUndefinedValue;
const JSValue JSTypes::kNaNValue = JSValue(nan);
const JSValue JSTypes::kTrueValue = JSValue(true);
const JSValue JSTypes::kFalseValue = JSValue(false);
const JSValue JSTypes::kNullValue = JSValue(JSValue::Tag::null_tag);
const JSValue JSTypes::kNegativeZero = JSValue(-0.0);
const JSValue JSTypes::kPositiveZero = JSValue(0.0);
const JSValue JSTypes::kNegativeInfinity = JSValue(negativeInfinity);
const JSValue JSTypes::kPositiveInfinity = JSValue(positiveInfinity);

//
// Portable double-precision floating point to string and back conversions
//


// Return the absolute difference between x and the adjacent greater-magnitude double number (ignoring exponent overflows).
double JS::ulp(double x)
{
    int32 L;
    double a;

    L = int32((word0(x) & Exp_mask) - (P-1)*Exp_msk1);
#ifndef Sudden_Underflow
    if (L > 0) {
#endif
        word0(a) = uint32(L);
        word1(a) = 0;
#ifndef Sudden_Underflow
    }
    else {
        L = -L >> Exp_shift;
        if (L < Exp_shift) {
            word0(a) = 0x80000u >> L;
            word1(a) = 0;
        }
        else {
            word0(a) = 0;
            L -= Exp_shift;
            word1(a) = L >= 31 ? 1u : 1u << (31 - L);
        }
    }
#endif
    return a;
}


// Return the number (0 through 32) of most significant zero bits in x.
int JS::hi0bits(uint32 x)
{
    int k = 0;

    if (!(x & 0xffff0000)) {
        k = 16;
        x <<= 16;
    }
    if (!(x & 0xff000000)) {
        k += 8;
        x <<= 8;
    }
    if (!(x & 0xf0000000)) {
        k += 4;
        x <<= 4;
    }
    if (!(x & 0xc0000000)) {
        k += 2;
        x <<= 2;
    }
    if (!(x & 0x80000000)) {
        k++;
        if (!(x & 0x40000000))
            return 32;
    }
    return k;
}


// Return the number (0 through 32) of least significant zero bits in y.
// Also shift y to the right past these 0 through 32 zeros so that y's
// least significant bit will be set unless y was originally zero.
static int lo0bits(uint32 &y)
{
    int k;
    uint32 x = y;

    if (x & 7) {
        if (x & 1)
            return 0;
        if (x & 2) {
            y = x >> 1;
            return 1;
        }
        y = x >> 2;
        return 2;
    }
    k = 0;
    if (!(x & 0xffff)) {
        k = 16;
        x >>= 16;
    }
    if (!(x & 0xff)) {
        k += 8;
        x >>= 8;
    }
    if (!(x & 0xf)) {
        k += 4;
        x >>= 4;
    }
    if (!(x & 0x3)) {
        k += 2;
        x >>= 2;
    }
    if (!(x & 1)) {
        k++;
        x >>= 1;
        if (!x & 1)
            return 32;
    }
    y = x;
    return k;
}


uint32 *JS::BigInt::freeLists[maxLgGrossSize+1];


// Allocate a BigInt with 2^lgGrossSize words.  The BigInt must not currently contain a number.
void JS::BigInt::allocate(uint lgGrossSize)
{
	ASSERT(lgGrossSize <= maxLgGrossSize);

	BigInt::lgGrossSize = lgGrossSize;
	negative = false;
	grossSize = 1u << lgGrossSize;
	size = 0;
	words = 0;
    ACQUIRE_DTOA_LOCK(0);
    uint32 *w = freeLists[lgGrossSize];
    if (w) {
        freeLists[lgGrossSize] = *reinterpret_cast<uint32 **>(w);
	    FREE_DTOA_LOCK(0);
    } else {
	    FREE_DTOA_LOCK(0);
        w = static_cast<uint32 *>(STD::malloc(max(uint32(grossSize*sizeof(uint32)), uint32(sizeof(uint32 *)))));
        if (!w) {
		    std::bad_alloc outOfMemory;
		    throw outOfMemory;
		}
    }
    words = w;
}


// Recycle this BigInt's words array, which must be non-nil.
void JS::BigInt::recycle()
{
	ASSERT(words);
	uint bucket = lgGrossSize;
	uint32 *w = words;
    ACQUIRE_DTOA_LOCK(0);
    *reinterpret_cast<uint32 **>(w) = freeLists[bucket];
    freeLists[bucket] = w;
    FREE_DTOA_LOCK(0);
}


// Copy b into this BigInt, which must be uninitialized.
void JS::BigInt::initCopy(const BigInt &b)
{
	allocate(b.lgGrossSize);
	negative = b.negative;
	size = b.size;
	std::copy(b.words, b.words+size, words);
}


// Move b into this BigInt.  The original words array of this BigInt is recycled
// and must be non-nil.  After the move b has no value.
void JS::BigInt::move(BigInt &b)
{
	recycle();
	lgGrossSize = b.lgGrossSize;
	negative = b.negative;
	grossSize = b.grossSize;
	size = b.size;
	words = b.words;
	b.words = 0;
}


// Change this BigInt's lgGrossSize to the given value without affecting the BigInt value
// contained.  This BigInt must currently have a value that will fit in the new lgGrossSize.
void JS::BigInt::setLgGrossSize(uint lgGrossSize)
{
	ASSERT(words);
	BigInt b(lgGrossSize);
	ASSERT(size <= b.grossSize);
	std::copy(words, words+size, b.words);
	move(b);
}


// Set the BigInt to the given integer value.
// The BigInt must not currently have a value.
void JS::BigInt::init(uint32 i)
{
	ASSERT(!words);
    allocate(1);	// Allocate two words to allow a little room for growth.
    if (i) {
	    size = 1;
	    words[0] = i;
    } else
    	size = 0;
}


// Convert d into the form b*2^e, where b is an odd integer.  b is the BigInt returned
// in this, and e is the returned binary exponent.  Return the number of significant
// bits in b in bits.  d must be finite and nonzero.
void JS::BigInt::init(double d, int32 &e, int32 &bits)
{
    allocate(1);

    uint32 *x = words;
    uint32 z = word0(d) & Frac_mask;
    word0(d) &= 0x7fffffff;   // clear sign bit, which we ignore
    int32 de = (int32)(word0(d) >> Exp_shift);
#ifdef Sudden_Underflow
    z |= Exp_msk11;
#else
    if (de)
        z |= Exp_msk1;
#endif
    uint32 y = word1(d);
    int k;
    int i;
    if (y) {
        if ((k = lo0bits(y)) != 0) {
            x[0] = y | z << (32 - k);
            z >>= k;
        }
        else
            x[0] = y;
        i = (x[1] = z) ? 2 : 1;
    } else {
        ASSERT(z);
        k = lo0bits(z);
        x[0] = z;
        i = 1;
        k += 32;
    }
    size = uint32(i);

#ifndef Sudden_Underflow
    if (de) {
#endif
        e = de - Bias - (P-1) + k;
        bits = P - k;
#ifndef Sudden_Underflow
    } else {
        e = de - Bias - (P-1) + 1 + k;
        bits = 32*i - hi0bits(x[i-1]);
    }
#endif
}


// Let this = this*m + a.  Both a and m must be between 0 and 65535 inclusive.
void JS::BigInt::mulAdd(uint m, uint a)
{
#ifdef NATIVE_INT64
    uint64 carry, y;
#else
    uint32 carry, y;
    uint32 xi, z;
#endif

	ASSERT(m <= 0xFFFF && a <= 0xFFFF);
    uint32 sz = size;
    uint32 *x = words;
    carry = a;
    for (uint32 i = 0; i != sz; i++) {
#ifdef NATIVE_INT64
        y = *x * (uint64)m + carry;
        carry = y >> 32;
        *x++ = (uint32)(y & 0xffffffffUL);
#else
        xi = *x;
        y = (xi & 0xffff) * m + carry;
        z = (xi >> 16) * m + (y >> 16);
        carry = z >> 16;
        *x++ = (z << 16) + (y & 0xffff);
#endif
    }
    if (carry) {
        if (sz >= grossSize)
        	setLgGrossSize(lgGrossSize+1);
        words[sz++] = (uint32)carry;
        size = sz;
    }
}


// Let this = this*m.
void JS::BigInt::operator*=(const BigInt &m)
{
	const BigInt *a;
	const BigInt *b;
	if (size >= m.size) {
		a = this;
		b = &m;
	} else {
		a = &m;
		b = this;
	}

    uint k = a->lgGrossSize;
    uint32 wa = a->size;
    uint32 wb = b->size;
    uint32 wc = wa + wb;
    if (wc > a->grossSize)
        k++;

    BigInt c(k);
    uint32 *xc;
    uint32 *xce;
    for (xc = c.words, xce = xc + wc; xc < xce; xc++)
        *xc = 0;
    const uint32 *xa = a->words;
    const uint32 *xae = xa + wa;
    const uint32 *xb = b->words;
    const uint32 *xbe = xb + wb;
    uint32 *xc0 = c.words;
    uint32 y;
#ifdef NATIVE_INT64
    for (; xb < xbe; xc0++) {
        if ((y = *xb++) != 0) {
            const uint32 *x = xa;
            xc = xc0;
            uint64 carry = 0;
            do {
                uint64 z = *x++ * (uint64)y + *xc + carry;
                carry = z >> 32;
                *xc++ = (uint32)(z & 0xffffffffUL);
            } while (x < xae);
            *xc = (uint32)carry;
            }
        }
#else
    for (; xb < xbe; xb++, xc0++) {
    	uint32 carry;
    	uint32 z, z2;
    	const uint32 *x;
    	
        if ((y = *xb & 0xffff) != 0) {
            x = xa;
            xc = xc0;
            carry = 0;
            do {
                z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
                carry = z >> 16;
                z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
                carry = z2 >> 16;
                Storeinc(xc, z2, z);
            } while (x < xae);
            *xc = carry;
        }
        if ((y = *xb >> 16) != 0) {
            x = xa;
            xc = xc0;
            carry = 0;
            z2 = *xc;
            do {
                z = (*x & 0xffff) * y + (*xc >> 16) + carry;
                carry = z >> 16;
                Storeinc(xc, z, z2);
                z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
                carry = z2 >> 16;
            } while (x < xae);
            *xc = z2;
        }
    }
#endif
    for (xc0 = c.words, xc = xc0 + wc; wc && !*--xc; --wc) ;
    c.size = wc;
    move(c);
}


// Let this = this * 2^k.  k must be nonnegative.
void JS::BigInt::pow2Mul(int32 k)
{
	ASSERT(k >= 0);

    uint32 n = uint32(k) >> 5;
    uint k1 = lgGrossSize;
    uint32 n1 = n + size + 1;
    uint32 i;
    for (i = grossSize; n1 > i; i <<= 1)
        k1++;

    BigInt b1(k1);
    uint32 *x1 = b1.words;
    for (i = 0; i < n; i++)
        *x1++ = 0;
    uint32 *x = words;
    uint32 *xe = x + size;
    if (k &= 0x1f) {
        k1 = uint(32 - k);
        uint32 z = 0;
        while (x != xe) {
            *x1++ = *x << k | z;
            z = *x++ >> k1;
        }
        if ((*x1 = z) != 0)
            ++n1;
    }
    else
    	while (x != xe)
    		*x1++ = *x++;
    b1.size = n1 - 1;
    move(b1);
}


// 'p5s' points to a linked list of Bigints that are powers of 625.
// This list grows on demand, and it can only grow: it won't change
// in any other way.  So if we read 'p5s' or the 'next' field of
// some BigInt on the list, and it is not NULL, we know it won't
// change to NULL or some other value.  Only when the value of
// 'p5s' or 'next' is NULL do we need to acquire the lock and add
// a new BigInt to the list.
struct PowerOf625 {
	PowerOf625 *next;
	BigInt b;
};

static PowerOf625 *p5s;

#ifdef JS_THREADSAFE
static PRLock *p5s_lock;
#endif


// Let this = this * 5^k.  k must be nonnegative.
void JS::BigInt::pow5Mul(int32 k)
{
    static const uint p05[3] = {5, 25, 125};

	ASSERT(k >= 0);
    int32 i = k & 3;
    if (i)
        mulAdd(p05[i-1], 0);

    if (!(k >>= 2))
        return;
    PowerOf625 *p5 = p5s;
    if (!p5) {
        auto_ptr<PowerOf625> p(new PowerOf625);
        p->next = 0;
        p->b.init(625);
#ifdef JS_THREADSAFE
        // We take great care to not call init() and recycle() while holding the lock.
        // lock and check again
        PR_Lock(p5s_lock);
        if (!(p5 = p5s)) {
#endif
            // first time
	        p5 = p.release();
	        p5s = p5;
#ifdef JS_THREADSAFE
        }
        PR_Unlock(p5s_lock);
#endif
    }
    for (;;) {
        if (k & 1)
        	*this *= p5->b;
        if (!(k >>= 1))
            break;
	    PowerOf625 *p51 = p5->next;
        if (!p51) {
	        auto_ptr<PowerOf625> p(new PowerOf625);
	        p->next = 0;
	        p->b = p5->b;
	        p->b *= p5->b;
#ifdef JS_THREADSAFE
            PR_Lock(p5s_lock);
            if (!(p51 = p5->next)) {
#endif
                p51 = p.release();
                p5->next = p51;
#ifdef JS_THREADSAFE
            }
            PR_Unlock(p5s_lock);
#endif
        }
        p5 = p51;
    }
}


// Return -1, 0, or 1 depending on whether this<b, this==b, or this>b, respectively.
int JS::BigInt::cmp(const BigInt &b) const
{
    uint32 i = size;
    uint32 j = b.size;
#ifdef DEBUG
    if (i > 1 && !words[i-1])
        NOT_REACHED("cmp called with words[size-1] == 0");
    if (j > 1 && !b.words[j-1])
        NOT_REACHED("cmp called with b.words[b.size-1] == 0");
#endif
    if (i != j)
        return i<j ? -1 : 1;
    const uint32 *xa0 = words;
    const uint32 *xa = xa0 + j;
    const uint32 *xb = b.words + j;
    while (xa != xa0) {
        if (*--xa != *--xb)
            return *xa < *xb ? -1 : 1;
    }
    return 0;
}


// Initialize this BigInt to m-n.  This BigInt must not have a previous value.
void JS::BigInt::initDiff(const BigInt &m, const BigInt &n)
{
	ASSERT(!words && this != &m && this != &n);

    int i = m.cmp(n);
    if (!i)
    	init(0);
    else {
    	const BigInt *a;
    	const BigInt *b;
	    if (i < 0) {
	    	a = &n;
	    	b = &m;
	    } else {
	    	a = &m;
	    	b = &n;
	    }
	    allocate(a->lgGrossSize);
	    negative = i < 0;
	    uint32 wa = a->size;
	    const uint32 *xa = a->words;
	    const uint32 *xae = xa + wa;
	    const uint32 *xb = b->words;
	    const uint32 *xbe = xb + b->size;
	    uint32 *xc = words;
#ifdef NATIVE_INT64
	    uint64 borrow = 0;
	    uint64 y;
	    while (xb < xbe) {
	        y = (uint64)*xa++ - *xb++ - borrow;
	        borrow = y >> 32 & 1UL;
	        *xc++ = (uint32)(y & 0xffffffffUL);
	    }
	    while (xa < xae) {
	        y = *xa++ - borrow;
	        borrow = y >> 32 & 1UL;
	        *xc++ = (uint32)(y & 0xffffffffUL);
	    }
#else
	    uint32 borrow = 0;
	    uint32 y;
	    uint32 z;
	    while (xb < xbe) {
	        y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
	        borrow = (y & 0x10000) >> 16;
	        z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
	        borrow = (z & 0x10000) >> 16;
	        Storeinc(xc, z, y);
	    }
	    while (xa < xae) {
	        y = (*xa & 0xffff) - borrow;
	        borrow = (y & 0x10000) >> 16;
	        z = (*xa++ >> 16) - borrow;
	        borrow = (z & 0x10000) >> 16;
	        Storeinc(xc, z, y);
	    }
#endif
	    while (!*--xc)
	        wa--;
	    size = wa;
    }
}


// Return floor(this/2^k) and set this to be the remainder.
// The returned quotient must be less than 2^32.
uint32 JS::BigInt::quoRem2(int32 k)
{
    int32 n = k >> 5;
    k &= 0x1F;
    uint32 mask = (1u<<k) - 1;

    int32 w = int32(size) - n;
    if (w <= 0)
        return 0;
    ASSERT(w <= 2);
    uint32 *bx = words;
    uint32 *bxe = bx + n;
    uint32 result = *bxe >> k;
    *bxe &= mask;
    if (w == 2) {
        ASSERT(!(bxe[1] & ~mask));
        if (k)
            result |= bxe[1] << (32 - k);
    }
    n++;
    while (!*bxe && bxe != bx) {
        n--;
        bxe--;
    }
    size = uint32(n);
    return result;
}


// Return floor(this/S) and set this to be the remainder.  As added restrictions, this must not have
// more words than S, the most significant word of S must not start with a 1 bit, and the
// returned quotient must be less than 36.
int32 JS::BigInt::quoRem(const BigInt &S)
{
#ifdef NATIVE_INT64
    uint64 borrow, carry, y, ys;
#else
    uint32 borrow, carry, y, ys;
    uint32 si, z, zs;
#endif

    uint32 n = S.size;
    ASSERT(size <= n && n);
    if (size < n)
        return 0;
    const uint32 *sx = S.words;
    const uint32 *sxe = sx + --n;
    uint32 *bx = words;
    uint32 *bxe = bx + n;
    ASSERT(*sxe <= 0x7FFFFFFF);
    uint32 q = *bxe / (*sxe + 1);  // ensure q <= true quotient
    ASSERT(q < 36);
    if (q) {
        borrow = 0;
        carry = 0;
        do {
#ifdef NATIVE_INT64
            ys = *sx++ * (uint64)q + carry;
            carry = ys >> 32;
            y = *bx - (ys & 0xffffffffUL) - borrow;
            borrow = y >> 32 & 1UL;
            *bx++ = (uint32)(y & 0xffffffffUL);
#else
            si = *sx++;
            ys = (si & 0xffff) * q + carry;
            zs = (si >> 16) * q + (ys >> 16);
            carry = zs >> 16;
            y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
            borrow = (y & 0x10000) >> 16;
            z = (*bx >> 16) - (zs & 0xffff) - borrow;
            borrow = (z & 0x10000) >> 16;
            Storeinc(bx, z, y);
#endif
        } while (sx <= sxe);
        if (!*bxe) {
            bx = words;
            while (--bxe > bx && !*bxe)
                --n;
            size = n;
        }
    }
    if (cmp(S) >= 0) {
        q++;
        borrow = 0;
        carry = 0;
        bx = words;
        sx = S.words;
        do {
#ifdef NATIVE_INT64
            ys = *sx++ + carry;
            carry = ys >> 32;
            y = *bx - (ys & 0xffffffffUL) - borrow;
            borrow = y >> 32 & 1UL;
            *bx++ = (uint32)(y & 0xffffffffUL);
#else
            si = *sx++;
            ys = (si & 0xffff) + carry;
            zs = (si >> 16) + (ys >> 16);
            carry = zs >> 16;
            y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
            borrow = (y & 0x10000) >> 16;
            z = (*bx >> 16) - (zs & 0xffff) - borrow;
            borrow = (z & 0x10000) >> 16;
            Storeinc(bx, z, y);
#endif
        } while (sx <= sxe);
        bx = words;
        bxe = bx + n;
        if (!*bxe) {
            while (--bxe > bx && !*bxe)
                --n;
            size = n;
        }
    }
    return int32(q);
}


// Let this = floor(this / divisor), and return the remainder.  this must be nonnegative.
// divisor must be between 1 and 65536.
uint32 JS::BigInt::divRem(uint32 divisor)
{
    uint32 n = size;
    uint32 remainder = 0;

    ASSERT(divisor > 0 && divisor <= 65536);

    if (!n)
        return 0; // this is zero
    uint32 *bx = words;
    uint32 *bp = bx + n;
    do {
        uint32 a = *--bp;
        uint32 dividend = remainder << 16 | a >> 16;
        uint32 quotientHi = dividend / divisor;
        uint32 quotientLo;
        
        remainder = dividend - quotientHi*divisor;
        ASSERT(quotientHi <= 0xFFFF && remainder < divisor);
        dividend = remainder << 16 | (a & 0xFFFF);
        quotientLo = dividend / divisor;
        remainder = dividend - quotientLo*divisor;
        ASSERT(quotientLo <= 0xFFFF && remainder < divisor);
        *bp = quotientHi << 16 | quotientLo;
    } while (bp != bx);
    // Decrease the size of the number if its most significant word is now zero.
    if (bx[n-1] == 0)
        size--;
    return remainder;
}


double JS::BigInt::b2d(int32 &e) const
{
    double d;

    const uint32 *xa0 = words;
    const uint32 *xa = xa0 + size;
    ASSERT(size);
    uint32 y = *--xa;
    ASSERT(y);
    int k = hi0bits(y);
    e = 32 - k;
    if (k < Ebits) {
        word0(d) = Exp_1 | y >> (Ebits - k);
        uint32 w = xa > xa0 ? *--xa : 0;
        word1(d) = y << (32-Ebits + k) | w >> (Ebits - k);
    } else {
	    uint32 z = xa > xa0 ? *--xa : 0;
	    if (k -= Ebits) {
	        word0(d) = Exp_1 | y << k | z >> (32 - k);
	        y = xa > xa0 ? *--xa : 0;
	        word1(d) = z << k | y >> (32 - k);
	    }
	    else {
	        word0(d) = Exp_1 | y;
	        word1(d) = z;
	    }
    }
    return d;
}


double JS::BigInt::ratio(const BigInt &denominator) const
{
    int32 ka, kb;

    double da = b2d(ka);
    double db = denominator.b2d(kb);
    int32 k = ka - kb + 32*int32(size - denominator.size);
    if (k > 0)
        word0(da) += k*Exp_msk1;
    else
    	word0(db) -= k*Exp_msk1;
    return da / db;
}


void JS::BigInt::s2b(const char *s, int32 nd0, int32 nd, uint32 y9)
{
    int32 i;
    int32 x, y;

    x = (nd + 8) / 9;
    uint k = 0;
    for (y = 1; x > y; y <<= 1, k++) ;
    ASSERT(!words);
    allocate(k);
    words[0] = y9;
    size = 1;

    i = 9;
    if (9 < nd0) {
        s += 9;
        do mulAdd(10, uint(*s++ - '0'));
        while (++i < nd0);
        s++;
    } else
        s += 10;
    for (; i < nd; i++)
        mulAdd(10, uint(*s++ - '0'));
}



static const double tens[] = {
    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
    1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
    1e20, 1e21, 1e22
};

static const double bigtens[] = {1e16, 1e32, 1e64, 1e128, 1e256};
static const double tinytens[] = {1e-16, 1e-32, 1e-64, 1e-128,
#ifdef Avoid_Underflow
        9007199254740992.e-256
#else
        1e-256
#endif
        };
// The factor of 2^53 in tinytens[4] helps us avoid setting the underflow
// flag unnecessarily.  It leads to a song and dance at the end of strToDouble.

const int32 Scale_Bit = 0x10;
const int n_bigtens = 5;


#ifdef JS_THREADSAFE
static bool initialized = false;

// hacked replica of nspr _PR_InitDtoa
static void InitDtoa(void)
{
    freelist_lock = PR_NewLock();
        p5s_lock = PR_NewLock();
    initialized = true;
}
#endif



// Return as a double-precision floating-point number the value represented by the character
// string str.  The string is scanned up to the first unrecognized character.  The character
// sequences 'Infinity', '+Infinity', '-Infinity', and 'NaN' are also recognized.
// Return a pointer to the character terminating the scan in numEnd.
// If no number can be formed, set numEnd to str and return zero.
double JS::strToDouble(const char *str, const char *&numEnd)
{
    int32 scale;
    int32 bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
        e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0;
    const char *s, *s0, *s1;
    double aadj, aadj1, adj, rv, rv0;
    int32 L;
    uint32 y, z;

#ifdef JS_THREADSAFE
    if (!initialized) InitDtoa();
#endif

    nz0 = nz = 0;
    bool negative = false;
    bool haveSign = false;
    rv = 0.;
    for (s = str;; s++)
    	switch (*s) {
	      case '-':
	        negative = true;
	        // no break
	      case '+':
	    	haveSign = true;
	        if (*++s)
	            goto break2;
	        // no break
	      case 0:
	        s = str;
	        goto ret;
	      case '\t':
	      case '\n':
	      case '\v':
	      case '\f':
	      case '\r':
	      case ' ':
	        continue;
	      default:
	        goto break2;
	    }
  break2:
    switch (*s) {
      case '0':
        nz0 = 1;
        while (*++s == '0') ;
        if (!*s)
            goto ret;
        break;
      case 'I':
        if (!STD::strncmp(s+1, "nfinity", 7)) {
        	rv = positiveInfinity;
        	s += 8;
        	goto ret;
        }
        break;
      case 'N':
        if (!haveSign && !STD::strncmp(s+1, "aN", 2)) {
        	rv = nan;
        	s += 3;
        	goto ret;
        }
    }
    s0 = s;
    y = z = 0;
    for (nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
        if (nd < 9)
            y = 10*y + c - '0';
        else if (nd < 16)
            z = 10*z + c - '0';
    nd0 = nd;
    if (c == '.') {
        c = *++s;
        if (!nd) {
            for (; c == '0'; c = *++s)
                nz++;
            if (c > '0' && c <= '9') {
                s0 = s;
                nf += nz;
                nz = 0;
                goto have_dig;
            }
            goto dig_done;
        }
        for (; c >= '0' && c <= '9'; c = *++s) {
          have_dig:
            nz++;
            if (c -= '0') {
                nf += nz;
                for (i = 1; i < nz; i++)
                    if (nd++ < 9)
                        y *= 10;
                    else if (nd <= DBL_DIG + 1)
                        z *= 10;
                if (nd++ < 9)
                    y = 10*y + c;
                else if (nd <= DBL_DIG + 1)
                    z = 10*z + c;
                nz = 0;
            }
        }
    }
  dig_done:
    e = 0;
    if (c == 'e' || c == 'E') {
        if (!nd && !nz && !nz0) {
            s = str;
            goto ret;
        }
        str = s;
        esign = 0;
        switch (c = *++s) {
          case '-':
            esign = 1;
          case '+':
            c = *++s;
        }
        if (c >= '0' && c <= '9') {
            while (c == '0')
                c = *++s;
            if (c > '0' && c <= '9') {
                L = c - '0';
                s1 = s;
                while ((c = *++s) >= '0' && c <= '9')
                    L = 10*L + c - '0';
                if (s - s1 > 8 || L > 19999)
                    // Avoid confusion from exponents so large that e might overflow.
                    e = 19999; // safe for 16 bit ints
                else
                    e = (int32)L;
                if (esign)
                    e = -e;
            }
            else
                e = 0;
        }
        else
            s = str;
    }
    if (!nd) {
        if (!nz && !nz0) {
            s = str;
            }
        goto ret;
    }
    e1 = e -= nf;

    // Now we have nd0 digits, starting at s0, followed by a
    // decimal point, followed by nd-nd0 digits.  The number we're
    // after is the integer represented by those digits times 10**e

    if (!nd0)
        nd0 = nd;
    k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
    rv = y;
    if (k > 9)
        rv = tens[k - 9] * rv + z;
    if (nd <= DBL_DIG && FLT_ROUNDS == 1) {
        if (!e)
            goto ret;
        if (e > 0) {
            if (e <= Ten_pmax) {
                rv *= tens[e];
                goto ret;
            }
            i = DBL_DIG - nd;
            if (e <= Ten_pmax + i) {
                // A fancier test would sometimes let us do this for larger i values.
                e -= i;
                rv *= tens[i];
                rv *= tens[e];
                goto ret;
            }
        }
#ifndef Inaccurate_Divide
        else if (e >= -Ten_pmax) {
            rv /= tens[-e];
            goto ret;
        }
#endif
    }
    e1 += nd - k;

    scale = 0;

    // Get starting approximation = rv * 10**e1

    if (e1 > 0) {
        if ((i = e1 & 15) != 0)
            rv *= tens[i];
        if (e1 &= ~15) {
            if (e1 > DBL_MAX_10_EXP) {
              ovfl:
            	// Return infinity.
                rv = positiveInfinity;
                goto ret;
            }
            e1 >>= 4;
            for (j = 0; e1 > 1; j++, e1 >>= 1)
                if (e1 & 1)
                    rv *= bigtens[j];
            // The last multiplication could overflow.
            word0(rv) -= P*Exp_msk1;
            rv *= bigtens[j];
            if ((z = word0(rv) & Exp_mask) > Exp_msk1*(DBL_MAX_EXP+Bias-P))
                goto ovfl;
            if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
                // set to largest number
                // (Can't trust DBL_MAX)
                word0(rv) = Big0;
                word1(rv) = Big1;
                }
            else
                word0(rv) += P*Exp_msk1;
            }
    }
    else if (e1 < 0) {
        e1 = -e1;
        if ((i = e1 & 15) != 0)
            rv /= tens[i];
        if (e1 &= ~15) {
            e1 >>= 4;
            if (e1 >= 1 << n_bigtens)
                goto undfl;
#ifdef Avoid_Underflow
            if (e1 & Scale_Bit)
                scale = P;
            for (j = 0; e1 > 0; j++, e1 >>= 1)
                if (e1 & 1)
                    rv *= tinytens[j];
            if (scale && (j = P + 1 - int32((word0(rv) & Exp_mask) >> Exp_shift)) > 0) {
                // scaled rv is denormal; zap j low bits
                if (j >= 32) {
                    word1(rv) = 0;
                    word0(rv) &= 0xffffffff << (j-32);
                    if (!word0(rv))
                        word0(rv) = 1;
                    }
                else
                    word1(rv) &= 0xffffffff << j;
                }
#else
            for (j = 0; e1 > 1; j++, e1 >>= 1)
                if (e1 & 1)
                    rv *= tinytens[j];
            // The last multiplication could underflow.
            rv0 = rv;
            rv *= tinytens[j];
            if (!rv) {
                rv = 2.*rv0;
                rv *= tinytens[j];
#endif
                if (!rv) {
                  undfl:
                    rv = 0.;
                    goto ret;
                }
#ifndef Avoid_Underflow
                word0(rv) = Tiny0;
                word1(rv) = Tiny1;
                // The refinement below will clean this approximation up.
            }
#endif
        }
    }

    // Now the hard part -- adjusting rv to the correct value.

    // Put digits into bd: true value = bd * 10^e
	{
	    BigInt bd0;
	    bd0.s2b(s0, nd0, nd, y);

	    for (;;) {
	    	BigInt bs;

	        BigInt bd = bd0;
	        BigInt bb;
	        bb.init(rv, bbe, bbbits);    // rv = bb * 2^bbe
	        bs.init(1);

	        if (e >= 0) {
	            bb2 = bb5 = 0;
	            bd2 = bd5 = e;
	        }
	        else {
	            bb2 = bb5 = -e;
	            bd2 = bd5 = 0;
	        }
	        if (bbe >= 0)
	            bb2 += bbe;
	        else
	            bd2 -= bbe;
	        bs2 = bb2;
#ifdef Sudden_Underflow
	        j = P + 1 - bbbits;
#else
#ifdef Avoid_Underflow
	        j = bbe - scale;
#else
	        j = bbe;
#endif
	        i = j + bbbits - 1; // logb(rv)
	        if (i < Emin)   // denormal
	            j += P - Emin;
	        else
	            j = P + 1 - bbbits;
#endif
	        bb2 += j;
	        bd2 += j;
#ifdef Avoid_Underflow
	        bd2 += scale;
#endif
	        i = bb2 < bd2 ? bb2 : bd2;
	        if (i > bs2)
	            i = bs2;
	        if (i > 0) {
	            bb2 -= i;
	            bd2 -= i;
	            bs2 -= i;
	        }
	        if (bb5 > 0) {
	            bs.pow5Mul(bb5);
	            bb *= bs;
	        }
	        if (bb2 > 0)
	            bb.pow2Mul(bb2);
	        if (bd5 > 0)
	            bd.pow5Mul(bd5);
	        if (bd2 > 0)
	            bd.pow2Mul(bd2);
	        if (bs2 > 0)
	            bs.pow2Mul(bs2);

	        BigInt delta;
	        delta.initDiff(bb, bd);
	        dsign = delta.negative;
	        delta.negative = false;
	        i = delta.cmp(bs);
	        if (i < 0) {
	            // Error is less than half an ulp -- check for special case of mantissa a power of two.
	            if (dsign || word1(rv) || word0(rv) & Bndry_mask
#ifdef Avoid_Underflow
	             || (word0(rv) & Exp_mask) <= Exp_msk1 + P*Exp_msk1
#else
	             || (word0(rv) & Exp_mask) <= Exp_msk1
#endif
	                ) {
#ifdef Avoid_Underflow
	                if (delta.isZero())
	                    dsign = 2;
#endif
	                break;
	                }
	            delta.pow2Mul(Log2P);
	            if (delta.cmp(bs) > 0)
	                goto drop_down;
	            break;
	        }
	        if (i == 0) {
	            // exactly half-way between
	            if (dsign) {
	                if ((word0(rv) & Bndry_mask1) == Bndry_mask1
	                    &&  word1(rv) == 0xffffffff) {
	                    //boundary case -- increment exponent
	                    word0(rv) = (word0(rv) & Exp_mask) + Exp_msk1;
	                    word1(rv) = 0;
#ifdef Avoid_Underflow
	                    dsign = 0;
#endif
	                    break;
	                }
	            }
	            else if (!(word0(rv) & Bndry_mask) && !word1(rv)) {
#ifdef Avoid_Underflow
	                dsign = 2;
#endif
	              drop_down:
	                // boundary case -- decrement exponent
#ifdef Sudden_Underflow
	                L = word0(rv) & Exp_mask;
	                if (L <= Exp_msk1)
	                    goto undfl;
	                L -= Exp_msk1;
#else
	                L = int32((word0(rv) & Exp_mask) - Exp_msk1);
#endif
	                word0(rv) = uint32(L) | Bndry_mask1;
	                word1(rv) = 0xffffffff;
	                break;
	            }
#ifndef ROUND_BIASED
	            if (!(word1(rv) & LSB))
	                break;
#endif
	            if (dsign)
	                rv += ulp(rv);
#ifndef ROUND_BIASED
	            else {
	                rv -= ulp(rv);
#ifndef Sudden_Underflow
	                if (!rv)
	                    goto undfl;
#endif
	            }
#ifdef Avoid_Underflow
	            dsign = 1 - dsign;
#endif
#endif
	            break;
	        }
	        if ((aadj = delta.ratio(bs)) <= 2.) {
	            if (dsign)
	                aadj = aadj1 = 1.;
	            else if (word1(rv) || word0(rv) & Bndry_mask) {
#ifndef Sudden_Underflow
	                if (word1(rv) == Tiny1 && !word0(rv))
	                    goto undfl;
#endif
	                aadj = 1.;
	                aadj1 = -1.;
	            }
	            else {
	                // special case -- power of FLT_RADIX to be
	                // rounded down...

	                if (aadj < 2./FLT_RADIX)
	                    aadj = 1./FLT_RADIX;
	                else
	                    aadj *= 0.5;
	                aadj1 = -aadj;
	            }
	        }
	        else {
	            aadj *= 0.5;
	            aadj1 = dsign ? aadj : -aadj;
#ifdef Check_FLT_ROUNDS
	            switch (FLT_ROUNDS) {
	              case 2: // towards +infinity
	                aadj1 -= 0.5;
	                break;
	              case 0: // towards 0
	              case 3: // towards -infinity
	                aadj1 += 0.5;
	            }
#else
	            if (FLT_ROUNDS == 0)
	                aadj1 += 0.5;
#endif
	        }
	        y = word0(rv) & Exp_mask;

	        // Check for overflow

	        if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
	            rv0 = rv;
	            word0(rv) -= P*Exp_msk1;
	            adj = aadj1 * ulp(rv);
	            rv += adj;
	            if ((word0(rv) & Exp_mask) >=
	                Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
	                if (word0(rv0) == Big0 && word1(rv0) == Big1)
	                    goto ovfl;
	                word0(rv) = Big0;
	                word1(rv) = Big1;
	                continue;
	            }
	            else
	                word0(rv) += P*Exp_msk1;
	        }
	        else {
#ifdef Sudden_Underflow
	            if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
	                rv0 = rv;
	                word0(rv) += P*Exp_msk1;
	                adj = aadj1 * ulp(rv);
	                rv += adj;
	                if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
	                    if (word0(rv0) == Tiny0 && word1(rv0) == Tiny1)
	                        goto undfl;
	                    word0(rv) = Tiny0;
	                    word1(rv) = Tiny1;
	                    continue;
	                } else
	                    word0(rv) -= P*Exp_msk1;
	            } else {
	                adj = aadj1 * ulp(rv);
	                rv += adj;
	            }
#else
	            // Compute adj so that the IEEE rounding rules will
	            // correctly round rv + adj in some half-way cases.
	            // If rv * ulp(rv) is denormalized (i.e.,
	            // y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
	            // trouble from bits lost to denormalization;
	            // example: 1.2e-307 .
#ifdef Avoid_Underflow
	            if (y <= P*Exp_msk1 && aadj > 1.)
#else
	            if (y <= (P-1)*Exp_msk1 && aadj > 1.)
#endif
	                {
	                aadj1 = (double)(int32)(aadj + 0.5);
	                if (!dsign)
	                    aadj1 = -aadj1;
	            }
#ifdef Avoid_Underflow
	            if (scale && y <= P*Exp_msk1)
	                word0(aadj1) += (P+1)*Exp_msk1 - y;
#endif
	            adj = aadj1 * ulp(rv);
	            rv += adj;
#endif
	        }
	        z = word0(rv) & Exp_mask;
#ifdef Avoid_Underflow
	        if (!scale)
#endif
	        if (y == z) {
	            // Can we stop now?
	            L = (int32)aadj;
	            aadj -= L;
	            // The tolerances below are conservative.
	            if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
	                if (aadj < .4999999 || aadj > .5000001)
	                    break;
	            }
	            else if (aadj < .4999999/FLT_RADIX)
	                break;
	        }
	    }
#ifdef Avoid_Underflow
	    if (scale) {
	        word0(rv0) = Exp_1 - P*Exp_msk1;
	        word1(rv0) = 0;
	        if ((word0(rv) & Exp_mask) <= P*Exp_msk1
	              && word1(rv) & 1
	              && dsign != 2) {
	            if (dsign) {
#ifdef Sudden_Underflow
	                // rv will be 0, but this would give the
	                // right result if only rv *= rv0 worked.
	                word0(rv) += P*Exp_msk1;
	                word0(rv0) = Exp_1 - 2*P*Exp_msk1;
#endif
	                rv += ulp(rv);
	                }
	            else
	                word1(rv) &= ~1;
	        }
	        rv *= rv0;
	    }
#endif // Avoid_Underflow
	}
  ret:
    numEnd = s;
    return negative ? -rv : rv;
}


// A version of strToDouble that takes a char16 string that begins at str and ends just
// before strEnd.  The char16 string does not have to be null-terminated.
// Leading Unicode whitespace is skipped.
double JS::stringToDouble(const char16 *str, const char16 *strEnd, const char16 *&numEnd)
{
    const char16 *str1 = skipWhiteSpace(str, strEnd);

    CharAutoPtr cstr(new char[strEnd - str1 + 1]);
    char *q = cstr.get();
    for (const char16 *p = str1; p != strEnd; p++) {
    	char16 ch = *p;
		if (uint16(ch) >> 8)
			break;
		*q++ = char(ch);
    }
    *q = '\0';

    const char *estr;
	double value = strToDouble(cstr.get(), estr);
    ptrdiff_t i = estr - cstr.get();
    numEnd = i ? str1 + i : str;
    return value;
}



class BinaryDigitReader
{
    uint base;							// Base of number; must be a power of 2
    uint digit;							// Current digit value in radix given by base
    uint digitMask;						// Mask to extract the next bit from digit
    const char16 *digits;				// Pointer to the remaining digits
    const char16 *digitsEnd;			// Pointer to first non-digit

  public:
	BinaryDigitReader(uint base, const char16 *digitsBegin, const char16 *digitsEnd):
		base(base), digitMask(0), digits(digitsBegin), digitsEnd(digitsEnd) {}
	
	int next();
};


// Return the next binary digit from the number or -1 if done.
int BinaryDigitReader::next()
{
    if (digitMask == 0) {
		if (digits == digitsEnd)
		    return -1;

		uint c = *digits++;
		if ('0' <= c && c <= '9')
		    digit = c - '0';
		else if ('a' <= c && c <= 'z')
		    digit = c - 'a' + 10;
		else digit = c - 'A' + 10;
		digitMask = base >> 1;
    }
    int bit = (digit & digitMask) != 0;
    digitMask >>= 1;
    return bit;
}


// Read an integer from a char16 string that begins at str and ends just before strEnd.
// The char16 string does not have to be null-terminated.  The integer is returned as a double,
// which is guaranteed to be the closest double number to the given input when base is 10 or a power of 2.
// May experience roundoff errors for very large numbers of a different radix.
// Return a pointer to the character just past the integer in numEnd.
// If the string does not have a number in it, set numEnd to str and return 0.
// Leading Unicode whitespace is skipped.
double JS::stringToInteger(const char16 *str, const char16 *strEnd, const char16 *&numEnd, uint base)
{
    const char16 *str1 = skipWhiteSpace(str, strEnd);

    bool negative = (*str1 == '-');
    if (negative || *str1 == '+')
		str1++;

    if ((base == 0 || base == 16) && *str1 == '0' && (str1[1] == 'X' || str1[1] == 'x')) {
		// Skip past hex prefix.
		base = 16;
		str1 += 2;
	}
    if (base == 0)
		base = 10; // Default to decimal.

    // Find some prefix of the string that's a number in the given base.
    const char16 *start = str1; // Mark - if string is empty, we return 0.
    double value = 0.0;
    while (true) {
		uint digit;
		char16 c = *str1;
		if ('0' <= c && c <= '9')
		    digit = uint(c) - '0';
		else if ('a' <= c && c <= 'z')
		    digit = uint(c) - 'a' + 10;
		else if ('A' <= c && c <= 'Z')
		    digit = uint(c) - 'A' + 10;
		else
		    break;
		if (digit >= base)
		    break;
		value = value*base + digit;
		str1++;
    }

    if (value >= 9007199254740992.0) {
		if (base == 10) {
		    // If we're accumulating a decimal number and the number is >= 2^53, then
		    // the result from the repeated multiply-add above may be inaccurate.  Call
		    // stringToDouble to get the correct answer.
		    const char16 *numEnd2;
		    value = stringToDouble(start, str1, numEnd2);
		    ASSERT(numEnd2 == str1);

		} else if (base == 2 || base == 4 || base == 8 || base == 16 || base == 32) {
		    // The number may also be inaccurate for one of these bases.  This
		    // happens if the addition in value*base + digit causes a round-down
		    // to an even least significant mantissa bit when the first dropped bit
		    // is a one.  If any of the following digits in the number (which haven't
		    // been added in yet) are nonzero then the correct action would have
		    // been to round up instead of down.  An example of this occurs when
		    // reading the number 0x1000000000000081, which rounds to 0x1000000000000000
		    // instead of 0x1000000000000100.
		    BinaryDigitReader bdr(base, start, str1);
		    value = 0.0;

		    // Skip leading zeros.
		    int bit;
		    do {
				bit = bdr.next();
		    } while (bit == 0);

		    if (bit == 1) {
				// Gather the 53 significant bits (including the leading 1)
				int bit2;
				value = 1.0;
				for (int j = 52; j; --j) {
				    bit = bdr.next();
				    if (bit < 0)
						goto done;
				    value = value*2 + bit;
				}
				// bit2 is the 54th bit (the first dropped from the mantissa)
				bit2 = bdr.next();
				if (bit2 >= 0) {
				    double factor = 2.0;
				    int sticky = 0;  // sticky is 1 if any bit beyond the 54th is 1
				    int bit3;

				    while ((bit3 = bdr.next()) >= 0) {
						sticky |= bit3;
						factor *= 2;
				    }
				    value += bit2 & (bit | sticky);
				    value *= factor;
				}
		      done:;
		    }
		}
    }
    // We don't worry about inaccurate numbers for any other base.

    if (str1 == start)
		numEnd = str;
    else {
    	numEnd = str1;
    	if (negative)
    		value = -value;
    }
    return value;
}



// doubleToAscii for IEEE arithmetic (dmg): convert double to ASCII string.
//
// Inspired by "How to Print Floating-Point Numbers Accurately" by
// Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101].
//
// Modifications:
//  1. Rather than iterating, we use a simple numeric overestimate
//     to determine k = floor(log10(d)).  We scale relevant
//     quantities using O(log2(k)) rather than O(k) multiplications.
//  2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
//     try to generate digits strictly left to right.  Instead, we
//     compute with fewer bits and propagate the carry if necessary
//     when rounding the final digit up.  This is often faster.
//  3. Under the assumption that input will be rounded nearest,
//     mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
//     That is, we allow equality in stopping tests when the
//     round-nearest rule will give the same floating-point value
//     as would satisfaction of the stopping test with strict
//     inequality.
//  4. We remove common factors of powers of 2 from relevant
//     quantities.
//  5. When converting floating-point integers less than 1e16,
//     we use floating-point arithmetic rather than resorting
//     to multiple-precision integers.
//  6. When asked to produce fewer than 15 digits, we first try
//     to get by with floating-point arithmetic; we resort to
//     multiple-precision integer arithmetic only if we cannot
//     guarantee that the floating-point calculation has given
//     the correctly rounded result.  For k requested digits and
//     "uniformly" distributed input, the probability is
//     something like 10^(k-15) that we must resort to the int32
//     calculation.
///

// Always emits at least one digit.
// If biasUp is set, then rounding in modes 2 and 3 will round away from zero
// when the number is exactly halfway between two representable values.  For example, 
// rounding 2.5 to zero digits after the decimal point will return 3 and not 2.
// 2.49 will still round to 2, and 2.51 will still round to 3.
// The buffer should be at least 20 bytes for modes 0 and 1.  For the other modes,
// the buffer's size should be two greater than the maximum number of output characters expected.
// Return a pointer to the resulting string's trailing null.
static char *doubleToAscii(double d, int mode, bool biasUp, int ndigits,
    int *decpt, bool *negative, char *buf)
{
    /*  Arguments ndigits, decpt, negative are similar to those
        of ecvt and fcvt; trailing zeros are suppressed from
        the returned string.  If d is +-Infinity or NaN,
        then *decpt is set to 9999.

        mode:
        0 ==> shortest string that yields d when read in
        and rounded to nearest.
        1 ==> like 0, but with Steele & White stopping rule;
        e.g. with IEEE P754 arithmetic , mode 0 gives
        1e23 whereas mode 1 gives 9.999999999999999e22.
        2 ==> max(1,ndigits) significant digits.  This gives a
        return value similar to that of ecvt, except
        that trailing zeros are suppressed.
        3 ==> through ndigits past the decimal point.  This
        gives a return value similar to that from fcvt,
        except that trailing zeros are suppressed, and
        ndigits can be negative.
        4-9 should give the same return values as 2-3, i.e.,
        4 <= mode <= 9 ==> same return as mode
        2 + (mode & 1).  These modes are mainly for
        debugging; often they run slower but sometimes
        faster than modes 2-3.
        4,5,8,9 ==> left-to-right digit generation.
        6-9 ==> don't try fast floating-point estimate
        (if applicable).

        Values of mode other than 0-9 are treated as mode 0.

        Sufficient space is allocated to the return value
        to hold the suppressed trailing zeros.
    */

    int32 bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
        j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
        try_quick;
    int32 L;
#ifndef Sudden_Underflow
    int32 denorm;
    uint32 x;
#endif
    double d2, ds, eps;
    char *s;

#ifdef JS_THREADSAFE
    if (!initialized) InitDtoa();
#endif

    if (word0(d) & Sign_bit) {
        // set negative for everything, including 0's and NaNs
        *negative = true;
        word0(d) &= ~Sign_bit;  // clear sign bit
    }
    else
        *negative = false;

    if ((word0(d) & Exp_mask) == Exp_mask) {
        // Infinity or NaN
        *decpt = 9999;
        strcpy(buf, !word1(d) && !(word0(d) & Frac_mask) ? "Infinity" : "NaN");
        return buf[3] ? buf + 8 : buf + 3;
    }
    if (!d) {
      no_digits:
        *decpt = 1;
        buf[0] = '0'; buf[1] = '\0';  // copy "0" to buffer
        return buf + 1;
    }

	BigInt b;
    b.init(d, be, bbits);
#ifdef Sudden_Underflow
    i = (int32)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
#else
    if ((i = (int32)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) != 0) {
#endif
        d2 = d;
        word0(d2) &= Frac_mask1;
        word0(d2) |= Exp_11;

        /* log(x)   ~=~ log(1.5) + (x-1.5)/1.5
         * log10(x)  =  log(x) / log(10)
         *      ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
         * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
         *
         * This suggests computing an approximation k to log10(d) by
         *
         * k = (i - Bias)*0.301029995663981
         *  + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
         *
         * We want k to be too large rather than too small.
         * The error in the first-order Taylor series approximation
         * is in our favor, so we just round up the constant enough
         * to compensate for any error in the multiplication of
         * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
         * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
         * adding 1e-13 to the constant term more than suffices.
         * Hence we adjust the constant term to 0.1760912590558.
         * (We could get a more accurate k by invoking log10,
         *  but this is probably not worthwhile.)
         */

        i -= Bias;
#ifndef Sudden_Underflow
        denorm = 0;
    }
    else {
        // d is denormalized

        i = bbits + be + (Bias + (P-1) - 1);
        x = i > 32 ? word0(d) << (64 - i) | word1(d) >> (i - 32) : word1(d) << (32 - i);
        d2 = x;
        word0(d2) -= 31*Exp_msk1; // adjust exponent
        i -= (Bias + (P-1) - 1) + 1;
        denorm = 1;
    }
#endif
    // At this point d = f*2^i, where 1 <= f < 2.  d2 is an approximation of f.
    ds = (d2-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
    k = (int32)ds;
    if (ds < 0. && ds != k)
        k--;    // want k = floor(ds)
    k_check = 1;
    if (k >= 0 && k <= Ten_pmax) {
        if (d < tens[k])
            k--;
        k_check = 0;
    }
    // At this point floor(log10(d)) <= k <= floor(log10(d))+1.
    // If k_check is zero, we're guaranteed that k = floor(log10(d)).
    j = bbits - i - 1;
    // At this point d = b/2^j, where b is an odd integer.
    if (j >= 0) {
        b2 = 0;
        s2 = j;
    }
    else {
        b2 = -j;
        s2 = 0;
    }
    if (k >= 0) {
        b5 = 0;
        s5 = k;
        s2 += k;
    }
    else {
        b2 -= k;
        b5 = -k;
        s5 = 0;
    }
    // At this point d/10^k = (b * 2^b2 * 5^b5) / (2^s2 * 5^s5), where b is an odd integer,
    // b2 >= 0, b5 >= 0, s2 >= 0, and s5 >= 0.
    if (mode < 0 || mode > 9)
        mode = 0;
    try_quick = 1;
    if (mode > 5) {
        mode -= 4;
        try_quick = 0;
    }
    leftright = 1;
    ilim = ilim1 = 0;
    switch (mode) {
      case 0:
      case 1:
        ilim = ilim1 = -1;
        i = 18;
        ndigits = 0;
        break;
      case 2:
        leftright = 0;
        // no break
      case 4:
        if (ndigits <= 0)
            ndigits = 1;
        ilim = ilim1 = i = ndigits;
        break;
      case 3:
        leftright = 0;
        // no break
      case 5:
        i = ndigits + k + 1;
        ilim = i;
        ilim1 = i - 1;
        if (i <= 0)
            i = 1;
    }
    // ilim is the maximum number of significant digits we want, based on k and ndigits.
    // ilim1 is the maximum number of significant digits we want, based on k and ndigits,
    // when it turns out that k was computed too high by one.
    s = buf;

    if (ilim >= 0 && ilim <= Quick_max && try_quick) {

        // Try to get by with floating-point arithmetic.

        i = 0;
        d2 = d;
        k0 = k;
        ilim0 = ilim;
        ieps = 2; // conservative
        // Divide d by 10^k, keeping track of the roundoff error and avoiding overflows.
        if (k > 0) {
            ds = tens[k&0xf];
            j = k >> 4;
            if (j & Bletch) {
                // prevent overflows
                j &= Bletch - 1;
                d /= bigtens[n_bigtens-1];
                ieps++;
            }
            for (; j; j >>= 1, i++)
                if (j & 1) {
                    ieps++;
                    ds *= bigtens[i];
                }
            d /= ds;
        }
        else if ((j1 = -k) != 0) {
            d *= tens[j1 & 0xf];
            for (j = j1 >> 4; j; j >>= 1, i++)
                if (j & 1) {
                    ieps++;
                    d *= bigtens[i];
                }
        }
        // Check that k was computed correctly.
        if (k_check && d < 1. && ilim > 0) {
            if (ilim1 <= 0)
                goto fast_failed;
            ilim = ilim1;
            k--;
            d *= 10.;
            ieps++;
        }
        // eps bounds the cumulative error.
        eps = ieps*d + 7.;
        word0(eps) -= (P-1)*Exp_msk1;
        if (ilim == 0) {
            d -= 5.;
            if (d > eps)
                goto one_digit;
            if (d < -eps)
                goto no_digits;
            goto fast_failed;
        }
#ifndef No_leftright
        if (leftright) {
            // Use Steele & White method of only generating digits needed.
            eps = 0.5/tens[ilim-1] - eps;
            for (i = 0;;) {
                L = (int32)d;
                d -= L;
                *s++ = char('0' + L);
                if (d < eps)
                    goto ret1;
                if (1. - d < eps)
                    goto bump_up;
                if (++i >= ilim)
                    break;
                eps *= 10.;
                d *= 10.;
            }
        }
        else {
#endif
            // Generate ilim digits, then fix them up.
            eps *= tens[ilim-1];
            for (i = 1;; i++, d *= 10.) {
                L = (int32)d;
                d -= L;
                *s++ = char('0' + L);
                if (i == ilim) {
                    if (d > 0.5 + eps)
                        goto bump_up;
                    else if (d < 0.5 - eps) {
                        while (*--s == '0') ;
                        s++;
                        goto ret1;
                    }
                    break;
                }
            }
#ifndef No_leftright
        }
#endif
      fast_failed:
        s = buf;
        d = d2;
        k = k0;
        ilim = ilim0;
    }

    // Do we have a "small" integer?

    if (be >= 0 && k <= Int_max) {
        // Yes.
        ds = tens[k];
        if (ndigits < 0 && ilim <= 0) {
            if (ilim < 0 || d < 5*ds || (!biasUp && d == 5*ds))
                goto no_digits;
	      one_digit:
	        *s++ = '1';
	        k++;
	        goto ret1;
        }
        for (i = 1;; i++) {
            L = (int32) (d / ds);
            d -= L*ds;
#ifdef Check_FLT_ROUNDS
            // If FLT_ROUNDS == 2, L will usually be high by 1
            if (d < 0) {
                L--;
                d += ds;
            }
#endif
            *s++ = char('0' + L);
            if (i == ilim) {
                d += d;
                if ((d > ds) || (d == ds && (L & 1 || biasUp))) {
                  bump_up:
                    while (*--s == '9')
                        if (s == buf) {
                            k++;
                            *s = '0';
                            break;
                        }
                    ++*s++;
                }
                break;
            }
            if (!(d *= 10.))
                break;
        }
        goto ret1;
    }

    {
	    m2 = b2;
	    m5 = b5;
	    BigInt mLow;	// If spec_case is false, assume that mLow == mHigh
	    BigInt mHigh;

	    if (leftright) {
	        if (mode < 2) {
	            i =
#ifndef Sudden_Underflow
	                denorm ? be + (Bias + (P-1) - 1 + 1) :
#endif
	            1 + P - bbits;
	            // i is 1 plus the number of trailing zero bits in d's significand. Thus,
	            // (2^m2 * 5^m5) / (2^(s2+i) * 5^s5) = (1/2 lsb of d)/10^k.
	        }
	        else {
	            j = ilim - 1;
	            if (m5 >= j)
	                m5 -= j;
	            else {
	                s5 += j -= m5;
	                b5 += j;
	                m5 = 0;
	            }
	            if ((i = ilim) < 0) {
	                m2 -= i;
	                i = 0;
	            }
	            // (2^m2 * 5^m5) / (2^(s2+i) * 5^s5) = (1/2 * 10^(1-ilim))/10^k.
	        }
	        b2 += i;
	        s2 += i;
	        mHigh.init(1);
	        // (mHigh * 2^m2 * 5^m5) / (2^s2 * 5^s5) = one-half of last printed (when mode >= 2) or
	        // input (when mode < 2) significant digit, divided by 10^k.
	    }
	    // We still have d/10^k = (b * 2^b2 * 5^b5) / (2^s2 * 5^s5).  Reduce common factors in
	    // b2, m2, and s2 without changing the equalities.
	    if (m2 > 0 && s2 > 0) {
	        i = m2 < s2 ? m2 : s2;
	        b2 -= i;
	        m2 -= i;
	        s2 -= i;
	    }

	    // Fold b5 into b and m5 into mHigh.
	    if (b5 > 0) {
	        if (leftright) {
	            if (m5 > 0) {
	                mHigh.pow5Mul(m5);
	                b *= mHigh;
	            }
	            if ((j = b5 - m5) != 0)
	                b.pow5Mul(j);
	        }
	        else
	            b.pow5Mul(b5);
	    }
	    // Now we have d/10^k = (b * 2^b2) / (2^s2 * 5^s5) and
	    // (mHigh * 2^m2) / (2^s2 * 5^s5) = one-half of last printed or input significant digit, divided by 10^k.

	    BigInt S;
	    S.init(1);
	    if (s5 > 0)
	        S.pow5Mul(s5);
	    // Now we have d/10^k = (b * 2^b2) / (S * 2^s2) and
	    // (mHigh * 2^m2) / (S * 2^s2) = one-half of last printed or input significant digit, divided by 10^k.

	    // Check for special case that d is a normalized power of 2.
	    bool spec_case = false;
	    if (mode < 2) {
	        if (!word1(d) && !(word0(d) & Bndry_mask)
#ifndef Sudden_Underflow
	            && word0(d) & (Exp_mask & Exp_mask << 1)
#endif
	            ) {
	            // The special case.  Here we want to be within a quarter of the last input
	            // significant digit instead of one half of it when the decimal output string's value is less than d.
	            b2 += Log2P;
	            s2 += Log2P;
	            spec_case = true;
	        }
	    }

	    // Arrange for convenient computation of quotients:
	    // shift left if necessary so divisor has 4 leading 0 bits.
	    //
	    // Perhaps we should just compute leading 28 bits of S once
	    // and for all and pass them and a shift to quoRem, so it
	    // can do shifts and ors to compute the numerator for q.
	    if ((i = ((s5 ? 32 - hi0bits(S.word(S.nWords()-1)) : 1) + s2) & 0x1f) != 0)
	        i = 32 - i;
	    // i is the number of leading zero bits in the most significant word of S*2^s2.
	    if (i > 4) {
	        i -= 4;
	        b2 += i;
	        m2 += i;
	        s2 += i;
	    }
	    else if (i < 4) {
	        i += 28;
	        b2 += i;
	        m2 += i;
	        s2 += i;
	    }
	    // Now S*2^s2 has exactly four leading zero bits in its most significant word.
	    if (b2 > 0)
	        b.pow2Mul(b2);
	    if (s2 > 0)
	        S.pow2Mul(s2);
	    // Now we have d/10^k = b/S and
	    // (mHigh * 2^m2) / S = maximum acceptable error, divided by 10^k.
	    if (k_check) {
	        if (b.cmp(S) < 0) {
	            k--;
	            b.mulAdd(10, 0);  // we botched the k estimate
	            if (leftright)
	                mHigh.mulAdd(10, 0);
	            ilim = ilim1;
	        }
	    }
	    // At this point 1 <= d/10^k = b/S < 10.

	    if (ilim <= 0 && mode > 2) {
	        // We're doing fixed-mode output and d is less than the minimum nonzero output in this mode.
	        // Output either zero or the minimum nonzero output depending on which is closer to d.
	        // Always emit at least one digit.  If the number appears to be zero
	        // using the current mode, then emit one '0' digit and set decpt to 1.
	        if (ilim < 0)
	            goto no_digits;
	        S.mulAdd(5, 0);
	        if ((i = b.cmp(S)) < 0 || (i == 0 && !biasUp))
	            goto no_digits;
	        goto one_digit;
	    }
	    if (leftright) {
	        if (m2 > 0)
	            mHigh.pow2Mul(m2);

	        // Compute mLow -- check for special case that d is a normalized power of 2.
	        if (spec_case) {
	        	mLow = mHigh;
	            mHigh.pow2Mul(Log2P);
	        }
	        // mLow/S = maximum acceptable error, divided by 10^k, if the output is less than d.
	        // mHigh/S = maximum acceptable error, divided by 10^k, if the output is greater than d.

	        for (i = 1;;i++) {
	            dig = b.quoRem(S) + '0';
	            // Do we yet have the shortest decimal string that will round to d?
	            j = b.cmp(spec_case ? mLow : mHigh);
	            // j is b/S compared with mLow/S.
                {
                	BigInt delta;
		            delta.initDiff(S, mHigh);
		            j1 = delta.negative ? 1 : b.cmp(delta);
	            }
	            // j1 is b/S compared with 1 - mHigh/S.
#ifndef ROUND_BIASED
	            if (j1 == 0 && !mode && !(word1(d) & 1)) {
	                if (dig == '9')
	                    goto round_9_up;
	                if (j > 0)
	                    dig++;
	                *s++ = (char)dig;
	                goto ret;
	            }
#endif
	            if ((j < 0) || (j == 0 && !mode
#ifndef ROUND_BIASED
	                && !(word1(d) & 1)
#endif
	                )) {
	                if (j1 > 0) {
	                    // Either dig or dig+1 would work here as the least significant decimal digit.
	                    // Use whichever would produce a decimal value closer to d.
	                    b.pow2Mul(1);
	                    j1 = b.cmp(S);
	                    if (((j1 > 0) || (j1 == 0 && (dig & 1 || biasUp)))
	                        && (dig++ == '9'))
	                        goto round_9_up;
	                }
	                *s++ = (char)dig;
	                goto ret;
	            }
	            if (j1 > 0) {
	                if (dig == '9') { // possible if i == 1
	                  round_9_up:
	                    *s++ = '9';
	                    goto roundoff;
	                }
	                *s++ = char(dig + 1);
	                goto ret;
	            }
	            *s++ = (char)dig;
	            if (i == ilim)
	                break;
	            b.mulAdd(10, 0);
	            if (spec_case)
	                mLow.mulAdd(10, 0);
	            mHigh.mulAdd(10, 0);
	        }
	    }
	    else
	        for (i = 1;; i++) {
	            *s++ = (char)(dig = b.quoRem(S) + '0');
	            if (i >= ilim)
	                break;
	            b.mulAdd(10, 0);
	        }

	    // Round off last digit

	    b.pow2Mul(1);
	    j = b.cmp(S);
	    if ((j > 0) || (j == 0 && (dig & 1 || biasUp))) {
	      roundoff:
	        while (*--s == '9')
	            if (s == buf) {
	                k++;
	                *s++ = '1';
	                goto ret;
	            }
	        ++*s++;
	    }
	    else {
	        // Strip trailing zeros
	        while (*--s == '0') ;
	        s++;
	    }
	  ret: ;
		// S, mLow, and mHigh are destroyed at the end of this block scope.
    }
  ret1:
    *s = '\0';
    *decpt = k + 1;
    return s;
}


// Mapping of DToStrMode -> doubleToAscii mode
static const int doubleToAsciiModes[] = {
    0,   // dtosStandard
    0,   // dtosStandardExponential
    3,   // dtosFixed
    2,   // dtosExponential
    2};  // dtosPrecision


// Convert value according to the given mode and return a pointer to the resulting ASCII string.
// The result is held somewhere in buffer, but not necessarily at the beginning.  The size of
// buffer is given in bufferSize, and must be at least as large as given by dtosStandardBufferSize
// or dtosVariableBufferSize, whichever is appropriate.
char *JS::doubleToStr(char *buffer, size_t DEBUG_ONLY(bufferSize), double value, DToStrMode mode, int precision)
{
    int decPt;                  // Position of decimal point relative to first digit returned by doubleToAscii
    bool negative;              // True if the sign bit was set in value
    int nDigits;                // Number of significand digits returned by doubleToAscii
    char *numBegin = buffer+2;  // Pointer to the digits returned by doubleToAscii; the +2 leaves space for
                                // the sign and/or decimal point
    char *numEnd;               // Pointer past the digits returned by doubleToAscii

    ASSERT(bufferSize >= (size_t)(mode <= dtosStandardExponential ? dtosStandardBufferSize : dtosVariableBufferSize(precision)));

    if (mode == dtosFixed && (value >= 1e21 || value <= -1e21))
        mode = dtosStandard; 	// Change mode here rather than below because the buffer may not be large enough to hold a large integer.

    numEnd = doubleToAscii(value, doubleToAsciiModes[mode], mode >= dtosFixed, precision, &decPt, &negative, numBegin);
    nDigits = numEnd - numBegin;

    // If Infinity, -Infinity, or NaN, return the string regardless of the mode.
    if (decPt != 9999) {
        bool exponentialNotation = false;
        int minNDigits = 0;         // Minimum number of significand digits required by mode and precision
        char *p;
        char *q;

        switch (mode) {
          case dtosStandard:
            if (decPt < -5 || decPt > 21)
                exponentialNotation = true;
            else
                minNDigits = decPt;
            break;

          case dtosFixed:
            if (precision >= 0)
                minNDigits = decPt + precision;
            else
                minNDigits = decPt;
            break;

          case dtosExponential:
            ASSERT(precision > 0);
            minNDigits = precision;
            // Fall through
          case dtosStandardExponential:
            exponentialNotation = true;
            break;

          case dtosPrecision:
            ASSERT(precision > 0);
            minNDigits = precision;
            if (decPt < -5 || decPt > precision)
                exponentialNotation = true;
            break;
        }

        // If the number has fewer than minNDigits, pad it with zeros at the end
        if (nDigits < minNDigits) {
            p = numBegin + minNDigits;
            nDigits = minNDigits;
            do {
                *numEnd++ = '0';
            } while (numEnd != p);
            *numEnd = '\0';
        }
        
        if (exponentialNotation) {
            // Insert a decimal point if more than one significand digit
            if (nDigits != 1) {
                numBegin--;
                numBegin[0] = numBegin[1];
                numBegin[1] = '.';
            }
            sprintf(numEnd, "e%+d", decPt-1);
        } else if (decPt != nDigits) {
            // Some kind of a fraction in fixed notation
            ASSERT(decPt <= nDigits);
            if (decPt > 0) {
                // dd...dd . dd...dd
                p = --numBegin;
                do {
                    *p = p[1];
                    p++;
                } while (--decPt);
                *p = '.';
            } else {
                // 0 . 00...00dd...dd
                p = numEnd;
                numEnd += 1 - decPt;
                q = numEnd;
                ASSERT(numEnd < buffer + bufferSize);
                *numEnd = '\0';
                while (p != numBegin)
                    *--q = *--p;
                for (p = numBegin + 1; p != q; p++)
                    *p = '0';
                *numBegin = '.';
                *--numBegin = '0';
            }
        }
    }

    // If negative and neither -0.0 nor NaN, output a leading '-'.
    if (negative &&
            !(word0(value) == Sign_bit && word1(value) == 0) &&
            !((word0(value) & Exp_mask) == Exp_mask &&
              (word1(value) || (word0(value) & Frac_mask)))) {
        *--numBegin = '-';
    }
    return numBegin;
}


inline char baseDigit(uint32 digit)
{
	if (digit >= 10)
		return char('a' - 10 + digit);
	else
		return char('0' + digit);
}


// Convert value to a string in the given base.  The integral part of value will be printed exactly
// in that base, regardless of how large it is, because there is no exponential notation for non-base-ten
// numbers.  The fractional part will be rounded to as few digits as possible while still preserving
// the round-trip property (analogous to that of printing decimal numbers).  In other words, if one were
// to read the resulting string in via a hypothetical base-number-reading routine that rounds to the nearest
// IEEE double (and to an even significand if there are two equally near doubles), then the result would
// equal value (except for -0.0, which converts to "0", and NaN, which is not equal to itself).
//
// Store the result in the given buffer, which must have at least dtobasesBufferSize bytes.
// Return the number of characters stored.
size_t JS::doubleToBaseStr(char *buffer, double value, uint base)
{
    ASSERT(base >= 2 && base <= 36);

    char *p = buffer;		// Pointer to current position in the buffer
    if (value < 0.0
#ifdef _WIN32
        && !((word0(value) & Exp_mask) == Exp_mask && ((word0(value) & Frac_mask) || word1(value))) // Visual C++ doesn't know how to compare against NaN
#endif
       ) {
        *p++ = '-';
        value = -value;
    }

    // Check for Infinity and NaN
    if ((word0(value) & Exp_mask) == Exp_mask) {
        strcpy(p, !word1(value) && !(word0(value) & Frac_mask) ? "Infinity" : "NaN");
        return strlen(buffer);
    }

    // Output the integer part of value with the digits in reverse order.
    char *pInt = p;					// Pointer to the beginning of the integer part of the string
    double valueInt = floor(value);	// value truncated to an integer
    uint32 digit;
    if (valueInt <= 4294967295.0) {
        uint32 n = (uint32)valueInt;
        if (n)
            do {
                uint32 m = n / base;
                digit = n - m*base;
                n = m;
                ASSERT(digit < base);
                *p++ = baseDigit(digit);
            } while (n);
        else *p++ = '0';
    } else {
        int32 e;
        int32 bits;  // Number of significant bits in valueInt; not used.
        BigInt b;
        b.init(valueInt, e, bits);
        b.pow2Mul(e);
        do {
            digit = b.divRem(base);
            ASSERT(digit < base);
            *p++ = baseDigit(digit);
        } while (!b.isZero());
    }
    // Reverse the digits of the integer part of value.
    char *q = p-1;
    while (q > pInt) {
        char ch = *pInt;
        *pInt++ = *q;
        *q-- = ch;
    }
    
    double valueFrac = value - valueInt;		// The fractional part of value
    if (valueFrac != 0.0) {
        // We have a fraction.
        *p++ = '.';

        int32 e, bbits;
        BigInt b;
        b.init(valueFrac, e, bbits);
        ASSERT(e < 0);
        // At this point valueFrac = b * 2^e.  e must be less than zero because 0 < valueFrac < 1.
        
        int32 s2 = -int32(word0(value) >> Exp_shift1 & Exp_mask>>Exp_shift1);
#ifndef Sudden_Underflow
        if (!s2)
            s2 = -1;
#endif
        s2 += Bias + P;
        // 1/2^s2 = (nextDouble(value) - value)/2
        ASSERT(-s2 < e);

        BigInt mLow;
        BigInt mHigh;
        bool useMHigh = false;	// If false, assume that mHigh == mLow

        mLow.init(1);
        if (!word1(value) && !(word0(value) & Bndry_mask)
#ifndef Sudden_Underflow
            && word0(value) & (Exp_mask & Exp_mask << 1)
#endif
            ) {
            // The special case.  Here we want to be within a quarter of the last input
            // significant digit instead of one half of it when the output string's value is less than value.
            s2 += Log2P;
            useMHigh = true;
            mHigh.init(1u<<Log2P);
        }
        b.pow2Mul(e + s2);

        BigInt s;
        s.init(1);
        s.pow2Mul(s2);

        // At this point we have the following:
        //   s = 2^s2;
        //   1 > valueFrac = b/2^s2 > 0;
        //   (value - prevDouble(value))/2 = mLow/2^s2;
        //   (nextDouble(value) - value)/2 = mHigh/2^s2.

        bool done = false;
        do {
            int32 j, j1;

            b.mulAdd(base, 0);
            digit = b.quoRem2(s2);
            mLow.mulAdd(base, 0);
            if (useMHigh)
                mHigh.mulAdd(base, 0);

            // Do we yet have the shortest string that will round to value?
            j = b.cmp(mLow);
            // j is b/2^s2 compared with mLow/2^s2.
            {
            	BigInt delta;
                delta.initDiff(s, useMHigh ? mHigh : mLow);
                j1 = delta.negative ? 1 : b.cmp(delta);
            }
            // j1 is b/2^s2 compared with 1 - mHigh/2^s2.

#ifndef ROUND_BIASED
            if (j1 == 0 && !(word1(value) & 1)) {
                if (j > 0)
                    digit++;
                done = true;
            } else
#endif
            if (j < 0 || (j == 0
#ifndef ROUND_BIASED
                && !(word1(value) & 1)
#endif
                )) {
                if (j1 > 0) {
                    // Either dig or dig+1 would work here as the least significant digit.
                    // Use whichever would produce an output value closer to value.
                    b.pow2Mul(1);
                    j1 = b.cmp(s);
                    if (j1 > 0) // The even test (|| (j1 == 0 && (digit & 1))) is not here because it messes up odd base output
                                // such as 3.5 in base 3.
                        digit++;
                }
                done = true;
            } else if (j1 > 0) {
                digit++;
                done = true;
            }
            ASSERT(digit < base);
            *p++ = baseDigit(digit);
        } while (!done);
    }
    ASSERT(p < buffer + dtobasesBufferSize);
    *p = '\0';
    return size_t(p - buffer);
}


// A version of doubleToStr that appends to the end of String dst.
// precision should not exceed 101.
void JS::appendDouble(String &dst, double value, DToStrMode mode, int precision)
{
	char buffer[dtosVariableBufferSize(101)];
	ASSERT(uint(precision) <= 101);
	
	dst += doubleToStr(buffer, sizeof buffer, value, mode, precision);
}


// A version of doubleToStr that prints to Formatter f.
// precision should not exceed 101.
void JS::printDouble(Formatter &f, double value, DToStrMode mode, int precision)
{
	char buffer[dtosVariableBufferSize(101)];
	ASSERT(uint(precision) <= 101);
	
	f << doubleToStr(buffer, sizeof buffer, value, mode, precision);
}