@@ -1,9 +1,9 @@

 /*

  *  duk_config.h configuration header generated by genconfig.py.

  *

- *  Git commit: 6001888049cb42656f8649db020e804bcdeca6a7

- *  Git describe: v2.5.0

- *  Git branch: master

+ *  Git commit: fffa346eff06a8764b02c31d4336f63a773a95c3

+ *  Git describe: v2.6.0

+ *  Git branch: v2-maintenance

  *

  *  Supported platforms:

  *      - Mac OSX, iPhone, Darwin

@@ -964,9 +964,7 @@

 #elif defined(DUK_F_PPC64)

 /* --- PowerPC 64-bit --- */

 #define DUK_USE_ARCH_STRING "ppc64"

-#if !defined(DUK_USE_BYTEORDER)

-#define DUK_USE_BYTEORDER 3

-#endif

+/* No forced byteorder (both little and big endian are possible). */

 #undef DUK_USE_PACKED_TVAL

 #define DUK_F_PACKED_TVAL_PROVIDED

 #elif defined(DUK_F_SPARC32)

@@ -2917,6 +2915,8 @@ typedef struct duk_hthread duk_context;

 #define DUK_USE_CACHE_CATCHER

 #define DUK_USE_CALLSTACK_LIMIT 10000

 #define DUK_USE_CBOR_BUILTIN

+#define DUK_USE_CBOR_DEC_RECLIMIT 1000

+#define DUK_USE_CBOR_ENC_RECLIMIT 1000

 #define DUK_USE_CBOR_SUPPORT

 #define DUK_USE_COMPILER_RECLIMIT 2500

 #define DUK_USE_COROUTINE_SUPPORT

@@ -1,8 +1,8 @@

 /*

- *  Single source autogenerated distributable for Duktape 2.5.0.

+ *  Single source autogenerated distributable for Duktape 2.6.0.

  *

- *  Git commit 6001888049cb42656f8649db020e804bcdeca6a7 (v2.5.0).

- *  Git branch master.

+ *  Git commit fffa346eff06a8764b02c31d4336f63a773a95c3 (v2.6.0).

+ *  Git branch v2-maintenance.

  *

  *  See Duktape AUTHORS.rst and LICENSE.txt for copyright and

  *  licensing information.

@@ -525,7 +525,8 @@ typedef union duk_double_union duk_double_union;

 	} while (0)

 #define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u)  do { \

-		if (DUK__DBLUNION_IS_NAN_NOTFULL((u))) { \

+		/* Check must be full. */ \

+		if (DUK__DBLUNION_IS_NAN_FULL((u))) { \

 			DUK__DBLUNION_SET_NAN_NOTFULL((u)); \

 		} \

 	} while (0)

@@ -537,12 +538,11 @@ typedef union duk_double_union duk_double_union;

  */

 #if defined(DUK_USE_PACKED_TVAL)

-#if defined(DUK_USE_FULL_TVAL)

 #define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u)  DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL((u))

 #define DUK_DBLUNION_IS_NAN(u)               DUK__DBLUNION_IS_NAN_FULL((u))

 #define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    DUK__DBLUNION_IS_NORMALIZED_NAN_FULL((u))

 #define DUK_DBLUNION_SET_NAN(d)              DUK__DBLUNION_SET_NAN_FULL((d))

-#else

+#if 0

 #define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u)  DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL((u))

 #define DUK_DBLUNION_IS_NAN(u)               DUK__DBLUNION_IS_NAN_NOTFULL((u))

 #define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL((u))

@@ -3141,10 +3141,12 @@ DUK_INTERNAL_DECL duk_bool_t duk_float_equals(duk_float_t x, duk_float_t y);

 /* JSON */

 #define DUK_STR_FMT_PTR                          "%p"

 #define DUK_STR_FMT_INVALID_JSON                 "invalid json (at offset %ld)"

-#define DUK_STR_JSONDEC_RECLIMIT                 "json decode recursion limit"

-#define DUK_STR_JSONENC_RECLIMIT                 "json encode recursion limit"

 #define DUK_STR_CYCLIC_INPUT                     "cyclic input"

+/* Generic codec */

+#define DUK_STR_DEC_RECLIMIT                     "decode recursion limit"

+#define DUK_STR_ENC_RECLIMIT                     "encode recursion limit"

+

 /* Object property access */

 #define DUK_STR_INVALID_BASE                     "invalid base value"

 #define DUK_STR_STRICT_CALLER_READ               "cannot read strict 'caller'"

