NetSurf
Data Structures | Macros | Typedefs | Functions | Variables
duktape.c File Reference
#include "duktape.h"
Include dependency graph for duktape.c:

Go to the source code of this file.

Data Structures

union  duk_double_union
 
struct  duk_jmpbuf
 
struct  duk_tval_unused
 
struct  duk_bitdecoder_ctx
 
struct  duk_bitencoder_ctx
 
struct  duk_bufwriter_ctx
 
struct  duk_token
 
struct  duk_re_token
 
struct  duk_lexer_point
 
struct  duk_lexer_codepoint
 
struct  duk_lexer_ctx
 
struct  duk_ispec
 
struct  duk_ivalue
 
struct  duk_compiler_instr
 
struct  duk_labelinfo
 
struct  duk_compiler_func
 
struct  duk_compiler_ctx
 
struct  duk_re_matcher_ctx
 
struct  duk_re_compiler_ctx
 
struct  duk_heaphdr
 
struct  duk_heaphdr_string
 
struct  duk_hstring
 
struct  duk_hstring_external
 
struct  duk_propaccessor
 
union  duk_propvalue
 
struct  duk_propdesc
 
struct  duk_hobject
 
struct  duk_hcompfunc
 
struct  duk_hnatfunc
 
struct  duk_hboundfunc
 
struct  duk_hbufobj
 
struct  duk_activation
 
struct  duk_catcher
 
struct  duk_hthread
 
struct  duk_harray
 
struct  duk_hdecenv
 
struct  duk_hobjenv
 
struct  duk_hbuffer
 
struct  duk_hbuffer_fixed
 
struct  duk_hbuffer_dynamic
 
struct  duk_hbuffer_external
 
struct  duk_hproxy
 
struct  duk_breakpoint
 
struct  duk_strcache_entry
 
struct  duk_ljstate
 
struct  duk_litcache_entry
 
struct  duk_heap
 
struct  duk_json_enc_ctx
 
struct  duk_json_dec_ctx
 
struct  duk__pcall_prop_args
 
struct  duk__pcall_method_args
 
struct  duk__pcall_args
 
struct  duk__compile_raw_args
 
struct  duk_internal_thread_state
 
struct  duk__encode_context
 
struct  duk__decode_context
 
struct  duk__transform_context
 
struct  duk__compiler_stkstate
 
struct  duk__objlit_state
 
struct  duk__id_lookup_result
 
struct  duk__exp_limits
 
struct  duk__bigint
 
struct  duk__numconv_stringify_ctx
 
struct  duk__re_disjunction_info
 

Macros

#define DUK_INTERNAL_H_INCLUDED
 
#define DUK_COMPILING_DUKTAPE
 
#define DUK_DBLUNION_H_INCLUDED
 
#define DUK_DBLUNION_SET_DOUBLE(u, v)
 
#define DUK_DBLUNION_SET_HIGH32(u, v)
 
#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u, v)
 
#define DUK_DBLUNION_SET_LOW32(u, v)
 
#define DUK_DBLUNION_GET_DOUBLE(u)   ((u)->d)
 
#define DUK_DBLUNION_GET_HIGH32(u)   ((u)->ui[DUK_DBL_IDX_UI0])
 
#define DUK_DBLUNION_GET_LOW32(u)   ((u)->ui[DUK_DBL_IDX_UI1])
 
#define DUK__DBLUNION_SET_NAN_FULL(u)
 
#define DUK__DBLUNION_IS_NAN_FULL(u)
 
#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u)
 
#define DUK__DBLUNION_IS_ANYINF(u)
 
#define DUK__DBLUNION_IS_POSINF(u)
 
#define DUK__DBLUNION_IS_NEGINF(u)
 
#define DUK__DBLUNION_IS_ANYZERO(u)
 
#define DUK__DBLUNION_IS_POSZERO(u)
 
#define DUK__DBLUNION_IS_NEGZERO(u)
 
#define DUK__DBLUNION_SET_NAN_NOTFULL(u)
 
#define DUK__DBLUNION_IS_NAN_NOTFULL(u)
 
#define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u)
 
#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL(u)
 
#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u)
 
#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))
 
#define DUK_DBLUNION_SET_NAN(d)   DUK__DBLUNION_SET_NAN_NOTFULL((d))
 
#define DUK_DBLUNION_IS_NORMALIZED(u)
 
#define DUK_DBLUNION_IS_ANYINF(u)   DUK__DBLUNION_IS_ANYINF((u))
 
#define DUK_DBLUNION_IS_POSINF(u)   DUK__DBLUNION_IS_POSINF((u))
 
#define DUK_DBLUNION_IS_NEGINF(u)   DUK__DBLUNION_IS_NEGINF((u))
 
#define DUK_DBLUNION_IS_ANYZERO(u)   DUK__DBLUNION_IS_ANYZERO((u))
 
#define DUK_DBLUNION_IS_POSZERO(u)   DUK__DBLUNION_IS_POSZERO((u))
 
#define DUK_DBLUNION_IS_NEGZERO(u)   DUK__DBLUNION_IS_NEGZERO((u))
 
#define DUK_DBLUNION_BSWAP64(u)
 
#define DUK_DBLUNION_DOUBLE_NTOH(u)   DUK_DBLUNION_DOUBLE_HTON((u))
 
#define DUK_DBLUNION_HAS_SIGNBIT(u)   (((u)->ui[DUK_DBL_IDX_UI0] & 0x80000000UL) != 0)
 
#define DUK_DBLUNION_GET_SIGNBIT(u)   (((u)->ui[DUK_DBL_IDX_UI0] >> 31U))
 
#define DUK_REPLACEMENTS_H_INCLUDED
 
#define DUK_JMPBUF_H_INCLUDED
 
#define DUK_EXCEPTION_H_INCLUDED
 
#define DUK_FORWDECL_H_INCLUDED
 
#define DUK_TVAL_H_INCLUDED
 
#define DUK_TAG_NORMALIZED_NAN   0x7ff8UL /* the NaN variant we use */
 
#define DUK_TAG_MIN   0xfff1UL
 
#define DUK_TAG_UNUSED   0xfff2UL /* marker; not actual tagged value */
 
#define DUK_TAG_UNDEFINED   0xfff3UL /* embed: nothing */
 
#define DUK_TAG_NULL   0xfff4UL /* embed: nothing */
 
#define DUK_TAG_BOOLEAN   0xfff5UL /* embed: 0 or 1 (false or true) */
 
#define DUK_TAG_POINTER   0xfff6UL /* embed: void ptr */
 
#define DUK_TAG_LIGHTFUNC   0xfff7UL /* embed: func ptr */
 
#define DUK_TAG_STRING   0xfff8UL /* embed: duk_hstring ptr */
 
#define DUK_TAG_OBJECT   0xfff9UL /* embed: duk_hobject ptr */
 
#define DUK_TAG_BUFFER   0xfffaUL /* embed: duk_hbuffer ptr */
 
#define DUK_TAG_MAX   0xfffaUL
 
#define DUK_XTAG_BOOLEAN_FALSE   0xfff50000UL
 
#define DUK_XTAG_BOOLEAN_TRUE   0xfff50001UL
 
#define DUK_TVAL_IS_VALID_TAG(tv)   (DUK_TVAL_GET_TAG((tv)) - DUK_TAG_MIN <= DUK_TAG_MAX - DUK_TAG_MIN)
 
#define DUK_TVAL_UNUSED_INITIALIZER()   { DUK_TAG_UNUSED, DUK_TAG_UNUSED, DUK_TAG_UNUSED, DUK_TAG_UNUSED }
 
#define DUK__TVAL_SET_TAGGEDPOINTER(tv, h, tag)
 
#define DUK__TVAL_SET_LIGHTFUNC(tv, fp, flags)
 
#define DUK_TVAL_SET_UNDEFINED(tv)
 
#define DUK_TVAL_SET_UNUSED(tv)
 
#define DUK_TVAL_SET_NULL(tv)
 
#define DUK_TVAL_SET_BOOLEAN(tv, val)   DUK_DBLUNION_SET_HIGH32((tv), (((duk_uint32_t) DUK_TAG_BOOLEAN) << 16) | ((duk_uint32_t) (val)))
 
#define DUK_TVAL_SET_NAN(tv)   DUK_DBLUNION_SET_NAN_FULL((tv))
 
#define DUK_TVAL_SET_DOUBLE(tv, d)
 
#define DUK_TVAL_SET_I48(tv, i)   DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i)) /* XXX: fast int-to-double */
 
#define DUK_TVAL_SET_I32(tv, i)   DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))
 
#define DUK_TVAL_SET_U32(tv, i)   DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))
 
#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv, d)   DUK_TVAL_SET_DOUBLE((tv), (d))
 
#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv, d)   DUK_TVAL_SET_DOUBLE((tv), (d))
 
#define DUK_TVAL_SET_NUMBER(tv, d)   DUK_TVAL_SET_DOUBLE((tv), (d))
 
#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv)   do { } while (0)
 
#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv)   do { } while (0)
 
#define DUK_TVAL_SET_FASTINT(tv, i)   DUK_TVAL_SET_I48((tv), (i)) /* alias */
 
#define DUK_TVAL_SET_LIGHTFUNC(tv, fp, flags)   DUK__TVAL_SET_LIGHTFUNC((tv), (fp), (flags))
 
#define DUK_TVAL_SET_STRING(tv, h)   DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_STRING)
 
#define DUK_TVAL_SET_OBJECT(tv, h)   DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_OBJECT)
 
#define DUK_TVAL_SET_BUFFER(tv, h)   DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_BUFFER)
 
#define DUK_TVAL_SET_POINTER(tv, p)   DUK__TVAL_SET_TAGGEDPOINTER((tv), (p), DUK_TAG_POINTER)
 
#define DUK_TVAL_SET_TVAL(tv, x)   do { *(tv) = *(x); } while (0)
 
#define DUK_TVAL_GET_BOOLEAN(tv)   ((duk_small_uint_t) (tv)->us[DUK_DBL_IDX_US1])
 
#define DUK_TVAL_GET_NUMBER(tv)   ((tv)->d)
 
#define DUK_TVAL_GET_DOUBLE(tv)   ((tv)->d)
 
#define DUK_TVAL_GET_LIGHTFUNC(tv, out_fp, out_flags)
 
#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv)   ((duk_c_function) ((tv)->ui[DUK_DBL_IDX_UI1]))
 
#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)   (((duk_small_uint_t) (tv)->ui[DUK_DBL_IDX_UI0]) & 0xffffUL)
 
#define DUK_TVAL_GET_STRING(tv)   ((duk_hstring *) (tv)->vp[DUK_DBL_IDX_VP1])
 
#define DUK_TVAL_GET_OBJECT(tv)   ((duk_hobject *) (tv)->vp[DUK_DBL_IDX_VP1])
 
#define DUK_TVAL_GET_BUFFER(tv)   ((duk_hbuffer *) (tv)->vp[DUK_DBL_IDX_VP1])
 
#define DUK_TVAL_GET_POINTER(tv)   ((void *) (tv)->vp[DUK_DBL_IDX_VP1])
 
#define DUK_TVAL_GET_HEAPHDR(tv)   ((duk_heaphdr *) (tv)->vp[DUK_DBL_IDX_VP1])
 
#define DUK_TVAL_GET_TAG(tv)   ((duk_small_uint_t) (tv)->us[DUK_DBL_IDX_US0])
 
#define DUK_TVAL_IS_UNDEFINED(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_UNDEFINED)
 
#define DUK_TVAL_IS_UNUSED(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_UNUSED)
 
#define DUK_TVAL_IS_NULL(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_NULL)
 
#define DUK_TVAL_IS_BOOLEAN(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_BOOLEAN)
 
#define DUK_TVAL_IS_BOOLEAN_TRUE(tv)   ((tv)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE)
 
#define DUK_TVAL_IS_BOOLEAN_FALSE(tv)   ((tv)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_FALSE)
 
#define DUK_TVAL_IS_LIGHTFUNC(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_LIGHTFUNC)
 
#define DUK_TVAL_IS_STRING(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_STRING)
 
#define DUK_TVAL_IS_OBJECT(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_OBJECT)
 
#define DUK_TVAL_IS_BUFFER(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_BUFFER)
 
#define DUK_TVAL_IS_POINTER(tv)   (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_POINTER)
 
#define DUK_TVAL_IS_NUMBER(tv)   (DUK_TVAL_GET_TAG((tv)) <= 0xfff0UL)
 
#define DUK_TVAL_IS_DOUBLE(tv)   DUK_TVAL_IS_NUMBER((tv))
 
#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)   (DUK_TVAL_GET_TAG((tv)) >= DUK_TAG_STRING)
 
#define DUK_TVAL_SET_BOOLEAN_TRUE(tv)   DUK_TVAL_SET_BOOLEAN((tv), 1)
 
#define DUK_TVAL_SET_BOOLEAN_FALSE(tv)   DUK_TVAL_SET_BOOLEAN((tv), 0)
 
#define DUK_TVAL_STRING_IS_SYMBOL(tv)   DUK_HSTRING_HAS_SYMBOL(DUK_TVAL_GET_STRING((tv)))
 
#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags)   ((duk_int32_t) (duk_int8_t) (((duk_uint16_t) (lf_flags)) >> 8))
 
#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags)   (((lf_flags) >> 4) & 0x0fU)
 
#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags)   ((lf_flags) & 0x0fU)
 
#define DUK_LFUNC_FLAGS_PACK(magic, length, nargs)   ((((duk_small_uint_t) (magic)) & 0xffU) << 8) | ((length) << 4) | (nargs)
 
#define DUK_LFUNC_NARGS_VARARGS   0x0f /* varargs marker */
 
#define DUK_LFUNC_NARGS_MIN   0x00
 
#define DUK_LFUNC_NARGS_MAX   0x0e /* max, excl. varargs marker */
 
#define DUK_LFUNC_LENGTH_MIN   0x00
 
#define DUK_LFUNC_LENGTH_MAX   0x0f
 
#define DUK_LFUNC_MAGIC_MIN   (-0x80)
 
#define DUK_LFUNC_MAGIC_MAX   0x7f
 
#define DUK_BUILTINS_H_INCLUDED
 
#define DUK_STRIDX_UC_UNDEFINED   0 /* 'Undefined' */
 
#define DUK_HEAP_STRING_UC_UNDEFINED(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
 
#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
 
#define DUK_STRIDX_UC_NULL   1 /* 'Null' */
 
#define DUK_HEAP_STRING_UC_NULL(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
 
#define DUK_HTHREAD_STRING_UC_NULL(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
 
#define DUK_STRIDX_UC_SYMBOL   2 /* 'Symbol' */
 
#define DUK_HEAP_STRING_UC_SYMBOL(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_SYMBOL)
 
#define DUK_HTHREAD_STRING_UC_SYMBOL(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_SYMBOL)
 
#define DUK_STRIDX_UC_ARGUMENTS   3 /* 'Arguments' */
 
#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
 
#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
 
#define DUK_STRIDX_UC_OBJECT   4 /* 'Object' */
 
#define DUK_HEAP_STRING_UC_OBJECT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
 
#define DUK_HTHREAD_STRING_UC_OBJECT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
 
#define DUK_STRIDX_UC_FUNCTION   5 /* 'Function' */
 
#define DUK_HEAP_STRING_UC_FUNCTION(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
 
#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
 
#define DUK_STRIDX_ARRAY   6 /* 'Array' */
 
#define DUK_HEAP_STRING_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
 
#define DUK_HTHREAD_STRING_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
 
#define DUK_STRIDX_UC_STRING   7 /* 'String' */
 
#define DUK_HEAP_STRING_UC_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
 
#define DUK_HTHREAD_STRING_UC_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
 
#define DUK_STRIDX_UC_BOOLEAN   8 /* 'Boolean' */
 
#define DUK_HEAP_STRING_UC_BOOLEAN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
 
#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
 
#define DUK_STRIDX_UC_NUMBER   9 /* 'Number' */
 
#define DUK_HEAP_STRING_UC_NUMBER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
 
#define DUK_HTHREAD_STRING_UC_NUMBER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
 
#define DUK_STRIDX_DATE   10 /* 'Date' */
 
#define DUK_HEAP_STRING_DATE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
 
#define DUK_HTHREAD_STRING_DATE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
 
#define DUK_STRIDX_REG_EXP   11 /* 'RegExp' */
 
#define DUK_HEAP_STRING_REG_EXP(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
 
#define DUK_HTHREAD_STRING_REG_EXP(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
 
#define DUK_STRIDX_UC_ERROR   12 /* 'Error' */
 
#define DUK_HEAP_STRING_UC_ERROR(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
 
#define DUK_HTHREAD_STRING_UC_ERROR(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
 
#define DUK_STRIDX_MATH   13 /* 'Math' */
 
#define DUK_HEAP_STRING_MATH(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
 
#define DUK_HTHREAD_STRING_MATH(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
 
#define DUK_STRIDX_JSON   14 /* 'JSON' */
 
#define DUK_HEAP_STRING_JSON(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
 
#define DUK_HTHREAD_STRING_JSON(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
 
#define DUK_STRIDX_EMPTY_STRING   15 /* '' */
 
#define DUK_HEAP_STRING_EMPTY_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
 
#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
 
#define DUK_STRIDX_ARRAY_BUFFER   16 /* 'ArrayBuffer' */
 
#define DUK_HEAP_STRING_ARRAY_BUFFER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER)
 
#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER)
 
#define DUK_STRIDX_DATA_VIEW   17 /* 'DataView' */
 
#define DUK_HEAP_STRING_DATA_VIEW(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW)
 
#define DUK_HTHREAD_STRING_DATA_VIEW(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW)
 
#define DUK_STRIDX_INT8_ARRAY   18 /* 'Int8Array' */
 
#define DUK_HEAP_STRING_INT8_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY)
 
#define DUK_HTHREAD_STRING_INT8_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY)
 
#define DUK_STRIDX_UINT8_ARRAY   19 /* 'Uint8Array' */
 
#define DUK_HEAP_STRING_UINT8_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY)
 
#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY)
 
#define DUK_STRIDX_UINT8_CLAMPED_ARRAY   20 /* 'Uint8ClampedArray' */
 
#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY)
 
#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY)
 
#define DUK_STRIDX_INT16_ARRAY   21 /* 'Int16Array' */
 
#define DUK_HEAP_STRING_INT16_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY)
 
#define DUK_HTHREAD_STRING_INT16_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY)
 
#define DUK_STRIDX_UINT16_ARRAY   22 /* 'Uint16Array' */
 
#define DUK_HEAP_STRING_UINT16_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY)
 
#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY)
 
#define DUK_STRIDX_INT32_ARRAY   23 /* 'Int32Array' */
 
#define DUK_HEAP_STRING_INT32_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY)
 
#define DUK_HTHREAD_STRING_INT32_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY)
 
#define DUK_STRIDX_UINT32_ARRAY   24 /* 'Uint32Array' */
 
#define DUK_HEAP_STRING_UINT32_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY)
 
#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY)
 
#define DUK_STRIDX_FLOAT32_ARRAY   25 /* 'Float32Array' */
 
#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY)
 
#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY)
 
#define DUK_STRIDX_FLOAT64_ARRAY   26 /* 'Float64Array' */
 
#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY)
 
#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY)
 
#define DUK_STRIDX_GLOBAL   27 /* 'global' */
 
#define DUK_HEAP_STRING_GLOBAL(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
 
#define DUK_HTHREAD_STRING_GLOBAL(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
 
#define DUK_STRIDX_OBJ_ENV   28 /* 'ObjEnv' */
 
#define DUK_HEAP_STRING_OBJ_ENV(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
 
#define DUK_HTHREAD_STRING_OBJ_ENV(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
 
#define DUK_STRIDX_DEC_ENV   29 /* 'DecEnv' */
 
