duk_numconv.h File Reference

Go to the source code of this file.

Macros
#define	DUK_N2S_FLAG_FIXED_FORMAT   (1 << 0)
#define	DUK_N2S_FLAG_FORCE_EXP   (1 << 1)
#define	DUK_N2S_FLAG_NO_ZERO_PAD   (1 << 2)
#define	DUK_N2S_FLAG_FRACTION_DIGITS   (1 << 3)
#define	DUK_S2N_MAX_EXPONENT   1000000000
#define	DUK_S2N_FLAG_TRIM_WHITE   (1 << 0)
#define	DUK_S2N_FLAG_ALLOW_EXP   (1 << 1)
#define	DUK_S2N_FLAG_ALLOW_GARBAGE   (1 << 2)
#define	DUK_S2N_FLAG_ALLOW_PLUS   (1 << 3)
#define	DUK_S2N_FLAG_ALLOW_MINUS   (1 << 4)
#define	DUK_S2N_FLAG_ALLOW_INF   (1 << 5)
#define	DUK_S2N_FLAG_ALLOW_FRAC   (1 << 6)
#define	DUK_S2N_FLAG_ALLOW_NAKED_FRAC   (1 << 7)
#define	DUK_S2N_FLAG_ALLOW_EMPTY_FRAC   (1 << 8)
#define	DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO   (1 << 9)
#define	DUK_S2N_FLAG_ALLOW_LEADING_ZERO   (1 << 10)
#define	DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT   (1 << 11)
#define	DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT   (1 << 12)

Functions
DUK_INTERNAL_DECL void	duk_numconv_stringify (duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags)
DUK_INTERNAL_DECL void	duk_numconv_parse (duk_context *ctx, duk_small_int_t radix, duk_small_uint_t flags)

Macro Definition Documentation

DUK_N2S_FLAG_FIXED_FORMAT

#define DUK_N2S_FLAG_FIXED_FORMAT   (1 << 0)

Definition at line 12 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_N2S_FLAG_FORCE_EXP

#define DUK_N2S_FLAG_FORCE_EXP   (1 << 1)

Definition at line 15 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_N2S_FLAG_FRACTION_DIGITS

#define DUK_N2S_FLAG_FRACTION_DIGITS   (1 << 3)

Definition at line 28 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_N2S_FLAG_NO_ZERO_PAD

#define DUK_N2S_FLAG_NO_ZERO_PAD   (1 << 2)

Definition at line 22 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT

#define DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT   (1 << 11)

Definition at line 76 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT

#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT   (1 << 12)

Definition at line 81 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO

#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO   (1 << 9)

Definition at line 68 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_EMPTY_FRAC

#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC   (1 << 8)

Definition at line 65 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_EXP

#define DUK_S2N_FLAG_ALLOW_EXP   (1 << 1)

Definition at line 44 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_FRAC

#define DUK_S2N_FLAG_ALLOW_FRAC   (1 << 6)

Definition at line 59 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_GARBAGE

#define DUK_S2N_FLAG_ALLOW_GARBAGE   (1 << 2)

Definition at line 47 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_INF

#define DUK_S2N_FLAG_ALLOW_INF   (1 << 5)

Definition at line 56 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_LEADING_ZERO

#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO   (1 << 10)

Definition at line 71 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_MINUS

#define DUK_S2N_FLAG_ALLOW_MINUS   (1 << 4)

Definition at line 53 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_NAKED_FRAC

#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC   (1 << 7)

Definition at line 62 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_ALLOW_PLUS

#define DUK_S2N_FLAG_ALLOW_PLUS   (1 << 3)

Definition at line 50 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_FLAG_TRIM_WHITE

#define DUK_S2N_FLAG_TRIM_WHITE   (1 << 0)

Definition at line 41 of file duktape-1.5.2/src-separate/duk_numconv.h.

DUK_S2N_MAX_EXPONENT

