duk_bi_json.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Macros
#define	DUK__JSON_DECSTR_BUFSIZE   128
#define	DUK__JSON_DECSTR_CHUNKSIZE   64
#define	DUK__JSON_ENCSTR_CHUNKSIZE   64
#define	DUK__JSON_STRINGIFY_BUFSIZE   128
#define	DUK__JSON_MAX_ESC_LEN   10 /* '\Udeadbeef' */
#define	DUK__EMIT_1(js_ctx, ch)   duk__emit_1((js_ctx), (duk_uint_fast8_t) (ch))
#define	DUK__EMIT_2(js_ctx, ch1, ch2)   duk__emit_2((js_ctx), (duk_uint_fast8_t) (ch1), (duk_uint_fast8_t) (ch2))
#define	DUK__EMIT_HSTR(js_ctx, h)   duk__emit_hstring((js_ctx), (h))
#define	DUK__EMIT_CSTR(js_ctx, p)   duk__emit_cstring((js_ctx), (p))
#define	DUK__EMIT_STRIDX(js_ctx, i)   duk__emit_stridx((js_ctx), (i))
#define	DUK__UNEMIT_1(js_ctx)   duk__unemit_1((js_ctx))
#define	DUK__MKESC(nybbles, esc1, esc2)

Functions
DUK_LOCAL_DECL void	duk__dec_syntax_error (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_eat_white (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL duk_uint8_t	duk__dec_peek (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL duk_uint8_t	duk__dec_get (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL duk_uint8_t	duk__dec_get_nonwhite (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL duk_uint_fast32_t	duk__dec_decode_hex_escape (duk_json_dec_ctx *js_ctx, duk_small_uint_t n)
DUK_LOCAL_DECL void	duk__dec_req_stridx (duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx)
DUK_LOCAL_DECL void	duk__dec_string (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_plain_string (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_pointer (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_buffer (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_number (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_objarr_entry (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_objarr_exit (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_object (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_array (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_value (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__dec_reviver_walk (duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__emit_1 (duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch)
DUK_LOCAL_DECL void	duk__emit_2 (duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch1, duk_uint_fast8_t ch2)
DUK_LOCAL_DECL void	duk__unemit_1 (duk_json_enc_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__emit_hstring (duk_json_enc_ctx *js_ctx, duk_hstring *h)
DUK_LOCAL_DECL void	duk__emit_stridx (duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx)
DUK_LOCAL_DECL duk_uint8_t *	duk__emit_esc_auto_fast (duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp, duk_uint8_t *q)
DUK_LOCAL_DECL void	duk__enc_key_autoquote (duk_json_enc_ctx *js_ctx, duk_hstring *k)
DUK_LOCAL_DECL void	duk__enc_quote_string (duk_json_enc_ctx *js_ctx, duk_hstring *h_str)
DUK_LOCAL_DECL void	duk__enc_objarr_entry (duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top)
DUK_LOCAL_DECL void	duk__enc_objarr_exit (duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top)
DUK_LOCAL_DECL void	duk__enc_object (duk_json_enc_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__enc_array (duk_json_enc_ctx *js_ctx)
DUK_LOCAL_DECL duk_bool_t	duk__enc_value (duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder)
DUK_LOCAL_DECL duk_bool_t	duk__enc_allow_into_proplist (duk_tval *tv)
DUK_LOCAL_DECL void	duk__enc_double (duk_json_enc_ctx *js_ctx)
DUK_LOCAL_DECL void	duk__enc_buffer (duk_json_enc_ctx *js_ctx, duk_hbuffer *h)
DUK_LOCAL_DECL void	duk__enc_pointer (duk_json_enc_ctx *js_ctx, void *ptr)
DUK_LOCAL_DECL void	duk__enc_bufferobject (duk_json_enc_ctx *js_ctx, duk_hbufferobject *h_bufobj)
DUK_LOCAL_DECL void	duk__enc_newline_indent (duk_json_enc_ctx *js_ctx, duk_int_t depth)
DUK_LOCAL duk_small_int_t	duk__dec_string_escape (duk_json_dec_ctx *js_ctx, duk_uint8_t **ext_p)
DUK_LOCAL void	duk__emit_cstring (duk_json_enc_ctx *js_ctx, const char *str)
DUK_LOCAL duk_uint8_t *	duk__enc_buffer_data_hex (const duk_uint8_t *src, duk_size_t src_len, duk_uint8_t *dst)
DUK_LOCAL void	duk__enc_buffer_data (duk_json_enc_ctx *js_ctx, duk_uint8_t *buf_data, duk_size_t buf_len)
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_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_INTERNAL duk_ret_t	duk_bi_json_object_parse (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_json_object_stringify (duk_context *ctx)

Variables
DUK_LOCAL const duk_uint8_t	duk__json_quotestr_lookup [256]
DUK_LOCAL const duk_uint8_t	duk__json_decstr_lookup [256]
DUK_LOCAL const duk_uint8_t	duk__json_eatwhite_lookup [256]
DUK_LOCAL const duk_uint8_t	duk__json_decnumber_lookup [256]

Macro Definition Documentation

DUK__EMIT_1

#define DUK__EMIT_1	(		js_ctx,
			ch )   duk__emit_1((js_ctx), (duk_uint_fast8_t) (ch))

Definition at line 1044 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_array(), duk__enc_newline_indent(), duk__enc_object(), and duk__enc_quote_string().

DUK__EMIT_2

#define DUK__EMIT_2	(		js_ctx,
			ch1,
			ch2 )   duk__emit_2((js_ctx), (duk_uint_fast8_t) (ch1), (duk_uint_fast8_t) (ch2))

Definition at line 1045 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_object().

DUK__EMIT_CSTR

#define DUK__EMIT_CSTR	(		js_ctx,
			p )   duk__emit_cstring((js_ctx), (p))

Definition at line 1048 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_pointer().

DUK__EMIT_HSTR

#define DUK__EMIT_HSTR	(		js_ctx,
			h )   duk__emit_hstring((js_ctx), (h))

Definition at line 1046 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_double(), and duk__enc_key_autoquote().

DUK__EMIT_STRIDX

#define DUK__EMIT_STRIDX	(		js_ctx,
			i )   duk__emit_stridx((js_ctx), (i))

Definition at line 1050 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_array(), duk__enc_bufferobject(), duk__enc_double(), and duk__enc_value().

DUK__JSON_DECSTR_BUFSIZE

#define DUK__JSON_DECSTR_BUFSIZE   128

Definition at line 23 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__dec_string().

DUK__JSON_DECSTR_CHUNKSIZE

#define DUK__JSON_DECSTR_CHUNKSIZE   64

Definition at line 24 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__dec_string().

DUK__JSON_ENCSTR_CHUNKSIZE

#define DUK__JSON_ENCSTR_CHUNKSIZE   64

Definition at line 25 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_quote_string().

DUK__JSON_MAX_ESC_LEN

#define DUK__JSON_MAX_ESC_LEN   10 /* '\Udeadbeef' */

Definition at line 27 of file duktape-1.5.2/src-separate/duk_bi_json.c.

DUK__JSON_STRINGIFY_BUFSIZE

#define DUK__JSON_STRINGIFY_BUFSIZE   128

Definition at line 26 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk_bi_json_stringify_helper().

DUK__MKESC

#define DUK__MKESC	(		nybbles,
			esc1,
			esc2 )

Value:

    (((duk_uint_fast32_t) (nybbles)) << 16) | \
    (((duk_uint_fast32_t) (esc1)) << 8) | \
    ((duk_uint_fast32_t) (esc2))

Definition at line 1087 of file duktape-1.5.2/src-separate/duk_bi_json.c.

#define DUK__MKESC(nybbles,esc1,esc2)  \
    (((duk_uint_fast32_t) (nybbles)) << 16) | \
    (((duk_uint_fast32_t) (esc1)) << 8) | \
    ((duk_uint_fast32_t) (esc2))

Referenced by duk__emit_esc_auto_fast().

DUK__UNEMIT_1

#define DUK__UNEMIT_1

(

js_ctx

)

duk__unemit_1((js_ctx))

Definition at line 1051 of file duktape-1.5.2/src-separate/duk_bi_json.c.

Referenced by duk__enc_array(), and duk__enc_object().

Function Documentation

duk__dec_array()

DUK_LOCAL_DECL void duk__dec_array

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 811 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                        {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_uarridx_t arr_idx;
    duk_uint8_t x;
 
    DUK_DDD(DUK_DDDPRINT("parse_array"));
 
    duk__dec_objarr_entry(js_ctx);
 
    duk_push_array(ctx);
 
    /* Initial '[' has been checked and eaten by caller. */
 
    arr_idx = 0;
    for (;;) {
        x = duk__dec_get_nonwhite(js_ctx);
 
        DUK_DDD(DUK_DDDPRINT("parse_array: arr=%!T, x=%ld, arr_idx=%ld",
                             (duk_tval *) duk_get_tval(ctx, -1),
                             (long) x, (long) arr_idx));
 
        /* handle comma and closing bracket */
 
        if ((x == DUK_ASC_COMMA) && (arr_idx != 0)) {
            /* accept comma, expect new value */
            ;
        } else if (x == DUK_ASC_RBRACKET) {
            /* eat closing bracket */
            break;
        } else if (arr_idx == 0) {
            /* accept anything, expect first value (EOF will be
             * caught by duk__dec_value() below.
             */
            js_ctx->p--;  /* backtrack (safe) */
        } else {
            /* catches EOF (NUL) and initial comma */
            goto syntax_error;
        }
 
        /* parse value */
 
        duk__dec_value(js_ctx);
 
        /* [ ... arr val ] */
 
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
    }
 
    /* Must set 'length' explicitly when using duk_xdef_prop_xxx() to
     * set the values.
     */
 
    duk_set_length(ctx, -1, arr_idx);
 
    /* [ ... arr ] */
 
    DUK_DDD(DUK_DDDPRINT("parse_array: final array is %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk__dec_objarr_exit(js_ctx);
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_get_nonwhite(), duk__dec_objarr_entry(), duk__dec_objarr_exit(), duk__dec_syntax_error(), duk__dec_value(), DUK_ASC_COMMA, DUK_ASC_RBRACKET, DUK_DDD, DUK_DDDPRINT, duk_get_tval(), duk_push_array(), duk_set_length(), DUK_UNREACHABLE, duk_xdef_prop_index_wec, duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_value().

duk__dec_buffer()

DUK_LOCAL_DECL void duk__dec_buffer

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 583 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                         {
    duk_hthread *thr = js_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    const duk_uint8_t *p;
    duk_uint8_t *buf;
    duk_size_t src_len;
    duk_small_int_t x;
 
    /* Caller has already eaten the first character ('|') which we don't need. */
 
    p = js_ctx->p;
 
    /* XXX: Would be nice to share the fast path loop from duk_hex_decode()
     * and avoid creating a temporary buffer.  However, there are some
     * differences which prevent trivial sharing:
     *
     *   - Pipe char detection
     *   - EOF detection
     *   - Unknown length of input and output
     *
     * The best approach here would be a bufwriter and a reasonaly sized
     * safe inner loop (e.g. 64 output bytes at a time).
     */
 
    for (;;) {
        x = *p;
 
        /* This loop intentionally does not ensure characters are valid
         * ([0-9a-fA-F]) because the hex decode call below will do that.
         */
        if (x == DUK_ASC_PIPE) {
            break;
        } else if (x <= 0) {
            /* NUL term or -1 (EOF), NUL check would suffice */
            goto syntax_error;
        }
        p++;
    }
 
    src_len = (duk_size_t) (p - js_ctx->p);
    buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, src_len);
    DUK_ASSERT(buf != NULL);
    DUK_MEMCPY((void *) buf, (const void *) js_ctx->p, src_len);
    duk_hex_decode(ctx, -1);
 
    js_ctx->p = p + 1;  /* skip '|' */
 
    /* [ ... buf ] */
 
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_syntax_error(), DUK_ASC_PIPE, DUK_ASSERT, duk_hex_decode(), DUK_MEMCPY, duk_push_fixed_buffer, DUK_UNREACHABLE, NULL, duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_value().

duk__dec_decode_hex_escape()

DUK_LOCAL_DECL duk_uint_fast32_t duk__dec_decode_hex_escape	(	duk_json_dec_ctx *	js_ctx,
		duk_small_uint_t	n )

Definition at line 256 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                                     {
    duk_small_uint_t i;
    duk_uint_fast32_t res = 0;
    duk_uint8_t x;
    duk_small_int_t t;
 
    for (i = 0; i < n; i++) {
        /* XXX: share helper from lexer; duk_lexer.c / hexval(). */
 
        x = duk__dec_get(js_ctx);
        DUK_DDD(DUK_DDDPRINT("decode_hex_escape: i=%ld, n=%ld, res=%ld, x=%ld",
                             (long) i, (long) n, (long) res, (long) x));
 
        /* x == 0x00 (EOF) causes syntax_error */
        DUK_ASSERT(duk_hex_dectab[0] == -1);
        t = duk_hex_dectab[x & 0xff];
        if (DUK_LIKELY(t >= 0)) {
            res = (res * 16) + t;
        } else {
            /* catches EOF and invalid digits */
            goto syntax_error;
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("final hex decoded value: %ld", (long) res));
    return res;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
    return 0;
}

References duk__dec_get(), duk__dec_syntax_error(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_hex_dectab, DUK_LIKELY, and DUK_UNREACHABLE.

Referenced by duk__dec_string_escape().

duk__dec_eat_white()

DUK_LOCAL_DECL void duk__dec_eat_white

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 210 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                            {
    const duk_uint8_t *p;
    duk_uint8_t t;
 
    p = js_ctx->p;
    for (;;) {
        DUK_ASSERT(p <= js_ctx->p_end);
        t = *p;
 
#if defined(DUK_USE_JSON_EATWHITE_FASTPATH)
        /* This fast path is pretty marginal in practice.
         * XXX: candidate for removal.
         */
        DUK_ASSERT(duk__json_eatwhite_lookup[0x00] == 0x00);  /* end-of-input breaks */
        if (duk__json_eatwhite_lookup[t] == 0) {
            break;
        }
#else  /* DUK_USE_JSON_EATWHITE_FASTPATH */
        if (!(t == 0x20 || t == 0x0a || t == 0x0d || t == 0x09)) {
            /* NUL also comes here.  Comparison order matters, 0x20
             * is most common whitespace.
             */
            break;
        }
#endif  /* DUK_USE_JSON_EATWHITE_FASTPATH */
        p++;
    }
    js_ctx->p = p;
}

References duk__json_eatwhite_lookup, DUK_ASSERT, and duk_json_dec_ctx::p.

Referenced by duk__dec_get_nonwhite(), and duk__dec_value().

duk__dec_get()

DUK_LOCAL_DECL duk_uint8_t duk__dec_get

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 245 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                             {
    DUK_ASSERT(js_ctx->p <= js_ctx->p_end);
    return *js_ctx->p++;
}

References DUK_ASSERT, duk_json_dec_ctx::p, and duk_json_dec_ctx::p_end.

Referenced by duk__dec_decode_hex_escape(), duk__dec_get_nonwhite(), duk__dec_req_stridx(), duk__dec_string(), and duk__dec_string_escape().

duk__dec_get_nonwhite()

DUK_LOCAL_DECL duk_uint8_t duk__dec_get_nonwhite

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 250 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                      {
    duk__dec_eat_white(js_ctx);
    return duk__dec_get(js_ctx);
}

References duk__dec_eat_white(), and duk__dec_get().

Referenced by duk__dec_array(), duk__dec_object(), and duk__dec_value().

duk__dec_number()

DUK_LOCAL_DECL void duk__dec_number

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 641 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                         {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    const duk_uint8_t *p_start;
    const duk_uint8_t *p;
    duk_uint8_t x;
    duk_small_uint_t s2n_flags;
 
    DUK_DDD(DUK_DDDPRINT("parse_number"));
 
    p_start = js_ctx->p;
 
    /* First pass parse is very lenient (e.g. allows '1.2.3') and extracts a
     * string for strict number parsing.
     */
 
    p = js_ctx->p;
    for (;;) {
        x = *p;
 
        DUK_DDD(DUK_DDDPRINT("parse_number: p_start=%p, p=%p, p_end=%p, x=%ld",
                             (const void *) p_start, (const void *) p,
                             (const void *) js_ctx->p_end, (long) x));
 
#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH)
        /* This fast path is pretty marginal in practice.
         * XXX: candidate for removal.
         */
        DUK_ASSERT(duk__json_decnumber_lookup[0x00] == 0x00);  /* end-of-input breaks */
        if (duk__json_decnumber_lookup[x] == 0) {
            break;
        }
#else  /* DUK_USE_JSON_DECNUMBER_FASTPATH */
        if (!((x >= DUK_ASC_0 && x <= DUK_ASC_9) ||
              (x == DUK_ASC_PERIOD || x == DUK_ASC_LC_E ||
               x == DUK_ASC_UC_E || x == DUK_ASC_MINUS || x == DUK_ASC_PLUS))) {
            /* Plus sign must be accepted for positive exponents
             * (e.g. '1.5e+2').  This clause catches NULs.
             */
            break;
        }
#endif  /* DUK_USE_JSON_DECNUMBER_FASTPATH */
        p++;  /* safe, because matched (NUL causes a break) */
    }
    js_ctx->p = p;
 
    DUK_ASSERT(js_ctx->p > p_start);
    duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (p - p_start));
 
    s2n_flags = DUK_S2N_FLAG_ALLOW_EXP |
                DUK_S2N_FLAG_ALLOW_MINUS |  /* but don't allow leading plus */
                DUK_S2N_FLAG_ALLOW_FRAC;
 
    DUK_DDD(DUK_DDDPRINT("parse_number: string before parsing: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
    duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags);
    if (duk_is_nan(ctx, -1)) {
        duk__dec_syntax_error(js_ctx);
    }
    DUK_ASSERT(duk_is_number(ctx, -1));
    DUK_DDD(DUK_DDDPRINT("parse_number: final number: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    /* [ ... num ] */
}

References duk__dec_syntax_error(), duk__json_decnumber_lookup, DUK_ASC_0, DUK_ASC_9, DUK_ASC_LC_E, DUK_ASC_MINUS, DUK_ASC_PERIOD, DUK_ASC_PLUS, DUK_ASC_UC_E, DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_get_tval(), duk_is_nan(), duk_is_number(), duk_numconv_parse(), duk_push_lstring(), DUK_S2N_FLAG_ALLOW_EXP, DUK_S2N_FLAG_ALLOW_FRAC, DUK_S2N_FLAG_ALLOW_MINUS, duk_json_dec_ctx::p, duk_json_dec_ctx::p_end, and duk_json_dec_ctx::thr.

Referenced by duk__dec_value().

duk__dec_objarr_entry()

DUK_LOCAL_DECL void duk__dec_objarr_entry

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 706 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                               {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_require_stack(ctx, DUK_JSON_DEC_REQSTACK);
 
    /* c recursion check */
 
    DUK_ASSERT(js_ctx->recursion_depth >= 0);
    DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
    if (js_ctx->recursion_depth >= js_ctx->recursion_limit) {
        DUK_ERROR_RANGE((duk_hthread *) ctx, DUK_STR_JSONDEC_RECLIMIT);
    }
    js_ctx->recursion_depth++;
}

References DUK_ASSERT, DUK_ERROR_RANGE, DUK_JSON_DEC_REQSTACK, duk_require_stack(), DUK_STR_JSONDEC_RECLIMIT, duk_json_dec_ctx::recursion_depth, duk_json_dec_ctx::recursion_limit, and duk_json_dec_ctx::thr.

Referenced by duk__dec_array(), and duk__dec_object().

duk__dec_objarr_exit()

DUK_LOCAL_DECL void duk__dec_objarr_exit

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 720 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                              {
    /* c recursion check */
 
    DUK_ASSERT(js_ctx->recursion_depth > 0);
    DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
    js_ctx->recursion_depth--;
}

References DUK_ASSERT, duk_json_dec_ctx::recursion_depth, and duk_json_dec_ctx::recursion_limit.

Referenced by duk__dec_array(), and duk__dec_object().

duk__dec_object()

DUK_LOCAL_DECL void duk__dec_object

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 728 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                         {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_int_t key_count;  /* XXX: a "first" flag would suffice */
    duk_uint8_t x;
 
    DUK_DDD(DUK_DDDPRINT("parse_object"));
 
    duk__dec_objarr_entry(js_ctx);
 
    duk_push_object(ctx);
 
    /* Initial '{' has been checked and eaten by caller. */
 
    key_count = 0;
    for (;;) {
        x = duk__dec_get_nonwhite(js_ctx);
 
        DUK_DDD(DUK_DDDPRINT("parse_object: obj=%!T, x=%ld, key_count=%ld",
                             (duk_tval *) duk_get_tval(ctx, -1),
                             (long) x, (long) key_count));
 
        /* handle comma and closing brace */
 
        if (x == DUK_ASC_COMMA && key_count > 0) {
            /* accept comma, expect new value */
            x = duk__dec_get_nonwhite(js_ctx);
        } else if (x == DUK_ASC_RCURLY) {
            /* eat closing brace */
            break;
        } else if (key_count == 0) {
            /* accept anything, expect first value (EOF will be
             * caught by key parsing below.
             */
            ;
        } else {
            /* catches EOF (NUL) and initial comma */
            goto syntax_error;
        }
 
        /* parse key and value */
 
        if (x == DUK_ASC_DOUBLEQUOTE) {
            duk__dec_string(js_ctx);
#ifdef DUK_USE_JX
        } else if (js_ctx->flag_ext_custom &&
                   duk_unicode_is_identifier_start((duk_codepoint_t) x)) {
            duk__dec_plain_string(js_ctx);
#endif
        } else {
            goto syntax_error;
        }
 
        /* [ ... obj key ] */
 
        x = duk__dec_get_nonwhite(js_ctx);
        if (x != DUK_ASC_COLON) {
            goto syntax_error;
        }
 
        duk__dec_value(js_ctx);
 
        /* [ ... obj key val ] */
 
        duk_xdef_prop_wec(ctx, -3);
 
        /* [ ... obj ] */
 
        key_count++;
    }
 
    /* [ ... obj ] */
 
    DUK_DDD(DUK_DDDPRINT("parse_object: final object is %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk__dec_objarr_exit(js_ctx);
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_get_nonwhite(), duk__dec_objarr_entry(), duk__dec_objarr_exit(), duk__dec_plain_string(), duk__dec_string(), duk__dec_syntax_error(), duk__dec_value(), DUK_ASC_COLON, DUK_ASC_COMMA, DUK_ASC_DOUBLEQUOTE, DUK_ASC_RCURLY, DUK_DDD, DUK_DDDPRINT, duk_get_tval(), duk_push_object(), duk_unicode_is_identifier_start(), DUK_UNREACHABLE, duk_xdef_prop_wec, duk_json_dec_ctx::flag_ext_custom, and duk_json_dec_ctx::thr.

Referenced by duk__dec_value().

duk__dec_peek()

DUK_LOCAL_DECL duk_uint8_t duk__dec_peek

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 240 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                              {
    DUK_ASSERT(js_ctx->p <= js_ctx->p_end);
    return *js_ctx->p;
}

References DUK_ASSERT, duk_json_dec_ctx::p, and duk_json_dec_ctx::p_end.

Referenced by duk__dec_value().

duk__dec_plain_string()

DUK_LOCAL_DECL void duk__dec_plain_string

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 486 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                               {
    duk_hthread *thr = js_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    const duk_uint8_t *p;
    duk_small_int_t x;
 
    /* Caller has already eaten the first char so backtrack one byte. */
 
    js_ctx->p--;  /* safe */
    p = js_ctx->p;
 
    /* Here again we parse bytes, and non-ASCII UTF-8 will cause end of
     * parsing (which is correct except if there are non-shortest encodings).
     * There is also no need to check explicitly for end of input buffer as
     * the input is NUL padded and NUL will exit the parsing loop.
     *
     * Because no unescaping takes place, we can just scan to the end of the
     * plain string and intern from the input buffer.
     */
 
    for (;;) {
        x = *p;
 
        /* There is no need to check the first character specially here
         * (i.e. reject digits): the caller only accepts valid initial
         * characters and won't call us if the first character is a digit.
         * This also ensures that the plain string won't be empty.
         */
 
        if (!duk_unicode_is_identifier_part((duk_codepoint_t) x)) {
            break;
        }
        p++;
    }
 
    duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p));
    js_ctx->p = p;
 
    /* [ ... str ] */
}

References duk_push_lstring(), duk_unicode_is_identifier_part(), duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_object().

duk__dec_pointer()

DUK_LOCAL_DECL void duk__dec_pointer

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 529 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                          {
    duk_hthread *thr = js_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    const duk_uint8_t *p;
    duk_small_int_t x;
    void *voidptr;
 
    /* Caller has already eaten the first character ('(') which we don't need. */
 
    p = js_ctx->p;
 
    for (;;) {
        x = *p;
 
        /* Assume that the native representation never contains a closing
         * parenthesis.
         */
 
        if (x == DUK_ASC_RPAREN) {
            break;
        } else if (x <= 0) {
            /* NUL term or -1 (EOF), NUL check would suffice */
            goto syntax_error;
        }
        p++;
    }
 
    /* There is no need to NUL delimit the sscanf() call: trailing garbage is
     * ignored and there is always a NUL terminator which will force an error
     * if no error is encountered before it.  It's possible that the scan
     * would scan further than between [js_ctx->p,p[ though and we'd advance
     * by less than the scanned value.
     *
     * Because pointers are platform specific, a failure to scan a pointer
     * results in a null pointer which is a better placeholder than a missing
     * value or an error.
     */
 
    voidptr = NULL;
    (void) DUK_SSCANF((const char *) js_ctx->p, DUK_STR_FMT_PTR, &voidptr);
    duk_push_pointer(ctx, voidptr);
    js_ctx->p = p + 1;  /* skip ')' */
 
    /* [ ... ptr ] */
 
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_syntax_error(), DUK_ASC_RPAREN, duk_push_pointer(), DUK_SSCANF, DUK_STR_FMT_PTR, DUK_UNREACHABLE, NULL, duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_value().

duk__dec_req_stridx()

DUK_LOCAL_DECL void duk__dec_req_stridx	(	duk_json_dec_ctx *	js_ctx,
		duk_small_uint_t	stridx )

Definition at line 289 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                      {
    duk_hstring *h;
    const duk_uint8_t *p;
    duk_uint8_t x, y;
 
    /* First character has already been eaten and checked by the caller.
     * We can scan until a NUL in stridx string because no built-in strings
     * have internal NULs.
     */
 
    DUK_ASSERT_DISABLE(stridx >= 0);  /* unsigned */
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx);
    DUK_ASSERT(h != NULL);
 
    p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h) + 1;
    DUK_ASSERT(*(js_ctx->p - 1) == *(p - 1));  /* first character has been matched */
 
    for (;;) {
        x = *p;
        if (x == 0) {
            break;
        }
        y = duk__dec_get(js_ctx);
        if (x != y) {
            /* Catches EOF of JSON input. */
            goto syntax_error;
        }
        p++;
    }
 
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_get(), duk__dec_syntax_error(), DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_HEAP_NUM_STRINGS, DUK_HSTRING_GET_DATA, DUK_HTHREAD_GET_STRING, DUK_UNREACHABLE, NULL, duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_value().

duk__dec_reviver_walk()

DUK_LOCAL_DECL void duk__dec_reviver_walk

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 951 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                               {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hobject *h;
    duk_uarridx_t i, arr_len;
 
    DUK_DDD(DUK_DDDPRINT("walk: top=%ld, holder=%!T, name=%!T",
                         (long) duk_get_top(ctx),
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk_dup_top(ctx);
    duk_get_prop(ctx, -3);  /* -> [ ... holder name val ] */
 
    h = duk_get_hobject(ctx, -1);
    if (h != NULL) {
        if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
            arr_len = (duk_uarridx_t) duk_get_length(ctx, -1);
            for (i = 0; i < arr_len; i++) {
                /* [ ... holder name val ] */
 
                DUK_DDD(DUK_DDDPRINT("walk: array, top=%ld, i=%ld, arr_len=%ld, holder=%!T, name=%!T, val=%!T",
                                     (long) duk_get_top(ctx), (long) i, (long) arr_len,
                                     (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
                                     (duk_tval *) duk_get_tval(ctx, -1)));
 
                /* XXX: push_uint_string / push_u32_string */
                duk_dup_top(ctx);
                duk_push_uint(ctx, (duk_uint_t) i);
                duk_to_string(ctx, -1);  /* -> [ ... holder name val val ToString(i) ] */
                duk__dec_reviver_walk(js_ctx);  /* -> [ ... holder name val new_elem ] */
 
                if (duk_is_undefined(ctx, -1)) {
                    duk_pop(ctx);
                    duk_del_prop_index(ctx, -1, i);
                } else {
                    /* XXX: duk_xdef_prop_index_wec() would be more appropriate
                     * here but it currently makes some assumptions that might
                     * not hold (e.g. that previous property is not an accessor).
                     */
                    duk_put_prop_index(ctx, -2, i);
                }
            }
        } else {
            /* [ ... holder name val ] */
            duk_enum(ctx, -1, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/);
            while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) {
                DUK_DDD(DUK_DDDPRINT("walk: object, top=%ld, holder=%!T, name=%!T, val=%!T, enum=%!iT, obj_key=%!T",
                                     (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -5),
                                     (duk_tval *) duk_get_tval(ctx, -4), (duk_tval *) duk_get_tval(ctx, -3),
                                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
 
                /* [ ... holder name val enum obj_key ] */
                duk_dup(ctx, -3);
                duk_dup(ctx, -2);
 
                /* [ ... holder name val enum obj_key val obj_key ] */
                duk__dec_reviver_walk(js_ctx);
 
                /* [ ... holder name val enum obj_key new_elem ] */
                if (duk_is_undefined(ctx, -1)) {
                    duk_pop(ctx);
                    duk_del_prop(ctx, -3);
                } else {
                    /* XXX: duk_xdef_prop_index_wec() would be more appropriate
                     * here but it currently makes some assumptions that might
                     * not hold (e.g. that previous property is not an accessor).
                     *
                     * Using duk_put_prop() works incorrectly with '__proto__'
                     * if the own property with that name has been deleted.  This
                     * does not happen normally, but a clever reviver can trigger
                     * that, see complex reviver case in: test-bug-json-parse-__proto__.js.
                     */
                    duk_put_prop(ctx, -4);
                }
            }
            duk_pop(ctx);  /* pop enum */
        }
    }
 
    /* [ ... holder name val ] */
 
    duk_dup(ctx, js_ctx->idx_reviver);
    duk_insert(ctx, -4);  /* -> [ ... reviver holder name val ] */
    duk_call_method(ctx, 2);  /* -> [ ... res ] */
 
    DUK_DDD(DUK_DDDPRINT("walk: top=%ld, result=%!T",
                         (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -1)));
}

References duk__dec_reviver_walk(), duk_call_method(), DUK_DDD, DUK_DDDPRINT, duk_del_prop(), duk_del_prop_index(), duk_dup(), duk_dup_top(), duk_enum(), DUK_ENUM_OWN_PROPERTIES_ONLY, duk_get_hobject(), duk_get_length(), duk_get_prop(), duk_get_top(), duk_get_tval(), DUK_HOBJECT_CLASS_ARRAY, DUK_HOBJECT_GET_CLASS_NUMBER, duk_insert(), duk_is_undefined(), duk_next(), duk_pop(), duk_push_uint(), duk_put_prop(), duk_put_prop_index(), duk_to_string(), duk_json_dec_ctx::idx_reviver, NULL, and duk_json_dec_ctx::thr.

Referenced by duk__dec_reviver_walk(), and duk_bi_json_parse_helper().

duk__dec_string()

DUK_LOCAL_DECL void duk__dec_string

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 376 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                         {
    duk_hthread *thr = js_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
    duk_uint8_t *q;
 
    /* '"' was eaten by caller */
 
    /* Note that we currently parse -bytes-, not codepoints.
     * All non-ASCII extended UTF-8 will encode to bytes >= 0x80,
     * so they'll simply pass through (valid UTF-8 or not).
     */
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(js_ctx->thr, bw, DUK__JSON_DECSTR_BUFSIZE);
    q = DUK_BW_GET_PTR(js_ctx->thr, bw);
 
#if defined(DUK_USE_JSON_DECSTRING_FASTPATH)
    for (;;) {
        duk_small_uint_t safe;
        duk_uint8_t b, x;
        const duk_uint8_t *p;
 
        /* Select a safe loop count where no output checks are
         * needed assuming we won't encounter escapes.  Input
         * bound checks are not necessary as a NUL (guaranteed)
         * will cause a SyntaxError before we read out of bounds.
         */
 
        safe = DUK__JSON_DECSTR_CHUNKSIZE;
 
        /* Ensure space for 1:1 output plus one escape. */
        q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, safe + DUK_UNICODE_MAX_XUTF8_LENGTH, q);
 
        p = js_ctx->p;  /* temp copy, write back for next loop */
        for (;;) {
            if (safe == 0) {
                js_ctx->p = p;
                break;
            }
            safe--;
 
            /* End of input (NUL) goes through slow path and causes SyntaxError. */
            DUK_ASSERT(duk__json_decstr_lookup[0] == 0x00);
 
            b = *p++;
            x = (duk_small_int_t) duk__json_decstr_lookup[b];
            if (DUK_LIKELY(x != 0)) {
                /* Fast path, decode as is. */
                *q++ = b;
            } else if (b == DUK_ASC_DOUBLEQUOTE) {
                js_ctx->p = p;
                goto found_quote;
            } else if (b == DUK_ASC_BACKSLASH) {
                /* We've ensured space for one escaped input; then
                 * bail out and recheck (this makes escape handling
                 * quite slow but it's uncommon).
                 */
                js_ctx->p = p;
                if (duk__dec_string_escape(js_ctx, &q) != 0) {
                    goto syntax_error;
                }
                break;
            } else {
                js_ctx->p = p;
                goto syntax_error;
            }
        }
    }
 found_quote:
#else  /* DUK_USE_JSON_DECSTRING_FASTPATH */
    for (;;) {
        duk_uint8_t x;
 
        q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, DUK_UNICODE_MAX_XUTF8_LENGTH, q);
 
        x = duk__dec_get(js_ctx);
 
        if (x == DUK_ASC_DOUBLEQUOTE) {
            break;
        } else if (x == DUK_ASC_BACKSLASH) {
            if (duk__dec_string_escape(js_ctx, &q) != 0) {
                goto syntax_error;
            }
        } else if (x < 0x20) {
            /* catches EOF (NUL) */
            goto syntax_error;
        } else {
            *q++ = (duk_uint8_t) x;
        }
    }
#endif  /* DUK_USE_JSON_DECSTRING_FASTPATH */
 
    DUK_BW_SETPTR_AND_COMPACT(js_ctx->thr, bw, q);
    duk_to_string(ctx, -1);
 
    /* [ ... str ] */
 
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_get(), duk__dec_string_escape(), duk__dec_syntax_error(), DUK__JSON_DECSTR_BUFSIZE, DUK__JSON_DECSTR_CHUNKSIZE, duk__json_decstr_lookup, DUK_ASC_BACKSLASH, DUK_ASC_DOUBLEQUOTE, DUK_ASSERT, DUK_BW_ENSURE_RAW, DUK_BW_GET_PTR, DUK_BW_INIT_PUSHBUF, DUK_BW_SETPTR_AND_COMPACT, DUK_LIKELY, duk_to_string(), DUK_UNICODE_MAX_XUTF8_LENGTH, DUK_UNREACHABLE, duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_object(), and duk__dec_value().

duk__dec_string_escape()

DUK_LOCAL duk_small_int_t duk__dec_string_escape	(	duk_json_dec_ctx *	js_ctx,
		duk_uint8_t **	ext_p )

Definition at line 327 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                                {
    duk_uint_fast32_t cp;
 
    /* EOF (-1) will be cast to an unsigned value first
     * and then re-cast for the switch.  In any case, it
     * will match the default case (syntax error).
     */
    cp = (duk_uint_fast32_t) duk__dec_get(js_ctx);
    switch ((int) cp) {
    case DUK_ASC_BACKSLASH: break;
    case DUK_ASC_DOUBLEQUOTE: break;
    case DUK_ASC_SLASH: break;
    case DUK_ASC_LC_T: cp = 0x09; break;
    case DUK_ASC_LC_N: cp = 0x0a; break;
    case DUK_ASC_LC_R: cp = 0x0d; break;
    case DUK_ASC_LC_F: cp = 0x0c; break;
    case DUK_ASC_LC_B: cp = 0x08; break;
    case DUK_ASC_LC_U: {
        cp = duk__dec_decode_hex_escape(js_ctx, 4);
        break;
    }
#ifdef DUK_USE_JX
    case DUK_ASC_UC_U: {
        if (js_ctx->flag_ext_custom) {
            cp = duk__dec_decode_hex_escape(js_ctx, 8);
        } else {
            return 1;  /* syntax error */
        }
        break;
    }
    case DUK_ASC_LC_X: {
        if (js_ctx->flag_ext_custom) {
            cp = duk__dec_decode_hex_escape(js_ctx, 2);
        } else {
            return 1;  /* syntax error */
        }
        break;
    }
#endif  /* DUK_USE_JX */
    default:
        /* catches EOF (0x00) */
        return 1;  /* syntax error */
    }
 
    DUK_RAW_WRITE_XUTF8(*ext_p, cp);
 
    return 0;
}

References duk__dec_decode_hex_escape(), duk__dec_get(), DUK_ASC_BACKSLASH, DUK_ASC_DOUBLEQUOTE, DUK_ASC_LC_B, DUK_ASC_LC_F, DUK_ASC_LC_N, DUK_ASC_LC_R, DUK_ASC_LC_T, DUK_ASC_LC_U, DUK_ASC_LC_X, DUK_ASC_SLASH, DUK_ASC_UC_U, DUK_RAW_WRITE_XUTF8, and duk_json_dec_ctx::flag_ext_custom.

Referenced by duk__dec_string().

duk__dec_syntax_error()

DUK_LOCAL_DECL void duk__dec_syntax_error

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 201 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                               {
    /* Shared handler to minimize parser size.  Cause will be
     * hidden, unfortunately, but we'll have an offset which
     * is often quite enough.
     */
    DUK_ERROR_FMT1(js_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FMT_INVALID_JSON,
                   (long) (js_ctx->p - js_ctx->p_start));
}

References DUK_ERR_SYNTAX_ERROR, DUK_ERROR_FMT1, DUK_STR_FMT_INVALID_JSON, duk_json_dec_ctx::p, duk_json_dec_ctx::p_start, and duk_json_dec_ctx::thr.

Referenced by duk__dec_array(), duk__dec_buffer(), duk__dec_decode_hex_escape(), duk__dec_number(), duk__dec_object(), duk__dec_pointer(), duk__dec_req_stridx(), duk__dec_string(), duk__dec_value(), and duk_bi_json_parse_helper().

duk__dec_value()

DUK_LOCAL_DECL void duk__dec_value

(

duk_json_dec_ctx *

js_ctx

)

Definition at line 879 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                        {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_uint8_t x;
 
    x = duk__dec_get_nonwhite(js_ctx);
 
    DUK_DDD(DUK_DDDPRINT("parse_value: initial x=%ld", (long) x));
 
    /* Note: duk__dec_req_stridx() backtracks one char */
 
    if (x == DUK_ASC_DOUBLEQUOTE) {
        duk__dec_string(js_ctx);
    } else if ((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_MINUS)) {
#ifdef DUK_USE_JX
        if (js_ctx->flag_ext_custom && x == DUK_ASC_MINUS && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) {
            duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY);  /* "-Infinity", '-' has been eaten */
            duk_push_number(ctx, -DUK_DOUBLE_INFINITY);
        } else {
#else
        {  /* unconditional block */
#endif
            /* We already ate 'x', so backup one byte. */
            js_ctx->p--;  /* safe */
            duk__dec_number(js_ctx);
        }
    } else if (x == DUK_ASC_LC_T) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_TRUE);
        duk_push_true(ctx);
    } else if (x == DUK_ASC_LC_F) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_FALSE);
        duk_push_false(ctx);
    } else if (x == DUK_ASC_LC_N) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_NULL);
        duk_push_null(ctx);
#ifdef DUK_USE_JX
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LC_U) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_UNDEFINED);
        duk_push_undefined(ctx);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_N) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_NAN);
        duk_push_nan(ctx);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_I) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_INFINITY);
        duk_push_number(ctx, DUK_DOUBLE_INFINITY);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LPAREN) {
        duk__dec_pointer(js_ctx);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_PIPE) {
        duk__dec_buffer(js_ctx);
#endif
    } else if (x == DUK_ASC_LCURLY) {
        duk__dec_object(js_ctx);
    } else if (x == DUK_ASC_LBRACKET) {
        duk__dec_array(js_ctx);
    } else {
        /* catches EOF (NUL) */
        goto syntax_error;
    }
 
    duk__dec_eat_white(js_ctx);
 
    /* [ ... val ] */
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}

References duk__dec_array(), duk__dec_buffer(), duk__dec_eat_white(), duk__dec_get_nonwhite(), duk__dec_number(), duk__dec_object(), duk__dec_peek(), duk__dec_pointer(), duk__dec_req_stridx(), duk__dec_string(), duk__dec_syntax_error(), DUK_ASC_0, DUK_ASC_9, DUK_ASC_DOUBLEQUOTE, DUK_ASC_LBRACKET, DUK_ASC_LC_F, DUK_ASC_LC_N, DUK_ASC_LC_T, DUK_ASC_LC_U, DUK_ASC_LCURLY, DUK_ASC_LPAREN, DUK_ASC_MINUS, DUK_ASC_PIPE, DUK_ASC_UC_I, DUK_ASC_UC_N, DUK_DDD, DUK_DDDPRINT, DUK_DOUBLE_INFINITY, duk_push_false(), duk_push_nan(), duk_push_null(), duk_push_number(), duk_push_true(), duk_push_undefined(), DUK_STRIDX_FALSE, DUK_STRIDX_INFINITY, DUK_STRIDX_LC_NULL, DUK_STRIDX_LC_UNDEFINED, DUK_STRIDX_MINUS_INFINITY, DUK_STRIDX_NAN, DUK_STRIDX_TRUE, DUK_UNREACHABLE, duk_json_dec_ctx::flag_ext_custom, duk_json_dec_ctx::p, and duk_json_dec_ctx::thr.

Referenced by duk__dec_array(), duk__dec_object(), and duk_bi_json_parse_helper().

duk__emit_1()

DUK_LOCAL_DECL void duk__emit_1	(	duk_json_enc_ctx *	js_ctx,
		duk_uint_fast8_t	ch )

Definition at line 1053 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                          {
    DUK_BW_WRITE_ENSURE_U8(js_ctx->thr, &js_ctx->bw, ch);
}

References duk_json_enc_ctx::bw, DUK_BW_WRITE_ENSURE_U8, and duk_json_enc_ctx::thr.

duk__emit_2()

DUK_LOCAL_DECL void duk__emit_2	(	duk_json_enc_ctx *	js_ctx,
		duk_uint_fast8_t	ch1,
		duk_uint_fast8_t	ch2 )

Definition at line 1057 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                                 {
    DUK_BW_WRITE_ENSURE_U8_2(js_ctx->thr, &js_ctx->bw, ch1, ch2);
}

References duk_json_enc_ctx::bw, DUK_BW_WRITE_ENSURE_U8_2, and duk_json_enc_ctx::thr.

duk__emit_cstring()

DUK_LOCAL void duk__emit_cstring	(	duk_json_enc_ctx *	js_ctx,
		const char *	str )

Definition at line 1066 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                            {
    DUK_BW_WRITE_ENSURE_CSTRING(js_ctx->thr, &js_ctx->bw, str);
}

References duk_json_enc_ctx::bw, DUK_BW_WRITE_ENSURE_CSTRING, and duk_json_enc_ctx::thr.

duk__emit_esc_auto_fast()

DUK_LOCAL_DECL duk_uint8_t * duk__emit_esc_auto_fast	(	duk_json_enc_ctx *	js_ctx,
		duk_uint_fast32_t	cp,
		duk_uint8_t *	q )

Definition at line 1092 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                                               {
    duk_uint_fast32_t tmp;
    duk_small_uint_t dig;
 
    DUK_UNREF(js_ctx);
 
    /* Caller ensures space for at least DUK__JSON_MAX_ESC_LEN. */
 
    /* Select appropriate escape format automatically, and set 'tmp' to a
     * value encoding both the escape format character and the nybble count:
     *
     *   (nybble_count << 16) | (escape_char1) | (escape_char2)
     */
 
#ifdef DUK_USE_JX
    if (DUK_LIKELY(cp < 0x100UL)) {
        if (DUK_UNLIKELY(js_ctx->flag_ext_custom)) {
            tmp = DUK__MKESC(2, DUK_ASC_BACKSLASH, DUK_ASC_LC_X);
        } else {
            tmp = DUK__MKESC(4, DUK_ASC_BACKSLASH, DUK_ASC_LC_U);
        }
    } else
#endif
    if (DUK_LIKELY(cp < 0x10000UL)) {
        tmp = DUK__MKESC(4, DUK_ASC_BACKSLASH, DUK_ASC_LC_U);
    } else {
#ifdef DUK_USE_JX
        if (DUK_LIKELY(js_ctx->flag_ext_custom)) {
            tmp = DUK__MKESC(8, DUK_ASC_BACKSLASH, DUK_ASC_UC_U);
        } else
#endif
        {
            /* In compatible mode and standard JSON mode, output
             * something useful for non-BMP characters.  This won't
             * roundtrip but will still be more or less readable and
             * more useful than an error.
             */
            tmp = DUK__MKESC(8, DUK_ASC_UC_U, DUK_ASC_PLUS);
        }
    }
 
    *q++ = (duk_uint8_t) ((tmp >> 8) & 0xff);
    *q++ = (duk_uint8_t) (tmp & 0xff);
 
    tmp = tmp >> 16;
    while (tmp > 0) {
        tmp--;
        dig = (duk_small_uint_t) ((cp >> (4 * tmp)) & 0x0f);
        *q++ = duk_lc_digits[dig];
    }
 
    return q;
}

References DUK__MKESC, DUK_ASC_BACKSLASH, DUK_ASC_LC_U, DUK_ASC_LC_X, DUK_ASC_PLUS, DUK_ASC_UC_U, duk_lc_digits, DUK_LIKELY, DUK_UNLIKELY, DUK_UNREF, and duk_json_enc_ctx::flag_ext_custom.

Referenced by duk__enc_quote_string().

duk__emit_hstring()

DUK_LOCAL_DECL void duk__emit_hstring	(	duk_json_enc_ctx *	js_ctx,
		duk_hstring *	h )

Definition at line 1061 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                           {
    DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h);
}

References duk_json_enc_ctx::bw, DUK_BW_WRITE_ENSURE_HSTRING, and duk_json_enc_ctx::thr.

duk__emit_stridx()

DUK_LOCAL_DECL void duk__emit_stridx	(	duk_json_enc_ctx *	js_ctx,
		duk_small_uint_t	stridx )

Definition at line 1071 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                   {
    duk_hstring *h;
 
    DUK_ASSERT_DISABLE(stridx >= 0);  /* unsigned */
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx);
    DUK_ASSERT(h != NULL);
 
    DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h);
}

References duk_json_enc_ctx::bw, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_BW_WRITE_ENSURE_HSTRING, DUK_HEAP_NUM_STRINGS, DUK_HTHREAD_GET_STRING, NULL, and duk_json_enc_ctx::thr.

duk__enc_allow_into_proplist()

DUK_LOCAL_DECL duk_bool_t duk__enc_allow_into_proplist

(

duk_tval *

tv

)

Definition at line 2187 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                {
    duk_hobject *h;
    duk_small_int_t c;
 
    DUK_ASSERT(tv != NULL);
    if (DUK_TVAL_IS_STRING(tv) || DUK_TVAL_IS_NUMBER(tv)) {
        return 1;
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h);
        if (c == DUK_HOBJECT_CLASS_STRING || c == DUK_HOBJECT_CLASS_NUMBER) {
            return 1;
        }
    }
 
    return 0;
}

References DUK_ASSERT, DUK_HOBJECT_CLASS_NUMBER, DUK_HOBJECT_CLASS_STRING, DUK_HOBJECT_GET_CLASS_NUMBER, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_OBJECT, DUK_TVAL_IS_STRING, and NULL.

Referenced by duk_bi_json_stringify_helper().

duk__enc_array()

DUK_LOCAL_DECL void duk__enc_array

(

duk_json_enc_ctx *

js_ctx

)

Definition at line 1863 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                        {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_idx_t entry_top;
    duk_idx_t idx_arr;
    duk_bool_t emitted;
    duk_uarridx_t i, arr_len;
 
    DUK_DDD(DUK_DDDPRINT("duk__enc_array: array=%!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk__enc_objarr_entry(js_ctx, &entry_top);
 
    idx_arr = entry_top - 1;
 
    /* Steps 8-10 have been merged to avoid a "partial" variable. */
 
    DUK__EMIT_1(js_ctx, DUK_ASC_LBRACKET);
 
    arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_arr);
    emitted = 0;
    for (i = 0; i < arr_len; i++) {
        DUK_DDD(DUK_DDDPRINT("array entry loop: array=%!T, index=%ld, arr_len=%ld",
                             (duk_tval *) duk_get_tval(ctx, idx_arr),
                             (long) i, (long) arr_len));
 
        if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) {
            DUK_ASSERT(js_ctx->recursion_depth >= 1);
            duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth);
        }
 
        /* XXX: duk_push_uint_string() */
        duk_push_uint(ctx, (duk_uint_t) i);
        duk_to_string(ctx, -1);  /* -> [ ... key ] */
 
        /* [ ... key ] */
 
        if (DUK_UNLIKELY(duk__enc_value(js_ctx, idx_arr) == 0)) {
            /* Value would normally be omitted, replace with 'null'. */
            DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL);
        } else {
            ;
        }
 
        /* [ ... ] */
 
        DUK__EMIT_1(js_ctx, DUK_ASC_COMMA);
        emitted = 1;
    }
 
    if (emitted) {
        DUK_ASSERT(*((duk_uint8_t *) DUK_BW_GET_PTR(js_ctx->thr, &js_ctx->bw) - 1) == DUK_ASC_COMMA);
        DUK__UNEMIT_1(js_ctx);  /* eat trailing comma */
        if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) {
            DUK_ASSERT(js_ctx->recursion_depth >= 1);
            duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1);
        }
    }
    DUK__EMIT_1(js_ctx, DUK_ASC_RBRACKET);
 
    duk__enc_objarr_exit(js_ctx, &entry_top);
 
    DUK_ASSERT_TOP(ctx, entry_top);
}

References duk_json_enc_ctx::bw, DUK__EMIT_1, DUK__EMIT_STRIDX, duk__enc_newline_indent(), duk__enc_objarr_entry(), duk__enc_objarr_exit(), duk__enc_value(), DUK__UNEMIT_1, DUK_ASC_COMMA, DUK_ASC_LBRACKET, DUK_ASC_RBRACKET, DUK_ASSERT, DUK_ASSERT_TOP, DUK_BW_GET_PTR, DUK_DDD, DUK_DDDPRINT, duk_get_length(), duk_get_tval(), duk_push_uint(), DUK_STRIDX_LC_NULL, duk_to_string(), DUK_UNLIKELY, duk_json_enc_ctx::h_gap, NULL, duk_json_enc_ctx::recursion_depth, and duk_json_enc_ctx::thr.

Referenced by duk__enc_value().

duk__enc_buffer()

DUK_LOCAL_DECL void duk__enc_buffer	(	duk_json_enc_ctx *	js_ctx,
		duk_hbuffer *	h )

Definition at line 1557 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                         {
    duk__enc_buffer_data(js_ctx,
                         (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(js_ctx->thr->heap, h),
                         (duk_size_t) DUK_HBUFFER_GET_SIZE(h));
}

References duk__enc_buffer_data(), DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, duk_hthread::heap, and duk_json_enc_ctx::thr.

Referenced by duk__enc_value().

duk__enc_buffer_data()

DUK_LOCAL void duk__enc_buffer_data	(	duk_json_enc_ctx *	js_ctx,
		duk_uint8_t *	buf_data,
		duk_size_t	buf_len )

Definition at line 1503 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                                         {
    duk_hthread *thr;
    duk_uint8_t *q;
    duk_size_t space;
 
    thr = js_ctx->thr;
 
    DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);  /* caller checks */
    DUK_ASSERT(js_ctx->flag_ext_custom_or_compatible);
 
    /* Buffer values are encoded in (lowercase) hex to make the
     * binary data readable.  Base64 or similar would be more
     * compact but less readable, and the point of JX/JC
     * variants is to be as useful to a programmer as possible.
     */
 
    /* The #ifdef clutter here needs to handle the three cases:
     * (1) JX+JC, (2) JX only, (3) JC only.
     */
 
    /* Note: space must cater for both JX and JC. */
    space = 9 + buf_len * 2 + 2;
    DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7ffffffeUL);
    DUK_ASSERT((space - 2) / 2 >= buf_len);  /* overflow not possible, buffer limits */
    q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space);
 
#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
    if (js_ctx->flag_ext_custom)
#endif
#if defined(DUK_USE_JX)
    {
        *q++ = DUK_ASC_PIPE;
        q = duk__enc_buffer_data_hex(buf_data, buf_len, q);
        *q++ = DUK_ASC_PIPE;
 
    }
#endif
#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
    else
#endif
#if defined(DUK_USE_JC)
    {
        DUK_ASSERT(js_ctx->flag_ext_compatible);
        DUK_MEMCPY((void *) q, (const void *) "{\"_buf\":\"", 9);  /* len: 9 */
        q += 9;
        q = duk__enc_buffer_data_hex(buf_data, buf_len, q);
        *q++ = DUK_ASC_DOUBLEQUOTE;
        *q++ = DUK_ASC_RCURLY;
    }
#endif
 
    DUK_BW_SET_PTR(thr, &js_ctx->bw, q);
}

References duk_json_enc_ctx::bw, duk__enc_buffer_data_hex(), DUK_ASC_DOUBLEQUOTE, DUK_ASC_PIPE, DUK_ASC_RCURLY, DUK_ASSERT, DUK_BW_ENSURE_GETPTR, DUK_BW_SET_PTR, DUK_HBUFFER_MAX_BYTELEN, DUK_MEMCPY, duk_json_enc_ctx::flag_ext_compatible, duk_json_enc_ctx::flag_ext_custom, duk_json_enc_ctx::flag_ext_custom_or_compatible, and duk_json_enc_ctx::thr.

Referenced by duk__enc_buffer(), and duk__enc_bufferobject().

duk__enc_buffer_data_hex()

DUK_LOCAL duk_uint8_t * duk__enc_buffer_data_hex	(	const duk_uint8_t *	src,
		duk_size_t	src_len,
		duk_uint8_t *	dst )

Definition at line 1426 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                                              {
    duk_uint8_t *q;
    duk_uint16_t *q16;
    duk_small_uint_t x;
    duk_size_t i, len_safe;
#if !defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
    duk_bool_t shift_dst;
#endif
 
    /* Unlike in duk_hex_encode() 'dst' is not necessarily aligned by 2.
     * For platforms where unaligned accesses are not allowed, shift 'dst'
     * ahead by 1 byte to get alignment and then DUK_MEMMOVE() the result
     * in place.  The faster encoding loop makes up the difference.
     * There's always space for one extra byte because a terminator always
     * follows the hex data and that's been accounted for by the caller.
     */
 
#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
    q16 = (duk_uint16_t *) (void *) dst;
#else
    shift_dst = (duk_bool_t) (((duk_size_t) dst) & 0x01U);
    if (shift_dst) {
        DUK_DD(DUK_DDPRINT("unaligned accesses not possible, dst not aligned -> step to dst + 1"));
        q16 = (duk_uint16_t *) (void *) (dst + 1);
    } else {
        DUK_DD(DUK_DDPRINT("unaligned accesses not possible, dst is aligned"));
        q16 = (duk_uint16_t *) (void *) dst;
    }
    DUK_ASSERT((((duk_size_t) q16) & 0x01U) == 0);
#endif
 
    len_safe = src_len & ~0x03U;
    for (i = 0; i < len_safe; i += 4) {
        q16[0] = duk_hex_enctab[src[i]];
        q16[1] = duk_hex_enctab[src[i + 1]];
        q16[2] = duk_hex_enctab[src[i + 2]];
        q16[3] = duk_hex_enctab[src[i + 3]];
        q16 += 4;
    }
    q = (duk_uint8_t *) q16;
 
#if !defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
    if (shift_dst) {
        q--;
        DUK_MEMMOVE((void *) dst, (const void *) (dst + 1), 2 * len_safe);
        DUK_ASSERT(dst + 2 * len_safe == q);
    }
#endif
 
    for (; i < src_len; i++) {
        x = src[i];
        *q++ = duk_lc_digits[x >> 4];
        *q++ = duk_lc_digits[x & 0x0f];
    }
 
    return q;
}

References DUK_ASSERT, DUK_DD, DUK_DDPRINT, duk_hex_enctab, duk_lc_digits, and DUK_MEMMOVE.

Referenced by duk__enc_buffer_data().

duk__enc_bufferobject()

DUK_LOCAL_DECL void duk__enc_bufferobject	(	duk_json_enc_ctx *	js_ctx,
		duk_hbufferobject *	h_bufobj )

Definition at line 1602 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                            {
    DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
    if (h_bufobj->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) {
        DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL);
    } else {
        /* Handle both full and partial slice (as long as covered). */
        duk__enc_buffer_data(js_ctx,
                             (duk_uint8_t *) DUK_HBUFFEROBJECT_GET_SLICE_BASE(js_ctx->thr->heap, h_bufobj),
                             (duk_size_t) h_bufobj->length);
    }
}

