duk_bi_protos.h File Reference

Go to the source code of this file.

Macros
#define	DUK_BI_DATE_ISO8601_BUFSIZE   48
#define	DUK_BI_COMMONJS_MODULE_ID_LIMIT   256

Functions
DUK_INTERNAL_DECL void	duk_bi_date_timeval_to_parts (duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags)
DUK_INTERNAL_DECL duk_double_t	duk_bi_date_get_timeval_from_dparts (duk_double_t *dparts, duk_small_uint_t flags)
DUK_INTERNAL_DECL void	duk_bi_date_format_timeval (duk_double_t timeval, duk_uint8_t *out_buf)
DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_is_leap_year (duk_int_t year)
DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_timeval_in_valid_range (duk_double_t x)
DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_year_in_valid_range (duk_double_t year)
DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_timeval_in_leeway_range (duk_double_t x)
DUK_INTERNAL_DECL void	duk_bi_json_parse_helper (duk_context *ctx, duk_idx_t idx_value, duk_idx_t idx_reviver, duk_small_uint_t flags)
DUK_INTERNAL_DECL void	duk_bi_json_stringify_helper (duk_context *ctx, duk_idx_t idx_value, duk_idx_t idx_replacer, duk_idx_t idx_space, duk_small_uint_t flags)

Macro Definition Documentation

DUK_BI_COMMONJS_MODULE_ID_LIMIT

#define DUK_BI_COMMONJS_MODULE_ID_LIMIT   256

Definition at line 21 of file duktape-1.5.2/src-separate/duk_bi_protos.h.

DUK_BI_DATE_ISO8601_BUFSIZE

#define DUK_BI_DATE_ISO8601_BUFSIZE   48

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

Function Documentation

duk_bi_date_format_timeval()

DUK_INTERNAL_DECL void duk_bi_date_format_timeval	(	duk_double_t	timeval,
		duk_uint8_t *	out_buf )

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

duk_bi_date_get_timeval_from_dparts()

DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_timeval_from_dparts	(	duk_double_t *	dparts,
		duk_small_uint_t	flags )

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

                        {
        for (i = 0; i < DUK_DATE_IDX_NUM_PARTS; i++) {
            dparts[i] = (duk_double_t) parts[i];
        }
    }
}
 
/* Compute time value from (double) parts.  The parts can be either UTC
 * or local time; if local, they need to be (conceptually) converted into
 * UTC time.  The parts may represent valid or invalid time, and may be
 * wildly out of range (but may cancel each other and still come out in
 * the valid Date range).
 */