#define DUK_S2N_MAX_EXPONENT   1000000000

Definition at line 38 of file duktape-1.5.2/src-separate/duk_numconv.h.

Function Documentation

duk_numconv_parse()

DUK_INTERNAL_DECL void duk_numconv_parse	(	duk_context *	ctx,
		duk_small_int_t	radix,
		duk_small_uint_t	flags )

Definition at line 76728 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk__numconv_stringify_ctx nc_ctx_alloc;  /* large context; around 2kB now */
    duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc;
    duk_double_t res;
    duk_hstring *h_str;
    duk_small_int_t expt;
    duk_small_int_t expt_neg;
    duk_small_int_t expt_adj;
    duk_small_int_t neg;
    duk_small_int_t dig;
    duk_small_int_t dig_whole;
    duk_small_int_t dig_lzero;
    duk_small_int_t dig_frac;
    duk_small_int_t dig_expt;
    duk_small_int_t dig_prec;
    const duk__exp_limits *explim;
    const duk_uint8_t *p;
    duk_small_int_t ch;
 
    /* This seems to waste a lot of stack frame entries, but good compilers
     * will compute these as needed below.  Some of these initial flags are
     * also modified in the code below, so they can't all be removed.
     */
    duk_small_int_t trim_white = (flags & DUK_S2N_FLAG_TRIM_WHITE);
    duk_small_int_t allow_expt = (flags & DUK_S2N_FLAG_ALLOW_EXP);
    duk_small_int_t allow_garbage = (flags & DUK_S2N_FLAG_ALLOW_GARBAGE);
    duk_small_int_t allow_plus = (flags & DUK_S2N_FLAG_ALLOW_PLUS);
    duk_small_int_t allow_minus = (flags & DUK_S2N_FLAG_ALLOW_MINUS);
    duk_small_int_t allow_infinity = (flags & DUK_S2N_FLAG_ALLOW_INF);
    duk_small_int_t allow_frac = (flags & DUK_S2N_FLAG_ALLOW_FRAC);
    duk_small_int_t allow_naked_frac = (flags & DUK_S2N_FLAG_ALLOW_NAKED_FRAC);
    duk_small_int_t allow_empty_frac = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_FRAC);
    duk_small_int_t allow_empty = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO);
    duk_small_int_t allow_leading_zero = (flags & DUK_S2N_FLAG_ALLOW_LEADING_ZERO);
    duk_small_int_t allow_auto_hex_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT);
    duk_small_int_t allow_auto_oct_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT);
 
    DUK_DDD(DUK_DDDPRINT("parse number: %!T, radix=%ld, flags=0x%08lx",
                         (duk_tval *) duk_get_tval(ctx, -1),
                         (long) radix, (unsigned long) flags));
 
    DUK_ASSERT(radix >= 2 && radix <= 36);
    DUK_ASSERT(radix - 2 < (duk_small_int_t) sizeof(duk__str2num_digits_for_radix));
 
    /*
     *  Preliminaries: trim, sign, Infinity check
     *
     *  We rely on the interned string having a NUL terminator, which will
     *  cause a parse failure wherever it is encountered.  As a result, we
     *  don't need separate pointer checks.
     *
     *  There is no special parsing for 'NaN' in the specification although
     *  'Infinity' (with an optional sign) is allowed in some contexts.
     *  Some contexts allow plus/minus sign, while others only allow the
     *  minus sign (like JSON.parse()).
     *
     *  Automatic hex number detection (leading '0x' or '0X') and octal
     *  number detection (leading '0' followed by at least one octal digit)
     *  is done here too.
     */
 
    if (trim_white) {
        /* Leading / trailing whitespace is sometimes accepted and
         * sometimes not.  After white space trimming, all valid input
         * characters are pure ASCII.
         */
        duk_trim(ctx, -1);
    }
    h_str = duk_require_hstring(ctx, -1);
    DUK_ASSERT(h_str != NULL);
    p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_str);
 
    neg = 0;
    ch = *p;
    if (ch == (duk_small_int_t) '+') {
        if (!allow_plus) {
            DUK_DDD(DUK_DDDPRINT("parse failed: leading plus sign not allowed"));
            goto parse_fail;
        }
        p++;
    } else if (ch == (duk_small_int_t) '-') {
        if (!allow_minus) {
            DUK_DDD(DUK_DDDPRINT("parse failed: leading minus sign not allowed"));
            goto parse_fail;
        }
        p++;
        neg = 1;
    }
 
    ch = *p;
    if (allow_infinity && ch == (duk_small_int_t) 'I') {
        /* Don't check for Infinity unless the context allows it.
         * 'Infinity' is a valid integer literal in e.g. base-36:
         *
         *   parseInt('Infinity', 36)
         *   1461559270678
         */
 
        const duk_uint8_t *q;
 
        /* borrow literal Infinity from builtin string */
        q = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(DUK_HTHREAD_STRING_INFINITY(thr));
        if (DUK_STRNCMP((const char *) p, (const char *) q, 8) == 0) {
            if (!allow_garbage && (p[8] != (duk_uint8_t) 0)) {
                DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage after matching 'Infinity' not allowed"));
                goto parse_fail;
            } else {
                res = DUK_DOUBLE_INFINITY;
                goto negcheck_and_ret;
            }
        }
    }
    if (ch == (duk_small_int_t) '0') {
        duk_small_int_t detect_radix = 0;
        ch = p[1];
        if (allow_auto_hex_int && (ch == (duk_small_int_t) 'x' || ch == (duk_small_int_t) 'X')) {
            DUK_DDD(DUK_DDDPRINT("detected 0x/0X hex prefix, changing radix and preventing fractions and exponent"));
            detect_radix = 16;
            allow_empty = 0;  /* interpret e.g. '0x' and '0xg' as a NaN (= parse error) */
            p += 2;
        } else if (allow_auto_oct_int && (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9')) {
            DUK_DDD(DUK_DDDPRINT("detected 0n oct prefix, changing radix and preventing fractions and exponent"));
            detect_radix = 8;
            allow_empty = 1;  /* interpret e.g. '09' as '0', not NaN */
            p += 1;
        }
        if (detect_radix > 0) {
            radix = detect_radix;
            allow_expt = 0;
            allow_frac = 0;
            allow_naked_frac = 0;
            allow_empty_frac = 0;
            allow_leading_zero = 1;  /* allow e.g. '0x0009' and '00077' */
        }
    }
 
    /*
     *  Scan number and setup for Dragon4.
     *
     *  The fast path case is detected during setup: an integer which
     *  can be converted without rounding, no net exponent.  The fast
     *  path could be implemented as a separate scan, but may not really
     *  be worth it: the multiplications for building 'f' are not
     *  expensive when 'f' is small.
     *
     *  The significand ('f') must contain enough bits of (apparent)
     *  accuracy, so that Dragon4 will generate enough binary output digits.
     *  For decimal numbers, this means generating a 20-digit significand,
     *  which should yield enough practical accuracy to parse IEEE doubles.
     *  In fact, the Ecmascript specification explicitly allows an
     *  implementation to treat digits beyond 20 as zeroes (and even
     *  to round the 20th digit upwards).  For non-decimal numbers, the
     *  appropriate number of digits has been precomputed for comparable
     *  accuracy.
     *
     *  Digit counts:
     *
     *    [ dig_lzero ]
     *      |
     *     .+-..---[ dig_prec ]----.
     *     |  ||                   |
     *     0000123.456789012345678901234567890e+123456
     *     |     | |                         |  |    |
     *     `--+--' `------[ dig_frac ]-------'  `-+--'
     *        |                                   |
     *    [ dig_whole ]                       [ dig_expt ]
     *
     *    dig_frac and dig_expt are -1 if not present
     *    dig_lzero is only computed for whole number part
     *
     *  Parsing state
     *
     *     Parsing whole part      dig_frac < 0 AND dig_expt < 0
     *     Parsing fraction part   dig_frac >= 0 AND dig_expt < 0
     *     Parsing exponent part   dig_expt >= 0   (dig_frac may be < 0 or >= 0)
     *
     *  Note: in case we hit an implementation limit (like exponent range),
     *  we should throw an error, NOT return NaN or Infinity.  Even with
     *  very large exponent (or significand) values the final result may be
     *  finite, so NaN/Infinity would be incorrect.
     */
 
    duk__bi_set_small(&nc_ctx->f, 0);
    dig_prec = 0;
    dig_lzero = 0;
    dig_whole = 0;
    dig_frac = -1;
    dig_expt = -1;
    expt = 0;
    expt_adj = 0;  /* essentially tracks digit position of lowest 'f' digit */
    expt_neg = 0;
    for (;;) {
        ch = *p++;
 
        DUK_DDD(DUK_DDDPRINT("parse digits: p=%p, ch='%c' (%ld), expt=%ld, expt_adj=%ld, "
                             "dig_whole=%ld, dig_frac=%ld, dig_expt=%ld, dig_lzero=%ld, dig_prec=%ld",
                             (const void *) p, (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : '?'), (long) ch,
                             (long) expt, (long) expt_adj, (long) dig_whole, (long) dig_frac,
                             (long) dig_expt, (long) dig_lzero, (long) dig_prec));
        DUK__BI_PRINT("f", &nc_ctx->f);
 
        /* Most common cases first. */
        if (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9') {
            dig = (int) ch - '0' + 0;
        } else if (ch == (duk_small_int_t) '.') {
            /* A leading digit is not required in some cases, e.g. accept ".123".
             * In other cases (JSON.parse()) a leading digit is required.  This
             * is checked for after the loop.
             */
            if (dig_frac >= 0 || dig_expt >= 0) {
                if (allow_garbage) {
                    DUK_DDD(DUK_DDDPRINT("garbage termination (invalid period)"));
                    break;
                } else {
                    DUK_DDD(DUK_DDDPRINT("parse failed: period not allowed"));
                    goto parse_fail;
                }
            }
 
            if (!allow_frac) {
                /* Some contexts don't allow fractions at all; this can't be a
                 * post-check because the state ('f' and expt) would be incorrect.
                 */
                if (allow_garbage) {
                    DUK_DDD(DUK_DDDPRINT("garbage termination (invalid first period)"));
                    break;
                } else {
                    DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed"));
                }
            }
 
            DUK_DDD(DUK_DDDPRINT("start fraction part"));
            dig_frac = 0;
            continue;
        } else if (ch == (duk_small_int_t) 0) {
            DUK_DDD(DUK_DDDPRINT("NUL termination"));
            break;
        } else if (allow_expt && dig_expt < 0 && (ch == (duk_small_int_t) 'e' || ch == (duk_small_int_t) 'E')) {
            /* Note: we don't parse back exponent notation for anything else
             * than radix 10, so this is not an ambiguous check (e.g. hex
             * exponent values may have 'e' either as a significand digit
             * or as an exponent separator).
             *
             * If the exponent separator occurs twice, 'e' will be interpreted
             * as a digit (= 14) and will be rejected as an invalid decimal
             * digit.
             */
 
            DUK_DDD(DUK_DDDPRINT("start exponent part"));
 
            /* Exponent without a sign or with a +/- sign is accepted
             * by all call sites (even JSON.parse()).
             */
            ch = *p;
            if (ch == (duk_small_int_t) '-') {
                expt_neg = 1;
                p++;
            } else if (ch == (duk_small_int_t) '+') {
                p++;
            }
            dig_expt = 0;
            continue;
        } else if (ch >= (duk_small_int_t) 'a' && ch <= (duk_small_int_t) 'z') {
            dig = (duk_small_int_t) (ch - (duk_small_int_t) 'a' + 0x0a);
        } else if (ch >= (duk_small_int_t) 'A' && ch <= (duk_small_int_t) 'Z') {
            dig = (duk_small_int_t) (ch - (duk_small_int_t) 'A' + 0x0a);
        } else {
            dig = 255;  /* triggers garbage digit check below */
        }
        DUK_ASSERT((dig >= 0 && dig <= 35) || dig == 255);
 
        if (dig >= radix) {
            if (allow_garbage) {
                DUK_DDD(DUK_DDDPRINT("garbage termination"));
                break;
            } else {
                DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage or invalid digit"));
                goto parse_fail;
            }
        }
 
        if (dig_expt < 0) {
            /* whole or fraction digit */
 
            if (dig_prec < duk__str2num_digits_for_radix[radix - 2]) {
                /* significant from precision perspective */
 
                duk_small_int_t f_zero = duk__bi_is_zero(&nc_ctx->f);
                if (f_zero && dig == 0) {
                    /* Leading zero is not counted towards precision digits; not
                     * in the integer part, nor in the fraction part.
                     */
                    if (dig_frac < 0) {
                        dig_lzero++;
                    }
                } else {
                    /* XXX: join these ops (multiply-accumulate), but only if
                     * code footprint decreases.
                     */
                    duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, radix);
                    duk__bi_add_small(&nc_ctx->f, &nc_ctx->t1, dig);
                    dig_prec++;
                }
            } else {
                /* Ignore digits beyond a radix-specific limit, but note them
                 * in expt_adj.
                 */
                expt_adj++;
            }
 
            if (dig_frac >= 0) {
                dig_frac++;
                expt_adj--;
            } else {
                dig_whole++;
            }
        } else {
            /* exponent digit */
 
            expt = expt * radix + dig;
            if (expt > DUK_S2N_MAX_EXPONENT) {
                /* impose a reasonable exponent limit, so that exp
                 * doesn't need to get tracked using a bigint.
                 */
                DUK_DDD(DUK_DDDPRINT("parse failed: exponent too large"));
                goto parse_explimit_error;
            }
            dig_expt++;
        }
    }
 
    /* Leading zero. */
 
    if (dig_lzero > 0 && dig_whole > 1) {
        if (!allow_leading_zero) {
            DUK_DDD(DUK_DDDPRINT("parse failed: leading zeroes not allowed in integer part"));
            goto parse_fail;
        }
    }
 
    /* Validity checks for various fraction formats ("0.1", ".1", "1.", "."). */
 
    if (dig_whole == 0) {
        if (dig_frac == 0) {
            /* "." is not accepted in any format */
            DUK_DDD(DUK_DDDPRINT("parse failed: plain period without leading or trailing digits"));
            goto parse_fail;
        } else if (dig_frac > 0) {
            /* ".123" */
            if (!allow_naked_frac) {
                DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed without "
                                     "leading integer digit(s)"));
                goto parse_fail;
            }
        } else {
            /* empty ("") is allowed in some formats (e.g. Number(''), as zero */
            if (!allow_empty) {
                DUK_DDD(DUK_DDDPRINT("parse failed: empty string not allowed (as zero)"));
                goto parse_fail;
            }
        }
    } else {
        if (dig_frac == 0) {
            /* "123." is allowed in some formats */
            if (!allow_empty_frac) {
                DUK_DDD(DUK_DDDPRINT("parse failed: empty fractions"));
                goto parse_fail;
            }
        } else if (dig_frac > 0) {
            /* "123.456" */
            ;
        } else {
            /* "123" */
            ;
        }
    }
 
    /* Exponent without digits (e.g. "1e" or "1e+").  If trailing garbage is
     * allowed, ignore exponent part as garbage (= parse as "1", i.e. exp 0).
     */
 
    if (dig_expt == 0) {
        if (!allow_garbage) {
            DUK_DDD(DUK_DDDPRINT("parse failed: empty exponent"));
            goto parse_fail;
        }
        DUK_ASSERT(expt == 0);
    }
 
    if (expt_neg) {
        expt = -expt;
    }
    DUK_DDD(DUK_DDDPRINT("expt=%ld, expt_adj=%ld, net exponent -> %ld",
                         (long) expt, (long) expt_adj, (long) (expt + expt_adj)));
    expt += expt_adj;
 
    /* Fast path check. */
 
    if (nc_ctx->f.n <= 1 &&   /* 32-bit value */
        expt == 0    /* no net exponent */) {
        /* Fast path is triggered for no exponent and also for balanced exponent
         * and fraction parts, e.g. for "1.23e2" == "123".  Remember to respect
         * zero sign.
         */
 
        /* XXX: could accept numbers larger than 32 bits, e.g. up to 53 bits? */
        DUK_DDD(DUK_DDDPRINT("fast path number parse"));
        if (nc_ctx->f.n == 1) {
            res = (double) nc_ctx->f.v[0];
        } else {
            res = 0.0;
        }
        goto negcheck_and_ret;
    }
 
    /* Significand ('f') padding. */
 
    while (dig_prec < duk__str2num_digits_for_radix[radix - 2]) {
        /* Pad significand with "virtual" zero digits so that Dragon4 will
         * have enough (apparent) precision to work with.
         */
        DUK_DDD(DUK_DDDPRINT("dig_prec=%ld, pad significand with zero", (long) dig_prec));
        duk__bi_mul_small_copy(&nc_ctx->f, radix, &nc_ctx->t1);
        DUK__BI_PRINT("f", &nc_ctx->f);
        expt--;
        dig_prec++;
    }
 
    DUK_DDD(DUK_DDDPRINT("final exponent: %ld", (long) expt));
 
    /* Detect zero special case. */
 
    if (nc_ctx->f.n == 0) {
        /* This may happen even after the fast path check, if exponent is
         * not balanced (e.g. "0e1").  Remember to respect zero sign.
         */
        DUK_DDD(DUK_DDDPRINT("significand is zero"));
        res = 0.0;
        goto negcheck_and_ret;
    }
 
 
    /* Quick reject of too large or too small exponents.  This check
     * would be incorrect for zero (e.g. "0e1000" is zero, not Infinity)
     * so zero check must be above.
     */
 
    explim = &duk__str2num_exp_limits[radix - 2];
    if (expt > explim->upper) {
        DUK_DDD(DUK_DDDPRINT("exponent too large -> infinite"));
        res = (duk_double_t) DUK_DOUBLE_INFINITY;
        goto negcheck_and_ret;
    } else if (expt < explim->lower) {
        DUK_DDD(DUK_DDDPRINT("exponent too small -> zero"));
        res = (duk_double_t) 0.0;
        goto negcheck_and_ret;
    }
 
    nc_ctx->is_s2n = 1;
    nc_ctx->e = expt;
    nc_ctx->b = radix;
    nc_ctx->B = 2;
    nc_ctx->is_fixed = 1;
    nc_ctx->abs_pos = 0;
    nc_ctx->req_digits = 53 + 1;
 
    DUK__BI_PRINT("f", &nc_ctx->f);
    DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e));
 
    /*
     *  Dragon4 slow path (binary) digit generation.
     *  An extra digit is generated for rounding.
     */
 
    duk__dragon4_prepare(nc_ctx);  /* setup many variables in nc_ctx */
 
    DUK_DDD(DUK_DDDPRINT("after prepare:"));
    DUK__BI_PRINT("r", &nc_ctx->r);
    DUK__BI_PRINT("s", &nc_ctx->s);
    DUK__BI_PRINT("mp", &nc_ctx->mp);
    DUK__BI_PRINT("mm", &nc_ctx->mm);
 
    duk__dragon4_scale(nc_ctx);
 
    DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k));
    DUK__BI_PRINT("r", &nc_ctx->r);
    DUK__BI_PRINT("s", &nc_ctx->s);
    DUK__BI_PRINT("mp", &nc_ctx->mp);
    DUK__BI_PRINT("mm", &nc_ctx->mm);
 
    duk__dragon4_generate(nc_ctx);
 
    DUK_ASSERT(nc_ctx->count == 53 + 1);
 
    /*
     *  Convert binary digits into an IEEE double.  Need to handle
     *  denormals and rounding correctly.
     */
 
    duk__dragon4_ctx_to_double(nc_ctx, &res);
    goto negcheck_and_ret;
 
 negcheck_and_ret:
    if (neg) {
        res = -res;

duk_numconv_stringify()

DUK_INTERNAL_DECL void duk_numconv_stringify	(	duk_context *	ctx,
		duk_small_int_t	radix,
		duk_small_int_t	digits,
		duk_small_uint_t	flags )

Definition at line 76525 of file duktape-1.5.2/src-noline/duktape.c.

                                            : %08lx %08lx",
                         (unsigned long) DUK_DBLUNION_GET_HIGH32(&u),
                         (unsigned long) DUK_DBLUNION_GET_LOW32(&u)));
 
    *x = DUK_DBLUNION_GET_DOUBLE(&u);
}
 