References duk_hbufferobject::buf, DUK__EMIT_STRIDX, duk__enc_buffer_data(), DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_HBUFFEROBJECT_GET_SLICE_BASE, DUK_HBUFFEROBJECT_VALID_SLICE, DUK_STRIDX_LC_NULL, duk_hthread::heap, duk_hbufferobject::length, NULL, and duk_json_enc_ctx::thr.

Referenced by duk__enc_value().

duk__enc_double()

DUK_LOCAL_DECL void duk__enc_double

(

duk_json_enc_ctx *

js_ctx

)

Definition at line 1334 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                         {
    duk_hthread *thr;
    duk_context *ctx;
    duk_tval *tv;
    duk_double_t d;
    duk_small_int_t c;
    duk_small_int_t s;
    duk_small_uint_t stridx;
    duk_small_uint_t n2s_flags;
    duk_hstring *h_str;
 
    DUK_ASSERT(js_ctx != NULL);
    thr = js_ctx->thr;
    DUK_ASSERT(thr != NULL);
    ctx = (duk_context *) thr;
 
    /* Caller must ensure 'tv' is indeed a double and not a fastint! */
    tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
    DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
    d = DUK_TVAL_GET_DOUBLE(tv);
 
    c = (duk_small_int_t) DUK_FPCLASSIFY(d);
    s = (duk_small_int_t) DUK_SIGNBIT(d);
    DUK_UNREF(s);
 
    if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) {
        DUK_ASSERT(DUK_ISFINITE(d));
 
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
        /* Negative zero needs special handling in JX/JC because
         * it would otherwise serialize to '0', not '-0'.
         */
        if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 &&
                         (js_ctx->flag_ext_custom_or_compatible))) {
            duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_ZERO);  /* '-0' */
        } else