#define DUK_HEAP_STRING_DEC_ENV(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
 
#define DUK_HTHREAD_STRING_DEC_ENV(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
 
#define DUK_STRIDX_UC_BUFFER   30 /* 'Buffer' */
 
#define DUK_HEAP_STRING_UC_BUFFER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
 
#define DUK_HTHREAD_STRING_UC_BUFFER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
 
#define DUK_STRIDX_UC_POINTER   31 /* 'Pointer' */
 
#define DUK_HEAP_STRING_UC_POINTER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
 
#define DUK_HTHREAD_STRING_UC_POINTER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
 
#define DUK_STRIDX_UC_THREAD   32 /* 'Thread' */
 
#define DUK_HEAP_STRING_UC_THREAD(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
 
#define DUK_HTHREAD_STRING_UC_THREAD(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
 
#define DUK_STRIDX_EVAL   33 /* 'eval' */
 
#define DUK_HEAP_STRING_EVAL(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
 
#define DUK_HTHREAD_STRING_EVAL(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
 
#define DUK_STRIDX_VALUE   34 /* 'value' */
 
#define DUK_HEAP_STRING_VALUE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
 
#define DUK_HTHREAD_STRING_VALUE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
 
#define DUK_STRIDX_WRITABLE   35 /* 'writable' */
 
#define DUK_HEAP_STRING_WRITABLE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
 
#define DUK_HTHREAD_STRING_WRITABLE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
 
#define DUK_STRIDX_CONFIGURABLE   36 /* 'configurable' */
 
#define DUK_HEAP_STRING_CONFIGURABLE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
 
#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
 
#define DUK_STRIDX_ENUMERABLE   37 /* 'enumerable' */
 
#define DUK_HEAP_STRING_ENUMERABLE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
 
#define DUK_HTHREAD_STRING_ENUMERABLE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
 
#define DUK_STRIDX_JOIN   38 /* 'join' */
 
#define DUK_HEAP_STRING_JOIN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
 
#define DUK_HTHREAD_STRING_JOIN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
 
#define DUK_STRIDX_TO_LOCALE_STRING   39 /* 'toLocaleString' */
 
#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
 
#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
 
#define DUK_STRIDX_VALUE_OF   40 /* 'valueOf' */
 
#define DUK_HEAP_STRING_VALUE_OF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
 
#define DUK_HTHREAD_STRING_VALUE_OF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
 
#define DUK_STRIDX_TO_UTC_STRING   41 /* 'toUTCString' */
 
#define DUK_HEAP_STRING_TO_UTC_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
 
#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
 
#define DUK_STRIDX_TO_ISO_STRING   42 /* 'toISOString' */
 
#define DUK_HEAP_STRING_TO_ISO_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
 
#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
 
#define DUK_STRIDX_TO_GMT_STRING   43 /* 'toGMTString' */
 
#define DUK_HEAP_STRING_TO_GMT_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
 
#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
 
#define DUK_STRIDX_SOURCE   44 /* 'source' */
 
#define DUK_HEAP_STRING_SOURCE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
 
#define DUK_HTHREAD_STRING_SOURCE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
 
#define DUK_STRIDX_IGNORE_CASE   45 /* 'ignoreCase' */
 
#define DUK_HEAP_STRING_IGNORE_CASE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
 
#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
 
#define DUK_STRIDX_MULTILINE   46 /* 'multiline' */
 
#define DUK_HEAP_STRING_MULTILINE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
 
#define DUK_HTHREAD_STRING_MULTILINE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
 
#define DUK_STRIDX_LAST_INDEX   47 /* 'lastIndex' */
 
#define DUK_HEAP_STRING_LAST_INDEX(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
 
#define DUK_HTHREAD_STRING_LAST_INDEX(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
 
#define DUK_STRIDX_FLAGS   48 /* 'flags' */
 
#define DUK_HEAP_STRING_FLAGS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLAGS)
 
#define DUK_HTHREAD_STRING_FLAGS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLAGS)
 
#define DUK_STRIDX_INDEX   49 /* 'index' */
 
#define DUK_HEAP_STRING_INDEX(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
 
#define DUK_HTHREAD_STRING_INDEX(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
 
#define DUK_STRIDX_PROTOTYPE   50 /* 'prototype' */
 
#define DUK_HEAP_STRING_PROTOTYPE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
 
#define DUK_HTHREAD_STRING_PROTOTYPE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
 
#define DUK_STRIDX_CONSTRUCTOR   51 /* 'constructor' */
 
#define DUK_HEAP_STRING_CONSTRUCTOR(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
 
#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
 
#define DUK_STRIDX_MESSAGE   52 /* 'message' */
 
#define DUK_HEAP_STRING_MESSAGE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
 
#define DUK_HTHREAD_STRING_MESSAGE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
 
#define DUK_STRIDX_LC_BOOLEAN   53 /* 'boolean' */
 
#define DUK_HEAP_STRING_LC_BOOLEAN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
 
#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
 
#define DUK_STRIDX_LC_NUMBER   54 /* 'number' */
 
#define DUK_HEAP_STRING_LC_NUMBER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
 
#define DUK_HTHREAD_STRING_LC_NUMBER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
 
#define DUK_STRIDX_LC_STRING   55 /* 'string' */
 
#define DUK_HEAP_STRING_LC_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
 
#define DUK_HTHREAD_STRING_LC_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
 
#define DUK_STRIDX_LC_SYMBOL   56 /* 'symbol' */
 
#define DUK_HEAP_STRING_LC_SYMBOL(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_SYMBOL)
 
#define DUK_HTHREAD_STRING_LC_SYMBOL(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_SYMBOL)
 
#define DUK_STRIDX_LC_OBJECT   57 /* 'object' */
 
#define DUK_HEAP_STRING_LC_OBJECT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
 
#define DUK_HTHREAD_STRING_LC_OBJECT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
 
#define DUK_STRIDX_LC_UNDEFINED   58 /* 'undefined' */
 
#define DUK_HEAP_STRING_LC_UNDEFINED(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
 
#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
 
#define DUK_STRIDX_NAN   59 /* 'NaN' */
 
#define DUK_HEAP_STRING_NAN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
 
#define DUK_HTHREAD_STRING_NAN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
 
#define DUK_STRIDX_INFINITY   60 /* 'Infinity' */
 
#define DUK_HEAP_STRING_INFINITY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
 
#define DUK_HTHREAD_STRING_INFINITY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
 
#define DUK_STRIDX_MINUS_INFINITY   61 /* '-Infinity' */
 
#define DUK_HEAP_STRING_MINUS_INFINITY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
 
#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
 
#define DUK_STRIDX_MINUS_ZERO   62 /* '-0' */
 
#define DUK_HEAP_STRING_MINUS_ZERO(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
 
#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
 
#define DUK_STRIDX_COMMA   63 /* ',' */
 
#define DUK_HEAP_STRING_COMMA(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
 
#define DUK_HTHREAD_STRING_COMMA(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
 
#define DUK_STRIDX_NEWLINE_4SPACE   64 /* '\n ' */
 
#define DUK_HEAP_STRING_NEWLINE_4SPACE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_4SPACE)
 
#define DUK_HTHREAD_STRING_NEWLINE_4SPACE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_4SPACE)
 
#define DUK_STRIDX_BRACKETED_ELLIPSIS   65 /* '[...]' */
 
#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
 
#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
 
#define DUK_STRIDX_INVALID_DATE   66 /* 'Invalid Date' */
 
#define DUK_HEAP_STRING_INVALID_DATE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
 
#define DUK_HTHREAD_STRING_INVALID_DATE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
 
#define DUK_STRIDX_LC_ARGUMENTS   67 /* 'arguments' */
 
#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
 
#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
 
#define DUK_STRIDX_CALLEE   68 /* 'callee' */
 
#define DUK_HEAP_STRING_CALLEE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
 
#define DUK_HTHREAD_STRING_CALLEE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
 
#define DUK_STRIDX_CALLER   69 /* 'caller' */
 
#define DUK_HEAP_STRING_CALLER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
 
#define DUK_HTHREAD_STRING_CALLER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
 
#define DUK_STRIDX_APPLY   70 /* 'apply' */
 
#define DUK_HEAP_STRING_APPLY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
 
#define DUK_HTHREAD_STRING_APPLY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
 
#define DUK_STRIDX_CONSTRUCT   71 /* 'construct' */
 
#define DUK_HEAP_STRING_CONSTRUCT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCT)
 
#define DUK_HTHREAD_STRING_CONSTRUCT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCT)
 
#define DUK_STRIDX_DELETE_PROPERTY   72 /* 'deleteProperty' */
 
#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
 
#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
 
#define DUK_STRIDX_GET   73 /* 'get' */
 
#define DUK_HEAP_STRING_GET(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
 
#define DUK_HTHREAD_STRING_GET(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
 
#define DUK_STRIDX_HAS   74 /* 'has' */
 
#define DUK_HEAP_STRING_HAS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
 
#define DUK_HTHREAD_STRING_HAS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
 
#define DUK_STRIDX_OWN_KEYS   75 /* 'ownKeys' */
 
#define DUK_HEAP_STRING_OWN_KEYS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
 
#define DUK_HTHREAD_STRING_OWN_KEYS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
 
#define DUK_STRIDX_WELLKNOWN_SYMBOL_TO_PRIMITIVE   76 /* '\x81Symbol.toPrimitive\xff' */
 
#define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_TO_PRIMITIVE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_PRIMITIVE)
 
#define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_TO_PRIMITIVE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_PRIMITIVE)
 
#define DUK_STRIDX_WELLKNOWN_SYMBOL_HAS_INSTANCE   77 /* '\x81Symbol.hasInstance\xff' */
 
#define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_HAS_INSTANCE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_HAS_INSTANCE)
 
#define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_HAS_INSTANCE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_HAS_INSTANCE)
 
#define DUK_STRIDX_WELLKNOWN_SYMBOL_TO_STRING_TAG   78 /* '\x81Symbol.toStringTag\xff' */
 
#define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_TO_STRING_TAG(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_STRING_TAG)
 
#define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_TO_STRING_TAG(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_STRING_TAG)
 
#define DUK_STRIDX_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE   79 /* '\x81Symbol.isConcatSpreadable\xff' */
 
#define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE)
 
#define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE)
 
#define DUK_STRIDX_SET_PROTOTYPE_OF   80 /* 'setPrototypeOf' */
 
#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
 
#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
 
#define DUK_STRIDX___PROTO__   81 /* '__proto__' */
 
#define DUK_HEAP_STRING___PROTO__(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
 
#define DUK_HTHREAD_STRING___PROTO__(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
 
#define DUK_STRIDX_TO_STRING   82 /* 'toString' */
 
#define DUK_HEAP_STRING_TO_STRING(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
 
#define DUK_HTHREAD_STRING_TO_STRING(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
 
#define DUK_STRIDX_TO_JSON   83 /* 'toJSON' */
 
#define DUK_HEAP_STRING_TO_JSON(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
 
#define DUK_HTHREAD_STRING_TO_JSON(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
 
#define DUK_STRIDX_TYPE   84 /* 'type' */
 
#define DUK_HEAP_STRING_TYPE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE)
 
#define DUK_HTHREAD_STRING_TYPE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE)
 
#define DUK_STRIDX_DATA   85 /* 'data' */
 
#define DUK_HEAP_STRING_DATA(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA)
 
#define DUK_HTHREAD_STRING_DATA(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA)
 
#define DUK_STRIDX_LENGTH   86 /* 'length' */
 
#define DUK_HEAP_STRING_LENGTH(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
 
#define DUK_HTHREAD_STRING_LENGTH(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
 
#define DUK_STRIDX_SET   87 /* 'set' */
 
#define DUK_HEAP_STRING_SET(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
 
#define DUK_HTHREAD_STRING_SET(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
 
#define DUK_STRIDX_STACK   88 /* 'stack' */
 
#define DUK_HEAP_STRING_STACK(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
 
#define DUK_HTHREAD_STRING_STACK(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
 
#define DUK_STRIDX_PC   89 /* 'pc' */
 
#define DUK_HEAP_STRING_PC(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
 
#define DUK_HTHREAD_STRING_PC(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
 
#define DUK_STRIDX_LINE_NUMBER   90 /* 'lineNumber' */
 
#define DUK_HEAP_STRING_LINE_NUMBER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
 
#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
 
#define DUK_STRIDX_INT_TRACEDATA   91 /* '\x82Tracedata' */
 
#define DUK_HEAP_STRING_INT_TRACEDATA(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
 
#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
 
#define DUK_STRIDX_NAME   92 /* 'name' */
 
#define DUK_HEAP_STRING_NAME(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
 
#define DUK_HTHREAD_STRING_NAME(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
 
#define DUK_STRIDX_FILE_NAME   93 /* 'fileName' */
 
#define DUK_HEAP_STRING_FILE_NAME(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
 
#define DUK_HTHREAD_STRING_FILE_NAME(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
 
#define DUK_STRIDX_LC_POINTER   94 /* 'pointer' */
 
#define DUK_HEAP_STRING_LC_POINTER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
 
#define DUK_HTHREAD_STRING_LC_POINTER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
 
#define DUK_STRIDX_INT_TARGET   95 /* '\x82Target' */
 
#define DUK_HEAP_STRING_INT_TARGET(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
 
#define DUK_HTHREAD_STRING_INT_TARGET(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
 
#define DUK_STRIDX_INT_NEXT   96 /* '\x82Next' */
 
#define DUK_HEAP_STRING_INT_NEXT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
 
#define DUK_HTHREAD_STRING_INT_NEXT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
 
#define DUK_STRIDX_INT_BYTECODE   97 /* '\x82Bytecode' */
 
#define DUK_HEAP_STRING_INT_BYTECODE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
 
#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
 
#define DUK_STRIDX_INT_FORMALS   98 /* '\x82Formals' */
 
#define DUK_HEAP_STRING_INT_FORMALS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
 
#define DUK_HTHREAD_STRING_INT_FORMALS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
 
#define DUK_STRIDX_INT_VARMAP   99 /* '\x82Varmap' */
 
#define DUK_HEAP_STRING_INT_VARMAP(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
 
#define DUK_HTHREAD_STRING_INT_VARMAP(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
 
#define DUK_STRIDX_INT_SOURCE   100 /* '\x82Source' */
 
#define DUK_HEAP_STRING_INT_SOURCE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
 
#define DUK_HTHREAD_STRING_INT_SOURCE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
 
#define DUK_STRIDX_INT_PC2LINE   101 /* '\x82Pc2line' */
 
#define DUK_HEAP_STRING_INT_PC2LINE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
 
#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
 
#define DUK_STRIDX_INT_MAP   102 /* '\x82Map' */
 
#define DUK_HEAP_STRING_INT_MAP(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
 
#define DUK_HTHREAD_STRING_INT_MAP(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
 
#define DUK_STRIDX_INT_VARENV   103 /* '\x82Varenv' */
 
#define DUK_HEAP_STRING_INT_VARENV(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
 
#define DUK_HTHREAD_STRING_INT_VARENV(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
 
#define DUK_STRIDX_INT_FINALIZER   104 /* '\x82Finalizer' */
 
#define DUK_HEAP_STRING_INT_FINALIZER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
 
#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
 
#define DUK_STRIDX_INT_VALUE   105 /* '\x82Value' */
 
#define DUK_HEAP_STRING_INT_VALUE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
 
#define DUK_HTHREAD_STRING_INT_VALUE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
 
#define DUK_STRIDX_COMPILE   106 /* 'compile' */
 
#define DUK_HEAP_STRING_COMPILE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
 
#define DUK_HTHREAD_STRING_COMPILE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
 
#define DUK_STRIDX_INPUT   107 /* 'input' */
 
#define DUK_HEAP_STRING_INPUT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
 
#define DUK_HTHREAD_STRING_INPUT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
 
#define DUK_STRIDX_ERR_CREATE   108 /* 'errCreate' */
 
#define DUK_HEAP_STRING_ERR_CREATE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
 
#define DUK_HTHREAD_STRING_ERR_CREATE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
 
#define DUK_STRIDX_ERR_THROW   109 /* 'errThrow' */
 
#define DUK_HEAP_STRING_ERR_THROW(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
 
#define DUK_HTHREAD_STRING_ERR_THROW(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
 
#define DUK_STRIDX_ENV   110 /* 'env' */
 
#define DUK_HEAP_STRING_ENV(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
 
#define DUK_HTHREAD_STRING_ENV(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
 
#define DUK_STRIDX_HEX   111 /* 'hex' */
 
#define DUK_HEAP_STRING_HEX(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
 
#define DUK_HTHREAD_STRING_HEX(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
 
#define DUK_STRIDX_BASE64   112 /* 'base64' */
 
#define DUK_HEAP_STRING_BASE64(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
 
#define DUK_HTHREAD_STRING_BASE64(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
 
#define DUK_STRIDX_JX   113 /* 'jx' */
 
#define DUK_HEAP_STRING_JX(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
 
#define DUK_HTHREAD_STRING_JX(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
 
#define DUK_STRIDX_JC   114 /* 'jc' */
 
#define DUK_HEAP_STRING_JC(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
 
#define DUK_HTHREAD_STRING_JC(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
 
#define DUK_STRIDX_JSON_EXT_UNDEFINED   115 /* '{"_undef":true}' */
 
#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
 
#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
 
#define DUK_STRIDX_JSON_EXT_NAN   116 /* '{"_nan":true}' */
 
#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
 
#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
 
#define DUK_STRIDX_JSON_EXT_POSINF   117 /* '{"_inf":true}' */
 
#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
 
#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
 
#define DUK_STRIDX_JSON_EXT_NEGINF   118 /* '{"_ninf":true}' */
 
#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
 
#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
 
#define DUK_STRIDX_JSON_EXT_FUNCTION1   119 /* '{"_func":true}' */
 
#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
 
#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
 
#define DUK_STRIDX_JSON_EXT_FUNCTION2   120 /* '{_func:true}' */
 
#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
 
#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
 
#define DUK_STRIDX_BREAK   121 /* 'break' */
 
#define DUK_HEAP_STRING_BREAK(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
 
#define DUK_HTHREAD_STRING_BREAK(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
 
#define DUK_STRIDX_CASE   122 /* 'case' */
 
#define DUK_HEAP_STRING_CASE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
 
#define DUK_HTHREAD_STRING_CASE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
 
#define DUK_STRIDX_CATCH   123 /* 'catch' */
 
#define DUK_HEAP_STRING_CATCH(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
 
#define DUK_HTHREAD_STRING_CATCH(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
 
#define DUK_STRIDX_CONTINUE   124 /* 'continue' */
 
#define DUK_HEAP_STRING_CONTINUE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
 
#define DUK_HTHREAD_STRING_CONTINUE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
 
#define DUK_STRIDX_DEBUGGER   125 /* 'debugger' */
 
#define DUK_HEAP_STRING_DEBUGGER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
 
#define DUK_HTHREAD_STRING_DEBUGGER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
 
#define DUK_STRIDX_DEFAULT   126 /* 'default' */
 
#define DUK_HEAP_STRING_DEFAULT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
 
#define DUK_HTHREAD_STRING_DEFAULT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
 
#define DUK_STRIDX_DELETE   127 /* 'delete' */
 
#define DUK_HEAP_STRING_DELETE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
 
#define DUK_HTHREAD_STRING_DELETE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
 
#define DUK_STRIDX_DO   128 /* 'do' */
 
#define DUK_HEAP_STRING_DO(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
 
#define DUK_HTHREAD_STRING_DO(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
 
#define DUK_STRIDX_ELSE   129 /* 'else' */
 
#define DUK_HEAP_STRING_ELSE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
 
#define DUK_HTHREAD_STRING_ELSE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
 
#define DUK_STRIDX_FINALLY   130 /* 'finally' */
 
#define DUK_HEAP_STRING_FINALLY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
 