DUK_INTERNAL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags) {
#if defined(DUK_USE_PARANOID_DATE_COMPUTATION)
    /* See comments below on MakeTime why these are volatile. */
    volatile duk_double_t tmp_time;
    volatile duk_double_t tmp_day;
    volatile duk_double_t d;
#else
    duk_double_t tmp_time;
    duk_double_t tmp_day;
    duk_double_t d;
#endif
    duk_small_uint_t i;
    duk_int_t tzoff, tzoffprev1, tzoffprev2;
 
    /* Expects 'this' at top of stack on entry. */
 
    /* Coerce all finite parts with ToInteger().  ToInteger() must not
     * be called for NaN/Infinity because it will convert e.g. NaN to
     * zero.  If ToInteger() has already been called, this has no side
     * effects and is idempotent.
     *
     * Don't read dparts[DUK_DATE_IDX_WEEKDAY]; it will cause Valgrind
     * issues if the value is uninitialized.
     */
    for (i = 0; i <= DUK_DATE_IDX_MILLISECOND; i++) {
        /* SCANBUILD: scan-build complains here about assigned value
         * being garbage or undefined.  This is correct but operating
         * on undefined values has no ill effect and is ignored by the
         * caller in the case where this happens.
         */
        d = dparts[i];
        if (DUK_ISFINITE(d)) {
            dparts[i] = duk_js_tointeger_number(d);
        }
    }
 
    /* Use explicit steps in computation to try to ensure that
     * computation happens with intermediate results coerced to
     * double values (instead of using something more accurate).
     * E.g. E5.1 Section 15.9.1.11 requires use of IEEE 754
     * rules (= Ecmascript '+' and '*' operators).
     *
     * Without 'volatile' even this approach fails on some platform
     * and compiler combinations.  For instance, gcc 4.8.1 on Ubuntu
     * 64-bit, with -m32 and without -std=c99, test-bi-date-canceling.js
     * would fail because of some optimizations when computing tmp_time
     * (MakeTime below).  Adding 'volatile' to tmp_time solved this
     * particular problem (annoyingly, also adding debug prints or
     * running the executable under valgrind hides it).
     */
 
    /* MakeTime */
    tmp_time = 0.0;
    tmp_time += dparts[DUK_DATE_IDX_HOUR] * ((duk_double_t) DUK_DATE_MSEC_HOUR);
    tmp_time += dparts[DUK_DATE_IDX_MINUTE] * ((duk_double_t) DUK_DATE_MSEC_MINUTE);
    tmp_time += dparts[DUK_DATE_IDX_SECOND] * ((duk_double_t) DUK_DATE_MSEC_SECOND);
    tmp_time += dparts[DUK_DATE_IDX_MILLISECOND];
 
    /* MakeDay */
    tmp_day = duk__make_day(dparts[DUK_DATE_IDX_YEAR], dparts[DUK_DATE_IDX_MONTH], dparts[DUK_DATE_IDX_DAY]);
 
    /* MakeDate */
    d = tmp_day * ((duk_double_t) DUK_DATE_MSEC_DAY) + tmp_time;
 
    DUK_DDD(DUK_DDDPRINT("time=%lf day=%lf --> timeval=%lf",
                         (double) tmp_time, (double) tmp_day, (double) d));
 
    /* Optional UTC conversion. */
    if (flags & DUK_DATE_FLAG_LOCALTIME) {
        /* DUK_USE_DATE_GET_LOCAL_TZOFFSET() needs to be called with a
         * time value computed from UTC parts.  At this point we only
         * have 'd' which is a time value computed from local parts, so
         * it is off by the UTC-to-local time offset which we don't know
         * yet.  The current solution for computing the UTC-to-local
         * time offset is to iterate a few times and detect a fixed
         * point or a two-cycle loop (or a sanity iteration limit),
         * see test-bi-date-local-parts.js and test-bi-date-tzoffset-basic-fi.js.
         *
         * E5.1 Section 15.9.1.9:
         * UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA)
         *
         * For NaN/inf, DUK_USE_DATE_GET_LOCAL_TZOFFSET() returns 0.
         */
 
#if 0
        /* Old solution: don't iterate, incorrect */
        tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d);
        DUK_DDD(DUK_DDDPRINT("tzoffset w/o iteration, tzoff=%ld", (long) tzoff));
        d -= tzoff * 1000L;
        DUK_UNREF(tzoffprev1);
        DUK_UNREF(tzoffprev2);
#endif
 
        /* Iteration solution */
        tzoff = 0;
        tzoffprev1 = 999999999L;  /* invalid value which never matches */
        for (i = 0; i < DUK__LOCAL_TZOFFSET_MAXITER; i++) {
            tzoffprev2 = tzoffprev1;
            tzoffprev1 = tzoff;
            tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d - tzoff * 1000L);
            DUK_DDD(DUK_DDDPRINT("tzoffset iteration, i=%d, tzoff=%ld, tzoffprev1=%ld tzoffprev2=%ld",
                                 (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
            if (tzoff == tzoffprev1) {
                DUK_DDD(DUK_DDDPRINT("tzoffset iteration finished, i=%d, tzoff=%ld, tzoffprev1=%ld, tzoffprev2=%ld",
                                     (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
                break;
            } else if (tzoff == tzoffprev2) {
                /* Two value cycle, see e.g. test-bi-date-tzoffset-basic-fi.js.
                 * In these cases, favor a higher tzoffset to get a consistent
                 * result which is independent of iteration count.  Not sure if
                 * this is a generically correct solution.
                 */

duk_bi_date_is_leap_year()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_is_leap_year

(

duk_int_t

year

)

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

duk_bi_date_timeval_in_leeway_range()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_leeway_range

(

duk_double_t

x

)

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

                                                                 {
    if ((year % 4) != 0) {
        return 0;

duk_bi_date_timeval_in_valid_range()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_valid_range

(

duk_double_t

x

)

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

duk_bi_date_timeval_to_parts()

DUK_INTERNAL_DECL void duk_bi_date_timeval_to_parts	(	duk_double_t	d,
		duk_int_t *	parts,
		duk_double_t *	dparts,
		duk_small_uint_t	flags )

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

                            {
        day_num += duk__days_in_month[i];
        if (i == 1 && is_leap) {
            day_num++;
        }
    }
 
    /* If 'day' is NaN, returns NaN. */
    return (duk_double_t) day_num + day;
}
 
/* Split time value into parts.  The time value is assumed to be an internal
 * one, i.e. finite, no fractions.  Possible local time adjustment has already
 * been applied when reading the time value.
 */
DUK_INTERNAL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags) {
    duk_double_t d1, d2;
    duk_int_t t1, t2;
    duk_int_t day_since_epoch;
    duk_int_t year;  /* does not fit into 16 bits */
    duk_small_int_t day_in_year;
    duk_small_int_t month;
    duk_small_int_t day;
    duk_small_int_t dim;
    duk_int_t jan1_since_epoch;
    duk_small_int_t jan1_weekday;
    duk_int_t equiv_year;
    duk_small_uint_t i;
    duk_bool_t is_leap;
    duk_small_int_t arridx;
 
    DUK_ASSERT(DUK_ISFINITE(d));    /* caller checks */
    DUK_ASSERT(DUK_FLOOR(d) == d);  /* no fractions in internal time */
 
    /* The timevalue must be in valid Ecmascript range, but since a local
     * time offset can be applied, we need to allow a +/- 24h leeway to
     * the value.  In other words, although the UTC time is within the
     * Ecmascript range, the local part values can be just outside of it.
     */
    DUK_UNREF(duk_bi_date_timeval_in_leeway_range);
    DUK_ASSERT(duk_bi_date_timeval_in_leeway_range(d));
 
    /* these computations are guaranteed to be exact for the valid
     * E5 time value range, assuming milliseconds without fractions.
     */
    d1 = (duk_double_t) DUK_FMOD(d, (double) DUK_DATE_MSEC_DAY);
    if (d1 < 0.0) {
        /* deal with negative values */
        d1 += (duk_double_t) DUK_DATE_MSEC_DAY;
    }
    d2 = DUK_FLOOR((double) (d / (duk_double_t) DUK_DATE_MSEC_DAY));
    DUK_ASSERT(d2 * ((duk_double_t) DUK_DATE_MSEC_DAY) + d1 == d);
    /* now expected to fit into a 32-bit integer */
    t1 = (duk_int_t) d1;
    t2 = (duk_int_t) d2;
    day_since_epoch = t2;
    DUK_ASSERT((duk_double_t) t1 == d1);
    DUK_ASSERT((duk_double_t) t2 == d2);
 
    /* t1 = milliseconds within day (fits 32 bit)
     * t2 = day number from epoch (fits 32 bit, may be negative)
     */
 
    parts[DUK_DATE_IDX_MILLISECOND] = t1 % 1000; t1 /= 1000;
    parts[DUK_DATE_IDX_SECOND] = t1 % 60; t1 /= 60;
    parts[DUK_DATE_IDX_MINUTE] = t1 % 60; t1 /= 60;
    parts[DUK_DATE_IDX_HOUR] = t1;
    DUK_ASSERT(parts[DUK_DATE_IDX_MILLISECOND] >= 0 && parts[DUK_DATE_IDX_MILLISECOND] <= 999);
    DUK_ASSERT(parts[DUK_DATE_IDX_SECOND] >= 0 && parts[DUK_DATE_IDX_SECOND] <= 59);
    DUK_ASSERT(parts[DUK_DATE_IDX_MINUTE] >= 0 && parts[DUK_DATE_IDX_MINUTE] <= 59);
    DUK_ASSERT(parts[DUK_DATE_IDX_HOUR] >= 0 && parts[DUK_DATE_IDX_HOUR] <= 23);
 
    DUK_DDD(DUK_DDDPRINT("d=%lf, d1=%lf, d2=%lf, t1=%ld, t2=%ld, parts: hour=%ld min=%ld sec=%ld msec=%ld",
                         (double) d, (double) d1, (double) d2, (long) t1, (long) t2,
                         (long) parts[DUK_DATE_IDX_HOUR],
                         (long) parts[DUK_DATE_IDX_MINUTE],
                         (long) parts[DUK_DATE_IDX_SECOND],
                         (long) parts[DUK_DATE_IDX_MILLISECOND]));
 
    /* This assert depends on the input parts representing time inside
     * the Ecmascript range.
     */
    DUK_ASSERT(t2 + DUK__WEEKDAY_MOD_ADDER >= 0);
    parts[DUK_DATE_IDX_WEEKDAY] = (t2 + 4 + DUK__WEEKDAY_MOD_ADDER) % 7;  /* E5.1 Section 15.9.1.6 */
    DUK_ASSERT(parts[DUK_DATE_IDX_WEEKDAY] >= 0 && parts[DUK_DATE_IDX_WEEKDAY] <= 6);
 
    year = duk__year_from_day(t2, &day_in_year);
    day = day_in_year;
    is_leap = duk_bi_date_is_leap_year(year);
    for (month = 0; month < 12; month++) {
        dim = duk__days_in_month[month];
        if (month == 1 && is_leap) {
            dim++;
        }
        DUK_DDD(DUK_DDDPRINT("month=%ld, dim=%ld, day=%ld",
                             (long) month, (long) dim, (long) day));
        if (day < dim) {
            break;
        }
        day -= dim;
    }
    DUK_DDD(DUK_DDDPRINT("final month=%ld", (long) month));
    DUK_ASSERT(month >= 0 && month <= 11);
    DUK_ASSERT(day >= 0 && day <= 31);
 
    /* Equivalent year mapping, used to avoid DST trouble when platform
     * may fail to provide reasonable DST answers for dates outside the
     * ordinary range (e.g. 1970-2038).  An equivalent year has the same
     * leap-year-ness as the original year and begins on the same weekday
     * (Jan 1).
     *
     * The year 2038 is avoided because there seem to be problems with it
     * on some platforms.  The year 1970 is also avoided as there were
     * practical problems with it; an equivalent year is used for it too,
     * which breaks some DST computations for 1970 right now, see e.g.
     * test-bi-date-tzoffset-brute-fi.js.
     */
    if ((flags & DUK_DATE_FLAG_EQUIVYEAR) && (year < 1971 || year > 2037)) {
        DUK_ASSERT(is_leap == 0 || is_leap == 1);
 
        jan1_since_epoch = day_since_epoch - day_in_year;  /* day number for Jan 1 since epoch */
        DUK_ASSERT(jan1_since_epoch + DUK__WEEKDAY_MOD_ADDER >= 0);
        jan1_weekday = (jan1_since_epoch + 4 + DUK__WEEKDAY_MOD_ADDER) % 7;  /* E5.1 Section 15.9.1.6 */
        DUK_ASSERT(jan1_weekday >= 0 && jan1_weekday <= 6);
        arridx = jan1_weekday;
        if (is_leap) {
            arridx += 7;
        }
        DUK_ASSERT(arridx >= 0 && arridx < (duk_small_int_t) (sizeof(duk__date_equivyear) / sizeof(duk_uint8_t)));
 
        equiv_year = (duk_int_t) duk__date_equivyear[arridx] + 1970;
        year = equiv_year;
        DUK_DDD(DUK_DDDPRINT("equiv year mapping, year=%ld, day_in_year=%ld, day_since_epoch=%ld, "
                             "jan1_since_epoch=%ld, jan1_weekday=%ld -> equiv year %ld",
                             (long) year, (long) day_in_year, (long) day_since_epoch,
                             (long) jan1_since_epoch, (long) jan1_weekday, (long) equiv_year));

duk_bi_date_year_in_valid_range()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_year_in_valid_range

(

duk_double_t

year

)

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

                           {
        return 1;
    }

duk_bi_json_parse_helper()

DUK_INTERNAL_DECL void duk_bi_json_parse_helper	(	duk_context *	ctx,
		duk_idx_t	idx_value,
		duk_idx_t	idx_reviver,
		duk_small_uint_t	flags )

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

                                                         {
        DUK_DD(DUK_DDPRINT("top level value not supported, fail fast path"));
        return DUK_RET_ERROR;  /* error message doesn't matter, ignored anyway */
    }
 
    return 0;
}
#endif  /* DUK_USE_JSON_STRINGIFY_FASTPATH */
 
/*
 *  Top level wrappers
 */
 
DUK_INTERNAL
void duk_bi_json_parse_helper(duk_context *ctx,
                              duk_idx_t idx_value,
                              duk_idx_t idx_reviver,
                              duk_small_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_json_dec_ctx js_ctx_alloc;
    duk_json_dec_ctx *js_ctx = &js_ctx_alloc;
    duk_hstring *h_text;
#ifdef DUK_USE_ASSERTIONS
    duk_idx_t entry_top = duk_get_top(ctx);
#endif
 
    /* negative top-relative indices not allowed now */
    DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0);
    DUK_ASSERT(idx_reviver == DUK_INVALID_INDEX || idx_reviver >= 0);
 
    DUK_DDD(DUK_DDDPRINT("JSON parse start: text=%!T, reviver=%!T, flags=0x%08lx, stack_top=%ld",
                         (duk_tval *) duk_get_tval(ctx, idx_value),
                         (duk_tval *) duk_get_tval(ctx, idx_reviver),
                         (unsigned long) flags,
                         (long) duk_get_top(ctx)));
 
    DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc));
    js_ctx->thr = thr;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    /* nothing now */
#endif
    js_ctx->recursion_limit = DUK_USE_JSON_DEC_RECLIMIT;
    DUK_ASSERT(js_ctx->recursion_depth == 0);
 
    /* Flag handling currently assumes that flags are consistent.  This is OK
     * because the call sites are now strictly controlled.
     */
 
    js_ctx->flags = flags;
#if defined(DUK_USE_JX)
    js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM;
#endif
#if defined(DUK_USE_JC)
    js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE;
#endif
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    js_ctx->flag_ext_custom_or_compatible = flags & (DUK_JSON_FLAG_EXT_CUSTOM | DUK_JSON_FLAG_EXT_COMPATIBLE);
#endif
 
    h_text = duk_to_hstring(ctx, idx_value);  /* coerce in-place */
    DUK_ASSERT(h_text != NULL);
 
    /* JSON parsing code is allowed to read [p_start,p_end]: p_end is
     * valid and points to the string NUL terminator (which is always
     * guaranteed for duk_hstrings.
     */
    js_ctx->p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text);
    js_ctx->p = js_ctx->p_start;
    js_ctx->p_end = ((const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text)) +
                    DUK_HSTRING_GET_BYTELEN(h_text);
    DUK_ASSERT(*(js_ctx->p_end) == 0x00);
 
    duk__dec_value(js_ctx);  /* -> [ ... value ] */
 
    /* Trailing whitespace has been eaten by duk__dec_value(), so if
     * we're not at end of input here, it's a SyntaxError.
     */
 
    if (js_ctx->p != js_ctx->p_end) {
        duk__dec_syntax_error(js_ctx);
    }
 
    if (duk_is_callable(ctx, idx_reviver)) {
        DUK_DDD(DUK_DDDPRINT("applying reviver: %!T",
                             (duk_tval *) duk_get_tval(ctx, idx_reviver)));
 
        js_ctx->idx_reviver = idx_reviver;
 
        duk_push_object(ctx);
        duk_dup(ctx, -2);  /* -> [ ... val root val ] */
        duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING);  /* default attrs ok */
        duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);  /* -> [ ... val root "" ] */
 
        DUK_DDD(DUK_DDDPRINT("start reviver walk, root=%!T, name=%!T",
                             (duk_tval *) duk_get_tval(ctx, -2),
                             (duk_tval *) duk_get_tval(ctx, -1)));
 
        duk__dec_reviver_walk(js_ctx);  /* [ ... val root "" ] -> [ ... val val' ] */

duk_bi_json_stringify_helper()

DUK_INTERNAL_DECL void duk_bi_json_stringify_helper	(	duk_context *	ctx,
		duk_idx_t	idx_value,
		duk_idx_t	idx_replacer,
		duk_idx_t	idx_space,
		duk_small_uint_t	flags )

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

                                                                       : %!T",
                             (duk_tval *) duk_get_tval(ctx, idx_reviver)));
    }
 
    /* Final result is at stack top. */
 
    DUK_DDD(DUK_DDDPRINT("JSON parse end: text=%!T, reviver=%!T, flags=0x%08lx, result=%!T, stack_top=%ld",
                         (duk_tval *) duk_get_tval(ctx, idx_value),
                         (duk_tval *) duk_get_tval(ctx, idx_reviver),
                         (unsigned long) flags,
                         (duk_tval *) duk_get_tval(ctx, -1),
                         (long) duk_get_top(ctx)));
 
    DUK_ASSERT(duk_get_top(ctx) == entry_top + 1);
}
 
DUK_INTERNAL
void duk_bi_json_stringify_helper(duk_context *ctx,
                                  duk_idx_t idx_value,
                                  duk_idx_t idx_replacer,
                                  duk_idx_t idx_space,
                                  duk_small_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_json_enc_ctx js_ctx_alloc;
    duk_json_enc_ctx *js_ctx = &js_ctx_alloc;
    duk_hobject *h;
    duk_idx_t idx_holder;
    duk_idx_t entry_top;
 
    /* negative top-relative indices not allowed now */
    DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0);
    DUK_ASSERT(idx_replacer == DUK_INVALID_INDEX || idx_replacer >= 0);
    DUK_ASSERT(idx_space == DUK_INVALID_INDEX || idx_space >= 0);
 
    DUK_DDD(DUK_DDDPRINT("JSON stringify start: value=%!T, replacer=%!T, space=%!T, flags=0x%08lx, stack_top=%ld",
                         (duk_tval *) duk_get_tval(ctx, idx_value),
                         (duk_tval *) duk_get_tval(ctx, idx_replacer),
                         (duk_tval *) duk_get_tval(ctx, idx_space),
                         (unsigned long) flags,
                         (long) duk_get_top(ctx)));
 
    entry_top = duk_get_top(ctx);
 
    /*
     *  Context init
     */
 
    DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc));
    js_ctx->thr = thr;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    js_ctx->h_replacer = NULL;
    js_ctx->h_gap = NULL;