@@ -11289,14 +11291,14 @@ DUK_INTERNAL const duk_uint8_t duk_builtins_data[4281] = {

 137,194,70,46,142,68,165,19,236,1,64,174,187,161,95,37,134,204,23,225,35,

 23,71,34,82,137,246,128,160,89,93,208,167,147,195,201,194,70,46,142,68,165,

 19,238,1,64,182,187,161,71,105,20,19,177,139,163,145,41,68,16,7,6,15,82,70,

-72,115,96,0,0,0,0,0,2,234,32,91,60,165,195,201,194,8,134,149,216,162,0,192,

-41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,195,

-192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,1,

-119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,36,

-98,232,237,156,13,26,208,211,14,102,19,87,137,91,95,128,0,10,96,24,92,0,0,

-83,2,53,56,0,0,165,3,28,204,160,160,226,100,226,200,211,76,241,240,0,1,102,

-8,22,75,64,137,73,20,230,105,133,7,19,39,22,70,154,103,143,128,0,11,48,20,

-28,76,156,113,75,34,78,62,0,0,45,3,103,31,0,0,22,65,44,57,137,62,33,179,

+72,115,96,0,0,0,0,0,15,106,32,91,60,165,195,201,194,8,134,149,216,162,0,

+192,41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,

+195,192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,

+1,119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,

+36,98,232,237,156,13,26,208,211,14,102,19,87,137,91,95,128,0,10,96,24,92,0,

+0,83,2,53,56,0,0,165,3,28,204,160,160,226,100,226,200,211,76,241,240,0,1,

+102,8,22,75,64,137,73,20,230,105,133,7,19,39,22,70,154,103,143,128,0,11,48,

+20,28,76,156,113,75,34,78,62,0,0,45,3,103,31,0,0,22,65,44,57,137,62,33,179,

 216,162,152,192,131,18,124,162,27,61,138,41,108,32,196,159,16,217,232,235,

 81,76,104,73,137,62,81,13,158,142,181,20,184,16,98,79,136,108,244,244,168,

 166,56,36,196,159,40,134,207,79,74,138,93,10,49,39,194,173,192,158,158,149,

@@ -11489,7 +11491,7 @@ DUK_INTERNAL const duk_uint8_t duk_builtins_data[4281] = {

 137,194,70,46,142,68,165,19,236,1,64,174,187,161,95,37,134,204,23,225,35,

 23,71,34,82,137,246,128,160,89,93,208,167,147,195,201,194,70,46,142,68,165,

 19,238,1,64,182,187,161,71,105,20,19,177,139,163,145,41,68,16,7,6,15,82,70,

-72,115,96,32,106,2,128,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,

+72,115,96,32,106,15,0,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,

 192,41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,

 195,192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,

 1,119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,

@@ -11689,14 +11691,14 @@ DUK_INTERNAL const duk_uint8_t duk_builtins_data[4281] = {

 137,194,70,46,142,68,165,19,236,1,64,174,187,161,95,37,134,204,23,225,35,

 23,71,34,82,137,246,128,160,89,93,208,167,147,195,201,194,70,46,142,68,165,

 19,238,1,64,182,187,161,71,105,20,19,177,139,163,145,41,68,16,7,6,15,82,70,

-72,115,96,0,2,234,32,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,192,

-41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,195,

-192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,1,

-119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,36,

-98,232,237,156,13,26,208,211,14,102,19,87,137,91,95,128,0,10,96,24,92,0,0,

-83,2,53,56,0,0,165,3,28,204,160,160,226,100,226,200,211,76,241,240,0,1,102,

-8,22,75,64,137,73,20,230,105,133,7,19,39,22,70,154,103,143,128,0,11,48,20,

-28,76,156,113,75,34,78,62,0,0,45,3,103,31,0,0,22,65,44,57,137,62,33,179,

+72,115,96,0,15,106,32,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,

+192,41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,

+195,192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,

+1,119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,

+36,98,232,237,156,13,26,208,211,14,102,19,87,137,91,95,128,0,10,96,24,92,0,

+0,83,2,53,56,0,0,165,3,28,204,160,160,226,100,226,200,211,76,241,240,0,1,

+102,8,22,75,64,137,73,20,230,105,133,7,19,39,22,70,154,103,143,128,0,11,48,

+20,28,76,156,113,75,34,78,62,0,0,45,3,103,31,0,0,22,65,44,57,137,62,33,179,

 216,162,152,192,131,18,124,162,27,61,138,41,108,32,196,159,16,217,232,235,

 81,76,104,73,137,62,81,13,158,142,181,20,184,16,98,79,136,108,244,244,168,

 166,56,36,196,159,40,134,207,79,74,138,93,10,49,39,194,173,192,158,158,149,

@@ -16443,6 +16445,7 @@ struct duk_internal_thread_state {

 	duk_ljstate lj;

 	duk_bool_t creating_error;

 	duk_hthread *curr_thread;

+	duk_uint8_t thread_state;

 	duk_int_t call_recursion_depth;

 };

@@ -16541,6 +16544,7 @@ DUK_EXTERNAL void duk_suspend(duk_hthread *thr, duk_thread_state *state) {

 	duk_memcpy((void *) &snapshot->lj, (const void *) lj, sizeof(duk_ljstate));

 	snapshot->creating_error = heap->creating_error;

 	snapshot->curr_thread = heap->curr_thread;

+	snapshot->thread_state = thr->state;

 	snapshot->call_recursion_depth = heap->call_recursion_depth;

 	lj->jmpbuf_ptr = NULL;

@@ -16550,6 +16554,8 @@ DUK_EXTERNAL void duk_suspend(duk_hthread *thr, duk_thread_state *state) {

 	heap->creating_error = 0;

 	heap->curr_thread = NULL;

 	heap->call_recursion_depth = 0;

+

+	thr->state = DUK_HTHREAD_STATE_INACTIVE;

 }

 DUK_EXTERNAL void duk_resume(duk_hthread *thr, const duk_thread_state *state) {

@@ -16566,6 +16572,8 @@ DUK_EXTERNAL void duk_resume(duk_hthread *thr, const duk_thread_state *state) {

 	DUK_ASSERT(thr->heap->pf_prevent_count == 0);

 	DUK_ASSERT(thr->heap->creating_error == 0);

+	thr->state = snapshot->thread_state;

+

 	heap = thr->heap;

 	duk_memcpy((void *) &heap->lj, (const void *) &snapshot->lj, sizeof(duk_ljstate));

@@ -20026,7 +20034,7 @@ DUK_EXTERNAL void *duk_require_buffer(duk_hthread *thr, duk_idx_t idx, duk_size_

 }

 /* Get the active buffer data area for a plain buffer or a buffer object.

- * Return NULL if the value is not a buffer.  Note that a buffer may

+ * Return NULL if the the value is not a buffer.  Note that a buffer may

  * have a NULL data pointer when its size is zero, the optional 'out_isbuffer'

  * argument allows caller to detect this reliably.

  */

@@ -30090,6 +30098,8 @@ typedef struct {

 	duk_uint8_t *buf_end;

 	duk_size_t len;

 	duk_idx_t idx_buf;

+	duk_uint_t recursion_depth;

+	duk_uint_t recursion_limit;

 } duk_cbor_encode_context;

 typedef struct {

@@ -30097,6 +30107,8 @@ typedef struct {

 	const duk_uint8_t *buf;

 	duk_size_t off;

 	duk_size_t len;

+	duk_uint_t recursion_depth;

+	duk_uint_t recursion_limit;

 } duk_cbor_decode_context;

 DUK_LOCAL void duk__cbor_encode_value(duk_cbor_encode_context *enc_ctx);

@@ -30120,6 +30132,34 @@ DUK_LOCAL void duk__cbor_encode_error(duk_cbor_encode_context *enc_ctx) {

 	(void) duk_type_error(enc_ctx->thr, "cbor encode error");

 }

+DUK_LOCAL void duk__cbor_encode_req_stack(duk_cbor_encode_context *enc_ctx) {

+	duk_require_stack(enc_ctx->thr, 4);

+}

+

+DUK_LOCAL void duk__cbor_encode_objarr_entry(duk_cbor_encode_context *enc_ctx) {

+	duk_hthread *thr = enc_ctx->thr;

+

+	/* Native stack check in object/array recursion. */

+	duk_native_stack_check(thr);

+

+	/* When working with deeply recursive structures, this is important

+	 * to ensure there's no effective depth limit.

+	 */

+	duk__cbor_encode_req_stack(enc_ctx);

+

+	DUK_ASSERT(enc_ctx->recursion_depth <= enc_ctx->recursion_limit);

+	if (enc_ctx->recursion_depth >= enc_ctx->recursion_limit) {

+		DUK_ERROR_RANGE(thr, DUK_STR_ENC_RECLIMIT);

+		DUK_WO_NORETURN(return;);

+	}

+	enc_ctx->recursion_depth++;

+}

+

+DUK_LOCAL void duk__cbor_encode_objarr_exit(duk_cbor_encode_context *enc_ctx) {

+	DUK_ASSERT(enc_ctx->recursion_depth > 0);

+	enc_ctx->recursion_depth--;

+}

+

 /* Check that a size_t is in uint32 range to avoid out-of-range casts. */

 DUK_LOCAL void duk__cbor_encode_sizet_uint32_check(duk_cbor_encode_context *enc_ctx, duk_size_t len) {

 	if (DUK_UNLIKELY(sizeof(duk_size_t) > sizeof(duk_uint32_t) && len > (duk_size_t) DUK_UINT32_MAX)) {

@@ -30522,6 +30562,8 @@ DUK_LOCAL void duk__cbor_encode_object(duk_cbor_encode_context *enc_ctx) {

 	/* Caller must ensure space. */

 	DUK_ASSERT(duk__cbor_get_reserve(enc_ctx) >= 1 + 8);

+	duk__cbor_encode_objarr_entry(enc_ctx);

+

 	/* XXX: Support for specific built-ins like Date and RegExp. */

 	if (duk_is_array(enc_ctx->thr, -1)) {

 		/* Shortest encoding for arrays >= 256 in length is actually

@@ -30546,7 +30588,7 @@ DUK_LOCAL void duk__cbor_encode_object(duk_cbor_encode_context *enc_ctx) {

 		duk__cbor_encode_uint32(enc_ctx, (duk_uint32_t) len, 0x40U);

 		duk__cbor_encode_ensure(enc_ctx, len);

 		p = enc_ctx->ptr;

-		duk_memcpy((void *) p, (const void *) buf, len);

+		duk_memcpy_unsafe((void *) p, (const void *) buf, len);

 		p += len;

 		enc_ctx->ptr = p;

 	} else {

@@ -30585,6 +30627,8 @@ DUK_LOCAL void duk__cbor_encode_object(duk_cbor_encode_context *enc_ctx) {

 			enc_ctx->ptr = p;

 		}

 	}

+

+	duk__cbor_encode_objarr_exit(enc_ctx);

 }

 DUK_LOCAL void duk__cbor_encode_buffer(duk_cbor_encode_context *enc_ctx) {

@@ -30601,7 +30645,7 @@ DUK_LOCAL void duk__cbor_encode_buffer(duk_cbor_encode_context *enc_ctx) {

 	duk__cbor_encode_uint32(enc_ctx, (duk_uint32_t) len, 0x40U);

 	duk__cbor_encode_ensure(enc_ctx, len);

 	p = enc_ctx->ptr;

-	duk_memcpy((void *) p, (const void *) buf, len);

+	duk_memcpy_unsafe((void *) p, (const void *) buf, len);

 	p += len;

 	enc_ctx->ptr = p;

 }

@@ -30648,11 +30692,6 @@ DUK_LOCAL void duk__cbor_encode_value(duk_cbor_encode_context *enc_ctx) {

 	 * This can be improved by registering custom tags with IANA.

 	 */

-	/* When working with deeply recursive structures, this is important

-	 * to ensure there's no effective depth limit.

-	 */

-	duk_require_stack(enc_ctx->thr, 4);

-

 	/* Reserve space for up to 64-bit types (1 initial byte + 8

 	 * followup bytes).  This allows encoding of integers, floats,

 	 * string/buffer length fields, etc without separate checks

@@ -30720,12 +30759,33 @@ DUK_LOCAL void duk__cbor_encode_value(duk_cbor_encode_context *enc_ctx) {

  *  Decoding

  */

-DUK_LOCAL void duk__cbor_req_stack(duk_cbor_decode_context *dec_ctx) {

+DUK_LOCAL void duk__cbor_decode_error(duk_cbor_decode_context *dec_ctx) {

+	(void) duk_type_error(dec_ctx->thr, "cbor decode error");

+}

+

+DUK_LOCAL void duk__cbor_decode_req_stack(duk_cbor_decode_context *dec_ctx) {

 	duk_require_stack(dec_ctx->thr, 4);

 }

-DUK_LOCAL void duk__cbor_decode_error(duk_cbor_decode_context *dec_ctx) {

-	(void) duk_type_error(dec_ctx->thr, "cbor decode error");

+DUK_LOCAL void duk__cbor_decode_objarr_entry(duk_cbor_decode_context *dec_ctx) {

+	duk_hthread *thr = dec_ctx->thr;

+

+	/* Native stack check in object/array recursion. */

+	duk_native_stack_check(thr);

+

+	duk__cbor_decode_req_stack(dec_ctx);

+

+	DUK_ASSERT(dec_ctx->recursion_depth <= dec_ctx->recursion_limit);

+	if (dec_ctx->recursion_depth >= dec_ctx->recursion_limit) {

+		DUK_ERROR_RANGE(thr, DUK_STR_DEC_RECLIMIT);

+		DUK_WO_NORETURN(return;);

+	}

+	dec_ctx->recursion_depth++;

+}

+

+DUK_LOCAL void duk__cbor_decode_objarr_exit(duk_cbor_decode_context *dec_ctx) {

+	DUK_ASSERT(dec_ctx->recursion_depth > 0);

+	dec_ctx->recursion_depth--;

 }

 DUK_LOCAL duk_uint8_t duk__cbor_decode_readbyte(duk_cbor_decode_context *dec_ctx) {

@@ -31004,9 +31064,7 @@ DUK_LOCAL void duk__cbor_decode_join_buffers(duk_cbor_decode_context *dec_ctx, d

 			buf_data = (duk_uint8_t *) duk_require_buffer(dec_ctx->thr, idx, &buf_size);

 			if (p != NULL) {

-				if (buf_size > 0U) {

-					duk_memcpy((void *) p, (const void *) buf_data, buf_size);

-				}

+				duk_memcpy_unsafe((void *) p, (const void *) buf_data, buf_size);

 				p += buf_size;

 			} else {

 				total_size += buf_size;

@@ -31171,7 +31229,7 @@ DUK_LOCAL void duk__cbor_decode_string(duk_cbor_decode_context *dec_ctx, duk_uin

 DUK_LOCAL duk_bool_t duk__cbor_decode_array(duk_cbor_decode_context *dec_ctx, duk_uint8_t ib, duk_uint8_t ai) {

 	duk_uint32_t idx, len;

-	duk__cbor_req_stack(dec_ctx);

+	duk__cbor_decode_objarr_entry(dec_ctx);

 	/* Support arrays up to 0xfffffffeU in length.  0xffffffff is

 	 * used as an indefinite length marker.

@@ -31181,7 +31239,7 @@ DUK_LOCAL duk_bool_t duk__cbor_decode_array(duk_cbor_decode_context *dec_ctx, du

 	} else {

 		len = duk__cbor_decode_aival_uint32(dec_ctx, ib);

 		if (len == 0xffffffffUL) {

-			return 0;

+			goto failure;

 		}

 	}

@@ -31193,7 +31251,7 @@ DUK_LOCAL duk_bool_t duk__cbor_decode_array(duk_cbor_decode_context *dec_ctx, du

 		}

 		if (idx == len) {

 			if (ai == 0x1fU) {

-				return 0;

+				goto failure;

 			}

 			break;

 		}

@@ -31201,24 +31259,32 @@ DUK_LOCAL duk_bool_t duk__cbor_decode_array(duk_cbor_decode_context *dec_ctx, du

 		duk_put_prop_index(dec_ctx->thr, -2, (duk_uarridx_t) idx);

 		idx++;

 		if (idx == 0U) {

-			return 0;  /* wrapped */

+			goto failure;  /* wrapped */

 		}

 	}

+#if 0

+ success:

+#endif

+	duk__cbor_decode_objarr_exit(dec_ctx);

 	return 1;

+

+ failure:

+	/* No need to unwind recursion checks, caller will throw. */

+	return 0;

 }

 DUK_LOCAL duk_bool_t duk__cbor_decode_map(duk_cbor_decode_context *dec_ctx, duk_uint8_t ib, duk_uint8_t ai) {

 	duk_uint32_t count;

-	duk__cbor_req_stack(dec_ctx);

+	duk__cbor_decode_objarr_entry(dec_ctx);

 	if (ai == 0x1fU) {

 		count = 0xffffffffUL;

 	} else {

 		count = duk__cbor_decode_aival_uint32(dec_ctx, ib);

 		if (count == 0xffffffffUL) {

-			return 0;

+			goto failure;

 		}

 	}

@@ -31249,7 +31315,15 @@ DUK_LOCAL duk_bool_t duk__cbor_decode_map(duk_cbor_decode_context *dec_ctx, duk_

 		duk_put_prop(dec_ctx->thr, -3);

 	}

+#if 0

+ success:

+#endif

+	duk__cbor_decode_objarr_exit(dec_ctx);

 	return 1;

+

+ failure:

+	/* No need to unwind recursion checks, caller will throw. */

+	return 0;

 }

 DUK_LOCAL duk_double_t duk__cbor_decode_float(duk_cbor_decode_context *dec_ctx) {

@@ -31626,8 +31700,13 @@ DUK_LOCAL void duk__cbor_encode(duk_hthread *thr, duk_idx_t idx, duk_uint_t enco

 	enc_ctx.buf = buf;

 	enc_ctx.buf_end = buf + enc_ctx.len;

+	enc_ctx.recursion_depth = 0;

+	enc_ctx.recursion_limit = DUK_USE_CBOR_ENC_RECLIMIT;

+

 	duk_dup(thr, idx);

+	duk__cbor_encode_req_stack(&enc_ctx);

 	duk__cbor_encode_value(&enc_ctx);

+	DUK_ASSERT(enc_ctx.recursion_depth == 0);

 	duk_resize_buffer(enc_ctx.thr, enc_ctx.idx_buf, (duk_size_t) (enc_ctx.ptr - enc_ctx.buf));

 	duk_replace(thr, idx);

 }

@@ -31649,8 +31728,12 @@ DUK_LOCAL void duk__cbor_decode(duk_hthread *thr, duk_idx_t idx, duk_uint_t deco

 	dec_ctx.off = 0;

 	/* dec_ctx.len: set above */

-	duk__cbor_req_stack(&dec_ctx);

+	dec_ctx.recursion_depth = 0;

+	dec_ctx.recursion_limit = DUK_USE_CBOR_DEC_RECLIMIT;

+

+	duk__cbor_decode_req_stack(&dec_ctx);

 	duk__cbor_decode_value(&dec_ctx);

+	DUK_ASSERT(dec_ctx.recursion_depth == 0);

 	if (dec_ctx.off != dec_ctx.len) {

 		(void) duk_type_error(thr, "trailing garbage");

 	}

@@ -36373,28 +36456,28 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_hthread *thr) {

 #define DUK__JSON_STRINGIFY_BUFSIZE 128

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

-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 void duk__json_dec_syntax_error(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_eat_white(duk_json_dec_ctx *js_ctx);

 #if defined(DUK_USE_JX)

-DUK_LOCAL_DECL duk_uint8_t duk__dec_peek(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL duk_uint8_t duk__json_dec_peek(duk_json_dec_ctx *js_ctx);

 #endif

-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 duk_uint8_t duk__json_dec_get(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL duk_uint8_t duk__json_dec_get_nonwhite(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL duk_uint_fast32_t duk__json_dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n);

+DUK_LOCAL_DECL void duk__json_dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx);

+DUK_LOCAL_DECL void duk__json_dec_string(duk_json_dec_ctx *js_ctx);

 #if defined(DUK_USE_JX)

-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);

-#endif

-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__json_dec_plain_string(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_pointer(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_buffer(duk_json_dec_ctx *js_ctx);

+#endif

+DUK_LOCAL_DECL void duk__json_dec_number(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_objarr_entry(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_objarr_exit(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_object(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_array(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_dec_value(duk_json_dec_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_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);

@@ -36405,29 +36488,29 @@ DUK_LOCAL_DECL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *p);

 #endif

 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__json_enc_key_autoquote(duk_json_enc_ctx *js_ctx, duk_hstring *k);

+DUK_LOCAL_DECL void duk__json_enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str);

+DUK_LOCAL_DECL void duk__json_enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top);

+DUK_LOCAL_DECL void duk__json_enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top);

+DUK_LOCAL_DECL void duk__json_enc_object(duk_json_enc_ctx *js_ctx);

+DUK_LOCAL_DECL void duk__json_enc_array(duk_json_enc_ctx *js_ctx);

+DUK_LOCAL_DECL duk_bool_t duk__json_enc_value(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder);

+DUK_LOCAL_DECL duk_bool_t duk__json_enc_allow_into_proplist(duk_tval *tv);

+DUK_LOCAL_DECL void duk__json_enc_double(duk_json_enc_ctx *js_ctx);

 #if defined(DUK_USE_FASTINT)

-DUK_LOCAL_DECL void duk__enc_fastint_tval(duk_json_enc_ctx *js_ctx, duk_tval *tv);

+DUK_LOCAL_DECL void duk__json_enc_fastint_tval(duk_json_enc_ctx *js_ctx, duk_tval *tv);

 #endif

 #if defined(DUK_USE_JX) || defined(DUK_USE_JC)

-DUK_LOCAL_DECL void duk__enc_buffer_jx_jc(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__json_enc_buffer_jx_jc(duk_json_enc_ctx *js_ctx, duk_hbuffer *h);

+DUK_LOCAL_DECL void duk__json_enc_pointer(duk_json_enc_ctx *js_ctx, void *ptr);

 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)

-DUK_LOCAL_DECL void duk__enc_bufobj(duk_json_enc_ctx *js_ctx, duk_hbufobj *h_bufobj);

+DUK_LOCAL_DECL void duk__json_enc_bufobj(duk_json_enc_ctx *js_ctx, duk_hbufobj *h_bufobj);

 #endif

 #endif

 #if defined(DUK_USE_JSON_STRINGIFY_FASTPATH)

-DUK_LOCAL_DECL void duk__enc_buffer_json_fastpath(duk_json_enc_ctx *js_ctx, duk_hbuffer *h);

+DUK_LOCAL_DECL void duk__json_enc_buffer_json_fastpath(duk_json_enc_ctx *js_ctx, duk_hbuffer *h);

 #endif

-DUK_LOCAL_DECL void duk__enc_newline_indent(duk_json_enc_ctx *js_ctx, duk_uint_t depth);

+DUK_LOCAL_DECL void duk__json_enc_newline_indent(duk_json_enc_ctx *js_ctx, duk_uint_t depth);

 /*

  *  Helper tables

@@ -36552,7 +36635,7 @@ DUK_LOCAL const duk_uint8_t duk__json_decnumber_lookup[256] = {

  *  CESU-8 encodings.

  */

-DUK_LOCAL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_syntax_error(duk_json_dec_ctx *js_ctx) {

 	/* Shared handler to minimize parser size.  Cause will be

 	 * hidden, unfortunately, but we'll have an offset which

 	 * is often quite enough.

@@ -36562,7 +36645,7 @@ DUK_LOCAL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx) {

 	DUK_WO_NORETURN(return;);

 }

-DUK_LOCAL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_eat_white(duk_json_dec_ctx *js_ctx) {

 	const duk_uint8_t *p;

 	duk_uint8_t t;

@@ -36593,24 +36676,24 @@ DUK_LOCAL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx) {

 }

 #if defined(DUK_USE_JX)

-DUK_LOCAL duk_uint8_t duk__dec_peek(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL duk_uint8_t duk__json_dec_peek(duk_json_dec_ctx *js_ctx) {

 	DUK_ASSERT(js_ctx->p <= js_ctx->p_end);

 	return *js_ctx->p;

 }

 #endif

-DUK_LOCAL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL duk_uint8_t duk__json_dec_get(duk_json_dec_ctx *js_ctx) {

 	DUK_ASSERT(js_ctx->p <= js_ctx->p_end);

 	return *js_ctx->p++;

 }

-DUK_LOCAL duk_uint8_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) {

-	duk__dec_eat_white(js_ctx);

-	return duk__dec_get(js_ctx);

+DUK_LOCAL duk_uint8_t duk__json_dec_get_nonwhite(duk_json_dec_ctx *js_ctx) {

+	duk__json_dec_eat_white(js_ctx);

+	return duk__json_dec_get(js_ctx);

 }

 /* For JX, expressing the whole unsigned 32-bit range matters. */

-DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n) {

+DUK_LOCAL duk_uint_fast32_t duk__json_dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n) {

 	duk_small_uint_t i;

 	duk_uint_fast32_t res = 0;

 	duk_uint8_t x;

@@ -36619,7 +36702,7 @@ DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx,

 	for (i = 0; i < n; i++) {

 		/* XXX: share helper from lexer; duk_lexer.c / hexval(). */

-		x = duk__dec_get(js_ctx);

+		x = duk__json_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));

@@ -36638,12 +36721,12 @@ DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx,

 	return res;

  syntax_error:

-	duk__dec_syntax_error(js_ctx);

+	duk__json_dec_syntax_error(js_ctx);

 	DUK_UNREACHABLE();

 	return 0;

 }

-DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx) {

+DUK_LOCAL void duk__json_dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx) {

 	duk_hstring *h;

 	const duk_uint8_t *p;

 	duk_uint8_t x, y;

@@ -36665,7 +36748,7 @@ DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t st

 		if (x == 0) {

 			break;

 		}

-		y = duk__dec_get(js_ctx);

+		y = duk__json_dec_get(js_ctx);

 		if (x != y) {

 			/* Catches EOF of JSON input. */

 			goto syntax_error;

@@ -36676,18 +36759,18 @@ DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t st

 	return;

  syntax_error:

-	duk__dec_syntax_error(js_ctx);

+	duk__json_dec_syntax_error(js_ctx);

 	DUK_UNREACHABLE();

 }

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

+DUK_LOCAL duk_small_int_t duk__json_dec_string_escape(duk_json_dec_ctx *js_ctx, duk_uint8_t **ext_p) {

 	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);

+	cp = (duk_uint_fast32_t) duk__json_dec_get(js_ctx);

 	switch (cp) {

 	case DUK_ASC_BACKSLASH: break;

 	case DUK_ASC_DOUBLEQUOTE: break;

@@ -36698,13 +36781,13 @@ DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_u

 	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);

+		cp = duk__json_dec_decode_hex_escape(js_ctx, 4);

 		break;

 	}

 #if defined(DUK_USE_JX)

 	case DUK_ASC_UC_U: {

 		if (js_ctx->flag_ext_custom) {

-			cp = duk__dec_decode_hex_escape(js_ctx, 8);

+			cp = duk__json_dec_decode_hex_escape(js_ctx, 8);

 		} else {

 			return 1;  /* syntax error */

 		}

@@ -36712,7 +36795,7 @@ DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_u

 	}

 	case DUK_ASC_LC_X: {

 		if (js_ctx->flag_ext_custom) {

-			cp = duk__dec_decode_hex_escape(js_ctx, 2);

+			cp = duk__json_dec_decode_hex_escape(js_ctx, 2);

 		} else {

 			return 1;  /* syntax error */

 		}

@@ -36729,7 +36812,7 @@ DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_u

 	return 0;

 }

-DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_string(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = js_ctx->thr;

 	duk_bufwriter_ctx bw_alloc;

 	duk_bufwriter_ctx *bw;

@@ -36788,7 +36871,7 @@ DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) {

 				 * quite slow but it's uncommon).

 				 */

 				js_ctx->p = p;

-				if (duk__dec_string_escape(js_ctx, &q) != 0) {

+				if (duk__json_dec_string_escape(js_ctx, &q) != 0) {

 					goto syntax_error;

 				}

 				break;

@@ -36805,12 +36888,12 @@ DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) {

 		q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, DUK_UNICODE_MAX_XUTF8_LENGTH, q);

-		x = duk__dec_get(js_ctx);

+		x = duk__json_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) {

+			if (duk__json_dec_string_escape(js_ctx, &q) != 0) {

 				goto syntax_error;

 			}

 		} else if (x < 0x20) {

@@ -36830,7 +36913,7 @@ DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) {

 	return;

  syntax_error:

-	duk__dec_syntax_error(js_ctx);

+	duk__json_dec_syntax_error(js_ctx);

 	DUK_UNREACHABLE();

 }

@@ -36838,7 +36921,7 @@ DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) {

 /* Decode a plain string consisting entirely of identifier characters.

  * Used to parse plain keys (e.g. "foo: 123").

  */

-DUK_LOCAL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_plain_string(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = js_ctx->thr;

 	const duk_uint8_t *p;

 	duk_small_int_t x;

@@ -36880,7 +36963,7 @@ DUK_LOCAL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx) {

 #endif  /* DUK_USE_JX */

 #if defined(DUK_USE_JX)

-DUK_LOCAL void duk__dec_pointer(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_pointer(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = js_ctx->thr;

 	const duk_uint8_t *p;

 	duk_small_int_t x;

@@ -36927,13 +37010,13 @@ DUK_LOCAL void duk__dec_pointer(duk_json_dec_ctx *js_ctx) {

 	return;

  syntax_error:

-	duk__dec_syntax_error(js_ctx);

+	duk__json_dec_syntax_error(js_ctx);

 	DUK_UNREACHABLE();

 }

 #endif  /* DUK_USE_JX */

 #if defined(DUK_USE_JX)

-DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_buffer(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = js_ctx->thr;

 	const duk_uint8_t *p;

 	duk_uint8_t *buf;

@@ -36985,13 +37068,13 @@ DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) {

 	return;

  syntax_error:

-	duk__dec_syntax_error(js_ctx);

+	duk__json_dec_syntax_error(js_ctx);

 	DUK_UNREACHABLE();

 }

 #endif  /* DUK_USE_JX */

 /* Parse a number, other than NaN or +/- Infinity */

-DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_number(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = js_ctx->thr;

 	const duk_uint8_t *p_start;

 	const duk_uint8_t *p;

@@ -37047,7 +37130,7 @@ DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) {

 	                     (duk_tval *) duk_get_tval(thr, -1)));

 	duk_numconv_parse(thr, 10 /*radix*/, s2n_flags);

 	if (duk_is_nan(thr, -1)) {

-		duk__dec_syntax_error(js_ctx);

+		duk__json_dec_syntax_error(js_ctx);

 	}

 	DUK_ASSERT(duk_is_number(thr, -1));

 	DUK_DDD(DUK_DDDPRINT("parse_number: final number: %!T",

@@ -37056,22 +37139,24 @@ DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) {

 	/* [ ... num ] */

 }

-DUK_LOCAL void duk__dec_objarr_entry(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_objarr_entry(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = js_ctx->thr;

 	duk_require_stack(thr, DUK_JSON_DEC_REQSTACK);

 	/* c recursion check */

+	duk_native_stack_check(thr);

+

 	DUK_ASSERT_DISABLE(js_ctx->recursion_depth >= 0);  /* unsigned */

 	DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);

 	if (js_ctx->recursion_depth >= js_ctx->recursion_limit) {

-		DUK_ERROR_RANGE(thr, DUK_STR_JSONDEC_RECLIMIT);

+		DUK_ERROR_RANGE(thr, DUK_STR_DEC_RECLIMIT);

 		DUK_WO_NORETURN(return;);

 	}

 	js_ctx->recursion_depth++;

 }

-DUK_LOCAL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_objarr_exit(duk_json_dec_ctx *js_ctx) {

 	/* c recursion check */

 	DUK_ASSERT(js_ctx->recursion_depth > 0);

@@ -37079,14 +37164,14 @@ DUK_LOCAL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx) {

 	js_ctx->recursion_depth--;

 }

-DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_object(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = 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__json_dec_objarr_entry(js_ctx);

 	duk_push_object(thr);

@@ -37094,7 +37179,7 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {

 	key_count = 0;

 	for (;;) {

-		x = duk__dec_get_nonwhite(js_ctx);

+		x = duk__json_dec_get_nonwhite(js_ctx);

 		DUK_DDD(DUK_DDDPRINT("parse_object: obj=%!T, x=%ld, key_count=%ld",

 		                     (duk_tval *) duk_get_tval(thr, -1),

@@ -37104,7 +37189,7 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {

 		if (x == DUK_ASC_COMMA && key_count > 0) {

 			/* accept comma, expect new value */

-			x = duk__dec_get_nonwhite(js_ctx);

+			x = duk__json_dec_get_nonwhite(js_ctx);

 		} else if (x == DUK_ASC_RCURLY) {

 			/* eat closing brace */

 			break;

@@ -37121,11 +37206,11 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {

 		/* parse key and value */

 		if (x == DUK_ASC_DOUBLEQUOTE) {

-			duk__dec_string(js_ctx);

+			duk__json_dec_string(js_ctx);

 #if defined(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);

+			duk__json_dec_plain_string(js_ctx);

 #endif

 		} else {

 			goto syntax_error;

@@ -37133,12 +37218,12 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {

 		/* [ ... obj key ] */

-		x = duk__dec_get_nonwhite(js_ctx);

+		x = duk__json_dec_get_nonwhite(js_ctx);

 		if (x != DUK_ASC_COLON) {

 			goto syntax_error;

 		}

-		duk__dec_value(js_ctx);

+		duk__json_dec_value(js_ctx);

 		/* [ ... obj key val ] */

@@ -37154,22 +37239,22 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {

 	DUK_DDD(DUK_DDDPRINT("parse_object: final object is %!T",

 	                     (duk_tval *) duk_get_tval(thr, -1)));

-	duk__dec_objarr_exit(js_ctx);

+	duk__json_dec_objarr_exit(js_ctx);

 	return;

  syntax_error:

-	duk__dec_syntax_error(js_ctx);

+	duk__json_dec_syntax_error(js_ctx);

 	DUK_UNREACHABLE();

 }

-DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) {

+DUK_LOCAL void duk__json_dec_array(duk_json_dec_ctx *js_ctx) {

 	duk_hthread *thr = 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__json_dec_objarr_entry(js_ctx);

 	duk_push_array(thr);

@@ -37177,7 +37262,7 @@ DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) {

 	arr_idx = 0;

 	for (;;) {

-		x = duk__dec_get_nonwhite(js_ctx);

+		x = duk__json_dec_get_nonwhite(js_ctx);

 		DUK_DDD(DUK_DDDPRINT("parse_array: arr=%!T, x=%ld, arr_idx=%ld",

 		                     (duk_tval *) duk_get_tval(thr, -1),

@@ -37193,7 +37278,7 @@ DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) {

 			break;

 		} else if (arr_idx == 0) {

 			/* accept anything, expect first value (EOF will be

-			 * caught by duk__dec_value() below.

+			 * caught by duk__json_dec_value() below.

 			 */

 			js_ctx->p--;  /* backtrack (safe) */

 		} else {

@@ -37203,7 +37288,7 @@ DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) {

 		/* parse value */

-		duk__dec_value(js_ctx);

+		duk__json_dec_value(js_ctx);

 		/* [ ... arr val ] */