#define DUK_HTHREAD_STRING_FINALLY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
 
#define DUK_STRIDX_FOR   131 /* 'for' */
 
#define DUK_HEAP_STRING_FOR(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
 
#define DUK_HTHREAD_STRING_FOR(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
 
#define DUK_STRIDX_LC_FUNCTION   132 /* 'function' */
 
#define DUK_HEAP_STRING_LC_FUNCTION(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
 
#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
 
#define DUK_STRIDX_IF   133 /* 'if' */
 
#define DUK_HEAP_STRING_IF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
 
#define DUK_HTHREAD_STRING_IF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
 
#define DUK_STRIDX_IN   134 /* 'in' */
 
#define DUK_HEAP_STRING_IN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
 
#define DUK_HTHREAD_STRING_IN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
 
#define DUK_STRIDX_INSTANCEOF   135 /* 'instanceof' */
 
#define DUK_HEAP_STRING_INSTANCEOF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
 
#define DUK_HTHREAD_STRING_INSTANCEOF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
 
#define DUK_STRIDX_NEW   136 /* 'new' */
 
#define DUK_HEAP_STRING_NEW(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
 
#define DUK_HTHREAD_STRING_NEW(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
 
#define DUK_STRIDX_RETURN   137 /* 'return' */
 
#define DUK_HEAP_STRING_RETURN(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
 
#define DUK_HTHREAD_STRING_RETURN(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
 
#define DUK_STRIDX_SWITCH   138 /* 'switch' */
 
#define DUK_HEAP_STRING_SWITCH(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
 
#define DUK_HTHREAD_STRING_SWITCH(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
 
#define DUK_STRIDX_THIS   139 /* 'this' */
 
#define DUK_HEAP_STRING_THIS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
 
#define DUK_HTHREAD_STRING_THIS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
 
#define DUK_STRIDX_THROW   140 /* 'throw' */
 
#define DUK_HEAP_STRING_THROW(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
 
#define DUK_HTHREAD_STRING_THROW(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
 
#define DUK_STRIDX_TRY   141 /* 'try' */
 
#define DUK_HEAP_STRING_TRY(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
 
#define DUK_HTHREAD_STRING_TRY(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
 
#define DUK_STRIDX_TYPEOF   142 /* 'typeof' */
 
#define DUK_HEAP_STRING_TYPEOF(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
 
#define DUK_HTHREAD_STRING_TYPEOF(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
 
#define DUK_STRIDX_VAR   143 /* 'var' */
 
#define DUK_HEAP_STRING_VAR(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
 
#define DUK_HTHREAD_STRING_VAR(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
 
#define DUK_STRIDX_CONST   144 /* 'const' */
 
#define DUK_HEAP_STRING_CONST(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
 
#define DUK_HTHREAD_STRING_CONST(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
 
#define DUK_STRIDX_VOID   145 /* 'void' */
 
#define DUK_HEAP_STRING_VOID(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
 
#define DUK_HTHREAD_STRING_VOID(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
 
#define DUK_STRIDX_WHILE   146 /* 'while' */
 
#define DUK_HEAP_STRING_WHILE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
 
#define DUK_HTHREAD_STRING_WHILE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
 
#define DUK_STRIDX_WITH   147 /* 'with' */
 
#define DUK_HEAP_STRING_WITH(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
 
#define DUK_HTHREAD_STRING_WITH(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
 
#define DUK_STRIDX_CLASS   148 /* 'class' */
 
#define DUK_HEAP_STRING_CLASS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
 
#define DUK_HTHREAD_STRING_CLASS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
 
#define DUK_STRIDX_ENUM   149 /* 'enum' */
 
#define DUK_HEAP_STRING_ENUM(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
 
#define DUK_HTHREAD_STRING_ENUM(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
 
#define DUK_STRIDX_EXPORT   150 /* 'export' */
 
#define DUK_HEAP_STRING_EXPORT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
 
#define DUK_HTHREAD_STRING_EXPORT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
 
#define DUK_STRIDX_EXTENDS   151 /* 'extends' */
 
#define DUK_HEAP_STRING_EXTENDS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
 
#define DUK_HTHREAD_STRING_EXTENDS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
 
#define DUK_STRIDX_IMPORT   152 /* 'import' */
 
#define DUK_HEAP_STRING_IMPORT(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
 
#define DUK_HTHREAD_STRING_IMPORT(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
 
#define DUK_STRIDX_SUPER   153 /* 'super' */
 
#define DUK_HEAP_STRING_SUPER(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
 
#define DUK_HTHREAD_STRING_SUPER(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
 
#define DUK_STRIDX_LC_NULL   154 /* 'null' */
 
#define DUK_HEAP_STRING_LC_NULL(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
 
#define DUK_HTHREAD_STRING_LC_NULL(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
 
#define DUK_STRIDX_TRUE   155 /* 'true' */
 
#define DUK_HEAP_STRING_TRUE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
 
#define DUK_HTHREAD_STRING_TRUE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
 
#define DUK_STRIDX_FALSE   156 /* 'false' */
 
#define DUK_HEAP_STRING_FALSE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
 
#define DUK_HTHREAD_STRING_FALSE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
 
#define DUK_STRIDX_IMPLEMENTS   157 /* 'implements' */
 
#define DUK_HEAP_STRING_IMPLEMENTS(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
 
#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
 
#define DUK_STRIDX_INTERFACE   158 /* 'interface' */
 
#define DUK_HEAP_STRING_INTERFACE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
 
#define DUK_HTHREAD_STRING_INTERFACE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
 
#define DUK_STRIDX_LET   159 /* 'let' */
 
#define DUK_HEAP_STRING_LET(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
 
#define DUK_HTHREAD_STRING_LET(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
 
#define DUK_STRIDX_PACKAGE   160 /* 'package' */
 
#define DUK_HEAP_STRING_PACKAGE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
 
#define DUK_HTHREAD_STRING_PACKAGE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
 
#define DUK_STRIDX_PRIVATE   161 /* 'private' */
 
#define DUK_HEAP_STRING_PRIVATE(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
 
#define DUK_HTHREAD_STRING_PRIVATE(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
 
#define DUK_STRIDX_PROTECTED   162 /* 'protected' */
 
#define DUK_HEAP_STRING_PROTECTED(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
 
#define DUK_HTHREAD_STRING_PROTECTED(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
 
#define DUK_STRIDX_PUBLIC   163 /* 'public' */
 
#define DUK_HEAP_STRING_PUBLIC(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
 
#define DUK_HTHREAD_STRING_PUBLIC(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
 
#define DUK_STRIDX_STATIC   164 /* 'static' */
 
#define DUK_HEAP_STRING_STATIC(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
 
#define DUK_HTHREAD_STRING_STATIC(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
 
#define DUK_STRIDX_YIELD   165 /* 'yield' */
 
#define DUK_HEAP_STRING_YIELD(heap)   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
 
#define DUK_HTHREAD_STRING_YIELD(thr)   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
 
#define DUK_HEAP_NUM_STRINGS   166
 
#define DUK_STRIDX_START_RESERVED   121
 
#define DUK_STRIDX_START_STRICT_RESERVED   157
 
#define DUK_STRIDX_END_RESERVED   166 /* exclusive endpoint */
 
#define DUK_STRDATA_MAX_STRLEN   27
 
#define DUK_STRDATA_DATA_LENGTH   967
 
#define DUK_BIDX_GLOBAL   0
 
#define DUK_BIDX_GLOBAL_ENV   1
 
#define DUK_BIDX_OBJECT_CONSTRUCTOR   2
 
#define DUK_BIDX_OBJECT_PROTOTYPE   3
 
#define DUK_BIDX_FUNCTION_CONSTRUCTOR   4
 
#define DUK_BIDX_FUNCTION_PROTOTYPE   5
 
#define DUK_BIDX_NATIVE_FUNCTION_PROTOTYPE   6
 
#define DUK_BIDX_ARRAY_CONSTRUCTOR   7
 
#define DUK_BIDX_ARRAY_PROTOTYPE   8
 
#define DUK_BIDX_STRING_CONSTRUCTOR   9
 
#define DUK_BIDX_STRING_PROTOTYPE   10
 
#define DUK_BIDX_BOOLEAN_CONSTRUCTOR   11
 
#define DUK_BIDX_BOOLEAN_PROTOTYPE   12
 
#define DUK_BIDX_NUMBER_CONSTRUCTOR   13
 
#define DUK_BIDX_NUMBER_PROTOTYPE   14
 
#define DUK_BIDX_DATE_CONSTRUCTOR   15
 
#define DUK_BIDX_DATE_PROTOTYPE   16
 
#define DUK_BIDX_REGEXP_CONSTRUCTOR   17
 
#define DUK_BIDX_REGEXP_PROTOTYPE   18
 
#define DUK_BIDX_ERROR_CONSTRUCTOR   19
 
#define DUK_BIDX_ERROR_PROTOTYPE   20
 
#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR   21
 
#define DUK_BIDX_EVAL_ERROR_PROTOTYPE   22
 
#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR   23
 
#define DUK_BIDX_RANGE_ERROR_PROTOTYPE   24
 
#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR   25
 
#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE   26
 
#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR   27
 
#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE   28
 
#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR   29
 
#define DUK_BIDX_TYPE_ERROR_PROTOTYPE   30
 
#define DUK_BIDX_URI_ERROR_CONSTRUCTOR   31
 
#define DUK_BIDX_URI_ERROR_PROTOTYPE   32
 
#define DUK_BIDX_TYPE_ERROR_THROWER   33
 
#define DUK_BIDX_DUKTAPE   34
 
#define DUK_BIDX_THREAD_PROTOTYPE   35
 
#define DUK_BIDX_POINTER_PROTOTYPE   36
 
#define DUK_BIDX_DOUBLE_ERROR   37
 
#define DUK_BIDX_SYMBOL_PROTOTYPE   38
 
#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE   39
 
#define DUK_BIDX_DATAVIEW_PROTOTYPE   40
 
#define DUK_BIDX_INT8ARRAY_PROTOTYPE   41
 
#define DUK_BIDX_UINT8ARRAY_PROTOTYPE   42
 
#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE   43
 
#define DUK_BIDX_INT16ARRAY_PROTOTYPE   44
 
#define DUK_BIDX_UINT16ARRAY_PROTOTYPE   45
 
#define DUK_BIDX_INT32ARRAY_PROTOTYPE   46
 
#define DUK_BIDX_UINT32ARRAY_PROTOTYPE   47
 
#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE   48
 
#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE   49
 
#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE   50
 
#define DUK_NUM_BUILTINS   51
 
#define DUK_NUM_BIDX_BUILTINS   51
 
#define DUK_NUM_ALL_BUILTINS   78
 
#define DUK_UTIL_H_INCLUDED
 
#define DUK_UTIL_GET_RANDOM_DOUBLE(thr)   duk_util_tinyrandom_get_double(thr)
 
#define DUK_DOUBLE_2TO32   4294967296.0
 
#define DUK_DOUBLE_2TO31   2147483648.0
 
#define DUK_DOUBLE_LOG2E   1.4426950408889634
 
#define DUK_DOUBLE_LOG10E   0.4342944819032518
 
#define DUK_BD_BITPACKED_STRING_MAXLEN   256
 
#define DUK_RAW_WRITE_U8(ptr, val)
 
#define DUK_RAW_WRITE_U16_BE(ptr, val)   duk_raw_write_u16_be(&(ptr), (duk_uint16_t) (val))
 
#define DUK_RAW_WRITE_U32_BE(ptr, val)   duk_raw_write_u32_be(&(ptr), (duk_uint32_t) (val))
 
#define DUK_RAW_WRITE_DOUBLE_BE(ptr, val)   duk_raw_write_double_be(&(ptr), (duk_double_t) (val))
 
#define DUK_RAW_WRITE_XUTF8(ptr, val)
 
#define DUK_RAW_WRITE_CESU8(ptr, val)
 
#define DUK_RAW_READ_U8(ptr)   ((duk_uint8_t) (*(ptr)++))
 
#define DUK_RAW_READ_U16_BE(ptr)   duk_raw_read_u16_be(&(ptr));
 
#define DUK_RAW_READ_U32_BE(ptr)   duk_raw_read_u32_be(&(ptr));
 
#define DUK_RAW_READ_DOUBLE_BE(ptr)   duk_raw_read_double_be(&(ptr));
 
#define DUK_BW_SLACK_ADD   64
 
#define DUK_BW_SLACK_SHIFT   2 /* 2^2 -> 1/4 = 25% slack */
 
#define DUK_BW_INIT_PUSHBUF(thr, bw_ctx, sz)
 
#define DUK_BW_INIT_WITHBUF(thr, bw_ctx, buf)
 
#define DUK_BW_COMPACT(thr, bw_ctx)
 
#define DUK_BW_PUSH_AS_STRING(thr, bw_ctx)
 
#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx)
 
#define DUK_BW_ASSERT_VALID(thr, bw_ctx)
 
#define DUK_BW_GET_PTR(thr, bw_ctx)   ((bw_ctx)->p)
 
#define DUK_BW_SET_PTR(thr, bw_ctx, ptr)
 
#define DUK_BW_ADD_PTR(thr, bw_ctx, delta)
 
#define DUK_BW_GET_BASEPTR(thr, bw_ctx)   ((bw_ctx)->p_base)
 
#define DUK_BW_GET_LIMITPTR(thr, bw_ctx)   ((bw_ctx)->p_limit)
 
#define DUK_BW_GET_SIZE(thr, bw_ctx)   ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))
 
#define DUK_BW_SET_SIZE(thr, bw_ctx, sz)
 
#define DUK_BW_RESET_SIZE(thr, bw_ctx)
 
#define DUK_BW_GET_BUFFER(thr, bw_ctx)   ((bw_ctx)->buf)
 
#define DUK_BW_ENSURE(thr, bw_ctx, sz)
 
#define DUK_BW_ENSURE_RAW(thr, bw_ctx, sz, ptr)
 
#define DUK_BW_ENSURE_GETPTR(thr, bw_ctx, sz)   DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)
 
#define DUK_BW_ASSERT_SPACE_EXPR(thr, bw_ctx, sz)
 
#define DUK_BW_ASSERT_SPACE(thr, bw_ctx, sz)
 
#define DUK_BW_SETPTR_AND_COMPACT(thr, bw_ctx, ptr)
 
#define DUK_BW_WRITE_RAW_U8(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_U8_2(thr, bw_ctx, val1, val2)
 
#define DUK_BW_WRITE_RAW_U8_3(thr, bw_ctx, val1, val2, val3)
 
#define DUK_BW_WRITE_RAW_U8_4(thr, bw_ctx, val1, val2, val3, val4)
 
#define DUK_BW_WRITE_RAW_U8_5(thr, bw_ctx, val1, val2, val3, val4, val5)
 
#define DUK_BW_WRITE_RAW_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6)
 
#define DUK_BW_WRITE_RAW_XUTF8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_RAW_CESU8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_RAW_BYTES(thr, bw_ctx, valptr, valsz)
 
#define DUK_BW_WRITE_RAW_CSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HBUFFER(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_SLICE(thr, bw, dst_off, dst_len)   duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))
 
#define DUK_BW_INSERT_RAW_BYTES(thr, bw, dst_off, buf, len)   duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))
 
#define DUK_BW_INSERT_RAW_SLICE(thr, bw, dst_off, src_off, len)   duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))
 
#define DUK_BW_INSERT_RAW_AREA(thr, bw, off, len)   duk_bw_insert_raw_area((thr), (bw), (off), (len))
 
#define DUK_BW_REMOVE_RAW_SLICE(thr, bw, off, len)   duk_bw_remove_raw_slice((thr), (bw), (off), (len))
 
#define DUK_BW_WRITE_ENSURE_U8(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_U8_2(thr, bw_ctx, val1, val2)
 
#define DUK_BW_WRITE_ENSURE_U8_3(thr, bw_ctx, val1, val2, val3)
 
#define DUK_BW_WRITE_ENSURE_U8_4(thr, bw_ctx, val1, val2, val3, val4)
 
#define DUK_BW_WRITE_ENSURE_U8_5(thr, bw_ctx, val1, val2, val3, val4, val5)
 
#define DUK_BW_WRITE_ENSURE_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6)
 
#define DUK_BW_WRITE_ENSURE_XUTF8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_ENSURE_CESU8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_ENSURE_BYTES(thr, bw_ctx, valptr, valsz)
 
#define DUK_BW_WRITE_ENSURE_CSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HBUFFER(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_SLICE(thr, bw, dst_off, dst_len)   duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))
 
#define DUK_BW_INSERT_ENSURE_BYTES(thr, bw, dst_off, buf, len)   duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))
 
#define DUK_BW_INSERT_ENSURE_SLICE(thr, bw, dst_off, src_off, len)   duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len))
 
#define DUK_BW_INSERT_ENSURE_AREA(thr, bw, off, len)
 
#define DUK_BW_REMOVE_ENSURE_SLICE(thr, bw, off, len)
 
#define duk_memcpy(dst, src, len)
 
#define duk_memcpy_unsafe(dst, src, len)
 
#define duk_memmove(dst, src, len)
 
#define duk_memmove_unsafe(dst, src, len)
 
#define duk_memset(dst, val, len)
 
#define duk_memset_unsafe(dst, val, len)
 
#define duk_memzero(dst, len)
 
#define duk_memzero_unsafe(dst, len)
 
#define DUK_IS_POWER_OF_TWO(x)   ((x) != 0U && ((x) & ((x) - 1U)) == 0U)
 
#define DUK_ERRMSG_H_INCLUDED
 
#define DUK_STR_INTERNAL_ERROR   "internal error"
 
#define DUK_STR_UNSUPPORTED   "unsupported"
 
#define DUK_STR_INVALID_COUNT   "invalid count"
 
#define DUK_STR_INVALID_ARGS   "invalid args"
 
#define DUK_STR_INVALID_STATE   "invalid state"
 
#define DUK_STR_INVALID_INPUT   "invalid input"
 
#define DUK_STR_INVALID_LENGTH   "invalid length"
 
#define DUK_STR_NOT_CONSTRUCTABLE   "not constructable"
 
#define DUK_STR_CONSTRUCT_ONLY   "constructor requires 'new'"
 
#define DUK_STR_NOT_CALLABLE   "not callable"
 
#define DUK_STR_NOT_EXTENSIBLE   "not extensible"
 
#define DUK_STR_NOT_WRITABLE   "not writable"
 
#define DUK_STR_NOT_CONFIGURABLE   "not configurable"
 
#define DUK_STR_INVALID_CONTEXT   "invalid context"
 
#define DUK_STR_INVALID_INDEX   "invalid args"
 
#define DUK_STR_PUSH_BEYOND_ALLOC_STACK   "cannot push beyond allocated stack"
 
#define DUK_STR_NOT_UNDEFINED   "unexpected type"
 
#define DUK_STR_NOT_NULL   "unexpected type"
 
#define DUK_STR_NOT_BOOLEAN   "unexpected type"
 
#define DUK_STR_NOT_NUMBER   "unexpected type"
 
#define DUK_STR_NOT_STRING   "unexpected type"
 
#define DUK_STR_NOT_OBJECT   "unexpected type"
 
#define DUK_STR_NOT_POINTER   "unexpected type"
 
#define DUK_STR_NOT_BUFFER   "not buffer" /* still in use with verbose messages */
 
#define DUK_STR_UNEXPECTED_TYPE   "unexpected type"
 
#define DUK_STR_NOT_THREAD   "unexpected type"
 
#define DUK_STR_NOT_COMPFUNC   "unexpected type"
 
#define DUK_STR_NOT_NATFUNC   "unexpected type"
 
#define DUK_STR_NOT_C_FUNCTION   "unexpected type"
 
#define DUK_STR_NOT_FUNCTION   "unexpected type"
 
#define DUK_STR_NOT_REGEXP   "unexpected type"
 