#endif  /* DUK_USE_JX || DUK_USE_JC */
        {
            n2s_flags = 0;
            /* [ ... number ] -> [ ... string ] */
            duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags);
        }
        h_str = duk_to_hstring(ctx, -1);
        DUK_ASSERT(h_str != NULL);
        DUK__EMIT_HSTR(js_ctx, h_str);
        return;
    }
 
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    if (!(js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
                           DUK_JSON_FLAG_EXT_COMPATIBLE))) {
        stridx = DUK_STRIDX_LC_NULL;
    } else if (c == DUK_FP_NAN) {
        stridx = js_ctx->stridx_custom_nan;
    } else if (s == 0) {
        stridx = js_ctx->stridx_custom_posinf;
    } else {
        stridx = js_ctx->stridx_custom_neginf;
    }
#else
    stridx = DUK_STRIDX_LC_NULL;
#endif
    DUK__EMIT_STRIDX(js_ctx, stridx);
}

References DUK__EMIT_HSTR, DUK__EMIT_STRIDX, DUK_ASSERT, DUK_FP_INFINITE, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_GET_TVAL_NEGIDX, DUK_ISFINITE, DUK_JSON_FLAG_EXT_COMPATIBLE, DUK_JSON_FLAG_EXT_CUSTOM, DUK_LIKELY, duk_numconv_stringify(), duk_push_hstring_stridx(), DUK_SIGNBIT, DUK_STRIDX_LC_NULL, DUK_STRIDX_MINUS_ZERO, duk_to_hstring(), DUK_TVAL_GET_DOUBLE, DUK_TVAL_IS_DOUBLE, DUK_UNLIKELY, DUK_UNREF, duk_json_enc_ctx::flag_ext_custom_or_compatible, duk_json_enc_ctx::flags, NULL, s, duk_json_enc_ctx::stridx_custom_nan, duk_json_enc_ctx::stridx_custom_neginf, duk_json_enc_ctx::stridx_custom_posinf, and duk_json_enc_ctx::thr.