/*
 *  Exposed number-to-string API
 *
 *  Input: [ number ]
 *  Output: [ string ]
 */
 
DUK_INTERNAL void duk_numconv_stringify(duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags) {
    duk_double_t x;
    duk_small_int_t c;
    duk_small_int_t neg;
    duk_uint32_t uval;
    duk__numconv_stringify_ctx nc_ctx_alloc;  /* large context; around 2kB now */
    duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc;
 
    x = (duk_double_t) duk_require_number(ctx, -1);
    duk_pop(ctx);
 
    /*
     *  Handle special cases (NaN, infinity, zero).
     */
 
    c = (duk_small_int_t) DUK_FPCLASSIFY(x);
    if (DUK_SIGNBIT((double) x)) {
        x = -x;
        neg = 1;
    } else {
        neg = 0;
    }
 
    /* NaN sign bit is platform specific with unpacked, un-normalized NaNs */
    DUK_ASSERT(c == DUK_FP_NAN || DUK_SIGNBIT((double) x) == 0);
 
    if (c == DUK_FP_NAN) {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_NAN);
        return;
    } else if (c == DUK_FP_INFINITE) {
        if (neg) {
            /* -Infinity */
            duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_INFINITY);
        } else {
            /* Infinity */
            duk_push_hstring_stridx(ctx, DUK_STRIDX_INFINITY);
        }
        return;
    } else if (c == DUK_FP_ZERO) {
        /* We can't shortcut zero here if it goes through special formatting
         * (such as forced exponential notation).
         */
        ;
    }
 
    /*
     *  Handle integers in 32-bit range (that is, [-(2**32-1),2**32-1])
     *  specially, as they're very likely for embedded programs.  This
     *  is now done for all radix values.  We must be careful not to use
     *  the fast path when special formatting (e.g. forced exponential)
     *  is in force.
     *
     *  XXX: could save space by supporting radix 10 only and using
     *  sprintf "%lu" for the fast path and for exponent formatting.
     */
 
    uval = (unsigned int) x;
    if (((double) uval) == x &&  /* integer number in range */
        flags == 0) {            /* no special formatting */
        /* use bigint area as a temp */
        duk_uint8_t *buf = (duk_uint8_t *) (&nc_ctx->f);
        duk_uint8_t *p = buf;
 
        DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= 32 + 1);  /* max size: radix=2 + sign */
        if (neg && uval != 0) {
            /* no negative sign for zero */
            *p++ = (duk_uint8_t) '-';
        }
        p += duk__dragon4_format_uint32(p, uval, radix);
        duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (p - buf));
        return;
    }
 
    /*
     *  Dragon4 setup.
     *
     *  Convert double from IEEE representation for conversion;
     *  normal finite values have an implicit leading 1-bit.  The
     *  slow path algorithm doesn't handle zero, so zero is special
     *  cased here but still creates a valid nc_ctx, and goes
     *  through normal formatting in case special formatting has
     *  been requested (e.g. forced exponential format: 0 -> "0e+0").
     */
 
    /* Would be nice to bulk clear the allocation, but the context
     * is 1-2 kilobytes and nothing should rely on it being zeroed.
     */