#endif
    js_ctx->idx_proplist = -1;
 
    /* Flag handling currently assumes that flags are consistent.  This is OK
     * because the call sites are now strictly controlled.
     */
 
    js_ctx->flags = flags;
    js_ctx->flag_ascii_only = flags & DUK_JSON_FLAG_ASCII_ONLY;
    js_ctx->flag_avoid_key_quotes = flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES;
#ifdef DUK_USE_JX
    js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM;
#endif
#ifdef DUK_USE_JC
    js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE;
#endif
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    js_ctx->flag_ext_custom_or_compatible = flags & (DUK_JSON_FLAG_EXT_CUSTOM | DUK_JSON_FLAG_EXT_COMPATIBLE);
#endif
 
    /* The #ifdef clutter here handles the JX/JC enable/disable
     * combinations properly.
     */
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    js_ctx->stridx_custom_undefined = DUK_STRIDX_LC_NULL;  /* standard JSON; array gaps */
#if defined(DUK_USE_JX)
    if (flags & DUK_JSON_FLAG_EXT_CUSTOM) {
        js_ctx->stridx_custom_undefined = DUK_STRIDX_LC_UNDEFINED;
        js_ctx->stridx_custom_nan = DUK_STRIDX_NAN;
        js_ctx->stridx_custom_neginf = DUK_STRIDX_MINUS_INFINITY;
        js_ctx->stridx_custom_posinf = DUK_STRIDX_INFINITY;
        js_ctx->stridx_custom_function =
                (flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES) ?
                        DUK_STRIDX_JSON_EXT_FUNCTION2 :
                        DUK_STRIDX_JSON_EXT_FUNCTION1;
    }