#define DUK_STR_TOPRIMITIVE_FAILED   "coercion to primitive failed"
 
#define DUK_STR_NUMBER_OUTSIDE_RANGE   "number outside range"
 
#define DUK_STR_NOT_OBJECT_COERCIBLE   "not object coercible"
 
#define DUK_STR_CANNOT_NUMBER_COERCE_SYMBOL   "cannot number coerce Symbol"
 
#define DUK_STR_CANNOT_STRING_COERCE_SYMBOL   "cannot string coerce Symbol"
 
#define DUK_STR_STRING_TOO_LONG   "string too long"
 
#define DUK_STR_BUFFER_TOO_LONG   "buffer too long"
 
#define DUK_STR_ALLOC_FAILED   "alloc failed"
 
#define DUK_STR_WRONG_BUFFER_TYPE   "wrong buffer type"
 
#define DUK_STR_BASE64_ENCODE_FAILED   "base64 encode failed"
 
#define DUK_STR_SOURCE_DECODE_FAILED   "source decode failed"
 
#define DUK_STR_UTF8_DECODE_FAILED   "utf-8 decode failed"
 
#define DUK_STR_BASE64_DECODE_FAILED   "base64 decode failed"
 
#define DUK_STR_HEX_DECODE_FAILED   "hex decode failed"
 
#define DUK_STR_INVALID_BYTECODE   "invalid bytecode"
 
#define DUK_STR_NO_SOURCECODE   "no sourcecode"
 
#define DUK_STR_RESULT_TOO_LONG   "result too long"
 
#define DUK_STR_INVALID_CFUNC_RC   "invalid C function rc"
 
#define DUK_STR_INVALID_INSTANCEOF_RVAL   "invalid instanceof rval"
 
#define DUK_STR_INVALID_INSTANCEOF_RVAL_NOPROTO   "instanceof rval has no .prototype"
 
#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"
 
#define DUK_STR_INVALID_BASE   "invalid base value"
 
#define DUK_STR_STRICT_CALLER_READ   "cannot read strict 'caller'"
 
#define DUK_STR_PROXY_REJECTED   "proxy rejected"
 
#define DUK_STR_INVALID_ARRAY_LENGTH   "invalid array length"
 
#define DUK_STR_SETTER_UNDEFINED   "setter undefined"
 
#define DUK_STR_INVALID_DESCRIPTOR   "invalid descriptor"
 
#define DUK_STR_PROXY_REVOKED   "proxy revoked"
 
#define DUK_STR_INVALID_TRAP_RESULT   "invalid trap result"
 
#define DUK_STR_INVALID_ESCAPE   "invalid escape"
 
#define DUK_STR_UNTERMINATED_STRING   "unterminated string"
 
#define DUK_STR_UNTERMINATED_COMMENT   "unterminated comment"
 
#define DUK_STR_UNTERMINATED_REGEXP   "unterminated regexp"
 
#define DUK_STR_TOKEN_LIMIT   "token limit"
 
#define DUK_STR_REGEXP_SUPPORT_DISABLED   "regexp support disabled"
 
#define DUK_STR_INVALID_NUMBER_LITERAL   "invalid number literal"
 
#define DUK_STR_INVALID_TOKEN   "invalid token"
 
#define DUK_STR_PARSE_ERROR   "parse error"
 
#define DUK_STR_DUPLICATE_LABEL   "duplicate label"
 
#define DUK_STR_INVALID_LABEL   "invalid label"
 
#define DUK_STR_INVALID_ARRAY_LITERAL   "invalid array literal"
 
#define DUK_STR_INVALID_OBJECT_LITERAL   "invalid object literal"
 
#define DUK_STR_INVALID_VAR_DECLARATION   "invalid variable declaration"
 
#define DUK_STR_CANNOT_DELETE_IDENTIFIER   "cannot delete identifier"
 
#define DUK_STR_INVALID_EXPRESSION   "invalid expression"
 
#define DUK_STR_INVALID_LVALUE   "invalid lvalue"
 
#define DUK_STR_INVALID_NEWTARGET   "invalid new.target"
 
#define DUK_STR_EXPECTED_IDENTIFIER   "expected identifier"
 
#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED   "empty expression not allowed"
 
#define DUK_STR_INVALID_FOR   "invalid for statement"
 
#define DUK_STR_INVALID_SWITCH   "invalid switch statement"
 
#define DUK_STR_INVALID_BREAK_CONT_LABEL   "invalid break/continue label"
 
#define DUK_STR_INVALID_RETURN   "invalid return"
 
#define DUK_STR_INVALID_TRY   "invalid try"
 
#define DUK_STR_INVALID_THROW   "invalid throw"
 
#define DUK_STR_WITH_IN_STRICT_MODE   "with in strict mode"
 
#define DUK_STR_FUNC_STMT_NOT_ALLOWED   "function statement not allowed"
 
#define DUK_STR_UNTERMINATED_STMT   "unterminated statement"
 
#define DUK_STR_INVALID_ARG_NAME   "invalid argument name"
 
#define DUK_STR_INVALID_FUNC_NAME   "invalid function name"
 
#define DUK_STR_INVALID_GETSET_NAME   "invalid getter/setter name"
 
#define DUK_STR_FUNC_NAME_REQUIRED   "function name required"
 
#define DUK_STR_INVALID_QUANTIFIER   "invalid regexp quantifier"
 
#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM   "quantifier without preceding atom"
 
#define DUK_STR_INVALID_QUANTIFIER_VALUES   "quantifier values invalid (qmin > qmax)"
 
#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES   "quantifier requires too many atom copies"
 
#define DUK_STR_UNEXPECTED_CLOSING_PAREN   "unexpected closing parenthesis"
 
#define DUK_STR_UNEXPECTED_END_OF_PATTERN   "unexpected end of pattern"
 
#define DUK_STR_UNEXPECTED_REGEXP_TOKEN   "unexpected token in regexp"
 
#define DUK_STR_INVALID_REGEXP_FLAGS   "invalid regexp flags"
 
#define DUK_STR_INVALID_REGEXP_ESCAPE   "invalid regexp escape"
 
#define DUK_STR_INVALID_BACKREFS   "invalid backreference(s)"
 
#define DUK_STR_INVALID_REGEXP_CHARACTER   "invalid regexp character"
 
#define DUK_STR_INVALID_REGEXP_GROUP   "invalid regexp group"
 
#define DUK_STR_UNTERMINATED_CHARCLASS   "unterminated character class"
 
#define DUK_STR_INVALID_RANGE   "invalid range"
 
#define DUK_STR_VALSTACK_LIMIT   "valstack limit"
 
#define DUK_STR_CALLSTACK_LIMIT   "callstack limit"
 
#define DUK_STR_PROTOTYPE_CHAIN_LIMIT   "prototype chain limit"
 
#define DUK_STR_BOUND_CHAIN_LIMIT   "function call bound chain limit"
 
#define DUK_STR_C_CALLSTACK_LIMIT   "C call stack depth limit"
 
#define DUK_STR_COMPILER_RECURSION_LIMIT   "compiler recursion limit"
 
#define DUK_STR_BYTECODE_LIMIT   "bytecode limit"
 
#define DUK_STR_REG_LIMIT   "register limit"
 
#define DUK_STR_TEMP_LIMIT   "temp limit"
 
#define DUK_STR_CONST_LIMIT   "const limit"
 
#define DUK_STR_FUNC_LIMIT   "function limit"
 
#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT   "regexp compiler recursion limit"
 
#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT   "regexp executor recursion limit"
 
#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT   "regexp step limit"
 
#define DUK_JS_BYTECODE_H_INCLUDED
 
#define DUK_BC_SHIFT_OP   0
 
#define DUK_BC_SHIFT_A   8
 
#define DUK_BC_SHIFT_B   16
 
#define DUK_BC_SHIFT_C   24
 
#define DUK_BC_SHIFT_BC   DUK_BC_SHIFT_B
 
#define DUK_BC_SHIFT_ABC   DUK_BC_SHIFT_A
 
#define DUK_BC_UNSHIFTED_MASK_OP   0xffUL
 
#define DUK_BC_UNSHIFTED_MASK_A   0xffUL
 
#define DUK_BC_UNSHIFTED_MASK_B   0xffUL
 
#define DUK_BC_UNSHIFTED_MASK_C   0xffUL
 
#define DUK_BC_UNSHIFTED_MASK_BC   0xffffUL
 
#define DUK_BC_UNSHIFTED_MASK_ABC   0xffffffUL
 
#define DUK_BC_SHIFTED_MASK_OP   (DUK_BC_UNSHIFTED_MASK_OP << DUK_BC_SHIFT_OP)
 
#define DUK_BC_SHIFTED_MASK_A   (DUK_BC_UNSHIFTED_MASK_A << DUK_BC_SHIFT_A)
 
#define DUK_BC_SHIFTED_MASK_B   (DUK_BC_UNSHIFTED_MASK_B << DUK_BC_SHIFT_B)
 
#define DUK_BC_SHIFTED_MASK_C   (DUK_BC_UNSHIFTED_MASK_C << DUK_BC_SHIFT_C)
 
#define DUK_BC_SHIFTED_MASK_BC   (DUK_BC_UNSHIFTED_MASK_BC << DUK_BC_SHIFT_BC)
 
#define DUK_BC_SHIFTED_MASK_ABC   (DUK_BC_UNSHIFTED_MASK_ABC << DUK_BC_SHIFT_ABC)
 
#define DUK_DEC_OP(x)   ((x) & 0xffUL)
 
#define DUK_DEC_A(x)   (((x) >> 8) & 0xffUL)
 
#define DUK_DEC_B(x)   (((x) >> 16) & 0xffUL)
 
#define DUK_DEC_C(x)   (((x) >> 24) & 0xffUL)
 
#define DUK_DEC_BC(x)   (((x) >> 16) & 0xffffUL)
 
#define DUK_DEC_ABC(x)   (((x) >> 8) & 0xffffffUL)
 
#define DUK_ENC_OP(op)   ((duk_instr_t) (op))
 
#define DUK_ENC_OP_ABC(op, abc)
 
#define DUK_ENC_OP_A_BC(op, a, bc)
 
#define DUK_ENC_OP_A_B_C(op, a, b, c)
 
#define DUK_ENC_OP_A_B(op, a, b)   DUK_ENC_OP_A_B_C((op),(a),(b),0)
 
#define DUK_ENC_OP_A(op, a)   DUK_ENC_OP_A_B_C((op),(a),0,0)
 
#define DUK_ENC_OP_BC(op, bc)   DUK_ENC_OP_A_BC((op),0,(bc))
 
#define DUK_BC_NOREGCONST_OP(op)   ((op) & 0xfc)
 
#define DUK_BC_OP_MIN   0
 
#define DUK_BC_OP_MAX   0xffL
 
#define DUK_BC_A_MIN   0
 
#define DUK_BC_A_MAX   0xffL
 
#define DUK_BC_B_MIN   0
 
#define DUK_BC_B_MAX   0xffL
 
#define DUK_BC_C_MIN   0
 
#define DUK_BC_C_MAX   0xffL
 
#define DUK_BC_BC_MIN   0
 
#define DUK_BC_BC_MAX   0xffffL
 
#define DUK_BC_ABC_MIN   0
 
#define DUK_BC_ABC_MAX   0xffffffL
 
#define DUK_BC_REGCONST_B   (0x01UL)
 
#define DUK_BC_REGCONST_C   (0x02UL)
 
#define DUK_BC_INCDECP_FLAG_DEC   (0x04UL)
 
#define DUK_BC_INCDECP_FLAG_POST   (0x08UL)
 
#define DUK_OP_LDREG   0
 
#define DUK_OP_STREG   1
 
#define DUK_OP_JUMP   2
 
#define DUK_OP_LDCONST   3
 
#define DUK_OP_LDINT   4
 
#define DUK_OP_LDINTX   5
 
#define DUK_OP_LDTHIS   6
 
#define DUK_OP_LDUNDEF   7
 
#define DUK_OP_LDNULL   8
 
#define DUK_OP_LDTRUE   9
 
#define DUK_OP_LDFALSE   10
 
#define DUK_OP_GETVAR   11
 
#define DUK_OP_BNOT   12
 
#define DUK_OP_LNOT   13
 
#define DUK_OP_UNM   14
 
#define DUK_OP_UNP   15
 
#define DUK_OP_EQ   16
 
#define DUK_OP_EQ_RR   16
 
#define DUK_OP_EQ_CR   17
 
#define DUK_OP_EQ_RC   18
 
#define DUK_OP_EQ_CC   19
 
#define DUK_OP_NEQ   20
 
#define DUK_OP_NEQ_RR   20
 
#define DUK_OP_NEQ_CR   21
 
#define DUK_OP_NEQ_RC   22
 
#define DUK_OP_NEQ_CC   23
 
#define DUK_OP_SEQ   24
 
#define DUK_OP_SEQ_RR   24
 
#define DUK_OP_SEQ_CR   25
 
#define DUK_OP_SEQ_RC   26
 
#define DUK_OP_SEQ_CC   27
 
#define DUK_OP_SNEQ   28
 
#define DUK_OP_SNEQ_RR   28
 
#define DUK_OP_SNEQ_CR   29
 
#define DUK_OP_SNEQ_RC   30
 
#define DUK_OP_SNEQ_CC   31
 
#define DUK_OP_GT   32
 
#define DUK_OP_GT_RR   32
 
#define DUK_OP_GT_CR   33
 
#define DUK_OP_GT_RC   34
 
#define DUK_OP_GT_CC   35
 
#define DUK_OP_GE   36
 
#define DUK_OP_GE_RR   36
 
#define DUK_OP_GE_CR   37
 
#define DUK_OP_GE_RC   38
 
#define DUK_OP_GE_CC   39
 
#define DUK_OP_LT   40
 
#define DUK_OP_LT_RR   40
 
#define DUK_OP_LT_CR   41
 
#define DUK_OP_LT_RC   42
 
#define DUK_OP_LT_CC   43
 
#define DUK_OP_LE   44
 
#define DUK_OP_LE_RR   44
 
#define DUK_OP_LE_CR   45
 
#define DUK_OP_LE_RC   46
 
#define DUK_OP_LE_CC   47
 
#define DUK_OP_IFTRUE   48
 
#define DUK_OP_IFTRUE_R   48
 
#define DUK_OP_IFTRUE_C   49
 
#define DUK_OP_IFFALSE   50
 
#define DUK_OP_IFFALSE_R   50
 
#define DUK_OP_IFFALSE_C   51
 
#define DUK_OP_ADD   52
 
#define DUK_OP_ADD_RR   52
 
#define DUK_OP_ADD_CR   53
 
#define DUK_OP_ADD_RC   54
 
#define DUK_OP_ADD_CC   55
 
#define DUK_OP_SUB   56
 
#define DUK_OP_SUB_RR   56
 
#define DUK_OP_SUB_CR   57
 
#define DUK_OP_SUB_RC   58
 
#define DUK_OP_SUB_CC   59
 
#define DUK_OP_MUL   60
 
#define DUK_OP_MUL_RR   60
 
#define DUK_OP_MUL_CR   61
 
#define DUK_OP_MUL_RC   62
 
#define DUK_OP_MUL_CC   63
 
#define DUK_OP_DIV   64
 
#define DUK_OP_DIV_RR   64
 
#define DUK_OP_DIV_CR   65
 
#define DUK_OP_DIV_RC   66
 
#define DUK_OP_DIV_CC   67
 
#define DUK_OP_MOD   68
 
#define DUK_OP_MOD_RR   68
 
#define DUK_OP_MOD_CR   69
 
#define DUK_OP_MOD_RC   70
 
#define DUK_OP_MOD_CC   71
 
#define DUK_OP_EXP   72
 
#define DUK_OP_EXP_RR   72
 
#define DUK_OP_EXP_CR   73
 
#define DUK_OP_EXP_RC   74
 
#define DUK_OP_EXP_CC   75
 
#define DUK_OP_BAND   76
 
#define DUK_OP_BAND_RR   76
 
#define DUK_OP_BAND_CR   77
 
#define DUK_OP_BAND_RC   78
 
#define DUK_OP_BAND_CC   79
 
#define DUK_OP_BOR   80
 
#define DUK_OP_BOR_RR   80
 
#define DUK_OP_BOR_CR   81
 
#define DUK_OP_BOR_RC   82
 
#define DUK_OP_BOR_CC   83
 
#define DUK_OP_BXOR   84
 
#define DUK_OP_BXOR_RR   84
 
#define DUK_OP_BXOR_CR   85
 
#define DUK_OP_BXOR_RC   86
 
#define DUK_OP_BXOR_CC   87
 
#define DUK_OP_BASL   88
 
#define DUK_OP_BASL_RR   88
 
#define DUK_OP_BASL_CR   89
 
#define DUK_OP_BASL_RC   90
 
#define DUK_OP_BASL_CC   91
 
#define DUK_OP_BLSR   92
 
#define DUK_OP_BLSR_RR   92
 
#define DUK_OP_BLSR_CR   93
 
#define DUK_OP_BLSR_RC   94
 
#define DUK_OP_BLSR_CC   95
 
#define DUK_OP_BASR   96
 
#define DUK_OP_BASR_RR   96
 
#define DUK_OP_BASR_CR   97
 
#define DUK_OP_BASR_RC   98
 
#define DUK_OP_BASR_CC   99
 
#define DUK_OP_INSTOF   100
 
#define DUK_OP_INSTOF_RR   100
 
#define DUK_OP_INSTOF_CR   101
 
#define DUK_OP_INSTOF_RC   102
 
#define DUK_OP_INSTOF_CC   103
 
#define DUK_OP_IN   104
 
#define DUK_OP_IN_RR   104
 
#define DUK_OP_IN_CR   105
 
#define DUK_OP_IN_RC   106
 
#define DUK_OP_IN_CC   107
 
#define DUK_OP_GETPROP   108
 
#define DUK_OP_GETPROP_RR   108
 
#define DUK_OP_GETPROP_CR   109
 
#define DUK_OP_GETPROP_RC   110
 
#define DUK_OP_GETPROP_CC   111
 
#define DUK_OP_PUTPROP   112
 
#define DUK_OP_PUTPROP_RR   112
 
#define DUK_OP_PUTPROP_CR   113
 
#define DUK_OP_PUTPROP_RC   114
 
#define DUK_OP_PUTPROP_CC   115
 
#define DUK_OP_DELPROP   116
 
#define DUK_OP_DELPROP_RR   116
 
#define DUK_OP_DELPROP_CR_UNUSED   117 /* unused now */
 
#define DUK_OP_DELPROP_RC   118
 
#define DUK_OP_DELPROP_CC_UNUSED   119 /* unused now */
 
#define DUK_OP_PREINCR   120 /* pre/post opcode values have constraints, */
 
#define DUK_OP_PREDECR   121 /* see duk_js_executor.c and duk_js_compiler.c. */
 
#define DUK_OP_POSTINCR   122
 
#define DUK_OP_POSTDECR   123
 
#define DUK_OP_PREINCV   124
 
#define DUK_OP_PREDECV   125
 
#define DUK_OP_POSTINCV   126
 
#define DUK_OP_POSTDECV   127
 
#define DUK_OP_PREINCP   128 /* pre/post inc/dec prop opcodes have constraints */
 
#define DUK_OP_PREINCP_RR   128
 
#define DUK_OP_PREINCP_CR   129
 
#define DUK_OP_PREINCP_RC   130
 
#define DUK_OP_PREINCP_CC   131
 
#define DUK_OP_PREDECP   132
 
#define DUK_OP_PREDECP_RR   132
 
#define DUK_OP_PREDECP_CR   133
 
#define DUK_OP_PREDECP_RC   134
 
#define DUK_OP_PREDECP_CC   135
 
#define DUK_OP_POSTINCP   136
 