Referenced by duk__enc_value().

duk__enc_key_autoquote()

DUK_LOCAL_DECL void duk__enc_key_autoquote	(	duk_json_enc_ctx *	js_ctx,
		duk_hstring *	k )

Definition at line 1146 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                {
    const duk_int8_t *p, *p_start, *p_end;  /* Note: intentionally signed. */
    duk_size_t k_len;
    duk_codepoint_t cp;
 
    DUK_ASSERT(k != NULL);
 
    /* Accept ASCII strings which conform to identifier requirements
     * as being emitted without key quotes.  Since we only accept ASCII
     * there's no need for actual decoding: 'p' is intentionally signed
     * so that bytes >= 0x80 extend to negative values and are rejected
     * as invalid identifier codepoints.
     */
 
    if (js_ctx->flag_avoid_key_quotes) {
        k_len = DUK_HSTRING_GET_BYTELEN(k);
        p_start = (const duk_int8_t *) DUK_HSTRING_GET_DATA(k);
        p_end = p_start + k_len;
        p = p_start;
 
        if (p == p_end) {
            /* Zero length string is not accepted without quotes */
            goto quote_normally;
        }
        cp = (duk_codepoint_t) (*p++);
        if (DUK_UNLIKELY(!duk_unicode_is_identifier_start(cp))) {
            goto quote_normally;
        }
        while (p < p_end) {
            cp = (duk_codepoint_t) (*p++);
            if (DUK_UNLIKELY(!duk_unicode_is_identifier_part(cp))) {
                goto quote_normally;
            }
        }
 
        /* This seems faster than emitting bytes one at a time and
         * then potentially rewinding.
         */
        DUK__EMIT_HSTR(js_ctx, k);
        return;
    }
 
 quote_normally:
    duk__enc_quote_string(js_ctx, k);
}