#endif  /* DUK_USE_JX */
#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
    else
#endif  /* DUK_USE_JX && DUK_USE_JC */
#if defined(DUK_USE_JC)
    if (js_ctx->flags & DUK_JSON_FLAG_EXT_COMPATIBLE) {
        js_ctx->stridx_custom_undefined = DUK_STRIDX_JSON_EXT_UNDEFINED;
        js_ctx->stridx_custom_nan = DUK_STRIDX_JSON_EXT_NAN;
        js_ctx->stridx_custom_neginf = DUK_STRIDX_JSON_EXT_NEGINF;
        js_ctx->stridx_custom_posinf = DUK_STRIDX_JSON_EXT_POSINF;
        js_ctx->stridx_custom_function = DUK_STRIDX_JSON_EXT_FUNCTION1;
    }
#endif  /* DUK_USE_JC */
#endif  /* DUK_USE_JX || DUK_USE_JC */
 
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
                         DUK_JSON_FLAG_EXT_COMPATIBLE)) {
        DUK_ASSERT(js_ctx->mask_for_undefined == 0);  /* already zero */
    }
    else
#endif  /* DUK_USE_JX || DUK_USE_JC */
    {
        js_ctx->mask_for_undefined = DUK_TYPE_MASK_UNDEFINED |
                                     DUK_TYPE_MASK_POINTER |
                                     DUK_TYPE_MASK_BUFFER |
                                     DUK_TYPE_MASK_LIGHTFUNC;
    }
 
    DUK_BW_INIT_PUSHBUF(thr, &js_ctx->bw, DUK__JSON_STRINGIFY_BUFSIZE);
 
    js_ctx->idx_loop = duk_push_object_internal(ctx);
    DUK_ASSERT(js_ctx->idx_loop >= 0);
 
    /* [ ... buf loop ] */
 
    /*
     *  Process replacer/proplist (2nd argument to JSON.stringify)
     */
 
    h = duk_get_hobject(ctx, idx_replacer);
    if (h != NULL) {
        if (DUK_HOBJECT_IS_CALLABLE(h)) {
            js_ctx->h_replacer = h;
        } else if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
            /* Here the specification requires correct array index enumeration
             * which is a bit tricky for sparse arrays (it is handled by the
             * enum setup code).  We now enumerate ancestors too, although the
             * specification is not very clear on whether that is required.
             */
 
            duk_uarridx_t plist_idx = 0;
            duk_small_uint_t enum_flags;
 
            js_ctx->idx_proplist = duk_push_array(ctx);  /* XXX: array internal? */
 
            enum_flags = DUK_ENUM_ARRAY_INDICES_ONLY |
                         DUK_ENUM_SORT_ARRAY_INDICES;  /* expensive flag */
            duk_enum(ctx, idx_replacer, enum_flags);
            while (duk_next(ctx, -1 /*enum_index*/, 1 /*get_value*/)) {
                /* [ ... proplist enum_obj key val ] */
                if (duk__enc_allow_into_proplist(duk_get_tval(ctx, -1))) {
                    /* XXX: duplicates should be eliminated here */
                    DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> accept",
                                         (duk_tval *) duk_get_tval(ctx, -2),
                                         (duk_tval *) duk_get_tval(ctx, -1)));
                    duk_to_string(ctx, -1);  /* extra coercion of strings is OK */
                    duk_put_prop_index(ctx, -4, plist_idx);  /* -> [ ... proplist enum_obj key ] */
                    plist_idx++;
                    duk_pop(ctx);
                } else {
                    DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> reject",
                                         (duk_tval *) duk_get_tval(ctx, -2),
                                         (duk_tval *) duk_get_tval(ctx, -1)));
                    duk_pop_2(ctx);
                }
                        }
                        duk_pop(ctx);  /* pop enum */
 
            /* [ ... proplist ] */
        }
    }
 
    /* [ ... buf loop (proplist) ] */
 
    /*
     *  Process space (3rd argument to JSON.stringify)
     */
 
    h = duk_get_hobject(ctx, idx_space);
    if (h != NULL) {
        int c = DUK_HOBJECT_GET_CLASS_NUMBER(h);
        if (c == DUK_HOBJECT_CLASS_NUMBER) {
            duk_to_number(ctx, idx_space);
        } else if (c == DUK_HOBJECT_CLASS_STRING) {
            duk_to_string(ctx, idx_space);
        }
    }
 
    if (duk_is_number(ctx, idx_space)) {
        duk_small_int_t nspace;
        /* spaces[] must be static to allow initializer with old compilers like BCC */
        static const char spaces[10] = {
            DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE,
            DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE,
            DUK_ASC_SPACE, DUK_ASC_SPACE
        };  /* XXX: helper */
 
        /* ToInteger() coercion; NaN -> 0, infinities are clamped to 0 and 10 */
        nspace = (duk_small_int_t) duk_to_int_clamped(ctx, idx_space, 0 /*minval*/, 10 /*maxval*/);
        DUK_ASSERT(nspace >= 0 && nspace <= 10);
 
        duk_push_lstring(ctx, spaces, (duk_size_t) nspace);
        js_ctx->h_gap = duk_get_hstring(ctx, -1);
        DUK_ASSERT(js_ctx->h_gap != NULL);
    } else if (duk_is_string(ctx, idx_space)) {
        /* XXX: substring in-place at idx_place? */
        duk_dup(ctx, idx_space);
        duk_substring(ctx, -1, 0, 10);  /* clamp to 10 chars */
        js_ctx->h_gap = duk_get_hstring(ctx, -1);
        DUK_ASSERT(js_ctx->h_gap != NULL);
    } else {
        /* nop */
    }
 
    if (js_ctx->h_gap != NULL) {
        /* if gap is empty, behave as if not given at all */
        if (DUK_HSTRING_GET_CHARLEN(js_ctx->h_gap) == 0) {
            js_ctx->h_gap = NULL;
        }
    }
 
    /* [ ... buf loop (proplist) (gap) ] */
 
    /*
     *  Fast path: assume no mutation, iterate object property tables
     *  directly; bail out if that assumption doesn't hold.
     */
 