#define DUK_OP_POSTINCP_RR   136
 
#define DUK_OP_POSTINCP_CR   137
 
#define DUK_OP_POSTINCP_RC   138
 
#define DUK_OP_POSTINCP_CC   139
 
#define DUK_OP_POSTDECP   140
 
#define DUK_OP_POSTDECP_RR   140
 
#define DUK_OP_POSTDECP_CR   141
 
#define DUK_OP_POSTDECP_RC   142
 
#define DUK_OP_POSTDECP_CC   143
 
#define DUK_OP_DECLVAR   144
 
#define DUK_OP_DECLVAR_RR   144
 
#define DUK_OP_DECLVAR_CR   145
 
#define DUK_OP_DECLVAR_RC   146
 
#define DUK_OP_DECLVAR_CC   147
 
#define DUK_OP_REGEXP   148
 
#define DUK_OP_REGEXP_RR   148
 
#define DUK_OP_REGEXP_CR   149
 
#define DUK_OP_REGEXP_RC   150
 
#define DUK_OP_REGEXP_CC   151
 
#define DUK_OP_CLOSURE   152
 
#define DUK_OP_TYPEOF   153
 
#define DUK_OP_TYPEOFID   154
 
#define DUK_OP_PUTVAR   155
 
#define DUK_OP_DELVAR   156
 
#define DUK_OP_RETREG   157
 
#define DUK_OP_RETUNDEF   158
 
#define DUK_OP_RETCONST   159
 
#define DUK_OP_RETCONSTN   160 /* return const without incref (e.g. number) */
 
#define DUK_OP_LABEL   161
 
#define DUK_OP_ENDLABEL   162
 
#define DUK_OP_BREAK   163
 
#define DUK_OP_CONTINUE   164
 
#define DUK_OP_TRYCATCH   165
 
#define DUK_OP_ENDTRY   166
 
#define DUK_OP_ENDCATCH   167
 
#define DUK_OP_ENDFIN   168
 
#define DUK_OP_THROW   169
 
#define DUK_OP_INVLHS   170
 
#define DUK_OP_CSREG   171
 
#define DUK_OP_CSVAR   172
 
#define DUK_OP_CSVAR_RR   172
 
#define DUK_OP_CSVAR_CR   173
 
#define DUK_OP_CSVAR_RC   174
 
#define DUK_OP_CSVAR_CC   175
 
#define DUK_OP_CALL0   176 /* DUK_OP_CALL0 & 0x0F must be zero. */
 
#define DUK_OP_CALL1   177
 
#define DUK_OP_CALL2   178
 
#define DUK_OP_CALL3   179
 
#define DUK_OP_CALL4   180
 
#define DUK_OP_CALL5   181
 
#define DUK_OP_CALL6   182
 
#define DUK_OP_CALL7   183
 
#define DUK_OP_CALL8   184
 
#define DUK_OP_CALL9   185
 
#define DUK_OP_CALL10   186
 
#define DUK_OP_CALL11   187
 
#define DUK_OP_CALL12   188
 
#define DUK_OP_CALL13   189
 
#define DUK_OP_CALL14   190
 
#define DUK_OP_CALL15   191
 
#define DUK_OP_NEWOBJ   192
 
#define DUK_OP_NEWARR   193
 
#define DUK_OP_MPUTOBJ   194
 
#define DUK_OP_MPUTOBJI   195
 
#define DUK_OP_INITSET   196
 
#define DUK_OP_INITGET   197
 
#define DUK_OP_MPUTARR   198
 
#define DUK_OP_MPUTARRI   199
 
#define DUK_OP_SETALEN   200
 
#define DUK_OP_INITENUM   201
 
#define DUK_OP_NEXTENUM   202
 
#define DUK_OP_NEWTARGET   203
 
#define DUK_OP_DEBUGGER   204
 
#define DUK_OP_NOP   205
 
#define DUK_OP_INVALID   206
 
#define DUK_OP_UNUSED207   207
 
#define DUK_OP_GETPROPC   208
 
#define DUK_OP_GETPROPC_RR   208
 
#define DUK_OP_GETPROPC_CR   209
 
#define DUK_OP_GETPROPC_RC   210
 
#define DUK_OP_GETPROPC_CC   211
 
#define DUK_OP_UNUSED212   212
 
#define DUK_OP_UNUSED213   213
 
#define DUK_OP_UNUSED214   214
 
#define DUK_OP_UNUSED215   215
 
#define DUK_OP_UNUSED216   216
 
#define DUK_OP_UNUSED217   217
 
#define DUK_OP_UNUSED218   218
 
#define DUK_OP_UNUSED219   219
 
#define DUK_OP_UNUSED220   220
 
#define DUK_OP_UNUSED221   221
 
#define DUK_OP_UNUSED222   222
 
#define DUK_OP_UNUSED223   223
 
#define DUK_OP_UNUSED224   224
 
#define DUK_OP_UNUSED225   225
 
#define DUK_OP_UNUSED226   226
 
#define DUK_OP_UNUSED227   227
 
#define DUK_OP_UNUSED228   228
 
#define DUK_OP_UNUSED229   229
 
#define DUK_OP_UNUSED230   230
 
#define DUK_OP_UNUSED231   231
 
#define DUK_OP_UNUSED232   232
 
#define DUK_OP_UNUSED233   233
 
#define DUK_OP_UNUSED234   234
 
#define DUK_OP_UNUSED235   235
 
#define DUK_OP_UNUSED236   236
 
#define DUK_OP_UNUSED237   237
 
#define DUK_OP_UNUSED238   238
 
#define DUK_OP_UNUSED239   239
 
#define DUK_OP_UNUSED240   240
 
#define DUK_OP_UNUSED241   241
 
#define DUK_OP_UNUSED242   242
 
#define DUK_OP_UNUSED243   243
 
#define DUK_OP_UNUSED244   244
 
#define DUK_OP_UNUSED245   245
 
#define DUK_OP_UNUSED246   246
 
#define DUK_OP_UNUSED247   247
 
#define DUK_OP_UNUSED248   248
 
#define DUK_OP_UNUSED249   249
 
#define DUK_OP_UNUSED250   250
 
#define DUK_OP_UNUSED251   251
 
#define DUK_OP_UNUSED252   252
 
#define DUK_OP_UNUSED253   253
 
#define DUK_OP_UNUSED254   254
 
#define DUK_OP_UNUSED255   255
 
#define DUK_OP_NONE   256 /* dummy value used as marker (doesn't fit in 8-bit field) */
 
#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH   (1U << 0)
 
#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY   (1U << 1)
 
#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING   (1U << 2)
 
#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING   (1U << 3)
 
#define DUK_BC_DECLVAR_FLAG_FUNC_DECL   (1U << 4) /* function declaration */
 
#define DUK_BC_CALL_FLAG_TAILCALL   (1U << 0)
 
#define DUK_BC_CALL_FLAG_CONSTRUCT   (1U << 1)
 
#define DUK_BC_CALL_FLAG_CALLED_AS_EVAL   (1U << 2)
 
#define DUK_BC_CALL_FLAG_INDIRECT   (1U << 3)
 
#define DUK_BC_LDINT_BIAS   (1L << 15)
 
#define DUK_BC_LDINTX_SHIFT   16
 
#define DUK_BC_JUMP_BIAS   (1L << 23)
 
#define DUK_LEXER_H_INCLUDED
 
#define DUK_LEXER_INITCTX(ctx)   duk_lexer_initctx((ctx))
 
#define DUK_LEXER_SETPOINT(ctx, pt)   duk_lexer_setpoint((ctx), (pt))
 
#define DUK_LEXER_GETPOINT(ctx, pt)   duk_lexer_getpoint((ctx), (pt))
 
#define DUK_LEXER_WINDOW_SIZE   6
 
#define DUK_LEXER_BUFFER_SIZE   64
 
#define DUK_TOK_MINVAL   0
 
#define DUK_TOK_EOF   0
 
#define DUK_TOK_IDENTIFIER   1
 
#define DUK_TOK_START_RESERVED   2
 
#define DUK_TOK_BREAK   2
 
#define DUK_TOK_CASE   3
 
#define DUK_TOK_CATCH   4
 
#define DUK_TOK_CONTINUE   5
 
#define DUK_TOK_DEBUGGER   6
 
#define DUK_TOK_DEFAULT   7
 
#define DUK_TOK_DELETE   8
 
#define DUK_TOK_DO   9
 
#define DUK_TOK_ELSE   10
 
#define DUK_TOK_FINALLY   11
 
#define DUK_TOK_FOR   12
 
#define DUK_TOK_FUNCTION   13
 
#define DUK_TOK_IF   14
 
#define DUK_TOK_IN   15
 
#define DUK_TOK_INSTANCEOF   16
 
#define DUK_TOK_NEW   17
 
#define DUK_TOK_RETURN   18
 
#define DUK_TOK_SWITCH   19
 
#define DUK_TOK_THIS   20
 
#define DUK_TOK_THROW   21
 
#define DUK_TOK_TRY   22
 
#define DUK_TOK_TYPEOF   23
 
#define DUK_TOK_VAR   24
 
#define DUK_TOK_CONST   25
 
#define DUK_TOK_VOID   26
 
#define DUK_TOK_WHILE   27
 
#define DUK_TOK_WITH   28
 
#define DUK_TOK_CLASS   29
 
#define DUK_TOK_ENUM   30
 
#define DUK_TOK_EXPORT   31
 
#define DUK_TOK_EXTENDS   32
 
#define DUK_TOK_IMPORT   33
 
#define DUK_TOK_SUPER   34
 
#define DUK_TOK_NULL   35
 
#define DUK_TOK_TRUE   36
 
#define DUK_TOK_FALSE   37
 
#define DUK_TOK_START_STRICT_RESERVED   38 /* inclusive */
 
#define DUK_TOK_IMPLEMENTS   38
 
#define DUK_TOK_INTERFACE   39
 
#define DUK_TOK_LET   40
 
#define DUK_TOK_PACKAGE   41
 
#define DUK_TOK_PRIVATE   42
 
#define DUK_TOK_PROTECTED   43
 
#define DUK_TOK_PUBLIC   44
 
#define DUK_TOK_STATIC   45
 
#define DUK_TOK_YIELD   46
 
#define DUK_TOK_END_RESERVED   47 /* exclusive */
 
#define DUK_TOK_GET   47
 
#define DUK_TOK_SET   48
 
#define DUK_TOK_LCURLY   49
 
#define DUK_TOK_RCURLY   50
 
#define DUK_TOK_LBRACKET   51
 
#define DUK_TOK_RBRACKET   52
 
#define DUK_TOK_LPAREN   53
 
#define DUK_TOK_RPAREN   54
 
#define DUK_TOK_PERIOD   55
 
#define DUK_TOK_SEMICOLON   56
 
#define DUK_TOK_COMMA   57
 
#define DUK_TOK_LT   58
 
#define DUK_TOK_GT   59
 
#define DUK_TOK_LE   60
 
#define DUK_TOK_GE   61
 
#define DUK_TOK_EQ   62
 
#define DUK_TOK_NEQ   63
 
#define DUK_TOK_SEQ   64
 
#define DUK_TOK_SNEQ   65
 
#define DUK_TOK_ADD   66
 
#define DUK_TOK_SUB   67
 
#define DUK_TOK_MUL   68
 
#define DUK_TOK_DIV   69
 
#define DUK_TOK_MOD   70
 
#define DUK_TOK_EXP   71
 
#define DUK_TOK_INCREMENT   72
 
#define DUK_TOK_DECREMENT   73
 
#define DUK_TOK_ALSHIFT   74 /* named "arithmetic" because result is signed */
 
#define DUK_TOK_ARSHIFT   75
 
#define DUK_TOK_RSHIFT   76
 
#define DUK_TOK_BAND   77
 
#define DUK_TOK_BOR   78
 
#define DUK_TOK_BXOR   79
 
#define DUK_TOK_LNOT   80
 
#define DUK_TOK_BNOT   81
 
#define DUK_TOK_LAND   82
 
#define DUK_TOK_LOR   83
 
#define DUK_TOK_QUESTION   84
 
#define DUK_TOK_COLON   85
 
#define DUK_TOK_EQUALSIGN   86
 
#define DUK_TOK_ADD_EQ   87
 
#define DUK_TOK_SUB_EQ   88
 
#define DUK_TOK_MUL_EQ   89
 
#define DUK_TOK_DIV_EQ   90
 
#define DUK_TOK_MOD_EQ   91
 
#define DUK_TOK_EXP_EQ   92
 
#define DUK_TOK_ALSHIFT_EQ   93
 
#define DUK_TOK_ARSHIFT_EQ   94
 
#define DUK_TOK_RSHIFT_EQ   95
 
#define DUK_TOK_BAND_EQ   96
 
#define DUK_TOK_BOR_EQ   97
 
#define DUK_TOK_BXOR_EQ   98
 
#define DUK_TOK_NUMBER   99
 
#define DUK_TOK_STRING   100
 
#define DUK_TOK_REGEXP   101
 
#define DUK_TOK_MAXVAL   101 /* inclusive */
 
#define DUK_TOK_INVALID   DUK_SMALL_UINT_MAX
 
#define DUK_STRIDX_TO_TOK(x)   ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED)
 
#define DUK_RETOK_EOF   0
 
#define DUK_RETOK_DISJUNCTION   1
 
#define DUK_RETOK_QUANTIFIER   2
 
#define DUK_RETOK_ASSERT_START   3
 
#define DUK_RETOK_ASSERT_END   4
 
#define DUK_RETOK_ASSERT_WORD_BOUNDARY   5
 
#define DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY   6
 
#define DUK_RETOK_ASSERT_START_POS_LOOKAHEAD   7
 
#define DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD   8
 
#define DUK_RETOK_ATOM_PERIOD   9
 
#define DUK_RETOK_ATOM_CHAR   10
 
#define DUK_RETOK_ATOM_DIGIT   11 /* assumptions in regexp compiler */
 
#define DUK_RETOK_ATOM_NOT_DIGIT   12 /* -""- */
 
#define DUK_RETOK_ATOM_WHITE   13 /* -""- */
 
#define DUK_RETOK_ATOM_NOT_WHITE   14 /* -""- */
 
#define DUK_RETOK_ATOM_WORD_CHAR   15 /* -""- */
 
#define DUK_RETOK_ATOM_NOT_WORD_CHAR   16 /* -""- */
 
#define DUK_RETOK_ATOM_BACKREFERENCE   17
 
#define DUK_RETOK_ATOM_START_CAPTURE_GROUP   18
 
#define DUK_RETOK_ATOM_START_NONCAPTURE_GROUP   19
 
#define DUK_RETOK_ATOM_START_CHARCLASS   20
 
#define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED   21
 
#define DUK_RETOK_ATOM_END_GROUP   22
 
#define DUK_LEXER_TEMP_BUF_LIMIT   256
 
#define DUK_RE_QUANTIFIER_INFINITE   ((duk_uint32_t) 0xffffffffUL)
 
#define DUK_JS_COMPILER_H_INCLUDED
 
#define DUK_COMPILER_TOKEN_LIMIT   100000000L /* 1e8: protects against deeply nested inner functions */
 
#define DUK_COMPILER_PEEPHOLE_MAXITER   3
 
#define DUK_COMPILER_MAX_BYTECODE_LENGTH   (256L * 1024L * 1024L) /* 1 GB */
 
#define DUK_IVAL_NONE   0 /* no value */
 
#define DUK_IVAL_PLAIN   1 /* register, constant, or value */
 
#define DUK_IVAL_ARITH   2 /* binary arithmetic; DUK_OP_ADD, DUK_OP_EQ, other binary ops */
 
#define DUK_IVAL_PROP   3 /* property access */
 
#define DUK_IVAL_VAR   4 /* variable access */
 
#define DUK_ISPEC_NONE   0 /* no value */
 
#define DUK_ISPEC_VALUE   1 /* value resides in 'valstack_idx' */
 
#define DUK_ISPEC_REGCONST   2 /* value resides in a register or constant */
 
#define DUK_REGCONST_CONST_MARKER   DUK_INT32_MIN /* = -0x80000000 */
 
#define DUK_LABEL_FLAG_ALLOW_BREAK   (1U << 0)
 
#define DUK_LABEL_FLAG_ALLOW_CONTINUE   (1U << 1)
 
#define DUK_DECL_TYPE_VAR   0
 
#define DUK_DECL_TYPE_FUNC   1
 
#define DUK_REGEXP_H_INCLUDED
 
#define DUK_RE_MAX_ATOM_COPIES   1000
 
#define DUK_RE_COMPILE_TOKEN_LIMIT   100000000L /* 1e8 */
 
#define DUK_RE_EXECUTE_STEPS_LIMIT   1000000000L /* 1e9 */
 
#define DUK_REOP_MATCH   1
 
#define DUK_REOP_CHAR   2
 
#define DUK_REOP_PERIOD   3
 
#define DUK_REOP_RANGES   4
 
#define DUK_REOP_INVRANGES   5
 
#define DUK_REOP_JUMP   6
 
#define DUK_REOP_SPLIT1   7
 
#define DUK_REOP_SPLIT2   8
 
#define DUK_REOP_SQMINIMAL   9
 
#define DUK_REOP_SQGREEDY   10
 
#define DUK_REOP_SAVE   11
 
#define DUK_REOP_WIPERANGE   12
 
#define DUK_REOP_LOOKPOS   13
 
#define DUK_REOP_LOOKNEG   14
 
#define DUK_REOP_BACKREFERENCE   15
 
#define DUK_REOP_ASSERT_START   16
 
#define DUK_REOP_ASSERT_END   17
 
#define DUK_REOP_ASSERT_WORD_BOUNDARY   18
 
#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY   19
 
#define DUK_RE_FLAG_GLOBAL   (1U << 0)
 
#define DUK_RE_FLAG_IGNORE_CASE   (1U << 1)
 
#define DUK_RE_FLAG_MULTILINE   (1U << 2)
 
#define DUK_HEAPHDR_H_INCLUDED
 
#define DUK_HEAPHDR_FLAGS_TYPE_MASK   0x00000003UL
 
#define DUK_HEAPHDR_FLAGS_FLAG_MASK   (~DUK_HEAPHDR_FLAGS_TYPE_MASK)
 
#define DUK_HEAPHDR_FLAGS_HEAP_START   2 /* 5 heap flags */
 
#define DUK_HEAPHDR_FLAGS_USER_START   7 /* 25 user flags */
 
#define DUK_HEAPHDR_HEAP_FLAG_NUMBER(n)   (DUK_HEAPHDR_FLAGS_HEAP_START + (n))
 
#define DUK_HEAPHDR_USER_FLAG_NUMBER(n)   (DUK_HEAPHDR_FLAGS_USER_START + (n))
 
#define DUK_HEAPHDR_HEAP_FLAG(n)   (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n)))
 
#define DUK_HEAPHDR_USER_FLAG(n)   (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n)))
 
#define DUK_HEAPHDR_FLAG_REACHABLE   DUK_HEAPHDR_HEAP_FLAG(0) /* mark-and-sweep: reachable */
 
#define DUK_HEAPHDR_FLAG_TEMPROOT   DUK_HEAPHDR_HEAP_FLAG(1) /* mark-and-sweep: children not processed */
 
#define DUK_HEAPHDR_FLAG_FINALIZABLE   DUK_HEAPHDR_HEAP_FLAG(2) /* mark-and-sweep: finalizable (on current pass) */
 
#define DUK_HEAPHDR_FLAG_FINALIZED   DUK_HEAPHDR_HEAP_FLAG(3) /* mark-and-sweep: finalized (on previous pass) */
 
#define DUK_HEAPHDR_FLAG_READONLY   DUK_HEAPHDR_HEAP_FLAG(4) /* read-only object, in code section */
 
#define DUK_HTYPE_MIN   0
 
#define DUK_HTYPE_STRING   0
 