References DUK__EMIT_HSTR, duk__enc_quote_string(), DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_unicode_is_identifier_part(), duk_unicode_is_identifier_start(), DUK_UNLIKELY, duk_json_enc_ctx::flag_avoid_key_quotes, and NULL.

Referenced by duk__enc_object().

duk__enc_newline_indent()

DUK_LOCAL_DECL void duk__enc_newline_indent	(	duk_json_enc_ctx *	js_ctx,
		duk_int_t	depth )

Definition at line 1630 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                  {
    const duk_uint8_t *gap_data;
    duk_size_t gap_len;
    duk_size_t avail_bytes;   /* bytes of indent available for copying */
    duk_size_t need_bytes;    /* bytes of indent still needed */
    duk_uint8_t *p_start;
    duk_uint8_t *p;
 
    DUK_ASSERT(js_ctx->h_gap != NULL);
    DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap) > 0);  /* caller guarantees */
 
    DUK__EMIT_1(js_ctx, 0x0a);
    if (DUK_UNLIKELY(depth == 0)) {
        return;
    }
 
    /* To handle deeper indents efficiently, make use of copies we've
     * already emitted.  In effect we can emit a sequence of 1, 2, 4,
     * 8, etc copies, and then finish the last run.  Byte counters
     * avoid multiply with gap_len on every loop.
     */
 
    gap_data = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(js_ctx->h_gap);
    gap_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap);
    DUK_ASSERT(gap_len > 0);
 
    need_bytes = gap_len * depth;
    p = DUK_BW_ENSURE_GETPTR(js_ctx->thr, &js_ctx->bw, need_bytes);
    p_start = p;
 
    DUK_MEMCPY((void *) p, (const void *) gap_data, (size_t) gap_len);
    p += gap_len;
    avail_bytes = gap_len;
    DUK_ASSERT(need_bytes >= gap_len);
    need_bytes -= gap_len;
 
    while (need_bytes >= avail_bytes) {
        DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) avail_bytes);
        p += avail_bytes;
        need_bytes -= avail_bytes;
        avail_bytes <<= 1;
    }
 
    DUK_ASSERT(need_bytes < avail_bytes);  /* need_bytes may be zero */
    DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) need_bytes);
    p += need_bytes;
    /*avail_bytes += need_bytes*/
 
    DUK_BW_SET_PTR(js_ctx->thr, &js_ctx->bw, p);
}