#if 0
    DUK_MEMZERO((void *) nc_ctx, sizeof(*nc_ctx));  /* slow init, do only for slow path cases */
#endif
 
    nc_ctx->is_s2n = 0;
    nc_ctx->b = 2;
    nc_ctx->B = radix;
    nc_ctx->abs_pos = 0;
    if (flags & DUK_N2S_FLAG_FIXED_FORMAT) {
        nc_ctx->is_fixed = 1;
        if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) {
            /* absolute req_digits; e.g. digits = 1 -> last digit is 0,
             * but add an extra digit for rounding.
             */
            nc_ctx->abs_pos = 1;
            nc_ctx->req_digits = (-digits + 1) - 1;
        } else {
            nc_ctx->req_digits = digits + 1;
        }
    } else {
        nc_ctx->is_fixed = 0;
        nc_ctx->req_digits = 0;
    }
 
    if (c == DUK_FP_ZERO) {
        /* Zero special case: fake requested number of zero digits; ensure
         * no sign bit is printed.  Relative and absolute fixed format
         * require separate handling.
         */
        duk_small_int_t count;
        if (nc_ctx->is_fixed) {
            if (nc_ctx->abs_pos) {
                count = digits + 2;  /* lead zero + 'digits' fractions + 1 for rounding */
            } else {
                count = digits + 1;  /* + 1 for rounding */
            }
        } else {
            count = 1;
        }
        DUK_DDD(DUK_DDDPRINT("count=%ld", (long) count));
        DUK_ASSERT(count >= 1);
        DUK_MEMZERO((void *) nc_ctx->digits, count);
        nc_ctx->count = count;
        nc_ctx->k = 1;  /* 0.000... */
        neg = 0;
        goto zero_skip;
    }
 
    duk__dragon4_double_to_ctx(nc_ctx, x);   /* -> sets 'f' and 'e' */
    DUK__BI_PRINT("f", &nc_ctx->f);
    DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e));
 
    /*
     *  Dragon4 slow path digit generation.
     */
 
    duk__dragon4_prepare(nc_ctx);  /* setup many variables in nc_ctx */
 
    DUK_DDD(DUK_DDDPRINT("after prepare:"));
    DUK__BI_PRINT("r", &nc_ctx->r);
    DUK__BI_PRINT("s", &nc_ctx->s);
    DUK__BI_PRINT("mp", &nc_ctx->mp);
    DUK__BI_PRINT("mm", &nc_ctx->mm);
 
    duk__dragon4_scale(nc_ctx);
 
    DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k));
    DUK__BI_PRINT("r", &nc_ctx->r);
    DUK__BI_PRINT("s", &nc_ctx->s);
    DUK__BI_PRINT("mp", &nc_ctx->mp);
    DUK__BI_PRINT("mm", &nc_ctx->mm);
 
    duk__dragon4_generate(nc_ctx);
 
    /*
     *  Convert and push final string.
     */
 
 zero_skip:
 
    if (flags & DUK_N2S_FLAG_FIXED_FORMAT) {
        /* Perform fixed-format rounding. */
        duk_small_int_t roundpos;
        if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) {
            /* 'roundpos' is relative to nc_ctx->k and increases to the right
             * (opposite of how 'k' changes).
             */
            roundpos = -digits;  /* absolute position for digit considered for rounding */