#define DUK_HTYPE_OBJECT   1
 
#define DUK_HTYPE_BUFFER   2
 
#define DUK_HTYPE_MAX   2
 
#define DUK_HEAPHDR_GET_NEXT(heap, h)   ((h)->h_next)
 
#define DUK_HEAPHDR_SET_NEXT(heap, h, val)
 
#define DUK_HEAPHDR_GET_PREV(heap, h)   ((h)->h_prev)
 
#define DUK_HEAPHDR_SET_PREV(heap, h, val)
 
#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount)
 
#define DUK_HEAPHDR_SET_REFCOUNT(h, val)
 
#define DUK_HEAPHDR_PREINC_REFCOUNT(h)   (++(h)->h_refcount) /* result: updated refcount */
 
#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)   (--(h)->h_refcount) /* result: updated refcount */
 
#define DUK_HEAPHDR_GET_FLAGS_RAW(h)   ((h)->h_flags)
 
#define DUK_HEAPHDR_SET_FLAGS_RAW(h, val)
 
#define DUK_HEAPHDR_GET_FLAGS(h)   ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)
 
#define DUK_HEAPHDR_SET_FLAGS(h, val)
 
#define DUK_HEAPHDR_GET_TYPE(h)   ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK)
 
#define DUK_HEAPHDR_SET_TYPE(h, val)
 
#define DUK_HEAPHDR_HTYPE_VALID(h)
 
#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h, tval, fval)
 
#define DUK_HEAPHDR_SET_FLAG_BITS(h, bits)
 
#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h, bits)
 
#define DUK_HEAPHDR_CHECK_FLAG_BITS(h, bits)   (((h)->h_flags & (bits)) != 0)
 
#define DUK_HEAPHDR_SET_REACHABLE(h)   DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
 
#define DUK_HEAPHDR_CLEAR_REACHABLE(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
 
#define DUK_HEAPHDR_HAS_REACHABLE(h)   DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
 
#define DUK_HEAPHDR_SET_TEMPROOT(h)   DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
 
#define DUK_HEAPHDR_CLEAR_TEMPROOT(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
 
#define DUK_HEAPHDR_HAS_TEMPROOT(h)   DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
 
#define DUK_HEAPHDR_SET_FINALIZABLE(h)   DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
 
#define DUK_HEAPHDR_CLEAR_FINALIZABLE(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
 
#define DUK_HEAPHDR_HAS_FINALIZABLE(h)   DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
 
#define DUK_HEAPHDR_SET_FINALIZED(h)   DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
 
#define DUK_HEAPHDR_CLEAR_FINALIZED(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
 
#define DUK_HEAPHDR_HAS_FINALIZED(h)   DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
 
#define DUK_HEAPHDR_SET_READONLY(h)   DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
 
#define DUK_HEAPHDR_CLEAR_READONLY(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
 
#define DUK_HEAPHDR_HAS_READONLY(h)   DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
 
#define DUK_HEAPHDR_GET_FLAG_RANGE(h, m, n)   (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL))
 
#define DUK_HEAPHDR_SET_FLAG_RANGE(h, m, n, v)
 
#define DUK_HEAPHDR_INIT_NULLS(h)
 
#define DUK_HEAPHDR_STRING_INIT_NULLS(h)
 
#define DUK_HEAPHDR_IS_OBJECT(h)   ((h)->h_flags & 0x01UL)
 
#define DUK_HEAPHDR_IS_STRING(h)   (DUK_HEAPHDR_GET_TYPE((h)) == DUK_HTYPE_STRING)
 
#define DUK_HEAPHDR_IS_BUFFER(h)   (DUK_HEAPHDR_GET_TYPE((h)) == DUK_HTYPE_BUFFER)
 
#define DUK_ASSERT_HEAPHDR_LINKS(heap, h)   do {} while (0)
 
#define DUK_ASSERT_HEAPHDR_VALID(h)
 
#define DUK_REFCOUNT_H_INCLUDED
 
#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)   DUK_TVAL_IS_HEAP_ALLOCATED((tv))
 
#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)   1
 
#define DUK_TVAL_INCREF_FAST(thr, tv)
 
#define DUK_TVAL_DECREF_FAST(thr, tv)
 
#define DUK_TVAL_DECREF_NORZ_FAST(thr, tv)
 
#define DUK_HEAPHDR_INCREF_FAST(thr, h)
 
#define DUK_HEAPHDR_DECREF_FAST_RAW(thr, h, rzcall, rzcast)
 
#define DUK_HEAPHDR_DECREF_FAST(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero,duk_heaphdr *)
 
#define DUK_HEAPHDR_DECREF_NORZ_FAST(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero_norz,duk_heaphdr *)
 
#define DUK_TVAL_INCREF_SLOW(thr, tv)   do { duk_tval_incref((tv)); } while (0)
 
#define DUK_TVAL_DECREF_SLOW(thr, tv)   do { duk_tval_decref((thr), (tv)); } while (0)
 
#define DUK_TVAL_DECREF_NORZ_SLOW(thr, tv)   do { duk_tval_decref_norz((thr), (tv)); } while (0)
 
#define DUK_HEAPHDR_INCREF_SLOW(thr, h)   do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
 
#define DUK_HEAPHDR_DECREF_SLOW(thr, h)   do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HEAPHDR_DECREF_NORZ_SLOW(thr, h)   do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HSTRING_INCREF_SLOW(thr, h)   do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
 
#define DUK_HSTRING_DECREF_SLOW(thr, h)   do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HSTRING_DECREF_NORZ_SLOW(thr, h)   do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HBUFFER_INCREF_SLOW(thr, h)   do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
 
#define DUK_HBUFFER_DECREF_SLOW(thr, h)   do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HBUFFER_DECREF_NORZ_SLOW(thr, h)   do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HOBJECT_INCREF_SLOW(thr, h)   do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
 
#define DUK_HOBJECT_DECREF_SLOW(thr, h)   do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_HOBJECT_DECREF_NORZ_SLOW(thr, h)   do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
 
#define DUK_TVAL_INCREF(thr, tv)   DUK_TVAL_INCREF_FAST((thr),(tv))
 
#define DUK_TVAL_DECREF(thr, tv)   DUK_TVAL_DECREF_FAST((thr),(tv))
 
#define DUK_TVAL_DECREF_NORZ(thr, tv)   DUK_TVAL_DECREF_NORZ_FAST((thr),(tv))
 
#define DUK_HEAPHDR_INCREF(thr, h)   DUK_HEAPHDR_INCREF_FAST((thr),(h))
 
#define DUK_HEAPHDR_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero,duk_heaphdr *)
 
#define DUK_HEAPHDR_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero_norz,duk_heaphdr *)
 
#define DUK_HSTRING_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
 
#define DUK_HSTRING_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hstring_refzero,duk_hstring *)
 
#define DUK_HSTRING_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hstring_refzero,duk_hstring *) /* no 'norz' variant */
 
#define DUK_HOBJECT_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
 
#define DUK_HOBJECT_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
 
#define DUK_HOBJECT_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
 
#define DUK_HBUFFER_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
 
#define DUK_HBUFFER_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hbuffer_refzero,duk_hbuffer *)
 
#define DUK_HBUFFER_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hbuffer_refzero,duk_hbuffer *) /* no 'norz' variant */
 
#define DUK_HCOMPFUNC_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
 
#define DUK_HCOMPFUNC_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
 
#define DUK_HCOMPFUNC_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
 
#define DUK_HNATFUNC_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
 
#define DUK_HNATFUNC_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
 
#define DUK_HNATFUNC_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
 
#define DUK_HBUFOBJ_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
 
#define DUK_HBUFOBJ_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
 
#define DUK_HBUFOBJ_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
 
#define DUK_HTHREAD_INCREF(thr, h)   DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
 
#define DUK_HTHREAD_DECREF(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
 
#define DUK_HTHREAD_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
 
#define DUK_HEAPHDR_INCREF_ALLOWNULL(thr, h)
 
#define DUK_HEAPHDR_DECREF_ALLOWNULL(thr, h)
 
#define DUK_HEAPHDR_DECREF_NORZ_ALLOWNULL(thr, h)
 
#define DUK_HOBJECT_INCREF_ALLOWNULL(thr, h)
 
#define DUK_HOBJECT_DECREF_ALLOWNULL(thr, h)
 
#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr, h)
 
#define DUK_HBUFFER_INCREF_ALLOWNULL(thr, h)
 
#define DUK_HBUFFER_DECREF_ALLOWNULL(thr, h)
 
#define DUK_HBUFFER_DECREF_NORZ_ALLOWNULL(thr, h)
 
#define DUK_HTHREAD_INCREF_ALLOWNULL(thr, h)
 
#define DUK_HTHREAD_DECREF_ALLOWNULL(thr, h)
 
#define DUK_HTHREAD_DECREF_NORZ_ALLOWNULL(thr, h)
 
#define DUK_REFZERO_CHECK_FAST(thr)
 
#define DUK_REFZERO_CHECK_SLOW(thr)
 
#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr, tvptr_dst)
 
#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0(thr, tvptr_dst)
 
#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr, tvptr_dst)
 
#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr, tvptr_dst)
 
#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr, tvptr_dst)
 
#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr, tvptr_dst, newval)   DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
 
#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr, tvptr_dst, lf_v, lf_fp, lf_flags)
 
#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr, tvptr_dst, newval)
 
#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr, tvptr_dst, tvptr_src)
 
#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr, tvptr_dst, tvptr_src)
 
#define DUK_TVAL_SET_UNDEFINED_UPDREF   DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
 
#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ   DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0
 
#define DUK_TVAL_SET_UNUSED_UPDREF   DUK_TVAL_SET_UNUSED_UPDREF_ALT0
 
#define DUK_TVAL_SET_NULL_UPDREF   DUK_TVAL_SET_NULL_UPDREF_ALT0
 
#define DUK_TVAL_SET_BOOLEAN_UPDREF   DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
 
#define DUK_TVAL_SET_NUMBER_UPDREF   DUK_TVAL_SET_NUMBER_UPDREF_ALT0
 
#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF   DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
 
#define DUK_TVAL_SET_DOUBLE_UPDREF   DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
 
#define DUK_TVAL_SET_NAN_UPDREF   DUK_TVAL_SET_NAN_UPDREF_ALT0
 
#define DUK_TVAL_SET_I48_UPDREF   DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast int-to-double */
 
#define DUK_TVAL_SET_I32_UPDREF   DUK_TVAL_SET_DOUBLE_CAST_UPDREF
 
#define DUK_TVAL_SET_U32_UPDREF   DUK_TVAL_SET_DOUBLE_CAST_UPDREF
 
#define DUK_TVAL_SET_FASTINT_UPDREF   DUK_TVAL_SET_I48_UPDREF /* convenience */
 
#define DUK_TVAL_SET_LIGHTFUNC_UPDREF   DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
 
#define DUK_TVAL_SET_STRING_UPDREF   DUK_TVAL_SET_STRING_UPDREF_ALT0
 
#define DUK_TVAL_SET_OBJECT_UPDREF   DUK_TVAL_SET_OBJECT_UPDREF_ALT0
 
#define DUK_TVAL_SET_BUFFER_UPDREF   DUK_TVAL_SET_BUFFER_UPDREF_ALT0
 
#define DUK_TVAL_SET_POINTER_UPDREF   DUK_TVAL_SET_POINTER_UPDREF_ALT0
 
#define DUK_TVAL_SET_TVAL_UPDREF   DUK_TVAL_SET_TVAL_UPDREF_ALT1
 
#define DUK_TVAL_SET_TVAL_UPDREF_FAST   DUK_TVAL_SET_TVAL_UPDREF_ALT1
 
#define DUK_TVAL_SET_TVAL_UPDREF_SLOW   DUK_TVAL_SET_TVAL_UPDREF_ALT0
 
#define DUK_TVAL_SET_TVAL_UPDREF_NORZ(thr, tv_dst, tv_src)
 
#define DUK_TVAL_SET_U32_UPDREF_NORZ(thr, tv_dst, val)
 
#define DUK_API_INTERNAL_H_INCLUDED
 
#define DUK_INTERNAL_SYMBOL(x)   ("\x82" x)
 
#define DUK_PUSH_SPRINTF_INITIAL_SIZE   256L
 
#define DUK_PUSH_SPRINTF_SANITY_LIMIT   (1L * 1024L * 1024L * 1024L)
 
#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE   (1L << 24)
 
#define duk_push_u64(thr, val)   duk_push_number((thr), (duk_double_t) (val))
 
#define duk_push_i64(thr, val)   duk_push_number((thr), (duk_double_t) (val))
 
#define duk_push_u32(thr, val)   duk_push_uint((thr), (duk_uint_t) (val))
 
#define duk_push_i32(thr, val)   duk_push_int((thr), (duk_int_t) (val))
 
#define duk_push_idx(thr, val)   duk_push_int((thr), (duk_int_t) (val))
 
#define duk_push_uarridx(thr, val)   duk_push_uint((thr), (duk_uint_t) (val))
 
#define duk_push_size_t(thr, val)   duk_push_uint((thr), (duk_uint_t) (val)) /* XXX: assumed to fit for now */
 
#define duk_require_hobject_promote_lfunc(thr, idx)   duk_require_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC)
 
#define duk_get_hobject_promote_lfunc(thr, idx)   duk_get_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC)
 
#define duk_push_hthread(thr, h)   duk_push_hobject((thr), (duk_hobject *) (h))
 
#define duk_push_hnatfunc(thr, h)   duk_push_hobject((thr), (duk_hobject *) (h))
 
#define duk_get_prop_stridx_short(thr, obj_idx, stridx)
 
#define duk_put_prop_stridx_short(thr, obj_idx, stridx)
 
#define duk_del_prop_stridx_short(thr, obj_idx, stridx)   duk_del_prop_stridx((thr), (obj_idx), (stridx))
 
#define duk_has_prop_stridx_short(thr, obj_idx, stridx)   duk_has_prop_stridx((thr), (obj_idx), (stridx))
 
#define duk_xdef_prop_stridx_short(thr, obj_idx, stridx, desc_flags)
 
#define duk_xdef_prop_wec(thr, obj_idx)   duk_xdef_prop((thr), (obj_idx), DUK_PROPDESC_FLAGS_WEC)
 
#define duk_xdef_prop_index_wec(thr, obj_idx, arr_idx)   duk_xdef_prop_index((thr), (obj_idx), (arr_idx), DUK_PROPDESC_FLAGS_WEC)
 
#define duk_xdef_prop_stridx_wec(thr, obj_idx, stridx)   duk_xdef_prop_stridx((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC)
 
#define duk_xdef_prop_stridx_short_wec(thr, obj_idx, stridx)   duk_xdef_prop_stridx_short((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC)
 
#define DUK_ASSERT_VALID_NEGIDX(thr, idx)   (DUK_ASSERT_EXPR((duk_int_t) (idx) < 0), DUK_ASSERT_EXPR(duk_is_valid_index((thr), (idx))))
 
#define DUK_ASSERT_VALID_POSIDX(thr, idx)   (DUK_ASSERT_EXPR((duk_int_t) (idx) >= 0), DUK_ASSERT_EXPR(duk_is_valid_index((thr), (idx))))
 
#define DUK_GET_TVAL_NEGIDX(thr, idx)   (DUK_ASSERT_VALID_NEGIDX((thr),(idx)), ((duk_hthread *) (thr))->valstack_top + (idx))
 
#define DUK_GET_TVAL_POSIDX(thr, idx)   (DUK_ASSERT_VALID_POSIDX((thr),(idx)), ((duk_hthread *) (thr))->valstack_bottom + (idx))
 
#define DUK_GET_HOBJECT_NEGIDX(thr, idx)   (DUK_ASSERT_VALID_NEGIDX((thr),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_top + (idx)))
 
#define DUK_GET_HOBJECT_POSIDX(thr, idx)   (DUK_ASSERT_VALID_POSIDX((thr),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_bottom + (idx)))
 
#define DUK_GET_THIS_TVAL_PTR(thr)
 
#define DUK_HSTRING_H_INCLUDED
 
#define DUK_HSTRING_MAX_BYTELEN   (0x7fffffffUL)
 
#define DUK_HSTRING_FLAG_ASCII   DUK_HEAPHDR_USER_FLAG(0) /* string is ASCII, clen == blen */
 
#define DUK_HSTRING_FLAG_ARRIDX   DUK_HEAPHDR_USER_FLAG(1) /* string is a valid array index */
 
#define DUK_HSTRING_FLAG_SYMBOL   DUK_HEAPHDR_USER_FLAG(2) /* string is a symbol (invalid utf-8) */
 
#define DUK_HSTRING_FLAG_HIDDEN   DUK_HEAPHDR_USER_FLAG(3) /* string is a hidden symbol (implies symbol, Duktape 1.x internal string) */
 
#define DUK_HSTRING_FLAG_RESERVED_WORD   DUK_HEAPHDR_USER_FLAG(4) /* string is a reserved word (non-strict) */
 
#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD   DUK_HEAPHDR_USER_FLAG(5) /* string is a reserved word (strict) */
 
#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS   DUK_HEAPHDR_USER_FLAG(6) /* string is 'eval' or 'arguments' */
 
#define DUK_HSTRING_FLAG_EXTDATA   DUK_HEAPHDR_USER_FLAG(7) /* string data is external (duk_hstring_external) */
 
#define DUK_HSTRING_FLAG_PINNED_LITERAL   DUK_HEAPHDR_USER_FLAG(8) /* string is a literal, and pinned */
 
#define DUK_HSTRING_HAS_ASCII(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
 
#define DUK_HSTRING_HAS_ARRIDX(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
 
#define DUK_HSTRING_HAS_SYMBOL(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
 
#define DUK_HSTRING_HAS_HIDDEN(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
 
#define DUK_HSTRING_HAS_RESERVED_WORD(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
 
#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
 
#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
 
#define DUK_HSTRING_HAS_EXTDATA(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
 
#define DUK_HSTRING_HAS_PINNED_LITERAL(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
 
#define DUK_HSTRING_SET_ASCII(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
 
#define DUK_HSTRING_SET_ARRIDX(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
 
#define DUK_HSTRING_SET_SYMBOL(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
 
#define DUK_HSTRING_SET_HIDDEN(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
 
#define DUK_HSTRING_SET_RESERVED_WORD(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
 
#define DUK_HSTRING_SET_STRICT_RESERVED_WORD(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
 
#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
 
#define DUK_HSTRING_SET_EXTDATA(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
 
#define DUK_HSTRING_SET_PINNED_LITERAL(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
 
#define DUK_HSTRING_CLEAR_ASCII(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
 
#define DUK_HSTRING_CLEAR_ARRIDX(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
 
#define DUK_HSTRING_CLEAR_SYMBOL(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
 
#define DUK_HSTRING_CLEAR_HIDDEN(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
 
#define DUK_HSTRING_CLEAR_RESERVED_WORD(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
 
#define DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
 
#define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
 
#define DUK_HSTRING_CLEAR_EXTDATA(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
 
#define DUK_HSTRING_CLEAR_PINNED_LITERAL(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
 
#define DUK_HSTRING_IS_ASCII(x)   DUK_HSTRING_HAS_ASCII((x)) /* lazily set! */
 
#define DUK_HSTRING_IS_EMPTY(x)   (DUK_HSTRING_GET_BYTELEN((x)) == 0)
 
#define DUK_HSTRING_GET_HASH(x)   ((x)->hash)
 
#define DUK_HSTRING_SET_HASH(x, v)
 
#define DUK_HSTRING_GET_BYTELEN(x)   ((x)->blen)
 
#define DUK_HSTRING_SET_BYTELEN(x, v)
 
#define DUK_HSTRING_GET_CHARLEN(x)   duk_hstring_get_charlen((x))
 
#define DUK_HSTRING_SET_CHARLEN(x, v)
 