References duk_json_enc_ctx::bw, depth, DUK__EMIT_1, DUK_ASSERT, DUK_BW_ENSURE_GETPTR, DUK_BW_SET_PTR, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_MEMCPY, DUK_UNLIKELY, duk_json_enc_ctx::h_gap, NULL, and duk_json_enc_ctx::thr.

Referenced by duk__enc_array(), and duk__enc_object().

duk__enc_objarr_entry()

DUK_LOCAL_DECL void duk__enc_objarr_entry	(	duk_json_enc_ctx *	js_ctx,
		duk_idx_t *	entry_top )

Definition at line 1683 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                     {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hobject *h_target;
    duk_uint_fast32_t i, n;
 
    *entry_top = duk_get_top(ctx);
 
    duk_require_stack(ctx, DUK_JSON_ENC_REQSTACK);
 
    /* Loop check using a hybrid approach: a fixed-size visited[] array
     * with overflow in a loop check object.
     */
 
    h_target = duk_get_hobject(ctx, -1);  /* object or array */
    DUK_ASSERT(h_target != NULL);
 
    n = js_ctx->recursion_depth;
    if (DUK_UNLIKELY(n > DUK_JSON_ENC_LOOPARRAY)) {
        n = DUK_JSON_ENC_LOOPARRAY;
    }
    for (i = 0; i < n; i++) {
        if (DUK_UNLIKELY(js_ctx->visiting[i] == h_target)) {
            DUK_DD(DUK_DDPRINT("slow path loop detect"));
            DUK_ERROR_TYPE((duk_hthread *) ctx, DUK_STR_CYCLIC_INPUT);
        }
    }
    if (js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY) {
        js_ctx->visiting[js_ctx->recursion_depth] = h_target;
    } else {
        duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
        duk_dup_top(ctx);  /* -> [ ... voidp voidp ] */
        if (duk_has_prop(ctx, js_ctx->idx_loop)) {
            DUK_ERROR_TYPE((duk_hthread *) ctx, DUK_STR_CYCLIC_INPUT);
        }
        duk_push_true(ctx);  /* -> [ ... voidp true ] */
        duk_put_prop(ctx, js_ctx->idx_loop);  /* -> [ ... ] */
    }
 
    /* C recursion check. */
 
    DUK_ASSERT(js_ctx->recursion_depth >= 0);
    DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
    if (js_ctx->recursion_depth >= js_ctx->recursion_limit) {
        DUK_ERROR_RANGE((duk_hthread *) ctx, DUK_STR_JSONENC_RECLIMIT);
    }
    js_ctx->recursion_depth++;
 
    DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
                         (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
}

References DUK_ASSERT, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_dup_top(), DUK_ERROR_RANGE, DUK_ERROR_TYPE, duk_get_hobject(), duk_get_top(), duk_get_tval(), duk_has_prop(), DUK_JSON_ENC_LOOPARRAY, DUK_JSON_ENC_REQSTACK, duk_push_sprintf(), duk_push_true(), duk_put_prop(), duk_require_stack(), DUK_STR_CYCLIC_INPUT, DUK_STR_FMT_PTR, DUK_STR_JSONENC_RECLIMIT, DUK_UNLIKELY, duk_json_enc_ctx::idx_loop, NULL, duk_json_enc_ctx::recursion_depth, duk_json_enc_ctx::recursion_limit, duk_json_enc_ctx::thr, and duk_json_enc_ctx::visiting.

Referenced by duk__enc_array(), and duk__enc_object().

duk__enc_objarr_exit()

DUK_LOCAL_DECL void duk__enc_objarr_exit	(	duk_json_enc_ctx *	js_ctx,
		duk_idx_t *	entry_top )

Definition at line 1735 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                    {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hobject *h_target;
 
    /* C recursion check. */
 
    DUK_ASSERT(js_ctx->recursion_depth > 0);
    DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
    js_ctx->recursion_depth--;
 
    /* Loop check. */
 
    h_target = duk_get_hobject(ctx, *entry_top - 1);  /* original target at entry_top - 1 */
    DUK_ASSERT(h_target != NULL);
 
    if (js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY) {
        /* Previous entry was inside visited[], nothing to do. */
    } else {
        duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
        duk_del_prop(ctx, js_ctx->idx_loop);  /* -> [ ... ] */
    }
 
    /* Restore stack top after unbalanced code paths. */
    duk_set_top(ctx, *entry_top);
 
    DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
                         (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
}

References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_del_prop(), duk_get_hobject(), duk_get_top(), duk_get_tval(), DUK_JSON_ENC_LOOPARRAY, duk_push_sprintf(), duk_set_top(), DUK_STR_FMT_PTR, duk_json_enc_ctx::idx_loop, NULL, duk_json_enc_ctx::recursion_depth, duk_json_enc_ctx::recursion_limit, and duk_json_enc_ctx::thr.

Referenced by duk__enc_array(), and duk__enc_object().

duk__enc_object()

DUK_LOCAL_DECL void duk__enc_object

(

duk_json_enc_ctx *

js_ctx

)

Definition at line 1768 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                         {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hstring *h_key;
    duk_idx_t entry_top;
    duk_idx_t idx_obj;
    duk_idx_t idx_keys;
    duk_bool_t emitted;
    duk_uarridx_t arr_len, i;
    duk_size_t prev_size;
 
    DUK_DDD(DUK_DDDPRINT("duk__enc_object: obj=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk__enc_objarr_entry(js_ctx, &entry_top);
 
    idx_obj = entry_top - 1;
 
    if (js_ctx->idx_proplist >= 0) {
        idx_keys = js_ctx->idx_proplist;
    } else {
        /* XXX: would be nice to enumerate an object at specified index */
        duk_dup(ctx, idx_obj);
        (void) duk_hobject_get_enumerated_keys(ctx, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/);  /* [ ... target ] -> [ ... target keys ] */
        idx_keys = duk_require_normalize_index(ctx, -1);
        /* leave stack unbalanced on purpose */
    }
 
    DUK_DDD(DUK_DDDPRINT("idx_keys=%ld, h_keys=%!T",
                         (long) idx_keys, (duk_tval *) duk_get_tval(ctx, idx_keys)));
 
    /* Steps 8-10 have been merged to avoid a "partial" variable. */
 
    DUK__EMIT_1(js_ctx, DUK_ASC_LCURLY);
 
    /* XXX: keys is an internal object with all keys to be processed
     * in its (gapless) array part.  Because nobody can touch the keys
     * object, we could iterate its array part directly (keeping in mind
     * that it can be reallocated).
     */
 
    arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_keys);
    emitted = 0;
    for (i = 0; i < arr_len; i++) {
        duk_get_prop_index(ctx, idx_keys, i);  /* -> [ ... key ] */
 
        DUK_DDD(DUK_DDDPRINT("object property loop: holder=%!T, key=%!T",
                             (duk_tval *) duk_get_tval(ctx, idx_obj),
                             (duk_tval *) duk_get_tval(ctx, -1)));
 
        h_key = duk_get_hstring(ctx, -1);
        DUK_ASSERT(h_key != NULL);
 
        prev_size = DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw);
        if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) {
            duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth);
            duk__enc_key_autoquote(js_ctx, h_key);
            DUK__EMIT_2(js_ctx, DUK_ASC_COLON, DUK_ASC_SPACE);
        } else {
            duk__enc_key_autoquote(js_ctx, h_key);
            DUK__EMIT_1(js_ctx, DUK_ASC_COLON);
        }
 
        /* [ ... key ] */
 
        if (DUK_UNLIKELY(duk__enc_value(js_ctx, idx_obj) == 0)) {
            /* Value would yield 'undefined', so skip key altogether.
             * Side effects have already happened.
             */
            DUK_BW_SET_SIZE(js_ctx->thr, &js_ctx->bw, prev_size);
        } else {
            DUK__EMIT_1(js_ctx, DUK_ASC_COMMA);
            emitted = 1;
        }
 
        /* [ ... ] */
    }
 
    if (emitted) {
        DUK_ASSERT(*((duk_uint8_t *) DUK_BW_GET_PTR(js_ctx->thr, &js_ctx->bw) - 1) == DUK_ASC_COMMA);
        DUK__UNEMIT_1(js_ctx);  /* eat trailing comma */
        if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) {
            DUK_ASSERT(js_ctx->recursion_depth >= 1);
            duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1);
        }
    }
    DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY);
 
    duk__enc_objarr_exit(js_ctx, &entry_top);
 
    DUK_ASSERT_TOP(ctx, entry_top);
}

References duk_json_enc_ctx::bw, DUK__EMIT_1, DUK__EMIT_2, duk__enc_key_autoquote(), duk__enc_newline_indent(), duk__enc_objarr_entry(), duk__enc_objarr_exit(), duk__enc_value(), DUK__UNEMIT_1, DUK_ASC_COLON, DUK_ASC_COMMA, DUK_ASC_LCURLY, DUK_ASC_RCURLY, DUK_ASC_SPACE, DUK_ASSERT, DUK_ASSERT_TOP, DUK_BW_GET_PTR, DUK_BW_GET_SIZE, DUK_BW_SET_SIZE, DUK_DDD, DUK_DDDPRINT, duk_dup(), DUK_ENUM_OWN_PROPERTIES_ONLY, duk_get_hstring(), duk_get_length(), duk_get_prop_index(), duk_get_tval(), duk_hobject_get_enumerated_keys(), duk_require_normalize_index(), DUK_UNLIKELY, duk_json_enc_ctx::h_gap, duk_json_enc_ctx::idx_proplist, NULL, duk_json_enc_ctx::recursion_depth, and duk_json_enc_ctx::thr.

Referenced by duk__enc_value().

duk__enc_pointer()

DUK_LOCAL_DECL void duk__enc_pointer	(	duk_json_enc_ctx *	js_ctx,
		void *	ptr )

Definition at line 1565 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                     {
    char buf[64];  /* XXX: how to figure correct size? */
    const char *fmt;
 
    DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);  /* caller checks */
    DUK_ASSERT(js_ctx->flag_ext_custom_or_compatible);
 
    DUK_MEMZERO(buf, sizeof(buf));
 
    /* The #ifdef clutter here needs to handle the three cases:
     * (1) JX+JC, (2) JX only, (3) JC only.
     */
#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
    if (js_ctx->flag_ext_custom)
#endif
#if defined(DUK_USE_JX)
    {
        fmt = ptr ? "(%p)" : "(null)";
    }
#endif
#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
    else
#endif
#if defined(DUK_USE_JC)
    {
        DUK_ASSERT(js_ctx->flag_ext_compatible);
        fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}";
    }
#endif
 
    /* When ptr == NULL, the format argument is unused. */
    DUK_SNPRINTF(buf, sizeof(buf) - 1, fmt, ptr);  /* must not truncate */
    DUK__EMIT_CSTR(js_ctx, buf);
}

References DUK__EMIT_CSTR, DUK_ASSERT, DUK_MEMZERO, DUK_SNPRINTF, duk_json_enc_ctx::flag_ext_compatible, duk_json_enc_ctx::flag_ext_custom, and duk_json_enc_ctx::flag_ext_custom_or_compatible.

Referenced by duk__enc_value().

duk__enc_quote_string()

DUK_LOCAL_DECL void duk__enc_quote_string	(	duk_json_enc_ctx *	js_ctx,
		duk_hstring *	h_str )