#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH)
    if (js_ctx->h_replacer == NULL &&  /* replacer is a mutation risk */
        js_ctx->idx_proplist == -1) {  /* proplist is very rare */
        duk_int_t pcall_rc;
#ifdef DUK_USE_MARK_AND_SWEEP
        duk_small_uint_t prev_mark_and_sweep_base_flags;
#endif
 
        DUK_DD(DUK_DDPRINT("try JSON.stringify() fast path"));
 
        /* Use recursion_limit to ensure we don't overwrite js_ctx->visiting[]
         * array so we don't need two counter checks in the fast path.  The
         * slow path has a much larger recursion limit which we'll use if
         * necessary.
         */
        DUK_ASSERT(DUK_USE_JSON_ENC_RECLIMIT >= DUK_JSON_ENC_LOOPARRAY);
        js_ctx->recursion_limit = DUK_JSON_ENC_LOOPARRAY;
        DUK_ASSERT(js_ctx->recursion_depth == 0);
 
        /* Execute the fast path in a protected call.  If any error is thrown,
         * fall back to the slow path.  This includes e.g. recursion limit
         * because the fast path has a smaller recursion limit (and simpler,
         * limited loop detection).
         */
 
        duk_push_pointer(ctx, (void *) js_ctx);
        duk_dup(ctx, idx_value);
 
#if defined(DUK_USE_MARK_AND_SWEEP)
        /* Must prevent finalizers which may have arbitrary side effects. */
        prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags;
        thr->heap->mark_and_sweep_base_flags |=
            DUK_MS_FLAG_NO_FINALIZERS |         /* avoid attempts to add/remove object keys */
                DUK_MS_FLAG_NO_OBJECT_COMPACTION;   /* avoid attempt to compact any objects */
#endif
 
        pcall_rc = duk_safe_call(ctx, duk__json_stringify_fast, 2 /*nargs*/, 0 /*nret*/);
 
#if defined(DUK_USE_MARK_AND_SWEEP)
        thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
#endif
        if (pcall_rc == DUK_EXEC_SUCCESS) {
            DUK_DD(DUK_DDPRINT("fast path successful"));
            DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw);
            goto replace_finished;
        }
 
        /* We come here for actual aborts (like encountering .toJSON())
         * but also for recursion/loop errors.  Bufwriter size can be
         * kept because we'll probably need at least as much as we've
         * allocated so far.
         */
        DUK_D(DUK_DPRINT("fast path failed, serialize using slow path instead"));
        DUK_BW_RESET_SIZE(thr, &js_ctx->bw);
        js_ctx->recursion_depth = 0;
    }