#define DUK_HSTRING_GET_DATA(x)   ((const duk_uint8_t *) ((x) + 1))
 
#define DUK_HSTRING_GET_DATA_END(x)   (DUK_HSTRING_GET_DATA((x)) + (x)->blen)
 
#define DUK_HSTRING_NO_ARRAY_INDEX   (0xffffffffUL)
 
#define DUK_HSTRING_GET_ARRIDX_FAST(h)   ((h)->arridx)
 
#define DUK_HSTRING_GET_ARRIDX_SLOW(h)   ((h)->arridx)
 
#define DUK_SYMBOL_TYPE_HIDDEN   0
 
#define DUK_SYMBOL_TYPE_GLOBAL   1
 
#define DUK_SYMBOL_TYPE_LOCAL   2
 
#define DUK_SYMBOL_TYPE_WELLKNOWN   3
 
#define DUK_HOBJECT_H_INCLUDED
 
#define DUK_HOBJECT_FLAG_EXTENSIBLE   DUK_HEAPHDR_USER_FLAG(0) /* object is extensible */
 
#define DUK_HOBJECT_FLAG_CONSTRUCTABLE   DUK_HEAPHDR_USER_FLAG(1) /* object is constructable */
 
#define DUK_HOBJECT_FLAG_CALLABLE   DUK_HEAPHDR_USER_FLAG(2) /* object is callable */
 
#define DUK_HOBJECT_FLAG_BOUNDFUNC   DUK_HEAPHDR_USER_FLAG(3) /* object established using Function.prototype.bind() */
 
#define DUK_HOBJECT_FLAG_COMPFUNC   DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompfunc) */
 
#define DUK_HOBJECT_FLAG_NATFUNC   DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnatfunc) */
 
#define DUK_HOBJECT_FLAG_BUFOBJ   DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufobj) (always exotic) */
 
#define DUK_HOBJECT_FLAG_FASTREFS   DUK_HEAPHDR_USER_FLAG(7) /* object has no fields needing DECREF/marking beyond base duk_hobject header */
 
#define DUK_HOBJECT_FLAG_ARRAY_PART   DUK_HEAPHDR_USER_FLAG(8) /* object has an array part (a_size may still be 0) */
 
#define DUK_HOBJECT_FLAG_STRICT   DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */
 
#define DUK_HOBJECT_FLAG_NOTAIL   DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */
 
#define DUK_HOBJECT_FLAG_NEWENV   DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompfunc) */
 
#define DUK_HOBJECT_FLAG_NAMEBINDING   DUK_HEAPHDR_USER_FLAG(12) /* function: create binding for func name (function templates only, used for named function expressions) */
 
#define DUK_HOBJECT_FLAG_CREATEARGS   DUK_HEAPHDR_USER_FLAG(13) /* function: create an arguments object on function call */
 
#define DUK_HOBJECT_FLAG_HAVE_FINALIZER   DUK_HEAPHDR_USER_FLAG(14) /* object has a callable (own) finalizer property */
 
#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY   DUK_HEAPHDR_USER_FLAG(15) /* 'Array' object, array length and index exotic behavior */
 
#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ   DUK_HEAPHDR_USER_FLAG(16) /* 'String' object, array index exotic behavior */
 
#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS   DUK_HEAPHDR_USER_FLAG(17) /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */
 
#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ   DUK_HEAPHDR_USER_FLAG(18) /* 'Proxy' object */
 
#define DUK_HOBJECT_FLAG_SPECIAL_CALL   DUK_HEAPHDR_USER_FLAG(19) /* special casing in call behavior, for .call(), .apply(), etc. */
 
#define DUK_HOBJECT_FLAG_CLASS_BASE   DUK_HEAPHDR_USER_FLAG_NUMBER(20)
 
#define DUK_HOBJECT_FLAG_CLASS_BITS   5
 
#define DUK_HOBJECT_GET_CLASS_NUMBER(h)   DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)
 
#define DUK_HOBJECT_SET_CLASS_NUMBER(h, v)   DUK_HEAPHDR_SET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS, (v))
 
#define DUK_HOBJECT_GET_CLASS_MASK(h)   (1UL << DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS))
 
#define DUK_HOBJECT_CLASS_AS_FLAGS(v)   (((duk_uint_t) (v)) << DUK_HOBJECT_FLAG_CLASS_BASE)
 
#define DUK_HOBJECT_CLASS_NONE   0
 
#define DUK_HOBJECT_CLASS_OBJECT   1
 
#define DUK_HOBJECT_CLASS_ARRAY   2
 
#define DUK_HOBJECT_CLASS_FUNCTION   3
 
#define DUK_HOBJECT_CLASS_ARGUMENTS   4
 
#define DUK_HOBJECT_CLASS_BOOLEAN   5
 
#define DUK_HOBJECT_CLASS_DATE   6
 
#define DUK_HOBJECT_CLASS_ERROR   7
 
#define DUK_HOBJECT_CLASS_JSON   8
 
#define DUK_HOBJECT_CLASS_MATH   9
 
#define DUK_HOBJECT_CLASS_NUMBER   10
 
#define DUK_HOBJECT_CLASS_REGEXP   11
 
#define DUK_HOBJECT_CLASS_STRING   12
 
#define DUK_HOBJECT_CLASS_GLOBAL   13
 
#define DUK_HOBJECT_CLASS_SYMBOL   14
 
#define DUK_HOBJECT_CLASS_OBJENV   15 /* custom */
 
#define DUK_HOBJECT_CLASS_DECENV   16 /* custom */
 
#define DUK_HOBJECT_CLASS_POINTER   17 /* custom */
 
#define DUK_HOBJECT_CLASS_THREAD   18 /* custom; implies DUK_HOBJECT_IS_THREAD */
 
#define DUK_HOBJECT_CLASS_BUFOBJ_MIN   19
 
#define DUK_HOBJECT_CLASS_ARRAYBUFFER   19 /* implies DUK_HOBJECT_IS_BUFOBJ */
 
#define DUK_HOBJECT_CLASS_DATAVIEW   20
 
#define DUK_HOBJECT_CLASS_INT8ARRAY   21
 
#define DUK_HOBJECT_CLASS_UINT8ARRAY   22
 
#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY   23
 
#define DUK_HOBJECT_CLASS_INT16ARRAY   24
 
#define DUK_HOBJECT_CLASS_UINT16ARRAY   25
 
#define DUK_HOBJECT_CLASS_INT32ARRAY   26
 
#define DUK_HOBJECT_CLASS_UINT32ARRAY   27
 
#define DUK_HOBJECT_CLASS_FLOAT32ARRAY   28
 
#define DUK_HOBJECT_CLASS_FLOAT64ARRAY   29
 
#define DUK_HOBJECT_CLASS_BUFOBJ_MAX   29
 
#define DUK_HOBJECT_CLASS_MAX   29
 
#define DUK_HOBJECT_CMASK_ALL   ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL)
 
#define DUK_HOBJECT_CMASK_NONE   (1UL << DUK_HOBJECT_CLASS_NONE)
 
#define DUK_HOBJECT_CMASK_ARGUMENTS   (1UL << DUK_HOBJECT_CLASS_ARGUMENTS)
 
#define DUK_HOBJECT_CMASK_ARRAY   (1UL << DUK_HOBJECT_CLASS_ARRAY)
 
#define DUK_HOBJECT_CMASK_BOOLEAN   (1UL << DUK_HOBJECT_CLASS_BOOLEAN)
 
#define DUK_HOBJECT_CMASK_DATE   (1UL << DUK_HOBJECT_CLASS_DATE)
 
#define DUK_HOBJECT_CMASK_ERROR   (1UL << DUK_HOBJECT_CLASS_ERROR)
 
#define DUK_HOBJECT_CMASK_FUNCTION   (1UL << DUK_HOBJECT_CLASS_FUNCTION)
 
#define DUK_HOBJECT_CMASK_JSON   (1UL << DUK_HOBJECT_CLASS_JSON)
 
#define DUK_HOBJECT_CMASK_MATH   (1UL << DUK_HOBJECT_CLASS_MATH)
 
#define DUK_HOBJECT_CMASK_NUMBER   (1UL << DUK_HOBJECT_CLASS_NUMBER)
 
#define DUK_HOBJECT_CMASK_OBJECT   (1UL << DUK_HOBJECT_CLASS_OBJECT)
 
#define DUK_HOBJECT_CMASK_REGEXP   (1UL << DUK_HOBJECT_CLASS_REGEXP)
 
#define DUK_HOBJECT_CMASK_STRING   (1UL << DUK_HOBJECT_CLASS_STRING)
 
#define DUK_HOBJECT_CMASK_GLOBAL   (1UL << DUK_HOBJECT_CLASS_GLOBAL)
 
#define DUK_HOBJECT_CMASK_SYMBOL   (1UL << DUK_HOBJECT_CLASS_SYMBOL)
 
#define DUK_HOBJECT_CMASK_OBJENV   (1UL << DUK_HOBJECT_CLASS_OBJENV)
 
#define DUK_HOBJECT_CMASK_DECENV   (1UL << DUK_HOBJECT_CLASS_DECENV)
 
#define DUK_HOBJECT_CMASK_POINTER   (1UL << DUK_HOBJECT_CLASS_POINTER)
 
#define DUK_HOBJECT_CMASK_ARRAYBUFFER   (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER)
 
#define DUK_HOBJECT_CMASK_DATAVIEW   (1UL << DUK_HOBJECT_CLASS_DATAVIEW)
 
#define DUK_HOBJECT_CMASK_INT8ARRAY   (1UL << DUK_HOBJECT_CLASS_INT8ARRAY)
 
#define DUK_HOBJECT_CMASK_UINT8ARRAY   (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY)
 
#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY   (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY)
 
#define DUK_HOBJECT_CMASK_INT16ARRAY   (1UL << DUK_HOBJECT_CLASS_INT16ARRAY)
 
#define DUK_HOBJECT_CMASK_UINT16ARRAY   (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY)
 
#define DUK_HOBJECT_CMASK_INT32ARRAY   (1UL << DUK_HOBJECT_CLASS_INT32ARRAY)
 
#define DUK_HOBJECT_CMASK_UINT32ARRAY   (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY)
 
#define DUK_HOBJECT_CMASK_FLOAT32ARRAY   (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY)
 
#define DUK_HOBJECT_CMASK_FLOAT64ARRAY   (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY)
 
#define DUK_HOBJECT_CMASK_ALL_BUFOBJS
 
#define DUK_HOBJECT_IS_OBJENV(h)   (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV)
 
#define DUK_HOBJECT_IS_DECENV(h)   (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV)
 
#define DUK_HOBJECT_IS_ENV(h)   (DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_DECENV((h)))
 
#define DUK_HOBJECT_IS_ARRAY(h)   DUK_HOBJECT_HAS_EXOTIC_ARRAY((h)) /* Rely on class Array <=> exotic Array */
 
#define DUK_HOBJECT_IS_BOUNDFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
 
#define DUK_HOBJECT_IS_COMPFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
 
#define DUK_HOBJECT_IS_NATFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 
#define DUK_HOBJECT_IS_BUFOBJ(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 
#define DUK_HOBJECT_IS_THREAD(h)   (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_THREAD)
 
#define DUK_HOBJECT_IS_PROXY(h)   DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ((h))
 
#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)
 
#define DUK_HOBJECT_IS_FUNCTION(h)
 
#define DUK_HOBJECT_IS_CALLABLE(h)   DUK_HOBJECT_HAS_CALLABLE((h))
 
#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS
 
#define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS)
 
#define DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS
 
#define DUK_HOBJECT_HAS_VIRTUAL_PROPERTIES(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS)
 
#define DUK_HOBJECT_HAS_EXTENSIBLE(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
 
#define DUK_HOBJECT_HAS_CONSTRUCTABLE(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
 
#define DUK_HOBJECT_HAS_CALLABLE(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
 
#define DUK_HOBJECT_HAS_BOUNDFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
 
#define DUK_HOBJECT_HAS_COMPFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
 
#define DUK_HOBJECT_HAS_NATFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 
#define DUK_HOBJECT_HAS_BUFOBJ(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 
#define DUK_HOBJECT_HAS_FASTREFS(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
 
#define DUK_HOBJECT_HAS_ARRAY_PART(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
 
#define DUK_HOBJECT_HAS_STRICT(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
 
#define DUK_HOBJECT_HAS_NOTAIL(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
 
#define DUK_HOBJECT_HAS_NEWENV(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
 
#define DUK_HOBJECT_HAS_NAMEBINDING(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
 
#define DUK_HOBJECT_HAS_CREATEARGS(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
 
#define DUK_HOBJECT_HAS_HAVE_FINALIZER(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
 
#define DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
 
#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
 
#define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
 
#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
 
#define DUK_HOBJECT_HAS_SPECIAL_CALL(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
 
#define DUK_HOBJECT_SET_EXTENSIBLE(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
 
#define DUK_HOBJECT_SET_CONSTRUCTABLE(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
 
#define DUK_HOBJECT_SET_CALLABLE(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
 
#define DUK_HOBJECT_SET_BOUNDFUNC(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
 
#define DUK_HOBJECT_SET_COMPFUNC(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
 
#define DUK_HOBJECT_SET_NATFUNC(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 
#define DUK_HOBJECT_SET_BUFOBJ(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 
#define DUK_HOBJECT_SET_FASTREFS(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
 
#define DUK_HOBJECT_SET_ARRAY_PART(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
 
#define DUK_HOBJECT_SET_STRICT(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
 
#define DUK_HOBJECT_SET_NOTAIL(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
 
#define DUK_HOBJECT_SET_NEWENV(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
 
#define DUK_HOBJECT_SET_NAMEBINDING(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
 
#define DUK_HOBJECT_SET_CREATEARGS(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
 
#define DUK_HOBJECT_SET_HAVE_FINALIZER(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
 
#define DUK_HOBJECT_SET_EXOTIC_ARRAY(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
 
#define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
 
#define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
 
#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
 
#define DUK_HOBJECT_SET_SPECIAL_CALL(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
 
#define DUK_HOBJECT_CLEAR_EXTENSIBLE(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
 
#define DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
 
#define DUK_HOBJECT_CLEAR_CALLABLE(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
 
#define DUK_HOBJECT_CLEAR_BOUNDFUNC(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
 
#define DUK_HOBJECT_CLEAR_COMPFUNC(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
 
#define DUK_HOBJECT_CLEAR_NATFUNC(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 
#define DUK_HOBJECT_CLEAR_BUFOBJ(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 
#define DUK_HOBJECT_CLEAR_FASTREFS(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
 
#define DUK_HOBJECT_CLEAR_ARRAY_PART(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
 
#define DUK_HOBJECT_CLEAR_STRICT(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
 
#define DUK_HOBJECT_CLEAR_NOTAIL(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
 
#define DUK_HOBJECT_CLEAR_NEWENV(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
 
#define DUK_HOBJECT_CLEAR_NAMEBINDING(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
 
#define DUK_HOBJECT_CLEAR_CREATEARGS(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
 
#define DUK_HOBJECT_CLEAR_HAVE_FINALIZER(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
 
#define DUK_HOBJECT_CLEAR_EXOTIC_ARRAY(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
 
#define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
 
#define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
 
#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
 
#define DUK_HOBJECT_CLEAR_SPECIAL_CALL(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
 
#define DUK_HOBJECT_PROHIBITS_FASTREFS(h)
 
#define DUK_HOBJECT_ALLOWS_FASTREFS(h)   (!DUK_HOBJECT_PROHIBITS_FASTREFS((h)))
 
#define DUK_PROPDESC_FLAG_WRITABLE   (1U << 0) /* E5 Section 8.6.1 */
 
#define DUK_PROPDESC_FLAG_ENUMERABLE   (1U << 1) /* E5 Section 8.6.1 */
 
#define DUK_PROPDESC_FLAG_CONFIGURABLE   (1U << 2) /* E5 Section 8.6.1 */
 
#define DUK_PROPDESC_FLAG_ACCESSOR   (1U << 3) /* accessor */
 
#define DUK_PROPDESC_FLAG_VIRTUAL
 
#define DUK_PROPDESC_FLAGS_MASK
 
#define DUK_PROPDESC_FLAG_NO_OVERWRITE   (1U << 4) /* internal define property: skip write silently if exists */
 
#define DUK_PROPDESC_FLAGS_NONE   0
 
#define DUK_PROPDESC_FLAGS_W   (DUK_PROPDESC_FLAG_WRITABLE)
 
#define DUK_PROPDESC_FLAGS_E   (DUK_PROPDESC_FLAG_ENUMERABLE)
 
#define DUK_PROPDESC_FLAGS_C   (DUK_PROPDESC_FLAG_CONFIGURABLE)
 
#define DUK_PROPDESC_FLAGS_WE   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE)
 
#define DUK_PROPDESC_FLAGS_WC   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
 
#define DUK_PROPDESC_FLAGS_EC   (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
 
#define DUK_PROPDESC_FLAGS_WEC
 
#define DUK_GETDESC_FLAG_PUSH_VALUE   (1U << 0) /* push value to stack */
 
#define DUK_GETDESC_FLAG_IGNORE_PROTOLOOP   (1U << 1) /* don't throw for prototype loop */
 
#define DUK_ASSERT_HOBJECT_VALID(h)
 
#define DUK_HOBJECT_GET_PROPS(heap, h)   ((h)->props)
 
#define DUK_HOBJECT_SET_PROPS(heap, h, x)
 
#define DUK_HOBJECT_E_FLAG_PADDING(e_sz)   ((8 - (e_sz)) & 0x07)
 
#define DUK_HOBJECT_E_GET_KEY_BASE(heap, h)
 
#define DUK_HOBJECT_E_GET_VALUE_BASE(heap, h)
 
#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap, h)
 
#define DUK_HOBJECT_A_GET_BASE(heap, h)
 
#define DUK_HOBJECT_H_GET_BASE(heap, h)
 
#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent, n_arr, n_hash)
 
#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base, set_e_k, set_e_pv, set_e_f, set_a, set_h, n_ent, n_arr, n_hash)
 
#define DUK_HOBJECT_P_ALLOC_SIZE(h)   DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE((h)), DUK_HOBJECT_GET_ASIZE((h)), DUK_HOBJECT_GET_HSIZE((h)))
 
#define DUK_HOBJECT_E_GET_KEY(heap, h, i)   (DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_E_GET_KEY_PTR(heap, h, i)   (&DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_E_GET_VALUE(heap, h, i)   (DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)   (&DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_E_GET_VALUE_TVAL(heap, h, i)   (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)
 
#define DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, h, i)   (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)
 
#define DUK_HOBJECT_E_GET_VALUE_GETTER(heap, h, i)   (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)
 
#define DUK_HOBJECT_E_GET_VALUE_GETTER_PTR(heap, h, i)   (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)
 
#define DUK_HOBJECT_E_GET_VALUE_SETTER(heap, h, i)   (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)
 
#define DUK_HOBJECT_E_GET_VALUE_SETTER_PTR(heap, h, i)   (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)
 
#define DUK_HOBJECT_E_GET_FLAGS(heap, h, i)   (DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_E_GET_FLAGS_PTR(heap, h, i)   (&DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_A_GET_VALUE(heap, h, i)   (DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i)   (&DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_H_GET_INDEX(heap, h, i)   (DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_H_GET_INDEX_PTR(heap, h, i)   (&DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
 
#define DUK_HOBJECT_E_SET_KEY(heap, h, i, k)
 
#define DUK_HOBJECT_E_SET_VALUE(heap, h, i, v)
 
#define DUK_HOBJECT_E_SET_VALUE_TVAL(heap, h, i, v)
 
#define DUK_HOBJECT_E_SET_VALUE_GETTER(heap, h, i, v)
 
#define DUK_HOBJECT_E_SET_VALUE_SETTER(heap, h, i, v)
 