Definition at line 1197 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                   {
    duk_hthread *thr = js_ctx->thr;
    const duk_uint8_t *p, *p_start, *p_end, *p_now, *p_tmp;
    duk_uint8_t *q;
    duk_ucodepoint_t cp;  /* typed for duk_unicode_decode_xutf8() */
 
    DUK_DDD(DUK_DDDPRINT("duk__enc_quote_string: h_str=%!O", (duk_heaphdr *) h_str));
 
    DUK_ASSERT(h_str != NULL);
    p_start = DUK_HSTRING_GET_DATA(h_str);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_str);
    p = p_start;
 
    DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE);
 
    /* Encode string in small chunks, estimating the maximum expansion so that
     * there's no need to ensure space while processing the chunk.
     */
 
    while (p < p_end) {
        duk_size_t left, now, space;
 
        left = (duk_size_t) (p_end - p);
        now = (left > DUK__JSON_ENCSTR_CHUNKSIZE ?
               DUK__JSON_ENCSTR_CHUNKSIZE : left);
 
        /* Maximum expansion per input byte is 6:
         *   - invalid UTF-8 byte causes "\uXXXX" to be emitted (6/1 = 6).
         *   - 2-byte UTF-8 encodes as "\uXXXX" (6/2 = 3).
         *   - 4-byte UTF-8 encodes as "\Uxxxxxxxx" (10/4 = 2.5).
         */
        space = now * 6;
        q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space);
 
        p_now = p + now;
 
        while (p < p_now) {
#if defined(DUK_USE_JSON_QUOTESTRING_FASTPATH)
            duk_uint8_t b;
 
            b = duk__json_quotestr_lookup[*p++];
            if (DUK_LIKELY(b < 0x80)) {
                /* Most input bytes go through here. */
                *q++ = b;
            } else if (b >= 0xa0) {
                *q++ = DUK_ASC_BACKSLASH;
                *q++ = (duk_uint8_t) (b - 0x80);
            } else if (b == 0x80) {
                cp = (duk_ucodepoint_t) (*(p - 1));
                q = duk__emit_esc_auto_fast(js_ctx, cp, q);
            } else if (b == 0x7f && js_ctx->flag_ascii_only) {
                /* 0x7F is special */
                DUK_ASSERT(b == 0x81);
                cp = (duk_ucodepoint_t) 0x7f;
                q = duk__emit_esc_auto_fast(js_ctx, cp, q);
            } else {
                DUK_ASSERT(b == 0x81);
                p--;
 
                /* slow path is shared */
#else  /* DUK_USE_JSON_QUOTESTRING_FASTPATH */
            cp = *p;
 
            if (DUK_LIKELY(cp <= 0x7f)) {
                /* ascii fast path: avoid decoding utf-8 */
                p++;
                if (cp == 0x22 || cp == 0x5c) {
                    /* double quote or backslash */
                    *q++ = DUK_ASC_BACKSLASH;
                    *q++ = (duk_uint8_t) cp;
                } else if (cp < 0x20) {
                    duk_uint_fast8_t esc_char;
 
                    /* This approach is a bit shorter than a straight
                     * if-else-ladder and also a bit faster.
                     */
                    if (cp < (sizeof(duk__json_quotestr_esc) / sizeof(duk_uint8_t)) &&
                        (esc_char = duk__json_quotestr_esc[cp]) != 0) {
                        *q++ = DUK_ASC_BACKSLASH;
                        *q++ = (duk_uint8_t) esc_char;
                    } else {
                        q = duk__emit_esc_auto_fast(js_ctx, cp, q);
                    }
                } else if (cp == 0x7f && js_ctx->flag_ascii_only) {
                    q = duk__emit_esc_auto_fast(js_ctx, cp, q);
                } else {
                    /* any other printable -> as is */
                    *q++ = (duk_uint8_t) cp;
                }
            } else {
                /* slow path is shared */
#endif  /* DUK_USE_JSON_QUOTESTRING_FASTPATH */
 
                /* slow path decode */
 
                /* If XUTF-8 decoding fails, treat the offending byte as a codepoint directly
                 * and go forward one byte.  This is of course very lossy, but allows some kind
                 * of output to be produced even for internal strings which don't conform to
                 * XUTF-8.  All standard Ecmascript strings are always CESU-8, so this behavior
                 * does not violate the Ecmascript specification.  The behavior is applied to
                 * all modes, including Ecmascript standard JSON.  Because the current XUTF-8
                 * decoding is not very strict, this behavior only really affects initial bytes
                 * and truncated codepoints.
                 *
                 * Another alternative would be to scan forwards to start of next codepoint
                 * (or end of input) and emit just one replacement codepoint.
                 */
 
                p_tmp = p;
                if (!duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) {
                    /* Decode failed. */
                    cp = *p_tmp;
                    p = p_tmp + 1;
                }
 
#ifdef DUK_USE_NONSTD_JSON_ESC_U2028_U2029
                if (js_ctx->flag_ascii_only || cp == 0x2028 || cp == 0x2029) {
#else
                if (js_ctx->flag_ascii_only) {
#endif
                    q = duk__emit_esc_auto_fast(js_ctx, cp, q);
                } else {
                    /* as is */
                    DUK_RAW_WRITE_XUTF8(q, cp);
                }
            }
        }
 
        DUK_BW_SET_PTR(thr, &js_ctx->bw, q);
    }
 
    DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE);
}

References duk_json_enc_ctx::bw, DUK__EMIT_1, duk__emit_esc_auto_fast(), DUK__JSON_ENCSTR_CHUNKSIZE, duk__json_quotestr_lookup, DUK_ASC_BACKSLASH, DUK_ASC_DOUBLEQUOTE, DUK_ASSERT, DUK_BW_ENSURE_GETPTR, DUK_BW_SET_PTR, DUK_DDD, DUK_DDDPRINT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_LIKELY, DUK_RAW_WRITE_XUTF8, duk_unicode_decode_xutf8(), duk_json_enc_ctx::flag_ascii_only, left, NULL, and duk_json_enc_ctx::thr.

Referenced by duk__enc_key_autoquote(), and duk__enc_value().

duk__enc_value()

DUK_LOCAL_DECL duk_bool_t duk__enc_value	(	duk_json_enc_ctx *	js_ctx,
		duk_idx_t	idx_holder )

Definition at line 1931 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                                    {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_tmp;
    duk_tval *tv;
    duk_tval *tv_holder;
    duk_tval *tv_key;
    duk_small_int_t c;
 
    DUK_DDD(DUK_DDDPRINT("duk__enc_value: idx_holder=%ld, holder=%!T, key=%!T",
                         (long) idx_holder, (duk_tval *) duk_get_tval(ctx, idx_holder),
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    DUK_UNREF(thr);
 
    tv_holder = DUK_GET_TVAL_POSIDX(ctx, idx_holder);
    DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_holder));
    tv_key = DUK_GET_TVAL_NEGIDX(ctx, -1);
    DUK_ASSERT(DUK_TVAL_IS_STRING(tv_key));
    (void) duk_hobject_getprop(thr, tv_holder, tv_key);
 
    /* -> [ ... key val ] */
 
    DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    h_tmp = duk_get_hobject_or_lfunc_coerce(ctx, -1);
    if (h_tmp != NULL) {
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_JSON);
        h_tmp = duk_get_hobject_or_lfunc_coerce(ctx, -1);  /* toJSON() can also be a lightfunc */
 
        if (h_tmp != NULL && DUK_HOBJECT_IS_CALLABLE(h_tmp)) {
            DUK_DDD(DUK_DDDPRINT("value is object, has callable toJSON() -> call it"));
            /* XXX: duk_dup_unvalidated(ctx, -2) etc. */
            duk_dup(ctx, -2);         /* -> [ ... key val toJSON val ] */
            duk_dup(ctx, -4);         /* -> [ ... key val toJSON val key ] */
            duk_call_method(ctx, 1);  /* -> [ ... key val val' ] */
            duk_remove(ctx, -2);      /* -> [ ... key val' ] */
        } else {
            duk_pop(ctx);             /* -> [ ... key val ] */
        }
    }
 
    /* [ ... key val ] */
 
    DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    if (js_ctx->h_replacer) {
        /* XXX: Here a "slice copy" would be useful. */
        DUK_DDD(DUK_DDDPRINT("replacer is set, call replacer"));
        duk_push_hobject(ctx, js_ctx->h_replacer);  /* -> [ ... key val replacer ] */
        duk_dup(ctx, idx_holder);                   /* -> [ ... key val replacer holder ] */
        duk_dup(ctx, -4);                           /* -> [ ... key val replacer holder key ] */
        duk_dup(ctx, -4);                           /* -> [ ... key val replacer holder key val ] */
        duk_call_method(ctx, 2);                    /* -> [ ... key val val' ] */
        duk_remove(ctx, -2);                        /* -> [ ... key val' ] */
    }
 
    /* [ ... key val ] */
 
    DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
    if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h;
 
        h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
 
        if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
            duk_hbufferobject *h_bufobj;
            h_bufobj = (duk_hbufferobject *) h;
            DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
            /* Conceptually we'd extract the plain underlying buffer
             * or its slice and then do a type mask check below to
             * see if we should reject it.  Do the mask check here
             * instead to avoid making a copy of the buffer slice.
             */
 
            if (js_ctx->mask_for_undefined & DUK_TYPE_MASK_BUFFER) {
                DUK_DDD(DUK_DDDPRINT("-> bufferobject (-> plain buffer) will result in undefined (type mask check)"));
                goto pop2_undef;
            }
            DUK_DDD(DUK_DDDPRINT("-> bufferobject won't result in undefined, encode directly"));
            duk__enc_bufferobject(js_ctx, h_bufobj);
            goto pop2_emitted;
#else
            DUK_DDD(DUK_DDDPRINT("no JX/JC support, bufferobject/buffer will always result in undefined"));
            goto pop2_undef;
#endif
        } else {
            c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h);
            switch ((int) c) {
            case DUK_HOBJECT_CLASS_NUMBER: {
                DUK_DDD(DUK_DDDPRINT("value is a Number object -> coerce with ToNumber()"));
                duk_to_number(ctx, -1);
                /* The coercion potentially invokes user .valueOf() and .toString()
                 * but can't result in a function value because [[DefaultValue]] would
                 * reject such a result: test-dev-json-stringify-coercion-1.js.
                 */
                DUK_ASSERT(!duk_is_callable(ctx, -1));
                break;
            }
            case DUK_HOBJECT_CLASS_STRING: {
                DUK_DDD(DUK_DDDPRINT("value is a String object -> coerce with ToString()"));
                duk_to_string(ctx, -1);
                /* Same coercion behavior as for Number. */
                DUK_ASSERT(!duk_is_callable(ctx, -1));
                break;
            }
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
            case DUK_HOBJECT_CLASS_POINTER:
#endif
            case DUK_HOBJECT_CLASS_BOOLEAN: {
                DUK_DDD(DUK_DDDPRINT("value is a Boolean/Buffer/Pointer object -> get internal value"));
                duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
                duk_remove(ctx, -2);
                break;
            }
            default: {
                /* Normal object which doesn't get automatically coerced to a
                 * primitive value.  Functions are checked for specially.  The
                 * primitive value coercions for Number, String, Pointer, and
                 * Boolean can't result in functions so suffices to check here.
                 */
                DUK_ASSERT(h != NULL);
                if (DUK_HOBJECT_IS_CALLABLE(h)) {
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
                    if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
                                         DUK_JSON_FLAG_EXT_COMPATIBLE)) {
                        /* We only get here when doing non-standard JSON encoding */
                        DUK_DDD(DUK_DDDPRINT("-> function allowed, serialize to custom format"));
                        DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);
                        DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function);
                        goto pop2_emitted;
                    } else {
                        DUK_DDD(DUK_DDDPRINT("-> will result in undefined (function)"));
                        goto pop2_undef;
                    }
#else  /* DUK_USE_JX || DUK_USE_JC */
                    DUK_DDD(DUK_DDDPRINT("-> will result in undefined (function)"));
                    goto pop2_undef;
#endif  /* DUK_USE_JX || DUK_USE_JC */
                }
            }
            }  /* end switch */
        }
    }
 
    /* [ ... key val ] */
 
    DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    if (duk_check_type_mask(ctx, -1, js_ctx->mask_for_undefined)) {
        /* will result in undefined */
        DUK_DDD(DUK_DDDPRINT("-> will result in undefined (type mask check)"));
        goto pop2_undef;
    }
    tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    /* When JX/JC not in use, the type mask above will avoid this case if needed. */
    case DUK_TAG_UNDEFINED: {
        DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_undefined);
        break;
    }
#endif
    case DUK_TAG_NULL: {
        DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL);
        break;
    }
    case DUK_TAG_BOOLEAN: {
        DUK__EMIT_STRIDX(js_ctx, DUK_TVAL_GET_BOOLEAN(tv) ?
                         DUK_STRIDX_TRUE : DUK_STRIDX_FALSE);
        break;
    }
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    /* When JX/JC not in use, the type mask above will avoid this case if needed. */
    case DUK_TAG_POINTER: {
        duk__enc_pointer(js_ctx, DUK_TVAL_GET_POINTER(tv));
        break;
    }