#endif
 
    /*
     *  Create wrapper object and serialize
     */
 
    idx_holder = duk_push_object(ctx);
    duk_dup(ctx, idx_value);
    duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING);
 
    DUK_DDD(DUK_DDDPRINT("before: flags=0x%08lx, loop=%!T, replacer=%!O, "
                         "proplist=%!T, gap=%!O, holder=%!T",
                         (unsigned long) js_ctx->flags,
                         (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop),
                         (duk_heaphdr *) js_ctx->h_replacer,
                         (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL),
                         (duk_heaphdr *) js_ctx->h_gap,
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    /* serialize the wrapper with empty string key */
 
    duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
 
    /* [ ... buf loop (proplist) (gap) holder "" ] */
 
    js_ctx->recursion_limit = DUK_USE_JSON_ENC_RECLIMIT;
    DUK_ASSERT(js_ctx->recursion_depth == 0);
 
    if (DUK_UNLIKELY(duk__enc_value(js_ctx, idx_holder) == 0)) {  /* [ ... holder key ] -> [ ... holder ] */
        /* Result is undefined. */
        duk_push_undefined(ctx);
    } else {
        /* Convert buffer to result string. */
        DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw);
    }
 
    DUK_DDD(DUK_DDDPRINT("after: flags=0x%08lx, loop=%!T, replacer=%!O, "
                         "proplist=%!T, gap=%!O, holder=%!T",
                         (unsigned long) js_ctx->flags,
                         (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop),
                         (duk_heaphdr *) js_ctx->h_replacer,
                         (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL),
                         (duk_heaphdr *) js_ctx->h_gap,
                         (duk_tval *) duk_get_tval(ctx, idx_holder)));
 
    /* The stack has a variable shape here, so force it to the
     * desired one explicitly.
     */