#define DUK_HOBJECT_E_SET_FLAGS(heap, h, i, f)
 
#define DUK_HOBJECT_A_SET_VALUE(heap, h, i, v)
 
#define DUK_HOBJECT_A_SET_VALUE_TVAL(heap, h, i, v)   DUK_HOBJECT_A_SET_VALUE((heap), (h), (i), (v)) /* alias for above */
 
#define DUK_HOBJECT_H_SET_INDEX(heap, h, i, v)
 
#define DUK_HOBJECT_E_SET_FLAG_BITS(heap, h, i, mask)
 
#define DUK_HOBJECT_E_CLEAR_FLAG_BITS(heap, h, i, mask)
 
#define DUK_HOBJECT_E_SLOT_IS_WRITABLE(heap, h, i)   ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_WRITABLE) != 0)
 
#define DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(heap, h, i)   ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)
 
#define DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(heap, h, i)   ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)
 
#define DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)   ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ACCESSOR) != 0)
 
#define DUK_HOBJECT_E_SLOT_SET_WRITABLE(heap, h, i)   DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)
 
#define DUK_HOBJECT_E_SLOT_SET_ENUMERABLE(heap, h, i)   DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)
 
#define DUK_HOBJECT_E_SLOT_SET_CONFIGURABLE(heap, h, i)   DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)
 
#define DUK_HOBJECT_E_SLOT_SET_ACCESSOR(heap, h, i)   DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)
 
#define DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(heap, h, i)   DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)
 
#define DUK_HOBJECT_E_SLOT_CLEAR_ENUMERABLE(heap, h, i)   DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)
 
#define DUK_HOBJECT_E_SLOT_CLEAR_CONFIGURABLE(heap, h, i)   DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)
 
#define DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(heap, h, i)   DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)
 
#define DUK_PROPDESC_IS_WRITABLE(p)   (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0)
 
#define DUK_PROPDESC_IS_ENUMERABLE(p)   (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)
 
#define DUK_PROPDESC_IS_CONFIGURABLE(p)   (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)
 
#define DUK_PROPDESC_IS_ACCESSOR(p)   (((p)->flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0)
 
#define DUK_HOBJECT_HASHIDX_UNUSED   0xffffffffUL
 
#define DUK_HOBJECT_HASHIDX_DELETED   0xfffffffeUL
 
#define DUK_HOBJECT_GET_ESIZE(h)   ((h)->e_size)
 
#define DUK_HOBJECT_SET_ESIZE(h, v)   do { (h)->e_size = (v); } while (0)
 
#define DUK_HOBJECT_GET_ENEXT(h)   ((h)->e_next)
 
#define DUK_HOBJECT_SET_ENEXT(h, v)   do { (h)->e_next = (v); } while (0)
 
#define DUK_HOBJECT_POSTINC_ENEXT(h)   ((h)->e_next++)
 
#define DUK_HOBJECT_GET_ASIZE(h)   ((h)->a_size)
 
#define DUK_HOBJECT_SET_ASIZE(h, v)   do { (h)->a_size = (v); } while (0)
 
#define DUK_HOBJECT_GET_HSIZE(h)   ((h)->h_size)
 
#define DUK_HOBJECT_SET_HSIZE(h, v)   do { (h)->h_size = (v); } while (0)
 
#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY   10000L
 
#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n)   duk_class_number_to_stridx[(n)]
 
#define DUK_HOBJECT_GET_CLASS_STRING(heap, h)
 
#define DUK_HOBJECT_GET_PROTOTYPE(heap, h)   ((h)->prototype)
 
#define DUK_HOBJECT_SET_PROTOTYPE(heap, h, x)
 
#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, p)   duk_hobject_set_prototype_updref((thr), (h), (p))
 
#define DUK_HOBJECT_SET_PROTOTYPE_INIT_INCREF(thr, h, proto)
 
#define DUK_HOBJECT_HAS_FINALIZER_FAST(heap, h)   duk_hobject_has_finalizer_fast_raw((h))
 
#define DUK_HOBJECT_MAX_PROPERTIES   0x3fffffffUL /* 2**30-1 ~= 1G properties */
 
#define DUK_HOBJECT_ALIGN_TARGET   8
 
#define DUK_PC2LINE_SKIP   64
 
#define DUK_PC2LINE_MAX_DIFF_LENGTH   (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8)
 
#define duk_hobject_get_internal_value_tval_ptr(heap, obj)   duk_hobject_find_existing_entry_tval_ptr((heap), (obj), DUK_HEAP_STRING_INT_VALUE((heap)))
 
#define DUK_DELPROP_FLAG_THROW   (1U << 0)
 
#define DUK_DELPROP_FLAG_FORCE   (1U << 1)
 
#define DUK_HCOMPFUNC_H_INCLUDED
 
#define DUK_HCOMPFUNC_GET_DATA(heap, h)   ((duk_hbuffer_fixed *) (void *) (h)->data)
 
#define DUK_HCOMPFUNC_SET_DATA(heap, h, v)
 
#define DUK_HCOMPFUNC_GET_FUNCS(heap, h)   ((h)->funcs)
 
#define DUK_HCOMPFUNC_SET_FUNCS(heap, h, v)
 
#define DUK_HCOMPFUNC_GET_BYTECODE(heap, h)   ((h)->bytecode)
 
#define DUK_HCOMPFUNC_SET_BYTECODE(heap, h, v)
 
#define DUK_HCOMPFUNC_GET_LEXENV(heap, h)   ((h)->lex_env)
 
#define DUK_HCOMPFUNC_SET_LEXENV(heap, h, v)
 
#define DUK_HCOMPFUNC_GET_VARENV(heap, h)   ((h)->var_env)
 
#define DUK_HCOMPFUNC_SET_VARENV(heap, h, v)
 
#define DUK_HCOMPFUNC_GET_BUFFER_BASE(heap, h)   DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPFUNC_GET_DATA((heap), (h)))
 
#define DUK_HCOMPFUNC_GET_CONSTS_BASE(heap, h)   ((duk_tval *) (void *) DUK_HCOMPFUNC_GET_BUFFER_BASE((heap), (h)))
 
#define DUK_HCOMPFUNC_GET_FUNCS_BASE(heap, h)   DUK_HCOMPFUNC_GET_FUNCS((heap), (h))
 
#define DUK_HCOMPFUNC_GET_CODE_BASE(heap, h)   DUK_HCOMPFUNC_GET_BYTECODE((heap), (h))
 
#define DUK_HCOMPFUNC_GET_CONSTS_END(heap, h)   ((duk_tval *) (void *) DUK_HCOMPFUNC_GET_FUNCS((heap), (h)))
 
#define DUK_HCOMPFUNC_GET_FUNCS_END(heap, h)   ((duk_hobject **) (void *) DUK_HCOMPFUNC_GET_BYTECODE((heap), (h)))
 
#define DUK_HCOMPFUNC_GET_CODE_END(heap, h)
 
#define DUK_HCOMPFUNC_GET_CONSTS_SIZE(heap, h)
 
#define DUK_HCOMPFUNC_GET_FUNCS_SIZE(heap, h)
 
#define DUK_HCOMPFUNC_GET_CODE_SIZE(heap, h)
 
#define DUK_HCOMPFUNC_GET_CONSTS_COUNT(heap, h)   ((duk_size_t) (DUK_HCOMPFUNC_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))
 
#define DUK_HCOMPFUNC_GET_FUNCS_COUNT(heap, h)   ((duk_size_t) (DUK_HCOMPFUNC_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))
 
#define DUK_HCOMPFUNC_GET_CODE_COUNT(heap, h)   ((duk_size_t) (DUK_HCOMPFUNC_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t)))
 
#define DUK_ASSERT_HCOMPFUNC_VALID(h)
 
#define DUK_HNATFUNC_H_INCLUDED
 
#define DUK_HNATFUNC_NARGS_VARARGS   ((duk_int16_t) -1)
 
#define DUK_HNATFUNC_NARGS_MAX   ((duk_int16_t) 0x7fff)
 
#define DUK_HBOUNDFUNC_H_INCLUDED
 
#define DUK_HBOUNDFUNC_MAX_ARGS   0x20000000UL
 
#define DUK_ASSERT_HBOUNDFUNC_VALID(h)
 
#define DUK_HBUFOBJ_H_INCLUDED
 
#define DUK_HBUFOBJ_ELEM_UINT8   0
 
#define DUK_HBUFOBJ_ELEM_UINT8CLAMPED   1
 
#define DUK_HBUFOBJ_ELEM_INT8   2
 
#define DUK_HBUFOBJ_ELEM_UINT16   3
 
#define DUK_HBUFOBJ_ELEM_INT16   4
 
#define DUK_HBUFOBJ_ELEM_UINT32   5
 
#define DUK_HBUFOBJ_ELEM_INT32   6
 
#define DUK_HBUFOBJ_ELEM_FLOAT32   7
 
#define DUK_HBUFOBJ_ELEM_FLOAT64   8
 
#define DUK_HBUFOBJ_ELEM_MAX   8
 
#define DUK_ASSERT_HBUFOBJ_VALID(h)
 
#define DUK_HBUFOBJ_GET_SLICE_BASE(heap, h)
 
#define DUK_HBUFOBJ_FULL_SLICE(h)
 
#define DUK_HBUFOBJ_VALID_SLICE(h)
 
#define DUK_HBUFOBJ_VALID_BYTEOFFSET_INCL(h, off)
 
#define DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL(h, off)
 
#define DUK_HBUFOBJ_CLAMP_BYTELENGTH(h, len)
 
#define DUK_HBUFOBJ_HAS_VIRTUAL_INDICES(h)   ((h)->is_typedarray)
 
#define DUK_HTHREAD_H_INCLUDED
 
#define DUK_VALSTACK_INITIAL_SIZE   96U
 
#define DUK_VALSTACK_INTERNAL_EXTRA   32U
 
#define DUK_VALSTACK_API_ENTRY_MINIMUM   DUK_API_ENTRY_STACK
 
#define DUK_ACT_FLAG_STRICT   (1U << 0) /* function executes in strict mode */
 
#define DUK_ACT_FLAG_TAILCALLED   (1U << 1) /* activation has tail called one or more times */
 
#define DUK_ACT_FLAG_CONSTRUCT   (1U << 2) /* function executes as a constructor (called via "new") */
 
#define DUK_ACT_FLAG_PREVENT_YIELD   (1U << 3) /* activation prevents yield (native call or "new") */
 
#define DUK_ACT_FLAG_DIRECT_EVAL   (1U << 4) /* activation is a direct eval call */
 
#define DUK_ACT_FLAG_CONSTRUCT_PROXY   (1U << 5) /* activation is for Proxy 'construct' call, special return value handling */
 
#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE   (1U << 6) /* activation has active breakpoint(s) */
 
#define DUK_ACT_GET_FUNC(act)   ((act)->func)
 
#define DUK_TB_FLAG_NOBLAME_FILELINE   (1U << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */
 
#define DUK_CAT_TYPE_MASK   0x0000000fUL
 
#define DUK_CAT_TYPE_BITS   4
 
#define DUK_CAT_LABEL_MASK   0xffffff00UL
 
#define DUK_CAT_LABEL_BITS   24
 
#define DUK_CAT_LABEL_SHIFT   8
 
#define DUK_CAT_FLAG_CATCH_ENABLED   (1U << 4) /* catch part will catch */
 
#define DUK_CAT_FLAG_FINALLY_ENABLED   (1U << 5) /* finally part will catch */
 
#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED   (1U << 6) /* request to create catch binding */
 
#define DUK_CAT_FLAG_LEXENV_ACTIVE   (1U << 7) /* catch or with binding is currently active */
 
#define DUK_CAT_TYPE_UNKNOWN   0
 
#define DUK_CAT_TYPE_TCF   1
 
#define DUK_CAT_TYPE_LABEL   2
 
#define DUK_CAT_GET_TYPE(c)   ((c)->flags & DUK_CAT_TYPE_MASK)
 
#define DUK_CAT_GET_LABEL(c)   (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT)
 
#define DUK_CAT_HAS_CATCH_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED)
 
#define DUK_CAT_HAS_FINALLY_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED)
 
#define DUK_CAT_HAS_CATCH_BINDING_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED)
 
#define DUK_CAT_HAS_LEXENV_ACTIVE(c)   ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)
 
#define DUK_CAT_SET_CATCH_ENABLED(c)
 
#define DUK_CAT_SET_FINALLY_ENABLED(c)
 
#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c)
 
#define DUK_CAT_SET_LEXENV_ACTIVE(c)
 
#define DUK_CAT_CLEAR_CATCH_ENABLED(c)
 
#define DUK_CAT_CLEAR_FINALLY_ENABLED(c)
 
#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED(c)
 
#define DUK_CAT_CLEAR_LEXENV_ACTIVE(c)
 
#define DUK_HTHREAD_GET_STRING(thr, idx)   ((thr)->strs[(idx)])
 
#define DUK_HTHREAD_STATE_INACTIVE   1 /* thread not currently running */
 
#define DUK_HTHREAD_STATE_RUNNING   2 /* thread currently running (only one at a time) */
 
#define DUK_HTHREAD_STATE_RESUMED   3 /* thread resumed another thread (active but not running) */
 
#define DUK_HTHREAD_STATE_YIELDED   4 /* thread has yielded */
 
#define DUK_HTHREAD_STATE_TERMINATED   5 /* thread has terminated */
 
#define DUK_ASSERT_HTHREAD_VALID(thr)
 
#define DUK_ASSERT_CTX_VALID(thr)
 
#define DUK_ASSERT_API_ENTRY(thr)
 
#define DUK_ASSERT_STRIDX_VALID(val)   DUK_ASSERT((duk_uint_t) (val) < DUK_HEAP_NUM_STRINGS)
 
#define DUK_ASSERT_BIDX_VALID(val)   DUK_ASSERT((duk_uint_t) (val) < DUK_NUM_BUILTINS)
 
#define DUK_HTHREAD_THIS_PTR(thr)
 
#define DUK_HARRAY_H_INCLUDED
 
#define DUK_ASSERT_HARRAY_VALID(h)
 
#define DUK_HARRAY_LENGTH_WRITABLE(h)   (!(h)->length_nonwritable)
 
#define DUK_HARRAY_LENGTH_NONWRITABLE(h)   ((h)->length_nonwritable)
 
#define DUK_HARRAY_SET_LENGTH_WRITABLE(h)   do { (h)->length_nonwritable = 0; } while (0)
 
#define DUK_HARRAY_SET_LENGTH_NONWRITABLE(h)   do { (h)->length_nonwritable = 1; } while (0)
 
#define DUK_HENV_H_INCLUDED
 
#define DUK_ASSERT_HDECENV_VALID(h)
 
#define DUK_ASSERT_HOBJENV_VALID(h)
 
#define DUK_HBUFFER_H_INCLUDED
 
#define DUK_HBUFFER_FLAG_DYNAMIC   DUK_HEAPHDR_USER_FLAG(0) /* buffer is behind a pointer, dynamic or external */
 
#define DUK_HBUFFER_FLAG_EXTERNAL   DUK_HEAPHDR_USER_FLAG(1) /* buffer pointer is to an externally allocated buffer */
 
#define DUK_HBUFFER_HAS_DYNAMIC(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
 
#define DUK_HBUFFER_HAS_EXTERNAL(x)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
 
#define DUK_HBUFFER_SET_DYNAMIC(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
 
#define DUK_HBUFFER_SET_EXTERNAL(x)   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
 
#define DUK_HBUFFER_CLEAR_DYNAMIC(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
 
#define DUK_HBUFFER_CLEAR_EXTERNAL(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
 
#define DUK_HBUFFER_MAX_BYTELEN   (0x7ffffffeUL)
 
#define DUK_HBUFFER_GET_SIZE(x)   (((duk_hbuffer *) (x))->size)
 
#define DUK_HBUFFER_SET_SIZE(x, v)
 
#define DUK_HBUFFER_ADD_SIZE(x, dv)
 
#define DUK_HBUFFER_SUB_SIZE(x, dv)
 
#define DUK_HBUFFER_FIXED_GET_SIZE(x)   DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
 
#define DUK_HBUFFER_FIXED_SET_SIZE(x, v)   DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x))
 
#define DUK_HBUFFER_DYNAMIC_GET_SIZE(x)   DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
 
#define DUK_HBUFFER_DYNAMIC_SET_SIZE(x, v)   DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
 
#define DUK_HBUFFER_DYNAMIC_ADD_SIZE(x, dv)   DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv))
 
#define DUK_HBUFFER_DYNAMIC_SUB_SIZE(x, dv)   DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv))
 
#define DUK_HBUFFER_EXTERNAL_GET_SIZE(x)   DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
 
#define DUK_HBUFFER_EXTERNAL_SET_SIZE(x, v)   DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
 
#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap, x)   ((duk_uint8_t *) (((duk_hbuffer_fixed *) (void *) (x)) + 1))
 
#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, x)   ((x)->curr_alloc)
 
#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, x, v)
 
#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap, x)
 
#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, x)   ((void *) (x)->curr_alloc)
 
#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, x, v)
 
#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap, x)
 
#define DUK_HBUFFER_GET_DATA_PTR(heap, x)
 
#define DUK_HPROXY_H_INCLUDED
 
#define DUK_ASSERT_HPROXY_VALID(h)
 
#define DUK_HEAP_H_INCLUDED
 
#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED   (1U << 0) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
 
#define DUK_HEAP_FLAG_INTERRUPT_RUNNING   (1U << 1) /* executor interrupt running (used to avoid nested interrupts) */
 
#define DUK_HEAP_FLAG_FINALIZER_NORESCUE   (1U << 2) /* heap destruction ongoing, finalizer rescue no longer possible */
 
#define DUK_HEAP_FLAG_DEBUGGER_PAUSED   (1U << 3) /* debugger is paused: talk with debug client until step/resume */
 
#define DUK__HEAP_HAS_FLAGS(heap, bits)   ((heap)->flags & (bits))
 
#define DUK__HEAP_SET_FLAGS(heap, bits)
 
#define DUK__HEAP_CLEAR_FLAGS(heap, bits)
 
#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
 
#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
 
#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
 
#define DUK_HEAP_HAS_DEBUGGER_PAUSED(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
 
#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
 
#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
 
#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
 
#define DUK_HEAP_SET_DEBUGGER_PAUSED(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
 
#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
 
#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap)   DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
 
#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE(heap)   DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
 
#define DUK_HEAP_CLEAR_DEBUGGER_PAUSED(heap)   DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
 
#define DUK_LJ_TYPE_UNKNOWN   0 /* unused */
 
#define DUK_LJ_TYPE_THROW   1 /* value1 -> error object */
 
#define DUK_LJ_TYPE_YIELD   2 /* value1 -> yield value, iserror -> error / normal */
 
#define DUK_LJ_TYPE_RESUME   3 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */
 
#define DUK_LJ_TYPE_BREAK   4 /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */
 
#define DUK_LJ_TYPE_CONTINUE   5 /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */
 
#define DUK_LJ_TYPE_RETURN   6 /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */
 
#define DUK_LJ_TYPE_NORMAL   7 /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */
 
#define DUK_MS_FLAG_EMERGENCY   (1U << 0)
 
#define DUK_MS_FLAG_VOLUNTARY   (1U << 1)
 
#define DUK_MS_FLAG_POSTPONE_RESCUE   (1U << 2)
 
#define DUK_MS_FLAG_NO_OBJECT_COMPACTION   (1U << 3)
 
#define DUK_HEAP_SWITCH_THREAD(heap, newthr)
 
#define DUK_STATS_INC(heap, fieldname)   do {} while (0)
 
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT   12800L /* 50x heap size */
 
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD   1024L
 
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP   256L
 
#define DUK_GC_TORTURE(heap)   do { } while (0)
 
#define