#endif  /* DUK_USE_JX || DUK_USE_JC */
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
 
        duk__enc_quote_string(js_ctx, h);
        break;
    }
    case DUK_TAG_OBJECT: {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
 
        /* Function values are handled completely above (including
         * coercion results):
         */
        DUK_ASSERT(!DUK_HOBJECT_IS_CALLABLE(h));
 
        if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
            duk__enc_array(js_ctx);
        } else {
            duk__enc_object(js_ctx);
        }
        break;
    }
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
    /* When JX/JC not in use, the type mask above will avoid this case if needed. */
    case DUK_TAG_BUFFER: {
        duk__enc_buffer(js_ctx, DUK_TVAL_GET_BUFFER(tv));
        break;
    }
#endif  /* DUK_USE_JX || DUK_USE_JC */
    case DUK_TAG_LIGHTFUNC: {
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
        /* We only get here when doing non-standard JSON encoding */
        DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);
        DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function);
#else
        /* Standard JSON omits functions */
        DUK_UNREACHABLE();
#endif
        break;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
        /* Number serialization has a significant impact relative to
         * other fast path code, so careful fast path for fastints.
         */
        duk__enc_fastint_tval(js_ctx, tv);
        break;
#endif
    default: {
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        /* XXX: A fast path for usual integers would be useful when
         * fastint support is not enabled.
         */
        duk__enc_double(js_ctx);
        break;
    }
    }
 
 pop2_emitted:
    duk_pop_2(ctx); /* [ ... key val ] -> [ ... ] */
    return 1;  /* emitted */
 
 pop2_undef:
    duk_pop_2(ctx);  /* [ ... key val ] -> [ ... ] */
    return 0;  /* not emitted */
}

References DUK__EMIT_STRIDX, duk__enc_array(), duk__enc_buffer(), duk__enc_bufferobject(), duk__enc_double(), duk__enc_object(), duk__enc_pointer(), duk__enc_quote_string(), DUK_ASSERT, DUK_ASSERT_HBUFFEROBJECT_VALID, duk_call_method(), duk_check_type_mask(), DUK_DDD, DUK_DDDPRINT, duk_dup(), duk_get_hobject_or_lfunc_coerce(), duk_get_prop_stridx(), duk_get_tval(), DUK_GET_TVAL_NEGIDX, DUK_GET_TVAL_POSIDX, DUK_HOBJECT_CLASS_ARRAY, DUK_HOBJECT_CLASS_BOOLEAN, DUK_HOBJECT_CLASS_NUMBER, DUK_HOBJECT_CLASS_POINTER, DUK_HOBJECT_CLASS_STRING, DUK_HOBJECT_GET_CLASS_NUMBER, duk_hobject_getprop(), DUK_HOBJECT_IS_BUFFEROBJECT, DUK_HOBJECT_IS_CALLABLE, duk_is_callable, DUK_JSON_FLAG_EXT_COMPATIBLE, DUK_JSON_FLAG_EXT_CUSTOM, duk_pop(), duk_pop_2(), duk_push_hobject(), duk_remove(), DUK_STRIDX_FALSE, DUK_STRIDX_INT_VALUE, DUK_STRIDX_LC_NULL, DUK_STRIDX_TO_JSON, DUK_STRIDX_TRUE, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, duk_to_number(), duk_to_string(), DUK_TVAL_GET_BOOLEAN, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_OBJECT, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_OBJECT, DUK_TVAL_IS_STRING, DUK_TVAL_IS_UNUSED, DUK_TYPE_MASK_BUFFER, DUK_UNREACHABLE, DUK_UNREF, duk_json_enc_ctx::flag_ext_compatible, duk_json_enc_ctx::flag_ext_custom, duk_json_enc_ctx::flags, duk_json_enc_ctx::h_replacer, duk_json_enc_ctx::mask_for_undefined, NULL, duk_json_enc_ctx::stridx_custom_function, duk_json_enc_ctx::stridx_custom_undefined, and duk_json_enc_ctx::thr.

Referenced by duk__enc_array(), duk__enc_object(), and duk_bi_json_stringify_helper().

duk__unemit_1()

DUK_LOCAL_DECL void duk__unemit_1

(

duk_json_enc_ctx *

js_ctx

)

Definition at line 1082 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                       {
    DUK_ASSERT(DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw) >= 1);
    DUK_BW_ADD_PTR(js_ctx->thr, &js_ctx->bw, -1);
}

References duk_json_enc_ctx::bw, DUK_ASSERT, DUK_BW_ADD_PTR, DUK_BW_GET_SIZE, and duk_json_enc_ctx::thr.

duk_bi_json_object_parse()

DUK_INTERNAL duk_ret_t duk_bi_json_object_parse

(

duk_context *

ctx

)

Definition at line 3122 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                  {
    duk_bi_json_parse_helper(ctx,
                             0 /*idx_value*/,
                             1 /*idx_replacer*/,
                             0 /*flags*/);
    return 1;
}

References duk_bi_json_parse_helper().

duk_bi_json_object_stringify()

DUK_INTERNAL duk_ret_t duk_bi_json_object_stringify

(

duk_context *

ctx

)

Definition at line 3130 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                                      {
    duk_bi_json_stringify_helper(ctx,
                                 0 /*idx_value*/,
                                 1 /*idx_replacer*/,
                                 2 /*idx_space*/,
                                 0 /*flags*/);
    return 1;
}

References duk_bi_json_stringify_helper().

duk_bi_json_parse_helper()

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 )

Definition at line 2682 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                      {
    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_remove(ctx, -2);            /* -> [ ... val' ] */
    } else {
        DUK_DDD(DUK_DDDPRINT("reviver does not exist or is not callable: %!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);
}

References duk__dec_reviver_walk(), duk__dec_syntax_error(), duk__dec_value(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_dup(), duk_get_top(), duk_get_tval(), DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_INVALID_INDEX, duk_is_callable, DUK_JSON_FLAG_EXT_COMPATIBLE, DUK_JSON_FLAG_EXT_CUSTOM, DUK_MEMZERO, duk_push_hstring_stridx(), duk_push_object(), duk_put_prop_stridx(), duk_remove(), DUK_STRIDX_EMPTY_STRING, duk_to_hstring(), DUK_USE_JSON_DEC_RECLIMIT, duk_json_dec_ctx::flag_ext_compatible, duk_json_dec_ctx::flag_ext_custom, duk_json_dec_ctx::flag_ext_custom_or_compatible, duk_json_dec_ctx::flags, duk_json_dec_ctx::idx_reviver, NULL, duk_json_dec_ctx::p, duk_json_dec_ctx::p_end, duk_json_dec_ctx::p_start, duk_json_dec_ctx::recursion_depth, duk_json_dec_ctx::recursion_limit, and duk_json_dec_ctx::thr.

Referenced by duk_bi_json_object_parse().

duk_bi_json_stringify_helper()

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 )

Definition at line 2785 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                          {
    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.
     */
 
#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH)
 replace_finished:
#endif
    duk_replace(ctx, entry_top);
    duk_set_top(ctx, entry_top + 1);
 
    DUK_DDD(DUK_DDDPRINT("JSON stringify end: value=%!T, replacer=%!T, space=%!T, "
                         "flags=0x%08lx, result=%!T, 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,
                         (duk_tval *) duk_get_tval(ctx, -1),
                         (long) duk_get_top(ctx)));
 
    DUK_ASSERT(duk_get_top(ctx) == entry_top + 1);
}

References duk_json_enc_ctx::bw, duk__enc_allow_into_proplist(), duk__enc_value(), DUK__JSON_STRINGIFY_BUFSIZE, DUK_ASC_SPACE, DUK_ASSERT, DUK_BW_INIT_PUSHBUF, DUK_BW_PUSH_AS_STRING, DUK_BW_RESET_SIZE, DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_dup(), duk_enum(), DUK_ENUM_ARRAY_INDICES_ONLY, DUK_ENUM_SORT_ARRAY_INDICES, DUK_EXEC_SUCCESS, duk_get_hobject(), duk_get_hstring(), duk_get_top(), duk_get_tval(), DUK_HOBJECT_CLASS_ARRAY, DUK_HOBJECT_CLASS_NUMBER, DUK_HOBJECT_CLASS_STRING, DUK_HOBJECT_GET_CLASS_NUMBER, DUK_HOBJECT_IS_CALLABLE, DUK_HSTRING_GET_CHARLEN, DUK_INVALID_INDEX, duk_is_number(), duk_is_string(), DUK_JSON_ENC_LOOPARRAY, DUK_JSON_FLAG_ASCII_ONLY, DUK_JSON_FLAG_AVOID_KEY_QUOTES, DUK_JSON_FLAG_EXT_COMPATIBLE, DUK_JSON_FLAG_EXT_CUSTOM, DUK_MEMZERO, DUK_MS_FLAG_NO_FINALIZERS, DUK_MS_FLAG_NO_OBJECT_COMPACTION, duk_next(), duk_pop(), duk_pop_2(), duk_push_array(), duk_push_hstring_stridx(), duk_push_lstring(), duk_push_object(), duk_push_object_internal(), duk_push_pointer(), duk_push_undefined(), duk_put_prop_index(), duk_put_prop_stridx(), duk_replace(), duk_safe_call(), duk_set_top(), DUK_STRIDX_EMPTY_STRING, DUK_STRIDX_INFINITY, DUK_STRIDX_JSON_EXT_FUNCTION1, DUK_STRIDX_JSON_EXT_FUNCTION2, DUK_STRIDX_JSON_EXT_NAN, DUK_STRIDX_JSON_EXT_NEGINF, DUK_STRIDX_JSON_EXT_POSINF, DUK_STRIDX_JSON_EXT_UNDEFINED, DUK_STRIDX_LC_NULL, DUK_STRIDX_LC_UNDEFINED, DUK_STRIDX_MINUS_INFINITY, DUK_STRIDX_NAN, duk_substring(), duk_to_int_clamped(), duk_to_number(), duk_to_string(), DUK_TYPE_MASK_BUFFER, DUK_TYPE_MASK_LIGHTFUNC, DUK_TYPE_MASK_POINTER, DUK_TYPE_MASK_UNDEFINED, DUK_UNLIKELY, DUK_USE_JSON_ENC_RECLIMIT, duk_json_enc_ctx::flag_ascii_only, duk_json_enc_ctx::flag_avoid_key_quotes, duk_json_enc_ctx::flag_ext_compatible, duk_json_enc_ctx::flag_ext_custom, duk_json_enc_ctx::flag_ext_custom_or_compatible, duk_json_enc_ctx::flags, duk_json_enc_ctx::h_gap, duk_json_enc_ctx::h_replacer, duk_hthread::heap, duk_json_enc_ctx::idx_loop, duk_json_enc_ctx::idx_proplist, duk_heap::mark_and_sweep_base_flags, duk_json_enc_ctx::mask_for_undefined, NULL, duk_json_enc_ctx::recursion_depth, duk_json_enc_ctx::recursion_limit, duk_json_enc_ctx::stridx_custom_function, duk_json_enc_ctx::stridx_custom_nan, duk_json_enc_ctx::stridx_custom_neginf, duk_json_enc_ctx::stridx_custom_posinf, duk_json_enc_ctx::stridx_custom_undefined, and duk_json_enc_ctx::thr.

Referenced by duk_bi_json_object_stringify().

Variable Documentation

duk__json_decnumber_lookup

DUK_LOCAL const duk_uint8_t duk__json_decnumber_lookup[256]

Initial value:

= {
    
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00,
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}

Definition at line 165 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                              {
    /* 0x00: finish (not part of number)
     * 0x01: continue
     */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00,
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

Referenced by duk__dec_number().

duk__json_decstr_lookup

DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256]

Initial value:

= {
    
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x20, 0x21, 0x00, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x00, 0x5d, 0x5e, 0x5f,
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
}

Definition at line 117 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                           {
    /* 0x00: slow path
     * other: as is
     */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x20, 0x21, 0x00, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x00, 0x5d, 0x5e, 0x5f,
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};

Referenced by duk__dec_string().

duk__json_eatwhite_lookup

DUK_LOCAL const duk_uint8_t duk__json_eatwhite_lookup[256]

Initial value:

= {
    
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}

Definition at line 141 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                             {
    /* 0x00: finish (non-white)
     * 0x01: continue
     */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

Referenced by duk__dec_eat_white().

duk__json_quotestr_lookup

DUK_LOCAL const duk_uint8_t duk__json_quotestr_lookup[256]

Initial value:

= {
    
 
    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xe2, 0xf4, 0xee, 0x80, 0xe6, 0xf2, 0x80, 0x80,
    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
    0x20, 0x21, 0xa2, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0xdc, 0x5d, 0x5e, 0x5f,
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81
}

Definition at line 83 of file duktape-1.5.2/src-separate/duk_bi_json.c.

                                                             {
    /* 0x00 ... 0x7f: as is
     * 0x80: escape generically
     * 0x81: slow path
     * 0xa0 ... 0xff: backslash + one char
     */
 
    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xe2, 0xf4, 0xee, 0x80, 0xe6, 0xf2, 0x80, 0x80,
    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
    0x20, 0x21, 0xa2, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0xdc, 0x5d, 0x5e, 0x5f,
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81
};

Referenced by duk__enc_quote_string().