#include "duktape.h"

Data Structures
struct	duk_jmpbuf

struct	duk_tval_struct

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_hcompiledfunction

struct	duk_hnativefunction

struct	duk_hbufferobject

struct	duk_activation

struct	duk_catcher

struct	duk_hthread

struct	duk_hbuffer

struct	duk_hbuffer_fixed

struct	duk_hbuffer_dynamic

struct	duk_hbuffer_external

struct	duk_breakpoint

struct	duk_strcache

struct	duk_ljstate

struct	duk_strtab_entry

struct	duk_heap

struct	duk_json_enc_ctx

struct	duk_json_dec_ctx

struct	duk__compile_raw_args

struct	duk_internal_thread_state

struct	duk__transform_context

struct	duk__compiler_stkstate

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_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_NUMBER 0 /* not exposed */

#define	DUK_TAG_UNDEFINED 2

#define	DUK_TAG_NULL 3

#define	DUK_TAG_BOOLEAN 4

#define	DUK_TAG_POINTER 5

#define	DUK_TAG_LIGHTFUNC 6

#define	DUK_TAG_UNUSED 7 /* marker; not actual tagged type */

#define	DUK_TAG_STRING 8 /* first heap allocated, match bit boundary */

#define	DUK_TAG_OBJECT 9

#define	DUK_TAG_BUFFER 10

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

#define	DUK_TVAL_SET_DOUBLE(tv, d) DUK_TVAL_SET_NUMBER((tv), (d))

#define	DUK_TVAL_SET_FASTINT(tv, val) DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val)) /* XXX: fast int-to-double */

#define	DUK_TVAL_SET_FASTINT_U32(tv, val) DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))

#define	DUK_TVAL_SET_FASTINT_I32(tv, val) DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))

#define	DUK_TVAL_SET_NUMBER(tv, val)

#define	DUK_TVAL_SET_NUMBER_CHKFAST(tv, d) DUK_TVAL_SET_NUMBER((tv), (d))

#define	DUK_TVAL_CHKFAST_INPLACE(v) do { } while (0)

#define	DUK_TVAL_SET_POINTER(tv, hptr)

#define	DUK_TVAL_SET_LIGHTFUNC(tv, fp, flags)

#define	DUK_TVAL_SET_STRING(tv, hptr)

#define	DUK_TVAL_SET_OBJECT(tv, hptr)

#define	DUK_TVAL_SET_BUFFER(tv, hptr)

#define	DUK_TVAL_SET_NAN(tv)

#define	DUK_TVAL_SET_TVAL(v, x) do { (v) = (x); } while (0)

#define	DUK_TVAL_GET_BOOLEAN(tv) ((tv)->v.i)

#define	DUK_TVAL_GET_NUMBER(tv) ((tv)->v.d)

#define	DUK_TVAL_GET_DOUBLE(tv) ((tv)->v.d)

#define	DUK_TVAL_GET_POINTER(tv) ((tv)->v.voidptr)

#define	DUK_TVAL_GET_LIGHTFUNC(tv, out_fp, out_flags)

#define	DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv) ((tv)->v.lightfunc)

#define	DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv) ((duk_uint32_t) ((tv)->v_extra))

#define	DUK_TVAL_GET_STRING(tv) ((tv)->v.hstring)

#define	DUK_TVAL_GET_OBJECT(tv) ((tv)->v.hobject)

#define	DUK_TVAL_GET_BUFFER(tv) ((tv)->v.hbuffer)

#define	DUK_TVAL_GET_HEAPHDR(tv) ((tv)->v.heaphdr)

#define	DUK_TVAL_GET_TAG(tv) ((tv)->t)

#define	DUK_TVAL_IS_UNDEFINED(tv) ((tv)->t == DUK_TAG_UNDEFINED)

#define	DUK_TVAL_IS_UNUSED(tv) ((tv)->t == DUK_TAG_UNUSED)

#define	DUK_TVAL_IS_NULL(tv) ((tv)->t == DUK_TAG_NULL)

#define	DUK_TVAL_IS_BOOLEAN(tv) ((tv)->t == DUK_TAG_BOOLEAN)

#define	DUK_TVAL_IS_BOOLEAN_TRUE(tv) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0))

#define	DUK_TVAL_IS_BOOLEAN_FALSE(tv) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i == 0))

#define	DUK_TVAL_IS_NUMBER(tv) ((tv)->t == DUK__TAG_NUMBER)

#define	DUK_TVAL_IS_DOUBLE(v) DUK_TVAL_IS_NUMBER((v))

#define	DUK_TVAL_IS_POINTER(tv) ((tv)->t == DUK_TAG_POINTER)

#define	DUK_TVAL_IS_LIGHTFUNC(tv) ((tv)->t == DUK_TAG_LIGHTFUNC)

#define	DUK_TVAL_IS_STRING(tv) ((tv)->t == DUK_TAG_STRING)

#define	DUK_TVAL_IS_OBJECT(tv) ((tv)->t == DUK_TAG_OBJECT)

#define	DUK_TVAL_IS_BUFFER(tv) ((tv)->t == DUK_TAG_BUFFER)

#define	DUK_TVAL_IS_HEAP_ALLOCATED(tv) ((tv)->t & 0x08)

#define	DUK_TVAL_SET_BOOLEAN_TRUE(v) DUK_TVAL_SET_BOOLEAN(v, 1)

#define	DUK_TVAL_SET_BOOLEAN_FALSE(v) DUK_TVAL_SET_BOOLEAN(v, 0)

#define	DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags) ((((duk_int32_t) (lf_flags)) << 16) >> 24)

#define	DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags) (((lf_flags) >> 4) & 0x0f)

#define	DUK_LFUNC_FLAGS_GET_NARGS(lf_flags) ((lf_flags) & 0x0f)

#define	DUK_LFUNC_FLAGS_PACK(magic, length, nargs) (((magic) & 0xff) << 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_ARGUMENTS 2 /* '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 3 /* '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 4 /* '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 5 /* '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 6 /* '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 7 /* '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 8 /* '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 9 /* '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 10 /* '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 11 /* '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 12 /* '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 13 /* '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 14 /* '' */

#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 15 /* '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 16 /* '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 17 /* '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 18 /* '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 19 /* '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 20 /* '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 21 /* '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 22 /* '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 23 /* '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 24 /* '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 25 /* '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 26 /* '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 27 /* '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 28 /* '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 29 /* '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 30 /* '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 31 /* '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 32 /* '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_DEFINE_PROPERTY 33 /* 'defineProperty' */

#define	DUK_HEAP_STRING_DEFINE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)

#define	DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)

#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_ESCAPED_EMPTY_REGEXP 48 /* '(?:)' */

#define	DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)

#define	DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)

#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_OBJECT 56 /* '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 57 /* '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 58 /* '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 59 /* '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 60 /* '-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 61 /* '-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 62 /* ',' */

#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_SPACE 63 /* ' ' */

#define	DUK_HEAP_STRING_SPACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)

#define	DUK_HTHREAD_STRING_SPACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)

#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_HAS 70 /* '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_GET 71 /* '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_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_ENUMERATE 73 /* 'enumerate' */

#define	DUK_HEAP_STRING_ENUMERATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)

#define	DUK_HTHREAD_STRING_ENUMERATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)

#define	DUK_STRIDX_OWN_KEYS 74 /* '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_SET_PROTOTYPE_OF 75 /* '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__ 76 /* '__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_REQUIRE 77 /* 'require' */

#define	DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)

#define	DUK_HTHREAD_STRING_REQUIRE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)

#define	DUK_STRIDX_ID 78 /* 'id' */

#define	DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)

#define	DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)

#define	DUK_STRIDX_EXPORTS 79 /* 'exports' */

#define	DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS)

#define	DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS)

#define	DUK_STRIDX_FILENAME 80 /* 'filename' */

#define	DUK_HEAP_STRING_FILENAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILENAME)

#define	DUK_HTHREAD_STRING_FILENAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILENAME)

#define	DUK_STRIDX_TO_STRING 81 /* '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 82 /* '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 83 /* '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 84 /* '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 85 /* '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_BYTE_LENGTH 86 /* 'byteLength' */

#define	DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH)

#define	DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH)

#define	DUK_STRIDX_BYTE_OFFSET 87 /* 'byteOffset' */

#define	DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET)

#define	DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET)

#define	DUK_STRIDX_BYTES_PER_ELEMENT 88 /* 'BYTES_PER_ELEMENT' */

#define	DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT)

#define	DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT)

#define	DUK_STRIDX_SET 89 /* '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 90 /* '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 91 /* '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 92 /* '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 93 /* '\xffTracedata' */

#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 94 /* '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 95 /* '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_BUFFER 96 /* 'buffer' */

#define	DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)

#define	DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)

#define	DUK_STRIDX_LC_POINTER 97 /* '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_VALUE 98 /* '\xffValue' */

#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_INT_NEXT 99 /* '\xffNext' */

#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 100 /* '\xffBytecode' */

#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 101 /* '\xffFormals' */

#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 102 /* '\xffVarmap' */

#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_LEXENV 103 /* '\xffLexenv' */

#define	DUK_HEAP_STRING_INT_LEXENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)

#define	DUK_HTHREAD_STRING_INT_LEXENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)

#define	DUK_STRIDX_INT_VARENV 104 /* '\xffVarenv' */

#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_SOURCE 105 /* '\xffSource' */

#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 106 /* '\xffPc2line' */

#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_ARGS 107 /* '\xffArgs' */

#define	DUK_HEAP_STRING_INT_ARGS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)

#define	DUK_HTHREAD_STRING_INT_ARGS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)

#define	DUK_STRIDX_INT_MAP 108 /* '\xffMap' */

#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_FINALIZER 109 /* '\xffFinalizer' */

#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_HANDLER 110 /* '\xffHandler' */

#define	DUK_HEAP_STRING_INT_HANDLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)

#define	DUK_HTHREAD_STRING_INT_HANDLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)

#define	DUK_STRIDX_INT_CALLEE 111 /* '\xffCallee' */

#define	DUK_HEAP_STRING_INT_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)

#define	DUK_HTHREAD_STRING_INT_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)

#define	DUK_STRIDX_INT_THREAD 112 /* '\xffThread' */

#define	DUK_HEAP_STRING_INT_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)

#define	DUK_HTHREAD_STRING_INT_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)

#define	DUK_STRIDX_INT_REGBASE 113 /* '\xffRegbase' */

#define	DUK_HEAP_STRING_INT_REGBASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)

#define	DUK_HTHREAD_STRING_INT_REGBASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)

#define	DUK_STRIDX_INT_TARGET 114 /* '\xffTarget' */

#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_THIS 115 /* '\xffThis' */

#define	DUK_HEAP_STRING_INT_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)

#define	DUK_HTHREAD_STRING_INT_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)

#define	DUK_STRIDX_COMPILE 116 /* '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 117 /* '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 118 /* '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 119 /* '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_MOD_SEARCH 120 /* 'modSearch' */

#define	DUK_HEAP_STRING_MOD_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)

#define	DUK_HTHREAD_STRING_MOD_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)

#define	DUK_STRIDX_MOD_LOADED 121 /* 'modLoaded' */

#define	DUK_HEAP_STRING_MOD_LOADED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)

#define	DUK_HTHREAD_STRING_MOD_LOADED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)

#define	DUK_STRIDX_ENV 122 /* '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 123 /* '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 124 /* '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 125 /* '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 126 /* '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_RESUME 127 /* 'resume' */

#define	DUK_HEAP_STRING_RESUME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)

#define	DUK_HTHREAD_STRING_RESUME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)

#define	DUK_STRIDX_FMT 128 /* 'fmt' */

#define	DUK_HEAP_STRING_FMT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)

#define	DUK_HTHREAD_STRING_FMT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)

#define	DUK_STRIDX_RAW 129 /* 'raw' */

#define	DUK_HEAP_STRING_RAW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)

#define	DUK_HTHREAD_STRING_RAW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)

#define	DUK_STRIDX_LC_TRACE 130 /* 'trace' */

#define	DUK_HEAP_STRING_LC_TRACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)

#define	DUK_HTHREAD_STRING_LC_TRACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)

#define	DUK_STRIDX_LC_DEBUG 131 /* 'debug' */

#define	DUK_HEAP_STRING_LC_DEBUG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)

#define	DUK_HTHREAD_STRING_LC_DEBUG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)

#define	DUK_STRIDX_LC_INFO 132 /* 'info' */

#define	DUK_HEAP_STRING_LC_INFO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)

#define	DUK_HTHREAD_STRING_LC_INFO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)

#define	DUK_STRIDX_LC_WARN 133 /* 'warn' */

#define	DUK_HEAP_STRING_LC_WARN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)

#define	DUK_HTHREAD_STRING_LC_WARN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)

#define	DUK_STRIDX_LC_ERROR 134 /* 'error' */

#define	DUK_HEAP_STRING_LC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)

#define	DUK_HTHREAD_STRING_LC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)

#define	DUK_STRIDX_LC_FATAL 135 /* 'fatal' */

#define	DUK_HEAP_STRING_LC_FATAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)

#define	DUK_HTHREAD_STRING_LC_FATAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)

#define	DUK_STRIDX_LC_N 136 /* 'n' */

#define	DUK_HEAP_STRING_LC_N(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)

#define	DUK_HTHREAD_STRING_LC_N(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)

#define	DUK_STRIDX_LC_L 137 /* 'l' */

#define	DUK_HEAP_STRING_LC_L(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)

#define	DUK_HTHREAD_STRING_LC_L(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)

#define	DUK_STRIDX_CLOG 138 /* 'clog' */

#define	DUK_HEAP_STRING_CLOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)

#define	DUK_HTHREAD_STRING_CLOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)

#define	DUK_STRIDX_TO_LOG_STRING 139 /* 'toLogString' */

#define	DUK_HEAP_STRING_TO_LOG_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)

#define	DUK_HTHREAD_STRING_TO_LOG_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)

#define	DUK_STRIDX_JSON_EXT_UNDEFINED 140 /* '{"_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 141 /* '{"_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 142 /* '{"_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 143 /* '{"_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 144 /* '{"_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 145 /* '{_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 146 /* '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 147 /* '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 148 /* '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 149 /* '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 150 /* '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 151 /* '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 152 /* '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 153 /* '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 154 /* '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 155 /* '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 156 /* '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 157 /* '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 158 /* '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 159 /* '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 160 /* '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 161 /* '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 162 /* '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 163 /* '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 164 /* '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 165 /* '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 166 /* '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 167 /* '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 168 /* '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 169 /* '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 170 /* '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 171 /* '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 172 /* '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 173 /* '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 174 /* '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 175 /* '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 176 /* '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 177 /* '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 178 /* '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 179 /* '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 180 /* '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 181 /* '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 182 /* '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 183 /* '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 184 /* '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 185 /* '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 186 /* '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 187 /* '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 188 /* '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 189 /* '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 190 /* '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 191

#define	DUK_STRIDX_START_RESERVED 146

#define	DUK_STRIDX_START_STRICT_RESERVED 182

#define	DUK_STRIDX_END_RESERVED 191 /* exclusive endpoint */

#define	DUK_STRDATA_MAX_STRLEN 17

#define	DUK_STRDATA_DATA_LENGTH 1049

#define	DUK_BUILTIN_INITJS_DATA_LENGTH 204

#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_ARRAY_CONSTRUCTOR 6

#define	DUK_BIDX_ARRAY_PROTOTYPE 7

#define	DUK_BIDX_STRING_CONSTRUCTOR 8

#define	DUK_BIDX_STRING_PROTOTYPE 9

#define	DUK_BIDX_BOOLEAN_CONSTRUCTOR 10

#define	DUK_BIDX_BOOLEAN_PROTOTYPE 11

#define	DUK_BIDX_NUMBER_CONSTRUCTOR 12

#define	DUK_BIDX_NUMBER_PROTOTYPE 13

#define	DUK_BIDX_DATE_CONSTRUCTOR 14

#define	DUK_BIDX_DATE_PROTOTYPE 15

#define	DUK_BIDX_REGEXP_CONSTRUCTOR 16

#define	DUK_BIDX_REGEXP_PROTOTYPE 17

#define	DUK_BIDX_ERROR_CONSTRUCTOR 18

#define	DUK_BIDX_ERROR_PROTOTYPE 19

#define	DUK_BIDX_EVAL_ERROR_CONSTRUCTOR 20

#define	DUK_BIDX_EVAL_ERROR_PROTOTYPE 21

#define	DUK_BIDX_RANGE_ERROR_CONSTRUCTOR 22

#define	DUK_BIDX_RANGE_ERROR_PROTOTYPE 23

#define	DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR 24

#define	DUK_BIDX_REFERENCE_ERROR_PROTOTYPE 25

#define	DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR 26

#define	DUK_BIDX_SYNTAX_ERROR_PROTOTYPE 27

#define	DUK_BIDX_TYPE_ERROR_CONSTRUCTOR 28

#define	DUK_BIDX_TYPE_ERROR_PROTOTYPE 29

#define	DUK_BIDX_URI_ERROR_CONSTRUCTOR 30

#define	DUK_BIDX_URI_ERROR_PROTOTYPE 31

#define	DUK_BIDX_MATH 32

#define	DUK_BIDX_JSON 33

#define	DUK_BIDX_TYPE_ERROR_THROWER 34

#define	DUK_BIDX_PROXY_CONSTRUCTOR 35

#define	DUK_BIDX_DUKTAPE 36

#define	DUK_BIDX_THREAD_CONSTRUCTOR 37

#define	DUK_BIDX_THREAD_PROTOTYPE 38

#define	DUK_BIDX_BUFFER_CONSTRUCTOR 39

#define	DUK_BIDX_BUFFER_PROTOTYPE 40

#define	DUK_BIDX_POINTER_CONSTRUCTOR 41

#define	DUK_BIDX_POINTER_PROTOTYPE 42

#define	DUK_BIDX_LOGGER_CONSTRUCTOR 43

#define	DUK_BIDX_LOGGER_PROTOTYPE 44

#define	DUK_BIDX_DOUBLE_ERROR 45

#define	DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46

#define	DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47

#define	DUK_BIDX_DATAVIEW_CONSTRUCTOR 48

#define	DUK_BIDX_DATAVIEW_PROTOTYPE 49

#define	DUK_BIDX_TYPEDARRAY_PROTOTYPE 50

#define	DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51

#define	DUK_BIDX_INT8ARRAY_PROTOTYPE 52

#define	DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53

#define	DUK_BIDX_UINT8ARRAY_PROTOTYPE 54

#define	DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55

#define	DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56

#define	DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57

#define	DUK_BIDX_INT16ARRAY_PROTOTYPE 58

#define	DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59

#define	DUK_BIDX_UINT16ARRAY_PROTOTYPE 60

#define	DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61

#define	DUK_BIDX_INT32ARRAY_PROTOTYPE 62

#define	DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63

#define	DUK_BIDX_UINT32ARRAY_PROTOTYPE 64

#define	DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65

#define	DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66

#define	DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67

#define	DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68

#define	DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69

#define	DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70

#define	DUK_NUM_BUILTINS 71

#define	DUK_NUM_BIDX_BUILTINS 71

#define	DUK_NUM_ALL_BUILTINS 71

#define	DUK_UTIL_H_INCLUDED

#define	DUK_UTIL_MIN_HASH_PRIME 17 /* must match genhashsizes.py */

#define	DUK_UTIL_GET_HASH_PROBE_STEP(hash) (duk_util_probe_steps[(hash) & 0x1f])

#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_SPARE_ADD 64

#define	DUK_BW_SPARE_SHIFT 4 /* 2^4 -> 1/16 = 6.25% spare */

#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_ERRMSG_H_INCLUDED

#define	DUK_STR_INTERNAL_ERROR duk_str_internal_error

#define	DUK_STR_INVALID_COUNT duk_str_invalid_count

#define	DUK_STR_INVALID_CALL_ARGS duk_str_invalid_call_args

#define	DUK_STR_NOT_CONSTRUCTABLE duk_str_not_constructable

#define	DUK_STR_NOT_CALLABLE duk_str_not_callable

#define	DUK_STR_NOT_EXTENSIBLE duk_str_not_extensible

#define	DUK_STR_NOT_WRITABLE duk_str_not_writable

#define	DUK_STR_NOT_CONFIGURABLE duk_str_not_configurable

#define	DUK_STR_INVALID_CONTEXT duk_str_invalid_context

#define	DUK_STR_INVALID_INDEX duk_str_invalid_call_args

#define	DUK_STR_PUSH_BEYOND_ALLOC_STACK duk_str_push_beyond_alloc_stack

#define	DUK_STR_NOT_UNDEFINED duk_str_unexpected_type

#define	DUK_STR_NOT_NULL duk_str_unexpected_type

#define	DUK_STR_NOT_BOOLEAN duk_str_unexpected_type

#define	DUK_STR_NOT_NUMBER duk_str_unexpected_type

#define	DUK_STR_NOT_STRING duk_str_unexpected_type

#define	DUK_STR_NOT_OBJECT duk_str_unexpected_type

#define	DUK_STR_NOT_POINTER duk_str_unexpected_type

#define	DUK_STR_NOT_BUFFER duk_str_not_buffer /* still in use with verbose messages */

#define	DUK_STR_UNEXPECTED_TYPE duk_str_unexpected_type

#define	DUK_STR_NOT_THREAD duk_str_unexpected_type

#define	DUK_STR_NOT_COMPILEDFUNCTION duk_str_unexpected_type

#define	DUK_STR_NOT_NATIVEFUNCTION duk_str_unexpected_type

#define	DUK_STR_NOT_C_FUNCTION duk_str_unexpected_type

#define	DUK_STR_NOT_FUNCTION duk_str_unexpected_type

#define	DUK_STR_NOT_REGEXP duk_str_unexpected_type

#define	DUK_STR_DEFAULTVALUE_COERCE_FAILED duk_str_defaultvalue_coerce_failed

#define	DUK_STR_NUMBER_OUTSIDE_RANGE duk_str_number_outside_range

#define	DUK_STR_NOT_OBJECT_COERCIBLE duk_str_not_object_coercible

#define	DUK_STR_STRING_TOO_LONG duk_str_string_too_long

#define	DUK_STR_BUFFER_TOO_LONG duk_str_buffer_too_long

#define	DUK_STR_SPRINTF_TOO_LONG duk_str_sprintf_too_long

#define	DUK_STR_ALLOC_FAILED duk_str_alloc_failed

#define	DUK_STR_POP_TOO_MANY duk_str_pop_too_many

#define	DUK_STR_WRONG_BUFFER_TYPE duk_str_wrong_buffer_type

#define	DUK_STR_ENCODE_FAILED duk_str_encode_failed

#define	DUK_STR_DECODE_FAILED duk_str_decode_failed

#define	DUK_STR_NO_SOURCECODE duk_str_no_sourcecode

#define	DUK_STR_CONCAT_RESULT_TOO_LONG duk_str_concat_result_too_long

#define	DUK_STR_UNIMPLEMENTED duk_str_unimplemented

#define	DUK_STR_UNSUPPORTED duk_str_unsupported

#define	DUK_STR_ARRAY_LENGTH_OVER_2G duk_str_array_length_over_2g

#define	DUK_STR_FMT_PTR duk_str_fmt_ptr

#define	DUK_STR_FMT_INVALID_JSON duk_str_fmt_invalid_json

#define	DUK_STR_JSONDEC_RECLIMIT duk_str_jsondec_reclimit

#define	DUK_STR_JSONENC_RECLIMIT duk_str_jsonenc_reclimit

#define	DUK_STR_CYCLIC_INPUT duk_str_cyclic_input

#define	DUK_STR_PROXY_REVOKED duk_str_proxy_revoked

#define	DUK_STR_INVALID_BASE duk_str_invalid_base

#define	DUK_STR_STRICT_CALLER_READ duk_str_strict_caller_read

#define	DUK_STR_PROXY_REJECTED duk_str_proxy_rejected

#define	DUK_STR_INVALID_ARRAY_LENGTH duk_str_invalid_array_length

#define	DUK_STR_ARRAY_LENGTH_WRITE_FAILED duk_str_array_length_write_failed

#define	DUK_STR_ARRAY_LENGTH_NOT_WRITABLE duk_str_array_length_not_writable

#define	DUK_STR_SETTER_UNDEFINED duk_str_setter_undefined

#define	DUK_STR_REDEFINE_VIRT_PROP duk_str_redefine_virt_prop

#define	DUK_STR_INVALID_DESCRIPTOR duk_str_invalid_descriptor

#define	DUK_STR_PROPERTY_IS_VIRTUAL duk_str_property_is_virtual

#define	DUK_STR_PARSE_ERROR duk_str_parse_error

#define	DUK_STR_DUPLICATE_LABEL duk_str_duplicate_label

#define	DUK_STR_INVALID_LABEL duk_str_invalid_label

#define	DUK_STR_INVALID_ARRAY_LITERAL duk_str_invalid_array_literal

#define	DUK_STR_INVALID_OBJECT_LITERAL duk_str_invalid_object_literal

#define	DUK_STR_INVALID_VAR_DECLARATION duk_str_invalid_var_declaration

#define	DUK_STR_CANNOT_DELETE_IDENTIFIER duk_str_cannot_delete_identifier

#define	DUK_STR_INVALID_EXPRESSION duk_str_invalid_expression

#define	DUK_STR_INVALID_LVALUE duk_str_invalid_lvalue

#define	DUK_STR_EXPECTED_IDENTIFIER duk_str_expected_identifier

#define	DUK_STR_EMPTY_EXPR_NOT_ALLOWED duk_str_empty_expr_not_allowed

#define	DUK_STR_INVALID_FOR duk_str_invalid_for

#define	DUK_STR_INVALID_SWITCH duk_str_invalid_switch

#define	DUK_STR_INVALID_BREAK_CONT_LABEL duk_str_invalid_break_cont_label

#define	DUK_STR_INVALID_RETURN duk_str_invalid_return

#define	DUK_STR_INVALID_TRY duk_str_invalid_try

#define	DUK_STR_INVALID_THROW duk_str_invalid_throw

#define	DUK_STR_WITH_IN_STRICT_MODE duk_str_with_in_strict_mode

#define	DUK_STR_FUNC_STMT_NOT_ALLOWED duk_str_func_stmt_not_allowed

#define	DUK_STR_UNTERMINATED_STMT duk_str_unterminated_stmt

#define	DUK_STR_INVALID_ARG_NAME duk_str_invalid_arg_name

#define	DUK_STR_INVALID_FUNC_NAME duk_str_invalid_func_name

#define	DUK_STR_INVALID_GETSET_NAME duk_str_invalid_getset_name

#define	DUK_STR_FUNC_NAME_REQUIRED duk_str_func_name_required

#define	DUK_STR_INVALID_QUANTIFIER_NO_ATOM duk_str_invalid_quantifier_no_atom

#define	DUK_STR_INVALID_QUANTIFIER_VALUES duk_str_invalid_quantifier_values

#define	DUK_STR_QUANTIFIER_TOO_MANY_COPIES duk_str_quantifier_too_many_copies

#define	DUK_STR_UNEXPECTED_CLOSING_PAREN duk_str_unexpected_closing_paren

#define	DUK_STR_UNEXPECTED_END_OF_PATTERN duk_str_unexpected_end_of_pattern

#define	DUK_STR_UNEXPECTED_REGEXP_TOKEN duk_str_unexpected_regexp_token

#define	DUK_STR_INVALID_REGEXP_FLAGS duk_str_invalid_regexp_flags

#define	DUK_STR_INVALID_BACKREFS duk_str_invalid_backrefs

#define	DUK_STR_VALSTACK_LIMIT duk_str_valstack_limit

#define	DUK_STR_CALLSTACK_LIMIT duk_str_callstack_limit

#define	DUK_STR_CATCHSTACK_LIMIT duk_str_catchstack_limit

#define	DUK_STR_PROTOTYPE_CHAIN_LIMIT duk_str_prototype_chain_limit

#define	DUK_STR_BOUND_CHAIN_LIMIT duk_str_bound_chain_limit

#define	DUK_STR_C_CALLSTACK_LIMIT duk_str_c_callstack_limit

#define	DUK_STR_COMPILER_RECURSION_LIMIT duk_str_compiler_recursion_limit

#define	DUK_STR_BYTECODE_LIMIT duk_str_bytecode_limit

#define	DUK_STR_REG_LIMIT duk_str_reg_limit

#define	DUK_STR_TEMP_LIMIT duk_str_temp_limit

#define	DUK_STR_CONST_LIMIT duk_str_const_limit

#define	DUK_STR_FUNC_LIMIT duk_str_func_limit

#define	DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT duk_str_regexp_compiler_recursion_limit

#define	DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT duk_str_regexp_executor_recursion_limit

#define	DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT duk_str_regexp_executor_step_limit

#define	DUK_JS_BYTECODE_H_INCLUDED

#define	DUK_DEC_OP(x) ((x) & 0x3fUL)

#define	DUK_DEC_A(x) (((x) >> 6) & 0xffUL)

#define	DUK_DEC_B(x) (((x) >> 14) & 0x1ffUL)

#define	DUK_DEC_C(x) (((x) >> 23) & 0x1ffUL)

#define	DUK_DEC_BC(x) (((x) >> 14) & 0x3ffffUL)

#define	DUK_DEC_ABC(x) (((x) >> 6) & 0x3ffffffUL)

#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_BC_OP_MIN 0

#define	DUK_BC_OP_MAX 0x3fL

#define	DUK_BC_A_MIN 0

#define	DUK_BC_A_MAX 0xffL

#define	DUK_BC_B_MIN 0

#define	DUK_BC_B_MAX 0x1ffL

#define	DUK_BC_C_MIN 0

#define	DUK_BC_C_MAX 0x1ffL

#define	DUK_BC_BC_MIN 0

#define	DUK_BC_BC_MAX 0x3ffffL

#define	DUK_BC_ABC_MIN 0

#define	DUK_BC_ABC_MAX 0x3ffffffL

#define	DUK_BC_EXTRAOP_MIN DUK_BC_A_MIN

#define	DUK_BC_EXTRAOP_MAX DUK_BC_A_MAX

#define	DUK_OP_LDREG 0

#define	DUK_OP_STREG 1

#define	DUK_OP_LDCONST 2

#define	DUK_OP_LDINT 3

#define	DUK_OP_LDINTX 4

#define	DUK_OP_MPUTOBJ 5

#define	DUK_OP_MPUTOBJI 6

#define	DUK_OP_MPUTARR 7

#define	DUK_OP_MPUTARRI 8

#define	DUK_OP_NEW 9

#define	DUK_OP_NEWI 10

#define	DUK_OP_REGEXP 11

#define	DUK_OP_CSREG 12

#define	DUK_OP_CSREGI 13

#define	DUK_OP_GETVAR 14

#define	DUK_OP_PUTVAR 15

#define	DUK_OP_DECLVAR 16

#define	DUK_OP_DELVAR 17

#define	DUK_OP_CSVAR 18

#define	DUK_OP_CSVARI 19

#define	DUK_OP_CLOSURE 20

#define	DUK_OP_GETPROP 21

#define	DUK_OP_PUTPROP 22

#define	DUK_OP_DELPROP 23

#define	DUK_OP_CSPROP 24

#define	DUK_OP_CSPROPI 25

#define	DUK_OP_ADD 26

#define	DUK_OP_SUB 27

#define	DUK_OP_MUL 28

#define	DUK_OP_DIV 29

#define	DUK_OP_MOD 30

#define	DUK_OP_BAND 31

#define	DUK_OP_BOR 32

#define	DUK_OP_BXOR 33

#define	DUK_OP_BASL 34

#define	DUK_OP_BLSR 35

#define	DUK_OP_BASR 36

#define	DUK_OP_EQ 37

#define	DUK_OP_NEQ 38

#define	DUK_OP_SEQ 39

#define	DUK_OP_SNEQ 40

#define	DUK_OP_GT 41

#define	DUK_OP_GE 42

#define	DUK_OP_LT 43

#define	DUK_OP_LE 44

#define	DUK_OP_IF 45

#define	DUK_OP_JUMP 46

#define	DUK_OP_RETURN 47

#define	DUK_OP_CALL 48

#define	DUK_OP_CALLI 49

#define	DUK_OP_TRYCATCH 50

#define	DUK_OP_EXTRA 51

#define	DUK_OP_PREINCR 52 /* pre/post opcode values have constraints, */

#define	DUK_OP_PREDECR 53 /* see duk_js_executor.c */

#define	DUK_OP_POSTINCR 54

#define	DUK_OP_POSTDECR 55

#define	DUK_OP_PREINCV 56

#define	DUK_OP_PREDECV 57

#define	DUK_OP_POSTINCV 58

#define	DUK_OP_POSTDECV 59

#define	DUK_OP_PREINCP 60

#define	DUK_OP_PREDECP 61

#define	DUK_OP_POSTINCP 62

#define	DUK_OP_POSTDECP 63

#define	DUK_OP_NONE 64 /* dummy value used as marker */

#define	DUK_EXTRAOP_NOP 0

#define	DUK_EXTRAOP_INVALID 1

#define	DUK_EXTRAOP_LDTHIS 2

#define	DUK_EXTRAOP_LDUNDEF 3

#define	DUK_EXTRAOP_LDNULL 4

#define	DUK_EXTRAOP_LDTRUE 5

#define	DUK_EXTRAOP_LDFALSE 6

#define	DUK_EXTRAOP_NEWOBJ 7

#define	DUK_EXTRAOP_NEWARR 8

#define	DUK_EXTRAOP_SETALEN 9

#define	DUK_EXTRAOP_TYPEOF 10

#define	DUK_EXTRAOP_TYPEOFID 11

#define	DUK_EXTRAOP_INITENUM 12

#define	DUK_EXTRAOP_NEXTENUM 13

#define	DUK_EXTRAOP_INITSET 14

#define	DUK_EXTRAOP_INITSETI 15

#define	DUK_EXTRAOP_INITGET 16

#define	DUK_EXTRAOP_INITGETI 17

#define	DUK_EXTRAOP_ENDTRY 18

#define	DUK_EXTRAOP_ENDCATCH 19

#define	DUK_EXTRAOP_ENDFIN 20

#define	DUK_EXTRAOP_THROW 21

#define	DUK_EXTRAOP_INVLHS 22

#define	DUK_EXTRAOP_UNM 23

#define	DUK_EXTRAOP_UNP 24

#define	DUK_EXTRAOP_DEBUGGER 25

#define	DUK_EXTRAOP_BREAK 26

#define	DUK_EXTRAOP_CONTINUE 27

#define	DUK_EXTRAOP_BNOT 28

#define	DUK_EXTRAOP_LNOT 29

#define	DUK_EXTRAOP_INSTOF 30

#define	DUK_EXTRAOP_IN 31

#define	DUK_EXTRAOP_LABEL 32

#define	DUK_EXTRAOP_ENDLABEL 33

#define	DUK_BC_CALL_FLAG_TAILCALL (1 << 0)

#define	DUK_BC_CALL_FLAG_EVALCALL (1 << 1)

#define	DUK_BC_TRYCATCH_FLAG_HAVE_CATCH (1 << 0)

#define	DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY (1 << 1)

#define	DUK_BC_TRYCATCH_FLAG_CATCH_BINDING (1 << 2)

#define	DUK_BC_TRYCATCH_FLAG_WITH_BINDING (1 << 3)

#define	DUK_BC_RETURN_FLAG_HAVE_RETVAL (1 << 0)

#define	DUK_BC_DECLVAR_FLAG_UNDEF_VALUE (1 << 4) /* use 'undefined' for value automatically */

#define	DUK_BC_DECLVAR_FLAG_FUNC_DECL (1 << 5) /* function declaration */

#define	DUK_BC_REGLIMIT 256 /* if B/C is >= this value, refers to a const */

#define	DUK_BC_ISREG(x) ((x) < DUK_BC_REGLIMIT)

#define	DUK_BC_ISCONST(x) ((x) >= DUK_BC_REGLIMIT)

#define	DUK_BC_LDINT_BIAS (1L << 17)

#define	DUK_BC_LDINTX_SHIFT 18

#define	DUK_BC_JUMP_BIAS (1L << 25)

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

#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_INCREMENT 71

#define	DUK_TOK_DECREMENT 72

#define	DUK_TOK_ALSHIFT 73 /* named "arithmetic" because result is signed */

#define	DUK_TOK_ARSHIFT 74

#define	DUK_TOK_RSHIFT 75

#define	DUK_TOK_BAND 76

#define	DUK_TOK_BOR 77

#define	DUK_TOK_BXOR 78

#define	DUK_TOK_LNOT 79

#define	DUK_TOK_BNOT 80

#define	DUK_TOK_LAND 81

#define	DUK_TOK_LOR 82

#define	DUK_TOK_QUESTION 83

#define	DUK_TOK_COLON 84

#define	DUK_TOK_EQUALSIGN 85

#define	DUK_TOK_ADD_EQ 86

#define	DUK_TOK_SUB_EQ 87

#define	DUK_TOK_MUL_EQ 88

#define	DUK_TOK_DIV_EQ 89

#define	DUK_TOK_MOD_EQ 90

#define	DUK_TOK_ALSHIFT_EQ 91

#define	DUK_TOK_ARSHIFT_EQ 92

#define	DUK_TOK_RSHIFT_EQ 93

#define	DUK_TOK_BAND_EQ 94

#define	DUK_TOK_BOR_EQ 95

#define	DUK_TOK_BXOR_EQ 96

#define	DUK_TOK_NUMBER 97

#define	DUK_TOK_STRING 98

#define	DUK_TOK_REGEXP 99

#define	DUK_TOK_MAXVAL 99 /* inclusive */

#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

#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_ARITH_EXTRAOP 3 /* binary arithmetic using extraops; DUK_EXTRAOP_INSTOF etc */

#define	DUK_IVAL_PROP 4 /* property access */

#define	DUK_IVAL_VAR 5 /* 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_JS_CONST_MARKER 0x80000000UL

#define	DUK_LABEL_FLAG_ALLOW_BREAK (1 << 0)

#define	DUK_LABEL_FLAG_ALLOW_CONTINUE (1 << 1)

#define	DUK_DECL_TYPE_VAR 0

#define	DUK_DECL_TYPE_FUNC 1

#define	DUK_JS_COMPILE_FLAG_EVAL (1 << 0) /* source is eval code (not global) */

#define	DUK_JS_COMPILE_FLAG_STRICT (1 << 1) /* strict outer context */

#define	DUK_JS_COMPILE_FLAG_FUNCEXPR (1 << 2) /* source is a function expression (used for Function constructor) */

#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 (1 << 0)

#define	DUK_RE_FLAG_IGNORE_CASE (1 << 1)

#define	DUK_RE_FLAG_MULTILINE (1 << 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 1

#define	DUK_HTYPE_STRING 1

#define	DUK_HTYPE_OBJECT 2

#define	DUK_HTYPE_BUFFER 3

#define	DUK_HTYPE_MAX 3

#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_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) /* currently nop */

#define	DUK_ASSERT_HEAPHDR_LINKS(heap, h) do {} while (0)

#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_HEAPHDR_INCREF_FAST(thr, h)

#define	DUK_HEAPHDR_DECREF_FAST(thr, h)

#define	DUK_TVAL_INCREF_SLOW(thr, tv)

#define	DUK_TVAL_DECREF_SLOW(thr, tv)

#define	DUK_HEAPHDR_INCREF_SLOW(thr, h)

#define	DUK_HEAPHDR_DECREF_SLOW(thr, h)

#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_HEAPHDR_INCREF(thr, h) DUK_HEAPHDR_INCREF_FAST((thr),(h))

#define	DUK_HEAPHDR_DECREF(thr, h) DUK_HEAPHDR_DECREF_FAST((thr),(h))

#define	DUK_HSTRING_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))

#define	DUK_HSTRING_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))

#define	DUK_HOBJECT_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))

#define	DUK_HOBJECT_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))

#define	DUK_HBUFFER_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))

#define	DUK_HBUFFER_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))

#define	DUK_HCOMPILEDFUNCTION_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HCOMPILEDFUNCTION_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HNATIVEFUNCTION_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HNATIVEFUNCTION_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HBUFFEROBJECT_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HBUFFEROBJECT_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HTHREAD_INCREF(thr, h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HTHREAD_DECREF(thr, h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

#define	DUK_HOBJECT_INCREF_ALLOWNULL(thr, h)

#define	DUK_HOBJECT_DECREF_ALLOWNULL(thr, h)

#define	DUK_TVAL_SET_UNDEFINED_UPDREF_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_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_FASTINT_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast int-to-double */

#define	DUK_TVAL_SET_FASTINT_I32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF

#define	DUK_TVAL_SET_FASTINT_U32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF

#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_API_INTERNAL_H_INCLUDED

#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_VSRESIZE_FLAG_SHRINK (1 << 0)

#define	DUK_VSRESIZE_FLAG_COMPACT (1 << 1)

#define	DUK_VSRESIZE_FLAG_THROW (1 << 2)

#define	duk_push_u64(ctx, val) duk_push_number((ctx), (duk_double_t) (val))

#define	duk_push_i64(ctx, val) duk_push_number((ctx), (duk_double_t) (val))

#define	duk_push_u32(ctx, val) duk_push_uint((ctx), (duk_uint_t) (val))

#define	duk_push_i32(ctx, val) duk_push_int((ctx), (duk_int_t) (val))

#define	duk_push_idx(ctx, val) duk_push_int((ctx), (duk_int_t) (val))

#define	duk_push_uarridx(ctx, val) duk_push_uint((ctx), (duk_uint_t) (val))

#define	duk_push_size_t(ctx, val) duk_push_uint((ctx), (duk_uint_t) (val)) /* XXX: assumed to fit for now */

#define	duk_push_hthread(ctx, h) duk_push_hobject((ctx), (duk_hobject *) (h))

#define	duk_push_hcompiledfunction(ctx, h) duk_push_hobject((ctx), (duk_hobject *) (h))

#define	duk_push_hnativefunction(ctx, h) duk_push_hobject((ctx), (duk_hobject *) (h))

#define	duk_xdef_prop_wec(ctx, obj_index) duk_xdef_prop((ctx), (obj_index), DUK_PROPDESC_FLAGS_WEC)

#define	duk_xdef_prop_index_wec(ctx, obj_index, arr_index) duk_xdef_prop_index((ctx), (obj_index), (arr_index), DUK_PROPDESC_FLAGS_WEC)

#define	duk_xdef_prop_stridx_wec(ctx, obj_index, stridx) duk_xdef_prop_stridx((ctx), (obj_index), (stridx), DUK_PROPDESC_FLAGS_WEC)

#define	DUK_ASSERT_VALID_NEGIDX(ctx, idx) (DUK_ASSERT_EXPR((idx) < 0), DUK_ASSERT_EXPR(duk_is_valid_index((ctx), (idx))))

#define	DUK_ASSERT_VALID_POSIDX(ctx, idx) (DUK_ASSERT_EXPR((idx) >= 0), DUK_ASSERT_EXPR(duk_is_valid_index((ctx), (idx))))

#define	DUK_GET_TVAL_NEGIDX(ctx, idx) (DUK_ASSERT_VALID_NEGIDX((ctx),(idx)), ((duk_hthread *) (ctx))->valstack_top + (idx))

#define	DUK_GET_TVAL_POSIDX(ctx, idx) (DUK_ASSERT_VALID_POSIDX((ctx),(idx)), ((duk_hthread *) (ctx))->valstack_bottom + (idx))

#define	DUK_GET_HOBJECT_NEGIDX(ctx, idx) (DUK_ASSERT_VALID_NEGIDX((ctx),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (ctx))->valstack_top + (idx)))

#define	DUK_GET_HOBJECT_POSIDX(ctx, idx) (DUK_ASSERT_VALID_POSIDX((ctx),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (ctx))->valstack_bottom + (idx)))

#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_INTERNAL DUK_HEAPHDR_USER_FLAG(2) /* string is internal */

#define	DUK_HSTRING_FLAG_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(3) /* string is a reserved word (non-strict) */

#define	DUK_HSTRING_FLAG_STRICT_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(4) /* string is a reserved word (strict) */

#define	DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS DUK_HEAPHDR_USER_FLAG(5) /* string is 'eval' or 'arguments' */

#define	DUK_HSTRING_FLAG_EXTDATA DUK_HEAPHDR_USER_FLAG(6) /* string data is external (duk_hstring_external) */

#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_INTERNAL(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

#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_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_INTERNAL(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

#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_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_INTERNAL(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

#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_IS_ASCII(x) DUK_HSTRING_HAS_ASCII((x))

#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) ((x)->clen)

#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) (DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX)

#define	DUK_HSTRING_GET_ARRIDX_SLOW(h) (duk_js_to_arrayindex_string_helper((h)))

#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_BOUND DUK_HEAPHDR_USER_FLAG(2) /* object established using Function.prototype.bind() */

#define	DUK_HOBJECT_FLAG_COMPILEDFUNCTION DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompiledfunction) */

#define	DUK_HOBJECT_FLAG_NATIVEFUNCTION DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnativefunction) */

#define	DUK_HOBJECT_FLAG_BUFFEROBJECT DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufferobject) (always exotic) */

#define	DUK_HOBJECT_FLAG_THREAD DUK_HEAPHDR_USER_FLAG(7) /* object is a thread (duk_hthread) */

#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_hcompiledfunction) */

#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_ENVRECCLOSED DUK_HEAPHDR_USER_FLAG(14) /* envrec: (declarative) record is closed */

#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_DUKFUNC DUK_HEAPHDR_USER_FLAG(18) /* Duktape/C (nativefunction) object, exotic 'length' */

#define	DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ DUK_HEAPHDR_USER_FLAG(19) /* 'Proxy' object */

#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_UNUSED 0

#define	DUK_HOBJECT_CLASS_ARGUMENTS 1

#define	DUK_HOBJECT_CLASS_ARRAY 2

#define	DUK_HOBJECT_CLASS_BOOLEAN 3

#define	DUK_HOBJECT_CLASS_DATE 4

#define	DUK_HOBJECT_CLASS_ERROR 5

#define	DUK_HOBJECT_CLASS_FUNCTION 6

#define	DUK_HOBJECT_CLASS_JSON 7

#define	DUK_HOBJECT_CLASS_MATH 8

#define	DUK_HOBJECT_CLASS_NUMBER 9

#define	DUK_HOBJECT_CLASS_OBJECT 10

#define	DUK_HOBJECT_CLASS_REGEXP 11

#define	DUK_HOBJECT_CLASS_STRING 12

#define	DUK_HOBJECT_CLASS_GLOBAL 13

#define	DUK_HOBJECT_CLASS_OBJENV 14 /* custom */

#define	DUK_HOBJECT_CLASS_DECENV 15 /* custom */

#define	DUK_HOBJECT_CLASS_BUFFER 16 /* custom; implies DUK_HOBJECT_IS_BUFFEROBJECT */

#define	DUK_HOBJECT_CLASS_POINTER 17 /* custom */

#define	DUK_HOBJECT_CLASS_THREAD 18 /* custom; implies DUK_HOBJECT_IS_THREAD */

#define	DUK_HOBJECT_CLASS_ARRAYBUFFER 19 /* implies DUK_HOBJECT_IS_BUFFEROBJECT */

#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_MAX 29

#define	DUK_HOBJECT_CMASK_ALL ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL)

#define	DUK_HOBJECT_CMASK_UNUSED (1UL << DUK_HOBJECT_CLASS_UNUSED)

#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_OBJENV (1UL << DUK_HOBJECT_CLASS_OBJENV)

#define	DUK_HOBJECT_CMASK_DECENV (1UL << DUK_HOBJECT_CLASS_DECENV)

#define	DUK_HOBJECT_CMASK_BUFFER (1UL << DUK_HOBJECT_CLASS_BUFFER)

#define	DUK_HOBJECT_CMASK_POINTER (1UL << DUK_HOBJECT_CLASS_POINTER)

#define	DUK_HOBJECT_CMASK_THREAD (1UL << DUK_HOBJECT_CLASS_THREAD)

#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_BUFFEROBJECTS

#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_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAY)

#define	DUK_HOBJECT_IS_COMPILEDFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

#define	DUK_HOBJECT_IS_NATIVEFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

#define	DUK_HOBJECT_IS_BUFFEROBJECT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

#define	DUK_HOBJECT_IS_THREAD(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

#define	DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)

#define	DUK_HOBJECT_IS_FUNCTION(h)

#define	DUK_HOBJECT_IS_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_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_BOUND(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

#define	DUK_HOBJECT_HAS_COMPILEDFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

#define	DUK_HOBJECT_HAS_NATIVEFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

#define	DUK_HOBJECT_HAS_BUFFEROBJECT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

#define	DUK_HOBJECT_HAS_THREAD(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

#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_ENVRECCLOSED(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)

#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_DUKFUNC(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)

#define	DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

#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_BOUND(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

#define	DUK_HOBJECT_SET_COMPILEDFUNCTION(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

#define	DUK_HOBJECT_SET_NATIVEFUNCTION(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

#define	DUK_HOBJECT_SET_BUFFEROBJECT(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

#define	DUK_HOBJECT_SET_THREAD(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

#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_ENVRECCLOSED(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)

#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_DUKFUNC(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)

#define	DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

#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_BOUND(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

#define	DUK_HOBJECT_CLEAR_COMPILEDFUNCTION(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

#define	DUK_HOBJECT_CLEAR_NATIVEFUNCTION(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

#define	DUK_HOBJECT_CLEAR_BUFFEROBJECT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

#define	DUK_HOBJECT_CLEAR_THREAD(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

#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_ENVRECCLOSED(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)

#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_DUKFUNC(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)

#define	DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

#define	DUK_PROPDESC_FLAG_WRITABLE (1 << 0) /* E5 Section 8.6.1 */

#define	DUK_PROPDESC_FLAG_ENUMERABLE (1 << 1) /* E5 Section 8.6.1 */

#define	DUK_PROPDESC_FLAG_CONFIGURABLE (1 << 2) /* E5 Section 8.6.1 */

#define	DUK_PROPDESC_FLAG_ACCESSOR (1 << 3) /* accessor */

#define	DUK_PROPDESC_FLAG_VIRTUAL

#define	DUK_PROPDESC_FLAGS_MASK

#define	DUK_PROPDESC_FLAG_NO_OVERWRITE (1 << 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 (1 << 0) /* push value to stack */

#define	DUK_GETDESC_FLAG_IGNORE_PROTOLOOP (1 << 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_BOUND_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_MAX_PROPERTIES 0x7fffffffUL /* 2*31-1 ~= 2G properties /

#define	DUK_HOBJECT_E_USE_HASH_LIMIT 32

#define	DUK_HOBJECT_H_SIZE_DIVISOR 4 /* hash size approx. 1.25 times entries size */

#define	DUK_HOBJECT_A_FAST_RESIZE_LIMIT 9 /* 112.5%, i.e. new size less than 12.5% higher -> fast resize */

#define	DUK_HOBJECT_A_ABANDON_LIMIT 2 /* 25%, i.e. less than 25% used -> abandon */

#define	DUK_HOBJECT_ALIGN_TARGET 8

#define	DUK_HOBJECT_E_MIN_GROW_ADD 16

#define	DUK_HOBJECT_E_MIN_GROW_DIVISOR 8 /* 2^3 -> 1/8 = 12.5% min growth */

#define	DUK_HOBJECT_A_MIN_GROW_ADD 16

#define	DUK_HOBJECT_A_MIN_GROW_DIVISOR 8 /* 2^3 -> 1/8 = 12.5% min growth */

#define	DUK_HOBJECT_HASH_INITIAL(hash, h_size) ((hash) % (h_size))

#define	DUK_HOBJECT_HASH_PROBE_STEP(hash) DUK_UTIL_GET_HASH_PROBE_STEP((hash))

#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 (1 << 0)

#define	DUK_DELPROP_FLAG_FORCE (1 << 1)

#define	DUK_HCOMPILEDFUNCTION_H_INCLUDED

#define	DUK_HCOMPILEDFUNCTION_GET_DATA(heap, h) ((duk_hbuffer_fixed ) (void ) (h)->data)

#define	DUK_HCOMPILEDFUNCTION_SET_DATA(heap, h, v)

#define	DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap, h) ((h)->funcs)

#define	DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap, h, v)

#define	DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap, h) ((h)->bytecode)

#define	DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap, h, v)

#define	DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE(heap, h) DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h)))

#define	DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, h) ((duk_tval ) (void ) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h)))

#define	DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, h) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))

#define	DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap, h) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))

#define	DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, h) ((duk_tval ) (void ) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)))

#define	DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, h) ((duk_hobject *) (void ) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h)))

#define	DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap, h)

#define	DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap, h)

#define	DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(heap, h)

#define	DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap, h)

#define	DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap, h) ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))

#define	DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap, h) ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))

#define	DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(heap, h) ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t)))

#define	DUK_HNATIVEFUNCTION_H_INCLUDED

#define	DUK_HNATIVEFUNCTION_NARGS_VARARGS ((duk_int16_t) -1)

#define	DUK_HNATIVEFUNCTION_NARGS_MAX ((duk_int16_t) 0x7fff)

#define	DUK_HBUFFEROBJECT_H_INCLUDED

#define	DUK_HBUFFEROBJECT_ELEM_UINT8 0

#define	DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED 1

#define	DUK_HBUFFEROBJECT_ELEM_INT8 2

#define	DUK_HBUFFEROBJECT_ELEM_UINT16 3

#define	DUK_HBUFFEROBJECT_ELEM_INT16 4

#define	DUK_HBUFFEROBJECT_ELEM_UINT32 5

#define	DUK_HBUFFEROBJECT_ELEM_INT32 6

#define	DUK_HBUFFEROBJECT_ELEM_FLOAT32 7

#define	DUK_HBUFFEROBJECT_ELEM_FLOAT64 8

#define	DUK_HBUFFEROBJECT_ELEM_MAX 8

#define	DUK_ASSERT_HBUFFEROBJECT_VALID(h)

#define	DUK_HBUFFEROBJECT_GET_SLICE_BASE(heap, h)

#define	DUK_HBUFFEROBJECT_FULL_SLICE(h)

#define	DUK_HBUFFEROBJECT_VALID_SLICE(h)

#define	DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h, off)

#define	DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h, off)

#define	DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h, len)

#define	DUK_HTHREAD_H_INCLUDED

#define	DUK_VALSTACK_GROW_STEP 128 /* roughly 1 kiB */

#define	DUK_VALSTACK_SHRINK_THRESHOLD 256 /* roughly 2 kiB */

#define	DUK_VALSTACK_SHRINK_SPARE 64 /* roughly 0.5 kiB */

#define	DUK_VALSTACK_INITIAL_SIZE 128 /* roughly 1.0 kiB -> but rounds up to DUK_VALSTACK_GROW_STEP in practice */

#define	DUK_VALSTACK_INTERNAL_EXTRA

#define	DUK_VALSTACK_API_ENTRY_MINIMUM DUK_API_ENTRY_STACK

#define	DUK_VALSTACK_DEFAULT_MAX 1000000L

#define	DUK_CALLSTACK_GROW_STEP 8 /* roughly 256 bytes */

#define	DUK_CALLSTACK_SHRINK_THRESHOLD 16 /* roughly 512 bytes */

#define	DUK_CALLSTACK_SHRINK_SPARE 8 /* roughly 256 bytes */

#define	DUK_CALLSTACK_INITIAL_SIZE 8

#define	DUK_CALLSTACK_DEFAULT_MAX 10000L

#define	DUK_CATCHSTACK_GROW_STEP 4 /* roughly 64 bytes */

#define	DUK_CATCHSTACK_SHRINK_THRESHOLD 8 /* roughly 128 bytes */

#define	DUK_CATCHSTACK_SHRINK_SPARE 4 /* roughly 64 bytes */

#define	DUK_CATCHSTACK_INITIAL_SIZE 4

#define	DUK_CATCHSTACK_DEFAULT_MAX 10000L

#define	DUK_ACT_FLAG_STRICT (1 << 0) /* function executes in strict mode */

#define	DUK_ACT_FLAG_TAILCALLED (1 << 1) /* activation has tail called one or more times */

#define	DUK_ACT_FLAG_CONSTRUCT (1 << 2) /* function executes as a constructor (called via "new") */

#define	DUK_ACT_FLAG_PREVENT_YIELD (1 << 3) /* activation prevents yield (native call or "new") */

#define	DUK_ACT_FLAG_DIRECT_EVAL (1 << 4) /* activation is a direct eval call */

#define	DUK_ACT_FLAG_BREAKPOINT_ACTIVE (1 << 5) /* activation has active breakpoint(s) */

#define	DUK_ACT_GET_FUNC(act) ((act)->func)

#define	DUK_TB_FLAG_NOBLAME_FILELINE (1 << 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 (1 << 4) /* catch part will catch */

#define	DUK_CAT_FLAG_FINALLY_ENABLED (1 << 5) /* finally part will catch */

#define	DUK_CAT_FLAG_CATCH_BINDING_ENABLED (1 << 6) /* request to create catch binding */

#define	DUK_CAT_FLAG_LEXENV_ACTIVE (1 << 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_GET_CURRENT_ACTIVATION(thr) (&(thr)->callstack[(thr)->callstack_top - 1])

#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_CTX_VSSIZE(ctx)

#define	DUK_ASSERT_CTX_VALID(ctx)

#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 ) (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_HEAP_H_INCLUDED

#define	DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING (1 << 0) /* mark-and-sweep is currently running */

#define	DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED (1 << 1) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */

#define	DUK_HEAP_FLAG_REFZERO_FREE_RUNNING (1 << 2) /* refcount code is processing refzero list */

#define	DUK_HEAP_FLAG_ERRHANDLER_RUNNING (1 << 3) /* an error handler (user callback to augment/replace error) is running */

#define	DUK_HEAP_FLAG_INTERRUPT_RUNNING (1 << 4) /* executor interrupt running (used to avoid nested interrupts) */

#define	DUK_HEAP_FLAG_FINALIZER_NORESCUE (1 << 5) /* heap destruction ongoing, finalizer rescue no longer possible */

#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_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)

#define	DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)

#define	DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)

#define	DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)

#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_SET_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)

#define	DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)

#define	DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)

#define	DUK_HEAP_SET_ERRHANDLER_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)

#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_CLEAR_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)

#define	DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)

#define	DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)

#define	DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)

#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_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 (1 << 0) /* emergency mode: try extra hard */

#define	DUK_MS_FLAG_NO_STRINGTABLE_RESIZE (1 << 1) /* don't resize stringtable (but may sweep it); needed during stringtable resize */

#define	DUK_MS_FLAG_NO_OBJECT_COMPACTION (1 << 2) /* don't compact objects; needed during object property allocation resize */

#define	DUK_MS_FLAG_NO_FINALIZERS (1 << 3) /* don't run finalizers; leave finalizable objects in finalize_list for next round */

#define	DUK_MS_FLAG_SKIP_FINALIZERS (1 << 4) /* don't run finalizers; queue finalizable objects back to heap_allocated */

#define	DUK_HEAP_SWITCH_THREAD(heap, newthr)

#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_HEAP_STRCACHE_SIZE 4

#define	DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT 16 /* strings up to the this length are not cached */

#define	DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, hdr) duk_heap_insert_into_heap_allocated((heap),(hdr))

#define	DUK_STRTAB_INITIAL_SIZE 17

#define	DUK_STRTAB_DELETED_MARKER(heap) ((duk_hstring *) heap)

#define	DUK_STRTAB_MIN_FREE_DIVISOR 4 /* load factor max 75% */

#define	DUK_STRTAB_MIN_USED_DIVISOR 4 /* load factor min 25% */

#define	DUK_STRTAB_GROW_ST_SIZE(n) ((n) + (n)) /* used entries + approx 100% -> reset load to 50% */

#define	DUK_STRTAB_U32_MAX_STRLEN 10 /* 4'294'967'295 */

#define	DUK_STRTAB_HIGHEST_32BIT_PRIME 0xfffffffbUL

#define	DUK_STRTAB_HASH_INITIAL(hash, h_size) ((hash) % (h_size))

#define	DUK_STRTAB_HASH_PROBE_STEP(hash) DUK_UTIL_GET_HASH_PROBE_STEP((hash))

#define	DUK_STRTAB_CHAIN_SIZE DUK_USE_STRTAB_CHAIN_SIZE

#define	DUK_HEAP_GET_STRING(heap, idx) ((heap)->strs[(idx)])

#define	DUK_ALLOC_RAW(heap, size) ((heap)->alloc_func((heap)->heap_udata, (size)))

#define	DUK_REALLOC_RAW(heap, ptr, newsize) ((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize)))

#define	DUK_FREE_RAW(heap, ptr) ((heap)->free_func((heap)->heap_udata, (void *) (ptr)))

#define	DUK_ALLOC(heap, size) duk_heap_mem_alloc((heap), (size))

#define	DUK_ALLOC_ZEROED(heap, size) duk_heap_mem_alloc_zeroed((heap), (size))

#define	DUK_REALLOC(heap, ptr, newsize) duk_heap_mem_realloc((heap), (ptr), (newsize))

#define	DUK_REALLOC_INDIRECT(heap, cb, ud, newsize) duk_heap_mem_realloc_indirect((heap), (cb), (ud), (newsize))

#define	DUK_FREE(heap, ptr) duk_heap_mem_free((heap), (ptr))

#define	DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT

#define	DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT

#define	DUK_HEAP_MAX_BREAKPOINTS 16

#define	DUK_HEAP_DBG_RATELIMIT_OPCODES 4000

#define	DUK_HEAP_DBG_RATELIMIT_MILLISECS 200

#define	DUK_STEP_TYPE_NONE 0

#define	DUK_STEP_TYPE_INTO 1

#define	DUK_STEP_TYPE_OVER 2

#define	DUK_STEP_TYPE_OUT 3

#define	DUK_DEBUGGER_H_INCLUDED

#define	DUK_DBG_IB_EOM 0x00

#define	DUK_DBG_IB_REQUEST 0x01

#define	DUK_DBG_IB_REPLY 0x02

#define	DUK_DBG_IB_ERROR 0x03

#define	DUK_DBG_IB_NOTIFY 0x04

#define	DUK_DBG_IB_INT4 0x10

#define	DUK_DBG_IB_STR4 0x11

#define	DUK_DBG_IB_STR2 0x12

#define	DUK_DBG_IB_BUF4 0x13

#define	DUK_DBG_IB_BUF2 0x14

#define	DUK_DBG_IB_UNUSED 0x15

#define	DUK_DBG_IB_UNDEFINED 0x16

#define	DUK_DBG_IB_NULL 0x17

#define	DUK_DBG_IB_TRUE 0x18

#define	DUK_DBG_IB_FALSE 0x19

#define	DUK_DBG_IB_NUMBER 0x1a

#define	DUK_DBG_IB_OBJECT 0x1b

#define	DUK_DBG_IB_POINTER 0x1c

#define	DUK_DBG_IB_LIGHTFUNC 0x1d

#define	DUK_DBG_IB_HEAPPTR 0x1e

#define	DUK_DBG_ERR_UNKNOWN 0x00

#define	DUK_DBG_ERR_UNSUPPORTED 0x01

#define	DUK_DBG_ERR_TOOMANY 0x02

#define	DUK_DBG_ERR_NOTFOUND 0x03

#define	DUK_DBG_ERR_APPLICATION 0x04

#define	DUK_DBG_CMD_STATUS 0x01

#define	DUK_DBG_CMD_PRINT 0x02

#define	DUK_DBG_CMD_ALERT 0x03

#define	DUK_DBG_CMD_LOG 0x04

#define	DUK_DBG_CMD_THROW 0x05

#define	DUK_DBG_CMD_DETACHING 0x06

#define	DUK_DBG_CMD_APPNOTIFY 0x07

#define	DUK_DBG_CMD_BASICINFO 0x10

#define	DUK_DBG_CMD_TRIGGERSTATUS 0x11

#define	DUK_DBG_CMD_PAUSE 0x12

#define	DUK_DBG_CMD_RESUME 0x13

#define	DUK_DBG_CMD_STEPINTO 0x14

#define	DUK_DBG_CMD_STEPOVER 0x15

#define	DUK_DBG_CMD_STEPOUT 0x16

#define	DUK_DBG_CMD_LISTBREAK 0x17

#define	DUK_DBG_CMD_ADDBREAK 0x18

#define	DUK_DBG_CMD_DELBREAK 0x19

#define	DUK_DBG_CMD_GETVAR 0x1a

#define	DUK_DBG_CMD_PUTVAR 0x1b

#define	DUK_DBG_CMD_GETCALLSTACK 0x1c

#define	DUK_DBG_CMD_GETLOCALS 0x1d

#define	DUK_DBG_CMD_EVAL 0x1e

#define	DUK_DBG_CMD_DETACH 0x1f

#define	DUK_DBG_CMD_DUMPHEAP 0x20

#define	DUK_DBG_CMD_GETBYTECODE 0x21

#define	DUK_DBG_CMD_APPREQUEST 0x22

#define	DUK_DBG_CMD_GETHEAPOBJINFO 0x23

#define	DUK_DBG_CMD_GETOBJPROPDESC 0x24

#define	DUK_DBG_CMD_GETOBJPROPDESCRANGE 0x25

#define	DUK_DBG_PROPFLAG_INTERNAL (1 << 8)

#define	DUK_DEBUG_H_INCLUDED

#define	DUK_D(x) do { } while (0) /* omit */

#define	DUK_DD(x) do { } while (0) /* omit */

#define	DUK_DDD(x) do { } while (0) /* omit */

#define	DUK_DPRINT 0 && /* args go here as a comma expression in parens */

#define	DUK_DDPRINT 0 && /* args */

#define	DUK_DDDPRINT 0 && /* args */

#define	DUK_ERROR_H_INCLUDED

#define	DUK_ERROR(thr, err, msg)

#define	DUK_ERROR_RAW(thr, file, line, err, msg)

#define	DUK_ERROR_FMT1(thr, err, fmt, arg1)

#define	DUK_ERROR_RAW_FMT1(thr, file, line, err, fmt, arg1)

#define	DUK_ERROR_FMT2(thr, err, fmt, arg1, arg2)

#define	DUK_ERROR_RAW_FMT2(thr, file, line, err, fmt, arg1, arg2)

#define	DUK_ERROR_FMT3(thr, err, fmt, arg1, arg2, arg3)

#define	DUK_ERROR_RAW_FMT3(thr, file, line, err, fmt, arg1, arg2, arg3)

#define	DUK_ERROR_FMT4(thr, err, fmt, arg1, arg2, arg3, arg4)

#define	DUK_ERROR_RAW_FMT4(thr, file, line, err, fmt, arg1, arg2, arg3, arg4)

#define	DUK_PANIC(code, msg) duk_default_panic_handler((code),(msg))

#define	DUK_ASSERT(x) do { /* assertion omitted */ } while (0)

#define	DUK_ASSERT_EXPR(x) ((void) 0)

#define	DUK_ASSERT_DISABLE(x) do { /* assertion disabled */ } while (0)

#define	DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) /* no refcount check */

#define	DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) /* no refcount check */

#define	DUK_ASSERT_TOP(ctx, n) DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n))

#define	DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) /* nop */

#define	DUK_VALSTACK_ASSERT_EXTRA

#define	DUK_ASSERT_VALSTACK_SPACE(thr, n) /* no valstack space check */

#define	DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, expectname, lowmemstr)

#define	DUK_ERROR_UNIMPLEMENTED(thr, msg)

#define	DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr)

#define	DUK_ERROR_UNSUPPORTED(thr, msg)

#define	DUK_ERROR_INTERNAL(thr, msg)

#define	DUK_ERROR_INTERNAL_DEFMSG(thr)

#define	DUK_ERROR_ALLOC(thr, msg)

#define	DUK_ERROR_ALLOC_DEFMSG(thr)

#define	DUK_ERROR_API_INDEX(thr, index)

#define	DUK_ERROR_API(thr, msg)

#define	DUK_ERROR_RANGE(thr, msg)

#define	DUK_ERROR_SYNTAX(thr, msg)

#define	DUK_ERROR_TYPE(thr, msg)

#define	DUK_UNICODE_H_INCLUDED

#define	DUK_UNICODE_MAX_XUTF8_LENGTH 7 /* up to 36 bit codepoints */

#define	DUK_UNICODE_MAX_XUTF8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */

#define	DUK_UNICODE_MAX_CESU8_LENGTH 6 /* all codepoints up to U+10FFFF */

#define	DUK_UNICODE_MAX_CESU8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */

#define	DUK_UNICODE_CP_ZWNJ 0x200cL /* zero-width non-joiner */

#define	DUK_UNICODE_CP_ZWJ 0x200dL /* zero-width joiner */

#define	DUK_UNICODE_CP_REPLACEMENT_CHARACTER 0xfffdL /* http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */

#define	DUK_ASC_NUL 0x00

#define	DUK_ASC_SOH 0x01

#define	DUK_ASC_STX 0x02

#define	DUK_ASC_ETX 0x03

#define	DUK_ASC_EOT 0x04

#define	DUK_ASC_ENQ 0x05

#define	DUK_ASC_ACK 0x06

#define	DUK_ASC_BEL 0x07

#define	DUK_ASC_BS 0x08

#define	DUK_ASC_HT 0x09

#define	DUK_ASC_LF 0x0a

#define	DUK_ASC_VT 0x0b

#define	DUK_ASC_FF 0x0c

#define	DUK_ASC_CR 0x0d

#define	DUK_ASC_SO 0x0e

#define	DUK_ASC_SI 0x0f

#define	DUK_ASC_DLE 0x10

#define	DUK_ASC_DC1 0x11

#define	DUK_ASC_DC2 0x12

#define	DUK_ASC_DC3 0x13

#define	DUK_ASC_DC4 0x14

#define	DUK_ASC_NAK 0x15

#define	DUK_ASC_SYN 0x16

#define	DUK_ASC_ETB 0x17

#define	DUK_ASC_CAN 0x18

#define	DUK_ASC_EM 0x19

#define	DUK_ASC_SUB 0x1a

#define	DUK_ASC_ESC 0x1b

#define	DUK_ASC_FS 0x1c

#define	DUK_ASC_GS 0x1d

#define	DUK_ASC_RS 0x1e

#define	DUK_ASC_US 0x1f

#define	DUK_ASC_SPACE 0x20

#define	DUK_ASC_EXCLAMATION 0x21

#define	DUK_ASC_DOUBLEQUOTE 0x22

#define	DUK_ASC_HASH 0x23

#define	DUK_ASC_DOLLAR 0x24

#define	DUK_ASC_PERCENT 0x25

#define	DUK_ASC_AMP 0x26

#define	DUK_ASC_SINGLEQUOTE 0x27

#define	DUK_ASC_LPAREN 0x28

#define	DUK_ASC_RPAREN 0x29

#define	DUK_ASC_STAR 0x2a

#define	DUK_ASC_PLUS 0x2b

#define	DUK_ASC_COMMA 0x2c

#define	DUK_ASC_MINUS 0x2d

#define	DUK_ASC_PERIOD 0x2e

#define	DUK_ASC_SLASH 0x2f

#define	DUK_ASC_0 0x30

#define	DUK_ASC_1 0x31

#define	DUK_ASC_2 0x32

#define	DUK_ASC_3 0x33

#define	DUK_ASC_4 0x34

#define	DUK_ASC_5 0x35

#define	DUK_ASC_6 0x36

#define	DUK_ASC_7 0x37

#define	DUK_ASC_8 0x38

#define	DUK_ASC_9 0x39

#define	DUK_ASC_COLON 0x3a

#define	DUK_ASC_SEMICOLON 0x3b

#define	DUK_ASC_LANGLE 0x3c

#define	DUK_ASC_EQUALS 0x3d

#define	DUK_ASC_RANGLE 0x3e

#define	DUK_ASC_QUESTION 0x3f

#define	DUK_ASC_ATSIGN 0x40

#define	DUK_ASC_UC_A 0x41

#define	DUK_ASC_UC_B 0x42

#define	DUK_ASC_UC_C 0x43

#define	DUK_ASC_UC_D 0x44

#define	DUK_ASC_UC_E 0x45

#define	DUK_ASC_UC_F 0x46

#define	DUK_ASC_UC_G 0x47

#define	DUK_ASC_UC_H 0x48

#define	DUK_ASC_UC_I 0x49

#define	DUK_ASC_UC_J 0x4a

#define	DUK_ASC_UC_K 0x4b

#define	DUK_ASC_UC_L 0x4c

#define	DUK_ASC_UC_M 0x4d

#define	DUK_ASC_UC_N 0x4e

#define	DUK_ASC_UC_O 0x4f

#define	DUK_ASC_UC_P 0x50

#define	DUK_ASC_UC_Q 0x51

#define	DUK_ASC_UC_R 0x52

#define	DUK_ASC_UC_S 0x53

#define	DUK_ASC_UC_T 0x54

#define	DUK_ASC_UC_U 0x55

#define	DUK_ASC_UC_V 0x56

#define	DUK_ASC_UC_W 0x57

#define	DUK_ASC_UC_X 0x58

#define	DUK_ASC_UC_Y 0x59

#define	DUK_ASC_UC_Z 0x5a

#define	DUK_ASC_LBRACKET 0x5b

#define	DUK_ASC_BACKSLASH 0x5c

#define	DUK_ASC_RBRACKET 0x5d

#define	DUK_ASC_CARET 0x5e

#define	DUK_ASC_UNDERSCORE 0x5f

#define	DUK_ASC_GRAVE 0x60

#define	DUK_ASC_LC_A 0x61

#define	DUK_ASC_LC_B 0x62

#define	DUK_ASC_LC_C 0x63

#define	DUK_ASC_LC_D 0x64

#define	DUK_ASC_LC_E 0x65

#define	DUK_ASC_LC_F 0x66

#define	DUK_ASC_LC_G 0x67

#define	DUK_ASC_LC_H 0x68

#define	DUK_ASC_LC_I 0x69

#define	DUK_ASC_LC_J 0x6a

#define	DUK_ASC_LC_K 0x6b

#define	DUK_ASC_LC_L 0x6c

#define	DUK_ASC_LC_M 0x6d

#define	DUK_ASC_LC_N 0x6e

#define	DUK_ASC_LC_O 0x6f

#define	DUK_ASC_LC_P 0x70

#define	DUK_ASC_LC_Q 0x71

#define	DUK_ASC_LC_R 0x72

#define	DUK_ASC_LC_S 0x73

#define	DUK_ASC_LC_T 0x74

#define	DUK_ASC_LC_U 0x75

#define	DUK_ASC_LC_V 0x76

#define	DUK_ASC_LC_W 0x77

#define	DUK_ASC_LC_X 0x78

#define	DUK_ASC_LC_Y 0x79

#define	DUK_ASC_LC_Z 0x7a

#define	DUK_ASC_LCURLY 0x7b

#define	DUK_ASC_PIPE 0x7c

#define	DUK_ASC_RCURLY 0x7d

#define	DUK_ASC_TILDE 0x7e

#define	DUK_ASC_DEL 0x7f

#define	DUK_JSON_H_INCLUDED

#define	DUK_JSON_FLAG_ASCII_ONLY (1 << 0) /* escape any non-ASCII characters */

#define	DUK_JSON_FLAG_AVOID_KEY_QUOTES (1 << 1) /* avoid key quotes when key is an ASCII Identifier */

#define	DUK_JSON_FLAG_EXT_CUSTOM (1 << 2) /* extended types: custom encoding */

#define	DUK_JSON_FLAG_EXT_COMPATIBLE (1 << 3) /* extended types: compatible encoding */

#define	DUK_JSON_ENC_REQSTACK 32

#define	DUK_JSON_DEC_REQSTACK 32

#define	DUK_JSON_ENC_LOOPARRAY 64

#define	DUK_JS_H_INCLUDED

#define	DUK_CALL_FLAG_IGNORE_RECLIMIT (1 << 0) /* duk_handle_call_xxx: call ignores C recursion limit (for errhandler calls) */

#define	DUK_CALL_FLAG_CONSTRUCTOR_CALL (1 << 1) /* duk_handle_call_xxx: constructor call (i.e. called as 'new Foo()') */

#define	DUK_CALL_FLAG_IS_RESUME (1 << 2) /* duk_handle_ecma_call_setup: setup for a resume() */

#define	DUK_CALL_FLAG_IS_TAILCALL (1 << 3) /* duk_handle_ecma_call_setup: setup for a tail call */

#define	DUK_CALL_FLAG_DIRECT_EVAL (1 << 4) /* call is a direct eval call */

#define	DUK_EQUALS_FLAG_SAMEVALUE (1 << 0) /* use SameValue instead of non-strict equality */

#define	DUK_EQUALS_FLAG_STRICT (1 << 1) /* use strict equality instead of non-strict equality */

#define	DUK_COMPARE_FLAG_EVAL_LEFT_FIRST (1 << 0) /* eval left argument first */

#define	DUK_COMPARE_FLAG_NEGATE (1 << 1) /* negate result */

#define	duk_js_equals(thr, tv_x, tv_y) duk_js_equals_helper((thr), (tv_x), (tv_y), 0)

#define	duk_js_strict_equals(tv_x, tv_y) duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_STRICT)

#define	duk_js_samevalue(tv_x, tv_y) duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_SAMEVALUE)

#define	duk_js_lessthan(thr, tv_x, tv_y) duk_js_compare_helper((thr), (tv_x), (tv_Y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST)

#define	duk_js_greaterthan(thr, tv_x, tv_y) duk_js_compare_helper((thr), (tv_y), (tv_x), 0)

#define	duk_js_lessthanorequal(thr, tv_x, tv_y) duk_js_compare_helper((thr), (tv_y), (tv_x), DUK_COMPARE_FLAG_NEGATE)

#define	duk_js_greaterthanorequal(thr, tv_x, tv_y) duk_js_compare_helper((thr), (tv_x), (tv_y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST \| DUK_COMPARE_FLAG_NEGATE)

#define	DUK_NUMCONV_H_INCLUDED

#define	DUK_N2S_FLAG_FIXED_FORMAT (1 << 0)

#define	DUK_N2S_FLAG_FORCE_EXP (1 << 1)

#define	DUK_N2S_FLAG_NO_ZERO_PAD (1 << 2)

#define	DUK_N2S_FLAG_FRACTION_DIGITS (1 << 3)

#define	DUK_S2N_MAX_EXPONENT 1000000000

#define	DUK_S2N_FLAG_TRIM_WHITE (1 << 0)

#define	DUK_S2N_FLAG_ALLOW_EXP (1 << 1)

#define	DUK_S2N_FLAG_ALLOW_GARBAGE (1 << 2)

#define	DUK_S2N_FLAG_ALLOW_PLUS (1 << 3)

#define	DUK_S2N_FLAG_ALLOW_MINUS (1 << 4)

#define	DUK_S2N_FLAG_ALLOW_INF (1 << 5)

#define	DUK_S2N_FLAG_ALLOW_FRAC (1 << 6)

#define	DUK_S2N_FLAG_ALLOW_NAKED_FRAC (1 << 7)

#define	DUK_S2N_FLAG_ALLOW_EMPTY_FRAC (1 << 8)

#define	DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO (1 << 9)

#define	DUK_S2N_FLAG_ALLOW_LEADING_ZERO (1 << 10)

#define	DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT (1 << 11)

#define	DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT (1 << 12)

#define	DUK_BUILTIN_PROTOS_H_INCLUDED

#define	DUK_BI_DATE_ISO8601_BUFSIZE 48

#define	DUK_BI_COMMONJS_MODULE_ID_LIMIT 256

#define	DUK_SELFTEST_H_INCLUDED

#define	DUK__ERRFMT_BUFSIZE 256 /* size for formatting buffers */

#define	DUK__HASH_SIZE_RATIO 1177 /* floor(1.15 * (1 << 10)) */

#define	DUK__SER_MARKER 0xff

#define	DUK__SER_VERSION 0x00

#define	DUK__SER_STRING 0x00

#define	DUK__SER_NUMBER 0x01

#define	DUK__BYTECODE_INITIAL_ALLOC 256

#define	DUK__ASSERT_LEFT(n)

#define	DUK__CHECK_SPACE()

#define	DUK__PACK_ARGS(classnum, protobidx, elemtype, elemshift, isview) (((classnum) << 24) \| ((protobidx) << 16) \| ((elemtype) << 8) \| ((elemshift) << 4) \| (isview))

#define	DUK__READABLE_STRING_MAXCHARS 32

#define	DUK__ARRAY_MID_JOIN_LIMIT 4096

#define	DUK__ITER_EVERY 0

#define	DUK__ITER_SOME 1

#define	DUK__ITER_FOREACH 2

#define	DUK__ITER_MAP 3

#define	DUK__ITER_FILTER 4

#define	DUK__FLD_8BIT 0

#define	DUK__FLD_16BIT 1

#define	DUK__FLD_32BIT 2

#define	DUK__FLD_FLOAT 3

#define	DUK__FLD_DOUBLE 4

#define	DUK__FLD_VARINT 5

#define	DUK__FLD_BIGENDIAN (1 << 3)

#define	DUK__FLD_SIGNED (1 << 4)

#define	DUK__FLD_TYPEDARRAY (1 << 5)

#define	DUK__DPRINT_PARTS_AND_DPARTS(parts, dparts)

#define	DUK__DPRINT_PARTS(parts)

#define	DUK__DPRINT_DPARTS(dparts)

#define	DUK__YEAR(x) ((duk_uint8_t) ((x) - 1970))

#define	DUK__NUM_ISO8601_PARSER_PARTS 9

#define	DUK__PI_YEAR 0

#define	DUK__PI_MONTH 1

#define	DUK__PI_DAY 2

#define	DUK__PI_HOUR 3

#define	DUK__PI_MINUTE 4

#define	DUK__PI_SECOND 5

#define	DUK__PI_MILLISECOND 6

#define	DUK__PI_TZHOUR 7

#define	DUK__PI_TZMINUTE 8

#define	DUK__PM_YEAR (1 << DUK__PI_YEAR)

#define	DUK__PM_MONTH (1 << DUK__PI_MONTH)

#define	DUK__PM_DAY (1 << DUK__PI_DAY)

#define	DUK__PM_HOUR (1 << DUK__PI_HOUR)

#define	DUK__PM_MINUTE (1 << DUK__PI_MINUTE)

#define	DUK__PM_SECOND (1 << DUK__PI_SECOND)

#define	DUK__PM_MILLISECOND (1 << DUK__PI_MILLISECOND)

#define	DUK__PM_TZHOUR (1 << DUK__PI_TZHOUR)

#define	DUK__PM_TZMINUTE (1 << DUK__PI_TZMINUTE)

#define	DUK__SI_PLUS 0

#define	DUK__SI_MINUS 1

#define	DUK__SI_T 2

#define	DUK__SI_SPACE 3

#define	DUK__SI_COLON 4

#define	DUK__SI_PERIOD 5

#define	DUK__SI_Z 6

#define	DUK__SI_NUL 7

#define	DUK__SM_PLUS (1 << DUK__SI_PLUS)

#define	DUK__SM_MINUS (1 << DUK__SI_MINUS)

#define	DUK__SM_T (1 << DUK__SI_T)

#define	DUK__SM_SPACE (1 << DUK__SI_SPACE)

#define	DUK__SM_COLON (1 << DUK__SI_COLON)

#define	DUK__SM_PERIOD (1 << DUK__SI_PERIOD)

#define	DUK__SM_Z (1 << DUK__SI_Z)

#define	DUK__SM_NUL (1 << DUK__SI_NUL)

#define	DUK__CF_NEG (1 << 0) /* continue matching, set neg_tzoffset flag */

#define	DUK__CF_ACCEPT (1 << 1) /* accept string */

#define	DUK__CF_ACCEPT_NUL (1 << 2) /* accept string if next char is NUL (otherwise reject) */

#define	DUK__PACK_RULE(partmask, sepmask, nextpart, flags)

#define	DUK__UNPACK_RULE(rule, var_nextidx, var_flags)

#define	DUK__RULE_MASK_PART_SEP 0x1ffffUL

#define	DUK__LOCAL_TZOFFSET_MAXITER 4

#define	DUK__WEEKDAY_MOD_ADDER (20000000 * 7) /* 0x08583b00 */

#define	DUK__STRPTIME_BUF_SIZE 64

#define	DUK__STRFTIME_BUF_SIZE 64

#define	DUK__OUTPUT_TYPE_TRACEBACK (-1)

#define	DUK__OUTPUT_TYPE_FILENAME 0

#define	DUK__OUTPUT_TYPE_LINENUMBER 1

#define	DUK__MKBITS(a, b, c, d, e, f, g, h)

#define	DUK__CHECK_BITMASK(table, cp) ((table)[(cp) >> 3] & (1 << ((cp) & 0x07)))

#define	DUK__IDX_REQUESTED_ID 0 /* Module id requested */

#define	DUK__IDX_REQUIRE 1 /* Current require() function */

#define	DUK__IDX_REQUIRE_ID 2 /* The base ID of the current require() function, resolution base */

#define	DUK__IDX_RESOLVED_ID 3 /* Resolved, normalized absolute module ID */

#define	DUK__IDX_LASTCOMP 4 /* Last component name in resolved path */

#define	DUK__IDX_DUKTAPE 5 /* Duktape object */

#define	DUK__IDX_MODLOADED 6 /* Duktape.modLoaded[] module cache */

#define	DUK__IDX_UNDEFINED 7 /* 'undefined', artifact of lookup */

#define	DUK__IDX_FRESH_REQUIRE 8 /* New require() function for module, updated resolution base */

#define	DUK__IDX_EXPORTS 9 /* Default exports table */

#define	DUK__IDX_MODULE 10 /* Module object containing module.exports, etc */

#define	DUK__JSON_DECSTR_BUFSIZE 128

#define	DUK__JSON_DECSTR_CHUNKSIZE 64

#define	DUK__JSON_ENCSTR_CHUNKSIZE 64

#define	DUK__JSON_STRINGIFY_BUFSIZE 128

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

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

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

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

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

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

#define	DUK__UNEMIT_1(js_ctx) duk__unemit_1((js_ctx))

#define	DUK__MKESC(nybbles, esc1, esc2)

#define	DUK__BITPACK_LETTER_LIMIT 26

#define	DUK__BITPACK_UNDERSCORE 26

#define	DUK__BITPACK_FF 27

#define	DUK__BITPACK_SWITCH1 29

#define	DUK__BITPACK_SWITCH 30

#define	DUK__BITPACK_SEVENBIT 31

#define	DUK__VOLUNTARY_PERIODIC_GC(heap)

#define	DUK__HASH_INITIAL(hash, h_size) DUK_STRTAB_HASH_INITIAL((hash),(h_size))

#define	DUK__HASH_PROBE_STEP(hash) DUK_STRTAB_HASH_PROBE_STEP((hash))

#define	DUK__DELETED_MARKER(heap) DUK_STRTAB_DELETED_MARKER((heap))

#define	DUK__PREVENT_MS_SIDE_EFFECTS(heap)

#define	DUK__ENUM_START_INDEX 2

#define	DUK__NO_ARRAY_INDEX DUK_HSTRING_NO_ARRAY_INDEX

#define	DUK__HASH_INITIAL(hash, h_size) DUK_HOBJECT_HASH_INITIAL((hash),(h_size))

#define	DUK__HASH_PROBE_STEP(hash) DUK_HOBJECT_HASH_PROBE_STEP((hash))

#define	DUK__HASH_UNUSED DUK_HOBJECT_HASHIDX_UNUSED

#define	DUK__HASH_DELETED DUK_HOBJECT_HASHIDX_DELETED

#define	DUK__VALSTACK_SPACE 10

#define	DUK__VALSTACK_PROXY_LOOKUP 20

#define	DUK__CLASS_BITS 5

#define	DUK__BIDX_BITS 7

#define	DUK__STRIDX_BITS 9 /* XXX: try to optimize to 8 (would now be possible, <200 used) */

#define	DUK__NATIDX_BITS 8

#define	DUK__NUM_NORMAL_PROPS_BITS 6

#define	DUK__NUM_FUNC_PROPS_BITS 6

#define	DUK__PROP_FLAGS_BITS 3

#define	DUK__STRING_LENGTH_BITS 8

#define	DUK__STRING_CHAR_BITS 7

#define	DUK__LENGTH_PROP_BITS 3

#define	DUK__NARGS_BITS 3

#define	DUK__PROP_TYPE_BITS 3

#define	DUK__MAGIC_BITS 16

#define	DUK__NARGS_VARARGS_MARKER 0x07

#define	DUK__NO_CLASS_MARKER 0x00 /* 0 = DUK_HOBJECT_CLASS_UNUSED */

#define	DUK__NO_BIDX_MARKER 0x7f

#define	DUK__NO_STRIDX_MARKER 0xff

#define	DUK__PROP_TYPE_DOUBLE 0

#define	DUK__PROP_TYPE_STRING 1

#define	DUK__PROP_TYPE_STRIDX 2

#define	DUK__PROP_TYPE_BUILTIN 3

#define	DUK__PROP_TYPE_UNDEFINED 4

#define	DUK__PROP_TYPE_BOOLEAN_TRUE 5

#define	DUK__PROP_TYPE_BOOLEAN_FALSE 6

#define	DUK__PROP_TYPE_ACCESSOR 7

#define	DUK__CONST_MARKER DUK_JS_CONST_MARKER

#define	DUK__MAX_ARRAY_INIT_VALUES 20

#define	DUK__MAX_OBJECT_INIT_PAIRS 10

#define	DUK__GETCONST_MAX_CONSTS_CHECK 256

#define	DUK__MAX_CONSTS DUK_BC_BC_MAX

#define	DUK__MAX_FUNCS DUK_BC_BC_MAX

#define	DUK__MAX_TEMPS 0xffffL

#define	DUK__BC_INITIAL_INSTS 256

#define	DUK__RECURSION_INCREASE(comp_ctx, thr)

#define	DUK__RECURSION_DECREASE(comp_ctx, thr)

#define	DUK__COMPILE_ENTRY_SLOTS 8

#define	DUK__FUNCTION_INIT_REQUIRE_SLOTS 16

#define	DUK__FUNCTION_BODY_REQUIRE_SLOTS 16

#define	DUK__PARSE_STATEMENTS_SLOTS 16

#define	DUK__PARSE_EXPR_SLOTS 16

#define	DUK__BP_INVALID 0 /* always terminates led() */

#define	DUK__BP_EOF 2

#define	DUK__BP_CLOSING 4 /* token closes expression, e.g. ')', ']' */

#define	DUK__BP_FOR_EXPR DUK__BP_CLOSING /* bp to use when parsing a top level Expression */

#define	DUK__BP_COMMA 6

#define	DUK__BP_ASSIGNMENT 8

#define	DUK__BP_CONDITIONAL 10

#define	DUK__BP_LOR 12

#define	DUK__BP_LAND 14

#define	DUK__BP_BOR 16

#define	DUK__BP_BXOR 18

#define	DUK__BP_BAND 20

#define	DUK__BP_EQUALITY 22

#define	DUK__BP_RELATIONAL 24

#define	DUK__BP_SHIFT 26

#define	DUK__BP_ADDITIVE 28

#define	DUK__BP_MULTIPLICATIVE 30

#define	DUK__BP_POSTFIX 32

#define	DUK__BP_CALL 34

#define	DUK__BP_MEMBER 36

#define	DUK__TOKEN_LBP_BP_MASK 0x1f

#define	DUK__TOKEN_LBP_FLAG_NO_REGEXP (1 << 5) /* regexp literal must not follow this token */

#define	DUK__TOKEN_LBP_FLAG_TERMINATES (1 << 6) /* terminates expression; e.g. post-increment/-decrement */

#define	DUK__TOKEN_LBP_FLAG_UNUSED (1 << 7) /* spare */

#define	DUK__TOKEN_LBP_GET_BP(x) ((duk_small_uint_t) (((x) & DUK__TOKEN_LBP_BP_MASK) * 2))

#define	DUK__MK_LBP(bp) ((bp) >> 1) /* bp is assumed to be even */

#define	DUK__MK_LBP_FLAGS(bp, flags) (((bp) >> 1) \| (flags))

#define	DUK__EMIT_FLAG_NO_SHUFFLE_A (1 << 8)

#define	DUK__EMIT_FLAG_NO_SHUFFLE_B (1 << 9)

#define	DUK__EMIT_FLAG_NO_SHUFFLE_C (1 << 10)

#define	DUK__EMIT_FLAG_A_IS_SOURCE (1 << 11) /* slot A is a source (default: target) */

#define	DUK__EMIT_FLAG_B_IS_TARGET (1 << 12) /* slot B is a target (default: source) */

#define	DUK__EMIT_FLAG_C_IS_TARGET (1 << 13) /* slot C is a target (default: source) */

#define	DUK__EMIT_FLAG_B_IS_TARGETSOURCE (1 << 14) /* slot B is both a target and a source (used by extraops like DUK_EXTRAOP_INSTOF */

#define	DUK__EMIT_FLAG_RESERVE_JUMPSLOT (1 << 15) /* reserve a jumpslot after instr before target spilling, used for NEXTENUM */

#define	DUK__ISREG(comp_ctx, x) (((x) & DUK__CONST_MARKER) == 0)

#define	DUK__ISCONST(comp_ctx, x) (((x) & DUK__CONST_MARKER) != 0)

#define	DUK__ISTEMP(comp_ctx, x) (DUK__ISREG((comp_ctx), (x)) && (duk_regconst_t) (x) >= (duk_regconst_t) ((comp_ctx)->curr_func.temp_first))

#define	DUK__GETTEMP(comp_ctx) ((comp_ctx)->curr_func.temp_next)

#define	DUK__SETTEMP(comp_ctx, x) ((comp_ctx)->curr_func.temp_next = (x)) /* dangerous: must only lower (temp_max not updated) */

#define	DUK__SETTEMP_CHECKMAX(comp_ctx, x) duk__settemp_checkmax((comp_ctx),(x))

#define	DUK__ALLOCTEMP(comp_ctx) duk__alloctemp((comp_ctx))

#define	DUK__ALLOCTEMPS(comp_ctx, count) duk__alloctemps((comp_ctx),(count))

#define	DUK__IVAL_FLAG_ALLOW_CONST (1 << 0) /* allow a constant to be returned */

#define	DUK__IVAL_FLAG_REQUIRE_TEMP (1 << 1) /* require a (mutable) temporary as a result (or a const if allowed) */

#define	DUK__IVAL_FLAG_REQUIRE_SHORT (1 << 2) /* require a short (8-bit) reg/const which fits into bytecode B/C slot */

#define	DUK__DUMP_ISPEC(comp_ctx, x) do {} while (0)

#define	DUK__DUMP_IVALUE(comp_ctx, x) do {} while (0)

#define	DUK__OBJ_LIT_KEY_PLAIN (1 << 0) /* key encountered as a plain property */

#define	DUK__OBJ_LIT_KEY_GET (1 << 1) /* key encountered as a getter */

#define	DUK__OBJ_LIT_KEY_SET (1 << 2) /* key encountered as a setter */

#define	DUK__EXPR_RBP_MASK 0xff

#define	DUK__EXPR_FLAG_REJECT_IN (1 << 8) /* reject 'in' token (used for for-in) */

#define	DUK__EXPR_FLAG_ALLOW_EMPTY (1 << 9) /* allow empty expression */

#define	DUK__EXPR_FLAG_REQUIRE_INIT (1 << 10) /* require initializer for var/const */

#define	DUK__HAS_VAL (1 << 0) /* stmt has non-empty value */

#define	DUK__HAS_TERM (1 << 1) /* stmt has explicit/implicit semicolon terminator */

#define	DUK__ALLOW_AUTO_SEMI_ALWAYS (1 << 2) /* allow automatic semicolon even without lineterm (compatibility) */

#define	DUK__STILL_PROLOGUE (1 << 3) /* statement does not terminate directive prologue */

#define	DUK__IS_TERMINAL (1 << 4) /* statement is guaranteed to be terminal (control doesn't flow to next statement) */

#define	DUK__LONGJMP_RESTART 0 /* state updated, restart bytecode execution */

#define	DUK__LONGJMP_RETHROW 1 /* exit bytecode executor by rethrowing an error to caller */

#define	DUK__RETHAND_RESTART 0 /* state updated, restart bytecode execution */

#define	DUK__RETHAND_FINISHED 1 /* exit bytecode execution with return value */

#define	DUK__FUN() ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC((thr)->callstack + (thr)->callstack_top - 1))

#define	DUK__STRICT() (DUK_HOBJECT_HAS_STRICT((duk_hobject *) DUK__FUN()))

#define	DUK__REG(x) (*(thr->valstack_bottom + (x)))

#define	DUK__REGP(x) (thr->valstack_bottom + (x))

#define	DUK__CONST(x) (*(consts + (x)))

#define	DUK__CONSTP(x) (consts + (x))

#define	DUK__RCISREG(x) (((x) & 0x100) == 0)

#define	DUK__REGCONST(x) (*((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x)))

#define	DUK__REGCONSTP(x) ((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x))

#define	DUK__INTERNAL_ERROR(msg)

#define	DUK__SYNC_CURR_PC()

#define	DUK__SYNC_AND_NULL_CURR_PC()

#define	DUK__MAX_RE_DECESC_DIGITS 9

#define	DUK__MAX_RE_QUANT_DIGITS 9 /* Does not allow e.g. 2*31-1, but one more would allow overflows of u32. /

#define	DUK__ISDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_9)

#define	DUK__ISHEXDIGIT(x) duk__is_hex_digit((x))

#define	DUK__ISOCTDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_7)

#define	DUK__ISDIGIT03(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_3)

#define	DUK__ISDIGIT47(x) ((x) >= DUK_ASC_4 && (x) <= DUK_ASC_7)

#define	DUK__LOOKUP(lex_ctx, index) ((lex_ctx)->window[(index)].codepoint)

#define	DUK__ADVANCECHARS(lex_ctx, count) duk__advance_bytes((lex_ctx), (count) * sizeof(duk_lexer_codepoint))

#define	DUK__ADVANCEBYTES(lex_ctx, count) duk__advance_bytes((lex_ctx), (count))

#define	DUK__INITBUFFER(lex_ctx) duk__initbuffer((lex_ctx))

#define	DUK__APPENDBUFFER(lex_ctx, x) duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x))

#define	DUK__L0() DUK__LOOKUP(lex_ctx, 0)

#define	DUK__L1() DUK__LOOKUP(lex_ctx, 1)

#define	DUK__L2() DUK__LOOKUP(lex_ctx, 2)

#define	DUK__L3() DUK__LOOKUP(lex_ctx, 3)

#define	DUK__L4() DUK__LOOKUP(lex_ctx, 4)

#define	DUK__L5() DUK__LOOKUP(lex_ctx, 5)

#define	DUK__ADVTOK(advbytes, tok) ((((advbytes) * sizeof(duk_lexer_codepoint)) << 8) + (tok))

#define	DUK__IEEE_DOUBLE_EXP_BIAS 1023

#define	DUK__IEEE_DOUBLE_EXP_MIN (-1022) /* biased exp == 0 -> denormal, exp -1022 */

#define	DUK__DIGITCHAR(x) duk_lc_digits[(x)]

#define	DUK__BI_MAX_PARTS 37 /* 37x32 = 1184 bits */

#define	DUK__BI_PRINT(name, x)

#define	DUK__MAX_OUTPUT_DIGITS 1040 /* (Number.MAX_VALUE).toString(2).length == 1024, + spare */

#define	DUK__MAX_FORMATTED_LENGTH 1040 /* (-Number.MAX_VALUE).toString(2).length == 1025, + spare */

#define	DUK__NUMCONV_CTX_NUM_BIGINTS 7

#define	DUK__NUMCONV_CTX_BIGINTS_SIZE (sizeof(duk__bigint) * DUK__NUMCONV_CTX_NUM_BIGINTS)

#define	DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, preinc_idx, x)

#define	DUK__NO_EXP (65536) /* arbitrary marker, outside valid exp range */

#define	DUK__RE_INITIAL_BUFSIZE 64

#define	DUK__RE_BUFLEN(re_ctx) DUK_BW_GET_SIZE(re_ctx->thr, &re_ctx->bw)

#define	DUK__UPDATE_RND(rnd)

#define	DUK__RND_BIT(rnd) ((rnd) >> 31) /* only use the highest bit */

Typedefs
typedef struct duk_jmpbuf	duk_jmpbuf

typedef struct duk_heaphdr	duk_heaphdr

typedef struct duk_heaphdr_string	duk_heaphdr_string

typedef struct duk_hstring	duk_hstring

typedef struct duk_hstring_external	duk_hstring_external

typedef struct duk_hobject	duk_hobject

typedef struct duk_hcompiledfunction	duk_hcompiledfunction

typedef struct duk_hnativefunction	duk_hnativefunction

typedef struct duk_hbufferobject	duk_hbufferobject

typedef struct duk_hthread	duk_hthread

typedef struct duk_hbuffer	duk_hbuffer

typedef struct duk_hbuffer_fixed	duk_hbuffer_fixed

typedef struct duk_hbuffer_dynamic	duk_hbuffer_dynamic

typedef struct duk_hbuffer_external	duk_hbuffer_external

typedef struct duk_propaccessor	duk_propaccessor

typedef union duk_propvalue	duk_propvalue

typedef struct duk_propdesc	duk_propdesc

typedef struct duk_heap	duk_heap

typedef struct duk_breakpoint	duk_breakpoint

typedef struct duk_activation	duk_activation

typedef struct duk_catcher	duk_catcher

typedef struct duk_strcache	duk_strcache

typedef struct duk_ljstate	duk_ljstate

typedef struct duk_strtab_entry	duk_strtab_entry

typedef struct duk_bitdecoder_ctx	duk_bitdecoder_ctx

typedef struct duk_bitencoder_ctx	duk_bitencoder_ctx

typedef struct duk_bufwriter_ctx	duk_bufwriter_ctx

typedef struct duk_token	duk_token

typedef struct duk_re_token	duk_re_token

typedef struct duk_lexer_point	duk_lexer_point

typedef struct duk_lexer_ctx	duk_lexer_ctx

typedef struct duk_lexer_codepoint	duk_lexer_codepoint

typedef struct duk_compiler_instr	duk_compiler_instr

typedef struct duk_compiler_func	duk_compiler_func

typedef struct duk_compiler_ctx	duk_compiler_ctx

typedef struct duk_re_matcher_ctx	duk_re_matcher_ctx

typedef struct duk_re_compiler_ctx	duk_re_compiler_ctx

typedef struct duk_tval_struct	duk_tval

typedef duk_uint32_t	duk_instr_t

typedef void(*	duk_re_range_callback) (void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct)

typedef duk_uint32_t	duk_regconst_t

typedef duk_int32_t	duk_reg_t

typedef void (	duk_mem_getptr) (duk_heap heap, void ud)

typedef struct duk__compile_raw_args	duk__compile_raw_args

typedef struct duk_internal_thread_state	duk_internal_thread_state

typedef duk_double_t(*	duk__toint_coercer) (duk_hthread thr, duk_tval tv)

typedef void(*	duk__transform_callback) (duk__transform_context tfm_ctx, const void udata, duk_codepoint_t cp)

typedef double(*	duk__one_arg_func) (double)

typedef double(*	duk__two_arg_func) (double, double)

Functions
DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_function_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_function_prototype (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_boolean_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_regexp_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_constructor_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_type_error_thrower (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_proxy_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_thread_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_buffer_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_pointer_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_logger_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_arraybuffer_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_dataview_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_typedarray_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_constructor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_eval (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_parse_int (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_parse_float (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_is_nan (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_is_finite (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_decode_uri (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_decode_uri_component (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_encode_uri (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_encode_uri_component (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_escape (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_unescape (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_print_helper (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_global_object_require (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_getprototype_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_setprototype_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_get_own_property_descriptor (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_keys_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_create (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_define_property (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_define_properties (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_seal_freeze_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_prevent_extensions (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_is_sealed_frozen_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_constructor_is_extensible (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_prototype_to_locale_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_prototype_value_of (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_prototype_has_own_property (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_prototype_is_prototype_of (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_object_prototype_property_is_enumerable (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_function_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_function_prototype_apply (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_function_prototype_call (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_function_prototype_bind (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_constructor_is_array (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_join_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_concat (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_pop (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_push (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_reverse (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_shift (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_slice (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_sort (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_splice (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_unshift (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_indexof_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_iter_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_array_prototype_reduce_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_constructor_from_char_code (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_char_at (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_char_code_at (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_concat (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_indexof_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_locale_compare (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_match (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_replace (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_search (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_slice (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_split (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_substring (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_caseconv_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_trim (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_string_prototype_substr (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_boolean_prototype_tostring_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_prototype_to_locale_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_prototype_value_of (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_prototype_to_fixed (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_prototype_to_exponential (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_number_prototype_to_precision (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_constructor_parse (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_constructor_utc (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_constructor_now (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_tostring_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_to_json (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_value_of (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_get_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_get_timezone_offset (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_set_time (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_date_prototype_set_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_regexp_prototype_exec (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_regexp_prototype_test (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_regexp_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_stack_getter (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_stack_setter (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_filename_getter (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_filename_setter (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_linenumber_getter (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_linenumber_setter (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_error_prototype_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_math_object_onearg_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_math_object_twoarg_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_math_object_max (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_math_object_min (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_math_object_random (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_json_object_parse (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_json_object_stringify (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_info (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_act (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_gc (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_fin (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_enc (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_dec (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_duktape_object_compact (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_thread_yield (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_thread_resume (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_thread_current (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_buffer_prototype_tostring_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_pointer_prototype_tostring_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_logger_prototype_fmt (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_logger_prototype_raw (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_logger_prototype_log_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_arraybuffer_isview (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_buffer_slice_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_buffer_readfield (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_buffer_writefield (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_typedarray_set (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_concat (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_is_encoding (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_is_buffer (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_byte_length (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_buffer_compare_shared (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_tostring (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_tojson (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_fill (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_copy (duk_context *ctx)

DUK_INTERNAL_DECL duk_ret_t	duk_bi_nodejs_buffer_write (duk_context *ctx)

DUK_INTERNAL_DECL duk_uint32_t	duk_util_get_hash_prime (duk_uint32_t size)

DUK_INTERNAL_DECL duk_int32_t	duk_bd_decode (duk_bitdecoder_ctx *ctx, duk_small_int_t bits)

DUK_INTERNAL_DECL duk_small_int_t	duk_bd_decode_flag (duk_bitdecoder_ctx *ctx)

DUK_INTERNAL_DECL duk_int32_t	duk_bd_decode_flagged (duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value)

DUK_INTERNAL_DECL void	duk_be_encode (duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits)

DUK_INTERNAL_DECL void	duk_be_finish (duk_bitencoder_ctx *ctx)

DUK_INTERNAL_DECL duk_uint32_t	duk_util_tinyrandom_get_bits (duk_hthread *thr, duk_small_int_t n)

DUK_INTERNAL_DECL duk_double_t	duk_util_tinyrandom_get_double (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_bw_init (duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_hbuffer_dynamic *h_buf)

DUK_INTERNAL_DECL void	duk_bw_init_pushbuf (duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_size_t buf_size)

DUK_INTERNAL_DECL duk_uint8_t *	duk_bw_resize (duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_size_t sz)

DUK_INTERNAL_DECL void	duk_bw_compact (duk_hthread thr, duk_bufwriter_ctx bw_ctx)

DUK_INTERNAL_DECL void	duk_bw_write_raw_slice (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t src_off, duk_size_t len)

DUK_INTERNAL_DECL void	duk_bw_write_ensure_slice (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t src_off, duk_size_t len)

DUK_INTERNAL_DECL void	duk_bw_insert_raw_bytes (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len)

DUK_INTERNAL_DECL void	duk_bw_insert_ensure_bytes (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len)

DUK_INTERNAL_DECL void	duk_bw_insert_raw_slice (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len)

DUK_INTERNAL_DECL void	duk_bw_insert_ensure_slice (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len)

DUK_INTERNAL_DECL duk_uint8_t *	duk_bw_insert_raw_area (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t off, duk_size_t len)

DUK_INTERNAL_DECL duk_uint8_t *	duk_bw_insert_ensure_area (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t off, duk_size_t len)

DUK_INTERNAL_DECL void	duk_bw_remove_raw_slice (duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t off, duk_size_t len)

DUK_INTERNAL_DECL duk_uint16_t	duk_raw_read_u16_be (duk_uint8_t **p)

DUK_INTERNAL_DECL duk_uint32_t	duk_raw_read_u32_be (duk_uint8_t **p)

DUK_INTERNAL_DECL duk_double_t	duk_raw_read_double_be (duk_uint8_t **p)

DUK_INTERNAL_DECL void	duk_raw_write_u16_be (duk_uint8_t **p, duk_uint16_t val)

DUK_INTERNAL_DECL void	duk_raw_write_u32_be (duk_uint8_t **p, duk_uint32_t val)

DUK_INTERNAL_DECL void	duk_raw_write_double_be (duk_uint8_t **p, duk_double_t val)

DUK_INTERNAL_DECL void	duk_lexer_initctx (duk_lexer_ctx *lex_ctx)

DUK_INTERNAL_DECL void	duk_lexer_setpoint (duk_lexer_ctx lex_ctx, duk_lexer_point pt)

DUK_INTERNAL_DECL void	duk_lexer_parse_js_input_element (duk_lexer_ctx lex_ctx, duk_token out_token, duk_bool_t strict_mode, duk_bool_t regexp_mode)

DUK_INTERNAL_DECL void	duk_lexer_parse_re_token (duk_lexer_ctx lex_ctx, duk_re_token out_token)

DUK_INTERNAL_DECL void	duk_lexer_parse_re_ranges (duk_lexer_ctx lex_ctx, duk_re_range_callback gen_range, void userdata)

DUK_INTERNAL_DECL void	duk_js_compile (duk_hthread thr, const duk_uint8_t src_buffer, duk_size_t src_length, duk_small_uint_t flags)

DUK_INTERNAL_DECL void	duk_regexp_compile (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_regexp_create_instance (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_regexp_match (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_regexp_match_force_global (duk_hthread *thr)

DUK_INTERNAL_DECL duk_bool_t	duk_valstack_resize_raw (duk_context *ctx, duk_size_t min_new_size, duk_small_uint_t flags)

DUK_INTERNAL_DECL duk_tval *	duk_get_tval (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_tval *	duk_require_tval (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL void	duk_push_tval (duk_context ctx, duk_tval tv)

DUK_INTERNAL_DECL void	duk_push_this_check_object_coercible (duk_context *ctx)

DUK_INTERNAL_DECL duk_hobject *	duk_push_this_coercible_to_object (duk_context *ctx)

DUK_INTERNAL_DECL duk_hstring *	duk_push_this_coercible_to_string (duk_context *ctx)

DUK_INTERNAL_DECL duk_tval *	duk_get_borrowed_this_tval (duk_context *ctx)

DUK_INTERNAL_DECL duk_hstring *	duk_get_hstring (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hobject *	duk_get_hobject (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hbuffer *	duk_get_hbuffer (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hthread *	duk_get_hthread (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hcompiledfunction *	duk_get_hcompiledfunction (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hnativefunction *	duk_get_hnativefunction (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hobject *	duk_get_hobject_with_class (duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)

DUK_INTERNAL_DECL duk_hobject *	duk_get_hobject_or_lfunc_coerce (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hstring *	duk_to_hstring (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL void	duk_to_object_class_string_top (duk_context *ctx)

DUK_INTERNAL_DECL void	duk_push_hobject_class_string (duk_context ctx, duk_hobject h)

DUK_INTERNAL_DECL duk_int_t	duk_to_int_clamped_raw (duk_context ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t out_clamped)

DUK_INTERNAL_DECL duk_int_t	duk_to_int_clamped (duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval)

DUK_INTERNAL_DECL duk_int_t	duk_to_int_check_range (duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval)

DUK_INTERNAL_DECL duk_uint8_t	duk_to_uint8clamped (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hstring *	duk_require_hstring (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hobject *	duk_require_hobject (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hbuffer *	duk_require_hbuffer (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hthread *	duk_require_hthread (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hcompiledfunction *	duk_require_hcompiledfunction (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hnativefunction *	duk_require_hnativefunction (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hobject *	duk_require_hobject_with_class (duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)

DUK_INTERNAL_DECL duk_hobject *	duk_require_hobject_or_lfunc (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL duk_hobject *	duk_require_hobject_or_lfunc_coerce (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL void	duk_push_hstring (duk_context ctx, duk_hstring h)

DUK_INTERNAL_DECL void	duk_push_hstring_stridx (duk_context *ctx, duk_small_int_t stridx)

DUK_INTERNAL_DECL void	duk_push_hobject (duk_context ctx, duk_hobject h)

DUK_INTERNAL_DECL void	duk_push_hbuffer (duk_context ctx, duk_hbuffer h)

DUK_INTERNAL_DECL void	duk_push_hobject_bidx (duk_context *ctx, duk_small_int_t builtin_idx)

DUK_INTERNAL_DECL duk_idx_t	duk_push_object_helper (duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx)

DUK_INTERNAL_DECL duk_idx_t	duk_push_object_helper_proto (duk_context ctx, duk_uint_t hobject_flags_and_class, duk_hobject proto)

DUK_INTERNAL_DECL duk_idx_t	duk_push_object_internal (duk_context *ctx)

DUK_INTERNAL_DECL duk_idx_t	duk_push_compiledfunction (duk_context *ctx)

DUK_INTERNAL_DECL void	duk_push_c_function_noexotic (duk_context *ctx, duk_c_function func, duk_int_t nargs)

DUK_INTERNAL_DECL void	duk_push_c_function_noconstruct_noexotic (duk_context *ctx, duk_c_function func, duk_int_t nargs)

DUK_INTERNAL_DECL void	duk_push_string_funcptr (duk_context ctx, duk_uint8_t ptr, duk_size_t sz)

DUK_INTERNAL_DECL void	duk_push_lightfunc_name (duk_context ctx, duk_tval tv)

DUK_INTERNAL_DECL void	duk_push_lightfunc_tostring (duk_context ctx, duk_tval tv)

DUK_INTERNAL_DECL duk_hbufferobject *	duk_push_bufferobject_raw (duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx)

DUK_INTERNAL_DECL const char *	duk_push_string_readable (duk_context *ctx, duk_idx_t index)

DUK_INTERNAL_DECL const char *	duk_push_string_tval_readable (duk_context ctx, duk_tval tv)

DUK_INTERNAL_DECL duk_bool_t	duk_get_prop_stridx (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)

DUK_INTERNAL_DECL duk_bool_t	duk_put_prop_stridx (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)

DUK_INTERNAL_DECL duk_bool_t	duk_del_prop_stridx (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)

DUK_INTERNAL_DECL duk_bool_t	duk_has_prop_stridx (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)

DUK_INTERNAL_DECL duk_bool_t	duk_get_prop_stridx_boolean (duk_context ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t out_has_prop)

DUK_INTERNAL_DECL void	duk_xdef_prop (duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags)

DUK_INTERNAL_DECL void	duk_xdef_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index, duk_small_uint_t desc_flags)

DUK_INTERNAL_DECL void	duk_xdef_prop_stridx (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags)

DUK_INTERNAL_DECL void	duk_xdef_prop_stridx_builtin (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags)

DUK_INTERNAL_DECL void	duk_xdef_prop_stridx_thrower (duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags)

DUK_INTERNAL_DECL void	duk_set_length (duk_context *ctx, duk_idx_t index, duk_size_t length)

DUK_INTERNAL_DECL duk_ucodepoint_t	duk_hstring_char_code_at_raw (duk_hthread thr, duk_hstring h, duk_uint_t pos)

DUK_INTERNAL_DECL duk_hobject *	duk_hobject_alloc (duk_heap *heap, duk_uint_t hobject_flags)

DUK_INTERNAL_DECL duk_hcompiledfunction *	duk_hcompiledfunction_alloc (duk_heap *heap, duk_uint_t hobject_flags)

DUK_INTERNAL_DECL duk_hnativefunction *	duk_hnativefunction_alloc (duk_heap *heap, duk_uint_t hobject_flags)

DUK_INTERNAL duk_hbufferobject *	duk_hbufferobject_alloc (duk_heap *heap, duk_uint_t hobject_flags)

DUK_INTERNAL_DECL duk_hthread *	duk_hthread_alloc (duk_heap *heap, duk_uint_t hobject_flags)

DUK_INTERNAL_DECL void	duk_hobject_find_existing_entry (duk_heap heap, duk_hobject obj, duk_hstring key, duk_int_t e_idx, duk_int_t *h_idx)

DUK_INTERNAL_DECL duk_tval *	duk_hobject_find_existing_entry_tval_ptr (duk_heap heap, duk_hobject obj, duk_hstring *key)

DUK_INTERNAL_DECL duk_tval *	duk_hobject_find_existing_entry_tval_ptr_and_attrs (duk_heap heap, duk_hobject obj, duk_hstring key, duk_int_t out_attrs)

DUK_INTERNAL_DECL duk_tval *	duk_hobject_find_existing_array_entry_tval_ptr (duk_heap heap, duk_hobject obj, duk_uarridx_t i)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_get_own_propdesc (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_propdesc out_desc, duk_small_uint_t flags)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_getprop (duk_hthread thr, duk_tval tv_obj, duk_tval *tv_key)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_putprop (duk_hthread thr, duk_tval tv_obj, duk_tval tv_key, duk_tval tv_val, duk_bool_t throw_flag)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_delprop (duk_hthread thr, duk_tval tv_obj, duk_tval *tv_key, duk_bool_t throw_flag)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_hasprop (duk_hthread thr, duk_tval tv_obj, duk_tval *tv_key)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_delprop_raw (duk_hthread thr, duk_hobject obj, duk_hstring *key, duk_small_uint_t flags)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_hasprop_raw (duk_hthread thr, duk_hobject obj, duk_hstring *key)

DUK_INTERNAL_DECL void	duk_hobject_define_property_internal (duk_hthread thr, duk_hobject obj, duk_hstring *key, duk_small_uint_t flags)

DUK_INTERNAL_DECL void	duk_hobject_define_property_internal_arridx (duk_hthread thr, duk_hobject obj, duk_uarridx_t arr_idx, duk_small_uint_t flags)

DUK_INTERNAL_DECL void	duk_hobject_define_accessor_internal (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_hobject getter, duk_hobject *setter, duk_small_uint_t propflags)

DUK_INTERNAL_DECL void	duk_hobject_set_length (duk_hthread thr, duk_hobject obj, duk_uint32_t length)

DUK_INTERNAL_DECL void	duk_hobject_set_length_zero (duk_hthread thr, duk_hobject obj)

DUK_INTERNAL_DECL duk_uint32_t	duk_hobject_get_length (duk_hthread thr, duk_hobject obj)

DUK_INTERNAL_DECL void	duk_hobject_prepare_property_descriptor (duk_context ctx, duk_idx_t idx_in, duk_uint_t out_defprop_flags, duk_idx_t out_idx_value, duk_hobject out_getter, duk_hobject *out_setter)

DUK_INTERNAL_DECL void	duk_hobject_define_property_helper (duk_context ctx, duk_uint_t defprop_flags, duk_hobject obj, duk_hstring key, duk_idx_t idx_value, duk_hobject get, duk_hobject *set)

DUK_INTERNAL_DECL duk_ret_t	duk_hobject_object_get_own_property_descriptor (duk_context *ctx)

DUK_INTERNAL_DECL void	duk_hobject_object_seal_freeze_helper (duk_hthread thr, duk_hobject obj, duk_bool_t is_freeze)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_object_is_sealed_frozen_helper (duk_hthread thr, duk_hobject obj, duk_bool_t is_frozen)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_object_ownprop_helper (duk_context *ctx, duk_small_uint_t required_desc_flags)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_get_internal_value (duk_heap heap, duk_hobject obj, duk_tval *tv)

DUK_INTERNAL_DECL duk_hstring *	duk_hobject_get_internal_value_string (duk_heap heap, duk_hobject obj)

DUK_INTERNAL_DECL void	duk_hobject_compact_props (duk_hthread thr, duk_hobject obj)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_proxy_check (duk_hthread thr, duk_hobject obj, duk_hobject out_target, duk_hobject out_handler)

DUK_INTERNAL_DECL duk_hobject *	duk_hobject_resolve_proxy_target (duk_hthread thr, duk_hobject obj)

DUK_INTERNAL_DECL void	duk_hobject_enumerator_create (duk_context *ctx, duk_small_uint_t enum_flags)

DUK_INTERNAL_DECL duk_ret_t	duk_hobject_get_enumerated_keys (duk_context *ctx, duk_small_uint_t enum_flags)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_enumerator_next (duk_context *ctx, duk_bool_t get_value)

DUK_INTERNAL_DECL void	duk_hobject_set_prototype_updref (duk_hthread thr, duk_hobject h, duk_hobject *p)

DUK_INTERNAL_DECL void	duk_hobject_run_finalizer (duk_hthread thr, duk_hobject obj)

DUK_INTERNAL_DECL void	duk_hobject_pc2line_pack (duk_hthread thr, duk_compiler_instr instrs, duk_uint_fast32_t length)

DUK_INTERNAL_DECL duk_uint_fast32_t	duk_hobject_pc2line_query (duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc)

DUK_INTERNAL_DECL duk_bool_t	duk_hobject_prototype_chain_contains (duk_hthread thr, duk_hobject h, duk_hobject *p, duk_bool_t ignore_loop)

DUK_INTERNAL_DECL duk_uint_t	duk_hbufferobject_clamp_bytelength (duk_hbufferobject *h_bufobj, duk_uint_t len)

DUK_INTERNAL_DECL void	duk_hbufferobject_push_validated_read (duk_context ctx, duk_hbufferobject h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size)

DUK_INTERNAL_DECL void	duk_hbufferobject_validated_write (duk_context ctx, duk_hbufferobject h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size)

DUK_INTERNAL_DECL void	duk_hthread_copy_builtin_objects (duk_hthread thr_from, duk_hthread thr_to)

DUK_INTERNAL_DECL void	duk_hthread_create_builtin_objects (duk_hthread *thr)

DUK_INTERNAL_DECL duk_bool_t	duk_hthread_init_stacks (duk_heap heap, duk_hthread thr)

DUK_INTERNAL_DECL void	duk_hthread_terminate (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_hthread_callstack_grow (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_hthread_callstack_shrink_check (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_hthread_callstack_unwind (duk_hthread *thr, duk_size_t new_top)

DUK_INTERNAL_DECL void	duk_hthread_catchstack_grow (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_hthread_catchstack_shrink_check (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_hthread_catchstack_unwind (duk_hthread *thr, duk_size_t new_top)

DUK_INTERNAL_DECL duk_activation *	duk_hthread_get_current_activation (duk_hthread *thr)

DUK_INTERNAL_DECL void *	duk_hthread_get_valstack_ptr (duk_heap heap, void ud)

DUK_INTERNAL_DECL void *	duk_hthread_get_callstack_ptr (duk_heap heap, void ud)

DUK_INTERNAL_DECL void *	duk_hthread_get_catchstack_ptr (duk_heap heap, void ud)

DUK_INTERNAL_DECL duk_uint_fast32_t	duk_hthread_get_act_prev_pc (duk_hthread thr, duk_activation act)

DUK_INTERNAL_DECL void	duk_hthread_sync_currpc (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_hthread_sync_and_null_currpc (duk_hthread *thr)

DUK_INTERNAL_DECL duk_hbuffer *	duk_hbuffer_alloc (duk_heap heap, duk_size_t size, duk_small_uint_t flags, void *out_bufdata)

DUK_INTERNAL_DECL void *	duk_hbuffer_get_dynalloc_ptr (duk_heap heap, void ud)

DUK_INTERNAL_DECL void	duk_hbuffer_resize (duk_hthread thr, duk_hbuffer_dynamic buf, duk_size_t new_size)

DUK_INTERNAL_DECL void	duk_hbuffer_reset (duk_hthread thr, duk_hbuffer_dynamic buf)

DUK_INTERNAL_DECL duk_heap *	duk_heap_alloc (duk_alloc_function alloc_func, duk_realloc_function realloc_func, duk_free_function free_func, void *heap_udata, duk_fatal_function fatal_func)

DUK_INTERNAL_DECL void	duk_heap_free (duk_heap *heap)

DUK_INTERNAL_DECL void	duk_free_hobject_inner (duk_heap heap, duk_hobject h)

DUK_INTERNAL_DECL void	duk_free_hbuffer_inner (duk_heap heap, duk_hbuffer h)

DUK_INTERNAL_DECL void	duk_free_hstring_inner (duk_heap heap, duk_hstring h)

DUK_INTERNAL_DECL void	duk_heap_free_heaphdr_raw (duk_heap heap, duk_heaphdr hdr)

DUK_INTERNAL_DECL void	duk_heap_insert_into_heap_allocated (duk_heap heap, duk_heaphdr hdr)

DUK_INTERNAL_DECL void	duk_heap_remove_any_from_heap_allocated (duk_heap heap, duk_heaphdr hdr)

DUK_INTERNAL_DECL duk_hstring *	duk_heap_string_intern (duk_heap heap, const duk_uint8_t str, duk_uint32_t blen)

DUK_INTERNAL_DECL duk_hstring *	duk_heap_string_intern_checked (duk_hthread thr, const duk_uint8_t str, duk_uint32_t len)

DUK_INTERNAL_DECL duk_hstring *	duk_heap_string_intern_u32 (duk_heap *heap, duk_uint32_t val)

DUK_INTERNAL_DECL duk_hstring *	duk_heap_string_intern_u32_checked (duk_hthread *thr, duk_uint32_t val)

DUK_INTERNAL_DECL void	duk_heap_string_remove (duk_heap heap, duk_hstring h)

DUK_INTERNAL_DECL void	duk_heap_force_strtab_resize (duk_heap *heap)

DUK_INTERNAL void	duk_heap_free_strtab (duk_heap *heap)

DUK_INTERNAL_DECL void	duk_heap_strcache_string_remove (duk_heap heap, duk_hstring h)

DUK_INTERNAL_DECL duk_uint_fast32_t	duk_heap_strcache_offset_char2byte (duk_hthread thr, duk_hstring h, duk_uint_fast32_t char_offset)

DUK_INTERNAL_DECL void *	duk_default_alloc_function (void *udata, duk_size_t size)

DUK_INTERNAL_DECL void *	duk_default_realloc_function (void udata, void ptr, duk_size_t newsize)

DUK_INTERNAL_DECL void	duk_default_free_function (void udata, void ptr)

DUK_INTERNAL_DECL void *	duk_heap_mem_alloc (duk_heap *heap, duk_size_t size)

DUK_INTERNAL_DECL void *	duk_heap_mem_alloc_zeroed (duk_heap *heap, duk_size_t size)

DUK_INTERNAL_DECL void *	duk_heap_mem_realloc (duk_heap heap, void ptr, duk_size_t newsize)

DUK_INTERNAL_DECL void *	duk_heap_mem_realloc_indirect (duk_heap heap, duk_mem_getptr cb, void ud, duk_size_t newsize)

DUK_INTERNAL_DECL void	duk_heap_mem_free (duk_heap heap, void ptr)

DUK_INTERNAL_DECL void	duk_tval_decref (duk_hthread thr, duk_tval tv)

DUK_INTERNAL_DECL void	duk_heaphdr_decref (duk_hthread thr, duk_heaphdr h)

DUK_INTERNAL_DECL void	duk_heaphdr_decref_allownull (duk_hthread thr, duk_heaphdr h)

DUK_INTERNAL_DECL void	duk_heaphdr_refzero (duk_hthread thr, duk_heaphdr h)

DUK_INTERNAL_DECL void	duk_heaphdr_refcount_finalize (duk_hthread thr, duk_heaphdr hdr)

DUK_INTERNAL_DECL duk_bool_t	duk_heap_mark_and_sweep (duk_heap *heap, duk_small_uint_t flags)

DUK_INTERNAL_DECL duk_uint32_t	duk_heap_hashstring (duk_heap heap, const duk_uint8_t str, duk_size_t len)

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread thr, const char filename, duk_uint_t line_and_code, const char *msg))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_handle_error_fmt(duk_hthread thr, const char filename, duk_uint_t line_and_code, const char *fmt,...))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread thr, duk_errcode_t code, const char msg, const char *filename, duk_int_t line))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc))

DUK_INTERNAL_DECL void	duk_err_augment_error_create (duk_hthread thr, duk_hthread thr_callstack, const char *filename, duk_int_t line, duk_bool_t noblame_fileline)

DUK_INTERNAL_DECL void	duk_err_augment_error_throw (duk_hthread *thr)

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread thr, const char filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_api_index(duk_hthread thr, const char filename, duk_int_t linenumber, duk_idx_t index))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_api(duk_hthread thr, const char filename, duk_int_t linenumber, const char *message))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_unimplemented_defmsg(duk_hthread thr, const char filename, duk_int_t linenumber))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_default_fatal_handler(duk_context ctx, duk_errcode_t code, const char msg))

	DUK_NORETURN (DUK_INTERNAL_DECL void duk_default_panic_handler(duk_errcode_t code, const char *msg))

DUK_INTERNAL_DECL void	duk_err_setup_heap_ljstate (duk_hthread *thr, duk_small_int_t lj_type)

DUK_INTERNAL_DECL duk_hobject *	duk_error_prototype_from_code (duk_hthread *thr, duk_errcode_t err_code)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_get_xutf8_length (duk_ucodepoint_t cp)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_encode_xutf8 (duk_ucodepoint_t cp, duk_uint8_t *out)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_encode_cesu8 (duk_ucodepoint_t cp, duk_uint8_t *out)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_decode_xutf8 (duk_hthread thr, const duk_uint8_t ptr, const duk_uint8_t ptr_start, const duk_uint8_t ptr_end, duk_ucodepoint_t out_cp)

DUK_INTERNAL_DECL duk_ucodepoint_t	duk_unicode_decode_xutf8_checked (duk_hthread thr, const duk_uint8_t ptr, const duk_uint8_t ptr_start, const duk_uint8_t *ptr_end)

DUK_INTERNAL_DECL duk_size_t	duk_unicode_unvalidated_utf8_length (const duk_uint8_t *data, duk_size_t blen)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_is_whitespace (duk_codepoint_t cp)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_is_line_terminator (duk_codepoint_t cp)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_is_identifier_start (duk_codepoint_t cp)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_is_identifier_part (duk_codepoint_t cp)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_is_letter (duk_codepoint_t cp)

DUK_INTERNAL_DECL void	duk_unicode_case_convert_string (duk_hthread *thr, duk_bool_t uppercase)

DUK_INTERNAL_DECL duk_codepoint_t	duk_unicode_re_canonicalize_char (duk_hthread *thr, duk_codepoint_t cp)

DUK_INTERNAL_DECL duk_small_int_t	duk_unicode_re_is_wordchar (duk_codepoint_t cp)

DUK_INTERNAL_DECL duk_bool_t	duk_js_toboolean (duk_tval *tv)

DUK_INTERNAL_DECL duk_double_t	duk_js_tonumber (duk_hthread thr, duk_tval tv)

DUK_INTERNAL_DECL duk_double_t	duk_js_tointeger_number (duk_double_t x)

DUK_INTERNAL_DECL duk_double_t	duk_js_tointeger (duk_hthread thr, duk_tval tv)

DUK_INTERNAL_DECL duk_uint32_t	duk_js_touint32 (duk_hthread thr, duk_tval tv)

DUK_INTERNAL_DECL duk_int32_t	duk_js_toint32 (duk_hthread thr, duk_tval tv)

DUK_INTERNAL_DECL duk_uint16_t	duk_js_touint16 (duk_hthread thr, duk_tval tv)

DUK_INTERNAL_DECL duk_small_int_t	duk_js_to_arrayindex_raw_string (const duk_uint8_t str, duk_uint32_t blen, duk_uarridx_t out_idx)

DUK_INTERNAL_DECL duk_uarridx_t	duk_js_to_arrayindex_string_helper (duk_hstring *h)

DUK_INTERNAL_DECL duk_bool_t	duk_js_equals_helper (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y, duk_small_int_t flags)

DUK_INTERNAL_DECL duk_small_int_t	duk_js_data_compare (const duk_uint8_t buf1, const duk_uint8_t buf2, duk_size_t len1, duk_size_t len2)

DUK_INTERNAL_DECL duk_small_int_t	duk_js_string_compare (duk_hstring h1, duk_hstring h2)

DUK_INTERNAL_DECL duk_bool_t	duk_js_compare_helper (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y, duk_small_int_t flags)

DUK_INTERNAL_DECL duk_bool_t	duk_js_instanceof (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y)

DUK_INTERNAL_DECL duk_bool_t	duk_js_in (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y)

DUK_INTERNAL_DECL duk_hstring *	duk_js_typeof (duk_hthread thr, duk_tval tv_x)

DUK_INTERNAL_DECL duk_bool_t	duk_js_getvar_envrec (duk_hthread thr, duk_hobject env, duk_hstring *name, duk_bool_t throw_flag)

DUK_INTERNAL_DECL duk_bool_t	duk_js_getvar_activation (duk_hthread thr, duk_activation act, duk_hstring *name, duk_bool_t throw_flag)

DUK_INTERNAL_DECL void	duk_js_putvar_envrec (duk_hthread thr, duk_hobject env, duk_hstring name, duk_tval val, duk_bool_t strict)

DUK_INTERNAL_DECL void	duk_js_putvar_activation (duk_hthread thr, duk_activation act, duk_hstring name, duk_tval val, duk_bool_t strict)

DUK_INTERNAL_DECL duk_bool_t	duk_js_delvar_activation (duk_hthread thr, duk_activation act, duk_hstring *name)

DUK_INTERNAL_DECL duk_bool_t	duk_js_declvar_activation (duk_hthread thr, duk_activation act, duk_hstring name, duk_tval val, duk_small_int_t prop_flags, duk_bool_t is_func_decl)

DUK_INTERNAL_DECL void	duk_js_init_activation_environment_records_delayed (duk_hthread thr, duk_activation act)

DUK_INTERNAL_DECL void	duk_js_close_environment_record (duk_hthread thr, duk_hobject env, duk_hobject *func, duk_size_t regbase)

DUK_INTERNAL_DECL duk_hobject *	duk_create_activation_environment_record (duk_hthread thr, duk_hobject func, duk_size_t idx_bottom)

DUK_INTERNAL_DECL void	duk_js_push_closure (duk_hthread thr, duk_hcompiledfunction fun_temp, duk_hobject outer_var_env, duk_hobject outer_lex_env, duk_bool_t add_auto_proto)

DUK_INTERNAL_DECL duk_int_t	duk_handle_call_protected (duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags)

DUK_INTERNAL_DECL void	duk_handle_call_unprotected (duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags)

DUK_INTERNAL_DECL duk_int_t	duk_handle_safe_call (duk_hthread *thr, duk_safe_call_function func, duk_idx_t num_stack_args, duk_idx_t num_stack_res)

DUK_INTERNAL_DECL duk_bool_t	duk_handle_ecma_call_setup (duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags)

DUK_INTERNAL_DECL void	duk_js_execute_bytecode (duk_hthread *exec_thr)

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

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

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

DUK_INTERNAL_DECL duk_double_t	duk_bi_date_get_timeval_from_dparts (duk_double_t *dparts, duk_small_uint_t flags)

DUK_INTERNAL_DECL void	duk_bi_date_format_timeval (duk_double_t timeval, duk_uint8_t *out_buf)

DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_is_leap_year (duk_int_t year)

DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_timeval_in_valid_range (duk_double_t x)

DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_year_in_valid_range (duk_double_t year)

DUK_INTERNAL_DECL duk_bool_t	duk_bi_date_timeval_in_leeway_range (duk_double_t x)

DUK_INTERNAL_DECL duk_double_t	duk_bi_date_get_now_time (duk_context *ctx)

DUK_INTERNAL_DECL duk_int_t	duk_bi_date_get_local_tzoffset_gmtime (duk_double_t d)

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

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

DUK_INTERNAL int	duk_repl_fpclassify (double x)

DUK_INTERNAL int	duk_repl_signbit (double x)

DUK_INTERNAL int	duk_repl_isfinite (double x)

DUK_INTERNAL int	duk_repl_isnan (double x)

DUK_INTERNAL int	duk_repl_isinf (double x)

DUK_INTERNAL void	duk_err_handle_error_fmt (duk_hthread thr, const char filename, duk_uint_t line_and_code, const char *fmt,...)

DUK_INTERNAL void	duk_err_handle_error (duk_hthread thr, const char filename, duk_uint_t line_and_code, const char *msg)

DUK_INTERNAL void	duk_err_require_type_index (duk_hthread thr, const char filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name)

DUK_INTERNAL void	duk_err_range (duk_hthread thr, const char filename, duk_int_t linenumber, const char *message)

DUK_INTERNAL void	duk_err_api_index (duk_hthread thr, const char filename, duk_int_t linenumber, duk_idx_t index)

DUK_INTERNAL void	duk_err_api (duk_hthread thr, const char filename, duk_int_t linenumber, const char *message)

DUK_INTERNAL void	duk_err_unimplemented_defmsg (duk_hthread thr, const char filename, duk_int_t linenumber)

DUK_INTERNAL void	duk_err_internal_defmsg (duk_hthread thr, const char filename, duk_int_t linenumber)

DUK_INTERNAL void	duk_err_internal (duk_hthread thr, const char filename, duk_int_t linenumber, const char *message)

DUK_INTERNAL void	duk_err_alloc (duk_hthread thr, const char filename, duk_int_t linenumber, const char *message)

DUK_INTERNAL void	duk_default_fatal_handler (duk_context ctx, duk_errcode_t code, const char msg)

DUK_INTERNAL void	duk_default_panic_handler (duk_errcode_t code, const char *msg)

DUK_LOCAL duk_uint32_t	duk__uni_decode_value (duk_bitdecoder_ctx *bd_ctx)

DUK_LOCAL duk_small_int_t	duk__uni_range_match (const duk_uint8_t *unitab, duk_size_t unilen, duk_codepoint_t cp)

DUK_LOCAL duk_codepoint_t	duk__slow_case_conversion (duk_hthread thr, duk_bufwriter_ctx bw, duk_codepoint_t cp, duk_bitdecoder_ctx *bd_ctx)

DUK_LOCAL duk_codepoint_t	duk__case_transform_helper (duk_hthread thr, duk_bufwriter_ctx bw, duk_codepoint_t cp, duk_codepoint_t prev, duk_codepoint_t next, duk_bool_t uppercase)

DUK_EXTERNAL void *	duk_resize_buffer (duk_context *ctx, duk_idx_t index, duk_size_t new_size)

DUK_EXTERNAL void *	duk_steal_buffer (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL void	duk_config_buffer (duk_context ctx, duk_idx_t index, void ptr, duk_size_t len)

DUK_LOCAL duk_uint8_t *	duk__load_string_raw (duk_context ctx, duk_uint8_t p)

DUK_LOCAL duk_uint8_t *	duk__load_buffer_raw (duk_context ctx, duk_uint8_t p)

DUK_LOCAL duk_uint8_t *	duk__dump_hstring_raw (duk_uint8_t p, duk_hstring h)

DUK_LOCAL duk_uint8_t *	duk__dump_hbuffer_raw (duk_hthread thr, duk_uint8_t p, duk_hbuffer *h)

DUK_LOCAL duk_uint8_t *	duk__dump_string_prop (duk_hthread thr, duk_uint8_t p, duk_bufwriter_ctx bw_ctx, duk_hobject func, duk_small_uint_t stridx)

DUK_LOCAL duk_uint8_t *	duk__dump_buffer_prop (duk_hthread thr, duk_uint8_t p, duk_bufwriter_ctx bw_ctx, duk_hobject func, duk_small_uint_t stridx)

DUK_LOCAL duk_uint8_t *	duk__dump_uint32_prop (duk_hthread thr, duk_uint8_t p, duk_bufwriter_ctx bw_ctx, duk_hobject func, duk_small_uint_t stridx, duk_uint32_t def_value)

DUK_LOCAL duk_uint8_t *	duk__dump_varmap (duk_hthread thr, duk_uint8_t p, duk_bufwriter_ctx bw_ctx, duk_hobject func)

DUK_LOCAL duk_uint8_t *	duk__dump_formals (duk_hthread thr, duk_uint8_t p, duk_bufwriter_ctx bw_ctx, duk_hobject func)

static duk_uint8_t *	duk__dump_func (duk_context ctx, duk_hcompiledfunction func, duk_bufwriter_ctx bw_ctx, duk_uint8_t p)

static duk_uint8_t *	duk__load_func (duk_context ctx, duk_uint8_t p, duk_uint8_t *p_end)

DUK_EXTERNAL void	duk_dump_function (duk_context *ctx)

DUK_EXTERNAL void	duk_load_function (duk_context *ctx)

DUK_LOCAL void	duk__call_prop_prep_stack (duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs)

DUK_EXTERNAL void	duk_call (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL void	duk_call_method (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL void	duk_call_prop (duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs)

DUK_EXTERNAL duk_int_t	duk_pcall (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL duk_int_t	duk_pcall_method (duk_context *ctx, duk_idx_t nargs)

DUK_LOCAL duk_ret_t	duk__pcall_prop_raw (duk_context *ctx)

DUK_EXTERNAL duk_int_t	duk_pcall_prop (duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs)

DUK_EXTERNAL duk_int_t	duk_safe_call (duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets)

DUK_EXTERNAL void	duk_new (duk_context *ctx, duk_idx_t nargs)

DUK_LOCAL duk_ret_t	duk__pnew_helper (duk_context *ctx)

DUK_EXTERNAL duk_int_t	duk_pnew (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL duk_bool_t	duk_is_constructor_call (duk_context *ctx)

DUK_EXTERNAL duk_bool_t	duk_is_strict_call (duk_context *ctx)

DUK_EXTERNAL duk_int_t	duk_get_current_magic (duk_context *ctx)

DUK_EXTERNAL duk_int_t	duk_get_magic (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_set_magic (duk_context *ctx, duk_idx_t index, duk_int_t magic)

DUK_LOCAL const duk_uint8_t *	duk__prep_codec_arg (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_LOCAL void	duk__base64_encode_helper (const duk_uint8_t src, duk_size_t srclen, duk_uint8_t dst)

DUK_LOCAL duk_bool_t	duk__base64_decode_helper (const duk_uint8_t src, duk_size_t srclen, duk_uint8_t dst, duk_uint8_t **out_dst_final)

DUK_EXTERNAL const char *	duk_base64_encode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_base64_decode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL const char *	duk_hex_encode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_hex_decode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL const char *	duk_json_encode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_json_decode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_int_t	duk_eval_raw (duk_context ctx, const char src_buffer, duk_size_t src_length, duk_uint_t flags)

DUK_LOCAL duk_ret_t	duk__do_compile (duk_context *ctx)

DUK_EXTERNAL duk_int_t	duk_compile_raw (duk_context ctx, const char src_buffer, duk_size_t src_length, duk_uint_t flags)

DUK_EXTERNAL void	duk_push_context_dump (duk_context *ctx)

DUK_EXTERNAL void	duk_debugger_attach_custom (duk_context ctx, duk_debug_read_function read_cb, duk_debug_write_function write_cb, duk_debug_peek_function peek_cb, duk_debug_read_flush_function read_flush_cb, duk_debug_write_flush_function write_flush_cb, duk_debug_request_function request_cb, duk_debug_detached_function detached_cb, void udata)

DUK_EXTERNAL void	duk_debugger_detach (duk_context *ctx)

DUK_EXTERNAL void	duk_debugger_cooperate (duk_context *ctx)

DUK_EXTERNAL duk_bool_t	duk_debugger_notify (duk_context *ctx, duk_idx_t nvalues)

DUK_EXTERNAL void	duk_debugger_pause (duk_context *ctx)

DUK_EXTERNAL duk_context *	duk_create_heap (duk_alloc_function alloc_func, duk_realloc_function realloc_func, duk_free_function free_func, void *heap_udata, duk_fatal_function fatal_handler)

DUK_EXTERNAL void	duk_destroy_heap (duk_context *ctx)

DUK_EXTERNAL void	duk_suspend (duk_context ctx, duk_thread_state state)

DUK_EXTERNAL void	duk_resume (duk_context ctx, const duk_thread_state state)

DUK_EXTERNAL void	duk_set_global_object (duk_context *ctx)

DUK_EXTERNAL void	duk_log_va (duk_context ctx, duk_int_t level, const char fmt, va_list ap)

DUK_EXTERNAL void	duk_log (duk_context ctx, duk_int_t level, const char fmt,...)

DUK_EXTERNAL void *	duk_alloc_raw (duk_context *ctx, duk_size_t size)

DUK_EXTERNAL void	duk_free_raw (duk_context ctx, void ptr)

DUK_EXTERNAL void *	duk_realloc_raw (duk_context ctx, void ptr, duk_size_t size)

DUK_EXTERNAL void *	duk_alloc (duk_context *ctx, duk_size_t size)

DUK_EXTERNAL void	duk_free (duk_context ctx, void ptr)

DUK_EXTERNAL void *	duk_realloc (duk_context ctx, void ptr, duk_size_t size)

DUK_EXTERNAL void	duk_get_memory_functions (duk_context ctx, duk_memory_functions out_funcs)

DUK_EXTERNAL void	duk_gc (duk_context *ctx, duk_uint_t flags)

DUK_EXTERNAL duk_bool_t	duk_get_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL duk_bool_t	duk_get_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL duk_bool_t	duk_get_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_LOCAL duk_bool_t	duk__put_prop_shared (duk_context *ctx, duk_idx_t obj_idx, duk_idx_t idx_key)

DUK_EXTERNAL duk_bool_t	duk_put_prop (duk_context *ctx, duk_idx_t obj_idx)

DUK_EXTERNAL duk_bool_t	duk_put_prop_string (duk_context ctx, duk_idx_t obj_idx, const char key)

DUK_EXTERNAL duk_bool_t	duk_put_prop_index (duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx)

DUK_EXTERNAL duk_bool_t	duk_del_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL duk_bool_t	duk_del_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL duk_bool_t	duk_del_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_EXTERNAL duk_bool_t	duk_has_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL duk_bool_t	duk_has_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL duk_bool_t	duk_has_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_EXTERNAL void	duk_def_prop (duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags)

DUK_EXTERNAL void	duk_compact (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL void	duk_enum (duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags)

DUK_EXTERNAL duk_bool_t	duk_next (duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value)

DUK_EXTERNAL void	duk_put_function_list (duk_context ctx, duk_idx_t obj_index, const duk_function_list_entry funcs)

DUK_EXTERNAL void	duk_put_number_list (duk_context ctx, duk_idx_t obj_index, const duk_number_list_entry numbers)

DUK_EXTERNAL duk_bool_t	duk_get_global_string (duk_context ctx, const char key)

DUK_EXTERNAL duk_bool_t	duk_put_global_string (duk_context ctx, const char key)

DUK_EXTERNAL void	duk_get_prototype (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_set_prototype (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_get_finalizer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_set_finalizer (duk_context *ctx, duk_idx_t index)

DUK_LOCAL_DECL duk_idx_t	duk__push_c_function_raw (duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags)

DUK_LOCAL_DECL duk_heaphdr *	duk__get_tagged_heaphdr_raw (duk_context *ctx, duk_idx_t index, duk_uint_t tag)

DUK_LOCAL duk_int_t	duk__api_coerce_d2i (duk_context *ctx, duk_idx_t index, duk_bool_t require)

DUK_LOCAL duk_uint_t	duk__api_coerce_d2ui (duk_context *ctx, duk_idx_t index, duk_bool_t require)

DUK_EXTERNAL duk_idx_t	duk_normalize_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_idx_t	duk_require_normalize_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_valid_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_require_valid_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_idx_t	duk_get_top (duk_context *ctx)

DUK_EXTERNAL void	duk_set_top (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_idx_t	duk_get_top_index (duk_context *ctx)

DUK_EXTERNAL duk_idx_t	duk_require_top_index (duk_context *ctx)

DUK_LOCAL duk_bool_t	duk__resize_valstack (duk_context *ctx, duk_size_t new_size)

DUK_EXTERNAL duk_bool_t	duk_check_stack (duk_context *ctx, duk_idx_t extra)

DUK_EXTERNAL void	duk_require_stack (duk_context *ctx, duk_idx_t extra)

DUK_EXTERNAL duk_bool_t	duk_check_stack_top (duk_context *ctx, duk_idx_t top)

DUK_EXTERNAL void	duk_require_stack_top (duk_context *ctx, duk_idx_t top)

DUK_EXTERNAL void	duk_swap (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL void	duk_swap_top (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_dup (duk_context *ctx, duk_idx_t from_index)

DUK_EXTERNAL void	duk_dup_top (duk_context *ctx)

DUK_EXTERNAL void	duk_insert (duk_context *ctx, duk_idx_t to_index)

DUK_EXTERNAL void	duk_replace (duk_context *ctx, duk_idx_t to_index)

DUK_EXTERNAL void	duk_copy (duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index)

DUK_EXTERNAL void	duk_remove (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_xcopymove_raw (duk_context to_ctx, duk_context from_ctx, duk_idx_t count, duk_bool_t is_copy)

DUK_EXTERNAL void	duk_require_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_require_null (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_get_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_require_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_double_t	duk_get_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_double_t	duk_require_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_int_t	duk_get_int (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_uint_t	duk_get_uint (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_int_t	duk_require_int (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_uint_t	duk_require_uint (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL const char *	duk_get_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL const char *	duk_require_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL const char *	duk_get_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL const char *	duk_require_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void *	duk_get_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void *	duk_require_pointer (duk_context *ctx, duk_idx_t index)

DUK_LOCAL void *	duk__get_buffer_helper (duk_context ctx, duk_idx_t index, duk_size_t out_size, duk_bool_t throw_flag)

DUK_EXTERNAL void *	duk_get_buffer (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL void *	duk_require_buffer (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_LOCAL void *	duk__get_buffer_data_helper (duk_context ctx, duk_idx_t index, duk_size_t out_size, duk_bool_t throw_flag)

DUK_EXTERNAL void *	duk_get_buffer_data (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL void *	duk_require_buffer_data (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL duk_c_function	duk_get_c_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_c_function	duk_require_c_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_require_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_context *	duk_get_context (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_context *	duk_require_context (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void *	duk_get_heapptr (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void *	duk_require_heapptr (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_size_t	duk_get_length (duk_context *ctx, duk_idx_t index)

DUK_LOCAL duk_bool_t	duk__defaultvalue_coerce_attempt (duk_context *ctx, duk_idx_t index, duk_small_int_t func_stridx)

DUK_EXTERNAL void	duk_to_defaultvalue (duk_context *ctx, duk_idx_t index, duk_int_t hint)

DUK_EXTERNAL void	duk_to_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_to_null (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_to_primitive (duk_context *ctx, duk_idx_t index, duk_int_t hint)

DUK_EXTERNAL duk_bool_t	duk_to_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_double_t	duk_to_number (duk_context *ctx, duk_idx_t index)

DUK_LOCAL duk_double_t	duk__to_int_uint_helper (duk_context *ctx, duk_idx_t index, duk__toint_coercer coerce_func)

DUK_EXTERNAL duk_int_t	duk_to_int (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_uint_t	duk_to_uint (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_int32_t	duk_to_int32 (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_uint32_t	duk_to_uint32 (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_uint16_t	duk_to_uint16 (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL const char *	duk_to_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_LOCAL duk_ret_t	duk__safe_to_string_raw (duk_context *ctx)

DUK_EXTERNAL const char *	duk_safe_to_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL const char *	duk_to_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void *	duk_to_buffer_raw (duk_context ctx, duk_idx_t index, duk_size_t out_size, duk_uint_t mode)

DUK_EXTERNAL void *	duk_to_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_to_object (duk_context *ctx, duk_idx_t index)

DUK_LOCAL duk_bool_t	duk__tag_check (duk_context *ctx, duk_idx_t index, duk_small_uint_t tag)

DUK_LOCAL duk_bool_t	duk__obj_flag_any_default_false (duk_context *ctx, duk_idx_t index, duk_uint_t flag_mask)

DUK_EXTERNAL duk_int_t	duk_get_type (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_check_type (duk_context *ctx, duk_idx_t index, duk_int_t type)

DUK_EXTERNAL duk_uint_t	duk_get_type_mask (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_check_type_mask (duk_context *ctx, duk_idx_t index, duk_uint_t mask)

DUK_EXTERNAL duk_bool_t	duk_is_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_null (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_null_or_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_nan (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_object (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_buffer_data (duk_context *ctx, duk_idx_t idx)

DUK_EXTERNAL duk_bool_t	duk_is_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_lightfunc (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_array (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_c_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_ecmascript_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_bound_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_thread (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_fixed_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_dynamic_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_bool_t	duk_is_external_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_errcode_t	duk_get_error_code (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL void	duk_push_undefined (duk_context *ctx)

DUK_EXTERNAL void	duk_push_null (duk_context *ctx)

DUK_EXTERNAL void	duk_push_boolean (duk_context *ctx, duk_bool_t val)

DUK_EXTERNAL void	duk_push_true (duk_context *ctx)

DUK_EXTERNAL void	duk_push_false (duk_context *ctx)

DUK_EXTERNAL void	duk_push_number (duk_context *ctx, duk_double_t val)

DUK_EXTERNAL void	duk_push_int (duk_context *ctx, duk_int_t val)

DUK_EXTERNAL void	duk_push_uint (duk_context *ctx, duk_uint_t val)

DUK_EXTERNAL void	duk_push_nan (duk_context *ctx)

DUK_EXTERNAL const char *	duk_push_lstring (duk_context ctx, const char str, duk_size_t len)

DUK_EXTERNAL const char *	duk_push_string (duk_context ctx, const char str)

DUK_EXTERNAL const char *	duk_push_string_file_raw (duk_context ctx, const char path, duk_uint_t flags)

DUK_EXTERNAL void	duk_push_pointer (duk_context ctx, void val)

DUK_LOCAL void	duk__push_this_helper (duk_context *ctx, duk_small_uint_t check_object_coercible)

DUK_EXTERNAL void	duk_push_this (duk_context *ctx)

DUK_EXTERNAL void	duk_push_current_function (duk_context *ctx)

DUK_EXTERNAL void	duk_push_current_thread (duk_context *ctx)

DUK_EXTERNAL void	duk_push_global_object (duk_context *ctx)

DUK_LOCAL void	duk__push_stash (duk_context *ctx)

DUK_EXTERNAL void	duk_push_heap_stash (duk_context *ctx)

DUK_EXTERNAL void	duk_push_global_stash (duk_context *ctx)

DUK_EXTERNAL void	duk_push_thread_stash (duk_context ctx, duk_context target_ctx)

DUK_LOCAL duk_int_t	duk__try_push_vsprintf (duk_context ctx, void buf, duk_size_t sz, const char *fmt, va_list ap)

DUK_EXTERNAL const char *	duk_push_vsprintf (duk_context ctx, const char fmt, va_list ap)

DUK_EXTERNAL const char *	duk_push_sprintf (duk_context ctx, const char fmt,...)

DUK_EXTERNAL duk_idx_t	duk_push_object (duk_context *ctx)

DUK_EXTERNAL duk_idx_t	duk_push_array (duk_context *ctx)

DUK_EXTERNAL duk_idx_t	duk_push_thread_raw (duk_context *ctx, duk_uint_t flags)

DUK_EXTERNAL duk_idx_t	duk_push_c_function (duk_context *ctx, duk_c_function func, duk_int_t nargs)

DUK_EXTERNAL duk_idx_t	duk_push_c_lightfunc (duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic)

DUK_EXTERNAL void	duk_push_buffer_object (duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags)

DUK_EXTERNAL duk_idx_t	duk_push_error_object_va_raw (duk_context ctx, duk_errcode_t err_code, const char filename, duk_int_t line, const char *fmt, va_list ap)

DUK_EXTERNAL duk_idx_t	duk_push_error_object_raw (duk_context ctx, duk_errcode_t err_code, const char filename, duk_int_t line, const char *fmt,...)

DUK_EXTERNAL duk_idx_t	duk_push_error_object_stash (duk_context ctx, duk_errcode_t err_code, const char fmt,...)

DUK_EXTERNAL void *	duk_push_buffer_raw (duk_context *ctx, duk_size_t size, duk_small_uint_t flags)

DUK_EXTERNAL duk_idx_t	duk_push_heapptr (duk_context ctx, void ptr)

DUK_EXTERNAL void	duk_pop_n (duk_context *ctx, duk_idx_t count)

DUK_EXTERNAL void	duk_pop (duk_context *ctx)

DUK_EXTERNAL void	duk_pop_2 (duk_context *ctx)

DUK_EXTERNAL void	duk_pop_3 (duk_context *ctx)

DUK_EXTERNAL void	duk_throw (duk_context *ctx)

DUK_EXTERNAL void	duk_fatal (duk_context ctx, duk_errcode_t err_code, const char err_msg)

DUK_EXTERNAL void	duk_error_va_raw (duk_context ctx, duk_errcode_t err_code, const char filename, duk_int_t line, const char *fmt, va_list ap)

DUK_EXTERNAL void	duk_error_raw (duk_context ctx, duk_errcode_t err_code, const char filename, duk_int_t line, const char *fmt,...)

DUK_EXTERNAL void	duk_error_stash (duk_context ctx, duk_errcode_t err_code, const char fmt,...)

DUK_EXTERNAL duk_bool_t	duk_equals (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL duk_bool_t	duk_strict_equals (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL duk_bool_t	duk_instanceof (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_LOCAL void	duk__push_hstring_readable_unicode (duk_context ctx, duk_hstring h_input)

DUK_LOCAL void	duk__concat_and_join_helper (duk_context *ctx, duk_idx_t count_in, duk_bool_t is_join)

DUK_EXTERNAL void	duk_concat (duk_context *ctx, duk_idx_t count)

DUK_EXTERNAL void	duk_join (duk_context *ctx, duk_idx_t count)

DUK_EXTERNAL void	duk_decode_string (duk_context ctx, duk_idx_t index, duk_decode_char_function callback, void udata)

DUK_EXTERNAL void	duk_map_string (duk_context ctx, duk_idx_t index, duk_map_char_function callback, void udata)

DUK_EXTERNAL void	duk_substring (duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset)

DUK_EXTERNAL void	duk_trim (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL duk_codepoint_t	duk_char_code_at (duk_context *ctx, duk_idx_t index, duk_size_t char_offset)

DUK_EXTERNAL void	duk_get_var (duk_context *ctx)

DUK_EXTERNAL void	duk_put_var (duk_context *ctx)

DUK_EXTERNAL duk_bool_t	duk_del_var (duk_context *ctx)

DUK_EXTERNAL duk_bool_t	duk_has_var (duk_context *ctx)

DUK_LOCAL duk_uint32_t	duk__push_this_obj_len_u32 (duk_context *ctx)

DUK_LOCAL duk_uint32_t	duk__push_this_obj_len_u32_limited (duk_context *ctx)

DUK_LOCAL duk_small_int_t	duk__array_sort_compare (duk_context *ctx, duk_int_t idx1, duk_int_t idx2)

DUK_LOCAL void	duk__array_sort_swap (duk_context *ctx, duk_int_t l, duk_int_t r)

DUK_LOCAL void	duk__array_qsort (duk_context *ctx, duk_int_t lo, duk_int_t hi)

DUK_LOCAL duk_hbufferobject *	duk__getrequire_bufobj_this (duk_context *ctx, duk_bool_t throw_flag)

DUK_LOCAL duk_hbufferobject *	duk__get_bufobj_this (duk_context *ctx)

DUK_LOCAL duk_hbufferobject *	duk__require_bufobj_this (duk_context *ctx)

DUK_LOCAL duk_hbufferobject *	duk__require_bufobj_value (duk_context *ctx, duk_idx_t index)

DUK_LOCAL void	duk__set_bufobj_buffer (duk_context ctx, duk_hbufferobject h_bufobj, duk_hbuffer *h_val)

DUK_LOCAL duk_hbufferobject *	duk__push_arraybuffer_with_length (duk_context *ctx, duk_uint_t len)

DUK_LOCAL void	duk__resolve_offset_opt_length (duk_context ctx, duk_hbufferobject h_bufarg, duk_idx_t idx_offset, duk_idx_t idx_length, duk_uint_t out_offset, duk_uint_t out_length, duk_bool_t throw_flag)

DUK_LOCAL void	duk__clamp_startend_nonegidx_noshift (duk_context ctx, duk_hbufferobject h_bufobj, duk_idx_t idx_start, duk_idx_t idx_end, duk_int_t out_start_offset, duk_int_t out_end_offset)

DUK_LOCAL void	duk__clamp_startend_negidx_shifted (duk_context ctx, duk_hbufferobject h_bufobj, duk_idx_t idx_start, duk_idx_t idx_end, duk_int_t out_start_offset, duk_int_t out_end_offset)

DUK_LOCAL_DECL duk_double_t	duk__push_this_get_timeval_tzoffset (duk_context ctx, duk_small_uint_t flags, duk_int_t out_tzoffset)

DUK_LOCAL_DECL duk_double_t	duk__push_this_get_timeval (duk_context *ctx, duk_small_uint_t flags)

DUK_LOCAL_DECL void	duk__twodigit_year_fixup (duk_context *ctx, duk_idx_t idx_val)

DUK_LOCAL_DECL duk_ret_t	duk__set_this_timeval_from_dparts (duk_context ctx, duk_double_t dparts, duk_small_uint_t flags)

DUK_LOCAL duk_bool_t	duk__parse_string_iso8601_subset (duk_context ctx, const char str)

DUK_LOCAL duk_ret_t	duk__parse_string (duk_context ctx, const char str)

DUK_LOCAL duk_double_t	duk__timeclip (duk_double_t x)

DUK_LOCAL duk_int_t	duk__div_floor (duk_int_t a, duk_int_t b)

DUK_LOCAL duk_int_t	duk__day_from_year (duk_int_t year)

DUK_LOCAL duk_int_t	duk__year_from_day (duk_int_t day, duk_small_int_t *out_day_within_year)

DUK_LOCAL duk_double_t	duk__make_day (duk_double_t year, duk_double_t month, duk_double_t day)

DUK_LOCAL void	duk__format_parts_iso8601 (duk_int_t parts, duk_int_t tzoffset, duk_small_uint_t flags, duk_uint8_t out_buf)

DUK_LOCAL duk_ret_t	duk__to_string_helper (duk_context *ctx, duk_small_uint_t flags)

DUK_LOCAL duk_ret_t	duk__get_part_helper (duk_context *ctx, duk_small_uint_t flags_and_idx)

DUK_LOCAL duk_ret_t	duk__set_part_helper (duk_context *ctx, duk_small_uint_t flags_and_maxnargs)

DUK_LOCAL void	duk__set_parts_from_args (duk_context ctx, duk_double_t dparts, duk_idx_t nargs)

DUK_LOCAL duk_small_uint_t	duk__date_get_indirect_magic (duk_context *ctx)

DUK_LOCAL duk_ret_t	duk__error_getter_helper (duk_context *ctx, duk_small_int_t output_type)

DUK_LOCAL duk_ret_t	duk__error_setter_helper (duk_context *ctx, duk_small_uint_t stridx_key)

DUK_LOCAL duk_small_int_t	duk__decode_hex_escape (const duk_uint8_t *p, duk_small_int_t n)

DUK_LOCAL int	duk__transform_helper (duk_context ctx, duk__transform_callback callback, const void udata)

DUK_LOCAL void	duk__transform_callback_encode_uri (duk__transform_context tfm_ctx, const void udata, duk_codepoint_t cp)

DUK_LOCAL void	duk__transform_callback_decode_uri (duk__transform_context tfm_ctx, const void udata, duk_codepoint_t cp)

DUK_LOCAL void	duk__transform_callback_escape (duk__transform_context tfm_ctx, const void udata, duk_codepoint_t cp)

DUK_LOCAL void	duk__transform_callback_unescape (duk__transform_context tfm_ctx, const void udata, duk_codepoint_t cp)

DUK_LOCAL void	duk__bi_global_resolve_module_id (duk_context ctx, const char req_id, const char *mod_id)

DUK_LOCAL_DECL void	duk__dec_syntax_error (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_eat_white (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL duk_uint8_t	duk__dec_peek (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL duk_uint8_t	duk__dec_get (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL duk_uint8_t	duk__dec_get_nonwhite (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL duk_uint_fast32_t	duk__dec_decode_hex_escape (duk_json_dec_ctx *js_ctx, duk_small_uint_t n)

DUK_LOCAL_DECL void	duk__dec_req_stridx (duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx)

DUK_LOCAL_DECL void	duk__dec_string (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_plain_string (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_pointer (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_buffer (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_number (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_objarr_entry (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_objarr_exit (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_object (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_array (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_value (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__dec_reviver_walk (duk_json_dec_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__emit_1 (duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch)

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

DUK_LOCAL_DECL void	duk__unemit_1 (duk_json_enc_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__emit_hstring (duk_json_enc_ctx js_ctx, duk_hstring h)

DUK_LOCAL_DECL void	duk__emit_stridx (duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx)

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

DUK_LOCAL_DECL void	duk__enc_key_autoquote (duk_json_enc_ctx js_ctx, duk_hstring k)

DUK_LOCAL_DECL void	duk__enc_quote_string (duk_json_enc_ctx js_ctx, duk_hstring h_str)

DUK_LOCAL_DECL void	duk__enc_objarr_entry (duk_json_enc_ctx js_ctx, duk_idx_t entry_top)

DUK_LOCAL_DECL void	duk__enc_objarr_exit (duk_json_enc_ctx js_ctx, duk_idx_t entry_top)

DUK_LOCAL_DECL void	duk__enc_object (duk_json_enc_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__enc_array (duk_json_enc_ctx *js_ctx)

DUK_LOCAL_DECL duk_bool_t	duk__enc_value (duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder)

DUK_LOCAL_DECL duk_bool_t	duk__enc_allow_into_proplist (duk_tval *tv)

DUK_LOCAL_DECL void	duk__enc_double (duk_json_enc_ctx *js_ctx)

DUK_LOCAL_DECL void	duk__enc_buffer (duk_json_enc_ctx js_ctx, duk_hbuffer h)

DUK_LOCAL_DECL void	duk__enc_pointer (duk_json_enc_ctx js_ctx, void ptr)

DUK_LOCAL_DECL void	duk__enc_bufferobject (duk_json_enc_ctx js_ctx, duk_hbufferobject h_bufobj)

DUK_LOCAL_DECL void	duk__enc_newline_indent (duk_json_enc_ctx *js_ctx, duk_int_t depth)

DUK_LOCAL duk_small_int_t	duk__dec_string_escape (duk_json_dec_ctx js_ctx, duk_uint8_t *ext_p)

DUK_LOCAL void	duk__emit_cstring (duk_json_enc_ctx js_ctx, const char str)

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

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

DUK_LOCAL duk_ret_t	duk__math_minmax (duk_context *ctx, duk_double_t initial, duk__two_arg_func min_max)

DUK_LOCAL double	duk__fmin_fixed (double x, double y)

DUK_LOCAL double	duk__fmax_fixed (double x, double y)

DUK_LOCAL double	duk__round_fixed (double x)

DUK_LOCAL double	duk__pow_fixed (double x, double y)

DUK_LOCAL double	duk__fabs (double x)

DUK_LOCAL double	duk__acos (double x)

DUK_LOCAL double	duk__asin (double x)

DUK_LOCAL double	duk__atan (double x)

DUK_LOCAL double	duk__ceil (double x)

DUK_LOCAL double	duk__cos (double x)

DUK_LOCAL double	duk__exp (double x)

DUK_LOCAL double	duk__floor (double x)

DUK_LOCAL double	duk__log (double x)

DUK_LOCAL double	duk__sin (double x)

DUK_LOCAL double	duk__sqrt (double x)

DUK_LOCAL double	duk__tan (double x)

DUK_LOCAL double	duk__atan2 (double x, double y)

DUK_LOCAL duk_double_t	duk__push_this_number_plain (duk_context *ctx)

DUK_LOCAL void	duk__get_this_regexp (duk_context *ctx)

DUK_LOCAL void	duk__to_regexp_helper (duk_context *ctx, duk_idx_t index, duk_bool_t force_new)

DUK_LOCAL void	duk__err_augment_user (duk_hthread *thr, duk_small_uint_t stridx_cb)

DUK_LOCAL void	duk__add_traceback (duk_hthread thr, duk_hthread thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline)

DUK_LOCAL void	duk__add_compiler_error_line (duk_hthread *thr)

DUK_LOCAL void	duk__err_augment_builtin_create (duk_hthread thr, duk_hthread thr_callstack, const char c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject obj)

DUK_INTERNAL void	duk_err_longjmp (duk_hthread *thr)

DUK_INTERNAL void	duk_err_create_and_throw (duk_hthread thr, duk_errcode_t code, const char msg, const char *filename, duk_int_t line)

DUK_INTERNAL void	duk_error_throw_from_negative_rc (duk_hthread *thr, duk_ret_t rc)

DUK_LOCAL void	duk__free_allocated (duk_heap *heap)

DUK_LOCAL void	duk__free_refzero_list (duk_heap *heap)

DUK_LOCAL void	duk__free_markandsweep_finalize_list (duk_heap *heap)

DUK_LOCAL void	duk__free_stringtable (duk_heap *heap)

DUK_LOCAL void	duk__free_run_finalizers (duk_heap *heap)

DUK_LOCAL duk_bool_t	duk__init_heap_strings (duk_heap *heap)

DUK_LOCAL duk_bool_t	duk__init_heap_thread (duk_heap *heap)

DUK_LOCAL_DECL void	duk__mark_heaphdr (duk_heap heap, duk_heaphdr h)

DUK_LOCAL_DECL void	duk__mark_tval (duk_heap heap, duk_tval tv)

DUK_LOCAL duk_hthread *	duk__get_temp_hthread (duk_heap *heap)

DUK_LOCAL void	duk__mark_hstring (duk_heap heap, duk_hstring h)

DUK_LOCAL void	duk__mark_hobject (duk_heap heap, duk_hobject h)

DUK_LOCAL void	duk__mark_roots_heap (duk_heap *heap)

DUK_LOCAL void	duk__mark_refzero_list (duk_heap *heap)

DUK_LOCAL void	duk__mark_finalizable (duk_heap *heap)

DUK_LOCAL void	duk__mark_finalize_list (duk_heap *heap)

DUK_LOCAL void	duk__handle_temproot (duk_heap heap, duk_heaphdr hdr)

DUK_LOCAL void	duk__mark_temproots_by_heap_scan (duk_heap *heap)

DUK_LOCAL void	duk__finalize_refcounts (duk_heap *heap)

DUK_LOCAL void	duk__clear_refzero_list_flags (duk_heap *heap)

DUK_LOCAL void	duk__clear_finalize_list_flags (duk_heap *heap)

DUK_LOCAL void	duk__sweep_stringtable_probe (duk_heap heap, duk_size_t out_count_keep)

DUK_LOCAL void	duk__sweep_heap (duk_heap heap, duk_int_t flags, duk_size_t out_count_keep)

DUK_LOCAL void	duk__run_object_finalizers (duk_heap *heap, duk_small_uint_t flags)

DUK_LOCAL int	duk__protected_compact_object (duk_context *ctx)

DUK_LOCAL void	duk__compact_object_list (duk_heap heap, duk_hthread thr, duk_heaphdr *start)

DUK_LOCAL void	duk__compact_objects (duk_heap *heap)

DUK_LOCAL void	duk__run_voluntary_gc (duk_heap *heap)

DUK_LOCAL void	duk__queue_refzero (duk_heap heap, duk_heaphdr hdr)

DUK_LOCAL void	duk__refcount_finalize_hobject (duk_hthread thr, duk_hobject h)

DUK_LOCAL void	duk__refzero_free_pending (duk_hthread *thr)

DUK_LOCAL const duk_uint8_t *	duk__scan_forwards (const duk_uint8_t p, const duk_uint8_t q, duk_uint_fast32_t n)

DUK_LOCAL const duk_uint8_t *	duk__scan_backwards (const duk_uint8_t p, const duk_uint8_t q, duk_uint_fast32_t n)

DUK_LOCAL duk_hstring *	duk__alloc_init_hstring (duk_heap heap, const duk_uint8_t str, duk_uint32_t blen, duk_uint32_t strhash, const duk_uint8_t *extdata)

DUK_LOCAL duk_int_t	duk__count_used_probe (duk_heap *heap)

DUK_LOCAL void	duk__insert_hstring_probe (duk_heap heap, duk_hstring entries, duk_uint32_t size, duk_uint32_t p_used, duk_hstring *h)

DUK_LOCAL duk_hstring *	duk__find_matching_string_probe (duk_heap heap, duk_hstring entries, duk_uint32_t size, const duk_uint8_t str, duk_uint32_t blen, duk_uint32_t strhash)

DUK_LOCAL void	duk__remove_matching_hstring_probe (duk_heap heap, duk_hstring entries, duk_uint32_t size, duk_hstring h)

DUK_LOCAL duk_bool_t	duk__resize_strtab_raw_probe (duk_heap *heap, duk_uint32_t new_size)

DUK_LOCAL duk_bool_t	duk__resize_strtab_probe (duk_heap *heap)

DUK_LOCAL duk_bool_t	duk__recheck_strtab_size_probe (duk_heap *heap, duk_uint32_t new_used)

DUK_LOCAL duk_hstring *	duk__do_intern (duk_heap heap, const duk_uint8_t str, duk_uint32_t blen, duk_uint32_t strhash)

DUK_LOCAL duk_hstring *	duk__do_lookup (duk_heap heap, const duk_uint8_t str, duk_uint32_t blen, duk_uint32_t *out_strhash)

DUK_LOCAL void	duk__init_object_parts (duk_heap heap, duk_hobject obj, duk_uint_t hobject_flags)

DUK_LOCAL void	duk__sort_array_indices (duk_hthread thr, duk_hobject h_obj)

DUK_LOCAL duk_ret_t	duk__finalize_helper (duk_context *ctx)

DUK_LOCAL duk_uint_fast32_t	duk__hobject_pc2line_query_raw (duk_hthread thr, duk_hbuffer_fixed buf, duk_uint_fast32_t pc)

DUK_LOCAL_DECL duk_bool_t	duk__check_arguments_map_for_get (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_propdesc temp_desc)

DUK_LOCAL_DECL void	duk__check_arguments_map_for_put (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_propdesc temp_desc, duk_bool_t throw_flag)

DUK_LOCAL_DECL void	duk__check_arguments_map_for_delete (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_propdesc temp_desc)

DUK_LOCAL_DECL duk_bool_t	duk__handle_put_array_length_smaller (duk_hthread thr, duk_hobject obj, duk_uint32_t old_len, duk_uint32_t new_len, duk_bool_t force_flag, duk_uint32_t *out_result_len)

DUK_LOCAL_DECL duk_bool_t	duk__handle_put_array_length (duk_hthread thr, duk_hobject obj)

DUK_LOCAL_DECL duk_bool_t	duk__get_propdesc (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_propdesc out_desc, duk_small_uint_t flags)

DUK_LOCAL_DECL duk_bool_t	duk__get_own_propdesc_raw (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_uint32_t arr_idx, duk_propdesc out_desc, duk_small_uint_t flags)

DUK_LOCAL duk_uint32_t	duk__get_old_array_length (duk_hthread thr, duk_hobject obj, duk_propdesc *temp_desc)

DUK_LOCAL duk_uint32_t	duk__tval_number_to_arr_idx (duk_tval *tv)

DUK_LOCAL duk_uint32_t	duk__push_tval_to_hstring_arr_idx (duk_context ctx, duk_tval tv, duk_hstring **out_h)

DUK_LOCAL duk_bool_t	duk__key_is_lightfunc_ownprop (duk_hthread thr, duk_hstring key)

DUK_LOCAL duk_uint32_t	duk__get_default_h_size (duk_uint32_t e_size)

DUK_LOCAL duk_uint32_t	duk__get_min_grow_e (duk_uint32_t e_size)

DUK_LOCAL duk_uint32_t	duk__get_min_grow_a (duk_uint32_t a_size)

DUK_LOCAL duk_uint32_t	duk__count_used_e_keys (duk_hthread thr, duk_hobject obj)

DUK_LOCAL void	duk__compute_a_stats (duk_hthread thr, duk_hobject obj, duk_uint32_t out_used, duk_uint32_t out_min_size)

DUK_LOCAL duk_bool_t	duk__abandon_array_density_check (duk_uint32_t a_used, duk_uint32_t a_size)

DUK_LOCAL duk_bool_t	duk__abandon_array_slow_check_required (duk_uint32_t arr_idx, duk_uint32_t old_size)

DUK_LOCAL duk_bool_t	duk__proxy_check_prop (duk_hthread thr, duk_hobject obj, duk_small_uint_t stridx_trap, duk_tval tv_key, duk_hobject *out_target)

DUK_LOCAL void	duk__realloc_props (duk_hthread thr, duk_hobject obj, duk_uint32_t new_e_size, duk_uint32_t new_a_size, duk_uint32_t new_h_size, duk_bool_t abandon_array)

DUK_LOCAL void	duk__grow_props_for_new_entry_item (duk_hthread thr, duk_hobject obj)

DUK_LOCAL void	duk__grow_props_for_array_item (duk_hthread thr, duk_hobject obj, duk_uint32_t highest_arr_idx)

DUK_LOCAL void	duk__abandon_array_checked (duk_hthread thr, duk_hobject obj)

DUK_LOCAL duk_bool_t	duk__alloc_entry_checked (duk_hthread thr, duk_hobject obj, duk_hstring *key)

DUK_LOCAL duk_bool_t	duk__lookup_arguments_map (duk_hthread thr, duk_hobject obj, duk_hstring key, duk_propdesc temp_desc, duk_hobject out_map, duk_hobject out_varenv)

DUK_LOCAL duk_tval *	duk__getprop_shallow_fastpath_array_tval (duk_hthread thr, duk_hobject obj, duk_tval *tv_key)

DUK_LOCAL duk_bool_t	duk__putprop_shallow_fastpath_array_tval (duk_hthread thr, duk_hobject obj, duk_tval tv_key, duk_tval tv_val, duk_propdesc *temp_desc)

DUK_LOCAL duk_bool_t	duk__getprop_fastpath_bufobj_tval (duk_hthread thr, duk_hobject obj, duk_tval *tv_key)

DUK_LOCAL duk_bool_t	duk__putprop_fastpath_bufobj_tval (duk_hthread thr, duk_hobject obj, duk_tval tv_key, duk_tval tv_val)

DUK_LOCAL duk_uint32_t	duk__to_new_array_length_checked (duk_hthread *thr)

DUK_LOCAL void	duk__push_stridx (duk_context ctx, duk_bitdecoder_ctx bd)

DUK_LOCAL void	duk__push_string (duk_context ctx, duk_bitdecoder_ctx bd)

DUK_LOCAL void	duk__push_stridx_or_string (duk_context ctx, duk_bitdecoder_ctx bd)

DUK_LOCAL void	duk__push_double (duk_context ctx, duk_bitdecoder_ctx bd)

DUK_LOCAL void	duk__handle_call_inner (duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags, duk_idx_t idx_func)

DUK_LOCAL void	duk__handle_call_error (duk_hthread thr, duk_size_t entry_valstack_bottom_index, duk_size_t entry_valstack_end, duk_size_t entry_catchstack_top, duk_size_t entry_callstack_top, duk_int_t entry_call_recursion_depth, duk_hthread entry_curr_thread, duk_uint_fast8_t entry_thread_state, duk_instr_t *entry_ptr_curr_pc, duk_idx_t idx_func, duk_jmpbuf old_jmpbuf_ptr)

DUK_LOCAL void	duk__handle_safe_call_inner (duk_hthread *thr, duk_safe_call_function func, duk_idx_t idx_retbase, duk_idx_t num_stack_rets, duk_size_t entry_valstack_bottom_index, duk_size_t entry_callstack_top, duk_size_t entry_catchstack_top)

DUK_LOCAL void	duk__handle_safe_call_error (duk_hthread thr, duk_idx_t idx_retbase, duk_idx_t num_stack_rets, duk_size_t entry_valstack_bottom_index, duk_size_t entry_callstack_top, duk_size_t entry_catchstack_top, duk_jmpbuf old_jmpbuf_ptr)

DUK_LOCAL void	duk__handle_safe_call_shared (duk_hthread thr, duk_idx_t idx_retbase, duk_idx_t num_stack_rets, duk_int_t entry_call_recursion_depth, duk_hthread entry_curr_thread, duk_uint_fast8_t entry_thread_state, duk_instr_t **entry_ptr_curr_pc)

DUK_LOCAL void	duk__create_arguments_object (duk_hthread thr, duk_hobject func, duk_hobject *varenv, duk_idx_t idx_argbase, duk_idx_t num_stack_args)

DUK_LOCAL void	duk__handle_createargs_for_call (duk_hthread thr, duk_hobject func, duk_hobject *env, duk_idx_t num_stack_args)

DUK_LOCAL void	duk__handle_bound_chain_for_call (duk_hthread thr, duk_idx_t idx_func, duk_idx_t p_num_stack_args, duk_bool_t is_constructor_call)

DUK_LOCAL void	duk__handle_oldenv_for_call (duk_hthread thr, duk_hobject func, duk_activation *act)

DUK_LOCAL void	duk__coerce_effective_this_binding (duk_hthread thr, duk_hobject func, duk_idx_t idx_this)

DUK_LOCAL duk_hobject *	duk__nonbound_func_lookup (duk_context ctx, duk_idx_t idx_func, duk_idx_t out_num_stack_args, duk_tval **out_tv_func, duk_small_uint_t call_flags)

DUK_LOCAL void	duk__adjust_valstack_and_top (duk_hthread thr, duk_idx_t num_stack_args, duk_idx_t idx_args, duk_idx_t nregs, duk_idx_t nargs, duk_hobject func)

DUK_LOCAL void	duk__safe_call_adjust_valstack (duk_hthread *thr, duk_idx_t idx_retbase, duk_idx_t num_stack_rets, duk_idx_t num_actual_rets)

DUK_LOCAL duk_idx_t	duk__get_idx_func (duk_hthread *thr, duk_idx_t num_stack_args)

DUK_LOCAL_DECL void	duk__advance_helper (duk_compiler_ctx *comp_ctx, duk_small_int_t expect)

DUK_LOCAL_DECL void	duk__advance_expect (duk_compiler_ctx *comp_ctx, duk_small_int_t expect)

DUK_LOCAL_DECL void	duk__advance (duk_compiler_ctx *ctx)

DUK_LOCAL_DECL void	duk__init_func_valstack_slots (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__reset_func_for_pass2 (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__init_varmap_and_prologue_for_pass2 (duk_compiler_ctx comp_ctx, duk_reg_t out_stmt_value_reg)

DUK_LOCAL_DECL void	duk__convert_to_func_template (duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind)

DUK_LOCAL_DECL duk_int_t	duk__cleanup_varmap (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL duk_int_t	duk__get_current_pc (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL duk_compiler_instr *	duk__get_instr_ptr (duk_compiler_ctx *comp_ctx, duk_int_t pc)

DUK_LOCAL_DECL void	duk__emit (duk_compiler_ctx *comp_ctx, duk_instr_t ins)

DUK_LOCAL_DECL void	duk__emit_a_b_c (duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c)

DUK_LOCAL_DECL void	duk__emit_a_b (duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b)

DUK_LOCAL_DECL void	duk__emit_a_bc (duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc)

DUK_LOCAL_DECL void	duk__emit_abc (duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc)

DUK_LOCAL_DECL void	duk__emit_extraop_b_c (duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c)

DUK_LOCAL_DECL void	duk__emit_extraop_b (duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b)

DUK_LOCAL_DECL void	duk__emit_extraop_bc (duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc)

DUK_LOCAL_DECL void	duk__emit_extraop_only (duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags)

DUK_LOCAL_DECL void	duk__emit_load_int32 (duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val)

DUK_LOCAL_DECL void	duk__emit_load_int32_noshuffle (duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val)

DUK_LOCAL_DECL void	duk__emit_jump (duk_compiler_ctx *comp_ctx, duk_int_t target_pc)

DUK_LOCAL_DECL duk_int_t	duk__emit_jump_empty (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__insert_jump_entry (duk_compiler_ctx *comp_ctx, duk_int_t jump_pc)

DUK_LOCAL_DECL void	duk__patch_jump (duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc)

DUK_LOCAL_DECL void	duk__patch_jump_here (duk_compiler_ctx *comp_ctx, duk_int_t jump_pc)

DUK_LOCAL_DECL void	duk__patch_trycatch (duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags)

DUK_LOCAL_DECL void	duk__emit_if_false_skip (duk_compiler_ctx *comp_ctx, duk_regconst_t regconst)

DUK_LOCAL_DECL void	duk__emit_if_true_skip (duk_compiler_ctx *comp_ctx, duk_regconst_t regconst)

DUK_LOCAL_DECL void	duk__emit_invalid (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__copy_ispec (duk_compiler_ctx comp_ctx, duk_ispec src, duk_ispec *dst)

DUK_LOCAL_DECL void	duk__copy_ivalue (duk_compiler_ctx comp_ctx, duk_ivalue src, duk_ivalue *dst)

DUK_LOCAL_DECL duk_bool_t	duk__is_whole_get_int32 (duk_double_t x, duk_int32_t *ival)

DUK_LOCAL_DECL duk_reg_t	duk__alloctemps (duk_compiler_ctx *comp_ctx, duk_small_int_t num)

DUK_LOCAL_DECL duk_reg_t	duk__alloctemp (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__settemp_checkmax (duk_compiler_ctx *comp_ctx, duk_reg_t temp_next)

DUK_LOCAL_DECL duk_regconst_t	duk__getconst (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL duk_regconst_t	duk__ispec_toregconst_raw (duk_compiler_ctx comp_ctx, duk_ispec x, duk_reg_t forced_reg, duk_small_uint_t flags)

DUK_LOCAL_DECL void	duk__ispec_toforcedreg (duk_compiler_ctx comp_ctx, duk_ispec x, duk_reg_t forced_reg)

DUK_LOCAL_DECL void	duk__ivalue_toplain_raw (duk_compiler_ctx comp_ctx, duk_ivalue x, duk_reg_t forced_reg)

DUK_LOCAL_DECL void	duk__ivalue_toplain (duk_compiler_ctx comp_ctx, duk_ivalue x)

DUK_LOCAL_DECL void	duk__ivalue_toplain_ignore (duk_compiler_ctx comp_ctx, duk_ivalue x)

DUK_LOCAL_DECL duk_regconst_t	duk__ivalue_toregconst_raw (duk_compiler_ctx comp_ctx, duk_ivalue x, duk_reg_t forced_reg, duk_small_uint_t flags)

DUK_LOCAL_DECL duk_reg_t	duk__ivalue_toreg (duk_compiler_ctx comp_ctx, duk_ivalue x)

DUK_LOCAL_DECL void	duk__ivalue_toforcedreg (duk_compiler_ctx comp_ctx, duk_ivalue x, duk_int_t forced_reg)

DUK_LOCAL_DECL duk_regconst_t	duk__ivalue_toregconst (duk_compiler_ctx comp_ctx, duk_ivalue x)

DUK_LOCAL_DECL duk_regconst_t	duk__ivalue_totempconst (duk_compiler_ctx comp_ctx, duk_ivalue x)

DUK_LOCAL_DECL duk_reg_t	duk__lookup_active_register_binding (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL duk_bool_t	duk__lookup_lhs (duk_compiler_ctx ctx, duk_reg_t out_reg_varbind, duk_regconst_t *out_rc_varname)

DUK_LOCAL_DECL void	duk__add_label (duk_compiler_ctx comp_ctx, duk_hstring h_label, duk_int_t pc_label, duk_int_t label_id)

DUK_LOCAL_DECL void	duk__update_label_flags (duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags)

DUK_LOCAL_DECL void	duk__lookup_active_label (duk_compiler_ctx comp_ctx, duk_hstring h_label, duk_bool_t is_break, duk_int_t out_label_id, duk_int_t out_label_catch_depth, duk_int_t out_label_pc, duk_bool_t out_is_closest)

DUK_LOCAL_DECL void	duk__reset_labels_to_length (duk_compiler_ctx *comp_ctx, duk_int_t len)

DUK_LOCAL_DECL void	duk__expr_nud (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__expr_led (duk_compiler_ctx comp_ctx, duk_ivalue left, duk_ivalue *res)

DUK_LOCAL_DECL duk_small_uint_t	duk__expr_lbp (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL duk_bool_t	duk__expr_is_empty (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__expr (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL void	duk__exprtop (duk_compiler_ctx ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL void	duk__expr_toforcedreg (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg)

DUK_LOCAL_DECL duk_regconst_t	duk__expr_toregconst (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL void	duk__expr_toplain (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL void	duk__expr_toplain_ignore (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL duk_reg_t	duk__exprtop_toreg (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL void	duk__exprtop_toforcedreg (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg)

DUK_LOCAL_DECL duk_regconst_t	duk__exprtop_toregconst (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t rbp_flags)

DUK_LOCAL_DECL duk_int_t	duk__parse_arguments (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__nud_array_literal (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__nud_object_literal (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL duk_bool_t	duk__nud_object_literal_key_check (duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags)

DUK_LOCAL_DECL void	duk__parse_var_decl (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t expr_flags, duk_reg_t out_reg_varbind, duk_regconst_t out_rc_varname)

DUK_LOCAL_DECL void	duk__parse_var_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_small_uint_t expr_flags)

DUK_LOCAL_DECL void	duk__parse_for_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_int_t pc_label_site)

DUK_LOCAL_DECL void	duk__parse_switch_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_int_t pc_label_site)

DUK_LOCAL_DECL void	duk__parse_if_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__parse_do_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_int_t pc_label_site)

DUK_LOCAL_DECL void	duk__parse_while_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_int_t pc_label_site)

DUK_LOCAL_DECL void	duk__parse_break_or_continue_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__parse_return_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__parse_throw_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__parse_try_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__parse_with_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res)

DUK_LOCAL_DECL void	duk__parse_stmt (duk_compiler_ctx comp_ctx, duk_ivalue res, duk_bool_t allow_source_elem)

DUK_LOCAL_DECL duk_int_t	duk__stmt_label_site (duk_compiler_ctx *comp_ctx, duk_int_t label_id)

DUK_LOCAL_DECL void	duk__parse_stmts (duk_compiler_ctx *comp_ctx, duk_bool_t allow_source_elem, duk_bool_t expect_eof)

DUK_LOCAL_DECL void	duk__parse_func_body (duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token)

DUK_LOCAL_DECL void	duk__parse_func_formals (duk_compiler_ctx *comp_ctx)

DUK_LOCAL_DECL void	duk__parse_func_like_raw (duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget)

DUK_LOCAL_DECL duk_int_t	duk__parse_func_like_fnum (duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget)

DUK_LOCAL void	duk__recursion_increase (duk_compiler_ctx *comp_ctx)

DUK_LOCAL void	duk__recursion_decrease (duk_compiler_ctx *comp_ctx)

DUK_LOCAL duk_bool_t	duk__hstring_is_eval_or_arguments (duk_compiler_ctx comp_ctx, duk_hstring h)

DUK_LOCAL duk_bool_t	duk__hstring_is_eval_or_arguments_in_strict_mode (duk_compiler_ctx comp_ctx, duk_hstring h)

DUK_LOCAL void	duk__update_lineinfo_currtoken (duk_compiler_ctx *comp_ctx)

DUK_LOCAL void	duk__emit_load_int32_raw (duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val, duk_small_uint_t op_flags)

DUK_LOCAL void	duk__peephole_optimize_bytecode (duk_compiler_ctx *comp_ctx)

DUK_LOCAL duk_ret_t	duk__js_compile_raw (duk_context *ctx)

DUK_LOCAL_DECL void	duk__js_execute_bytecode_inner (duk_hthread *entry_thread, duk_size_t entry_callstack_top)

DUK_LOCAL duk_double_t	duk__compute_mod (duk_double_t d1, duk_double_t d2)

DUK_LOCAL void	duk__vm_arith_add (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z)

DUK_LOCAL void	duk__vm_arith_binary_op (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y, duk_idx_t idx_z, duk_small_uint_fast_t opcode)

DUK_LOCAL void	duk__vm_bitwise_binary_op (duk_hthread thr, duk_tval tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z, duk_small_uint_fast_t opcode)

DUK_LOCAL void	duk__vm_arith_unary_op (duk_hthread thr, duk_tval tv_x, duk_idx_t idx_x, duk_small_uint_fast_t opcode)

DUK_LOCAL void	duk__vm_bitwise_not (duk_hthread thr, duk_tval tv_x, duk_uint_fast_t idx_z)

DUK_LOCAL void	duk__vm_logical_not (duk_hthread thr, duk_tval tv_x, duk_tval *tv_z)

DUK_LOCAL void	duk__reconfig_valstack_ecma_return (duk_hthread *thr, duk_size_t act_idx)

DUK_LOCAL void	duk__reconfig_valstack_ecma_catcher (duk_hthread *thr, duk_size_t act_idx, duk_size_t cat_idx)

DUK_LOCAL void	duk__set_catcher_regs (duk_hthread thr, duk_size_t cat_idx, duk_tval tv_val_unstable, duk_small_uint_t lj_type)

DUK_LOCAL void	duk__handle_catch (duk_hthread thr, duk_size_t cat_idx, duk_tval tv_val_unstable, duk_small_uint_t lj_type)

DUK_LOCAL void	duk__handle_finally (duk_hthread thr, duk_size_t cat_idx, duk_tval tv_val_unstable, duk_small_uint_t lj_type)

DUK_LOCAL void	duk__handle_label (duk_hthread *thr, duk_size_t cat_idx, duk_small_uint_t lj_type)

DUK_LOCAL void	duk__handle_yield (duk_hthread thr, duk_hthread resumer, duk_size_t act_idx, duk_tval *tv_val_unstable)

DUK_LOCAL duk_small_uint_t	duk__handle_longjmp (duk_hthread thr, duk_hthread entry_thread, duk_size_t entry_callstack_top)

DUK_LOCAL void	duk__handle_break_or_continue (duk_hthread *thr, duk_uint_t label_id, duk_small_uint_t lj_type)

DUK_LOCAL duk_small_uint_t	duk__handle_return (duk_hthread thr, duk_hthread entry_thread, duk_size_t entry_callstack_top)

DUK_LOCAL void	duk__handle_executor_error (duk_heap heap, duk_hthread entry_thread, duk_size_t entry_callstack_top, duk_int_t entry_call_recursion_depth, duk_jmpbuf *entry_jmpbuf_ptr)

DUK_LOCAL duk_double_t	duk__tonumber_string_raw (duk_hthread *thr)

DUK_LOCAL duk_double_t	duk__toint32_touint32_helper (duk_double_t x, duk_bool_t is_toint32)

DUK_LOCAL duk_bool_t	duk__js_equals_number (duk_double_t x, duk_double_t y)

DUK_LOCAL duk_bool_t	duk__js_samevalue_number (duk_double_t x, duk_double_t y)

DUK_LOCAL void	duk__inc_data_inner_refcounts (duk_hthread thr, duk_hcompiledfunction f)

DUK_LOCAL duk_bool_t	duk__getid_open_decl_env_regs (duk_hthread thr, duk_hstring name, duk_hobject env, duk__id_lookup_result out)

DUK_LOCAL duk_bool_t	duk__getid_activation_regs (duk_hthread thr, duk_hstring name, duk_activation act, duk__id_lookup_result out)

DUK_LOCAL duk_bool_t	duk__get_identifier_reference (duk_hthread thr, duk_hobject env, duk_hstring name, duk_activation act, duk_bool_t parents, duk__id_lookup_result *out)

DUK_LOCAL duk_bool_t	duk__getvar_helper (duk_hthread thr, duk_hobject env, duk_activation act, duk_hstring name, duk_bool_t throw_flag)

DUK_LOCAL void	duk__putvar_helper (duk_hthread thr, duk_hobject env, duk_activation act, duk_hstring name, duk_tval *val, duk_bool_t strict)

DUK_LOCAL duk_bool_t	duk__delvar_helper (duk_hthread thr, duk_hobject env, duk_activation act, duk_hstring name)

DUK_LOCAL duk_bool_t	duk__declvar_helper (duk_hthread thr, duk_hobject env, duk_hstring name, duk_tval val, duk_small_int_t prop_flags, duk_bool_t is_func_decl)

DUK_LOCAL void	duk__fill_lexer_buffer (duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes)

DUK_LOCAL void	duk__advance_bytes (duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes)

DUK_LOCAL void	duk__init_lexer_window (duk_lexer_ctx *lex_ctx)

DUK_LOCAL void	duk__initbuffer (duk_lexer_ctx *lex_ctx)

DUK_LOCAL void	duk__appendbuffer (duk_lexer_ctx *lex_ctx, duk_codepoint_t x)

DUK_LOCAL void	duk__internbuffer (duk_lexer_ctx *lex_ctx, duk_idx_t valstack_idx)

DUK_LOCAL duk_codepoint_t	duk__hexval (duk_lexer_ctx *lex_ctx, duk_codepoint_t x)

DUK_LOCAL duk_bool_t	duk__is_hex_digit (duk_codepoint_t x)

DUK_LOCAL duk_codepoint_t	duk__decode_hexesc_from_window (duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset)

DUK_LOCAL duk_codepoint_t	duk__decode_uniesc_from_window (duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset)

DUK_LOCAL void	duk__emit_u16_direct_ranges (duk_lexer_ctx lex_ctx, duk_re_range_callback gen_range, void userdata, const duk_uint16_t *ranges, duk_small_int_t num)

DUK_LOCAL void	duk__bi_normalize (duk__bigint *x)

DUK_LOCAL void	duk__bi_copy (duk__bigint x, duk__bigint y)

DUK_LOCAL void	duk__bi_set_small (duk__bigint *x, duk_uint32_t v)

DUK_LOCAL int	duk__bi_compare (duk__bigint x, duk__bigint y)

DUK_LOCAL void	duk__bi_add (duk__bigint x, duk__bigint y, duk__bigint *z)

DUK_LOCAL void	duk__bi_add_small (duk__bigint x, duk__bigint y, duk_uint32_t z)

DUK_LOCAL void	duk__bi_sub (duk__bigint x, duk__bigint y, duk__bigint *z)

DUK_LOCAL void	duk__bi_sub_copy (duk__bigint x, duk__bigint y, duk__bigint *t)

DUK_LOCAL void	duk__bi_mul (duk__bigint x, duk__bigint y, duk__bigint *z)

DUK_LOCAL void	duk__bi_mul_small (duk__bigint x, duk__bigint y, duk_uint32_t z)

DUK_LOCAL void	duk__bi_mul_copy (duk__bigint x, duk__bigint y, duk__bigint *t)

DUK_LOCAL void	duk__bi_mul_small_copy (duk__bigint x, duk_uint32_t y, duk__bigint t)

DUK_LOCAL int	duk__bi_is_even (duk__bigint *x)

DUK_LOCAL int	duk__bi_is_zero (duk__bigint *x)

DUK_LOCAL duk_small_int_t	duk__bi_is_2to52 (duk__bigint *x)

DUK_LOCAL void	duk__bi_twoexp (duk__bigint *x, duk_small_int_t y)

DUK_LOCAL void	duk__bi_exp_small (duk__bigint x, duk_small_int_t b, duk_small_int_t y, duk__bigint t1, duk__bigint *t2)

DUK_LOCAL duk_size_t	duk__dragon4_format_uint32 (duk_uint8_t *buf, duk_uint32_t x, duk_small_int_t radix)

DUK_LOCAL void	duk__dragon4_prepare (duk__numconv_stringify_ctx *nc_ctx)

DUK_LOCAL void	duk__dragon4_scale (duk__numconv_stringify_ctx *nc_ctx)

DUK_LOCAL void	duk__dragon4_generate (duk__numconv_stringify_ctx *nc_ctx)

DUK_LOCAL duk_small_int_t	duk__dragon4_fixed_format_round (duk__numconv_stringify_ctx *nc_ctx, duk_small_int_t round_idx)

DUK_LOCAL void	duk__dragon4_convert_and_push (duk__numconv_stringify_ctx nc_ctx, duk_context ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags, duk_small_int_t neg)

DUK_LOCAL void	duk__dragon4_double_to_ctx (duk__numconv_stringify_ctx *nc_ctx, duk_double_t x)

DUK_LOCAL void	duk__dragon4_ctx_to_double (duk__numconv_stringify_ctx nc_ctx, duk_double_t x)

DUK_LOCAL duk_uint32_t	duk__encode_i32 (duk_int32_t x)

DUK_LOCAL duk_uint32_t	duk__insert_u32 (duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t x)

DUK_LOCAL duk_uint32_t	duk__append_u32 (duk_re_compiler_ctx *re_ctx, duk_uint32_t x)

DUK_LOCAL duk_uint32_t	duk__insert_i32 (duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t x)

DUK_LOCAL void	duk__append_u16_list (duk_re_compiler_ctx re_ctx, const duk_uint16_t values, duk_uint32_t count)

DUK_LOCAL void	duk__insert_slice (duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t data_offset, duk_uint32_t data_length)

DUK_LOCAL void	duk__append_slice (duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length)

DUK_LOCAL void	duk__remove_slice (duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length)

DUK_LOCAL duk_uint32_t	duk__insert_jump_offset (duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t skip)

DUK_LOCAL duk_uint32_t	duk__append_jump_offset (duk_re_compiler_ctx *re_ctx, duk_int32_t skip)

DUK_LOCAL void	duk__generate_ranges (void *userdata, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct)

DUK_LOCAL void	duk__parse_disjunction (duk_re_compiler_ctx re_ctx, duk_bool_t expect_eof, duk__re_disjunction_info out_atom_info)

DUK_LOCAL duk_uint32_t	duk__parse_regexp_flags (duk_hthread thr, duk_hstring h)

DUK_LOCAL void	duk__create_escaped_source (duk_hthread *thr, int idx_pattern)

DUK_LOCAL duk_uint32_t	duk__bc_get_u32 (duk_re_matcher_ctx re_ctx, const duk_uint8_t *pc)

DUK_LOCAL duk_int32_t	duk__bc_get_i32 (duk_re_matcher_ctx re_ctx, const duk_uint8_t *pc)

DUK_LOCAL const duk_uint8_t *	duk__utf8_backtrack (duk_hthread thr, const duk_uint8_t ptr, const duk_uint8_t ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count)

DUK_LOCAL const duk_uint8_t *	duk__utf8_advance (duk_hthread thr, const duk_uint8_t ptr, const duk_uint8_t ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count)

DUK_LOCAL duk_codepoint_t	duk__inp_get_cp (duk_re_matcher_ctx re_ctx, const duk_uint8_t *sp)

DUK_LOCAL const duk_uint8_t *	duk__inp_backtrack (duk_re_matcher_ctx re_ctx, const duk_uint8_t *sp, duk_uint_fast32_t count)

DUK_LOCAL duk_codepoint_t	duk__inp_get_prev_cp (duk_re_matcher_ctx re_ctx, const duk_uint8_t sp)

DUK_LOCAL const duk_uint8_t *	duk__match_regexp (duk_re_matcher_ctx re_ctx, const duk_uint8_t pc, const duk_uint8_t *sp)

DUK_LOCAL void	duk__regexp_match_helper (duk_hthread *thr, duk_small_int_t force_global)

DUK_LOCAL void	duk__bw_update_ptrs (duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_size_t curr_offset, duk_size_t new_length)

Variables
const duk_uint8_t	duk_unicode_ids_noa [791]

const duk_uint8_t	duk_unicode_ids_m_let_noa [42]

const duk_uint8_t	duk_unicode_idp_m_ids_noa [397]

const duk_uint8_t	duk_unicode_caseconv_uc [1288]

const duk_uint8_t	duk_unicode_caseconv_lc [616]

DUK_INTERNAL const char *	duk_str_internal_error = "internal error"

DUK_INTERNAL const char *	duk_str_invalid_count = "invalid count"

DUK_INTERNAL const char *	duk_str_invalid_call_args = "invalid call args"

DUK_INTERNAL const char *	duk_str_not_constructable = "not constructable"

DUK_INTERNAL const char *	duk_str_not_callable = "not callable"

DUK_INTERNAL const char *	duk_str_not_extensible = "not extensible"

DUK_INTERNAL const char *	duk_str_not_writable = "not writable"

DUK_INTERNAL const char *	duk_str_not_configurable = "not configurable"

DUK_INTERNAL const char *	duk_str_invalid_context = "invalid context"

DUK_INTERNAL const char *	duk_str_push_beyond_alloc_stack = "attempt to push beyond currently allocated stack"

DUK_INTERNAL const char *	duk_str_not_buffer = "not buffer"

DUK_INTERNAL const char *	duk_str_unexpected_type = "unexpected type"

DUK_INTERNAL const char *	duk_str_defaultvalue_coerce_failed = "[[DefaultValue]] coerce failed"

DUK_INTERNAL const char *	duk_str_number_outside_range = "number outside range"

DUK_INTERNAL const char *	duk_str_not_object_coercible = "not object coercible"

DUK_INTERNAL const char *	duk_str_string_too_long = "string too long"

DUK_INTERNAL const char *	duk_str_buffer_too_long = "buffer too long"

DUK_INTERNAL const char *	duk_str_sprintf_too_long = "sprintf message too long"

DUK_INTERNAL const char *	duk_str_alloc_failed = "alloc failed"

DUK_INTERNAL const char *	duk_str_pop_too_many = "attempt to pop too many entries"

DUK_INTERNAL const char *	duk_str_wrong_buffer_type = "wrong buffer type"

DUK_INTERNAL const char *	duk_str_encode_failed = "encode failed"

DUK_INTERNAL const char *	duk_str_decode_failed = "decode failed"

DUK_INTERNAL const char *	duk_str_no_sourcecode = "no sourcecode"

DUK_INTERNAL const char *	duk_str_concat_result_too_long = "concat result too long"

DUK_INTERNAL const char *	duk_str_unimplemented = "unimplemented"

DUK_INTERNAL const char *	duk_str_unsupported = "unsupported"

DUK_INTERNAL const char *	duk_str_array_length_over_2g = "array length over 2G"

DUK_INTERNAL const char *	duk_str_fmt_ptr = "%p"

DUK_INTERNAL const char *	duk_str_fmt_invalid_json = "invalid json (at offset %ld)"

DUK_INTERNAL const char *	duk_str_jsondec_reclimit = "json decode recursion limit"

DUK_INTERNAL const char *	duk_str_jsonenc_reclimit = "json encode recursion limit"

DUK_INTERNAL const char *	duk_str_cyclic_input = "cyclic input"

DUK_INTERNAL const char *	duk_str_proxy_revoked = "proxy revoked"

DUK_INTERNAL const char *	duk_str_invalid_base = "invalid base value"

DUK_INTERNAL const char *	duk_str_strict_caller_read = "attempt to read strict 'caller'"

DUK_INTERNAL const char *	duk_str_proxy_rejected = "proxy rejected"

DUK_INTERNAL const char *	duk_str_invalid_array_length = "invalid array length"

DUK_INTERNAL const char *	duk_str_array_length_write_failed = "array length write failed"

DUK_INTERNAL const char *	duk_str_array_length_not_writable = "array length non-writable"

DUK_INTERNAL const char *	duk_str_setter_undefined = "setter undefined"

DUK_INTERNAL const char *	duk_str_redefine_virt_prop = "attempt to redefine virtual property"

DUK_INTERNAL const char *	duk_str_invalid_descriptor = "invalid descriptor"

DUK_INTERNAL const char *	duk_str_property_is_virtual = "property is virtual"

DUK_INTERNAL const char *	duk_str_parse_error = "parse error"

DUK_INTERNAL const char *	duk_str_duplicate_label = "duplicate label"

DUK_INTERNAL const char *	duk_str_invalid_label = "invalid label"

DUK_INTERNAL const char *	duk_str_invalid_array_literal = "invalid array literal"

DUK_INTERNAL const char *	duk_str_invalid_object_literal = "invalid object literal"

DUK_INTERNAL const char *	duk_str_invalid_var_declaration = "invalid variable declaration"

DUK_INTERNAL const char *	duk_str_cannot_delete_identifier = "cannot delete identifier"

DUK_INTERNAL const char *	duk_str_invalid_expression = "invalid expression"

DUK_INTERNAL const char *	duk_str_invalid_lvalue = "invalid lvalue"

DUK_INTERNAL const char *	duk_str_expected_identifier = "expected identifier"

DUK_INTERNAL const char *	duk_str_empty_expr_not_allowed = "empty expression not allowed"

DUK_INTERNAL const char *	duk_str_invalid_for = "invalid for statement"

DUK_INTERNAL const char *	duk_str_invalid_switch = "invalid switch statement"

DUK_INTERNAL const char *	duk_str_invalid_break_cont_label = "invalid break/continue label"

DUK_INTERNAL const char *	duk_str_invalid_return = "invalid return"

DUK_INTERNAL const char *	duk_str_invalid_try = "invalid try"

DUK_INTERNAL const char *	duk_str_invalid_throw = "invalid throw"

DUK_INTERNAL const char *	duk_str_with_in_strict_mode = "with in strict mode"

DUK_INTERNAL const char *	duk_str_func_stmt_not_allowed = "function statement not allowed"

DUK_INTERNAL const char *	duk_str_unterminated_stmt = "unterminated statement"

DUK_INTERNAL const char *	duk_str_invalid_arg_name = "invalid argument name"

DUK_INTERNAL const char *	duk_str_invalid_func_name = "invalid function name"

DUK_INTERNAL const char *	duk_str_invalid_getset_name = "invalid getter/setter name"

DUK_INTERNAL const char *	duk_str_func_name_required = "function name required"

DUK_INTERNAL const char *	duk_str_invalid_quantifier_no_atom = "quantifier without preceding atom"

DUK_INTERNAL const char *	duk_str_invalid_quantifier_values = "quantifier values invalid (qmin > qmax)"

DUK_INTERNAL const char *	duk_str_quantifier_too_many_copies = "quantifier expansion requires too many atom copies"

DUK_INTERNAL const char *	duk_str_unexpected_closing_paren = "unexpected closing parenthesis"

DUK_INTERNAL const char *	duk_str_unexpected_end_of_pattern = "unexpected end of pattern"

DUK_INTERNAL const char *	duk_str_unexpected_regexp_token = "unexpected token in regexp"

DUK_INTERNAL const char *	duk_str_invalid_regexp_flags = "invalid regexp flags"

DUK_INTERNAL const char *	duk_str_invalid_backrefs = "invalid backreference(s)"

DUK_INTERNAL const char *	duk_str_valstack_limit = "valstack limit"

DUK_INTERNAL const char *	duk_str_callstack_limit = "callstack limit"

DUK_INTERNAL const char *	duk_str_catchstack_limit = "catchstack limit"

DUK_INTERNAL const char *	duk_str_prototype_chain_limit = "prototype chain limit"

DUK_INTERNAL const char *	duk_str_bound_chain_limit = "function call bound chain limit"

DUK_INTERNAL const char *	duk_str_c_callstack_limit = "C call stack depth limit"

DUK_INTERNAL const char *	duk_str_compiler_recursion_limit = "compiler recursion limit"

DUK_INTERNAL const char *	duk_str_bytecode_limit = "bytecode limit"

DUK_INTERNAL const char *	duk_str_reg_limit = "register limit"

DUK_INTERNAL const char *	duk_str_temp_limit = "temp limit"

DUK_INTERNAL const char *	duk_str_const_limit = "const limit"

DUK_INTERNAL const char *	duk_str_func_limit = "function limit"

DUK_INTERNAL const char *	duk_str_regexp_compiler_recursion_limit = "regexp compiler recursion limit"

DUK_INTERNAL const char *	duk_str_regexp_executor_recursion_limit = "regexp executor recursion limit"

DUK_INTERNAL const char *	duk_str_regexp_executor_step_limit = "regexp step limit"

DUK_INTERNAL const duk_uint8_t	duk_strings_data [1049]

DUK_INTERNAL const duk_c_function	duk_bi_native_functions [149]

DUK_INTERNAL const duk_uint8_t	duk_initjs_data [204]

DUK_INTERNAL const duk_int8_t	duk_is_idchar_tab [128]

DUK_INTERNAL const duk_uint8_t	duk_unicode_xutf8_markers [7]

DUK_INTERNAL const duk_uint16_t	duk_unicode_re_ranges_digit [2]

DUK_INTERNAL const duk_uint16_t	duk_unicode_re_ranges_white [22]

DUK_INTERNAL const duk_uint16_t	duk_unicode_re_ranges_wordchar [8]

DUK_INTERNAL const duk_uint16_t	duk_unicode_re_ranges_not_digit [4]

DUK_INTERNAL const duk_uint16_t	duk_unicode_re_ranges_not_white [24]

DUK_INTERNAL const duk_uint16_t	duk_unicode_re_ranges_not_wordchar [10]

DUK_INTERNAL const duk_uint8_t	duk_lc_digits [36]

DUK_INTERNAL const duk_uint8_t	duk_uc_nybbles [16]

DUK_INTERNAL const duk_int8_t	duk_hex_dectab [256]

DUK_INTERNAL const duk_int16_t	duk_hex_dectab_shift4 [256]

DUK_INTERNAL const duk_uint16_t	duk_hex_enctab [256]

DUK_INTERNAL const duk_uint8_t	duk_base64_enctab [64]

DUK_INTERNAL const duk_int8_t	duk_base64_dectab [256]

DUK_LOCAL const duk_int8_t	duk__hash_size_corrections []

DUK_INTERNAL duk_uint8_t	duk_util_probe_steps [32]

DUK_INTERNAL duk_uint8_t	duk_class_number_to_stridx [32]

DUK_EXTERNAL const char *	duk_api_global_filename = NULL

DUK_EXTERNAL duk_int_t	duk_api_global_line = 0

static const duk_uint32_t	duk__bufobj_flags_lookup []

static const duk_uint8_t	duk__buffer_class_from_elemtype [9]

static const duk_uint8_t	duk__buffer_proto_from_elemtype [9]

static const duk_uint8_t	duk__buffer_nbytes_from_fldtype [6]

static duk_uint16_t	duk__buffer_elemtype_copy_compatible [9]

DUK_LOCAL duk_uint8_t	duk__date_equivyear [14]

DUK_LOCAL const duk_uint8_t	duk__parse_iso8601_seps []

DUK_LOCAL const duk_uint32_t	duk__parse_iso8601_control []

DUK_LOCAL duk_uint8_t	duk__days_in_month [12]

static duk_uint16_t	duk__date_magics []

DUK_LOCAL const duk_uint8_t	duk__encode_uriunescaped_table [16]

DUK_LOCAL const duk_uint8_t	duk__encode_uricomponent_unescaped_table [16]

DUK_LOCAL const duk_uint8_t	duk__decode_uri_reserved_table [16]

DUK_LOCAL const duk_uint8_t	duk__decode_uri_component_reserved_table [16]

DUK_LOCAL const duk_uint8_t	duk__escape_unescaped_table [16]

DUK_LOCAL const duk_uint8_t	duk__json_quotestr_lookup [256]

DUK_LOCAL const duk_uint8_t	duk__json_decstr_lookup [256]

DUK_LOCAL const duk_uint8_t	duk__json_eatwhite_lookup [256]

DUK_LOCAL const duk_uint8_t	duk__json_decnumber_lookup [256]

DUK_LOCAL const duk_uint8_t	duk__log_level_strings []

DUK_LOCAL const duk__one_arg_func	duk__one_arg_funcs []

DUK_LOCAL const duk__two_arg_func	duk__two_arg_funcs []

DUK_LOCAL const duk_uint16_t	duk__bufferobject_virtual_props []

DUK_LOCAL const duk_uint8_t	duk__token_lbp []

DUK_LOCAL const duk_uint16_t	duk__closure_copy_proplist []

DUK_LOCAL const duk_uint8_t	duk__str2num_digits_for_radix []

DUK_LOCAL const duk__exp_limits	duk__str2num_exp_limits []

Macro Definition Documentation

◆ DUK__ADVANCEBYTES

#define DUK__ADVANCEBYTES	(		lex_ctx,
			count ) duk__advance_bytes((lex_ctx), (count))

Definition at line 73408 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ADVANCECHARS

#define DUK__ADVANCECHARS	(		lex_ctx,
			count ) duk__advance_bytes((lex_ctx), (count) * sizeof(duk_lexer_codepoint))

Definition at line 73407 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ADVTOK

#define DUK__ADVTOK	(		advbytes,
			tok ) ((((advbytes) * sizeof(duk_lexer_codepoint)) << 8) + (tok))

Definition at line 73421 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ALLOCTEMP

#define DUK__ALLOCTEMP ( comp_ctx ) duk__alloctemp((comp_ctx))

Definition at line 59493 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__ispec_toregconst_raw(), and duk__parse_func_body().

◆ DUK__ALLOCTEMPS

#define DUK__ALLOCTEMPS	(		comp_ctx,
			count ) duk__alloctemps((comp_ctx),(count))

Definition at line 59494 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK__ALLOW_AUTO_SEMI_ALWAYS

#define DUK__ALLOW_AUTO_SEMI_ALWAYS (1 << 2) /* allow automatic semicolon even without lineterm (compatibility) */

Definition at line 62669 of file duktape-1.8.0/src/duktape.c.

◆ DUK__APPENDBUFFER

#define DUK__APPENDBUFFER	(		lex_ctx,
			x ) duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x))

Definition at line 73410 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ARRAY_MID_JOIN_LIMIT

#define DUK__ARRAY_MID_JOIN_LIMIT 4096

Definition at line 20261 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ASSERT_LEFT

#define DUK__ASSERT_LEFT ( n )

Value:

        do { \
        DUK_ASSERT((duk_size_t) (p_end - p) >= (duk_size_t) (n)); \
    } while (0)

Definition at line 12015 of file duktape-1.8.0/src/duktape.c.

    p = duk__dump_formals(thr, p, bw_ctx, (duk_hobject *) func);
 
    DUK_DD(DUK_DDPRINT("serialized function %p -> final pointer %p", (void *) func, (void *) p));

◆ DUK__BC_INITIAL_INSTS

#define DUK__BC_INITIAL_INSTS 256

Definition at line 57764 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BI_MAX_PARTS

#define DUK__BI_MAX_PARTS 37 /* 37x32 = 1184 bits */

Definition at line 75460 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BI_PRINT

#define DUK__BI_PRINT	(		name,
			x )

Definition at line 75465 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BIDX_BITS

#define DUK__BIDX_BITS 7

Definition at line 53574 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BITPACK_FF

#define DUK__BITPACK_FF 27

Definition at line 41018 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BITPACK_LETTER_LIMIT

#define DUK__BITPACK_LETTER_LIMIT 26

Definition at line 41016 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BITPACK_SEVENBIT

#define DUK__BITPACK_SEVENBIT 31

Definition at line 41021 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BITPACK_SWITCH

#define DUK__BITPACK_SWITCH 30

Definition at line 41020 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BITPACK_SWITCH1

#define DUK__BITPACK_SWITCH1 29

Definition at line 41019 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BITPACK_UNDERSCORE

#define DUK__BITPACK_UNDERSCORE 26

Definition at line 41017 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_ADDITIVE

#define DUK__BP_ADDITIVE 28

Definition at line 57972 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_ASSIGNMENT

#define DUK__BP_ASSIGNMENT 8

Definition at line 57962 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_BAND

#define DUK__BP_BAND 20

Definition at line 57968 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_BOR

#define DUK__BP_BOR 16

Definition at line 57966 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_BXOR

#define DUK__BP_BXOR 18

Definition at line 57967 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_CALL

#define DUK__BP_CALL 34

Definition at line 57975 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_CLOSING

#define DUK__BP_CLOSING 4 /* token closes expression, e.g. ')', ']' */

Definition at line 57959 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_COMMA

#define DUK__BP_COMMA 6

Definition at line 57961 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_var_decl().

◆ DUK__BP_CONDITIONAL

#define DUK__BP_CONDITIONAL 10

Definition at line 57963 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_EOF

#define DUK__BP_EOF 2

Definition at line 57958 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_EQUALITY

#define DUK__BP_EQUALITY 22

Definition at line 57969 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_FOR_EXPR

#define DUK__BP_FOR_EXPR DUK__BP_CLOSING /* bp to use when parsing a top level Expression */

Definition at line 57960 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_try_stmt().

◆ DUK__BP_INVALID

#define DUK__BP_INVALID 0 /* always terminates led() */

Definition at line 57957 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_LAND

#define DUK__BP_LAND 14

Definition at line 57965 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_LOR

#define DUK__BP_LOR 12

Definition at line 57964 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_MEMBER

#define DUK__BP_MEMBER 36

Definition at line 57976 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_MULTIPLICATIVE

#define DUK__BP_MULTIPLICATIVE 30

Definition at line 57973 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_POSTFIX

#define DUK__BP_POSTFIX 32

Definition at line 57974 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_RELATIONAL

#define DUK__BP_RELATIONAL 24

Definition at line 57970 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BP_SHIFT

#define DUK__BP_SHIFT 26

Definition at line 57971 of file duktape-1.8.0/src/duktape.c.

◆ DUK__BYTECODE_INITIAL_ALLOC

#define DUK__BYTECODE_INITIAL_ALLOC 256

Definition at line 11669 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CF_ACCEPT

#define DUK__CF_ACCEPT (1 << 1) /* accept string */

Definition at line 24756 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CF_ACCEPT_NUL

#define DUK__CF_ACCEPT_NUL (1 << 2) /* accept string if next char is NUL (otherwise reject) */

Definition at line 24757 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CF_NEG

#define DUK__CF_NEG (1 << 0) /* continue matching, set neg_tzoffset flag */

Definition at line 24755 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CHECK_BITMASK

#define DUK__CHECK_BITMASK	(		table,
			cp ) ((table)[(cp) >> 3] & (1 << ((cp) & 0x07)))

Definition at line 27826 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CHECK_SPACE

#define DUK__CHECK_SPACE ( )

Value:

        do { \
        if (DUK_UNLIKELY(thr->valstack_top >= thr->valstack_end)) { \
            DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \
        } \
    } while (0)

Definition at line 15045 of file duktape-1.8.0/src/duktape.c.

 
#ifndef DUK_USE_VARIADIC_MACROS
DUK_EXTERNAL const char *duk_api_global_filename = NULL;
DUK_EXTERNAL duk_int_t duk_api_global_line = 0;
#endif

Referenced by duk_dup_top(), and duk_push_undefined().

◆ DUK__CLASS_BITS

#define DUK__CLASS_BITS 5

Definition at line 53573 of file duktape-1.8.0/src/duktape.c.

◆ DUK__COMPILE_ENTRY_SLOTS

#define DUK__COMPILE_ENTRY_SLOTS 8

Definition at line 57779 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CONST

#define DUK__CONST ( x ) (*(consts + (x)))

Definition at line 67525 of file duktape-1.8.0/src/duktape.c.

◆ DUK__CONST_MARKER

#define DUK__CONST_MARKER DUK_JS_CONST_MARKER

Definition at line 57747 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK__CONSTP

#define DUK__CONSTP ( x ) (consts + (x))

Definition at line 67526 of file duktape-1.8.0/src/duktape.c.

◆ DUK__DELETED_MARKER

#define DUK__DELETED_MARKER ( heap ) DUK_STRTAB_DELETED_MARKER((heap))

Definition at line 45015 of file duktape-1.8.0/src/duktape.c.

◆ DUK__DIGITCHAR

#define DUK__DIGITCHAR ( x ) duk_lc_digits[(x)]

Definition at line 75404 of file duktape-1.8.0/src/duktape.c.

◆ DUK__DPRINT_DPARTS

#define DUK__DPRINT_DPARTS ( dparts )

Value:

        do { \
        DUK_D(DUK_DPRINT("dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
                         (double) (dparts)[0], (double) (dparts)[1], \
                         (double) (dparts)[2], (double) (dparts)[3], \
                         (double) (dparts)[4], (double) (dparts)[5], \
                         (double) (dparts)[6], (double) (dparts)[7])); \
    } while (0)

Definition at line 24660 of file duktape-1.8.0/src/duktape.c.

        DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld, dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
                         (long) (parts)[0], (long) (parts)[1], \
                         (long) (parts)[2], (long) (parts)[3], \
                         (long) (parts)[4], (long) (parts)[5], \
                         (long) (parts)[6], (long) (parts)[7], \
                         (double) (dparts)[0], (double) (dparts)[1], \
                         (double) (dparts)[2], (double) (dparts)[3], \

◆ DUK__DPRINT_PARTS

#define DUK__DPRINT_PARTS ( parts )

Value:

        do { \
        DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld", \
                         (long) (parts)[0], (long) (parts)[1], \
                         (long) (parts)[2], (long) (parts)[3], \
                         (long) (parts)[4], (long) (parts)[5], \
                         (long) (parts)[6], (long) (parts)[7])); \
    } while (0)

Definition at line 24653 of file duktape-1.8.0/src/duktape.c.

 
/*
 *  Other file level defines
 */
 
/* Debug macro to print all parts and dparts (used manually because of debug level). */
#define  DUK__DPRINT_PARTS_AND_DPARTS(parts,dparts)  do { \

◆ DUK__DPRINT_PARTS_AND_DPARTS

#define DUK__DPRINT_PARTS_AND_DPARTS	(		parts,
			dparts )

Value:

        do { \
        DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld, dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
                         (long) (parts)[0], (long) (parts)[1], \
                         (long) (parts)[2], (long) (parts)[3], \
                         (long) (parts)[4], (long) (parts)[5], \
                         (long) (parts)[6], (long) (parts)[7], \
                         (double) (dparts)[0], (double) (dparts)[1], \
                         (double) (dparts)[2], (double) (dparts)[3], \
                         (double) (dparts)[4], (double) (dparts)[5], \
                         (double) (dparts)[6], (double) (dparts)[7])); \
    } while (0)

Definition at line 24642 of file duktape-1.8.0/src/duktape.c.

 
/* include removed: duk_internal.h */
 
/*
 *  Forward declarations
 */
 
DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset);
DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags);
DUK_LOCAL_DECL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val);
DUK_LOCAL_DECL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, duk_small_uint_t flags);

◆ DUK__DRAGON4_OUTPUT_PREINC

#define DUK__DRAGON4_OUTPUT_PREINC	(	nc_ctx,
		preinc_idx,
		x )

Value:

        do { \
        DUK_ASSERT((preinc_idx) - 1 >= 0); \
        DUK_ASSERT((preinc_idx) - 1 < DUK__MAX_OUTPUT_DIGITS); \
        ((nc_ctx)->digits[(preinc_idx) - 1]) = (duk_uint8_t) (x); \
    } while (0)

Definition at line 76053 of file duktape-1.8.0/src/duktape.c.

    duk_small_int_t e;             /* exponent for 'f' */
    duk_small_int_t b;             /* input radix */
    duk_small_int_t B;             /* output radix */
    duk_small_int_t k;             /* see algorithm */
    duk_small_int_t low_ok;        /* see algorithm */

◆ DUK__DUMP_ISPEC

#define DUK__DUMP_ISPEC	(		comp_ctx,
			x ) do {} while (0)

Definition at line 59526 of file duktape-1.8.0/src/duktape.c.

◆ DUK__DUMP_IVALUE

#define DUK__DUMP_IVALUE	(		comp_ctx,
			x ) do {} while (0)

Definition at line 59527 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_1

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

Definition at line 30135 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_2

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

Definition at line 30136 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_CSTR

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

Definition at line 30139 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_FLAG_A_IS_SOURCE

#define DUK__EMIT_FLAG_A_IS_SOURCE (1 << 11) /* slot A is a source (default: target) */

Definition at line 58722 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_var_decl().

◆ DUK__EMIT_FLAG_B_IS_TARGET

#define DUK__EMIT_FLAG_B_IS_TARGET (1 << 12) /* slot B is a target (default: source) */

Definition at line 58723 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_FLAG_B_IS_TARGETSOURCE

#define DUK__EMIT_FLAG_B_IS_TARGETSOURCE (1 << 14) /* slot B is both a target and a source (used by extraops like DUK_EXTRAOP_INSTOF */

Definition at line 58725 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_FLAG_C_IS_TARGET

#define DUK__EMIT_FLAG_C_IS_TARGET (1 << 13) /* slot C is a target (default: source) */

Definition at line 58724 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_FLAG_NO_SHUFFLE_A

#define DUK__EMIT_FLAG_NO_SHUFFLE_A (1 << 8)

Definition at line 58719 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__emit_invalid(), duk__emit_jump(), duk__init_varmap_and_prologue_for_pass2(), and duk__parse_func_body().

◆ DUK__EMIT_FLAG_NO_SHUFFLE_B

#define DUK__EMIT_FLAG_NO_SHUFFLE_B (1 << 9)

Definition at line 58720 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_FLAG_NO_SHUFFLE_C

#define DUK__EMIT_FLAG_NO_SHUFFLE_C (1 << 10)

Definition at line 58721 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__emit_invalid().

◆ DUK__EMIT_FLAG_RESERVE_JUMPSLOT

#define DUK__EMIT_FLAG_RESERVE_JUMPSLOT (1 << 15) /* reserve a jumpslot after instr before target spilling, used for NEXTENUM */

Definition at line 58726 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_HSTR

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

Definition at line 30137 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EMIT_STRIDX

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

Definition at line 30141 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ENUM_START_INDEX

#define DUK__ENUM_START_INDEX 2

Definition at line 46405 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__sort_array_indices().

◆ DUK__ERRFMT_BUFSIZE

#define DUK__ERRFMT_BUFSIZE 256 /* size for formatting buffers */

Definition at line 9774 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_handle_error().

◆ DUK__EXPR_FLAG_ALLOW_EMPTY

#define DUK__EXPR_FLAG_ALLOW_EMPTY (1 << 9) /* allow empty expression */

Definition at line 62476 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EXPR_FLAG_REJECT_IN

#define DUK__EXPR_FLAG_REJECT_IN (1 << 8) /* reject 'in' token (used for for-in) */

Definition at line 62475 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EXPR_FLAG_REQUIRE_INIT

#define DUK__EXPR_FLAG_REQUIRE_INIT (1 << 10) /* require initializer for var/const */

Definition at line 62477 of file duktape-1.8.0/src/duktape.c.

◆ DUK__EXPR_RBP_MASK

#define DUK__EXPR_RBP_MASK 0xff

Definition at line 62474 of file duktape-1.8.0/src/duktape.c.

◆ DUK__FLD_16BIT

#define DUK__FLD_16BIT 1

Definition at line 24046 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_32BIT

#define DUK__FLD_32BIT 2

Definition at line 24047 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_8BIT

#define DUK__FLD_8BIT 0

Definition at line 24045 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_BIGENDIAN

#define DUK__FLD_BIGENDIAN (1 << 3)

Definition at line 24051 of file duktape-1.8.0/src/duktape.c.

◆ DUK__FLD_DOUBLE

#define DUK__FLD_DOUBLE 4

Definition at line 24049 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_FLOAT

#define DUK__FLD_FLOAT 3

Definition at line 24048 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_SIGNED

#define DUK__FLD_SIGNED (1 << 4)

Definition at line 24052 of file duktape-1.8.0/src/duktape.c.

◆ DUK__FLD_TYPEDARRAY

#define DUK__FLD_TYPEDARRAY (1 << 5)

Definition at line 24053 of file duktape-1.8.0/src/duktape.c.

◆ DUK__FLD_VARINT

#define DUK__FLD_VARINT 5

Definition at line 24050 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield().

◆ DUK__FUN

#define DUK__FUN ( ) ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC((thr)->callstack + (thr)->callstack_top - 1))

Definition at line 67516 of file duktape-1.8.0/src/duktape.c.

◆ DUK__FUNCTION_BODY_REQUIRE_SLOTS

#define DUK__FUNCTION_BODY_REQUIRE_SLOTS 16

Definition at line 57781 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK__FUNCTION_INIT_REQUIRE_SLOTS

#define DUK__FUNCTION_INIT_REQUIRE_SLOTS 16

Definition at line 57780 of file duktape-1.8.0/src/duktape.c.

◆ DUK__GETCONST_MAX_CONSTS_CHECK

#define DUK__GETCONST_MAX_CONSTS_CHECK 256

Definition at line 57754 of file duktape-1.8.0/src/duktape.c.

◆ DUK__GETTEMP

#define DUK__GETTEMP ( comp_ctx ) ((comp_ctx)->curr_func.temp_next)

Definition at line 59490 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK__HAS_TERM

#define DUK__HAS_TERM (1 << 1) /* stmt has explicit/implicit semicolon terminator */

Definition at line 62668 of file duktape-1.8.0/src/duktape.c.

◆ DUK__HAS_VAL

#define DUK__HAS_VAL (1 << 0) /* stmt has non-empty value */

Definition at line 62667 of file duktape-1.8.0/src/duktape.c.

◆ DUK__HASH_DELETED

#define DUK__HASH_DELETED DUK_HOBJECT_HASHIDX_DELETED

Definition at line 47482 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK__HASH_INITIAL [1/2]

#define DUK__HASH_INITIAL	(		hash,
			h_size ) DUK_STRTAB_HASH_INITIAL((hash),(h_size))

Definition at line 45013 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK__HASH_INITIAL [2/2]

#define DUK__HASH_INITIAL	(		hash,
			h_size ) DUK_HOBJECT_HASH_INITIAL((hash),(h_size))

Definition at line 45013 of file duktape-1.8.0/src/duktape.c.

◆ DUK__HASH_PROBE_STEP [1/2]

#define DUK__HASH_PROBE_STEP ( hash ) DUK_STRTAB_HASH_PROBE_STEP((hash))

Definition at line 45014 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK__HASH_PROBE_STEP [2/2]

#define DUK__HASH_PROBE_STEP ( hash ) DUK_HOBJECT_HASH_PROBE_STEP((hash))

Definition at line 45014 of file duktape-1.8.0/src/duktape.c.

◆ DUK__HASH_SIZE_RATIO

#define DUK__HASH_SIZE_RATIO 1177 /* floor(1.15 * (1 << 10)) */

Definition at line 11350 of file duktape-1.8.0/src/duktape.c.

◆ DUK__HASH_UNUSED

#define DUK__HASH_UNUSED DUK_HOBJECT_HASHIDX_UNUSED

Definition at line 47481 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK__HEAP_CLEAR_FLAGS

#define DUK__HEAP_CLEAR_FLAGS	(		heap,
			bits )

Value:

        do { \
        (heap)->flags &= ~(bits); \
    } while (0)

Definition at line 6701 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING                       (1 << 3)  /* an error handler (user callback to augment/replace error) is running */
#define DUK_HEAP_FLAG_INTERRUPT_RUNNING                        (1 << 4)  /* executor interrupt running (used to avoid nested interrupts) */
#define DUK_HEAP_FLAG_FINALIZER_NORESCUE                       (1 << 5)  /* heap destruction ongoing, finalizer rescue no longer possible */

◆ DUK__HEAP_HAS_FLAGS

#define DUK__HEAP_HAS_FLAGS	(		heap,
			bits ) ((heap)->flags & (bits))

Definition at line 6697 of file duktape-1.8.0/src/duktape.c.

◆ DUK__HEAP_SET_FLAGS

#define DUK__HEAP_SET_FLAGS	(		heap,
			bits )

Value:

        do { \
        (heap)->flags |= (bits); \
    } while (0)

Definition at line 6698 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING                     (1 << 0)  /* mark-and-sweep is currently running */
#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED            (1 << 1)  /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
#define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING                     (1 << 2)  /* refcount code is processing refzero list */

◆ DUK__IDX_DUKTAPE

#define DUK__IDX_DUKTAPE 5 /* Duktape object */

Definition at line 28821 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_EXPORTS

#define DUK__IDX_EXPORTS 9 /* Default exports table */

Definition at line 28825 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_FRESH_REQUIRE

#define DUK__IDX_FRESH_REQUIRE 8 /* New require() function for module, updated resolution base */

Definition at line 28824 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_LASTCOMP

#define DUK__IDX_LASTCOMP 4 /* Last component name in resolved path */

Definition at line 28820 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_MODLOADED

#define DUK__IDX_MODLOADED 6 /* Duktape.modLoaded[] module cache */

Definition at line 28822 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_MODULE

#define DUK__IDX_MODULE 10 /* Module object containing module.exports, etc */

Definition at line 28826 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_REQUESTED_ID

#define DUK__IDX_REQUESTED_ID 0 /* Module id requested */

Definition at line 28816 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_REQUIRE

#define DUK__IDX_REQUIRE 1 /* Current require() function */

Definition at line 28817 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_REQUIRE_ID

#define DUK__IDX_REQUIRE_ID 2 /* The base ID of the current require() function, resolution base */

Definition at line 28818 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_RESOLVED_ID

#define DUK__IDX_RESOLVED_ID 3 /* Resolved, normalized absolute module ID */

Definition at line 28819 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IDX_UNDEFINED

#define DUK__IDX_UNDEFINED 7 /* 'undefined', artifact of lookup */

Definition at line 28823 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IEEE_DOUBLE_EXP_BIAS

#define DUK__IEEE_DOUBLE_EXP_BIAS 1023

Definition at line 75401 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IEEE_DOUBLE_EXP_MIN

#define DUK__IEEE_DOUBLE_EXP_MIN (-1022) /* biased exp == 0 -> denormal, exp -1022 */

Definition at line 75402 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__dragon4_ctx_to_double().

◆ DUK__INITBUFFER

#define DUK__INITBUFFER ( lex_ctx ) duk__initbuffer((lex_ctx))

Definition at line 73409 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__INTERNAL_ERROR

#define DUK__INTERNAL_ERROR ( msg )

Value:

        do { \
        DUK_ERROR_INTERNAL(thr, (msg)); \
    } while (0)

Definition at line 67542 of file duktape-1.8.0/src/duktape.c.

#define DUK__CONST(x)       (*(consts + (x)))
#define DUK__CONSTP(x)      (consts + (x))
#if 0

◆ DUK__IS_TERMINAL

#define DUK__IS_TERMINAL (1 << 4) /* statement is guaranteed to be terminal (control doesn't flow to next statement) */

Definition at line 62671 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ISCONST

#define DUK__ISCONST	(		comp_ctx,
			x ) (((x) & DUK__CONST_MARKER) != 0)

Definition at line 59488 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ISDIGIT

#define DUK__ISDIGIT ( x ) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_9)

Definition at line 73399 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ISDIGIT03

#define DUK__ISDIGIT03 ( x ) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_3)

Definition at line 73402 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ISDIGIT47

#define DUK__ISDIGIT47 ( x ) ((x) >= DUK_ASC_4 && (x) <= DUK_ASC_7)

Definition at line 73403 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ISHEXDIGIT

#define DUK__ISHEXDIGIT ( x ) duk__is_hex_digit((x))

Definition at line 73400 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ISOCTDIGIT

#define DUK__ISOCTDIGIT ( x ) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_7)

Definition at line 73401 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ISREG

#define DUK__ISREG	(		comp_ctx,
			x ) (((x) & DUK__CONST_MARKER) == 0)

Definition at line 59487 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ISTEMP

#define DUK__ISTEMP	(		comp_ctx,
			x ) (DUK__ISREG((comp_ctx), (x)) && (duk_regconst_t) (x) >= (duk_regconst_t) ((comp_ctx)->curr_func.temp_first))

Definition at line 59489 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ITER_EVERY

#define DUK__ITER_EVERY 0

Definition at line 21419 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ITER_FILTER

#define DUK__ITER_FILTER 4

Definition at line 21423 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ITER_FOREACH

#define DUK__ITER_FOREACH 2

Definition at line 21421 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ITER_MAP

#define DUK__ITER_MAP 3

Definition at line 21422 of file duktape-1.8.0/src/duktape.c.

◆ DUK__ITER_SOME

#define DUK__ITER_SOME 1

Definition at line 21420 of file duktape-1.8.0/src/duktape.c.

◆ DUK__IVAL_FLAG_ALLOW_CONST

#define DUK__IVAL_FLAG_ALLOW_CONST (1 << 0) /* allow a constant to be returned */

Definition at line 59500 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), and duk__lookup_active_register_binding().

◆ DUK__IVAL_FLAG_REQUIRE_SHORT

#define DUK__IVAL_FLAG_REQUIRE_SHORT (1 << 2) /* require a short (8-bit) reg/const which fits into bytecode B/C slot */

Definition at line 59502 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK__IVAL_FLAG_REQUIRE_TEMP

#define DUK__IVAL_FLAG_REQUIRE_TEMP (1 << 1) /* require a (mutable) temporary as a result (or a const if allowed) */

Definition at line 59501 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), and duk__lookup_active_register_binding().

◆ DUK__JSON_DECSTR_BUFSIZE

#define DUK__JSON_DECSTR_BUFSIZE 128

Definition at line 29114 of file duktape-1.8.0/src/duktape.c.

◆ DUK__JSON_DECSTR_CHUNKSIZE

#define DUK__JSON_DECSTR_CHUNKSIZE 64

Definition at line 29115 of file duktape-1.8.0/src/duktape.c.

◆ DUK__JSON_ENCSTR_CHUNKSIZE

#define DUK__JSON_ENCSTR_CHUNKSIZE 64

Definition at line 29116 of file duktape-1.8.0/src/duktape.c.

◆ DUK__JSON_MAX_ESC_LEN

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

Definition at line 29118 of file duktape-1.8.0/src/duktape.c.

◆ DUK__JSON_STRINGIFY_BUFSIZE

#define DUK__JSON_STRINGIFY_BUFSIZE 128

Definition at line 29117 of file duktape-1.8.0/src/duktape.c.

◆ DUK__L0

#define DUK__L0 ( ) DUK__LOOKUP(lex_ctx, 0)

Definition at line 73413 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L1

#define DUK__L1 ( ) DUK__LOOKUP(lex_ctx, 1)

Definition at line 73414 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L2

#define DUK__L2 ( ) DUK__LOOKUP(lex_ctx, 2)

Definition at line 73415 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L3

#define DUK__L3 ( ) DUK__LOOKUP(lex_ctx, 3)

Definition at line 73416 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L4

#define DUK__L4 ( ) DUK__LOOKUP(lex_ctx, 4)

Definition at line 73417 of file duktape-1.8.0/src/duktape.c.

◆ DUK__L5

#define DUK__L5 ( ) DUK__LOOKUP(lex_ctx, 5)

Definition at line 73418 of file duktape-1.8.0/src/duktape.c.

◆ DUK__LENGTH_PROP_BITS

#define DUK__LENGTH_PROP_BITS 3

Definition at line 53582 of file duktape-1.8.0/src/duktape.c.

◆ DUK__LOCAL_TZOFFSET_MAXITER

#define DUK__LOCAL_TZOFFSET_MAXITER 4

Definition at line 25043 of file duktape-1.8.0/src/duktape.c.

◆ DUK__LONGJMP_RESTART

#define DUK__LONGJMP_RESTART 0 /* state updated, restart bytecode execution */

Definition at line 66143 of file duktape-1.8.0/src/duktape.c.

◆ DUK__LONGJMP_RETHROW

#define DUK__LONGJMP_RETHROW 1 /* exit bytecode executor by rethrowing an error to caller */

Definition at line 66144 of file duktape-1.8.0/src/duktape.c.

◆ DUK__LOOKUP

#define DUK__LOOKUP	(		lex_ctx,
			index ) ((lex_ctx)->window[(index)].codepoint)

Definition at line 73406 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__MAGIC_BITS

#define DUK__MAGIC_BITS 16

Definition at line 53585 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_ARRAY_INIT_VALUES

#define DUK__MAX_ARRAY_INIT_VALUES 20

Definition at line 57750 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_CONSTS

#define DUK__MAX_CONSTS DUK_BC_BC_MAX

Definition at line 57759 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_FORMATTED_LENGTH

#define DUK__MAX_FORMATTED_LENGTH 1040 /* (-Number.MAX_VALUE).toString(2).length == 1025, + spare */

Definition at line 76018 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_FUNCS

#define DUK__MAX_FUNCS DUK_BC_BC_MAX

Definition at line 57760 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_OBJECT_INIT_PAIRS

#define DUK__MAX_OBJECT_INIT_PAIRS 10

Definition at line 57751 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_OUTPUT_DIGITS

#define DUK__MAX_OUTPUT_DIGITS 1040 /* (Number.MAX_VALUE).toString(2).length == 1024, + spare */

Definition at line 76015 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_RE_DECESC_DIGITS

#define DUK__MAX_RE_DECESC_DIGITS 9

Definition at line 73395 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_RE_QUANT_DIGITS

#define DUK__MAX_RE_QUANT_DIGITS 9 /* Does not allow e.g. 2**31-1, but one more would allow overflows of u32. */

Definition at line 73396 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MAX_TEMPS

#define DUK__MAX_TEMPS 0xffffL

Definition at line 57761 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MK_LBP

#define DUK__MK_LBP ( bp ) ((bp) >> 1) /* bp is assumed to be even */

Definition at line 57985 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MK_LBP_FLAGS

#define DUK__MK_LBP_FLAGS	(		bp,
			flags ) (((bp) >> 1) \| (flags))

Definition at line 57986 of file duktape-1.8.0/src/duktape.c.

◆ DUK__MKBITS

#define DUK__MKBITS	(	a,
		b,
		c,
		d,
		e,
		f,
		g,
		h )

Value:

    ((duk_uint8_t) ( \
    ((a) << 0) | ((b) << 1) | ((c) << 2) | ((d) << 3) | \
    ((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7) \
    ))

Definition at line 27822 of file duktape-1.8.0/src/duktape.c.

 *  Global object built-ins
 */
 
/* include removed: duk_internal.h */

◆ DUK__MKESC

#define DUK__MKESC	(	nybbles,
		esc1,
		esc2 )

Value:

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

Definition at line 30178 of file duktape-1.8.0/src/duktape.c.

 
DUK_LOCAL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx) {
    duk_hstring *h;

◆ DUK__NARGS_BITS

#define DUK__NARGS_BITS 3

Definition at line 53583 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NARGS_VARARGS_MARKER

#define DUK__NARGS_VARARGS_MARKER 0x07

Definition at line 53587 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NATIDX_BITS

#define DUK__NATIDX_BITS 8

Definition at line 53576 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NO_ARRAY_INDEX

#define DUK__NO_ARRAY_INDEX DUK_HSTRING_NO_ARRAY_INDEX

Definition at line 47474 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK__NO_BIDX_MARKER

#define DUK__NO_BIDX_MARKER 0x7f

Definition at line 53589 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NO_CLASS_MARKER

#define DUK__NO_CLASS_MARKER 0x00 /* 0 = DUK_HOBJECT_CLASS_UNUSED */

Definition at line 53588 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NO_EXP

#define DUK__NO_EXP (65536) /* arbitrary marker, outside valid exp range */

Definition at line 76583 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NO_STRIDX_MARKER

#define DUK__NO_STRIDX_MARKER 0xff

Definition at line 53590 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NUM_FUNC_PROPS_BITS

#define DUK__NUM_FUNC_PROPS_BITS 6

Definition at line 53578 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NUM_ISO8601_PARSER_PARTS

#define DUK__NUM_ISO8601_PARSER_PARTS 9

Definition at line 24710 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NUM_NORMAL_PROPS_BITS

#define DUK__NUM_NORMAL_PROPS_BITS 6

Definition at line 53577 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NUMCONV_CTX_BIGINTS_SIZE

#define DUK__NUMCONV_CTX_BIGINTS_SIZE (sizeof(duk__bigint) * DUK__NUMCONV_CTX_NUM_BIGINTS)

Definition at line 76022 of file duktape-1.8.0/src/duktape.c.

◆ DUK__NUMCONV_CTX_NUM_BIGINTS

#define DUK__NUMCONV_CTX_NUM_BIGINTS 7

Definition at line 76021 of file duktape-1.8.0/src/duktape.c.

◆ DUK__OBJ_LIT_KEY_GET

#define DUK__OBJ_LIT_KEY_GET (1 << 1) /* key encountered as a getter */

Definition at line 60452 of file duktape-1.8.0/src/duktape.c.

◆ DUK__OBJ_LIT_KEY_PLAIN

#define DUK__OBJ_LIT_KEY_PLAIN (1 << 0) /* key encountered as a plain property */

Definition at line 60451 of file duktape-1.8.0/src/duktape.c.

◆ DUK__OBJ_LIT_KEY_SET

#define DUK__OBJ_LIT_KEY_SET (1 << 2) /* key encountered as a setter */

Definition at line 60453 of file duktape-1.8.0/src/duktape.c.

◆ DUK__OUTPUT_TYPE_FILENAME

#define DUK__OUTPUT_TYPE_FILENAME 0

Definition at line 27186 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK__OUTPUT_TYPE_LINENUMBER

#define DUK__OUTPUT_TYPE_LINENUMBER 1

Definition at line 27187 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK__OUTPUT_TYPE_TRACEBACK

#define DUK__OUTPUT_TYPE_TRACEBACK (-1)

Definition at line 27185 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PACK_ARGS

#define DUK__PACK_ARGS	(	classnum,
		protobidx,
		elemtype,
		elemshift,
		isview ) (((classnum) << 24) \| ((protobidx) << 16) \| ((elemtype) << 8) \| ((elemshift) << 4) \| (isview))

Definition at line 18931 of file duktape-1.8.0/src/duktape.c.

18931 DUK_ERROR_ALLOC_DEFMSG(thr);

18932 }

DUK_ERROR_ALLOC_DEFMSG

#define DUK_ERROR_ALLOC_DEFMSG(thr)

Definition duktape-1.8.0/src/duktape.c:7894

◆ DUK__PACK_RULE

#define DUK__PACK_RULE	(	partmask,
		sepmask,
		nextpart,
		flags )

Value:

    ((duk_uint32_t) (partmask) + \
     (((duk_uint32_t) (sepmask)) << 9) + \
     (((duk_uint32_t) (nextpart)) << 17) + \
     (((duk_uint32_t) (flags)) << 21))

Definition at line 24759 of file duktape-1.8.0/src/duktape.c.

#define DUK__SI_NUL          7
 
/* Parser separator masks. */
#define DUK__SM_PLUS         (1 << DUK__SI_PLUS)
#define DUK__SM_MINUS        (1 << DUK__SI_MINUS)

◆ DUK__PARSE_EXPR_SLOTS

#define DUK__PARSE_EXPR_SLOTS 16

Definition at line 57783 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PARSE_STATEMENTS_SLOTS

#define DUK__PARSE_STATEMENTS_SLOTS 16

Definition at line 57782 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_DAY

#define DUK__PI_DAY 2

Definition at line 24715 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_HOUR

#define DUK__PI_HOUR 3

Definition at line 24716 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_MILLISECOND

#define DUK__PI_MILLISECOND 6

Definition at line 24719 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_MINUTE

#define DUK__PI_MINUTE 4

Definition at line 24717 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_MONTH

#define DUK__PI_MONTH 1

Definition at line 24714 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_SECOND

#define DUK__PI_SECOND 5

Definition at line 24718 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_TZHOUR

#define DUK__PI_TZHOUR 7

Definition at line 24720 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_TZMINUTE

#define DUK__PI_TZMINUTE 8

Definition at line 24721 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PI_YEAR

#define DUK__PI_YEAR 0

Definition at line 24713 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_DAY

#define DUK__PM_DAY (1 << DUK__PI_DAY)

Definition at line 24726 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_HOUR

#define DUK__PM_HOUR (1 << DUK__PI_HOUR)

Definition at line 24727 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_MILLISECOND

#define DUK__PM_MILLISECOND (1 << DUK__PI_MILLISECOND)

Definition at line 24730 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_MINUTE

#define DUK__PM_MINUTE (1 << DUK__PI_MINUTE)

Definition at line 24728 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_MONTH

#define DUK__PM_MONTH (1 << DUK__PI_MONTH)

Definition at line 24725 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_SECOND

#define DUK__PM_SECOND (1 << DUK__PI_SECOND)

Definition at line 24729 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_TZHOUR

#define DUK__PM_TZHOUR (1 << DUK__PI_TZHOUR)

Definition at line 24731 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_TZMINUTE

#define DUK__PM_TZMINUTE (1 << DUK__PI_TZMINUTE)

Definition at line 24732 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PM_YEAR

#define DUK__PM_YEAR (1 << DUK__PI_YEAR)

Definition at line 24724 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PREVENT_MS_SIDE_EFFECTS

#define DUK__PREVENT_MS_SIDE_EFFECTS ( heap )

Value:

        do { \
        (heap)->mark_and_sweep_base_flags |= \
                DUK_MS_FLAG_NO_STRINGTABLE_RESIZE |  /* avoid recursive string table call */ \
                DUK_MS_FLAG_NO_FINALIZERS |          /* avoid pressure to add/remove strings, invalidation of call data argument, etc. */ \
                DUK_MS_FLAG_NO_OBJECT_COMPACTION;    /* avoid array abandoning which interns strings */ \
    } while (0)

Definition at line 45019 of file duktape-1.8.0/src/duktape.c.

    DUK_ERROR_INTERNAL_DEFMSG(thr);
    return 0;
}
#line 1 "duk_heap_stringtable.c"
/*
 *  Heap stringtable handling, string interning.

◆ DUK__PROP_FLAGS_BITS

#define DUK__PROP_FLAGS_BITS 3

Definition at line 53579 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_ACCESSOR

#define DUK__PROP_TYPE_ACCESSOR 7

Definition at line 53599 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_BITS

#define DUK__PROP_TYPE_BITS 3

Definition at line 53584 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_BOOLEAN_FALSE

#define DUK__PROP_TYPE_BOOLEAN_FALSE 6

Definition at line 53598 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_BOOLEAN_TRUE

#define DUK__PROP_TYPE_BOOLEAN_TRUE 5

Definition at line 53597 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_BUILTIN

#define DUK__PROP_TYPE_BUILTIN 3

Definition at line 53595 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_DOUBLE

#define DUK__PROP_TYPE_DOUBLE 0

Definition at line 53592 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_STRIDX

#define DUK__PROP_TYPE_STRIDX 2

Definition at line 53594 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_STRING

#define DUK__PROP_TYPE_STRING 1

Definition at line 53593 of file duktape-1.8.0/src/duktape.c.

◆ DUK__PROP_TYPE_UNDEFINED

#define DUK__PROP_TYPE_UNDEFINED 4

Definition at line 53596 of file duktape-1.8.0/src/duktape.c.

◆ DUK__RCISREG

#define DUK__RCISREG ( x ) (((x) & 0x100) == 0)

Definition at line 67537 of file duktape-1.8.0/src/duktape.c.

◆ DUK__RE_BUFLEN

#define DUK__RE_BUFLEN ( re_ctx ) DUK_BW_GET_SIZE(re_ctx->thr, &re_ctx->bw)

Definition at line 77685 of file duktape-1.8.0/src/duktape.c.

77685 * maximum supported size. This could be done by limiting the maximum

77686 * input string size (assuming an upper bound can be computed for number

Referenced by duk__parse_disjunction().

◆ DUK__RE_INITIAL_BUFSIZE

#define DUK__RE_INITIAL_BUFSIZE 64

Definition at line 77682 of file duktape-1.8.0/src/duktape.c.

◆ DUK__READABLE_STRING_MAXCHARS

#define DUK__READABLE_STRING_MAXCHARS 32

Definition at line 19678 of file duktape-1.8.0/src/duktape.c.

◆ DUK__RECURSION_DECREASE

#define DUK__RECURSION_DECREASE	(		comp_ctx,
			thr )

Value:

        do { \
        DUK_DDD(DUK_DDDPRINT("RECURSION DECREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \
        duk__recursion_decrease((comp_ctx)); \
    } while (0)

Definition at line 57771 of file duktape-1.8.0/src/duktape.c.

#define DUK__GETCONST_MAX_CONSTS_CHECK    256
 
/* These limits are based on bytecode limits.  Max temps is limited
 * by duk_hcompiledfunction nargs/nregs fields being 16 bits.

Referenced by duk__parse_func_body().

◆ DUK__RECURSION_INCREASE

#define DUK__RECURSION_INCREASE	(		comp_ctx,
			thr )

Value:

        do { \
        DUK_DDD(DUK_DDDPRINT("RECURSION INCREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \
        duk__recursion_increase((comp_ctx)); \
    } while (0)

Definition at line 57766 of file duktape-1.8.0/src/duktape.c.

/* for array and object literals */
#define DUK__MAX_ARRAY_INIT_VALUES        20
#define DUK__MAX_OBJECT_INIT_PAIRS        10
 

Referenced by duk__parse_func_body().

◆ DUK__REG

#define DUK__REG ( x ) (*(thr->valstack_bottom + (x)))

Definition at line 67523 of file duktape-1.8.0/src/duktape.c.

◆ DUK__REGCONST

#define DUK__REGCONST ( x ) (*((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x)))

Definition at line 67538 of file duktape-1.8.0/src/duktape.c.

◆ DUK__REGCONSTP

#define DUK__REGCONSTP ( x ) ((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x))

Definition at line 67539 of file duktape-1.8.0/src/duktape.c.

◆ DUK__REGP

#define DUK__REGP ( x ) (thr->valstack_bottom + (x))

Definition at line 67524 of file duktape-1.8.0/src/duktape.c.

◆ DUK__RETHAND_FINISHED

#define DUK__RETHAND_FINISHED 1 /* exit bytecode execution with return value */

Definition at line 66147 of file duktape-1.8.0/src/duktape.c.

◆ DUK__RETHAND_RESTART

#define DUK__RETHAND_RESTART 0 /* state updated, restart bytecode execution */

Definition at line 66146 of file duktape-1.8.0/src/duktape.c.

◆ DUK__RND_BIT

#define DUK__RND_BIT ( rnd ) ((rnd) >> 31) /* only use the highest bit */

Definition at line 86918 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_util_tinyrandom_get_double().

◆ DUK__RULE_MASK_PART_SEP

#define DUK__RULE_MASK_PART_SEP 0x1ffffUL

Definition at line 24770 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SER_MARKER

#define DUK__SER_MARKER 0xff

Definition at line 11665 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SER_NUMBER

#define DUK__SER_NUMBER 0x01

Definition at line 11668 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SER_STRING

#define DUK__SER_STRING 0x00

Definition at line 11667 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SER_VERSION

#define DUK__SER_VERSION 0x00

Definition at line 11666 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SETTEMP

#define DUK__SETTEMP	(		comp_ctx,
			x ) ((comp_ctx)->curr_func.temp_next = (x)) /* dangerous: must only lower (temp_max not updated) */

Definition at line 59491 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK__SETTEMP_CHECKMAX

#define DUK__SETTEMP_CHECKMAX	(		comp_ctx,
			x ) duk__settemp_checkmax((comp_ctx),(x))

Definition at line 59492 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK__SI_COLON

#define DUK__SI_COLON 4

Definition at line 24739 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_MINUS

#define DUK__SI_MINUS 1

Definition at line 24736 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_NUL

#define DUK__SI_NUL 7

Definition at line 24742 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_PERIOD

#define DUK__SI_PERIOD 5

Definition at line 24740 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_PLUS

#define DUK__SI_PLUS 0

Definition at line 24735 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_SPACE

#define DUK__SI_SPACE 3

Definition at line 24738 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_T

#define DUK__SI_T 2

Definition at line 24737 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SI_Z

#define DUK__SI_Z 6

Definition at line 24741 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_COLON

#define DUK__SM_COLON (1 << DUK__SI_COLON)

Definition at line 24749 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_MINUS

#define DUK__SM_MINUS (1 << DUK__SI_MINUS)

Definition at line 24746 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_NUL

#define DUK__SM_NUL (1 << DUK__SI_NUL)

Definition at line 24752 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_PERIOD

#define DUK__SM_PERIOD (1 << DUK__SI_PERIOD)

Definition at line 24750 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_PLUS

#define DUK__SM_PLUS (1 << DUK__SI_PLUS)

Definition at line 24745 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_SPACE

#define DUK__SM_SPACE (1 << DUK__SI_SPACE)

Definition at line 24748 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_T

#define DUK__SM_T (1 << DUK__SI_T)

Definition at line 24747 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SM_Z

#define DUK__SM_Z (1 << DUK__SI_Z)

Definition at line 24751 of file duktape-1.8.0/src/duktape.c.

◆ DUK__STILL_PROLOGUE

#define DUK__STILL_PROLOGUE (1 << 3) /* statement does not terminate directive prologue */

Definition at line 62670 of file duktape-1.8.0/src/duktape.c.

◆ DUK__STRFTIME_BUF_SIZE

#define DUK__STRFTIME_BUF_SIZE 64

Definition at line 26356 of file duktape-1.8.0/src/duktape.c.

◆ DUK__STRICT

#define DUK__STRICT ( ) (DUK_HOBJECT_HAS_STRICT((duk_hobject *) DUK__FUN()))

Definition at line 67518 of file duktape-1.8.0/src/duktape.c.

◆ DUK__STRIDX_BITS

#define DUK__STRIDX_BITS 9 /* XXX: try to optimize to 8 (would now be possible, <200 used) */

Definition at line 53575 of file duktape-1.8.0/src/duktape.c.

◆ DUK__STRING_CHAR_BITS

#define DUK__STRING_CHAR_BITS 7

Definition at line 53581 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__push_double().

◆ DUK__STRING_LENGTH_BITS

#define DUK__STRING_LENGTH_BITS 8

Definition at line 53580 of file duktape-1.8.0/src/duktape.c.

◆ DUK__STRPTIME_BUF_SIZE

#define DUK__STRPTIME_BUF_SIZE 64

Definition at line 26355 of file duktape-1.8.0/src/duktape.c.

◆ DUK__SYNC_AND_NULL_CURR_PC

#define DUK__SYNC_AND_NULL_CURR_PC ( )

Value:

        do { \
        duk_activation *act; \
        act = thr->callstack + thr->callstack_top - 1; \
        act->curr_pc = curr_pc; \
        thr->ptr_curr_pc = NULL; \
    } while (0)

Definition at line 67556 of file duktape-1.8.0/src/duktape.c.

#define DUK__REGCONSTP(x)   ((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x))
 
#ifdef DUK_USE_VERBOSE_EXECUTOR_ERRORS
#define DUK__INTERNAL_ERROR(msg)  do { \
        DUK_ERROR_INTERNAL(thr, (msg)); \
    } while (0)

◆ DUK__SYNC_CURR_PC

#define DUK__SYNC_CURR_PC ( )

Value:

        do { \
        duk_activation *act; \
        act = thr->callstack + thr->callstack_top - 1; \
        act->curr_pc = curr_pc; \
    } while (0)

Definition at line 67551 of file duktape-1.8.0/src/duktape.c.

 * DUK_LIKELY/DUK_UNLIKELY increases code footprint and doesn't seem to
 * improve performance on x64 (and actually harms performance in some tests).
 */
#define DUK__RCISREG(x)     (((x) & 0x100) == 0)
#define DUK__REGCONST(x)    (*((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x)))

◆ DUK__TAG_NUMBER

#define DUK__TAG_NUMBER 0 /* not exposed */

Definition at line 643 of file duktape-1.8.0/src/duktape.c.

◆ DUK__TOKEN_LBP_BP_MASK

#define DUK__TOKEN_LBP_BP_MASK 0x1f

Definition at line 57978 of file duktape-1.8.0/src/duktape.c.

◆ DUK__TOKEN_LBP_FLAG_NO_REGEXP

#define DUK__TOKEN_LBP_FLAG_NO_REGEXP (1 << 5) /* regexp literal must not follow this token */

Definition at line 57979 of file duktape-1.8.0/src/duktape.c.

◆ DUK__TOKEN_LBP_FLAG_TERMINATES

#define DUK__TOKEN_LBP_FLAG_TERMINATES (1 << 6) /* terminates expression; e.g. post-increment/-decrement */

Definition at line 57980 of file duktape-1.8.0/src/duktape.c.

◆ DUK__TOKEN_LBP_FLAG_UNUSED

#define DUK__TOKEN_LBP_FLAG_UNUSED (1 << 7) /* spare */

Definition at line 57981 of file duktape-1.8.0/src/duktape.c.

◆ DUK__TOKEN_LBP_GET_BP

#define DUK__TOKEN_LBP_GET_BP ( x ) ((duk_small_uint_t) (((x) & DUK__TOKEN_LBP_BP_MASK) * 2))

Definition at line 57983 of file duktape-1.8.0/src/duktape.c.

◆ DUK__UNEMIT_1

#define DUK__UNEMIT_1 ( js_ctx ) duk__unemit_1((js_ctx))

Definition at line 30142 of file duktape-1.8.0/src/duktape.c.

◆ DUK__UNPACK_RULE

#define DUK__UNPACK_RULE	(	rule,
		var_nextidx,
		var_flags )

Value:

        do { \
        (var_nextidx) = (duk_small_uint_t) (((rule) >> 17) & 0x0f); \
        (var_flags) = (duk_small_uint_t) ((rule) >> 21); \
    } while (0)

Definition at line 24765 of file duktape-1.8.0/src/duktape.c.

#define DUK__SM_SPACE        (1 << DUK__SI_SPACE)
#define DUK__SM_COLON        (1 << DUK__SI_COLON)
#define DUK__SM_PERIOD       (1 << DUK__SI_PERIOD)
#define DUK__SM_Z            (1 << DUK__SI_Z)

◆ DUK__UPDATE_RND

#define DUK__UPDATE_RND ( rnd )

Value:

        do { \
        (rnd) += ((rnd) * (rnd)) | 0x05; \
        (rnd) = ((rnd) & 0xffffffffU);       /* if duk_uint32_t is exactly 32 bits, this is a NOP */ \
    } while (0)

Definition at line 86913 of file duktape-1.8.0/src/duktape.c.

    h *= DUK__MAGIC_M;
    h ^= h >> 15;
 
    return h;

Referenced by duk_util_tinyrandom_get_double().

◆ DUK__VALSTACK_PROXY_LOOKUP

#define DUK__VALSTACK_PROXY_LOOKUP 20

Definition at line 47492 of file duktape-1.8.0/src/duktape.c.

◆ DUK__VALSTACK_SPACE

#define DUK__VALSTACK_SPACE 10

Definition at line 47487 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__get_propdesc(), duk__realloc_props(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK__VOLUNTARY_PERIODIC_GC

#define DUK__VOLUNTARY_PERIODIC_GC ( heap )

Value:

        do { \
        (heap)->mark_and_sweep_trigger_counter--; \
        if ((heap)->mark_and_sweep_trigger_counter <= 0) { \
            duk__run_voluntary_gc(heap); \
        } \
    } while (0)

Definition at line 43632 of file duktape-1.8.0/src/duktape.c.

#endif  /* DUK_USE_MARK_AND_SWEEP */
#line 1 "duk_heap_memory.c"
/*
 *  Memory allocation handling.
 */
 

◆ DUK__WEEKDAY_MOD_ADDER

#define DUK__WEEKDAY_MOD_ADDER (20000000 * 7) /* 0x08583b00 */

Definition at line 25051 of file duktape-1.8.0/src/duktape.c.

◆ DUK__YEAR

#define DUK__YEAR ( x ) ((duk_uint8_t) ((x) - 1970))

Definition at line 24673 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ACT_FLAG_BREAKPOINT_ACTIVE

#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE (1 << 5) /* activation has active breakpoint(s) */

Definition at line 6019 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ACT_FLAG_CONSTRUCT

#define DUK_ACT_FLAG_CONSTRUCT (1 << 2) /* function executes as a constructor (called via "new") */

Definition at line 6016 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_ACT_FLAG_DIRECT_EVAL

#define DUK_ACT_FLAG_DIRECT_EVAL (1 << 4) /* activation is a direct eval call */

Definition at line 6018 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_ACT_FLAG_PREVENT_YIELD

#define DUK_ACT_FLAG_PREVENT_YIELD (1 << 3) /* activation prevents yield (native call or "new") */

Definition at line 6017 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_handle_ecma_call_setup().

◆ DUK_ACT_FLAG_STRICT

#define DUK_ACT_FLAG_STRICT (1 << 0) /* function executes in strict mode */

Definition at line 6014 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_handle_ecma_call_setup().

◆ DUK_ACT_FLAG_TAILCALLED

#define DUK_ACT_FLAG_TAILCALLED (1 << 1) /* activation has tail called one or more times */

Definition at line 6015 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_handle_ecma_call_setup().

◆ DUK_ACT_GET_FUNC

#define DUK_ACT_GET_FUNC ( act ) ((act)->func)

Definition at line 6021 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__reconfig_valstack_ecma_return(), and duk_handle_ecma_call_setup().

◆ DUK_ALLOC

#define DUK_ALLOC	(		heap,
			size ) duk_heap_mem_alloc((heap), (size))

Definition at line 6891 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__realloc_props(), and duk_realloc().

◆ DUK_ALLOC_RAW

#define DUK_ALLOC_RAW	(		heap,
			size ) ((heap)->alloc_func((heap)->heap_udata, (size)))

Definition at line 6851 of file duktape-1.8.0/src/duktape.c.

6851 ((heap)->strs[(idx)])

6852#endif

Referenced by duk_realloc_raw().

◆ DUK_ALLOC_ZEROED

#define DUK_ALLOC_ZEROED	(		heap,
			size ) duk_heap_mem_alloc_zeroed((heap), (size))

Definition at line 6892 of file duktape-1.8.0/src/duktape.c.

◆ DUK_API_INTERNAL_H_INCLUDED

#define DUK_API_INTERNAL_H_INCLUDED

Definition at line 4229 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_0

#define DUK_ASC_0 0x30

Definition at line 8119 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_1

#define DUK_ASC_1 0x31

Definition at line 8120 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_2

#define DUK_ASC_2 0x32

Definition at line 8121 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_3

#define DUK_ASC_3 0x33

Definition at line 8122 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_4

#define DUK_ASC_4 0x34

Definition at line 8123 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_5

#define DUK_ASC_5 0x35

Definition at line 8124 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_6

#define DUK_ASC_6 0x36

Definition at line 8125 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_7

#define DUK_ASC_7 0x37

Definition at line 8126 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_8

#define DUK_ASC_8 0x38

Definition at line 8127 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_9

#define DUK_ASC_9 0x39

Definition at line 8128 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_ACK

#define DUK_ASC_ACK 0x06

Definition at line 8077 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_AMP

#define DUK_ASC_AMP 0x26

Definition at line 8109 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_ATSIGN

#define DUK_ASC_ATSIGN 0x40

Definition at line 8135 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_BACKSLASH

#define DUK_ASC_BACKSLASH 0x5c

Definition at line 8163 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__create_escaped_source().

◆ DUK_ASC_BEL

#define DUK_ASC_BEL 0x07

Definition at line 8078 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_BS

#define DUK_ASC_BS 0x08

Definition at line 8079 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_CAN

#define DUK_ASC_CAN 0x18

Definition at line 8095 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_CARET

#define DUK_ASC_CARET 0x5e

Definition at line 8165 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_COLON

#define DUK_ASC_COLON 0x3a

Definition at line 8129 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_COMMA

#define DUK_ASC_COMMA 0x2c

Definition at line 8115 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_CR

#define DUK_ASC_CR 0x0d

Definition at line 8084 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DC1

#define DUK_ASC_DC1 0x11

Definition at line 8088 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DC2

#define DUK_ASC_DC2 0x12

Definition at line 8089 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DC3

#define DUK_ASC_DC3 0x13

Definition at line 8090 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DC4

#define DUK_ASC_DC4 0x14

Definition at line 8091 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DEL

#define DUK_ASC_DEL 0x7f

Definition at line 8198 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DLE

#define DUK_ASC_DLE 0x10

Definition at line 8087 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DOLLAR

#define DUK_ASC_DOLLAR 0x24

Definition at line 8107 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_DOUBLEQUOTE

#define DUK_ASC_DOUBLEQUOTE 0x22

Definition at line 8105 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_EM

#define DUK_ASC_EM 0x19

Definition at line 8096 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_ENQ

#define DUK_ASC_ENQ 0x05

Definition at line 8076 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_EOT

#define DUK_ASC_EOT 0x04

Definition at line 8075 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_EQUALS

#define DUK_ASC_EQUALS 0x3d

Definition at line 8132 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_ESC

#define DUK_ASC_ESC 0x1b

Definition at line 8098 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_ETB

#define DUK_ASC_ETB 0x17

Definition at line 8094 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_ETX

#define DUK_ASC_ETX 0x03

Definition at line 8074 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_EXCLAMATION

#define DUK_ASC_EXCLAMATION 0x21

Definition at line 8104 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_FF

#define DUK_ASC_FF 0x0c

Definition at line 8083 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_FS

#define DUK_ASC_FS 0x1c

Definition at line 8099 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_GRAVE

#define DUK_ASC_GRAVE 0x60

Definition at line 8167 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_GS

#define DUK_ASC_GS 0x1d

Definition at line 8100 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_HASH

#define DUK_ASC_HASH 0x23

Definition at line 8106 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_HT

#define DUK_ASC_HT 0x09

Definition at line 8080 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LANGLE

#define DUK_ASC_LANGLE 0x3c

Definition at line 8131 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LBRACKET

#define DUK_ASC_LBRACKET 0x5b

Definition at line 8162 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LC_A

#define DUK_ASC_LC_A 0x61

Definition at line 8168 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_B

#define DUK_ASC_LC_B 0x62

Definition at line 8169 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_C

#define DUK_ASC_LC_C 0x63

Definition at line 8170 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_D

#define DUK_ASC_LC_D 0x64

Definition at line 8171 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_E

#define DUK_ASC_LC_E 0x65

Definition at line 8172 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_F

#define DUK_ASC_LC_F 0x66

Definition at line 8173 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_G

#define DUK_ASC_LC_G 0x67

Definition at line 8174 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_H

#define DUK_ASC_LC_H 0x68

Definition at line 8175 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_I

#define DUK_ASC_LC_I 0x69

Definition at line 8176 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_J

#define DUK_ASC_LC_J 0x6a

Definition at line 8177 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_K

#define DUK_ASC_LC_K 0x6b

Definition at line 8178 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_L

#define DUK_ASC_LC_L 0x6c

Definition at line 8179 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_M

#define DUK_ASC_LC_M 0x6d

Definition at line 8180 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_N

#define DUK_ASC_LC_N 0x6e

Definition at line 8181 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_O

#define DUK_ASC_LC_O 0x6f

Definition at line 8182 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_P

#define DUK_ASC_LC_P 0x70

Definition at line 8183 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_Q

#define DUK_ASC_LC_Q 0x71

Definition at line 8184 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_R

#define DUK_ASC_LC_R 0x72

Definition at line 8185 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_S

#define DUK_ASC_LC_S 0x73

Definition at line 8186 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_T

#define DUK_ASC_LC_T 0x74

Definition at line 8187 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_U

#define DUK_ASC_LC_U 0x75

Definition at line 8188 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_V

#define DUK_ASC_LC_V 0x76

Definition at line 8189 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_W

#define DUK_ASC_LC_W 0x77

Definition at line 8190 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_X

#define DUK_ASC_LC_X 0x78

Definition at line 8191 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_Y

#define DUK_ASC_LC_Y 0x79

Definition at line 8192 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LC_Z

#define DUK_ASC_LC_Z 0x7a

Definition at line 8193 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_LCURLY

#define DUK_ASC_LCURLY 0x7b

Definition at line 8194 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LF

#define DUK_ASC_LF 0x0a

Definition at line 8081 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LPAREN

#define DUK_ASC_LPAREN 0x28

Definition at line 8111 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_MINUS

#define DUK_ASC_MINUS 0x2d

Definition at line 8116 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_NAK

#define DUK_ASC_NAK 0x15

Definition at line 8092 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_NUL

#define DUK_ASC_NUL 0x00

Definition at line 8071 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_PERCENT

#define DUK_ASC_PERCENT 0x25

Definition at line 8108 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_PERIOD

#define DUK_ASC_PERIOD 0x2e

Definition at line 8117 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_PIPE

#define DUK_ASC_PIPE 0x7c

Definition at line 8195 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_PLUS

#define DUK_ASC_PLUS 0x2b

Definition at line 8114 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_QUESTION

#define DUK_ASC_QUESTION 0x3f

Definition at line 8134 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RANGLE

#define DUK_ASC_RANGLE 0x3e

Definition at line 8133 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RBRACKET

#define DUK_ASC_RBRACKET 0x5d

Definition at line 8164 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RCURLY

#define DUK_ASC_RCURLY 0x7d

Definition at line 8196 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RPAREN

#define DUK_ASC_RPAREN 0x29

Definition at line 8112 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RS

#define DUK_ASC_RS 0x1e

Definition at line 8101 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_SEMICOLON

#define DUK_ASC_SEMICOLON 0x3b

Definition at line 8130 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_SI

#define DUK_ASC_SI 0x0f

Definition at line 8086 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_SINGLEQUOTE

#define DUK_ASC_SINGLEQUOTE 0x27

Definition at line 8110 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_SLASH

#define DUK_ASC_SLASH 0x2f

Definition at line 8118 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_SO

#define DUK_ASC_SO 0x0e

Definition at line 8085 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_SOH

#define DUK_ASC_SOH 0x01

Definition at line 8072 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_SPACE

#define DUK_ASC_SPACE 0x20

Definition at line 8103 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_STAR

#define DUK_ASC_STAR 0x2a

Definition at line 8113 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_STX

#define DUK_ASC_STX 0x02

Definition at line 8073 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_SUB

#define DUK_ASC_SUB 0x1a

Definition at line 8097 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_SYN

#define DUK_ASC_SYN 0x16

Definition at line 8093 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_TILDE

#define DUK_ASC_TILDE 0x7e

Definition at line 8197 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_UC_A

#define DUK_ASC_UC_A 0x41

Definition at line 8136 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_B

#define DUK_ASC_UC_B 0x42

Definition at line 8137 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_C

#define DUK_ASC_UC_C 0x43

Definition at line 8138 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_D

#define DUK_ASC_UC_D 0x44

Definition at line 8139 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_E

#define DUK_ASC_UC_E 0x45

Definition at line 8140 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_F

#define DUK_ASC_UC_F 0x46

Definition at line 8141 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_G

#define DUK_ASC_UC_G 0x47

Definition at line 8142 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_H

#define DUK_ASC_UC_H 0x48

Definition at line 8143 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_I

#define DUK_ASC_UC_I 0x49

Definition at line 8144 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_J

#define DUK_ASC_UC_J 0x4a

Definition at line 8145 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_K

#define DUK_ASC_UC_K 0x4b

Definition at line 8146 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_L

#define DUK_ASC_UC_L 0x4c

Definition at line 8147 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_M

#define DUK_ASC_UC_M 0x4d

Definition at line 8148 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_N

#define DUK_ASC_UC_N 0x4e

Definition at line 8149 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_O

#define DUK_ASC_UC_O 0x4f

Definition at line 8150 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_P

#define DUK_ASC_UC_P 0x50

Definition at line 8151 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_Q

#define DUK_ASC_UC_Q 0x51

Definition at line 8152 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_R

#define DUK_ASC_UC_R 0x52

Definition at line 8153 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_S

#define DUK_ASC_UC_S 0x53

Definition at line 8154 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_T

#define DUK_ASC_UC_T 0x54

Definition at line 8155 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_U

#define DUK_ASC_UC_U 0x55

Definition at line 8156 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_V

#define DUK_ASC_UC_V 0x56

Definition at line 8157 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_W

#define DUK_ASC_UC_W 0x57

Definition at line 8158 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_X

#define DUK_ASC_UC_X 0x58

Definition at line 8159 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_Y

#define DUK_ASC_UC_Y 0x59

Definition at line 8160 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UC_Z

#define DUK_ASC_UC_Z 0x5a

Definition at line 8161 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_UNDERSCORE

#define DUK_ASC_UNDERSCORE 0x5f

Definition at line 8166 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_US

#define DUK_ASC_US 0x1f

Definition at line 8102 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASC_VT

#define DUK_ASC_VT 0x0b

Definition at line 8082 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASSERT

#define DUK_ASSERT ( x ) do { /* assertion omitted */ } while (0)

Definition at line 7787 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__append_jump_offset(), duk__base64_encode_helper(), duk__bi_is_2to52(), duk__coerce_effective_this_binding(), duk__compact_object_list(), duk__create_escaped_source(), duk__dec_decode_hex_escape(), duk__declvar_helper(), duk__delvar_helper(), duk__dump_hbuffer_raw(), duk__enc_buffer(), duk__enc_bufferobject(), duk__err_augment_user(), duk__error_getter_helper(), duk__fill_lexer_buffer(), duk__finalize_helper(), duk__get_buffer_helper(), duk__get_min_grow_e(), duk__get_own_propdesc_raw(), duk__get_propdesc(), duk__getid_open_decl_env_regs(), duk__getprop_shallow_fastpath_array_tval(), duk__getvar_helper(), duk__handle_catch(), duk__handle_executor_error(), duk__hexval(), duk__hstring_is_eval_or_arguments(), duk__inc_data_inner_refcounts(), duk__init_varmap_and_prologue_for_pass2(), duk__ispec_toregconst_raw(), duk__js_samevalue_number(), duk__parse_disjunction(), duk__parse_func_body(), duk__parse_func_formals(), duk__parse_string(), duk__parse_var_decl(), duk__proxy_check_prop(), duk__push_stridx(), duk__put_prop_shared(), duk__putvar_helper(), duk__queue_refzero(), duk__realloc_props(), duk__reconfig_valstack_ecma_return(), duk__resize_valstack(), duk__slow_case_conversion(), duk__sort_array_indices(), duk_bi_boolean_constructor(), duk_bi_boolean_prototype_tostring_shared(), duk_bi_buffer_readfield(), duk_bi_buffer_slice_shared(), duk_bi_duktape_object_info(), duk_bi_regexp_constructor(), duk_bi_string_constructor(), duk_bi_typedarray_set(), duk_bw_init(), duk_bw_insert_raw_area(), duk_bw_write_ensure_slice(), duk_del_prop_stridx(), duk_dup_top(), duk_err_augment_error_create(), duk_err_create_and_throw(), duk_free_hobject_inner(), duk_gc(), duk_get_number(), duk_get_prop_stridx(), duk_get_top(), duk_get_type_mask(), duk_handle_call_protected(), duk_handle_ecma_call_setup(), duk_has_prop_stridx(), duk_hbuffer_reset(), duk_hbuffer_resize(), duk_heap_free_heaphdr_raw(), duk_heap_mem_realloc_indirect(), duk_heap_string_intern_checked(), duk_heap_string_intern_u32_checked(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_find_existing_entry_tval_ptr_and_attrs(), duk_hobject_prepare_property_descriptor(), duk_hobject_putprop(), duk_hstring_char_code_at_raw(), duk_hthread_callstack_grow(), duk_hthread_get_act_prev_pc(), duk_js_instanceof(), duk_js_toboolean(), duk_js_tointeger_number(), duk_lexer_initctx(), duk_lexer_parse_js_input_element(), duk_push_current_thread(), duk_push_hobject_bidx(), duk_push_pointer(), duk_push_string_funcptr(), duk_push_thread_stash(), duk_push_undefined(), duk_put_global_string(), duk_remove(), duk_require_heapptr(), duk_to_boolean(), duk_to_int_clamped_raw(), duk_to_uint16(), duk_to_uint32(), duk_tval_decref(), and duk_unicode_decode_xutf8_checked().

◆ DUK_ASSERT_CTX_VALID

#define DUK_ASSERT_CTX_VALID ( ctx )

Value:

        do { \
        DUK_ASSERT((ctx) != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \
        DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused2 == 0); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack != NULL); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack_bottom); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack_top); \
        DUK_ASSERT_CTX_VSSIZE((ctx)); \
    } while (0)

Definition at line 6133 of file duktape-1.8.0/src/duktape.c.

 
#if defined(DUK_USE_PREFER_SIZE)
#define DUK_ASSERT_CTX_VSSIZE(ctx)  /*nop*/
#else
#define DUK_ASSERT_CTX_VSSIZE(ctx) \
    DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \
        ((duk_hthread *) (ctx))->valstack_size)
#endif
#define DUK_ASSERT_CTX_VALID(ctx) do { \
        DUK_ASSERT((ctx) != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \
        DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \

Referenced by duk__concat_and_join_helper(), duk__get_buffer_helper(), duk__put_prop_shared(), duk__resize_valstack(), duk_alloc(), duk_alloc_raw(), duk_debugger_pause(), duk_decode_string(), duk_del_prop_stridx(), duk_dup_top(), duk_enum(), duk_free(), duk_gc(), duk_get_hobject_with_class(), duk_get_number(), duk_get_prop_stridx(), duk_get_string(), duk_get_top(), duk_handle_call_protected(), duk_has_prop_stridx(), duk_is_array(), duk_is_buffer_data(), duk_is_c_function(), duk_is_function(), duk_push_buffer_raw(), duk_push_c_function_noconstruct_noexotic(), duk_push_c_function_noexotic(), duk_push_current_thread(), duk_push_hobject_bidx(), duk_push_pointer(), duk_push_string_file_raw(), duk_push_thread_stash(), duk_push_undefined(), duk_push_vsprintf(), duk_put_global_string(), duk_put_number_list(), duk_realloc(), duk_realloc_raw(), duk_remove(), duk_require_heapptr(), duk_require_null(), duk_require_top_index(), duk_set_top(), duk_to_boolean(), duk_to_int_clamped_raw(), duk_to_uint16(), and duk_to_uint32().

◆ DUK_ASSERT_CTX_VSSIZE

#define DUK_ASSERT_CTX_VSSIZE ( ctx )

Value:

DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \

((duk_hthread *) (ctx))->valstack_size)

DUK_ASSERT

#define DUK_ASSERT(x)

Definition duktape-1.8.0/src/duktape.c:7787

Definition at line 6129 of file duktape-1.8.0/src/duktape.c.

 *  This is used by public API call entrypoints to catch invalid 'ctx' pointers
 *  as early as possible; invalid 'ctx' pointers cause very odd and difficult to
 *  diagnose behavior so it's worth checking even when the check is not 100%.

◆ DUK_ASSERT_DISABLE

#define DUK_ASSERT_DISABLE ( x ) do { /* assertion disabled */ } while (0)

Definition at line 7796 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user(), duk__getid_open_decl_env_regs(), duk__hexval(), duk__put_prop_shared(), duk__reconfig_valstack_ecma_return(), duk_handle_ecma_call_setup(), duk_heap_mem_realloc_indirect(), duk_hstring_char_code_at_raw(), duk_hthread_callstack_grow(), duk_push_current_thread(), and duk_tval_decref().

◆ DUK_ASSERT_DOUBLE_IS_NORMALIZED

#define DUK_ASSERT_DOUBLE_IS_NORMALIZED ( dval ) /* nop */

Definition at line 7825 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASSERT_EXPR

#define DUK_ASSERT_EXPR ( x ) ((void) 0)

Definition at line 7789 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ASSERT_HBUFFEROBJECT_VALID

#define DUK_ASSERT_HBUFFEROBJECT_VALID ( h )

Value:

        do { \
        DUK_ASSERT((h) != NULL); \
        DUK_ASSERT((h)->shift <= 3); \
        DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \
        DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \
                   ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \
                   ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \
                   ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \
                   ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \
                   ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \
        DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \
        DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \
        if ((h)->buf == NULL) { \
            DUK_ASSERT((h)->offset == 0); \
            DUK_ASSERT((h)->length == 0); \
        } else { \
            /* No assertions for offset or length; in particular, \
             * it's OK for length to be longer than underlying \
             * buffer.  Just ensure they don't wrap when added. \
             */ \
            DUK_ASSERT((h)->offset + (h)->length >= (h)->offset); \
        } \
    } while (0)

Definition at line 5855 of file duktape-1.8.0/src/duktape.c.

#define DUK_HBUFFEROBJECT_ELEM_MAX             8
 
#define DUK_ASSERT_HBUFFEROBJECT_VALID(h) do { \
        DUK_ASSERT((h) != NULL); \
        DUK_ASSERT((h)->shift <= 3); \
        DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \
        DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \
                   ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \
                   ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \
                   ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \
                   ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \
                   ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \
        DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \
        DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \
        if ((h)->buf == NULL) { \
            DUK_ASSERT((h)->offset == 0); \
            DUK_ASSERT((h)->length == 0); \
        } else { \
            /* No assertions for offset or length; in particular, \
             * it's OK for length to be longer than underlying \

Referenced by duk__get_own_propdesc_raw(), duk_bi_typedarray_set(), and duk_hobject_putprop().

◆ DUK_ASSERT_HEAPHDR_LINKS

#define DUK_ASSERT_HEAPHDR_LINKS	(		heap,
			h ) do {} while (0)

Definition at line 3726 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_object_parts(), and duk__queue_refzero().

◆ DUK_ASSERT_HOBJECT_VALID

#define DUK_ASSERT_HOBJECT_VALID ( h )

Value:

        do { \
        DUK_ASSERT((h) != NULL); \
        DUK_ASSERT(!DUK_HOBJECT_IS_CALLABLE((h)) || \
                   DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FUNCTION); \
        DUK_ASSERT(!DUK_HOBJECT_IS_BUFFEROBJECT((h)) || \
                   (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_BUFFER || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAYBUFFER || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DATAVIEW || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT8ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT16ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT16ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT32ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT32ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT32ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT64ARRAY)); \
    } while (0)

Definition at line 4924 of file duktape-1.8.0/src/duktape.c.

 */
 
#define DUK_ASSERT_HOBJECT_VALID(h) do { \
        DUK_ASSERT((h) != NULL); \
        DUK_ASSERT(!DUK_HOBJECT_IS_CALLABLE((h)) || \
                   DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FUNCTION); \
        DUK_ASSERT(!DUK_HOBJECT_IS_BUFFEROBJECT((h)) || \
                   (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_BUFFER || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAYBUFFER || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DATAVIEW || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT8ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT16ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT16ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT32ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT32ARRAY || \
                    DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT32ARRAY || \

◆ DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR

#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR ( h ) /* no refcount check */

Definition at line 7812 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__delvar_helper(), duk__getvar_helper(), and duk__putvar_helper().

◆ DUK_ASSERT_REFCOUNT_NONZERO_TVAL

#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL ( tv ) /* no refcount check */

Definition at line 7813 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__putvar_helper().

◆ DUK_ASSERT_TOP

#define DUK_ASSERT_TOP	(		ctx,
			n ) DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n))

Definition at line 7816 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), duk_bi_error_constructor_shared(), duk_bi_object_prototype_is_prototype_of(), and duk_bi_typedarray_set().

◆ DUK_ASSERT_VALID_NEGIDX

#define DUK_ASSERT_VALID_NEGIDX	(		ctx,
			idx ) (DUK_ASSERT_EXPR((idx) < 0), DUK_ASSERT_EXPR(duk_is_valid_index((ctx), (idx))))

Definition at line 4403 of file duktape-1.8.0/src/duktape.c.

4403#define DUK_ASSERT_VALID_NEGIDX(ctx,idx) \

4404 (DUK_ASSERT_EXPR((idx) < 0), DUK_ASSERT_EXPR(duk_is_valid_index((ctx), (idx))))

◆ DUK_ASSERT_VALID_POSIDX

#define DUK_ASSERT_VALID_POSIDX	(		ctx,
			idx ) (DUK_ASSERT_EXPR((idx) >= 0), DUK_ASSERT_EXPR(duk_is_valid_index((ctx), (idx))))

Definition at line 4405 of file duktape-1.8.0/src/duktape.c.

4405#define DUK_ASSERT_VALID_POSIDX(ctx,idx) \

4406 (DUK_ASSERT_EXPR((idx) >= 0), DUK_ASSERT_EXPR(duk_is_valid_index((ctx), (idx))))

◆ DUK_ASSERT_VALSTACK_SPACE

#define DUK_ASSERT_VALSTACK_SPACE	(		thr,
			n ) /* no valstack space check */

Definition at line 7843 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user(), duk__get_own_propdesc_raw(), duk__get_propdesc(), duk__realloc_props(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_BC_A_MAX

#define DUK_BC_A_MAX 0xffL

Definition at line 2582 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_A_MIN

#define DUK_BC_A_MIN 0

Definition at line 2581 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_ABC_MAX

#define DUK_BC_ABC_MAX 0x3ffffffL

Definition at line 2590 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_ABC_MIN

#define DUK_BC_ABC_MIN 0

Definition at line 2589 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_B_MAX

#define DUK_BC_B_MAX 0x1ffL

Definition at line 2584 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_B_MIN

#define DUK_BC_B_MIN 0

Definition at line 2583 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_BC_MAX

#define DUK_BC_BC_MAX 0x3ffffL

Definition at line 2588 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_BC_MIN

#define DUK_BC_BC_MIN 0

Definition at line 2587 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_C_MAX

#define DUK_BC_C_MAX 0x1ffL

Definition at line 2586 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_C_MIN

#define DUK_BC_C_MIN 0

Definition at line 2585 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_CALL_FLAG_EVALCALL

#define DUK_BC_CALL_FLAG_EVALCALL (1 << 1)

Definition at line 2698 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_CALL_FLAG_TAILCALL

#define DUK_BC_CALL_FLAG_TAILCALL (1 << 0)

Definition at line 2697 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_DECLVAR_FLAG_FUNC_DECL

#define DUK_BC_DECLVAR_FLAG_FUNC_DECL (1 << 5) /* function declaration */

Definition at line 2711 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_BC_DECLVAR_FLAG_UNDEF_VALUE

#define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE (1 << 4) /* use 'undefined' for value automatically */

Definition at line 2710 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_BC_EXTRAOP_MAX

#define DUK_BC_EXTRAOP_MAX DUK_BC_A_MAX

Definition at line 2592 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_EXTRAOP_MIN

#define DUK_BC_EXTRAOP_MIN DUK_BC_A_MIN

Definition at line 2591 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_ISCONST

#define DUK_BC_ISCONST ( x ) ((x) >= DUK_BC_REGLIMIT)

Definition at line 2716 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_ISREG

#define DUK_BC_ISREG ( x ) ((x) < DUK_BC_REGLIMIT)

Definition at line 2715 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_JUMP_BIAS

#define DUK_BC_JUMP_BIAS (1L << 25)

Definition at line 2719 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_LDINT_BIAS

#define DUK_BC_LDINT_BIAS (1L << 17)

Definition at line 2717 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__emit_load_int32().

◆ DUK_BC_LDINTX_SHIFT

#define DUK_BC_LDINTX_SHIFT 18

Definition at line 2718 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_OP_MAX

#define DUK_BC_OP_MAX 0x3fL

Definition at line 2580 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_OP_MIN

#define DUK_BC_OP_MIN 0

Definition at line 2579 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_REGLIMIT

#define DUK_BC_REGLIMIT 256 /* if B/C is >= this value, refers to a const */

Definition at line 2714 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_RETURN_FLAG_HAVE_RETVAL

#define DUK_BC_RETURN_FLAG_HAVE_RETVAL (1 << 0)

Definition at line 2707 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK_BC_TRYCATCH_FLAG_CATCH_BINDING

#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING (1 << 2)

Definition at line 2703 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_TRYCATCH_FLAG_HAVE_CATCH

#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH (1 << 0)

Definition at line 2701 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY

#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY (1 << 1)

Definition at line 2702 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BC_TRYCATCH_FLAG_WITH_BINDING

#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING (1 << 3)

Definition at line 2704 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BI_COMMONJS_MODULE_ID_LIMIT

#define DUK_BI_COMMONJS_MODULE_ID_LIMIT 256

Definition at line 8581 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BI_DATE_ISO8601_BUFSIZE

#define DUK_BI_DATE_ISO8601_BUFSIZE 48

Definition at line 8575 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_ARRAY_CONSTRUCTOR

#define DUK_BIDX_ARRAY_CONSTRUCTOR 6

Definition at line 1642 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_ARRAY_PROTOTYPE

#define DUK_BIDX_ARRAY_PROTOTYPE 7

Definition at line 1643 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR

#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46

Definition at line 1682 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_ARRAYBUFFER_PROTOTYPE

#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47

Definition at line 1683 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_BOOLEAN_CONSTRUCTOR

#define DUK_BIDX_BOOLEAN_CONSTRUCTOR 10

Definition at line 1646 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_BOOLEAN_PROTOTYPE

#define DUK_BIDX_BOOLEAN_PROTOTYPE 11

Definition at line 1647 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_BIDX_BUFFER_CONSTRUCTOR

#define DUK_BIDX_BUFFER_CONSTRUCTOR 39

Definition at line 1675 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_BUFFER_PROTOTYPE

#define DUK_BIDX_BUFFER_PROTOTYPE 40

Definition at line 1676 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_BIDX_DATAVIEW_CONSTRUCTOR

#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48

Definition at line 1684 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_DATAVIEW_PROTOTYPE

#define DUK_BIDX_DATAVIEW_PROTOTYPE 49

Definition at line 1685 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_DATE_CONSTRUCTOR

#define DUK_BIDX_DATE_CONSTRUCTOR 14

Definition at line 1650 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_DATE_PROTOTYPE

#define DUK_BIDX_DATE_PROTOTYPE 15

Definition at line 1651 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_DOUBLE_ERROR

#define DUK_BIDX_DOUBLE_ERROR 45

Definition at line 1681 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_create_and_throw().

◆ DUK_BIDX_DUKTAPE

#define DUK_BIDX_DUKTAPE 36

Definition at line 1672 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user().

◆ DUK_BIDX_ERROR_CONSTRUCTOR

#define DUK_BIDX_ERROR_CONSTRUCTOR 18

Definition at line 1654 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_ERROR_PROTOTYPE

#define DUK_BIDX_ERROR_PROTOTYPE 19

Definition at line 1655 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_augment_error_create().

◆ DUK_BIDX_EVAL_ERROR_CONSTRUCTOR

#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR 20

Definition at line 1656 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_EVAL_ERROR_PROTOTYPE

#define DUK_BIDX_EVAL_ERROR_PROTOTYPE 21

Definition at line 1657 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR

#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65

Definition at line 1701 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_FLOAT32ARRAY_PROTOTYPE

#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66

Definition at line 1702 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR

#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67

Definition at line 1703 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_FLOAT64ARRAY_PROTOTYPE

#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68

Definition at line 1704 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_FUNCTION_CONSTRUCTOR

#define DUK_BIDX_FUNCTION_CONSTRUCTOR 4

Definition at line 1640 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_FUNCTION_PROTOTYPE

#define DUK_BIDX_FUNCTION_PROTOTYPE 5

Definition at line 1641 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_BIDX_GLOBAL

#define DUK_BIDX_GLOBAL 0

Definition at line 1636 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__declvar_helper(), and duk_put_global_string().

◆ DUK_BIDX_GLOBAL_ENV

#define DUK_BIDX_GLOBAL_ENV 1

Definition at line 1637 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper().

◆ DUK_BIDX_INT16ARRAY_CONSTRUCTOR

#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57

Definition at line 1693 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_INT16ARRAY_PROTOTYPE

#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58

Definition at line 1694 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_INT32ARRAY_CONSTRUCTOR

#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61

Definition at line 1697 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_INT32ARRAY_PROTOTYPE

#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62

Definition at line 1698 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_INT8ARRAY_CONSTRUCTOR

#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51

Definition at line 1687 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_INT8ARRAY_PROTOTYPE

#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52

Definition at line 1688 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_JSON

#define DUK_BIDX_JSON 33

Definition at line 1669 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_LOGGER_CONSTRUCTOR

#define DUK_BIDX_LOGGER_CONSTRUCTOR 43

Definition at line 1679 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_LOGGER_PROTOTYPE

#define DUK_BIDX_LOGGER_PROTOTYPE 44

Definition at line 1680 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_MATH

#define DUK_BIDX_MATH 32

Definition at line 1668 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR

#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69

Definition at line 1705 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_NODEJS_BUFFER_PROTOTYPE

#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70

Definition at line 1706 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_NUMBER_CONSTRUCTOR

#define DUK_BIDX_NUMBER_CONSTRUCTOR 12

Definition at line 1648 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_NUMBER_PROTOTYPE

#define DUK_BIDX_NUMBER_PROTOTYPE 13

Definition at line 1649 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_BIDX_OBJECT_CONSTRUCTOR

#define DUK_BIDX_OBJECT_CONSTRUCTOR 2

Definition at line 1638 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_OBJECT_PROTOTYPE

#define DUK_BIDX_OBJECT_PROTOTYPE 3

Definition at line 1639 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ DUK_BIDX_POINTER_CONSTRUCTOR

#define DUK_BIDX_POINTER_CONSTRUCTOR 41

Definition at line 1677 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_POINTER_PROTOTYPE

#define DUK_BIDX_POINTER_PROTOTYPE 42

Definition at line 1678 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_BIDX_PROXY_CONSTRUCTOR

#define DUK_BIDX_PROXY_CONSTRUCTOR 35

Definition at line 1671 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_RANGE_ERROR_CONSTRUCTOR

#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR 22

Definition at line 1658 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_RANGE_ERROR_PROTOTYPE

#define DUK_BIDX_RANGE_ERROR_PROTOTYPE 23

Definition at line 1659 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR

#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR 24

Definition at line 1660 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_REFERENCE_ERROR_PROTOTYPE

#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE 25

Definition at line 1661 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_REGEXP_CONSTRUCTOR

#define DUK_BIDX_REGEXP_CONSTRUCTOR 16

Definition at line 1652 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_REGEXP_PROTOTYPE

#define DUK_BIDX_REGEXP_PROTOTYPE 17

Definition at line 1653 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_STRING_CONSTRUCTOR

#define DUK_BIDX_STRING_CONSTRUCTOR 8

Definition at line 1644 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_STRING_PROTOTYPE

#define DUK_BIDX_STRING_PROTOTYPE 9

Definition at line 1645 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_string_constructor_from_char_code(), and duk_hobject_putprop().

◆ DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR

#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR 26

Definition at line 1662 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_SYNTAX_ERROR_PROTOTYPE

#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE 27

Definition at line 1663 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_THREAD_CONSTRUCTOR

#define DUK_BIDX_THREAD_CONSTRUCTOR 37

Definition at line 1673 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_THREAD_PROTOTYPE

#define DUK_BIDX_THREAD_PROTOTYPE 38

Definition at line 1674 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_TYPE_ERROR_CONSTRUCTOR

#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR 28

Definition at line 1664 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_TYPE_ERROR_PROTOTYPE

#define DUK_BIDX_TYPE_ERROR_PROTOTYPE 29

Definition at line 1665 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_TYPE_ERROR_THROWER

#define DUK_BIDX_TYPE_ERROR_THROWER 34

Definition at line 1670 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_TYPEDARRAY_PROTOTYPE

#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50

Definition at line 1686 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT16ARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59

Definition at line 1695 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT16ARRAY_PROTOTYPE

#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60

Definition at line 1696 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT32ARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63

Definition at line 1699 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT32ARRAY_PROTOTYPE

#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64

Definition at line 1700 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT8ARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53

Definition at line 1689 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT8ARRAY_PROTOTYPE

#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54

Definition at line 1690 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55

Definition at line 1691 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE

#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56

Definition at line 1692 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_URI_ERROR_CONSTRUCTOR

#define DUK_BIDX_URI_ERROR_CONSTRUCTOR 30

Definition at line 1666 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BIDX_URI_ERROR_PROTOTYPE

#define DUK_BIDX_URI_ERROR_PROTOTYPE 31

Definition at line 1667 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BUILTIN_INITJS_DATA_LENGTH

#define DUK_BUILTIN_INITJS_DATA_LENGTH 204

Definition at line 1634 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BUILTIN_PROTOS_H_INCLUDED

#define DUK_BUILTIN_PROTOS_H_INCLUDED

Definition at line 8567 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BUILTINS_H_INCLUDED

#define DUK_BUILTINS_H_INCLUDED

Definition at line 881 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BW_ADD_PTR

#define DUK_BW_ADD_PTR	(	thr,
		bw_ctx,
		delta )

Value:

        do { \
        (bw_ctx)->p += (delta); \
    } while (0)

Definition at line 1902 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ADD_PTR(thr,bw_ctx,delta) do { \
        (bw_ctx)->p += (delta); \
    } while (0)

◆ DUK_BW_ASSERT_SPACE

#define DUK_BW_ASSERT_SPACE	(	thr,
		bw_ctx,
		sz )

Value:

        do { \
        DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \
    } while (0)

Definition at line 1944 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ASSERT_SPACE(thr,bw_ctx,sz) do { \
        DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \
    } while (0)

◆ DUK_BW_ASSERT_SPACE_EXPR

#define DUK_BW_ASSERT_SPACE_EXPR	(	thr,
		bw_ctx,
		sz )

Value:

(DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \

DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz)))

DUK_BW_ASSERT_VALID_EXPR

#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx)

Definition duktape-1.8.0/src/duktape.c:1881

Definition at line 1941 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ASSERT_SPACE_EXPR(thr,bw_ctx,sz) \
    (DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \
     DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz)))

◆ DUK_BW_ASSERT_VALID

#define DUK_BW_ASSERT_VALID	(		thr,
			bw_ctx )

Value:

        do { \
        DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \
    } while (0)

Definition at line 1891 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ASSERT_VALID(thr,bw_ctx) do { \
        DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \
    } while (0)

◆ DUK_BW_ASSERT_VALID_EXPR

#define DUK_BW_ASSERT_VALID_EXPR	(		thr,
			bw_ctx )

Value:

    DUK_ASSERT_EXPR((bw_ctx) != NULL && \
                    (bw_ctx)->buf != NULL && \
            ((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \
                ((bw_ctx)->p != NULL && \
                         (bw_ctx)->p_base != NULL && \
                         (bw_ctx)->p_limit != NULL && \
                         (bw_ctx)->p_limit >= (bw_ctx)->p_base && \
                         (bw_ctx)->p >= (bw_ctx)->p_base && \
                         (bw_ctx)->p <= (bw_ctx)->p_limit)))

Definition at line 1881 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx) \
    DUK_ASSERT_EXPR((bw_ctx) != NULL && \
                    (bw_ctx)->buf != NULL && \
            ((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \
                ((bw_ctx)->p != NULL && \
                         (bw_ctx)->p_base != NULL && \
                         (bw_ctx)->p_limit != NULL && \
                         (bw_ctx)->p_limit >= (bw_ctx)->p_base && \
                         (bw_ctx)->p >= (bw_ctx)->p_base && \
                         (bw_ctx)->p <= (bw_ctx)->p_limit)))

◆ DUK_BW_COMPACT

#define DUK_BW_COMPACT	(		thr,
			bw_ctx )

Value:

        do { \
        /* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \
        duk_bw_compact((thr), (bw_ctx)); \
    } while (0)

Definition at line 1867 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_COMPACT(thr,bw_ctx) do { \
        /* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \
        duk_bw_compact((thr), (bw_ctx)); \
    } while (0)

◆ DUK_BW_ENSURE

#define DUK_BW_ENSURE	(	thr,
		bw_ctx,
		sz )

Value:

        do { \
        duk_size_t duk__sz, duk__space; \
        DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \
        duk__sz = (sz); \
        duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \
        if (duk__space < duk__sz) { \
            (void) duk_bw_resize((thr), (bw_ctx), duk__sz); \
        } \
    } while (0)

Definition at line 1924 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ENSURE(thr,bw_ctx,sz) do { \
        duk_size_t duk__sz, duk__space; \
        DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \
        duk__sz = (sz); \
        duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \
        if (duk__space < duk__sz) { \
            (void) duk_bw_resize((thr), (bw_ctx), duk__sz); \
        } \
    } while (0)

Referenced by duk_bw_insert_raw_area().

◆ DUK_BW_ENSURE_GETPTR

#define DUK_BW_ENSURE_GETPTR	(	thr,
		bw_ctx,
		sz ) DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)

Definition at line 1939 of file duktape-1.8.0/src/duktape.c.

1939#define DUK_BW_ENSURE_GETPTR(thr,bw_ctx,sz) \

1940 DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)

◆ DUK_BW_ENSURE_RAW

#define DUK_BW_ENSURE_RAW	(	thr,
		bw_ctx,
		sz,
		ptr )

Value:

    (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \
     (ptr) : \
     ((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz))))

Definition at line 1935 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_ENSURE_RAW(thr,bw_ctx,sz,ptr) \
    (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \
     (ptr) : \
     ((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz))))

Referenced by duk__create_escaped_source().

◆ DUK_BW_GET_BASEPTR

#define DUK_BW_GET_BASEPTR	(		thr,
			bw_ctx ) ((bw_ctx)->p_base)

Definition at line 1905 of file duktape-1.8.0/src/duktape.c.

1905#define DUK_BW_GET_BASEPTR(thr,bw_ctx) \

1906 ((bw_ctx)->p_base)

◆ DUK_BW_GET_BUFFER

#define DUK_BW_GET_BUFFER	(		thr,
			bw_ctx ) ((bw_ctx)->buf)

Definition at line 1919 of file duktape-1.8.0/src/duktape.c.

1919#define DUK_BW_GET_BUFFER(thr,bw_ctx) \

1920 ((bw_ctx)->buf)

◆ DUK_BW_GET_LIMITPTR

#define DUK_BW_GET_LIMITPTR	(		thr,
			bw_ctx ) ((bw_ctx)->p_limit)

Definition at line 1907 of file duktape-1.8.0/src/duktape.c.

1907#define DUK_BW_GET_LIMITPTR(thr,bw_ctx) \

1908 ((bw_ctx)->p_limit)

◆ DUK_BW_GET_PTR

#define DUK_BW_GET_PTR	(		thr,
			bw_ctx ) ((bw_ctx)->p)

Definition at line 1897 of file duktape-1.8.0/src/duktape.c.

1897#define DUK_BW_GET_PTR(thr,bw_ctx) \

1898 ((bw_ctx)->p)

Referenced by duk__create_escaped_source().

◆ DUK_BW_GET_SIZE

#define DUK_BW_GET_SIZE	(		thr,
			bw_ctx ) ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))

Definition at line 1909 of file duktape-1.8.0/src/duktape.c.

1909#define DUK_BW_GET_SIZE(thr,bw_ctx) \

1910 ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))

Referenced by duk__emit(), duk_bw_insert_raw_area(), and duk_bw_write_ensure_slice().

◆ DUK_BW_INIT_PUSHBUF

#define DUK_BW_INIT_PUSHBUF	(	thr,
		bw_ctx,
		sz )

Value:

        do { \
        duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \
    } while (0)

Definition at line 1861 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_INIT_PUSHBUF(thr,bw_ctx,sz) do { \
        duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \
    } while (0)

Referenced by duk__create_escaped_source().

◆ DUK_BW_INIT_WITHBUF

#define DUK_BW_INIT_WITHBUF	(	thr,
		bw_ctx,
		buf )

Value:

        do { \
        duk_bw_init((thr), (bw_ctx), (buf)); \
    } while (0)

Definition at line 1864 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_INIT_WITHBUF(thr,bw_ctx,buf) do { \
        duk_bw_init((thr), (bw_ctx), (buf)); \
    } while (0)

Referenced by duk__appendbuffer().

◆ DUK_BW_INSERT_ENSURE_AREA

#define DUK_BW_INSERT_ENSURE_AREA	(	thr,
		bw,
		off,
		len )

Value:

/* Evaluates to (duk_uint8_t *) pointing to start of area. */ \

duk_bw_insert_ensure_area((thr), (bw), (off), (len))

Definition at line 2186 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_INSERT_ENSURE_AREA(thr,bw,off,len) \
    /* Evaluates to (duk_uint8_t *) pointing to start of area. */ \
    duk_bw_insert_ensure_area((thr), (bw), (off), (len))

◆ DUK_BW_INSERT_ENSURE_BYTES

#define DUK_BW_INSERT_ENSURE_BYTES	(	thr,
		bw,
		dst_off,
		buf,
		len ) duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))

Definition at line 2182 of file duktape-1.8.0/src/duktape.c.

2182#define DUK_BW_INSERT_ENSURE_BYTES(thr,bw,dst_off,buf,len) \

2183 duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))

◆ DUK_BW_INSERT_ENSURE_SLICE

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

Definition at line 2184 of file duktape-1.8.0/src/duktape.c.

2184#define DUK_BW_INSERT_ENSURE_SLICE(thr,bw,dst_off,src_off,len) \

2185 duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len))

◆ DUK_BW_INSERT_RAW_AREA

#define DUK_BW_INSERT_RAW_AREA	(	thr,
		bw,
		off,
		len ) duk_bw_insert_raw_area((thr), (bw), (off), (len))

Definition at line 2091 of file duktape-1.8.0/src/duktape.c.

2091#define DUK_BW_INSERT_RAW_AREA(thr,bw,off,len) \

2092 duk_bw_insert_raw_area((thr), (bw), (off), (len))

◆ DUK_BW_INSERT_RAW_BYTES

#define DUK_BW_INSERT_RAW_BYTES	(	thr,
		bw,
		dst_off,
		buf,
		len ) duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))

Definition at line 2078 of file duktape-1.8.0/src/duktape.c.

2078#define DUK_BW_INSERT_RAW_BYTES(thr,bw,dst_off,buf,len) \

2079 duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))

◆ DUK_BW_INSERT_RAW_SLICE

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

Definition at line 2084 of file duktape-1.8.0/src/duktape.c.

2084#define DUK_BW_INSERT_RAW_SLICE(thr,bw,dst_off,src_off,len) \

2085 duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))

◆ DUK_BW_PUSH_AS_STRING

#define DUK_BW_PUSH_AS_STRING	(		thr,
			bw_ctx )

Value:

        do { \
        duk_push_lstring((duk_context *) (thr), \
                         (const char *) (bw_ctx)->p_base, \
                         (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
    } while (0)

Definition at line 1871 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_PUSH_AS_STRING(thr,bw_ctx) do { \
        duk_push_lstring((duk_context *) (thr), \
                         (const char *) (bw_ctx)->p_base, \
                         (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
    } while (0)

Referenced by duk_lexer_initctx().

◆ DUK_BW_REMOVE_ENSURE_SLICE

#define DUK_BW_REMOVE_ENSURE_SLICE	(	thr,
		bw,
		off,
		len )

Value:

/* No difference between raw/ensure because the buffer shrinks. */ \

DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len))

Definition at line 2189 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_REMOVE_ENSURE_SLICE(thr,bw,off,len) \
    /* No difference between raw/ensure because the buffer shrinks. */ \
    DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len))

Referenced by duk__insert_jump_offset().

◆ DUK_BW_REMOVE_RAW_SLICE

#define DUK_BW_REMOVE_RAW_SLICE	(	thr,
		bw,
		off,
		len ) duk_bw_remove_raw_slice((thr), (bw), (off), (len))

Definition at line 2095 of file duktape-1.8.0/src/duktape.c.

2095#define DUK_BW_REMOVE_RAW_SLICE(thr,bw,off,len) \

2096 duk_bw_remove_raw_slice((thr), (bw), (off), (len))

◆ DUK_BW_RESET_SIZE

#define DUK_BW_RESET_SIZE	(		thr,
			bw_ctx )

Value:

        do { \
        /* Reset to zero size, keep current limit. */ \
        (bw_ctx)->p = (bw_ctx)->p_base; \
    } while (0)

Definition at line 1915 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_RESET_SIZE(thr,bw_ctx) do { \
        /* Reset to zero size, keep current limit. */ \
        (bw_ctx)->p = (bw_ctx)->p_base; \
    } while (0)

◆ DUK_BW_SET_PTR

#define DUK_BW_SET_PTR	(	thr,
		bw_ctx,
		ptr )

Value:

        do { \
        (bw_ctx)->p = (ptr); \
    } while (0)

Definition at line 1899 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_SET_PTR(thr,bw_ctx,ptr) do { \
        (bw_ctx)->p = (ptr); \
    } while (0)

◆ DUK_BW_SET_SIZE

#define DUK_BW_SET_SIZE	(	thr,
		bw_ctx,
		sz )

Value:

        do { \
        DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
        (bw_ctx)->p = (bw_ctx)->p_base + (sz); \
    } while (0)

Definition at line 1911 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_SET_SIZE(thr,bw_ctx,sz) do { \
        DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
        (bw_ctx)->p = (bw_ctx)->p_base + (sz); \
    } while (0)

◆ DUK_BW_SETPTR_AND_COMPACT

#define DUK_BW_SETPTR_AND_COMPACT	(	thr,
		bw_ctx,
		ptr )

Value:

        do { \
        (bw_ctx)->p = (ptr); \
        duk_bw_compact((thr), (bw_ctx)); \
    } while (0)

Definition at line 1950 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_SETPTR_AND_COMPACT(thr,bw_ctx,ptr) do { \
        (bw_ctx)->p = (ptr); \
        duk_bw_compact((thr), (bw_ctx)); \
    } while (0)

Referenced by duk__create_escaped_source().

◆ DUK_BW_SPARE_ADD

#define DUK_BW_SPARE_ADD 64

Definition at line 1856 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BW_SPARE_SHIFT

#define DUK_BW_SPARE_SHIFT 4 /* 2^4 -> 1/16 = 6.25% spare */

Definition at line 1857 of file duktape-1.8.0/src/duktape.c.

◆ DUK_BW_WRITE_ENSURE_BYTES

#define DUK_BW_WRITE_ENSURE_BYTES	(	thr,
		bw_ctx,
		valptr,
		valsz )

Value:

        do { \
        const void *duk__valptr; \
        duk_size_t duk__valsz; \
        duk__valptr = (const void *) (valptr); \
        duk__valsz = (duk_size_t) (valsz); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
        (bw_ctx)->p += duk__valsz; \
    } while (0)

Definition at line 2133 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_BYTES(thr,bw_ctx,valptr,valsz) do { \
        const void *duk__valptr; \
        duk_size_t duk__valsz; \
        duk__valptr = (const void *) (valptr); \
        duk__valsz = (duk_size_t) (valsz); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
        (bw_ctx)->p += duk__valsz; \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_CESU8

#define DUK_BW_WRITE_ENSURE_CESU8	(	thr,
		bw_ctx,
		cp )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \
        DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \
    } while (0)

Definition at line 2128 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_CESU8(thr,bw_ctx,cp) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \
        DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_CSTRING

#define DUK_BW_WRITE_ENSURE_CSTRING	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        const duk_uint8_t *duk__val; \
        duk_size_t duk__val_len; \
        duk__val = (const duk_uint8_t *) (val); \
        duk__val_len = DUK_STRLEN((const char *) duk__val); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2142 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_CSTRING(thr,bw_ctx,val) do { \
        const duk_uint8_t *duk__val; \
        duk_size_t duk__val_len; \
        duk__val = (const duk_uint8_t *) (val); \
        duk__val_len = DUK_STRLEN((const char *) duk__val); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Referenced by duk__unemit_1().

◆ DUK_BW_WRITE_ENSURE_HBUFFER

#define DUK_BW_WRITE_ENSURE_HBUFFER	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2158 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_HBUFFER(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC

#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2172 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_HBUFFER_FIXED

#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2165 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_HSTRING

#define DUK_BW_WRITE_ENSURE_HSTRING	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2151 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_HSTRING(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
        DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_SLICE

#define DUK_BW_WRITE_ENSURE_SLICE	(	thr,
		bw,
		dst_off,
		dst_len ) duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))

Definition at line 2180 of file duktape-1.8.0/src/duktape.c.

2180#define DUK_BW_WRITE_ENSURE_SLICE(thr,bw,dst_off,dst_len) \

2181 duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))

◆ DUK_BW_WRITE_ENSURE_U8

#define DUK_BW_WRITE_ENSURE_U8	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 1); \
        DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \
    } while (0)

Definition at line 2100 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_U8(thr,bw_ctx,val) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 1); \
        DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_2

#define DUK_BW_WRITE_ENSURE_U8_2	(	thr,
		bw_ctx,
		val1,
		val2 )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 2); \
        DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \
    } while (0)

Definition at line 2104 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_U8_2(thr,bw_ctx,val1,val2) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 2); \
        DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_3

#define DUK_BW_WRITE_ENSURE_U8_3	(	thr,
		bw_ctx,
		val1,
		val2,
		val3 )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 3); \
        DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \
    } while (0)

Definition at line 2108 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_U8_3(thr,bw_ctx,val1,val2,val3) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 3); \
        DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_4

#define DUK_BW_WRITE_ENSURE_U8_4	(	thr,
		bw_ctx,
		val1,
		val2,
		val3,
		val4 )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 4); \
        DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \
    } while (0)

Definition at line 2112 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 4); \
        DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_5

#define DUK_BW_WRITE_ENSURE_U8_5	(	thr,
		bw_ctx,
		val1,
		val2,
		val3,
		val4,
		val5 )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 5); \
        DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \
    } while (0)

Definition at line 2116 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 5); \
        DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_6

#define DUK_BW_WRITE_ENSURE_U8_6	(	thr,
		bw_ctx,
		val1,
		val2,
		val3,
		val4,
		val5,
		val6 )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 6); \
        DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \
    } while (0)

Definition at line 2120 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), 6); \
        DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \
    } while (0)

◆ DUK_BW_WRITE_ENSURE_XUTF8

#define DUK_BW_WRITE_ENSURE_XUTF8	(	thr,
		bw_ctx,
		cp )

Value:

        do { \
        DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \
        DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \
    } while (0)

Definition at line 2124 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_ENSURE_XUTF8(thr,bw_ctx,cp) do { \
        DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \
        DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \
    } while (0)

◆ DUK_BW_WRITE_RAW_BYTES

#define DUK_BW_WRITE_RAW_BYTES	(	thr,
		bw_ctx,
		valptr,
		valsz )

Value:

        do { \
        const void *duk__valptr; \
        duk_size_t duk__valsz; \
        duk__valptr = (const void *) (valptr); \
        duk__valsz = (duk_size_t) (valsz); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
        (bw_ctx)->p += duk__valsz; \
    } while (0)

Definition at line 2032 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_BYTES(thr,bw_ctx,valptr,valsz) do { \
        const void *duk__valptr; \
        duk_size_t duk__valsz; \
        duk__valptr = (const void *) (valptr); \
        duk__valsz = (duk_size_t) (valsz); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
        (bw_ctx)->p += duk__valsz; \
    } while (0)

◆ DUK_BW_WRITE_RAW_CESU8

#define DUK_BW_WRITE_RAW_CESU8	(	thr,
		bw_ctx,
		cp )

Value:

        do { \
        duk_ucodepoint_t duk__cp; \
        duk_small_int_t duk__enc_len; \
        duk__cp = (duk_ucodepoint_t) (cp); \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \
        duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \
        (bw_ctx)->p += duk__enc_len; \
    } while (0)

Definition at line 2023 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_CESU8(thr,bw_ctx,cp) do { \
        duk_ucodepoint_t duk__cp; \
        duk_small_int_t duk__enc_len; \
        duk__cp = (duk_ucodepoint_t) (cp); \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \
        duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \
        (bw_ctx)->p += duk__enc_len; \
    } while (0)

◆ DUK_BW_WRITE_RAW_CSTRING

#define DUK_BW_WRITE_RAW_CSTRING	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        const duk_uint8_t *duk__val; \
        duk_size_t duk__val_len; \
        duk__val = (const duk_uint8_t *) (val); \
        duk__val_len = DUK_STRLEN((const char *) duk__val); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2040 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_CSTRING(thr,bw_ctx,val) do { \
        const duk_uint8_t *duk__val; \
        duk_size_t duk__val_len; \
        duk__val = (const duk_uint8_t *) (val); \
        duk__val_len = DUK_STRLEN((const char *) duk__val); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_RAW_HBUFFER

#define DUK_BW_WRITE_RAW_HBUFFER	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2054 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_HBUFFER(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC

#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2066 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_RAW_HBUFFER_FIXED

#define DUK_BW_WRITE_RAW_HBUFFER_FIXED	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2060 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_RAW_HSTRING

#define DUK_BW_WRITE_RAW_HSTRING	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

Definition at line 2048 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_HSTRING(thr,bw_ctx,val) do { \
        duk_size_t duk__val_len; \
        duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
        DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
        (bw_ctx)->p += duk__val_len; \
    } while (0)

◆ DUK_BW_WRITE_RAW_SLICE

#define DUK_BW_WRITE_RAW_SLICE	(	thr,
		bw,
		dst_off,
		dst_len ) duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))

Definition at line 2074 of file duktape-1.8.0/src/duktape.c.

2074#define DUK_BW_WRITE_RAW_SLICE(thr,bw,dst_off,dst_len) \

2075 duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))

◆ DUK_BW_WRITE_RAW_U8

#define DUK_BW_WRITE_RAW_U8	(	thr,
		bw_ctx,
		val )

Value:

        do { \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \
        *(bw_ctx)->p++ = (duk_uint8_t) (val); \
    } while (0)

Definition at line 1961 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_U8(thr,bw_ctx,val) do { \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \
        *(bw_ctx)->p++ = (duk_uint8_t) (val); \
    } while (0)

◆ DUK_BW_WRITE_RAW_U8_2

#define DUK_BW_WRITE_RAW_U8_2	(	thr,
		bw_ctx,
		val1,
		val2 )

Value:

        do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        (bw_ctx)->p = duk__p; \
    } while (0)

Definition at line 1965 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_U8_2(thr,bw_ctx,val1,val2) do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        (bw_ctx)->p = duk__p; \
    } while (0)

◆ DUK_BW_WRITE_RAW_U8_3

#define DUK_BW_WRITE_RAW_U8_3	(	thr,
		bw_ctx,
		val1,
		val2,
		val3 )

Value:

        do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        (bw_ctx)->p = duk__p; \
    } while (0)

Definition at line 1973 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_U8_3(thr,bw_ctx,val1,val2,val3) do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        (bw_ctx)->p = duk__p; \
    } while (0)

◆ DUK_BW_WRITE_RAW_U8_4

#define DUK_BW_WRITE_RAW_U8_4	(	thr,
		bw_ctx,
		val1,
		val2,
		val3,
		val4 )

Value:

        do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        *duk__p++ = (duk_uint8_t) (val4); \
        (bw_ctx)->p = duk__p; \
    } while (0)

Definition at line 1982 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        *duk__p++ = (duk_uint8_t) (val4); \
        (bw_ctx)->p = duk__p; \
    } while (0)

◆ DUK_BW_WRITE_RAW_U8_5

#define DUK_BW_WRITE_RAW_U8_5	(	thr,
		bw_ctx,
		val1,
		val2,
		val3,
		val4,
		val5 )

Value:

        do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        *duk__p++ = (duk_uint8_t) (val4); \
        *duk__p++ = (duk_uint8_t) (val5); \
        (bw_ctx)->p = duk__p; \
    } while (0)

Definition at line 1992 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        *duk__p++ = (duk_uint8_t) (val4); \
        *duk__p++ = (duk_uint8_t) (val5); \
        (bw_ctx)->p = duk__p; \
    } while (0)

◆ DUK_BW_WRITE_RAW_U8_6

#define DUK_BW_WRITE_RAW_U8_6	(	thr,
		bw_ctx,
		val1,
		val2,
		val3,
		val4,
		val5,
		val6 )

Value:

        do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        *duk__p++ = (duk_uint8_t) (val4); \
        *duk__p++ = (duk_uint8_t) (val5); \
        *duk__p++ = (duk_uint8_t) (val6); \
        (bw_ctx)->p = duk__p; \
    } while (0)

Definition at line 2003 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
        duk_uint8_t *duk__p; \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \
        duk__p = (bw_ctx)->p; \
        *duk__p++ = (duk_uint8_t) (val1); \
        *duk__p++ = (duk_uint8_t) (val2); \
        *duk__p++ = (duk_uint8_t) (val3); \
        *duk__p++ = (duk_uint8_t) (val4); \
        *duk__p++ = (duk_uint8_t) (val5); \
        *duk__p++ = (duk_uint8_t) (val6); \
        (bw_ctx)->p = duk__p; \
    } while (0)

◆ DUK_BW_WRITE_RAW_XUTF8

#define DUK_BW_WRITE_RAW_XUTF8	(	thr,
		bw_ctx,
		cp )

Value:

        do { \
        duk_ucodepoint_t duk__cp; \
        duk_small_int_t duk__enc_len; \
        duk__cp = (cp); \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \
        duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \
        (bw_ctx)->p += duk__enc_len; \
    } while (0)

Definition at line 2015 of file duktape-1.8.0/src/duktape.c.

#define DUK_BW_WRITE_RAW_XUTF8(thr,bw_ctx,cp) do { \
        duk_ucodepoint_t duk__cp; \
        duk_small_int_t duk__enc_len; \
        duk__cp = (cp); \
        DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \
        duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \
        (bw_ctx)->p += duk__enc_len; \
    } while (0)

Referenced by duk__case_transform_helper(), duk__slow_case_conversion(), and duk_unicode_case_convert_string().

◆ DUK_CALL_FLAG_CONSTRUCTOR_CALL

#define DUK_CALL_FLAG_CONSTRUCTOR_CALL (1 << 1) /* duk_handle_call_xxx: constructor call (i.e. called as 'new Foo()') */

Definition at line 8379 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_call_protected().

◆ DUK_CALL_FLAG_DIRECT_EVAL

#define DUK_CALL_FLAG_DIRECT_EVAL (1 << 4) /* call is a direct eval call */

Definition at line 8382 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CALL_FLAG_IGNORE_RECLIMIT

#define DUK_CALL_FLAG_IGNORE_RECLIMIT (1 << 0) /* duk_handle_call_xxx: call ignores C recursion limit (for errhandler calls) */

Definition at line 8378 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user(), and duk_handle_call_protected().

◆ DUK_CALL_FLAG_IS_RESUME

#define DUK_CALL_FLAG_IS_RESUME (1 << 2) /* duk_handle_ecma_call_setup: setup for a resume() */

Definition at line 8380 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_CALL_FLAG_IS_TAILCALL

#define DUK_CALL_FLAG_IS_TAILCALL (1 << 3) /* duk_handle_ecma_call_setup: setup for a tail call */

Definition at line 8381 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_CALLSTACK_DEFAULT_MAX

#define DUK_CALLSTACK_DEFAULT_MAX 10000L

Definition at line 6002 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_create_and_throw().

◆ DUK_CALLSTACK_GROW_STEP

#define DUK_CALLSTACK_GROW_STEP 8 /* roughly 256 bytes */

Definition at line 5998 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_create_and_throw(), and duk_hthread_callstack_grow().

◆ DUK_CALLSTACK_INITIAL_SIZE

#define DUK_CALLSTACK_INITIAL_SIZE 8

Definition at line 6001 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CALLSTACK_SHRINK_SPARE

#define DUK_CALLSTACK_SHRINK_SPARE 8 /* roughly 256 bytes */

Definition at line 6000 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CALLSTACK_SHRINK_THRESHOLD

#define DUK_CALLSTACK_SHRINK_THRESHOLD 16 /* roughly 512 bytes */

Definition at line 5999 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_CLEAR_CATCH_BINDING_ENABLED

#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED ( c )

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
    } while (0)

Definition at line 6076 of file duktape-1.8.0/src/duktape.c.

    } while (0)
 
#define DUK_CAT_CLEAR_CATCH_ENABLED(c)    do { \

◆ DUK_CAT_CLEAR_CATCH_ENABLED

#define DUK_CAT_CLEAR_CATCH_ENABLED ( c )

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)

Definition at line 6070 of file duktape-1.8.0/src/duktape.c.

    } while (0)
#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c)    do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \

◆ DUK_CAT_CLEAR_FINALLY_ENABLED

#define DUK_CAT_CLEAR_FINALLY_ENABLED ( c )

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_FINALLY_ENABLED; \
    } while (0)

Definition at line 6073 of file duktape-1.8.0/src/duktape.c.

    } while (0)
#define DUK_CAT_SET_LEXENV_ACTIVE(c)    do { \
        (c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \

◆ DUK_CAT_CLEAR_LEXENV_ACTIVE

#define DUK_CAT_CLEAR_LEXENV_ACTIVE ( c )

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_LEXENV_ACTIVE; \
    } while (0)

Definition at line 6079 of file duktape-1.8.0/src/duktape.c.

        (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)
#define DUK_CAT_CLEAR_FINALLY_ENABLED(c)  do { \

◆ DUK_CAT_FLAG_CATCH_BINDING_ENABLED

#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED (1 << 6) /* request to create catch binding */

Definition at line 6042 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_FLAG_CATCH_ENABLED

#define DUK_CAT_FLAG_CATCH_ENABLED (1 << 4) /* catch part will catch */

Definition at line 6040 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_FLAG_FINALLY_ENABLED

#define DUK_CAT_FLAG_FINALLY_ENABLED (1 << 5) /* finally part will catch */

Definition at line 6041 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_FLAG_LEXENV_ACTIVE

#define DUK_CAT_FLAG_LEXENV_ACTIVE (1 << 7) /* catch or with binding is currently active */

Definition at line 6043 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_GET_LABEL

#define DUK_CAT_GET_LABEL ( c ) (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT)

Definition at line 6050 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_GET_TYPE

#define DUK_CAT_GET_TYPE ( c ) ((c)->flags & DUK_CAT_TYPE_MASK)

Definition at line 6049 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_CAT_HAS_CATCH_BINDING_ENABLED

#define DUK_CAT_HAS_CATCH_BINDING_ENABLED ( c ) ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED)

Definition at line 6054 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_HAS_CATCH_ENABLED

#define DUK_CAT_HAS_CATCH_ENABLED ( c ) ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED)

Definition at line 6052 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_error_prototype_from_code().

◆ DUK_CAT_HAS_FINALLY_ENABLED

#define DUK_CAT_HAS_FINALLY_ENABLED ( c ) ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED)

Definition at line 6053 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_HAS_LEXENV_ACTIVE

#define DUK_CAT_HAS_LEXENV_ACTIVE ( c ) ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)

Definition at line 6055 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_LABEL_BITS

#define DUK_CAT_LABEL_BITS 24

Definition at line 6037 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_LABEL_MASK

#define DUK_CAT_LABEL_MASK 0xffffff00UL

Definition at line 6036 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_LABEL_SHIFT

#define DUK_CAT_LABEL_SHIFT 8

Definition at line 6038 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_SET_CATCH_BINDING_ENABLED

#define DUK_CAT_SET_CATCH_BINDING_ENABLED ( c )

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
    } while (0)

Definition at line 6063 of file duktape-1.8.0/src/duktape.c.

#define DUK_CAT_HAS_LEXENV_ACTIVE(c)           ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)
 
#define DUK_CAT_SET_CATCH_ENABLED(c)    do { \

◆ DUK_CAT_SET_CATCH_ENABLED

#define DUK_CAT_SET_CATCH_ENABLED ( c )

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)

Definition at line 6057 of file duktape-1.8.0/src/duktape.c.

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

◆ DUK_CAT_SET_FINALLY_ENABLED

#define DUK_CAT_SET_FINALLY_ENABLED ( c )

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; \
    } while (0)

Definition at line 6060 of file duktape-1.8.0/src/duktape.c.

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

◆ DUK_CAT_SET_LEXENV_ACTIVE

#define DUK_CAT_SET_LEXENV_ACTIVE ( c )

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \
    } while (0)

Definition at line 6066 of file duktape-1.8.0/src/duktape.c.

        (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)
#define DUK_CAT_SET_FINALLY_ENABLED(c)  do { \

◆ DUK_CAT_TYPE_BITS

#define DUK_CAT_TYPE_BITS 4

Definition at line 6035 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_TYPE_LABEL

#define DUK_CAT_TYPE_LABEL 2

Definition at line 6047 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_CAT_TYPE_MASK

#define DUK_CAT_TYPE_MASK 0x0000000fUL

Definition at line 6034 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_TYPE_TCF

#define DUK_CAT_TYPE_TCF 1

Definition at line 6046 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CAT_TYPE_UNKNOWN

#define DUK_CAT_TYPE_UNKNOWN 0

Definition at line 6045 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CATCHSTACK_DEFAULT_MAX

#define DUK_CATCHSTACK_DEFAULT_MAX 10000L

Definition at line 6008 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CATCHSTACK_GROW_STEP

#define DUK_CATCHSTACK_GROW_STEP 4 /* roughly 64 bytes */

Definition at line 6004 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CATCHSTACK_INITIAL_SIZE

#define DUK_CATCHSTACK_INITIAL_SIZE 4

Definition at line 6007 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CATCHSTACK_SHRINK_SPARE

#define DUK_CATCHSTACK_SHRINK_SPARE 4 /* roughly 64 bytes */

Definition at line 6006 of file duktape-1.8.0/src/duktape.c.

◆ DUK_CATCHSTACK_SHRINK_THRESHOLD

#define DUK_CATCHSTACK_SHRINK_THRESHOLD 8 /* roughly 128 bytes */

Definition at line 6005 of file duktape-1.8.0/src/duktape.c.

◆ DUK_COMPARE_FLAG_EVAL_LEFT_FIRST

#define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST (1 << 0) /* eval left argument first */

Definition at line 8389 of file duktape-1.8.0/src/duktape.c.

◆ DUK_COMPARE_FLAG_NEGATE

#define DUK_COMPARE_FLAG_NEGATE (1 << 1) /* negate result */

Definition at line 8390 of file duktape-1.8.0/src/duktape.c.

◆ DUK_COMPILER_MAX_BYTECODE_LENGTH

#define DUK_COMPILER_MAX_BYTECODE_LENGTH (256L * 1024L * 1024L) /* 1 GB */

Definition at line 3170 of file duktape-1.8.0/src/duktape.c.

◆ DUK_COMPILER_PEEPHOLE_MAXITER

#define DUK_COMPILER_PEEPHOLE_MAXITER 3

Definition at line 3167 of file duktape-1.8.0/src/duktape.c.

◆ DUK_COMPILER_TOKEN_LIMIT

#define DUK_COMPILER_TOKEN_LIMIT 100000000L /* 1e8: protects against deeply nested inner functions */

Definition at line 3164 of file duktape-1.8.0/src/duktape.c.

◆ DUK_COMPILING_DUKTAPE

#define DUK_COMPILING_DUKTAPE

Definition at line 139 of file duktape-1.8.0/src/duktape.c.

◆ DUK_D

#define DUK_D ( x ) do { } while (0) /* omit */

Definition at line 7526 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__coerce_effective_this_binding(), duk__get_own_propdesc_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__ivalue_toplain_ignore(), duk__parse_func_body(), duk__realloc_props(), duk__resize_valstack(), duk_err_create_and_throw(), duk_handle_call_protected(), duk_handle_ecma_call_setup(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_DBG_CMD_ADDBREAK

#define DUK_DBG_CMD_ADDBREAK 0x18

Definition at line 7321 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_ALERT

#define DUK_DBG_CMD_ALERT 0x03

Definition at line 7306 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_APPNOTIFY

#define DUK_DBG_CMD_APPNOTIFY 0x07

Definition at line 7310 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_APPREQUEST

#define DUK_DBG_CMD_APPREQUEST 0x22

Definition at line 7331 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_BASICINFO

#define DUK_DBG_CMD_BASICINFO 0x10

Definition at line 7313 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_DELBREAK

#define DUK_DBG_CMD_DELBREAK 0x19

Definition at line 7322 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_DETACH

#define DUK_DBG_CMD_DETACH 0x1f

Definition at line 7328 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_DETACHING

#define DUK_DBG_CMD_DETACHING 0x06

Definition at line 7309 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_DUMPHEAP

#define DUK_DBG_CMD_DUMPHEAP 0x20

Definition at line 7329 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_EVAL

#define DUK_DBG_CMD_EVAL 0x1e

Definition at line 7327 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETBYTECODE

#define DUK_DBG_CMD_GETBYTECODE 0x21

Definition at line 7330 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETCALLSTACK

#define DUK_DBG_CMD_GETCALLSTACK 0x1c

Definition at line 7325 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETHEAPOBJINFO

#define DUK_DBG_CMD_GETHEAPOBJINFO 0x23

Definition at line 7332 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETLOCALS

#define DUK_DBG_CMD_GETLOCALS 0x1d

Definition at line 7326 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETOBJPROPDESC

#define DUK_DBG_CMD_GETOBJPROPDESC 0x24

Definition at line 7333 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETOBJPROPDESCRANGE

#define DUK_DBG_CMD_GETOBJPROPDESCRANGE 0x25

Definition at line 7334 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_GETVAR

#define DUK_DBG_CMD_GETVAR 0x1a

Definition at line 7323 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_LISTBREAK

#define DUK_DBG_CMD_LISTBREAK 0x17

Definition at line 7320 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_LOG

#define DUK_DBG_CMD_LOG 0x04

Definition at line 7307 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_PAUSE

#define DUK_DBG_CMD_PAUSE 0x12

Definition at line 7315 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_PRINT

#define DUK_DBG_CMD_PRINT 0x02

Definition at line 7305 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_PUTVAR

#define DUK_DBG_CMD_PUTVAR 0x1b

Definition at line 7324 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_RESUME

#define DUK_DBG_CMD_RESUME 0x13

Definition at line 7316 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_STATUS

#define DUK_DBG_CMD_STATUS 0x01

Definition at line 7304 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_STEPINTO

#define DUK_DBG_CMD_STEPINTO 0x14

Definition at line 7317 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_STEPOUT

#define DUK_DBG_CMD_STEPOUT 0x16

Definition at line 7319 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_STEPOVER

#define DUK_DBG_CMD_STEPOVER 0x15

Definition at line 7318 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_THROW

#define DUK_DBG_CMD_THROW 0x05

Definition at line 7308 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_CMD_TRIGGERSTATUS

#define DUK_DBG_CMD_TRIGGERSTATUS 0x11

Definition at line 7314 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_ERR_APPLICATION

#define DUK_DBG_ERR_APPLICATION 0x04

Definition at line 7301 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_ERR_NOTFOUND

#define DUK_DBG_ERR_NOTFOUND 0x03

Definition at line 7300 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_ERR_TOOMANY

#define DUK_DBG_ERR_TOOMANY 0x02

Definition at line 7299 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_ERR_UNKNOWN

#define DUK_DBG_ERR_UNKNOWN 0x00

Definition at line 7297 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_ERR_UNSUPPORTED

#define DUK_DBG_ERR_UNSUPPORTED 0x01

Definition at line 7298 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_BUF2

#define DUK_DBG_IB_BUF2 0x14

Definition at line 7281 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_BUF4

#define DUK_DBG_IB_BUF4 0x13

Definition at line 7280 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_EOM

#define DUK_DBG_IB_EOM 0x00

Definition at line 7270 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_ERROR

#define DUK_DBG_IB_ERROR 0x03

Definition at line 7273 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_FALSE

#define DUK_DBG_IB_FALSE 0x19

Definition at line 7286 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_HEAPPTR

#define DUK_DBG_IB_HEAPPTR 0x1e

Definition at line 7291 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_INT4

#define DUK_DBG_IB_INT4 0x10

Definition at line 7277 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_LIGHTFUNC

#define DUK_DBG_IB_LIGHTFUNC 0x1d

Definition at line 7290 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_NOTIFY

#define DUK_DBG_IB_NOTIFY 0x04

Definition at line 7274 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_NULL

#define DUK_DBG_IB_NULL 0x17

Definition at line 7284 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_NUMBER

#define DUK_DBG_IB_NUMBER 0x1a

Definition at line 7287 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_OBJECT

#define DUK_DBG_IB_OBJECT 0x1b

Definition at line 7288 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_POINTER

#define DUK_DBG_IB_POINTER 0x1c

Definition at line 7289 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_REPLY

#define DUK_DBG_IB_REPLY 0x02

Definition at line 7272 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_REQUEST

#define DUK_DBG_IB_REQUEST 0x01

Definition at line 7271 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_STR2

#define DUK_DBG_IB_STR2 0x12

Definition at line 7279 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_STR4

#define DUK_DBG_IB_STR4 0x11

Definition at line 7278 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_TRUE

#define DUK_DBG_IB_TRUE 0x18

Definition at line 7285 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_UNDEFINED

#define DUK_DBG_IB_UNDEFINED 0x16

Definition at line 7283 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_IB_UNUSED

#define DUK_DBG_IB_UNUSED 0x15

Definition at line 7282 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DBG_PROPFLAG_INTERNAL

#define DUK_DBG_PROPFLAG_INTERNAL (1 << 8)

Definition at line 7339 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DD

#define DUK_DD ( x ) do { } while (0) /* omit */

Definition at line 7527 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user(), duk__generate_ranges(), duk__parse_disjunction(), duk__realloc_props(), duk__resize_valstack(), duk__run_voluntary_gc(), duk_err_create_and_throw(), duk_handle_call_protected(), duk_handle_ecma_call_setup(), duk_heap_strcache_string_remove(), duk_hobject_define_property_helper(), duk_hobject_putprop(), duk_hthread_callstack_grow(), and duk_hthread_copy_builtin_objects().

◆ DUK_DDD

#define DUK_DDD ( x ) do { } while (0) /* omit */

Definition at line 7528 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__coerce_effective_this_binding(), duk__declvar_helper(), duk__delvar_helper(), duk__emit_load_int32(), duk__err_augment_user(), duk__finalize_helper(), duk__free_markandsweep_finalize_list(), duk__free_refzero_list(), duk__free_run_finalizers(), duk__get_own_propdesc_raw(), duk__get_propdesc(), duk__getprop_shallow_fastpath_array_tval(), duk__getvar_helper(), duk__init_varmap_and_prologue_for_pass2(), duk__ispec_toregconst_raw(), duk__mark_temproots_by_heap_scan(), duk__parse_disjunction(), duk__parse_func_body(), duk__parse_string(), duk__parse_var_decl(), duk__putvar_helper(), duk__realloc_props(), duk__slow_case_conversion(), duk__sort_array_indices(), duk_bi_buffer_readfield(), duk_bi_typedarray_set(), duk_err_augment_error_create(), duk_err_create_and_throw(), duk_handle_ecma_call_setup(), duk_hbuffer_resize(), duk_heap_free_heaphdr_raw(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_putprop(), duk_hobject_run_finalizer(), duk_hstring_char_code_at_raw(), and duk_js_putvar_envrec().

◆ DUK_DDDPRINT

#define DUK_DDDPRINT 0 && /* args */

Definition at line 7540 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__coerce_effective_this_binding(), duk__declvar_helper(), duk__delvar_helper(), duk__emit_load_int32(), duk__err_augment_user(), duk__finalize_helper(), duk__free_markandsweep_finalize_list(), duk__free_refzero_list(), duk__free_run_finalizers(), duk__get_own_propdesc_raw(), duk__get_propdesc(), duk__getprop_shallow_fastpath_array_tval(), duk__getvar_helper(), duk__init_varmap_and_prologue_for_pass2(), duk__ispec_toregconst_raw(), duk__mark_temproots_by_heap_scan(), duk__parse_disjunction(), duk__parse_func_body(), duk__parse_string(), duk__parse_var_decl(), duk__putvar_helper(), duk__realloc_props(), duk__slow_case_conversion(), duk__sort_array_indices(), duk_bi_buffer_readfield(), duk_bi_typedarray_set(), duk_err_augment_error_create(), duk_err_create_and_throw(), duk_handle_ecma_call_setup(), duk_hbuffer_resize(), duk_heap_free_heaphdr_raw(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_putprop(), duk_hobject_run_finalizer(), duk_hstring_char_code_at_raw(), and duk_js_putvar_envrec().

◆ DUK_DDPRINT

#define DUK_DDPRINT 0 && /* args */

Definition at line 7539 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user(), duk__generate_ranges(), duk__parse_disjunction(), duk__realloc_props(), duk__resize_valstack(), duk__run_voluntary_gc(), duk_err_create_and_throw(), duk_handle_call_protected(), duk_handle_ecma_call_setup(), duk_heap_strcache_string_remove(), duk_hobject_define_property_helper(), duk_hobject_putprop(), duk_hthread_callstack_grow(), and duk_hthread_copy_builtin_objects().

◆ DUK_DEBUG_H_INCLUDED

#define DUK_DEBUG_H_INCLUDED

Definition at line 7432 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEBUGGER_H_INCLUDED

#define DUK_DEBUGGER_H_INCLUDED

Definition at line 7265 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEC_A

#define DUK_DEC_A ( x ) (((x) >> 6) & 0xffUL)

Definition at line 2551 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEC_ABC

#define DUK_DEC_ABC ( x ) (((x) >> 6) & 0x3ffffffUL)

Definition at line 2555 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEC_B

#define DUK_DEC_B ( x ) (((x) >> 14) & 0x1ffUL)

Definition at line 2552 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEC_BC

#define DUK_DEC_BC ( x ) (((x) >> 14) & 0x3ffffUL)

Definition at line 2554 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEC_C

#define DUK_DEC_C ( x ) (((x) >> 23) & 0x1ffUL)

Definition at line 2553 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DEC_OP

#define DUK_DEC_OP ( x ) ((x) & 0x3fUL)

Definition at line 2550 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DECL_TYPE_FUNC

#define DUK_DECL_TYPE_FUNC 1

Definition at line 3242 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_DECL_TYPE_VAR

#define DUK_DECL_TYPE_VAR 0

Definition at line 3241 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__parse_var_decl().

◆ DUK_DELPROP_FLAG_FORCE

#define DUK_DELPROP_FLAG_FORCE (1 << 1)

Definition at line 5495 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DELPROP_FLAG_THROW

#define DUK_DELPROP_FLAG_THROW (1 << 0)

Definition at line 5494 of file duktape-1.8.0/src/duktape.c.

◆ DUK_DPRINT

#define DUK_DPRINT 0 && /* args go here as a comma expression in parens */

Definition at line 7538 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__coerce_effective_this_binding(), duk__get_own_propdesc_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__ivalue_toplain_ignore(), duk__parse_func_body(), duk__realloc_props(), duk__resize_valstack(), duk_err_create_and_throw(), duk_handle_call_protected(), duk_handle_ecma_call_setup(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_ENC_OP

#define DUK_ENC_OP ( op ) ((duk_instr_t) (op))

Definition at line 2557 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ENC_OP_A

#define DUK_ENC_OP_A	(		op,
			a ) DUK_ENC_OP_A_B_C(op,a,0,0)

Definition at line 2574 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ENC_OP_A_B

#define DUK_ENC_OP_A_B	(	op,
		a,
		b ) DUK_ENC_OP_A_B_C(op,a,b,0)

Definition at line 2573 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ENC_OP_A_B_C

#define DUK_ENC_OP_A_B_C	(	op,
		a,
		b,
		c )

Value:

                                        ((duk_instr_t) ( \
                                        (((duk_instr_t) (c)) << 23) | \
                                        (((duk_instr_t) (b)) << 14) | \
                                        (((duk_instr_t) (a)) << 6) | \
                                        ((duk_instr_t) (op)) \
                                    ))

Definition at line 2567 of file duktape-1.8.0/src/duktape.c.

#define DUK_ENC_OP_A_B_C(op,a,b,c)  ((duk_instr_t) ( \
                                        (((duk_instr_t) (c)) << 23) | \
                                        (((duk_instr_t) (b)) << 14) | \
                                        (((duk_instr_t) (a)) << 6) | \
                                        ((duk_instr_t) (op)) \
                                    ))

◆ DUK_ENC_OP_A_BC

#define DUK_ENC_OP_A_BC	(	op,
		a,
		bc )

Value:

                                        ((duk_instr_t) ( \
                                        (((duk_instr_t) (bc)) << 14) | \
                                        (((duk_instr_t) (a)) << 6) | \
                                        ((duk_instr_t) (op)) \
                                    ))

Definition at line 2562 of file duktape-1.8.0/src/duktape.c.

#define DUK_ENC_OP_A_BC(op,a,bc)    ((duk_instr_t) ( \
                                        (((duk_instr_t) (bc)) << 14) | \
                                        (((duk_instr_t) (a)) << 6) | \
                                        ((duk_instr_t) (op)) \
                                    ))

◆ DUK_ENC_OP_ABC

#define DUK_ENC_OP_ABC	(		op,
			abc )

Value:

                                        ((duk_instr_t) ( \
                                        (((duk_instr_t) (abc)) << 6) | \
                                        ((duk_instr_t) (op)) \
                                    ))

Definition at line 2558 of file duktape-1.8.0/src/duktape.c.

#define DUK_ENC_OP_ABC(op,abc)      ((duk_instr_t) ( \
                                        (((duk_instr_t) (abc)) << 6) | \
                                        ((duk_instr_t) (op)) \
                                    ))

◆ DUK_EQUALS_FLAG_SAMEVALUE

#define DUK_EQUALS_FLAG_SAMEVALUE (1 << 0) /* use SameValue instead of non-strict equality */

Definition at line 8385 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EQUALS_FLAG_STRICT

#define DUK_EQUALS_FLAG_STRICT (1 << 1) /* use strict equality instead of non-strict equality */

Definition at line 8386 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ERRCODE_FLAG_NOBLAME_FILELINE

#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE (1L << 24)

Definition at line 4238 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_create_and_throw().

◆ DUK_ERRMSG_H_INCLUDED

#define DUK_ERRMSG_H_INCLUDED

Definition at line 2285 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ERROR

#define DUK_ERROR	(	thr,
		err,
		msg )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
    } while (0)

Definition at line 7649 of file duktape-1.8.0/src/duktape.c.

 *  because vararg call sites are larger than normal, and there are a lot
 *  of call sites with no formatting.
 *
 *  Note that special formatting provided by debug macros is NOT available.
 *

Referenced by duk_js_putvar_envrec().

◆ DUK_ERROR_ALLOC

#define DUK_ERROR_ALLOC	(		thr,
			msg )

Value:

        do { \
        duk_err_alloc((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
    } while (0)

Definition at line 7891 of file duktape-1.8.0/src/duktape.c.

#define DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr) do { \
        duk_err_unimplemented_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
    } while (0)

◆ DUK_ERROR_ALLOC_DEFMSG

#define DUK_ERROR_ALLOC_DEFMSG ( thr )

Value:

        do { \
        DUK_ERROR_ALLOC((thr), DUK_STR_ALLOC_FAILED); \
    } while (0)

Definition at line 7894 of file duktape-1.8.0/src/duktape.c.

#define DUK_ERROR_UNSUPPORTED(thr,msg) do { \
        DUK_ERROR((thr), DUK_ERR_UNSUPPORTED_ERROR, (msg)); \
    } while (0)

Referenced by duk__realloc_props().

◆ DUK_ERROR_API

#define DUK_ERROR_API	(		thr,
			msg )

Value:

        do { \
        duk_err_api((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
    } while (0)

Definition at line 7901 of file duktape-1.8.0/src/duktape.c.

#endif
#define DUK_ERROR_INTERNAL(thr,msg) do { \
        duk_err_internal((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \

Referenced by duk__pcall_prop_raw(), duk_debugger_pause(), duk_handle_call_protected(), duk_handle_ecma_call_setup(), duk_is_constructor_call(), and duk_push_sprintf().

◆ DUK_ERROR_API_INDEX

#define DUK_ERROR_API_INDEX	(		thr,
			index )

Value:

        do { \
        duk_err_api_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index)); \
    } while (0)

Definition at line 7898 of file duktape-1.8.0/src/duktape.c.

#define DUK_ERROR_UNSUPPORTED_DEFMSG(thr) do { \
        duk_err_unsupported_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
    } while (0)

Referenced by duk_get_top().

◆ DUK_ERROR_FMT1

#define DUK_ERROR_FMT1	(	thr,
		err,
		fmt,
		arg1 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
    } while (0)

Definition at line 7660 of file duktape-1.8.0/src/duktape.c.

 
/* Because there are quite many call sites, pack error code (require at most
 * 8-bit) into a single argument.
 */
#define DUK_ERROR(thr,err,msg) do { \

Referenced by duk__dec_eat_white(), and duk_handle_call_protected().

◆ DUK_ERROR_FMT2

#define DUK_ERROR_FMT2	(	thr,
		err,
		fmt,
		arg1,
		arg2 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
    } while (0)

Definition at line 7671 of file duktape-1.8.0/src/duktape.c.

        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
    } while (0)
 
#define DUK_ERROR_FMT1(thr,err,fmt,arg1) do { \

Referenced by duk_hobject_putprop().

◆ DUK_ERROR_FMT3

#define DUK_ERROR_FMT3	(	thr,
		err,
		fmt,
		arg1,
		arg2,
		arg3 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
    } while (0)

Definition at line 7682 of file duktape-1.8.0/src/duktape.c.

        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
    } while (0)
 
#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) do { \

◆ DUK_ERROR_FMT4

#define DUK_ERROR_FMT4	(	thr,
		err,
		fmt,
		arg1,
		arg2,
		arg3,
		arg4 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
    } while (0)

Definition at line 7693 of file duktape-1.8.0/src/duktape.c.

        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
    } while (0)
 
#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) do { \

◆ DUK_ERROR_H_INCLUDED

#define DUK_ERROR_H_INCLUDED

Definition at line 7610 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ERROR_INTERNAL

#define DUK_ERROR_INTERNAL	(		thr,
			msg )

Value:

        do { \
        duk_err_internal((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
    } while (0)

Definition at line 7885 of file duktape-1.8.0/src/duktape.c.

    } while (0)
#endif  /* DUK_USE_PARANOID_ERRORS */
 

◆ DUK_ERROR_INTERNAL_DEFMSG

#define DUK_ERROR_INTERNAL_DEFMSG ( thr )

Value:

        do { \
        duk_err_internal_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
    } while (0)

Definition at line 7888 of file duktape-1.8.0/src/duktape.c.

#define DUK_ERROR_UNIMPLEMENTED(thr,msg) do { \
        DUK_ERROR((thr), DUK_ERR_UNIMPLEMENTED_ERROR, (msg)); \
    } while (0)

Referenced by duk__parse_func_body().

◆ DUK_ERROR_RANGE

#define DUK_ERROR_RANGE	(		thr,
			msg )

Value:

        do { \
        duk_err_range((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
    } while (0)

Definition at line 7907 of file duktape-1.8.0/src/duktape.c.

    } while (0)
#define DUK_ERROR_ALLOC(thr,msg) do { \
        duk_err_alloc((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \

Referenced by duk__get_propdesc(), duk__init_varmap_and_prologue_for_pass2(), duk__parse_disjunction(), duk__settemp_checkmax(), duk_bi_array_constructor(), duk_hbuffer_resize(), duk_hobject_putprop(), duk_hthread_callstack_grow(), duk_js_instanceof(), duk_lexer_parse_js_input_element(), and duk_to_string().

◆ DUK_ERROR_RAW

#define DUK_ERROR_RAW	(	thr,
		file,
		line,
		err,
		msg )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
    } while (0)

Definition at line 7654 of file duktape-1.8.0/src/duktape.c.

 *  The _RAW variants allow the caller to specify file and line.  This makes
 *  it easier to write checked calls which want to use the call site of the
 *  checked function, not the error macro call inside the checked function.
 */
 

Referenced by duk_err_alloc(), and duk_err_internal_defmsg().

◆ DUK_ERROR_RAW_FMT1

#define DUK_ERROR_RAW_FMT1	(	thr,
		file,
		line,
		err,
		fmt,
		arg1 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
    } while (0)

Definition at line 7665 of file duktape-1.8.0/src/duktape.c.

        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
    } while (0)
#define DUK_ERROR_RAW(thr,file,line,err,msg) do { \

Referenced by duk_err_internal().

◆ DUK_ERROR_RAW_FMT2

#define DUK_ERROR_RAW_FMT2	(	thr,
		file,
		line,
		err,
		fmt,
		arg1,
		arg2 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
    } while (0)

Definition at line 7676 of file duktape-1.8.0/src/duktape.c.

        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
    } while (0)
#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) do { \

◆ DUK_ERROR_RAW_FMT3

#define DUK_ERROR_RAW_FMT3	(	thr,
		file,
		line,
		err,
		fmt,
		arg1,
		arg2,
		arg3 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
    } while (0)

Definition at line 7687 of file duktape-1.8.0/src/duktape.c.

        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
    } while (0)
#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) do { \

Referenced by duk_err_api().

◆ DUK_ERROR_RAW_FMT4

#define DUK_ERROR_RAW_FMT4	(	thr,
		file,
		line,
		err,
		fmt,
		arg1,
		arg2,
		arg3,
		arg4 )

Value:

        do { \
        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
    } while (0)

Definition at line 7698 of file duktape-1.8.0/src/duktape.c.

        duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
        DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
        duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
    } while (0)
#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) do { \

◆ DUK_ERROR_REQUIRE_TYPE_INDEX

#define DUK_ERROR_REQUIRE_TYPE_INDEX	(	thr,
		index,
		expectname,
		lowmemstr )

Value:

        do { \
        duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index), (expectname)); \
    } while (0)

Definition at line 7866 of file duktape-1.8.0/src/duktape.c.

 *  The goal is to provide verbose and configurable error messages.  Call
 *  sites should be clean in source code and compile to a small footprint.
 *  Small footprint is also useful for performance because small cold paths

Referenced by duk_get_heapptr(), duk_get_hobject_with_class(), duk_get_number(), duk_normalize_index(), duk_require_hcompiledfunction(), duk_require_hnativefunction(), duk_require_hthread(), and duk_require_null().

◆ DUK_ERROR_SYNTAX

#define DUK_ERROR_SYNTAX	(		thr,
			msg )

Value:

        do { \
        DUK_ERROR((thr), DUK_ERR_SYNTAX_ERROR, (msg)); \
    } while (0)

Definition at line 7911 of file duktape-1.8.0/src/duktape.c.

#define DUK_ERROR_ALLOC_DEFMSG(thr) do { \
        DUK_ERROR_ALLOC((thr), DUK_STR_ALLOC_FAILED); \
    } while (0)

Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__parse_disjunction(), duk__parse_func_body(), duk__parse_func_formals(), duk__parse_try_stmt(), and duk_lexer_parse_js_input_element().

◆ DUK_ERROR_TYPE

#define DUK_ERROR_TYPE	(		thr,
			msg )

Value:

        do { \
        DUK_ERROR((thr), DUK_ERR_TYPE_ERROR, (msg)); \
    } while (0)

Definition at line 7914 of file duktape-1.8.0/src/duktape.c.

/* DUK_ERR_ASSERTION_ERROR: no macros needed */
#define DUK_ERROR_API_INDEX(thr,index) do { \
        duk_err_api_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index)); \

Referenced by duk_hobject_define_property_helper(), duk_hobject_prepare_property_descriptor(), duk_hobject_putprop(), duk_is_null_or_undefined(), and duk_js_instanceof().

◆ DUK_ERROR_UNIMPLEMENTED

#define DUK_ERROR_UNIMPLEMENTED	(		thr,
			msg )

Value:

        do { \
        DUK_ERROR((thr), DUK_ERR_UNIMPLEMENTED_ERROR, (msg)); \
    } while (0)

Definition at line 7871 of file duktape-1.8.0/src/duktape.c.

 */
 
#if defined(DUK_USE_VERBOSE_ERRORS)

◆ DUK_ERROR_UNIMPLEMENTED_DEFMSG

#define DUK_ERROR_UNIMPLEMENTED_DEFMSG ( thr )

Value:

        do { \
        duk_err_unimplemented_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
    } while (0)

Definition at line 7874 of file duktape-1.8.0/src/duktape.c.

/* Verbose errors with key/value summaries (non-paranoid) or without key/value
 * summaries (paranoid, for some security sensitive environments), the paranoid
 * vs. non-paranoid distinction affects only a few specific errors.

◆ DUK_ERROR_UNSUPPORTED

#define DUK_ERROR_UNSUPPORTED	(		thr,
			msg )

Value:

        do { \
        DUK_ERROR((thr), DUK_ERR_UNSUPPORTED_ERROR, (msg)); \
    } while (0)

Definition at line 7877 of file duktape-1.8.0/src/duktape.c.

 */
#if defined(DUK_USE_PARANOID_ERRORS)
#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \

◆ DUK_EXCEPTION_H_INCLUDED

#define DUK_EXCEPTION_H_INCLUDED

Definition at line 224 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_BNOT

#define DUK_EXTRAOP_BNOT 28

Definition at line 2689 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_BREAK

#define DUK_EXTRAOP_BREAK 26

Definition at line 2687 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_CONTINUE

#define DUK_EXTRAOP_CONTINUE 27

Definition at line 2688 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_DEBUGGER

#define DUK_EXTRAOP_DEBUGGER 25

Definition at line 2686 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_ENDCATCH

#define DUK_EXTRAOP_ENDCATCH 19

Definition at line 2680 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_ENDFIN

#define DUK_EXTRAOP_ENDFIN 20

Definition at line 2681 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_ENDLABEL

#define DUK_EXTRAOP_ENDLABEL 33

Definition at line 2694 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_ENDTRY

#define DUK_EXTRAOP_ENDTRY 18

Definition at line 2679 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_IN

#define DUK_EXTRAOP_IN 31

Definition at line 2692 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INITENUM

#define DUK_EXTRAOP_INITENUM 12

Definition at line 2673 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INITGET

#define DUK_EXTRAOP_INITGET 16

Definition at line 2677 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INITGETI

#define DUK_EXTRAOP_INITGETI 17

Definition at line 2678 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INITSET

#define DUK_EXTRAOP_INITSET 14

Definition at line 2675 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INITSETI

#define DUK_EXTRAOP_INITSETI 15

Definition at line 2676 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INSTOF

#define DUK_EXTRAOP_INSTOF 30

Definition at line 2691 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INVALID

#define DUK_EXTRAOP_INVALID 1

Definition at line 2662 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_INVLHS

#define DUK_EXTRAOP_INVLHS 22

Definition at line 2683 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_LABEL

#define DUK_EXTRAOP_LABEL 32

Definition at line 2693 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_LDFALSE

#define DUK_EXTRAOP_LDFALSE 6

Definition at line 2667 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK_EXTRAOP_LDNULL

#define DUK_EXTRAOP_LDNULL 4

Definition at line 2665 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK_EXTRAOP_LDTHIS

#define DUK_EXTRAOP_LDTHIS 2

Definition at line 2663 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_LDTRUE

#define DUK_EXTRAOP_LDTRUE 5

Definition at line 2666 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK_EXTRAOP_LDUNDEF

#define DUK_EXTRAOP_LDUNDEF 3

Definition at line 2664 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), and duk__parse_func_body().

◆ DUK_EXTRAOP_LNOT

#define DUK_EXTRAOP_LNOT 29

Definition at line 2690 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_NEWARR

#define DUK_EXTRAOP_NEWARR 8

Definition at line 2669 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_NEWOBJ

#define DUK_EXTRAOP_NEWOBJ 7

Definition at line 2668 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_NEXTENUM

#define DUK_EXTRAOP_NEXTENUM 13

Definition at line 2674 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_NOP

#define DUK_EXTRAOP_NOP 0

Definition at line 2661 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_SETALEN

#define DUK_EXTRAOP_SETALEN 9

Definition at line 2670 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_THROW

#define DUK_EXTRAOP_THROW 21

Definition at line 2682 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_try_stmt().

◆ DUK_EXTRAOP_TYPEOF

#define DUK_EXTRAOP_TYPEOF 10

Definition at line 2671 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_TYPEOFID

#define DUK_EXTRAOP_TYPEOFID 11

Definition at line 2672 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_UNM

#define DUK_EXTRAOP_UNM 23

Definition at line 2684 of file duktape-1.8.0/src/duktape.c.

◆ DUK_EXTRAOP_UNP

#define DUK_EXTRAOP_UNP 24

Definition at line 2685 of file duktape-1.8.0/src/duktape.c.

◆ DUK_FORWDECL_H_INCLUDED

#define DUK_FORWDECL_H_INCLUDED

Definition at line 239 of file duktape-1.8.0/src/duktape.c.

◆ DUK_FREE

#define DUK_FREE	(		heap,
			ptr ) duk_heap_mem_free((heap), (ptr))

Definition at line 6895 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__realloc_props(), and duk_free_hobject_inner().

◆ DUK_FREE_RAW

#define DUK_FREE_RAW	(		heap,
			ptr ) ((heap)->free_func((heap)->heap_udata, (void *) (ptr)))

Definition at line 6857 of file duktape-1.8.0/src/duktape.c.

6857 */

6858

Referenced by duk_alloc().

◆ DUK_GET_HOBJECT_NEGIDX

#define DUK_GET_HOBJECT_NEGIDX	(		ctx,
			idx ) (DUK_ASSERT_VALID_NEGIDX((ctx),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (ctx))->valstack_top + (idx)))

Definition at line 4411 of file duktape-1.8.0/src/duktape.c.

4411#define DUK_GET_HOBJECT_NEGIDX(ctx,idx) \

4412 (DUK_ASSERT_VALID_NEGIDX((ctx),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (ctx))->valstack_top + (idx)))

◆ DUK_GET_HOBJECT_POSIDX

#define DUK_GET_HOBJECT_POSIDX	(		ctx,
			idx ) (DUK_ASSERT_VALID_POSIDX((ctx),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (ctx))->valstack_bottom + (idx)))

Definition at line 4413 of file duktape-1.8.0/src/duktape.c.

4413#define DUK_GET_HOBJECT_POSIDX(ctx,idx) \

4414 (DUK_ASSERT_VALID_POSIDX((ctx),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (ctx))->valstack_bottom + (idx)))

◆ DUK_GET_TVAL_NEGIDX

#define DUK_GET_TVAL_NEGIDX	(		ctx,
			idx ) (DUK_ASSERT_VALID_NEGIDX((ctx),(idx)), ((duk_hthread *) (ctx))->valstack_top + (idx))

Definition at line 4407 of file duktape-1.8.0/src/duktape.c.

4407#define DUK_GET_TVAL_NEGIDX(ctx,idx) \

4408 (DUK_ASSERT_VALID_NEGIDX((ctx),(idx)), ((duk_hthread *) (ctx))->valstack_top + (idx))

Referenced by duk_hobject_get_length().

◆ DUK_GET_TVAL_POSIDX

#define DUK_GET_TVAL_POSIDX	(		ctx,
			idx ) (DUK_ASSERT_VALID_POSIDX((ctx),(idx)), ((duk_hthread *) (ctx))->valstack_bottom + (idx))

Definition at line 4409 of file duktape-1.8.0/src/duktape.c.

4409#define DUK_GET_TVAL_POSIDX(ctx,idx) \

4410 (DUK_ASSERT_VALID_POSIDX((ctx),(idx)), ((duk_hthread *) (ctx))->valstack_bottom + (idx))

Referenced by duk__ispec_toregconst_raw().

◆ DUK_GETDESC_FLAG_IGNORE_PROTOLOOP

#define DUK_GETDESC_FLAG_IGNORE_PROTOLOOP (1 << 1) /* don't throw for prototype loop */

Definition at line 4916 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_propdesc().

◆ DUK_GETDESC_FLAG_PUSH_VALUE

#define DUK_GETDESC_FLAG_PUSH_VALUE (1 << 0) /* push value to stack */

Definition at line 4915 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_HBUFFER_ADD_SIZE

#define DUK_HBUFFER_ADD_SIZE	(		x,
			dv )

Value:

        do { \
        (x)->size += (dv); \
    } while (0)

Definition at line 6425 of file duktape-1.8.0/src/duktape.c.

#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
        (x)->hdr.h_flags -= ((dv) << 16); \
    } while (0)

◆ DUK_HBUFFER_CLEAR_DYNAMIC

#define DUK_HBUFFER_CLEAR_DYNAMIC ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)

Definition at line 6376 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_CLEAR_EXTERNAL

#define DUK_HBUFFER_CLEAR_EXTERNAL ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)

Definition at line 6377 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_DECREF

#define DUK_HBUFFER_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))

Definition at line 3842 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_DYNAMIC_ADD_SIZE

#define DUK_HBUFFER_DYNAMIC_ADD_SIZE	(		x,
			dv ) DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv))

Definition at line 6438 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_DYNAMIC_GET_DATA_PTR

#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR	(		heap,
			x ) ((x)->curr_alloc)

Definition at line 6456 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bw_init(), and duk_hbuffer_resize().

◆ DUK_HBUFFER_DYNAMIC_GET_SIZE

#define DUK_HBUFFER_DYNAMIC_GET_SIZE ( x ) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))

Definition at line 6436 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__appendbuffer(), and duk_hbuffer_resize().

◆ DUK_HBUFFER_DYNAMIC_SET_DATA_PTR

#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR	(	heap,
		x,
		v )

Value:

        do { \
        (x)->curr_alloc = (void *) (v); \
    } while (0)

Definition at line 6457 of file duktape-1.8.0/src/duktape.c.

#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
        ((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
    } while (0)

◆ DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL

#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL	(		heap,
			x )

Value:

        do { \
        (x)->curr_alloc = (void *) NULL; \
    } while (0)

Definition at line 6460 of file duktape-1.8.0/src/duktape.c.

#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
        ((duk_heaphdr *) (x))->h_extra16 = 0;  /* assume 0 <=> NULL */ \
    } while (0)

◆ DUK_HBUFFER_DYNAMIC_SET_SIZE

#define DUK_HBUFFER_DYNAMIC_SET_SIZE	(		x,
			v ) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))

Definition at line 6437 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_DYNAMIC_SUB_SIZE

#define DUK_HBUFFER_DYNAMIC_SUB_SIZE	(		x,
			dv ) DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv))

Definition at line 6439 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_EXTERNAL_GET_DATA_PTR

#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR	(		heap,
			x ) ((void *) (x)->curr_alloc)

Definition at line 6478 of file duktape-1.8.0/src/duktape.c.

6478 ((void *) (x)->curr_alloc)

6479#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v) do { \

DUK_HBUFFER_EXTERNAL_SET_DATA_PTR

#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, x, v)

Definition duktape-1.8.0/src/duktape.c:6480

◆ DUK_HBUFFER_EXTERNAL_GET_SIZE

#define DUK_HBUFFER_EXTERNAL_GET_SIZE ( x ) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))

Definition at line 6441 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_EXTERNAL_SET_DATA_PTR

#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR	(	heap,
		x,
		v )

Value:

        do { \
        (x)->curr_alloc = (void *) (v); \
    } while (0)

Definition at line 6480 of file duktape-1.8.0/src/duktape.c.

        (x)->curr_alloc = (void *) (v); \
    } while (0)
#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \

◆ DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL

#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL	(		heap,
			x )

Value:

        do { \
        (x)->curr_alloc = (void *) NULL; \
    } while (0)

Definition at line 6483 of file duktape-1.8.0/src/duktape.c.

        (x)->curr_alloc = (void *) NULL; \
    } while (0)
#else

◆ DUK_HBUFFER_EXTERNAL_SET_SIZE

#define DUK_HBUFFER_EXTERNAL_SET_SIZE	(		x,
			v ) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))

Definition at line 6442 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_FIXED_GET_DATA_PTR

#define DUK_HBUFFER_FIXED_GET_DATA_PTR	(		heap,
			x ) ((duk_uint8_t ) (((duk_hbuffer_fixed ) (x)) + 1))

Definition at line 6444 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_FIXED_GET_SIZE

#define DUK_HBUFFER_FIXED_GET_SIZE ( x ) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))

Definition at line 6433 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_FIXED_SET_SIZE

#define DUK_HBUFFER_FIXED_SET_SIZE	(		x,
			v ) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x))

Definition at line 6434 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_FLAG_DYNAMIC

#define DUK_HBUFFER_FLAG_DYNAMIC DUK_HEAPHDR_USER_FLAG(0) /* buffer is behind a pointer, dynamic or external */

Definition at line 6367 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_FLAG_EXTERNAL

#define DUK_HBUFFER_FLAG_EXTERNAL DUK_HEAPHDR_USER_FLAG(1) /* buffer pointer is to an externally allocated buffer */

Definition at line 6368 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_GET_DATA_PTR

#define DUK_HBUFFER_GET_DATA_PTR	(		heap,
			x )

Value:

    ( \
    DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
        DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) : \
        DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
    )

Definition at line 6505 of file duktape-1.8.0/src/duktape.c.

                DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) \
        ) : \
        DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
    )
#else

Referenced by duk__get_own_propdesc_raw(), and duk_hobject_putprop().

◆ DUK_HBUFFER_GET_SIZE

#define DUK_HBUFFER_GET_SIZE ( x ) (((duk_hbuffer *) (x))->size)

Definition at line 6421 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_HBUFFER_H_INCLUDED

#define DUK_HBUFFER_H_INCLUDED

Definition at line 6357 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_HAS_DYNAMIC

#define DUK_HBUFFER_HAS_DYNAMIC ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)

Definition at line 6370 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info(), and duk_hbuffer_resize().

◆ DUK_HBUFFER_HAS_EXTERNAL

#define DUK_HBUFFER_HAS_EXTERNAL ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)

Definition at line 6371 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info(), and duk_hbuffer_resize().

◆ DUK_HBUFFER_INCREF

#define DUK_HBUFFER_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))

Definition at line 3841 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ DUK_HBUFFER_MAX_BYTELEN

#define DUK_HBUFFER_MAX_BYTELEN (0x7ffffffeUL)

Definition at line 6395 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hbuffer_resize().

◆ DUK_HBUFFER_SET_DYNAMIC

#define DUK_HBUFFER_SET_DYNAMIC ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)

Definition at line 6373 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_SET_EXTERNAL

#define DUK_HBUFFER_SET_EXTERNAL ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)

Definition at line 6374 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFER_SET_SIZE

#define DUK_HBUFFER_SET_SIZE	(		x,
			v )

Value:

        do { \
        ((duk_hbuffer *) (x))->size = (v); \
    } while (0)

Definition at line 6422 of file duktape-1.8.0/src/duktape.c.

#define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
        (x)->hdr.h_flags += ((dv) << 16); \
    } while (0)

◆ DUK_HBUFFER_SUB_SIZE

#define DUK_HBUFFER_SUB_SIZE	(		x,
			dv )

Value:

        do { \
        (x)->size -= (dv); \
    } while (0)

Definition at line 6428 of file duktape-1.8.0/src/duktape.c.

#else
#define DUK_HBUFFER_GET_SIZE(x)     (((duk_hbuffer *) (x))->size)
#define DUK_HBUFFER_SET_SIZE(x,v)   do { \

◆ DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH

#define DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH	(		h,
			len )

Value:

(DUK_ASSERT_EXPR((h) != NULL), \

duk_hbufferobject_clamp_bytelength((h), (len)))

Definition at line 5923 of file duktape-1.8.0/src/duktape.c.

 * duk_hbufferobject 'length') to the current dynamic buffer limits to
 * yield a byte length limit that's safe for memory accesses.  This value
 * can be invalidated by any side effect because it may trigger a user

Referenced by duk_bi_buffer_readfield(), and duk_bi_buffer_slice_shared().

◆ DUK_HBUFFEROBJECT_DECREF

#define DUK_HBUFFEROBJECT_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3848 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_FLOAT32

#define DUK_HBUFFEROBJECT_ELEM_FLOAT32 7

Definition at line 5851 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_FLOAT64

#define DUK_HBUFFEROBJECT_ELEM_FLOAT64 8

Definition at line 5852 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_INT16

#define DUK_HBUFFEROBJECT_ELEM_INT16 4

Definition at line 5848 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_INT32

#define DUK_HBUFFEROBJECT_ELEM_INT32 6

Definition at line 5850 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_INT8

#define DUK_HBUFFEROBJECT_ELEM_INT8 2

Definition at line 5846 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_MAX

#define DUK_HBUFFEROBJECT_ELEM_MAX 8

Definition at line 5853 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_UINT16

#define DUK_HBUFFEROBJECT_ELEM_UINT16 3

Definition at line 5847 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_UINT32

#define DUK_HBUFFEROBJECT_ELEM_UINT32 5

Definition at line 5849 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_UINT8

#define DUK_HBUFFEROBJECT_ELEM_UINT8 0

Definition at line 5844 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED

#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED 1

Definition at line 5845 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_FULL_SLICE

#define DUK_HBUFFEROBJECT_FULL_SLICE ( h )

Value:

(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \

((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf)))

Definition at line 5891 of file duktape-1.8.0/src/duktape.c.

/* True if slice is full, i.e. offset is zero and length covers the entire
 * buffer.  This status may change independently of the duk_hbufferobject if
 * the underlying buffer is dynamic and changes without the hbufferobject

◆ DUK_HBUFFEROBJECT_GET_SLICE_BASE

#define DUK_HBUFFEROBJECT_GET_SLICE_BASE	(		heap,
			h )

Value:

(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \

(((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset))

Definition at line 5882 of file duktape-1.8.0/src/duktape.c.

    } while (0)
 
/* Get the current data pointer (caller must ensure buf != NULL) as a

Referenced by duk_bi_buffer_readfield(), duk_bi_buffer_slice_shared(), and duk_bi_typedarray_set().

◆ DUK_HBUFFEROBJECT_H_INCLUDED

#define DUK_HBUFFEROBJECT_H_INCLUDED

Definition at line 5841 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_INCREF

#define DUK_HBUFFEROBJECT_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3847 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL

#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL	(		h,
			off )

Value:

(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \

((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf)))

Definition at line 5913 of file duktape-1.8.0/src/duktape.c.

 */
#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h,off) \
    (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \

Referenced by duk__get_own_propdesc_raw(), duk_bi_typedarray_set(), and duk_hobject_putprop().

◆ DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL

#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL	(		h,
			off )

Value:

(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \

((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf)))

Definition at line 5909 of file duktape-1.8.0/src/duktape.c.

 * buffer size.  This is a safety check which is needed to ensure
 * that even a misconfigured duk_hbufferobject never causes memory
 * unsafe behavior (e.g. if an underlying dynamic buffer changes

◆ DUK_HBUFFEROBJECT_VALID_SLICE

#define DUK_HBUFFEROBJECT_VALID_SLICE ( h )

Value:

(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \

((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf)))

Definition at line 5898 of file duktape-1.8.0/src/duktape.c.

    ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf)))
 
/* Validate that the whole slice [0,length[ is contained in the underlying

Referenced by duk_bi_typedarray_set().

◆ DUK_HCOMPILEDFUNCTION_DECREF

#define DUK_HCOMPILEDFUNCTION_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3844 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE

#define DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE	(		heap,
			h ) DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h)))

Definition at line 5618 of file duktape-1.8.0/src/duktape.c.

5618

5619/* Note: assumes 'data' is always a fixed buffer */

◆ DUK_HCOMPILEDFUNCTION_GET_BYTECODE

#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE	(		heap,
			h ) ((h)->bytecode)

Definition at line 5606 of file duktape-1.8.0/src/duktape.c.

5606 (h)->funcs = (v); \

5607 } while (0)

funcs

static const luaL_Reg funcs[]

Definition lua-5.3.6/src/lutf8lib.c:238

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_BASE

#define DUK_HCOMPILEDFUNCTION_GET_CODE_BASE	(		heap,
			h ) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))

Definition at line 5627 of file duktape-1.8.0/src/duktape.c.

5627 DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))

5628

DUK_HCOMPILEDFUNCTION_GET_FUNCS

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap, h)

Definition duktape-1.8.0/src/duktape.c:5601

Referenced by duk_handle_ecma_call_setup(), and duk_hthread_get_act_prev_pc().

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT

#define DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT	(		heap,
			h ) ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t)))

Definition at line 5674 of file duktape-1.8.0/src/duktape.c.

5674 ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))

5675

DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(heap, h)

Definition duktape-1.8.0/src/duktape.c:5650

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_END

#define DUK_HCOMPILEDFUNCTION_GET_CODE_END	(		heap,
			h )

Value:

((duk_instr_t *) (void *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + \

DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h))))

DUK_HCOMPILEDFUNCTION_GET_DATA

#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap, h)

Definition duktape-1.8.0/src/duktape.c:5596

Definition at line 5637 of file duktape-1.8.0/src/duktape.c.

 
/* XXX: double evaluation of DUK_HCOMPILEDFUNCTION_GET_DATA() */
#define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap,h)  \

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE	(		heap,
			h )

Value:

    ( \
     (duk_size_t) \
     ( \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \
     ) \
    )

Definition at line 5659 of file duktape-1.8.0/src/duktape.c.

    )
 
#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap,h)  \
    ( \
     (duk_size_t) \
     ( \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \

◆ DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE

#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE	(		heap,
			h ) ((duk_tval ) (void ) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h)))

Definition at line 5621 of file duktape-1.8.0/src/duktape.c.

5621 DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h)))

5622

Referenced by duk__inc_data_inner_refcounts().

◆ DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT

#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT	(		heap,
			h ) ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))

Definition at line 5668 of file duktape-1.8.0/src/duktape.c.

5668 )

5669

◆ DUK_HCOMPILEDFUNCTION_GET_CONSTS_END

#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_END	(		heap,
			h ) ((duk_tval ) (void ) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)))

Definition at line 5630 of file duktape-1.8.0/src/duktape.c.

5630 DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))

5631

DUK_HCOMPILEDFUNCTION_GET_BYTECODE

#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap, h)

Definition duktape-1.8.0/src/duktape.c:5606

Referenced by duk__inc_data_inner_refcounts().

◆ DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE	(		heap,
			h )

Value:

    ( \
     (duk_size_t) \
     ( \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE((heap), (h))) \
     ) \
    )

Definition at line 5641 of file duktape-1.8.0/src/duktape.c.

                    DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h))))
 
#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap,h)  \
    ( \
     (duk_size_t) \
     ( \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE((heap), (h))) \

◆ DUK_HCOMPILEDFUNCTION_GET_DATA

#define DUK_HCOMPILEDFUNCTION_GET_DATA	(		heap,
			h ) ((duk_hbuffer_fixed ) (void ) (h)->data)

Definition at line 5596 of file duktape-1.8.0/src/duktape.c.

5596 } while (0)

5597#else

Referenced by duk__inc_data_inner_refcounts(), and duk_bi_duktape_object_info().

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS	(		heap,
			h ) ((h)->funcs)

Definition at line 5601 of file duktape-1.8.0/src/duktape.c.

5601 (h)->data = (duk_hbuffer *) (v); \

5602 } while (0)

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE	(		heap,
			h ) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))

Definition at line 5624 of file duktape-1.8.0/src/duktape.c.

5624 ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h)))

5625

DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE

#define DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE(heap, h)

Definition duktape-1.8.0/src/duktape.c:5618

duk_tval_struct

Definition duktape-1.5.2/src-noline/duktape.c:616

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT	(		heap,
			h ) ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))

Definition at line 5671 of file duktape-1.8.0/src/duktape.c.

5671 ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))

5672

duk_tval

struct duk_tval_struct duk_tval

Definition duktape-1.8.0/src/duktape.c:620

DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap, h)

Definition duktape-1.8.0/src/duktape.c:5641

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS_END

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_END	(		heap,
			h ) ((duk_hobject *) (void ) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h)))

Definition at line 5633 of file duktape-1.8.0/src/duktape.c.

5633 ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)))

5634

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE	(		heap,
			h )

Value:

    ( \
     (duk_size_t) \
     ( \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \
     ) \
    )

Definition at line 5650 of file duktape-1.8.0/src/duktape.c.

    )
 
#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(heap,h)  \
    ( \
     (duk_size_t) \
     ( \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \
       ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \

◆ DUK_HCOMPILEDFUNCTION_H_INCLUDED

#define DUK_HCOMPILEDFUNCTION_H_INCLUDED

Definition at line 5571 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HCOMPILEDFUNCTION_INCREF

#define DUK_HCOMPILEDFUNCTION_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3843 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HCOMPILEDFUNCTION_SET_BYTECODE

#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE	(	heap,
		h,
		v )

Value:

        do { \
        (h)->bytecode = (v); \
    } while (0)

Definition at line 5608 of file duktape-1.8.0/src/duktape.c.

#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h)  \
    ((h)->bytecode)
#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v)  do { \

◆ DUK_HCOMPILEDFUNCTION_SET_DATA

#define DUK_HCOMPILEDFUNCTION_SET_DATA	(	heap,
		h,
		v )

Value:

        do { \
        (h)->data = (duk_hbuffer *) (v); \
    } while (0)

Definition at line 5598 of file duktape-1.8.0/src/duktape.c.

#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \
    ((duk_hbuffer_fixed *) (void *) (h)->data)
#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \

◆ DUK_HCOMPILEDFUNCTION_SET_FUNCS

#define DUK_HCOMPILEDFUNCTION_SET_FUNCS	(	heap,
		h,
		v )

Value:

        do { \
        (h)->funcs = (v); \
    } while (0)

Definition at line 5603 of file duktape-1.8.0/src/duktape.c.

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h)  \
    ((h)->funcs)
#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v)  do { \

◆ DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT

#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT

Value:

                                                              3  /* Starting from this round, use emergency mode
                                                              * for mark-and-sweep.
                                                              */

Definition at line 6903 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT

#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT

Value:

                                                              5   /* Retry allocation after mark-and-sweep for this
                                                              * many times.  A single mark-and-sweep round is
                                                              * not guaranteed to free all unreferenced memory
                                                              * because of finalization (in fact, ANY number of
                                                              * rounds is strictly not enough).
                                                              */

Definition at line 6901 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_CLEAR_ERRHANDLER_RUNNING

#define DUK_HEAP_CLEAR_ERRHANDLER_RUNNING ( heap ) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)

Definition at line 6722 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_CLEAR_FINALIZER_NORESCUE

#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE ( heap ) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)

Definition at line 6724 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_CLEAR_INTERRUPT_RUNNING

#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING ( heap ) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)

Definition at line 6723 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED

#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED ( heap ) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)

Definition at line 6720 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING

#define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING ( heap ) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)

Definition at line 6719 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING

#define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING ( heap ) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)

Definition at line 6721 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_DBG_RATELIMIT_MILLISECS

#define DUK_HEAP_DBG_RATELIMIT_MILLISECS 200

Definition at line 6922 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_DBG_RATELIMIT_OPCODES

#define DUK_HEAP_DBG_RATELIMIT_OPCODES 4000

Definition at line 6919 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_FLAG_ERRHANDLER_RUNNING

#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING (1 << 3) /* an error handler (user callback to augment/replace error) is running */

Definition at line 6693 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_FLAG_FINALIZER_NORESCUE

#define DUK_HEAP_FLAG_FINALIZER_NORESCUE (1 << 5) /* heap destruction ongoing, finalizer rescue no longer possible */

Definition at line 6695 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_FLAG_INTERRUPT_RUNNING

#define DUK_HEAP_FLAG_INTERRUPT_RUNNING (1 << 4) /* executor interrupt running (used to avoid nested interrupts) */

Definition at line 6694 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED

#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED (1 << 1) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */

Definition at line 6691 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING

#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING (1 << 0) /* mark-and-sweep is currently running */

Definition at line 6690 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_FLAG_REFZERO_FREE_RUNNING

#define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING (1 << 2) /* refcount code is processing refzero list */

Definition at line 6692 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_GET_STRING

#define DUK_HEAP_GET_STRING	(		heap,
			idx ) ((heap)->strs[(idx)])

Definition at line 6842 of file duktape-1.8.0/src/duktape.c.

6842#if defined(DUK_USE_ROM_STRINGS)

6843#define DUK_HEAP_GET_STRING(heap,idx) \

◆ DUK_HEAP_H_INCLUDED

#define DUK_HEAP_H_INCLUDED

Definition at line 6682 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_HAS_ERRHANDLER_RUNNING

#define DUK_HEAP_HAS_ERRHANDLER_RUNNING ( heap ) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)

Definition at line 6708 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user().

◆ DUK_HEAP_HAS_FINALIZER_NORESCUE

#define DUK_HEAP_HAS_FINALIZER_NORESCUE ( heap ) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)

Definition at line 6710 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_HAS_INTERRUPT_RUNNING

#define DUK_HEAP_HAS_INTERRUPT_RUNNING ( heap ) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)

Definition at line 6709 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED

#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED ( heap ) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)

Definition at line 6706 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_HAS_MARKANDSWEEP_RUNNING

#define DUK_HEAP_HAS_MARKANDSWEEP_RUNNING ( heap ) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)

Definition at line 6705 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__run_voluntary_gc().

◆ DUK_HEAP_HAS_REFZERO_FREE_RUNNING

#define DUK_HEAP_HAS_REFZERO_FREE_RUNNING ( heap ) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)

Definition at line 6707 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED

#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED	(		heap,
			hdr ) duk_heap_insert_into_heap_allocated((heap),(hdr))

Definition at line 6802 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_object_parts().

◆ DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD

#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD 1024L

Definition at line 6786 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT

#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT 12800L /* 50x heap size */

Definition at line 6785 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP

#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP 256L

Definition at line 6787 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_MAX_BREAKPOINTS

#define DUK_HEAP_MAX_BREAKPOINTS 16

Definition at line 6912 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_NUM_STRINGS

#define DUK_HEAP_NUM_STRINGS 191

Definition at line 1460 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user(), duk__put_prop_shared(), and duk_lexer_parse_js_input_element().

◆ DUK_HEAP_SET_ERRHANDLER_RUNNING

#define DUK_HEAP_SET_ERRHANDLER_RUNNING ( heap ) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)

Definition at line 6715 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__err_augment_user().

◆ DUK_HEAP_SET_FINALIZER_NORESCUE

#define DUK_HEAP_SET_FINALIZER_NORESCUE ( heap ) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)

Definition at line 6717 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_SET_INTERRUPT_RUNNING

#define DUK_HEAP_SET_INTERRUPT_RUNNING ( heap ) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)

Definition at line 6716 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED

#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED ( heap ) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)

Definition at line 6713 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_SET_MARKANDSWEEP_RUNNING

#define DUK_HEAP_SET_MARKANDSWEEP_RUNNING ( heap ) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)

Definition at line 6712 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_SET_REFZERO_FREE_RUNNING

#define DUK_HEAP_SET_REFZERO_FREE_RUNNING ( heap ) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)

Definition at line 6714 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRCACHE_SIZE

#define DUK_HEAP_STRCACHE_SIZE 4

Definition at line 6798 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_heap_strcache_string_remove().

◆ DUK_HEAP_STRING_PROTO

#define DUK_HEAP_STRING___PROTO__ ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)

Definition at line 1115 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ARRAY

#define DUK_HEAP_STRING_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)

Definition at line 902 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ARRAY_BUFFER

#define DUK_HEAP_STRING_ARRAY_BUFFER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER)

Definition at line 932 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_BASE64

#define DUK_HEAP_STRING_BASE64 ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)

Definition at line 1259 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_BRACKETED_ELLIPSIS

#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)

Definition at line 1082 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_BREAK

#define DUK_HEAP_STRING_BREAK ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)

Definition at line 1325 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_BYTE_LENGTH

#define DUK_HEAP_STRING_BYTE_LENGTH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH)

Definition at line 1145 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_BYTE_OFFSET

#define DUK_HEAP_STRING_BYTE_OFFSET ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET)

Definition at line 1148 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_BYTES_PER_ELEMENT

#define DUK_HEAP_STRING_BYTES_PER_ELEMENT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT)

Definition at line 1151 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CALLEE

#define DUK_HEAP_STRING_CALLEE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)

Definition at line 1091 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CALLER

#define DUK_HEAP_STRING_CALLER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)

Definition at line 1094 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CASE

#define DUK_HEAP_STRING_CASE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)

Definition at line 1328 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CATCH

#define DUK_HEAP_STRING_CATCH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)

Definition at line 1331 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CLASS

#define DUK_HEAP_STRING_CLASS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)

Definition at line 1406 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CLOG

#define DUK_HEAP_STRING_CLOG ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)

Definition at line 1301 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_COMMA

#define DUK_HEAP_STRING_COMMA ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)

Definition at line 1073 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_COMPILE

#define DUK_HEAP_STRING_COMPILE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)

Definition at line 1235 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CONFIGURABLE

#define DUK_HEAP_STRING_CONFIGURABLE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)

Definition at line 995 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CONST

#define DUK_HEAP_STRING_CONST ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)

Definition at line 1394 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CONSTRUCTOR

#define DUK_HEAP_STRING_CONSTRUCTOR ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)

Definition at line 1040 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_CONTINUE

#define DUK_HEAP_STRING_CONTINUE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)

Definition at line 1334 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DATA

#define DUK_HEAP_STRING_DATA ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA)

Definition at line 1139 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DATA_VIEW

#define DUK_HEAP_STRING_DATA_VIEW ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW)

Definition at line 935 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DATE

#define DUK_HEAP_STRING_DATE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)

Definition at line 914 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DEBUGGER

#define DUK_HEAP_STRING_DEBUGGER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)

Definition at line 1337 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DEC_ENV

#define DUK_HEAP_STRING_DEC_ENV ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)

Definition at line 971 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DEFAULT

#define DUK_HEAP_STRING_DEFAULT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)

Definition at line 1340 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DEFINE_PROPERTY

#define DUK_HEAP_STRING_DEFINE_PROPERTY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)

Definition at line 986 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DELETE

#define DUK_HEAP_STRING_DELETE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)

Definition at line 1343 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DELETE_PROPERTY

#define DUK_HEAP_STRING_DELETE_PROPERTY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)

Definition at line 1103 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_DO

#define DUK_HEAP_STRING_DO ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)

Definition at line 1346 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ELSE

#define DUK_HEAP_STRING_ELSE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)

Definition at line 1349 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_EMPTY_STRING

#define DUK_HEAP_STRING_EMPTY_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)

Definition at line 929 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ENUM

#define DUK_HEAP_STRING_ENUM ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)

Definition at line 1409 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ENUMERABLE

#define DUK_HEAP_STRING_ENUMERABLE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)

Definition at line 998 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ENUMERATE

#define DUK_HEAP_STRING_ENUMERATE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)

Definition at line 1106 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ENV

#define DUK_HEAP_STRING_ENV ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)

Definition at line 1253 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ERR_CREATE

#define DUK_HEAP_STRING_ERR_CREATE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)

Definition at line 1241 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ERR_THROW

#define DUK_HEAP_STRING_ERR_THROW ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)

Definition at line 1244 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP

#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)

Definition at line 1031 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_EVAL

#define DUK_HEAP_STRING_EVAL ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)

Definition at line 983 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_EXPORT

#define DUK_HEAP_STRING_EXPORT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)

Definition at line 1412 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_EXPORTS

#define DUK_HEAP_STRING_EXPORTS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS)

Definition at line 1124 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_EXTENDS

#define DUK_HEAP_STRING_EXTENDS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)

Definition at line 1415 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FALSE

#define DUK_HEAP_STRING_FALSE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)

Definition at line 1430 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FILE_NAME

#define DUK_HEAP_STRING_FILE_NAME ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)

Definition at line 1172 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FILENAME

#define DUK_HEAP_STRING_FILENAME ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILENAME)

Definition at line 1127 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FINALLY

#define DUK_HEAP_STRING_FINALLY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)

Definition at line 1352 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FLOAT32_ARRAY

#define DUK_HEAP_STRING_FLOAT32_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY)

Definition at line 959 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FLOAT64_ARRAY

#define DUK_HEAP_STRING_FLOAT64_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY)

Definition at line 962 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FMT

#define DUK_HEAP_STRING_FMT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)

Definition at line 1271 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_FOR

#define DUK_HEAP_STRING_FOR ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)

Definition at line 1355 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_GET

#define DUK_HEAP_STRING_GET ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)

Definition at line 1100 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_GLOBAL

#define DUK_HEAP_STRING_GLOBAL ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)

Definition at line 965 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_HAS

#define DUK_HEAP_STRING_HAS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)

Definition at line 1097 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_HEX

#define DUK_HEAP_STRING_HEX ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)

Definition at line 1256 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_ID

#define DUK_HEAP_STRING_ID ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)

Definition at line 1121 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_IF

#define DUK_HEAP_STRING_IF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)

Definition at line 1361 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_IGNORE_CASE

#define DUK_HEAP_STRING_IGNORE_CASE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)

Definition at line 1022 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_IMPLEMENTS

#define DUK_HEAP_STRING_IMPLEMENTS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)

Definition at line 1433 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_IMPORT

#define DUK_HEAP_STRING_IMPORT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)

Definition at line 1418 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_IN

#define DUK_HEAP_STRING_IN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)

Definition at line 1364 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INDEX

#define DUK_HEAP_STRING_INDEX ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)

Definition at line 1034 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INFINITY

#define DUK_HEAP_STRING_INFINITY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)

Definition at line 1064 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INPUT

#define DUK_HEAP_STRING_INPUT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)

Definition at line 1238 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INSTANCEOF

#define DUK_HEAP_STRING_INSTANCEOF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)

Definition at line 1367 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT16_ARRAY

#define DUK_HEAP_STRING_INT16_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY)

Definition at line 947 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT32_ARRAY

#define DUK_HEAP_STRING_INT32_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY)

Definition at line 953 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT8_ARRAY

#define DUK_HEAP_STRING_INT8_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY)

Definition at line 938 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_ARGS

#define DUK_HEAP_STRING_INT_ARGS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)

Definition at line 1208 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_BYTECODE

#define DUK_HEAP_STRING_INT_BYTECODE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)

Definition at line 1187 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_CALLEE

#define DUK_HEAP_STRING_INT_CALLEE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)

Definition at line 1220 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_FINALIZER

#define DUK_HEAP_STRING_INT_FINALIZER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)

Definition at line 1214 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_FORMALS

#define DUK_HEAP_STRING_INT_FORMALS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)

Definition at line 1190 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_HANDLER

#define DUK_HEAP_STRING_INT_HANDLER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)

Definition at line 1217 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_LEXENV

#define DUK_HEAP_STRING_INT_LEXENV ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)

Definition at line 1196 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_MAP

#define DUK_HEAP_STRING_INT_MAP ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)

Definition at line 1211 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_NEXT

#define DUK_HEAP_STRING_INT_NEXT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)

Definition at line 1184 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_PC2LINE

#define DUK_HEAP_STRING_INT_PC2LINE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)

Definition at line 1205 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_REGBASE

#define DUK_HEAP_STRING_INT_REGBASE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)

Definition at line 1226 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_SOURCE

#define DUK_HEAP_STRING_INT_SOURCE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)

Definition at line 1202 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_TARGET

#define DUK_HEAP_STRING_INT_TARGET ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)

Definition at line 1229 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_THIS

#define DUK_HEAP_STRING_INT_THIS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)

Definition at line 1232 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_THREAD

#define DUK_HEAP_STRING_INT_THREAD ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)

Definition at line 1223 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_TRACEDATA

#define DUK_HEAP_STRING_INT_TRACEDATA ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)

Definition at line 1166 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_VALUE

#define DUK_HEAP_STRING_INT_VALUE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)

Definition at line 1181 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_VARENV

#define DUK_HEAP_STRING_INT_VARENV ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)

Definition at line 1199 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INT_VARMAP

#define DUK_HEAP_STRING_INT_VARMAP ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)

Definition at line 1193 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INTERFACE

#define DUK_HEAP_STRING_INTERFACE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)

Definition at line 1436 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_INVALID_DATE

#define DUK_HEAP_STRING_INVALID_DATE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)

Definition at line 1085 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JC

#define DUK_HEAP_STRING_JC ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)

Definition at line 1265 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JOIN

#define DUK_HEAP_STRING_JOIN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)

Definition at line 1001 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON

#define DUK_HEAP_STRING_JSON ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)

Definition at line 926 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON_EXT_FUNCTION1

#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1 ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)

Definition at line 1319 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON_EXT_FUNCTION2

#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2 ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)

Definition at line 1322 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON_EXT_NAN

#define DUK_HEAP_STRING_JSON_EXT_NAN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)

Definition at line 1310 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON_EXT_NEGINF

#define DUK_HEAP_STRING_JSON_EXT_NEGINF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)

Definition at line 1316 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON_EXT_POSINF

#define DUK_HEAP_STRING_JSON_EXT_POSINF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)

Definition at line 1313 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JSON_EXT_UNDEFINED

#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)

Definition at line 1307 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_JX

#define DUK_HEAP_STRING_JX ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)

Definition at line 1262 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LAST_INDEX

#define DUK_HEAP_STRING_LAST_INDEX ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)

Definition at line 1028 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_ARGUMENTS

#define DUK_HEAP_STRING_LC_ARGUMENTS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)

Definition at line 1088 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_BOOLEAN

#define DUK_HEAP_STRING_LC_BOOLEAN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)

Definition at line 1046 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_BUFFER

#define DUK_HEAP_STRING_LC_BUFFER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)

Definition at line 1175 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_DEBUG

#define DUK_HEAP_STRING_LC_DEBUG ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)

Definition at line 1280 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_ERROR

#define DUK_HEAP_STRING_LC_ERROR ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)

Definition at line 1289 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_FATAL

#define DUK_HEAP_STRING_LC_FATAL ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)

Definition at line 1292 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_FUNCTION

#define DUK_HEAP_STRING_LC_FUNCTION ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)

Definition at line 1358 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_INFO

#define DUK_HEAP_STRING_LC_INFO ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)

Definition at line 1283 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_L

#define DUK_HEAP_STRING_LC_L ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)

Definition at line 1298 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_N

#define DUK_HEAP_STRING_LC_N ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)

Definition at line 1295 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_NULL

#define DUK_HEAP_STRING_LC_NULL ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)

Definition at line 1424 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_NUMBER

#define DUK_HEAP_STRING_LC_NUMBER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)

Definition at line 1049 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_OBJECT

#define DUK_HEAP_STRING_LC_OBJECT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)

Definition at line 1055 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_POINTER

#define DUK_HEAP_STRING_LC_POINTER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)

Definition at line 1178 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_STRING

#define DUK_HEAP_STRING_LC_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)

Definition at line 1052 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_TRACE

#define DUK_HEAP_STRING_LC_TRACE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)

Definition at line 1277 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_UNDEFINED

#define DUK_HEAP_STRING_LC_UNDEFINED ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)

Definition at line 1058 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LC_WARN

#define DUK_HEAP_STRING_LC_WARN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)

Definition at line 1286 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LENGTH

#define DUK_HEAP_STRING_LENGTH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)

Definition at line 1142 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LET

#define DUK_HEAP_STRING_LET ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)

Definition at line 1439 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_LINE_NUMBER

#define DUK_HEAP_STRING_LINE_NUMBER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)

Definition at line 1163 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MATH

#define DUK_HEAP_STRING_MATH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)

Definition at line 923 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MESSAGE

#define DUK_HEAP_STRING_MESSAGE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)

Definition at line 1043 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MINUS_INFINITY

#define DUK_HEAP_STRING_MINUS_INFINITY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)

Definition at line 1067 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MINUS_ZERO

#define DUK_HEAP_STRING_MINUS_ZERO ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)

Definition at line 1070 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MOD_LOADED

#define DUK_HEAP_STRING_MOD_LOADED ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)

Definition at line 1250 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MOD_SEARCH

#define DUK_HEAP_STRING_MOD_SEARCH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)

Definition at line 1247 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_MULTILINE

#define DUK_HEAP_STRING_MULTILINE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)

Definition at line 1025 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_NAME

#define DUK_HEAP_STRING_NAME ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)

Definition at line 1169 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_NAN

#define DUK_HEAP_STRING_NAN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)

Definition at line 1061 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_NEW

#define DUK_HEAP_STRING_NEW ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)

Definition at line 1370 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_NEWLINE_4SPACE

#define DUK_HEAP_STRING_NEWLINE_4SPACE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_4SPACE)

Definition at line 1079 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_OBJ_ENV

#define DUK_HEAP_STRING_OBJ_ENV ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)

Definition at line 968 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_OWN_KEYS

#define DUK_HEAP_STRING_OWN_KEYS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)

Definition at line 1109 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_PACKAGE

#define DUK_HEAP_STRING_PACKAGE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)

Definition at line 1442 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_PC

#define DUK_HEAP_STRING_PC ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)

Definition at line 1160 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_PRIVATE

#define DUK_HEAP_STRING_PRIVATE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)

Definition at line 1445 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_PROTECTED

#define DUK_HEAP_STRING_PROTECTED ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)

Definition at line 1448 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_PROTOTYPE

#define DUK_HEAP_STRING_PROTOTYPE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)

Definition at line 1037 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_PUBLIC

#define DUK_HEAP_STRING_PUBLIC ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)

Definition at line 1451 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_RAW

#define DUK_HEAP_STRING_RAW ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)

Definition at line 1274 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_REG_EXP

#define DUK_HEAP_STRING_REG_EXP ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)

Definition at line 917 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_REQUIRE

#define DUK_HEAP_STRING_REQUIRE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)

Definition at line 1118 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_RESUME

#define DUK_HEAP_STRING_RESUME ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)

Definition at line 1268 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_RETURN

#define DUK_HEAP_STRING_RETURN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)

Definition at line 1373 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_SET

#define DUK_HEAP_STRING_SET ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)

Definition at line 1154 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_SET_PROTOTYPE_OF

#define DUK_HEAP_STRING_SET_PROTOTYPE_OF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)

Definition at line 1112 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_SOURCE

#define DUK_HEAP_STRING_SOURCE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)

Definition at line 1019 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_SPACE

#define DUK_HEAP_STRING_SPACE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)

Definition at line 1076 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_STACK

#define DUK_HEAP_STRING_STACK ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)

Definition at line 1157 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_STATIC

#define DUK_HEAP_STRING_STATIC ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)

Definition at line 1454 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_SUPER

#define DUK_HEAP_STRING_SUPER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)

Definition at line 1421 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_SWITCH

#define DUK_HEAP_STRING_SWITCH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)

Definition at line 1376 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_THIS

#define DUK_HEAP_STRING_THIS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)

Definition at line 1379 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_THROW

#define DUK_HEAP_STRING_THROW ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)

Definition at line 1382 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_GMT_STRING

#define DUK_HEAP_STRING_TO_GMT_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)

Definition at line 1016 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_ISO_STRING

#define DUK_HEAP_STRING_TO_ISO_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)

Definition at line 1013 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_JSON

#define DUK_HEAP_STRING_TO_JSON ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)

Definition at line 1133 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_LOCALE_STRING

#define DUK_HEAP_STRING_TO_LOCALE_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)

Definition at line 1004 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_LOG_STRING

#define DUK_HEAP_STRING_TO_LOG_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)

Definition at line 1304 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_STRING

#define DUK_HEAP_STRING_TO_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)

Definition at line 1130 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TO_UTC_STRING

#define DUK_HEAP_STRING_TO_UTC_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)

Definition at line 1010 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TRUE

#define DUK_HEAP_STRING_TRUE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)

Definition at line 1427 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TRY

#define DUK_HEAP_STRING_TRY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)

Definition at line 1385 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TYPE

#define DUK_HEAP_STRING_TYPE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE)

Definition at line 1136 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_TYPEOF

#define DUK_HEAP_STRING_TYPEOF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)

Definition at line 1388 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_ARGUMENTS

#define DUK_HEAP_STRING_UC_ARGUMENTS ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)

Definition at line 893 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_BOOLEAN

#define DUK_HEAP_STRING_UC_BOOLEAN ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)

Definition at line 908 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_BUFFER

#define DUK_HEAP_STRING_UC_BUFFER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)

Definition at line 974 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_ERROR

#define DUK_HEAP_STRING_UC_ERROR ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)

Definition at line 920 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_FUNCTION

#define DUK_HEAP_STRING_UC_FUNCTION ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)

Definition at line 899 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_NULL

#define DUK_HEAP_STRING_UC_NULL ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)

Definition at line 890 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_NUMBER

#define DUK_HEAP_STRING_UC_NUMBER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)

Definition at line 911 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_OBJECT

#define DUK_HEAP_STRING_UC_OBJECT ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)

Definition at line 896 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_POINTER

#define DUK_HEAP_STRING_UC_POINTER ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)

Definition at line 977 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_STRING

#define DUK_HEAP_STRING_UC_STRING ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)

Definition at line 905 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_THREAD

#define DUK_HEAP_STRING_UC_THREAD ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)

Definition at line 980 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UC_UNDEFINED

#define DUK_HEAP_STRING_UC_UNDEFINED ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)

Definition at line 887 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UINT16_ARRAY

#define DUK_HEAP_STRING_UINT16_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY)

Definition at line 950 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UINT32_ARRAY

#define DUK_HEAP_STRING_UINT32_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY)

Definition at line 956 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UINT8_ARRAY

#define DUK_HEAP_STRING_UINT8_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY)

Definition at line 941 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY

#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY)

Definition at line 944 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_VALUE

#define DUK_HEAP_STRING_VALUE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)

Definition at line 989 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_VALUE_OF

#define DUK_HEAP_STRING_VALUE_OF ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)

Definition at line 1007 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_VAR

#define DUK_HEAP_STRING_VAR ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)

Definition at line 1391 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_VOID

#define DUK_HEAP_STRING_VOID ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)

Definition at line 1397 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_WHILE

#define DUK_HEAP_STRING_WHILE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)

Definition at line 1400 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_WITH

#define DUK_HEAP_STRING_WITH ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)

Definition at line 1403 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_WRITABLE

#define DUK_HEAP_STRING_WRITABLE ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)

Definition at line 992 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRING_YIELD

#define DUK_HEAP_STRING_YIELD ( heap ) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)

Definition at line 1457 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT

#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT 16 /* strings up to the this length are not cached */

Definition at line 6799 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAP_SWITCH_THREAD

#define DUK_HEAP_SWITCH_THREAD	(		heap,
			newthr )

Value:

        do { \
        (heap)->curr_thread = (newthr); \
    } while (0)

Definition at line 6764 of file duktape-1.8.0/src/duktape.c.

 *  To switch heap->curr_thread, use the macro below so that interrupt counters
 *  get updated correctly.  The macro allows a NULL target thread because that
 *  happens e.g. in call handling.

◆ DUK_HEAPHDR_CHECK_FLAG_BITS

#define DUK_HEAPHDR_CHECK_FLAG_BITS	(		h,
			bits ) (((h)->h_flags & (bits)) != 0)

Definition at line 3663 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_CLEAR_FINALIZABLE

#define DUK_HEAPHDR_CLEAR_FINALIZABLE ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)

Definition at line 3674 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_CLEAR_FINALIZED

#define DUK_HEAPHDR_CLEAR_FINALIZED ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)

Definition at line 3678 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_CLEAR_FLAG_BITS

#define DUK_HEAPHDR_CLEAR_FLAG_BITS	(		h,
			bits )

Value:

        do { \
        DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
        (h)->h_flags &= ~((bits)); \
    } while (0)

Definition at line 3658 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits)  do { \
        DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
        (h)->h_flags &= ~((bits)); \
    } while (0)

◆ DUK_HEAPHDR_CLEAR_REACHABLE

#define DUK_HEAPHDR_CLEAR_REACHABLE ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)

Definition at line 3666 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__mark_temproots_by_heap_scan().

◆ DUK_HEAPHDR_CLEAR_READONLY

#define DUK_HEAPHDR_CLEAR_READONLY ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)

Definition at line 3682 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_CLEAR_TEMPROOT

#define DUK_HEAPHDR_CLEAR_TEMPROOT ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)

Definition at line 3670 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__mark_temproots_by_heap_scan().

◆ DUK_HEAPHDR_DECREF

#define DUK_HEAPHDR_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF_FAST((thr),(h))

Definition at line 3828 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_DECREF_FAST

#define DUK_HEAPHDR_DECREF_FAST	(		thr,
			h )

Value:

        do { \
        duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
        DUK_ASSERT(duk__h != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
        DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
        if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
            if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
                duk_heaphdr_refzero((thr), duk__h); \
            } \
        } \
    } while (0)

Definition at line 3792 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \
        duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
        DUK_ASSERT(duk__h != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
        DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
        if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
            if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
                duk_heaphdr_refzero((thr), duk__h); \
            } \
        } \
    } while (0)

◆ DUK_HEAPHDR_DECREF_SLOW

#define DUK_HEAPHDR_DECREF_SLOW	(		thr,
			h )

Value:

        do { \
        duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
    } while (0)

Definition at line 3816 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \
        duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
    } while (0)

◆ DUK_HEAPHDR_FLAG_FINALIZABLE

#define DUK_HEAPHDR_FLAG_FINALIZABLE DUK_HEAPHDR_HEAP_FLAG(2) /* mark-and-sweep: finalizable (on current pass) */

Definition at line 3568 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAG_FINALIZED

#define DUK_HEAPHDR_FLAG_FINALIZED DUK_HEAPHDR_HEAP_FLAG(3) /* mark-and-sweep: finalized (on previous pass) */

Definition at line 3569 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAG_REACHABLE

#define DUK_HEAPHDR_FLAG_REACHABLE DUK_HEAPHDR_HEAP_FLAG(0) /* mark-and-sweep: reachable */

Definition at line 3566 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAG_READONLY

#define DUK_HEAPHDR_FLAG_READONLY DUK_HEAPHDR_HEAP_FLAG(4) /* read-only object, in code section */

Definition at line 3570 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAG_TEMPROOT

#define DUK_HEAPHDR_FLAG_TEMPROOT DUK_HEAPHDR_HEAP_FLAG(1) /* mark-and-sweep: children not processed */

Definition at line 3567 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAGS_FLAG_MASK

#define DUK_HEAPHDR_FLAGS_FLAG_MASK (~DUK_HEAPHDR_FLAGS_TYPE_MASK)

Definition at line 3555 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAGS_HEAP_START

#define DUK_HEAPHDR_FLAGS_HEAP_START 2 /* 5 heap flags */

Definition at line 3558 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAGS_TYPE_MASK

#define DUK_HEAPHDR_FLAGS_TYPE_MASK 0x00000003UL

Definition at line 3554 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_FLAGS_USER_START

#define DUK_HEAPHDR_FLAGS_USER_START 7 /* 25 user flags */

Definition at line 3559 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_GET_FLAG_RANGE

#define DUK_HEAPHDR_GET_FLAG_RANGE	(	h,
		m,
		n ) (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL))

Definition at line 3686 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_GET_FLAGS

#define DUK_HEAPHDR_GET_FLAGS ( h ) ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)

Definition at line 3633 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_GET_FLAGS_RAW

#define DUK_HEAPHDR_GET_FLAGS_RAW ( h ) ((h)->h_flags)

Definition at line 3631 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_GET_NEXT

#define DUK_HEAPHDR_GET_NEXT	(		heap,
			h ) ((h)->h_next)

Definition at line 3585 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__free_markandsweep_finalize_list(), duk__free_refzero_list(), duk__free_run_finalizers(), duk__mark_finalize_list(), and duk__queue_refzero().

◆ DUK_HEAPHDR_GET_PREV

#define DUK_HEAPHDR_GET_PREV	(		heap,
			h ) ((h)->h_prev)

Definition at line 3599 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_GET_REFCOUNT

#define DUK_HEAPHDR_GET_REFCOUNT ( h ) ((h)->h_refcount)

Definition at line 3615 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info().

◆ DUK_HEAPHDR_GET_TYPE

#define DUK_HEAPHDR_GET_TYPE ( h ) ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK)

Definition at line 3638 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info().

◆ DUK_HEAPHDR_H_INCLUDED

#define DUK_HEAPHDR_H_INCLUDED

Definition at line 3473 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_HAS_FINALIZABLE

#define DUK_HEAPHDR_HAS_FINALIZABLE ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)

Definition at line 3675 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__mark_finalize_list().

◆ DUK_HEAPHDR_HAS_FINALIZED

#define DUK_HEAPHDR_HAS_FINALIZED ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)

Definition at line 3679 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_HAS_REACHABLE

#define DUK_HEAPHDR_HAS_REACHABLE ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)

Definition at line 3667 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_HAS_READONLY

#define DUK_HEAPHDR_HAS_READONLY ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)

Definition at line 3683 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_HEAPHDR_HAS_TEMPROOT

#define DUK_HEAPHDR_HAS_TEMPROOT ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)

Definition at line 3671 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__mark_temproots_by_heap_scan().

◆ DUK_HEAPHDR_HEAP_FLAG

#define DUK_HEAPHDR_HEAP_FLAG ( n ) (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n)))

Definition at line 3563 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_HEAP_FLAG_NUMBER

#define DUK_HEAPHDR_HEAP_FLAG_NUMBER ( n ) (DUK_HEAPHDR_FLAGS_HEAP_START + (n))

Definition at line 3561 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_HTYPE_VALID

#define DUK_HEAPHDR_HTYPE_VALID ( h )

Value:

    ( \
    DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \
    DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
    )

Definition at line 3643 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_HTYPE_VALID(h)    ( \
    DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \
    DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
    )

Referenced by duk_tval_decref().

◆ DUK_HEAPHDR_INCREF

#define DUK_HEAPHDR_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF_FAST((thr),(h))

Definition at line 3827 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_INCREF_FAST

#define DUK_HEAPHDR_INCREF_FAST	(		thr,
			h )

Value:

        do { \
        duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
        DUK_ASSERT(duk__h != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
        if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
            DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
        } \
    } while (0)

Definition at line 3784 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
        duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
        DUK_ASSERT(duk__h != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
        if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
            DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
        } \
    } while (0)

◆ DUK_HEAPHDR_INCREF_SLOW

#define DUK_HEAPHDR_INCREF_SLOW	(		thr,
			h )

Value:

        do { \
        duk_heaphdr_incref((duk_heaphdr *) (h)); \
    } while (0)

Definition at line 3813 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \
        duk_heaphdr_incref((duk_heaphdr *) (h)); \
    } while (0)

◆ DUK_HEAPHDR_INIT_NULLS

#define DUK_HEAPHDR_INIT_NULLS ( h )

Value:

        do { \
        DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
        DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
    } while (0)

Definition at line 3696 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
        DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
        DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
    } while (0)

◆ DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE

#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE ( h ) 1

Definition at line 3753 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_PREDEC_REFCOUNT

#define DUK_HEAPHDR_PREDEC_REFCOUNT ( h ) (--(h)->h_refcount) /* result: updated refcount */

Definition at line 3620 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_PREINC_REFCOUNT

#define DUK_HEAPHDR_PREINC_REFCOUNT ( h ) (++(h)->h_refcount) /* result: updated refcount */

Definition at line 3619 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_tval_decref().

◆ DUK_HEAPHDR_SET_FINALIZABLE

#define DUK_HEAPHDR_SET_FINALIZABLE ( h ) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)

Definition at line 3673 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_SET_FINALIZED

#define DUK_HEAPHDR_SET_FINALIZED ( h ) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)

Definition at line 3677 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_SET_FLAG_BITS

#define DUK_HEAPHDR_SET_FLAG_BITS	(		h,
			bits )

Value:

        do { \
        DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
        (h)->h_flags |= (bits); \
    } while (0)

Definition at line 3653 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits)  do { \
        DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
        (h)->h_flags |= (bits); \
    } while (0)

◆ DUK_HEAPHDR_SET_FLAG_RANGE

#define DUK_HEAPHDR_SET_FLAG_RANGE	(	h,
		m,
		n,
		v )

Value:

        do { \
        (h)->h_flags = \
            ((h)->h_flags & (~(((1UL << (n)) - 1UL) << (m)))) \
            | ((v) << (m)); \
    } while (0)

Definition at line 3688 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v)  do { \
        (h)->h_flags = \
            ((h)->h_flags & (~(((1UL << (n)) - 1UL) << (m)))) \
            | ((v) << (m)); \
    } while (0)

◆ DUK_HEAPHDR_SET_FLAGS

#define DUK_HEAPHDR_SET_FLAGS	(		h,
			val )

Value:

        do { \
        (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
    } while (0)

Definition at line 3634 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_FLAGS(h,val)  do { \
        (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
    } while (0)

◆ DUK_HEAPHDR_SET_NEXT

#define DUK_HEAPHDR_SET_NEXT	(	heap,
		h,
		val )

Value:

        do { \
        (h)->h_next = (val); \
    } while (0)

Definition at line 3586 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
        (h)->h_next = (val); \
    } while (0)

Referenced by duk__init_object_parts(), and duk__queue_refzero().

◆ DUK_HEAPHDR_SET_PREV

#define DUK_HEAPHDR_SET_PREV	(	heap,
		h,
		val )

Value:

        do { \
        (h)->h_prev = (val); \
    } while (0)

Definition at line 3600 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
        (h)->h_prev = (val); \
    } while (0)

Referenced by duk__init_object_parts(), and duk__queue_refzero().

◆ DUK_HEAPHDR_SET_REACHABLE

#define DUK_HEAPHDR_SET_REACHABLE ( h ) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)

Definition at line 3665 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_SET_READONLY

#define DUK_HEAPHDR_SET_READONLY ( h ) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)

Definition at line 3681 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_SET_REFCOUNT

#define DUK_HEAPHDR_SET_REFCOUNT	(		h,
			val )

Value:

        do { \
        (h)->h_refcount = (val); \
    } while (0)

Definition at line 3616 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
        (h)->h_refcount = (val); \
    } while (0)

◆ DUK_HEAPHDR_SET_TEMPROOT

#define DUK_HEAPHDR_SET_TEMPROOT ( h ) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)

Definition at line 3669 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_SET_TYPE

#define DUK_HEAPHDR_SET_TYPE	(		h,
			val )

Value:

        do { \
        (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
    } while (0)

Definition at line 3639 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_TYPE(h,val)   do { \
        (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
    } while (0)

Referenced by duk__init_object_parts().

◆ DUK_HEAPHDR_SET_TYPE_AND_FLAGS

#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS	(	h,
		tval,
		fval )

Value:

        do { \
        (h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
                       ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
    } while (0)

Definition at line 3648 of file duktape-1.8.0/src/duktape.c.

#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval)  do { \
        (h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
                       ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
    } while (0)

Referenced by duk__alloc_init_hstring().

◆ DUK_HEAPHDR_STRING_INIT_NULLS

#define DUK_HEAPHDR_STRING_INIT_NULLS ( h ) /* currently nop */

Definition at line 3706 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HEAPHDR_USER_FLAG

#define DUK_HEAPHDR_USER_FLAG ( n ) (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n)))

Definition at line 3564 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HEAPHDR_USER_FLAG_NUMBER

#define DUK_HEAPHDR_USER_FLAG_NUMBER ( n ) (DUK_HEAPHDR_FLAGS_USER_START + (n))

Definition at line 3562 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HNATIVEFUNCTION_DECREF

#define DUK_HNATIVEFUNCTION_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3846 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HNATIVEFUNCTION_H_INCLUDED

#define DUK_HNATIVEFUNCTION_H_INCLUDED

Definition at line 5808 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HNATIVEFUNCTION_INCREF

#define DUK_HNATIVEFUNCTION_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3845 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HNATIVEFUNCTION_NARGS_MAX

#define DUK_HNATIVEFUNCTION_NARGS_MAX ((duk_int16_t) 0x7fff)

Definition at line 5811 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HNATIVEFUNCTION_NARGS_VARARGS

#define DUK_HNATIVEFUNCTION_NARGS_VARARGS ((duk_int16_t) -1)

Definition at line 5810 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw().

◆ DUK_HOBJECT_A_ABANDON_LIMIT

#define DUK_HOBJECT_A_ABANDON_LIMIT 2 /* 25%, i.e. less than 25% used -> abandon */

Definition at line 5287 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_A_FAST_RESIZE_LIMIT

#define DUK_HOBJECT_A_FAST_RESIZE_LIMIT 9 /* 112.5%, i.e. new size less than 12.5% higher -> fast resize */

Definition at line 5283 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_A_GET_BASE

#define DUK_HOBJECT_A_GET_BASE	(		heap,
			h )

Value:

    ((duk_tval *) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + \
            DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
            DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) \
    ))

Definition at line 5024 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
    ))
#define DUK_HOBJECT_A_GET_BASE(heap,h) \
    ((duk_tval *) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + \
            DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_A_GET_VALUE

#define DUK_HOBJECT_A_GET_VALUE	(	heap,
		h,
		i ) (DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])

Definition at line 5115 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_A_GET_VALUE_PTR

#define DUK_HOBJECT_A_GET_VALUE_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])

Definition at line 5116 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__realloc_props(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_HOBJECT_A_MIN_GROW_ADD

#define DUK_HOBJECT_A_MIN_GROW_ADD 16

Definition at line 5305 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_A_MIN_GROW_DIVISOR

#define DUK_HOBJECT_A_MIN_GROW_DIVISOR 8 /* 2^3 -> 1/8 = 12.5% min growth */

Definition at line 5306 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_A_SET_VALUE

#define DUK_HOBJECT_A_SET_VALUE	(	heap,
		h,
		i,
		v )

Value:

        do { \
        DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \
    } while (0)

Definition at line 5138 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (duk_uint8_t) (f); \
    } while (0)
#define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v)  do { \

◆ DUK_HOBJECT_A_SET_VALUE_TVAL

#define DUK_HOBJECT_A_SET_VALUE_TVAL	(	heap,
		h,
		i,
		v ) DUK_HOBJECT_A_SET_VALUE((heap), (h), (i), (v)) /* alias for above */

Definition at line 5141 of file duktape-1.8.0/src/duktape.c.

5141 DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \

5142 } while (0)

DUK_HOBJECT_A_GET_VALUE

#define DUK_HOBJECT_A_GET_VALUE(heap, h, i)

Definition duktape-1.8.0/src/duktape.c:5115

◆ DUK_HOBJECT_ALIGN_TARGET

#define DUK_HOBJECT_ALIGN_TARGET 8

Definition at line 5293 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_BOUND_CHAIN_SANITY

#define DUK_HOBJECT_BOUND_CHAIN_SANITY 10000L

Definition at line 5224 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_instanceof().

◆ DUK_HOBJECT_CLASS_ARGUMENTS

#define DUK_HOBJECT_CLASS_ARGUMENTS 1

Definition at line 4715 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_ARRAY

#define DUK_HOBJECT_CLASS_ARRAY 2

Definition at line 4716 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_array_prototype_to_string().

◆ DUK_HOBJECT_CLASS_ARRAYBUFFER

#define DUK_HOBJECT_CLASS_ARRAYBUFFER 19 /* implies DUK_HOBJECT_IS_BUFFEROBJECT */

Definition at line 4733 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_AS_FLAGS

#define DUK_HOBJECT_CLASS_AS_FLAGS ( v ) (((duk_uint_t) (v)) << DUK_HOBJECT_FLAG_CLASS_BASE)

Definition at line 4711 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared(), duk_bi_string_constructor_from_char_code(), duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_CLASS_BOOLEAN

#define DUK_HOBJECT_CLASS_BOOLEAN 3

Definition at line 4717 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_BUFFER

#define DUK_HOBJECT_CLASS_BUFFER 16 /* custom; implies DUK_HOBJECT_IS_BUFFEROBJECT */

Definition at line 4730 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_DATAVIEW

#define DUK_HOBJECT_CLASS_DATAVIEW 20

Definition at line 4734 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_DATE

#define DUK_HOBJECT_CLASS_DATE 4

Definition at line 4718 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_DECENV

#define DUK_HOBJECT_CLASS_DECENV 15 /* custom */

Definition at line 4729 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_ERROR

#define DUK_HOBJECT_CLASS_ERROR 5

Definition at line 4719 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_FLOAT32ARRAY

#define DUK_HOBJECT_CLASS_FLOAT32ARRAY 28

Definition at line 4742 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_FLOAT64ARRAY

#define DUK_HOBJECT_CLASS_FLOAT64ARRAY 29

Definition at line 4743 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_FUNCTION

#define DUK_HOBJECT_CLASS_FUNCTION 6

Definition at line 4720 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_CLASS_GLOBAL

#define DUK_HOBJECT_CLASS_GLOBAL 13

Definition at line 4727 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper().

◆ DUK_HOBJECT_CLASS_INT16ARRAY

#define DUK_HOBJECT_CLASS_INT16ARRAY 24

Definition at line 4738 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_INT32ARRAY

#define DUK_HOBJECT_CLASS_INT32ARRAY 26

Definition at line 4740 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_INT8ARRAY

#define DUK_HOBJECT_CLASS_INT8ARRAY 21

Definition at line 4735 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_JSON

#define DUK_HOBJECT_CLASS_JSON 7

Definition at line 4721 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_MATH

#define DUK_HOBJECT_CLASS_MATH 8

Definition at line 4722 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_MAX

#define DUK_HOBJECT_CLASS_MAX 29

Definition at line 4744 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_NUMBER

#define DUK_HOBJECT_CLASS_NUMBER 9

Definition at line 4723 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX

#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX ( n ) duk_class_number_to_stridx[(n)]

Definition at line 5231 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_OBJECT

#define DUK_HOBJECT_CLASS_OBJECT 10

Definition at line 4724 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_OBJENV

#define DUK_HOBJECT_CLASS_OBJENV 14 /* custom */

Definition at line 4728 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_POINTER

#define DUK_HOBJECT_CLASS_POINTER 17 /* custom */

Definition at line 4731 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_REGEXP

#define DUK_HOBJECT_CLASS_REGEXP 11

Definition at line 4725 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_regexp_constructor().

◆ DUK_HOBJECT_CLASS_STRING

#define DUK_HOBJECT_CLASS_STRING 12

Definition at line 4726 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_string_constructor_from_char_code().

◆ DUK_HOBJECT_CLASS_THREAD

#define DUK_HOBJECT_CLASS_THREAD 18 /* custom; implies DUK_HOBJECT_IS_THREAD */

Definition at line 4732 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_UINT16ARRAY

#define DUK_HOBJECT_CLASS_UINT16ARRAY 25

Definition at line 4739 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_UINT32ARRAY

#define DUK_HOBJECT_CLASS_UINT32ARRAY 27

Definition at line 4741 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_UINT8ARRAY

#define DUK_HOBJECT_CLASS_UINT8ARRAY 22

Definition at line 4736 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY

#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY 23

Definition at line 4737 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLASS_UNUSED

#define DUK_HOBJECT_CLASS_UNUSED 0

Definition at line 4714 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_ARRAY_PART

#define DUK_HOBJECT_CLEAR_ARRAY_PART ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)

Definition at line 4873 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_CLEAR_BOUND

#define DUK_HOBJECT_CLEAR_BOUND ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

Definition at line 4868 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_BUFFEROBJECT

#define DUK_HOBJECT_CLEAR_BUFFEROBJECT ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

Definition at line 4871 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_COMPILEDFUNCTION

#define DUK_HOBJECT_CLEAR_COMPILEDFUNCTION ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

Definition at line 4869 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_CONSTRUCTABLE

#define DUK_HOBJECT_CLEAR_CONSTRUCTABLE ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)

Definition at line 4867 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_CREATEARGS

#define DUK_HOBJECT_CLEAR_CREATEARGS ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)

Definition at line 4878 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_ENVRECCLOSED

#define DUK_HOBJECT_CLEAR_ENVRECCLOSED ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)

Definition at line 4879 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS

#define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)

Definition at line 4882 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_EXOTIC_ARRAY

#define DUK_HOBJECT_CLEAR_EXOTIC_ARRAY ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)

Definition at line 4880 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_EXOTIC_DUKFUNC

#define DUK_HOBJECT_CLEAR_EXOTIC_DUKFUNC ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)

Definition at line 4883 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ

#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

Definition at line 4884 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ

#define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)

Definition at line 4881 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_EXTENSIBLE

#define DUK_HOBJECT_CLEAR_EXTENSIBLE ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)

Definition at line 4866 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_NAMEBINDING

#define DUK_HOBJECT_CLEAR_NAMEBINDING ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)

Definition at line 4877 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_NATIVEFUNCTION

#define DUK_HOBJECT_CLEAR_NATIVEFUNCTION ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4870 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_NEWENV

#define DUK_HOBJECT_CLEAR_NEWENV ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)

Definition at line 4876 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_NOTAIL

#define DUK_HOBJECT_CLEAR_NOTAIL ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)

Definition at line 4875 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_STRICT

#define DUK_HOBJECT_CLEAR_STRICT ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)

Definition at line 4874 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CLEAR_THREAD

#define DUK_HOBJECT_CLEAR_THREAD ( h ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

Definition at line 4872 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_ALL

#define DUK_HOBJECT_CMASK_ALL ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL)

Definition at line 4747 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS

#define DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS

Value:

    (DUK_HOBJECT_CMASK_BUFFER | \
     DUK_HOBJECT_CMASK_ARRAYBUFFER | \
     DUK_HOBJECT_CMASK_DATAVIEW | \
     DUK_HOBJECT_CMASK_INT8ARRAY | \
     DUK_HOBJECT_CMASK_UINT8ARRAY | \
     DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | \
     DUK_HOBJECT_CMASK_INT16ARRAY | \
     DUK_HOBJECT_CMASK_UINT16ARRAY | \
     DUK_HOBJECT_CMASK_INT32ARRAY | \
     DUK_HOBJECT_CMASK_UINT32ARRAY | \
     DUK_HOBJECT_CMASK_FLOAT32ARRAY | \
     DUK_HOBJECT_CMASK_FLOAT64ARRAY)

Definition at line 4779 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS \
    (DUK_HOBJECT_CMASK_BUFFER | \
     DUK_HOBJECT_CMASK_ARRAYBUFFER | \
     DUK_HOBJECT_CMASK_DATAVIEW | \
     DUK_HOBJECT_CMASK_INT8ARRAY | \
     DUK_HOBJECT_CMASK_UINT8ARRAY | \
     DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | \
     DUK_HOBJECT_CMASK_INT16ARRAY | \
     DUK_HOBJECT_CMASK_UINT16ARRAY | \
     DUK_HOBJECT_CMASK_INT32ARRAY | \
     DUK_HOBJECT_CMASK_UINT32ARRAY | \
     DUK_HOBJECT_CMASK_FLOAT32ARRAY | \
     DUK_HOBJECT_CMASK_FLOAT64ARRAY)

◆ DUK_HOBJECT_CMASK_ARGUMENTS

#define DUK_HOBJECT_CMASK_ARGUMENTS (1UL << DUK_HOBJECT_CLASS_ARGUMENTS)

Definition at line 4749 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_ARRAY

#define DUK_HOBJECT_CMASK_ARRAY (1UL << DUK_HOBJECT_CLASS_ARRAY)

Definition at line 4750 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_ARRAYBUFFER

#define DUK_HOBJECT_CMASK_ARRAYBUFFER (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER)

Definition at line 4767 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_BOOLEAN

#define DUK_HOBJECT_CMASK_BOOLEAN (1UL << DUK_HOBJECT_CLASS_BOOLEAN)

Definition at line 4751 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_BUFFER

#define DUK_HOBJECT_CMASK_BUFFER (1UL << DUK_HOBJECT_CLASS_BUFFER)

Definition at line 4764 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_DATAVIEW

#define DUK_HOBJECT_CMASK_DATAVIEW (1UL << DUK_HOBJECT_CLASS_DATAVIEW)

Definition at line 4768 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_DATE

#define DUK_HOBJECT_CMASK_DATE (1UL << DUK_HOBJECT_CLASS_DATE)

Definition at line 4752 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_DECENV

#define DUK_HOBJECT_CMASK_DECENV (1UL << DUK_HOBJECT_CLASS_DECENV)

Definition at line 4763 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_ERROR

#define DUK_HOBJECT_CMASK_ERROR (1UL << DUK_HOBJECT_CLASS_ERROR)

Definition at line 4753 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_FLOAT32ARRAY

#define DUK_HOBJECT_CMASK_FLOAT32ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY)

Definition at line 4776 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_FLOAT64ARRAY

#define DUK_HOBJECT_CMASK_FLOAT64ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY)

Definition at line 4777 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_FUNCTION

#define DUK_HOBJECT_CMASK_FUNCTION (1UL << DUK_HOBJECT_CLASS_FUNCTION)

Definition at line 4754 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_GLOBAL

#define DUK_HOBJECT_CMASK_GLOBAL (1UL << DUK_HOBJECT_CLASS_GLOBAL)

Definition at line 4761 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_INT16ARRAY

#define DUK_HOBJECT_CMASK_INT16ARRAY (1UL << DUK_HOBJECT_CLASS_INT16ARRAY)

Definition at line 4772 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_INT32ARRAY

#define DUK_HOBJECT_CMASK_INT32ARRAY (1UL << DUK_HOBJECT_CLASS_INT32ARRAY)

Definition at line 4774 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_INT8ARRAY

#define DUK_HOBJECT_CMASK_INT8ARRAY (1UL << DUK_HOBJECT_CLASS_INT8ARRAY)

Definition at line 4769 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_JSON

#define DUK_HOBJECT_CMASK_JSON (1UL << DUK_HOBJECT_CLASS_JSON)

Definition at line 4755 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_MATH

#define DUK_HOBJECT_CMASK_MATH (1UL << DUK_HOBJECT_CLASS_MATH)

Definition at line 4756 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_NUMBER

#define DUK_HOBJECT_CMASK_NUMBER (1UL << DUK_HOBJECT_CLASS_NUMBER)

Definition at line 4757 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_OBJECT

#define DUK_HOBJECT_CMASK_OBJECT (1UL << DUK_HOBJECT_CLASS_OBJECT)

Definition at line 4758 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_OBJENV

#define DUK_HOBJECT_CMASK_OBJENV (1UL << DUK_HOBJECT_CLASS_OBJENV)

Definition at line 4762 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_POINTER

#define DUK_HOBJECT_CMASK_POINTER (1UL << DUK_HOBJECT_CLASS_POINTER)

Definition at line 4765 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_REGEXP

#define DUK_HOBJECT_CMASK_REGEXP (1UL << DUK_HOBJECT_CLASS_REGEXP)

Definition at line 4759 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_STRING

#define DUK_HOBJECT_CMASK_STRING (1UL << DUK_HOBJECT_CLASS_STRING)

Definition at line 4760 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_THREAD

#define DUK_HOBJECT_CMASK_THREAD (1UL << DUK_HOBJECT_CLASS_THREAD)

Definition at line 4766 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_UINT16ARRAY

#define DUK_HOBJECT_CMASK_UINT16ARRAY (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY)

Definition at line 4773 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_UINT32ARRAY

#define DUK_HOBJECT_CMASK_UINT32ARRAY (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY)

Definition at line 4775 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_UINT8ARRAY

#define DUK_HOBJECT_CMASK_UINT8ARRAY (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY)

Definition at line 4770 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY

#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY)

Definition at line 4771 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_CMASK_UNUSED

#define DUK_HOBJECT_CMASK_UNUSED (1UL << DUK_HOBJECT_CLASS_UNUSED)

Definition at line 4748 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_DECREF

#define DUK_HOBJECT_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))

Definition at line 3840 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_DECREF_ALLOWNULL

#define DUK_HOBJECT_DECREF_ALLOWNULL	(		thr,
			h )

Value:

        do { \
        if ((h) != NULL) { \
            DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
        } \
    } while (0)

Definition at line 3860 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
        if ((h) != NULL) { \
            DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
        } \
    } while (0)

Referenced by duk__declvar_helper(), and duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_CLEAR_FLAG_BITS

#define DUK_HOBJECT_E_CLEAR_FLAG_BITS	(	heap,
		h,
		i,
		mask )

Value:

        do { \
        DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] &= ~(mask); \
    } while (0)

Definition at line 5151 of file duktape-1.8.0/src/duktape.c.

    } while (0)
 
#define DUK_HOBJECT_E_CLEAR_FLAG_BITS(heap,h,i,mask)  do { \

◆ DUK_HOBJECT_E_FLAG_PADDING

#define DUK_HOBJECT_E_FLAG_PADDING ( e_sz ) ((8 - (e_sz)) & 0x07)

Definition at line 5005 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_GET_FLAGS

#define DUK_HOBJECT_E_GET_FLAGS	(	heap,
		h,
		i ) (DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])

Definition at line 5113 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), duk__realloc_props(), and duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_GET_FLAGS_BASE

#define DUK_HOBJECT_E_GET_FLAGS_BASE	(		heap,
			h )

Value:

    ((duk_uint8_t *) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
    ))

Definition at line 5020 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_GET_PROPS((heap), (h)) \
    ))
#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
    ((duk_uint8_t *) (void *) ( \

◆ DUK_HOBJECT_E_GET_FLAGS_PTR

#define DUK_HOBJECT_E_GET_FLAGS_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])

Definition at line 5114 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_GET_KEY

#define DUK_HOBJECT_E_GET_KEY	(	heap,
		h,
		i ) (DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])

Definition at line 5103 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props(), and duk__sort_array_indices().

◆ DUK_HOBJECT_E_GET_KEY_BASE

#define DUK_HOBJECT_E_GET_KEY_BASE	(		heap,
			h )

Value:

    ((duk_hstring **) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + \
            DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
    ))

Definition at line 5011 of file duktape-1.8.0/src/duktape.c.

#error invalid DUK_USE_ALIGN_BY
#endif
#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
    ((duk_hstring **) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + \

Referenced by duk__sort_array_indices().

◆ DUK_HOBJECT_E_GET_KEY_PTR

#define DUK_HOBJECT_E_GET_KEY_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])

Definition at line 5104 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__sort_array_indices().

◆ DUK_HOBJECT_E_GET_VALUE

#define DUK_HOBJECT_E_GET_VALUE	(	heap,
		h,
		i ) (DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])

Definition at line 5105 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_E_GET_VALUE_BASE

#define DUK_HOBJECT_E_GET_VALUE_BASE	(		heap,
			h )

Value:

    ((duk_propvalue *) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) \
    ))

Definition at line 5016 of file duktape-1.8.0/src/duktape.c.

            DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
    ))
#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
    ((duk_propvalue *) (void *) ( \

◆ DUK_HOBJECT_E_GET_VALUE_GETTER

#define DUK_HOBJECT_E_GET_VALUE_GETTER	(	heap,
		h,
		i ) (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)

Definition at line 5109 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), and duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_GET_VALUE_GETTER_PTR

#define DUK_HOBJECT_E_GET_VALUE_GETTER_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)

Definition at line 5110 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_GET_VALUE_PTR

#define DUK_HOBJECT_E_GET_VALUE_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])

Definition at line 5106 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_GET_VALUE_SETTER

#define DUK_HOBJECT_E_GET_VALUE_SETTER	(	heap,
		h,
		i ) (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)

Definition at line 5111 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_HOBJECT_E_GET_VALUE_SETTER_PTR

#define DUK_HOBJECT_E_GET_VALUE_SETTER_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)

Definition at line 5112 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_GET_VALUE_TVAL

#define DUK_HOBJECT_E_GET_VALUE_TVAL	(	heap,
		h,
		i ) (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)

Definition at line 5107 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_GET_VALUE_TVAL_PTR

#define DUK_HOBJECT_E_GET_VALUE_TVAL_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)

Definition at line 5108 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_find_existing_entry_tval_ptr_and_attrs(), and duk_hobject_putprop().

◆ DUK_HOBJECT_E_MIN_GROW_ADD

#define DUK_HOBJECT_E_MIN_GROW_ADD 16

Definition at line 5301 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_MIN_GROW_DIVISOR

#define DUK_HOBJECT_E_MIN_GROW_DIVISOR 8 /* 2^3 -> 1/8 = 12.5% min growth */

Definition at line 5302 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SET_FLAG_BITS

#define DUK_HOBJECT_E_SET_FLAG_BITS	(	heap,
		h,
		i,
		mask )

Value:

        do { \
        DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] |= (mask); \
    } while (0)

Definition at line 5147 of file duktape-1.8.0/src/duktape.c.

    } while (0)
 
#define DUK_HOBJECT_E_SET_FLAG_BITS(heap,h,i,mask)  do { \

◆ DUK_HOBJECT_E_SET_FLAGS

#define DUK_HOBJECT_E_SET_FLAGS	(	heap,
		h,
		i,
		f )

Value:

        do { \
        DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (duk_uint8_t) (f); \
    } while (0)

Definition at line 5135 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \
    } while (0)
#define DUK_HOBJECT_E_SET_FLAGS(heap,h,i,f)  do { \

Referenced by duk__declvar_helper(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_HOBJECT_E_SET_KEY

#define DUK_HOBJECT_E_SET_KEY	(	heap,
		h,
		i,
		k )

Value:

        do { \
        DUK_HOBJECT_E_GET_KEY((heap), (h), (i)) = (k); \
    } while (0)

Definition at line 5120 of file duktape-1.8.0/src/duktape.c.

#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)  do { \

◆ DUK_HOBJECT_E_SET_VALUE

#define DUK_HOBJECT_E_SET_VALUE	(	heap,
		h,
		i,
		v )

Value:

        do { \
        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)) = (v); \
    } while (0)

Definition at line 5123 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_E_GET_KEY((heap), (h), (i)) = (k); \
    } while (0)
#define DUK_HOBJECT_E_SET_VALUE(heap,h,i,v)  do { \

◆ DUK_HOBJECT_E_SET_VALUE_GETTER

#define DUK_HOBJECT_E_SET_VALUE_GETTER	(	heap,
		h,
		i,
		v )

Value:

        do { \
        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get = (v); \
    } while (0)

Definition at line 5129 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v = (v); \
    } while (0)
#define DUK_HOBJECT_E_SET_VALUE_GETTER(heap,h,i,v)  do { \

Referenced by duk__declvar_helper(), and duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_SET_VALUE_SETTER

#define DUK_HOBJECT_E_SET_VALUE_SETTER	(	heap,
		h,
		i,
		v )

Value:

        do { \
        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \
    } while (0)

Definition at line 5132 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get = (v); \
    } while (0)
#define DUK_HOBJECT_E_SET_VALUE_SETTER(heap,h,i,v)  do { \

Referenced by duk__declvar_helper(), and duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_SET_VALUE_TVAL

#define DUK_HOBJECT_E_SET_VALUE_TVAL	(	heap,
		h,
		i,
		v )

Value:

        do { \
        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v = (v); \
    } while (0)

Definition at line 5126 of file duktape-1.8.0/src/duktape.c.

        DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)) = (v); \
    } while (0)
#define DUK_HOBJECT_E_SET_VALUE_TVAL(heap,h,i,v)  do { \

◆ DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR

#define DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR	(	heap,
		h,
		i ) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)

Definition at line 5168 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_SLOT_CLEAR_CONFIGURABLE

#define DUK_HOBJECT_E_SLOT_CLEAR_CONFIGURABLE	(	heap,
		h,
		i ) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 5167 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_CLEAR_ENUMERABLE

#define DUK_HOBJECT_E_SLOT_CLEAR_ENUMERABLE	(	heap,
		h,
		i ) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)

Definition at line 5166 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE

#define DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE	(	heap,
		h,
		i ) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)

Definition at line 5165 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_SLOT_IS_ACCESSOR

#define DUK_HOBJECT_E_SLOT_IS_ACCESSOR	(	heap,
		h,
		i ) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ACCESSOR) != 0)

Definition at line 5158 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_find_existing_entry_tval_ptr_and_attrs().

◆ DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE

#define DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE	(	heap,
		h,
		i ) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)

Definition at line 5157 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_IS_ENUMERABLE

#define DUK_HOBJECT_E_SLOT_IS_ENUMERABLE	(	heap,
		h,
		i ) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)

Definition at line 5156 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_IS_WRITABLE

#define DUK_HOBJECT_E_SLOT_IS_WRITABLE	(	heap,
		h,
		i ) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_WRITABLE) != 0)

Definition at line 5155 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_SET_ACCESSOR

#define DUK_HOBJECT_E_SLOT_SET_ACCESSOR	(	heap,
		h,
		i ) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)

Definition at line 5163 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper().

◆ DUK_HOBJECT_E_SLOT_SET_CONFIGURABLE

#define DUK_HOBJECT_E_SLOT_SET_CONFIGURABLE	(	heap,
		h,
		i ) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 5162 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_SET_ENUMERABLE

#define DUK_HOBJECT_E_SLOT_SET_ENUMERABLE	(	heap,
		h,
		i ) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)

Definition at line 5161 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_SLOT_SET_WRITABLE

#define DUK_HOBJECT_E_SLOT_SET_WRITABLE	(	heap,
		h,
		i ) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)

Definition at line 5160 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_E_USE_HASH_LIMIT

#define DUK_HOBJECT_E_USE_HASH_LIMIT 32

Definition at line 5277 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS

#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS

Value:

                                                (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \
                                                DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \
                                                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
                                                DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \
                                                DUK_HOBJECT_FLAG_BUFFEROBJECT | \
                                                DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

Definition at line 4817 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS      (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \
                                                DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \
                                                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
                                                DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \
                                                DUK_HOBJECT_FLAG_BUFFEROBJECT | \
                                                DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

◆ DUK_HOBJECT_FLAG_ARRAY_PART

#define DUK_HOBJECT_FLAG_ARRAY_PART DUK_HEAPHDR_USER_FLAG(8) /* object has an array part (a_size may still be 0) */

Definition at line 4682 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_BOUND

#define DUK_HOBJECT_FLAG_BOUND DUK_HEAPHDR_USER_FLAG(2) /* object established using Function.prototype.bind() */

Definition at line 4677 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_BUFFEROBJECT

#define DUK_HOBJECT_FLAG_BUFFEROBJECT DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufferobject) (always exotic) */

Definition at line 4680 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ DUK_HOBJECT_FLAG_CLASS_BASE

#define DUK_HOBJECT_FLAG_CLASS_BASE DUK_HEAPHDR_USER_FLAG_NUMBER(20)

Definition at line 4695 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_CLASS_BITS

#define DUK_HOBJECT_FLAG_CLASS_BITS 5

Definition at line 4696 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_COMPILEDFUNCTION

#define DUK_HOBJECT_FLAG_COMPILEDFUNCTION DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompiledfunction) */

Definition at line 4678 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_CONSTRUCTABLE

#define DUK_HOBJECT_FLAG_CONSTRUCTABLE DUK_HEAPHDR_USER_FLAG(1) /* object is constructable */

Definition at line 4676 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_CREATEARGS

#define DUK_HOBJECT_FLAG_CREATEARGS DUK_HEAPHDR_USER_FLAG(13) /* function: create an arguments object on function call */

Definition at line 4687 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_ENVRECCLOSED

#define DUK_HOBJECT_FLAG_ENVRECCLOSED DUK_HEAPHDR_USER_FLAG(14) /* envrec: (declarative) record is closed */

Definition at line 4688 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS

#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS DUK_HEAPHDR_USER_FLAG(17) /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */

Definition at line 4691 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_EXOTIC_ARRAY

#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY DUK_HEAPHDR_USER_FLAG(15) /* 'Array' object, array length and index exotic behavior */

Definition at line 4689 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC

#define DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC DUK_HEAPHDR_USER_FLAG(18) /* Duktape/C (nativefunction) object, exotic 'length' */

Definition at line 4692 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ

#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ DUK_HEAPHDR_USER_FLAG(19) /* 'Proxy' object */

Definition at line 4693 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ

#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ DUK_HEAPHDR_USER_FLAG(16) /* 'String' object, array index exotic behavior */

Definition at line 4690 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_string_constructor_from_char_code().

◆ DUK_HOBJECT_FLAG_EXTENSIBLE

#define DUK_HOBJECT_FLAG_EXTENSIBLE DUK_HEAPHDR_USER_FLAG(0) /* object is extensible */

Definition at line 4675 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared(), duk_bi_string_constructor_from_char_code(), duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_NAMEBINDING

#define DUK_HOBJECT_FLAG_NAMEBINDING DUK_HEAPHDR_USER_FLAG(12) /* function: create binding for func name (function templates only, used for named function expressions) */

Definition at line 4686 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_FLAG_NATIVEFUNCTION

#define DUK_HOBJECT_FLAG_NATIVEFUNCTION DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnativefunction) */

Definition at line 4679 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_NEWENV

#define DUK_HOBJECT_FLAG_NEWENV DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompiledfunction) */

Definition at line 4685 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_NOTAIL

#define DUK_HOBJECT_FLAG_NOTAIL DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */

Definition at line 4684 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_STRICT

#define DUK_HOBJECT_FLAG_STRICT DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */

Definition at line 4683 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ DUK_HOBJECT_FLAG_THREAD

#define DUK_HOBJECT_FLAG_THREAD DUK_HEAPHDR_USER_FLAG(7) /* object is a thread (duk_hthread) */

Definition at line 4681 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_GET_ASIZE

#define DUK_HOBJECT_GET_ASIZE ( h ) ((h)->a_size)

Definition at line 5203 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__getprop_shallow_fastpath_array_tval(), duk__realloc_props(), duk_bi_duktape_object_info(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_HOBJECT_GET_CLASS_MASK

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

Definition at line 4703 of file duktape-1.8.0/src/duktape.c.

4703#define DUK_HOBJECT_GET_CLASS_MASK(h) \

4704 (1UL << DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS))

◆ DUK_HOBJECT_GET_CLASS_NUMBER

#define DUK_HOBJECT_GET_CLASS_NUMBER ( h ) DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)

Definition at line 4698 of file duktape-1.8.0/src/duktape.c.

4698#define DUK_HOBJECT_GET_CLASS_NUMBER(h) \

4699 DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)

Referenced by duk__declvar_helper(), and duk_bi_buffer_slice_shared().

◆ DUK_HOBJECT_GET_CLASS_STRING

#define DUK_HOBJECT_GET_CLASS_STRING	(		heap,
			h )

Value:

    DUK_HEAP_GET_STRING( \
        (heap), \
        DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(DUK_HOBJECT_GET_CLASS_NUMBER((h))) \
    )

Definition at line 5233 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n)  duk_class_number_to_stridx[(n)]
 
#define DUK_HOBJECT_GET_CLASS_STRING(heap,h)          \
    DUK_HEAP_GET_STRING( \
        (heap), \

Referenced by duk_to_int_clamped_raw().

◆ DUK_HOBJECT_GET_ENEXT

#define DUK_HOBJECT_GET_ENEXT ( h ) ((h)->e_next)

Definition at line 5200 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props(), duk__sort_array_indices(), and duk_bi_duktape_object_info().

◆ DUK_HOBJECT_GET_ESIZE

#define DUK_HOBJECT_GET_ESIZE ( h ) ((h)->e_size)

Definition at line 5198 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props(), and duk_bi_duktape_object_info().

◆ DUK_HOBJECT_GET_HSIZE

#define DUK_HOBJECT_GET_HSIZE ( h ) ((h)->h_size)

Definition at line 5206 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props(), and duk_bi_duktape_object_info().

◆ duk_hobject_get_internal_value_tval_ptr

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

Definition at line 5484 of file duktape-1.8.0/src/duktape.c.

5484 * slot for internal value; this call can then access it directly.

5485 */

value

int value

Definition lsqlite3.c:2155

◆ DUK_HOBJECT_GET_PROPS

#define DUK_HOBJECT_GET_PROPS	(		heap,
			h ) ((h)->props)

Definition at line 4954 of file duktape-1.8.0/src/duktape.c.

4954 } while (0)

4955#else

Referenced by duk__realloc_props(), and duk_free_hobject_inner().

◆ DUK_HOBJECT_GET_PROTOTYPE

#define DUK_HOBJECT_GET_PROTOTYPE	(		heap,
			h ) ((h)->prototype)

Definition at line 5250 of file duktape-1.8.0/src/duktape.c.

5250 } while (0)

5251#else

Referenced by duk__declvar_helper(), duk__get_propdesc(), duk_bi_buffer_slice_shared(), duk_hobject_putprop(), and duk_js_instanceof().

◆ DUK_HOBJECT_H_GET_BASE

#define DUK_HOBJECT_H_GET_BASE	(		heap,
			h )

Value:

    ((duk_uint32_t *) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + \
            DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
            DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \
            DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
    ))

Definition at line 5030 of file duktape-1.8.0/src/duktape.c.

            DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) \
    ))
#define DUK_HOBJECT_H_GET_BASE(heap,h) \
    ((duk_uint32_t *) (void *) ( \
        DUK_HOBJECT_GET_PROPS((heap), (h)) + \
            DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
            DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \

◆ DUK_HOBJECT_H_GET_INDEX

#define DUK_HOBJECT_H_GET_INDEX	(	heap,
		h,
		i ) (DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])

Definition at line 5117 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_H_GET_INDEX_PTR

#define DUK_HOBJECT_H_GET_INDEX_PTR	(	heap,
		h,
		i ) (&DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])

Definition at line 5118 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_H_INCLUDED

#define DUK_HOBJECT_H_INCLUDED

Definition at line 4670 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_H_SET_INDEX

#define DUK_HOBJECT_H_SET_INDEX	(	heap,
		h,
		i,
		v )

Value:

        do { \
        DUK_HOBJECT_H_GET_INDEX((heap), (h), (i)) = (v); \
    } while (0)

Definition at line 5143 of file duktape-1.8.0/src/duktape.c.

#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)  do { \

◆ DUK_HOBJECT_H_SIZE_DIVISOR

#define DUK_HOBJECT_H_SIZE_DIVISOR 4 /* hash size approx. 1.25 times entries size */

Definition at line 5280 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_min_grow_e().

◆ DUK_HOBJECT_HAS_ARRAY_PART

#define DUK_HOBJECT_HAS_ARRAY_PART ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)

Definition at line 4833 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__getprop_shallow_fastpath_array_tval(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_HOBJECT_HAS_BOUND

#define DUK_HOBJECT_HAS_BOUND ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

Definition at line 4828 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup(), and duk_js_instanceof().

◆ DUK_HOBJECT_HAS_BUFFEROBJECT

#define DUK_HOBJECT_HAS_BUFFEROBJECT ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

Definition at line 4831 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HAS_COMPILEDFUNCTION

#define DUK_HOBJECT_HAS_COMPILEDFUNCTION ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

Definition at line 4829 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_HAS_CONSTRUCTABLE

#define DUK_HOBJECT_HAS_CONSTRUCTABLE ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)

Definition at line 4827 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HAS_CREATEARGS

#define DUK_HOBJECT_HAS_CREATEARGS ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)

Definition at line 4838 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_HAS_ENVRECCLOSED

#define DUK_HOBJECT_HAS_ENVRECCLOSED ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)

Definition at line 4839 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS

#define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)

Definition at line 4842 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__getprop_shallow_fastpath_array_tval(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_HOBJECT_HAS_EXOTIC_ARRAY

#define DUK_HOBJECT_HAS_EXOTIC_ARRAY ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)

Definition at line 4840 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR

#define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS)

Definition at line 4824 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HAS_EXOTIC_DUKFUNC

#define DUK_HOBJECT_HAS_EXOTIC_DUKFUNC ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)

Definition at line 4843 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw().

◆ DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ

#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

Definition at line 4844 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getprop_shallow_fastpath_array_tval(), and duk_hobject_putprop().

◆ DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ

#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)

Definition at line 4841 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), and duk__getprop_shallow_fastpath_array_tval().

◆ DUK_HOBJECT_HAS_EXTENSIBLE

#define DUK_HOBJECT_HAS_EXTENSIBLE ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)

Definition at line 4826 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk_err_augment_error_create(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_HOBJECT_HAS_NAMEBINDING

#define DUK_HOBJECT_HAS_NAMEBINDING ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)

Definition at line 4837 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HAS_NATIVEFUNCTION

#define DUK_HOBJECT_HAS_NATIVEFUNCTION ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4830 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_HAS_NEWENV

#define DUK_HOBJECT_HAS_NEWENV ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)

Definition at line 4836 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_HAS_NOTAIL

#define DUK_HOBJECT_HAS_NOTAIL ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)

Definition at line 4835 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_HAS_STRICT

#define DUK_HOBJECT_HAS_STRICT ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)

Definition at line 4834 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), and duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_HAS_THREAD

#define DUK_HOBJECT_HAS_THREAD ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

Definition at line 4832 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HASH_INITIAL

#define DUK_HOBJECT_HASH_INITIAL	(		hash,
			h_size ) ((hash) % (h_size))

Definition at line 5309 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HASH_PROBE_STEP

#define DUK_HOBJECT_HASH_PROBE_STEP ( hash ) DUK_UTIL_GET_HASH_PROBE_STEP((hash))

Definition at line 5310 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HASHIDX_DELETED

#define DUK_HOBJECT_HASHIDX_DELETED 0xfffffffeUL

Definition at line 5176 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_HASHIDX_UNUSED

#define DUK_HOBJECT_HASHIDX_UNUSED 0xffffffffUL

Definition at line 5175 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_INCREF

#define DUK_HOBJECT_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))

Definition at line 3839 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), and duk_handle_ecma_call_setup().

◆ DUK_HOBJECT_INCREF_ALLOWNULL

#define DUK_HOBJECT_INCREF_ALLOWNULL	(		thr,
			h )

Value:

        do { \
        if ((h) != NULL) { \
            DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
        } \
    } while (0)

Definition at line 3855 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
        if ((h) != NULL) { \
            DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
        } \
    } while (0)

Referenced by duk_hobject_define_property_helper(), and duk_hthread_terminate().

◆ DUK_HOBJECT_IS_ARRAY

#define DUK_HOBJECT_IS_ARRAY ( h ) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAY)

Definition at line 4796 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_IS_BUFFEROBJECT

#define DUK_HOBJECT_IS_BUFFEROBJECT ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

Definition at line 4799 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__getprop_shallow_fastpath_array_tval(), duk_bi_duktape_object_info(), duk_bi_typedarray_set(), and duk_hobject_putprop().

◆ DUK_HOBJECT_IS_CALLABLE

#define DUK_HOBJECT_IS_CALLABLE ( h )

Value:

                                                        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
                                                        DUK_HOBJECT_FLAG_BOUND | \
                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4811 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_IS_CALLABLE(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
                                                        DUK_HOBJECT_FLAG_BOUND | \
                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Referenced by duk_hobject_prepare_property_descriptor(), and duk_js_instanceof().

◆ DUK_HOBJECT_IS_COMPILEDFUNCTION

#define DUK_HOBJECT_IS_COMPILEDFUNCTION ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

Definition at line 4797 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs(), duk__reconfig_valstack_ecma_return(), duk_bi_duktape_object_info(), duk_free_hobject_inner(), duk_get_hnativefunction(), duk_handle_ecma_call_setup(), duk_hthread_get_act_prev_pc(), and duk_require_hnativefunction().

◆ DUK_HOBJECT_IS_DECENV

#define DUK_HOBJECT_IS_DECENV ( h ) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV)

Definition at line 4794 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), and duk__getid_open_decl_env_regs().

◆ DUK_HOBJECT_IS_ENV

#define DUK_HOBJECT_IS_ENV ( h ) (DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_DECENV((h)))

Definition at line 4795 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_IS_FUNCTION

#define DUK_HOBJECT_IS_FUNCTION ( h )

Value:

                                                        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
                                                        DUK_HOBJECT_FLAG_BOUND | \
                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4806 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_IS_FUNCTION(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
                                                        DUK_HOBJECT_FLAG_BOUND | \
                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)

◆ DUK_HOBJECT_IS_NATIVEFUNCTION

#define DUK_HOBJECT_IS_NATIVEFUNCTION ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4798 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info(), duk_free_hobject_inner(), and duk_get_c_function().

◆ DUK_HOBJECT_IS_NONBOUND_FUNCTION

#define DUK_HOBJECT_IS_NONBOUND_FUNCTION ( h )

Value:

                                                        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4802 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)

◆ DUK_HOBJECT_IS_OBJENV

#define DUK_HOBJECT_IS_OBJENV ( h ) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV)

Definition at line 4793 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper().

◆ DUK_HOBJECT_IS_THREAD

#define DUK_HOBJECT_IS_THREAD ( h ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

Definition at line 4800 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs(), duk_bi_duktape_object_info(), duk_get_hcompiledfunction(), and duk_require_hcompiledfunction().

◆ DUK_HOBJECT_MAX_PROPERTIES

#define DUK_HOBJECT_MAX_PROPERTIES 0x7fffffffUL /* 2**31-1 ~= 2G properties */

Definition at line 5273 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_P_ALLOC_SIZE

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

Definition at line 5100 of file duktape-1.8.0/src/duktape.c.

5100#endif /* hobject property layout */

5101

Referenced by duk_bi_duktape_object_info().

◆ DUK_HOBJECT_P_COMPUTE_SIZE

#define DUK_HOBJECT_P_COMPUTE_SIZE	(	n_ent,
		n_arr,
		n_hash )

Value:

    ( \
        (n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
        DUK_HOBJECT_E_FLAG_PADDING((n_ent)) + \
        (n_arr) * sizeof(duk_tval) + \
        (n_hash) * sizeof(duk_uint32_t) \
    )

Definition at line 5037 of file duktape-1.8.0/src/duktape.c.

            DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
    ))
#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
    ( \
        (n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
        DUK_HOBJECT_E_FLAG_PADDING((n_ent)) + \
        (n_arr) * sizeof(duk_tval) + \

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_P_SET_REALLOC_PTRS

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

Value:

        do { \
        (set_e_pv) = (duk_propvalue *) (void *) (p_base); \
        (set_e_k) = (duk_hstring **) (void *) ((set_e_pv) + (n_ent)); \
        (set_e_f) = (duk_uint8_t *) (void *) ((set_e_k) + (n_ent)); \
        (set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + \
                                         sizeof(duk_uint8_t) * (n_ent) + \
                                         DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \
        (set_h) = (duk_uint32_t *) (void *) ((set_a) + (n_arr)); \
    } while (0)

Definition at line 5044 of file duktape-1.8.0/src/duktape.c.

        (n_hash) * sizeof(duk_uint32_t) \
    )
#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)  do { \
        (set_e_pv) = (duk_propvalue *) (void *) (p_base); \
        (set_e_k) = (duk_hstring **) (void *) ((set_e_pv) + (n_ent)); \
        (set_e_f) = (duk_uint8_t *) (void *) ((set_e_k) + (n_ent)); \
        (set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + \
                                         sizeof(duk_uint8_t) * (n_ent) + \
                                         DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_POSTINC_ENEXT

#define DUK_HOBJECT_POSTINC_ENEXT ( h ) ((h)->e_next++)

Definition at line 5202 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY

#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY 10000L

Definition at line 5221 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_propdesc(), duk_hobject_putprop(), and duk_js_instanceof().

◆ DUK_HOBJECT_SET_ARRAY_PART

#define DUK_HOBJECT_SET_ARRAY_PART ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)

Definition at line 4853 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_ASIZE

#define DUK_HOBJECT_SET_ASIZE	(		h,
			v ) do { (h)->a_size = (v); } while (0)

Definition at line 5204 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_SET_BOUND

#define DUK_HOBJECT_SET_BOUND ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

Definition at line 4848 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_BUFFEROBJECT

#define DUK_HOBJECT_SET_BUFFEROBJECT ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT)

Definition at line 4851 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_CLASS_NUMBER

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

Definition at line 4700 of file duktape-1.8.0/src/duktape.c.

4700#define DUK_HOBJECT_SET_CLASS_NUMBER(h,v) \

4701 DUK_HEAPHDR_SET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS, (v))

◆ DUK_HOBJECT_SET_COMPILEDFUNCTION

#define DUK_HOBJECT_SET_COMPILEDFUNCTION ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)

Definition at line 4849 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_CONSTRUCTABLE

#define DUK_HOBJECT_SET_CONSTRUCTABLE ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)

Definition at line 4847 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_CREATEARGS

#define DUK_HOBJECT_SET_CREATEARGS ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)

Definition at line 4858 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_ENEXT

#define DUK_HOBJECT_SET_ENEXT	(		h,
			v ) do { (h)->e_next = (v); } while (0)

Definition at line 5201 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_SET_ENVRECCLOSED

#define DUK_HOBJECT_SET_ENVRECCLOSED ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)

Definition at line 4859 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_ESIZE

#define DUK_HOBJECT_SET_ESIZE	(		h,
			v ) do { (h)->e_size = (v); } while (0)

Definition at line 5199 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_SET_EXOTIC_ARGUMENTS

#define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)

Definition at line 4862 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_EXOTIC_ARRAY

#define DUK_HOBJECT_SET_EXOTIC_ARRAY ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)

Definition at line 4860 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_EXOTIC_DUKFUNC

#define DUK_HOBJECT_SET_EXOTIC_DUKFUNC ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)

Definition at line 4863 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_EXOTIC_PROXYOBJ

#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)

Definition at line 4864 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_EXOTIC_STRINGOBJ

#define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)

Definition at line 4861 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_EXTENSIBLE

#define DUK_HOBJECT_SET_EXTENSIBLE ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)

Definition at line 4846 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_HSIZE

#define DUK_HOBJECT_SET_HSIZE	(		h,
			v ) do { (h)->h_size = (v); } while (0)

Definition at line 5207 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_SET_NAMEBINDING

#define DUK_HOBJECT_SET_NAMEBINDING ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)

Definition at line 4857 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_NATIVEFUNCTION

#define DUK_HOBJECT_SET_NATIVEFUNCTION ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Definition at line 4850 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_NEWENV

#define DUK_HOBJECT_SET_NEWENV ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)

Definition at line 4856 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_NOTAIL

#define DUK_HOBJECT_SET_NOTAIL ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)

Definition at line 4855 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_PROPS

#define DUK_HOBJECT_SET_PROPS	(	heap,
		h,
		x )

Value:

        do { \
        (h)->props = (duk_uint8_t *) (x); \
    } while (0)

Definition at line 4956 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_GET_PROPS(heap,h) \
    ((h)->props)
#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \

Referenced by duk__init_object_parts(), and duk__realloc_props().

◆ DUK_HOBJECT_SET_PROTOTYPE

#define DUK_HOBJECT_SET_PROTOTYPE	(	heap,
		h,
		x )

Value:

        do { \
        (h)->prototype = (x); \
    } while (0)

Definition at line 5252 of file duktape-1.8.0/src/duktape.c.

#define DUK_HOBJECT_GET_PROTOTYPE(heap,h) \
    ((h)->prototype)
#define DUK_HOBJECT_SET_PROTOTYPE(heap,h,x) do { \

◆ DUK_HOBJECT_SET_PROTOTYPE_UPDREF

#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF	(	thr,
		h,
		p ) duk_hobject_set_prototype_updref((thr), (h), (p))

Definition at line 5258 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ DUK_HOBJECT_SET_STRICT

#define DUK_HOBJECT_SET_STRICT ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)

Definition at line 4854 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HOBJECT_SET_THREAD

#define DUK_HOBJECT_SET_THREAD ( h ) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)

Definition at line 4852 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_ARRIDX

#define DUK_HSTRING_CLEAR_ARRIDX ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)

Definition at line 4483 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_ASCII

#define DUK_HSTRING_CLEAR_ASCII ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)

Definition at line 4482 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS

#define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)

Definition at line 4487 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_EXTDATA

#define DUK_HSTRING_CLEAR_EXTDATA ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)

Definition at line 4488 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_INTERNAL

#define DUK_HSTRING_CLEAR_INTERNAL ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

Definition at line 4484 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_RESERVED_WORD

#define DUK_HSTRING_CLEAR_RESERVED_WORD ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)

Definition at line 4485 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD

#define DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD ( x ) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)

Definition at line 4486 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_DECREF

#define DUK_HSTRING_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))

Definition at line 3838 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_FLAG_ARRIDX

#define DUK_HSTRING_FLAG_ARRIDX DUK_HEAPHDR_USER_FLAG(1) /* string is a valid array index */

Definition at line 4459 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_FLAG_ASCII

#define DUK_HSTRING_FLAG_ASCII DUK_HEAPHDR_USER_FLAG(0) /* string is ASCII, clen == blen */

Definition at line 4458 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS

#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS DUK_HEAPHDR_USER_FLAG(5) /* string is 'eval' or 'arguments' */

Definition at line 4463 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_FLAG_EXTDATA

#define DUK_HSTRING_FLAG_EXTDATA DUK_HEAPHDR_USER_FLAG(6) /* string data is external (duk_hstring_external) */

Definition at line 4464 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_FLAG_INTERNAL

#define DUK_HSTRING_FLAG_INTERNAL DUK_HEAPHDR_USER_FLAG(2) /* string is internal */

Definition at line 4460 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_FLAG_RESERVED_WORD

#define DUK_HSTRING_FLAG_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(3) /* string is a reserved word (non-strict) */

Definition at line 4461 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_FLAG_STRICT_RESERVED_WORD

#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(4) /* string is a reserved word (strict) */

Definition at line 4462 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_GET_ARRIDX_FAST

#define DUK_HSTRING_GET_ARRIDX_FAST ( h ) (DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX)

Definition at line 4557 of file duktape-1.8.0/src/duktape.c.

4557#define DUK_HSTRING_GET_ARRIDX_FAST(h) \

4558 (DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX)

Referenced by duk__get_propdesc().

◆ DUK_HSTRING_GET_ARRIDX_SLOW

#define DUK_HSTRING_GET_ARRIDX_SLOW ( h ) (duk_js_to_arrayindex_string_helper((h)))

Definition at line 4561 of file duktape-1.8.0/src/duktape.c.

4561#define DUK_HSTRING_GET_ARRIDX_SLOW(h) \

4562 (duk_js_to_arrayindex_string_helper((h)))

Referenced by duk__sort_array_indices(), duk_hobject_define_property_helper(), and duk_hobject_define_property_internal().

◆ DUK_HSTRING_GET_BYTELEN

#define DUK_HSTRING_GET_BYTELEN ( x ) ((x)->blen)

Definition at line 4527 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__create_escaped_source(), duk__dump_hbuffer_raw(), duk__ispec_toregconst_raw(), duk_bi_duktape_object_info(), duk_hstring_char_code_at_raw(), and duk_js_toboolean().

◆ DUK_HSTRING_GET_CHARLEN

#define DUK_HSTRING_GET_CHARLEN ( x ) ((x)->clen)

Definition at line 4531 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), duk__get_own_propdesc_raw(), duk_hobject_putprop(), and duk_hstring_char_code_at_raw().

◆ DUK_HSTRING_GET_DATA

#define DUK_HSTRING_GET_DATA ( x ) ((const duk_uint8_t *) ((x) + 1))

Definition at line 4544 of file duktape-1.8.0/src/duktape.c.

4544#define DUK_HSTRING_GET_DATA(x) \

4545 ((const duk_uint8_t *) ((x) + 1))

Referenced by duk__create_escaped_source(), duk__dump_hbuffer_raw(), duk__error_getter_helper(), duk_hstring_char_code_at_raw(), and duk_to_int_clamped_raw().

◆ DUK_HSTRING_GET_DATA_END

#define DUK_HSTRING_GET_DATA_END ( x ) (DUK_HSTRING_GET_DATA((x)) + (x)->blen)

Definition at line 4548 of file duktape-1.8.0/src/duktape.c.

4548#define DUK_HSTRING_GET_DATA_END(x) \

4549 (DUK_HSTRING_GET_DATA((x)) + (x)->blen)

◆ DUK_HSTRING_GET_HASH

#define DUK_HSTRING_GET_HASH ( x ) ((x)->hash)

Definition at line 4504 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), and duk__realloc_props().

◆ DUK_HSTRING_H_INCLUDED

#define DUK_HSTRING_H_INCLUDED

Definition at line 4435 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_HAS_ARRIDX

#define DUK_HSTRING_HAS_ARRIDX ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)

Definition at line 4467 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_HAS_ASCII

#define DUK_HSTRING_HAS_ASCII ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)

Definition at line 4466 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS

#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)

Definition at line 4471 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_HAS_EXTDATA

#define DUK_HSTRING_HAS_EXTDATA ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)

Definition at line 4472 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), and duk_heap_free_heaphdr_raw().

◆ DUK_HSTRING_HAS_INTERNAL

#define DUK_HSTRING_HAS_INTERNAL ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

Definition at line 4468 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_HAS_RESERVED_WORD

#define DUK_HSTRING_HAS_RESERVED_WORD ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)

Definition at line 4469 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK_HSTRING_HAS_STRICT_RESERVED_WORD

#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD ( x ) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)

Definition at line 4470 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__parse_func_body().

◆ DUK_HSTRING_INCREF

#define DUK_HSTRING_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))

Definition at line 3837 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_HSTRING_IS_ASCII

#define DUK_HSTRING_IS_ASCII ( x ) DUK_HSTRING_HAS_ASCII((x))

Definition at line 4495 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_IS_EMPTY

#define DUK_HSTRING_IS_EMPTY ( x ) (DUK_HSTRING_GET_BYTELEN((x)) == 0)

Definition at line 4496 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_MAX_BYTELEN

#define DUK_HSTRING_MAX_BYTELEN (0x7fffffffUL)

Definition at line 4449 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_heap_string_intern_checked().

◆ DUK_HSTRING_NO_ARRAY_INDEX

#define DUK_HSTRING_NO_ARRAY_INDEX (0xffffffffUL)

Definition at line 4552 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_SET_ARRIDX

#define DUK_HSTRING_SET_ARRIDX ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)

Definition at line 4475 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_SET_ASCII

#define DUK_HSTRING_SET_ASCII ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)

Definition at line 4474 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_SET_BYTELEN

#define DUK_HSTRING_SET_BYTELEN	(		x,
			v )

Value:

        do { \
        (x)->blen = (v); \
    } while (0)

Definition at line 4528 of file duktape-1.8.0/src/duktape.c.

#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
        (x)->blen = (v); \
    } while (0)

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_SET_CHARLEN

#define DUK_HSTRING_SET_CHARLEN	(		x,
			v )

Value:

        do { \
        (x)->clen = (v); \
    } while (0)

Definition at line 4532 of file duktape-1.8.0/src/duktape.c.

#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
        (x)->clen = (v); \
    } while (0)

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_SET_EVAL_OR_ARGUMENTS

#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)

Definition at line 4479 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_SET_EXTDATA

#define DUK_HSTRING_SET_EXTDATA ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)

Definition at line 4480 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_SET_HASH

#define DUK_HSTRING_SET_HASH	(		x,
			v )

Value:

        do { \
        (x)->hash = (v); \
    } while (0)

Definition at line 4505 of file duktape-1.8.0/src/duktape.c.

#define DUK_HSTRING_SET_HASH(x,v) do { \
        (x)->hash = (v); \
    } while (0)

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_SET_INTERNAL

#define DUK_HSTRING_SET_INTERNAL ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

Definition at line 4476 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring().

◆ DUK_HSTRING_SET_RESERVED_WORD

#define DUK_HSTRING_SET_RESERVED_WORD ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)

Definition at line 4477 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HSTRING_SET_STRICT_RESERVED_WORD

#define DUK_HSTRING_SET_STRICT_RESERVED_WORD ( x ) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)

Definition at line 4478 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_DECREF

#define DUK_HTHREAD_DECREF	(		thr,
			h ) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3850 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_GET_CURRENT_ACTIVATION

#define DUK_HTHREAD_GET_CURRENT_ACTIVATION ( thr ) (&(thr)->callstack[(thr)->callstack_top - 1])

Definition at line 6100 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_GET_STRING

#define DUK_HTHREAD_GET_STRING	(		thr,
			idx ) ((thr)->strs[(idx)])

Definition at line 6095 of file duktape-1.8.0/src/duktape.c.

6095#if defined(DUK_USE_ROM_STRINGS)

6096#define DUK_HTHREAD_GET_STRING(thr,idx) \

Referenced by duk__err_augment_user(), and duk_lexer_parse_js_input_element().

◆ DUK_HTHREAD_H_INCLUDED

#define DUK_HTHREAD_H_INCLUDED

Definition at line 5975 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_INCREF

#define DUK_HTHREAD_INCREF	(		thr,
			h ) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)

Definition at line 3849 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STATE_INACTIVE

#define DUK_HTHREAD_STATE_INACTIVE 1 /* thread not currently running */

Definition at line 6103 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STATE_RESUMED

#define DUK_HTHREAD_STATE_RESUMED 3 /* thread resumed another thread (active but not running) */

Definition at line 6105 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STATE_RUNNING

#define DUK_HTHREAD_STATE_RUNNING 2 /* thread currently running (only one at a time) */

Definition at line 6104 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_HTHREAD_STATE_TERMINATED

#define DUK_HTHREAD_STATE_TERMINATED 5 /* thread has terminated */

Definition at line 6107 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STATE_YIELDED

#define DUK_HTHREAD_STATE_YIELDED 4 /* thread has yielded */

Definition at line 6106 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PROTO

#define DUK_HTHREAD_STRING___PROTO__ ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)

Definition at line 1116 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ARRAY

#define DUK_HTHREAD_STRING_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)

Definition at line 903 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ARRAY_BUFFER

#define DUK_HTHREAD_STRING_ARRAY_BUFFER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER)

Definition at line 933 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_BASE64

#define DUK_HTHREAD_STRING_BASE64 ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)

Definition at line 1260 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS

#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)

Definition at line 1083 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_BREAK

#define DUK_HTHREAD_STRING_BREAK ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)

Definition at line 1326 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_BYTE_LENGTH

#define DUK_HTHREAD_STRING_BYTE_LENGTH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH)

Definition at line 1146 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), and duk_hobject_putprop().

◆ DUK_HTHREAD_STRING_BYTE_OFFSET

#define DUK_HTHREAD_STRING_BYTE_OFFSET ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET)

Definition at line 1149 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), and duk_hobject_putprop().

◆ DUK_HTHREAD_STRING_BYTES_PER_ELEMENT

#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT)

Definition at line 1152 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), and duk_hobject_putprop().

◆ DUK_HTHREAD_STRING_CALLEE

#define DUK_HTHREAD_STRING_CALLEE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)

Definition at line 1092 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CALLER

#define DUK_HTHREAD_STRING_CALLER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)

Definition at line 1095 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CASE

#define DUK_HTHREAD_STRING_CASE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)

Definition at line 1329 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CATCH

#define DUK_HTHREAD_STRING_CATCH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)

Definition at line 1332 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CLASS

#define DUK_HTHREAD_STRING_CLASS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)

Definition at line 1407 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CLOG

#define DUK_HTHREAD_STRING_CLOG ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)

Definition at line 1302 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_COMMA

#define DUK_HTHREAD_STRING_COMMA ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)

Definition at line 1074 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_COMPILE

#define DUK_HTHREAD_STRING_COMPILE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)

Definition at line 1236 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CONFIGURABLE

#define DUK_HTHREAD_STRING_CONFIGURABLE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)

Definition at line 996 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CONST

#define DUK_HTHREAD_STRING_CONST ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)

Definition at line 1395 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CONSTRUCTOR

#define DUK_HTHREAD_STRING_CONSTRUCTOR ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)

Definition at line 1041 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_CONTINUE

#define DUK_HTHREAD_STRING_CONTINUE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)

Definition at line 1335 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DATA

#define DUK_HTHREAD_STRING_DATA ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA)

Definition at line 1140 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DATA_VIEW

#define DUK_HTHREAD_STRING_DATA_VIEW ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW)

Definition at line 936 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DATE

#define DUK_HTHREAD_STRING_DATE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)

Definition at line 915 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DEBUGGER

#define DUK_HTHREAD_STRING_DEBUGGER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)

Definition at line 1338 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DEC_ENV

#define DUK_HTHREAD_STRING_DEC_ENV ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)

Definition at line 972 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DEFAULT

#define DUK_HTHREAD_STRING_DEFAULT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)

Definition at line 1341 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DEFINE_PROPERTY

#define DUK_HTHREAD_STRING_DEFINE_PROPERTY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)

Definition at line 987 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DELETE

#define DUK_HTHREAD_STRING_DELETE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)

Definition at line 1344 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DELETE_PROPERTY

#define DUK_HTHREAD_STRING_DELETE_PROPERTY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)

Definition at line 1104 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_DO

#define DUK_HTHREAD_STRING_DO ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)

Definition at line 1347 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ELSE

#define DUK_HTHREAD_STRING_ELSE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)

Definition at line 1350 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_EMPTY_STRING

#define DUK_HTHREAD_STRING_EMPTY_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)

Definition at line 930 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_HTHREAD_STRING_ENUM

#define DUK_HTHREAD_STRING_ENUM ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)

Definition at line 1410 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ENUMERABLE

#define DUK_HTHREAD_STRING_ENUMERABLE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)

Definition at line 999 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ENUMERATE

#define DUK_HTHREAD_STRING_ENUMERATE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)

Definition at line 1107 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ENV

#define DUK_HTHREAD_STRING_ENV ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)

Definition at line 1254 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ERR_CREATE

#define DUK_HTHREAD_STRING_ERR_CREATE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)

Definition at line 1242 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ERR_THROW

#define DUK_HTHREAD_STRING_ERR_THROW ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)

Definition at line 1245 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP

#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)

Definition at line 1032 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_EVAL

#define DUK_HTHREAD_STRING_EVAL ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)

Definition at line 984 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__putvar_helper().

◆ DUK_HTHREAD_STRING_EXPORT

#define DUK_HTHREAD_STRING_EXPORT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)

Definition at line 1413 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_EXPORTS

#define DUK_HTHREAD_STRING_EXPORTS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS)

Definition at line 1125 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_EXTENDS

#define DUK_HTHREAD_STRING_EXTENDS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)

Definition at line 1416 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FALSE

#define DUK_HTHREAD_STRING_FALSE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)

Definition at line 1431 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FILE_NAME

#define DUK_HTHREAD_STRING_FILE_NAME ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)

Definition at line 1173 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FILENAME

#define DUK_HTHREAD_STRING_FILENAME ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILENAME)

Definition at line 1128 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FINALLY

#define DUK_HTHREAD_STRING_FINALLY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)

Definition at line 1353 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FLOAT32_ARRAY

#define DUK_HTHREAD_STRING_FLOAT32_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY)

Definition at line 960 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FLOAT64_ARRAY

#define DUK_HTHREAD_STRING_FLOAT64_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY)

Definition at line 963 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FMT

#define DUK_HTHREAD_STRING_FMT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)

Definition at line 1272 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_FOR

#define DUK_HTHREAD_STRING_FOR ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)

Definition at line 1356 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_GET

#define DUK_HTHREAD_STRING_GET ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)

Definition at line 1101 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_GLOBAL

#define DUK_HTHREAD_STRING_GLOBAL ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)

Definition at line 966 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_HAS

#define DUK_HTHREAD_STRING_HAS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)

Definition at line 1098 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_HEX

#define DUK_HTHREAD_STRING_HEX ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)

Definition at line 1257 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_ID

#define DUK_HTHREAD_STRING_ID ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)

Definition at line 1122 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_IF

#define DUK_HTHREAD_STRING_IF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)

Definition at line 1362 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_IGNORE_CASE

#define DUK_HTHREAD_STRING_IGNORE_CASE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)

Definition at line 1023 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_IMPLEMENTS

#define DUK_HTHREAD_STRING_IMPLEMENTS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)

Definition at line 1434 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_IMPORT

#define DUK_HTHREAD_STRING_IMPORT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)

Definition at line 1419 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_IN

#define DUK_HTHREAD_STRING_IN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)

Definition at line 1365 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INDEX

#define DUK_HTHREAD_STRING_INDEX ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)

Definition at line 1035 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INFINITY

#define DUK_HTHREAD_STRING_INFINITY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)

Definition at line 1065 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INPUT

#define DUK_HTHREAD_STRING_INPUT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)

Definition at line 1239 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INSTANCEOF

#define DUK_HTHREAD_STRING_INSTANCEOF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)

Definition at line 1368 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT16_ARRAY

#define DUK_HTHREAD_STRING_INT16_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY)

Definition at line 948 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT32_ARRAY

#define DUK_HTHREAD_STRING_INT32_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY)

Definition at line 954 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT8_ARRAY

#define DUK_HTHREAD_STRING_INT8_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY)

Definition at line 939 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_ARGS

#define DUK_HTHREAD_STRING_INT_ARGS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)

Definition at line 1209 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_BYTECODE

#define DUK_HTHREAD_STRING_INT_BYTECODE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)

Definition at line 1188 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_CALLEE

#define DUK_HTHREAD_STRING_INT_CALLEE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)

Definition at line 1221 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs().

◆ DUK_HTHREAD_STRING_INT_FINALIZER

#define DUK_HTHREAD_STRING_INT_FINALIZER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)

Definition at line 1215 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_FORMALS

#define DUK_HTHREAD_STRING_INT_FORMALS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)

Definition at line 1191 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_HANDLER

#define DUK_HTHREAD_STRING_INT_HANDLER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)

Definition at line 1218 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_LEXENV

#define DUK_HTHREAD_STRING_INT_LEXENV ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)

Definition at line 1197 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_MAP

#define DUK_HTHREAD_STRING_INT_MAP ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)

Definition at line 1212 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_NEXT

#define DUK_HTHREAD_STRING_INT_NEXT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)

Definition at line 1185 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_PC2LINE

#define DUK_HTHREAD_STRING_INT_PC2LINE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)

Definition at line 1206 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_REGBASE

#define DUK_HTHREAD_STRING_INT_REGBASE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)

Definition at line 1227 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs().

◆ DUK_HTHREAD_STRING_INT_SOURCE

#define DUK_HTHREAD_STRING_INT_SOURCE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)

Definition at line 1203 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_TARGET

#define DUK_HTHREAD_STRING_INT_TARGET ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)

Definition at line 1230 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper().

◆ DUK_HTHREAD_STRING_INT_THIS

#define DUK_HTHREAD_STRING_INT_THIS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)

Definition at line 1233 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_THREAD

#define DUK_HTHREAD_STRING_INT_THREAD ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)

Definition at line 1224 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs().

◆ DUK_HTHREAD_STRING_INT_TRACEDATA

#define DUK_HTHREAD_STRING_INT_TRACEDATA ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)

Definition at line 1167 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_VALUE

#define DUK_HTHREAD_STRING_INT_VALUE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)

Definition at line 1182 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_VARENV

#define DUK_HTHREAD_STRING_INT_VARENV ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)

Definition at line 1200 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INT_VARMAP

#define DUK_HTHREAD_STRING_INT_VARMAP ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)

Definition at line 1194 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs().

◆ DUK_HTHREAD_STRING_INTERFACE

#define DUK_HTHREAD_STRING_INTERFACE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)

Definition at line 1437 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_INVALID_DATE

#define DUK_HTHREAD_STRING_INVALID_DATE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)

Definition at line 1086 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JC

#define DUK_HTHREAD_STRING_JC ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)

Definition at line 1266 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JOIN

#define DUK_HTHREAD_STRING_JOIN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)

Definition at line 1002 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON

#define DUK_HTHREAD_STRING_JSON ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)

Definition at line 927 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1

#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1 ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)

Definition at line 1320 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2

#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2 ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)

Definition at line 1323 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON_EXT_NAN

#define DUK_HTHREAD_STRING_JSON_EXT_NAN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)

Definition at line 1311 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON_EXT_NEGINF

#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)

Definition at line 1317 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON_EXT_POSINF

#define DUK_HTHREAD_STRING_JSON_EXT_POSINF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)

Definition at line 1314 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED

#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)

Definition at line 1308 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_JX

#define DUK_HTHREAD_STRING_JX ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)

Definition at line 1263 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LAST_INDEX

#define DUK_HTHREAD_STRING_LAST_INDEX ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)

Definition at line 1029 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_ARGUMENTS

#define DUK_HTHREAD_STRING_LC_ARGUMENTS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)

Definition at line 1089 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__putvar_helper().

◆ DUK_HTHREAD_STRING_LC_BOOLEAN

#define DUK_HTHREAD_STRING_LC_BOOLEAN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)

Definition at line 1047 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_BUFFER

#define DUK_HTHREAD_STRING_LC_BUFFER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)

Definition at line 1176 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_DEBUG

#define DUK_HTHREAD_STRING_LC_DEBUG ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)

Definition at line 1281 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_ERROR

#define DUK_HTHREAD_STRING_LC_ERROR ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)

Definition at line 1290 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_FATAL

#define DUK_HTHREAD_STRING_LC_FATAL ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)

Definition at line 1293 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_FUNCTION

#define DUK_HTHREAD_STRING_LC_FUNCTION ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)

Definition at line 1359 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_INFO

#define DUK_HTHREAD_STRING_LC_INFO ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)

Definition at line 1284 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_L

#define DUK_HTHREAD_STRING_LC_L ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)

Definition at line 1299 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_N

#define DUK_HTHREAD_STRING_LC_N ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)

Definition at line 1296 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_NULL

#define DUK_HTHREAD_STRING_LC_NULL ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)

Definition at line 1425 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_NUMBER

#define DUK_HTHREAD_STRING_LC_NUMBER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)

Definition at line 1050 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_OBJECT

#define DUK_HTHREAD_STRING_LC_OBJECT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)

Definition at line 1056 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_POINTER

#define DUK_HTHREAD_STRING_LC_POINTER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)

Definition at line 1179 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_STRING

#define DUK_HTHREAD_STRING_LC_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)

Definition at line 1053 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_TRACE

#define DUK_HTHREAD_STRING_LC_TRACE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)

Definition at line 1278 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_UNDEFINED

#define DUK_HTHREAD_STRING_LC_UNDEFINED ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)

Definition at line 1059 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_WARN

#define DUK_HTHREAD_STRING_LC_WARN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)

Definition at line 1287 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LENGTH

#define DUK_HTHREAD_STRING_LENGTH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)

Definition at line 1143 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_HTHREAD_STRING_LET

#define DUK_HTHREAD_STRING_LET ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)

Definition at line 1440 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_LINE_NUMBER

#define DUK_HTHREAD_STRING_LINE_NUMBER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)

Definition at line 1164 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MATH

#define DUK_HTHREAD_STRING_MATH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)

Definition at line 924 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MESSAGE

#define DUK_HTHREAD_STRING_MESSAGE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)

Definition at line 1044 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MINUS_INFINITY

#define DUK_HTHREAD_STRING_MINUS_INFINITY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)

Definition at line 1068 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MINUS_ZERO

#define DUK_HTHREAD_STRING_MINUS_ZERO ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)

Definition at line 1071 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MOD_LOADED

#define DUK_HTHREAD_STRING_MOD_LOADED ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)

Definition at line 1251 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MOD_SEARCH

#define DUK_HTHREAD_STRING_MOD_SEARCH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)

Definition at line 1248 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_MULTILINE

#define DUK_HTHREAD_STRING_MULTILINE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)

Definition at line 1026 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_NAME

#define DUK_HTHREAD_STRING_NAME ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)

Definition at line 1170 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_NAN

#define DUK_HTHREAD_STRING_NAN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)

Definition at line 1062 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_NEW

#define DUK_HTHREAD_STRING_NEW ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)

Definition at line 1371 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_NEWLINE_4SPACE

#define DUK_HTHREAD_STRING_NEWLINE_4SPACE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_4SPACE)

Definition at line 1080 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_OBJ_ENV

#define DUK_HTHREAD_STRING_OBJ_ENV ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)

Definition at line 969 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_OWN_KEYS

#define DUK_HTHREAD_STRING_OWN_KEYS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)

Definition at line 1110 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PACKAGE

#define DUK_HTHREAD_STRING_PACKAGE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)

Definition at line 1443 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PC

#define DUK_HTHREAD_STRING_PC ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)

Definition at line 1161 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PRIVATE

#define DUK_HTHREAD_STRING_PRIVATE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)

Definition at line 1446 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PROTECTED

#define DUK_HTHREAD_STRING_PROTECTED ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)

Definition at line 1449 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PROTOTYPE

#define DUK_HTHREAD_STRING_PROTOTYPE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)

Definition at line 1038 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_PUBLIC

#define DUK_HTHREAD_STRING_PUBLIC ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)

Definition at line 1452 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_RAW

#define DUK_HTHREAD_STRING_RAW ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)

Definition at line 1275 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_REG_EXP

#define DUK_HTHREAD_STRING_REG_EXP ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)

Definition at line 918 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_REQUIRE

#define DUK_HTHREAD_STRING_REQUIRE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)

Definition at line 1119 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_RESUME

#define DUK_HTHREAD_STRING_RESUME ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)

Definition at line 1269 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_RETURN

#define DUK_HTHREAD_STRING_RETURN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)

Definition at line 1374 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_SET

#define DUK_HTHREAD_STRING_SET ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)

Definition at line 1155 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_SET_PROTOTYPE_OF

#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)

Definition at line 1113 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_SOURCE

#define DUK_HTHREAD_STRING_SOURCE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)

Definition at line 1020 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_SPACE

#define DUK_HTHREAD_STRING_SPACE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)

Definition at line 1077 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_STACK

#define DUK_HTHREAD_STRING_STACK ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)

Definition at line 1158 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_STATIC

#define DUK_HTHREAD_STRING_STATIC ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)

Definition at line 1455 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_SUPER

#define DUK_HTHREAD_STRING_SUPER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)

Definition at line 1422 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_SWITCH

#define DUK_HTHREAD_STRING_SWITCH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)

Definition at line 1377 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_THIS

#define DUK_HTHREAD_STRING_THIS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)

Definition at line 1380 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_THROW

#define DUK_HTHREAD_STRING_THROW ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)

Definition at line 1383 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_GMT_STRING

#define DUK_HTHREAD_STRING_TO_GMT_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)

Definition at line 1017 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_ISO_STRING

#define DUK_HTHREAD_STRING_TO_ISO_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)

Definition at line 1014 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_JSON

#define DUK_HTHREAD_STRING_TO_JSON ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)

Definition at line 1134 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_LOCALE_STRING

#define DUK_HTHREAD_STRING_TO_LOCALE_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)

Definition at line 1005 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_LOG_STRING

#define DUK_HTHREAD_STRING_TO_LOG_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)

Definition at line 1305 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_STRING

#define DUK_HTHREAD_STRING_TO_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)

Definition at line 1131 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TO_UTC_STRING

#define DUK_HTHREAD_STRING_TO_UTC_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)

Definition at line 1011 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TRUE

#define DUK_HTHREAD_STRING_TRUE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)

Definition at line 1428 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TRY

#define DUK_HTHREAD_STRING_TRY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)

Definition at line 1386 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TYPE

#define DUK_HTHREAD_STRING_TYPE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE)

Definition at line 1137 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_TYPEOF

#define DUK_HTHREAD_STRING_TYPEOF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)

Definition at line 1389 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_ARGUMENTS

#define DUK_HTHREAD_STRING_UC_ARGUMENTS ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)

Definition at line 894 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_BOOLEAN

#define DUK_HTHREAD_STRING_UC_BOOLEAN ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)

Definition at line 909 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_BUFFER

#define DUK_HTHREAD_STRING_UC_BUFFER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)

Definition at line 975 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_ERROR

#define DUK_HTHREAD_STRING_UC_ERROR ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)

Definition at line 921 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_FUNCTION

#define DUK_HTHREAD_STRING_UC_FUNCTION ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)

Definition at line 900 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_NULL

#define DUK_HTHREAD_STRING_UC_NULL ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)

Definition at line 891 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_NUMBER

#define DUK_HTHREAD_STRING_UC_NUMBER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)

Definition at line 912 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_OBJECT

#define DUK_HTHREAD_STRING_UC_OBJECT ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)

Definition at line 897 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_POINTER

#define DUK_HTHREAD_STRING_UC_POINTER ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)

Definition at line 978 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_STRING

#define DUK_HTHREAD_STRING_UC_STRING ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)

Definition at line 906 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_THREAD

#define DUK_HTHREAD_STRING_UC_THREAD ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)

Definition at line 981 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UC_UNDEFINED

#define DUK_HTHREAD_STRING_UC_UNDEFINED ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)

Definition at line 888 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UINT16_ARRAY

#define DUK_HTHREAD_STRING_UINT16_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY)

Definition at line 951 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UINT32_ARRAY

#define DUK_HTHREAD_STRING_UINT32_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY)

Definition at line 957 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UINT8_ARRAY

#define DUK_HTHREAD_STRING_UINT8_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY)

Definition at line 942 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY

#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY)

Definition at line 945 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_VALUE

#define DUK_HTHREAD_STRING_VALUE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)

Definition at line 990 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_VALUE_OF

#define DUK_HTHREAD_STRING_VALUE_OF ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)

Definition at line 1008 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_VAR

#define DUK_HTHREAD_STRING_VAR ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)

Definition at line 1392 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_VOID

#define DUK_HTHREAD_STRING_VOID ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)

Definition at line 1398 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_WHILE

#define DUK_HTHREAD_STRING_WHILE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)

Definition at line 1401 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_WITH

#define DUK_HTHREAD_STRING_WITH ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)

Definition at line 1404 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_WRITABLE

#define DUK_HTHREAD_STRING_WRITABLE ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)

Definition at line 993 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTHREAD_STRING_YIELD

#define DUK_HTHREAD_STRING_YIELD ( thr ) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)

Definition at line 1458 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTYPE_BUFFER

#define DUK_HTYPE_BUFFER 3

Definition at line 3575 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_duktape_object_info().

◆ DUK_HTYPE_MAX

#define DUK_HTYPE_MAX 3

Definition at line 3576 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTYPE_MIN

#define DUK_HTYPE_MIN 1

Definition at line 3572 of file duktape-1.8.0/src/duktape.c.

◆ DUK_HTYPE_OBJECT

#define DUK_HTYPE_OBJECT 2

Definition at line 3574 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_object_parts(), and duk_bi_duktape_object_info().

◆ DUK_HTYPE_STRING

#define DUK_HTYPE_STRING 1

Definition at line 3573 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__alloc_init_hstring(), and duk_bi_duktape_object_info().

◆ DUK_INTERNAL_H_INCLUDED

#define DUK_INTERNAL_H_INCLUDED

Definition at line 123 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ISPEC_NONE

#define DUK_ISPEC_NONE 0 /* no value */

Definition at line 3187 of file duktape-1.8.0/src/duktape.c.

◆ DUK_ISPEC_REGCONST

#define DUK_ISPEC_REGCONST 2 /* value resides in a register or constant */

Definition at line 3189 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK_ISPEC_VALUE

#define DUK_ISPEC_VALUE 1 /* value resides in 'valstack_idx' */

Definition at line 3188 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__expr_led(), and duk__ispec_toregconst_raw().

◆ DUK_IVAL_ARITH

#define DUK_IVAL_ARITH 2 /* binary arithmetic; DUK_OP_ADD, DUK_OP_EQ, other binary ops */

Definition at line 3182 of file duktape-1.8.0/src/duktape.c.

◆ DUK_IVAL_ARITH_EXTRAOP

#define DUK_IVAL_ARITH_EXTRAOP 3 /* binary arithmetic using extraops; DUK_EXTRAOP_INSTOF etc */

Definition at line 3183 of file duktape-1.8.0/src/duktape.c.

◆ DUK_IVAL_NONE

#define DUK_IVAL_NONE 0 /* no value */

Definition at line 3180 of file duktape-1.8.0/src/duktape.c.

◆ DUK_IVAL_PLAIN

#define DUK_IVAL_PLAIN 1 /* register, constant, or value */

Definition at line 3181 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__expr_led().

◆ DUK_IVAL_PROP

#define DUK_IVAL_PROP 4 /* property access */

Definition at line 3184 of file duktape-1.8.0/src/duktape.c.

◆ DUK_IVAL_VAR

#define DUK_IVAL_VAR 5 /* variable access */

Definition at line 3185 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JMPBUF_H_INCLUDED

#define DUK_JMPBUF_H_INCLUDED

Definition at line 201 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JS_BYTECODE_H_INCLUDED

#define DUK_JS_BYTECODE_H_INCLUDED

Definition at line 2522 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JS_COMPILE_FLAG_EVAL

#define DUK_JS_COMPILE_FLAG_EVAL (1 << 0) /* source is eval code (not global) */

Definition at line 3376 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JS_COMPILE_FLAG_FUNCEXPR

#define DUK_JS_COMPILE_FLAG_FUNCEXPR (1 << 2) /* source is a function expression (used for Function constructor) */

Definition at line 3378 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JS_COMPILE_FLAG_STRICT

#define DUK_JS_COMPILE_FLAG_STRICT (1 << 1) /* strict outer context */

Definition at line 3377 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JS_COMPILER_H_INCLUDED

#define DUK_JS_COMPILER_H_INCLUDED

Definition at line 3161 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JS_CONST_MARKER

#define DUK_JS_CONST_MARKER 0x80000000UL

Definition at line 3192 of file duktape-1.8.0/src/duktape.c.

◆ duk_js_equals

#define duk_js_equals	(	thr,
		tv_x,
		tv_y ) duk_js_equals_helper((thr), (tv_x), (tv_y), 0)

Definition at line 8413 of file duktape-1.8.0/src/duktape.c.

8413DUK_INTERNAL_DECL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv);

8414DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv);

DUK_INTERNAL_DECL

#define DUK_INTERNAL_DECL

Definition duktape-1.5.2/src-noline/duk_config.h:2541

duk_js_touint32

DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv)

Definition duktape-1.8.0/src/duktape.c:70442

duk_js_tointeger

DUK_INTERNAL_DECL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv)

Definition duktape-1.8.0/src/duktape.c:70375

◆ duk_js_greaterthan

#define duk_js_greaterthan	(	thr,
		tv_x,
		tv_y ) duk_js_compare_helper((thr), (tv_y), (tv_x), 0)

Definition at line 8425 of file duktape-1.8.0/src/duktape.c.

8425DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags);

8426DUK_INTERNAL_DECL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y);

duk_bool_t

duk_small_int_t duk_bool_t

Definition duktape-1.5.2/src-noline/duk_config.h:1825

duk_js_instanceof

DUK_INTERNAL_DECL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y)

Definition duktape-1.8.0/src/duktape.c:71136

duk_js_compare_helper

DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags)

Definition duktape-1.8.0/src/duktape.c:70942

◆ duk_js_greaterthanorequal

#define duk_js_greaterthanorequal	(	thr,
		tv_x,
		tv_y ) duk_js_compare_helper((thr), (tv_x), (tv_y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST \| DUK_COMPARE_FLAG_NEGATE)

Definition at line 8433 of file duktape-1.8.0/src/duktape.c.

8433 duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_STRICT)

8434#define duk_js_samevalue(tv_x,tv_y) \

DUK_EQUALS_FLAG_STRICT

#define DUK_EQUALS_FLAG_STRICT

Definition duktape-1.8.0/src/duktape.c:8386

duk_js_equals_helper

DUK_INTERNAL_DECL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags)

Definition duktape-1.8.0/src/duktape.c:70642

◆ DUK_JS_H_INCLUDED

#define DUK_JS_H_INCLUDED

Definition at line 8375 of file duktape-1.8.0/src/duktape.c.

◆ duk_js_lessthan

#define duk_js_lessthan	(	thr,
		tv_x,
		tv_y ) duk_js_compare_helper((thr), (tv_x), (tv_Y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST)

Definition at line 8421 of file duktape-1.8.0/src/duktape.c.

8421DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2);

8422#if 0 /* unused */

duk_js_string_compare

DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2)

Definition duktape-1.8.0/src/duktape.c:70904

◆ duk_js_lessthanorequal

#define duk_js_lessthanorequal	(	thr,
		tv_x,
		tv_y ) duk_js_compare_helper((thr), (tv_y), (tv_x), DUK_COMPARE_FLAG_NEGATE)

Definition at line 8429 of file duktape-1.8.0/src/duktape.c.

8429

8430#define duk_js_equals(thr,tv_x,tv_y) \

◆ duk_js_samevalue

#define duk_js_samevalue	(		tv_x,
			tv_y ) duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_SAMEVALUE)

Definition at line 8417 of file duktape-1.8.0/src/duktape.c.

8417DUK_INTERNAL_DECL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx);

8418DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h);

duk_uarridx_t

duk_uint_t duk_uarridx_t

Definition duktape-1.5.2/src-noline/duk_config.h:1842

duk_js_to_arrayindex_raw_string

DUK_INTERNAL_DECL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx)

Definition duktape-1.8.0/src/duktape.c:71414

duk_js_to_arrayindex_string_helper

DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h)

Definition duktape-1.8.0/src/duktape.c:71470

Referenced by duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ duk_js_strict_equals

#define duk_js_strict_equals	(		tv_x,
			tv_y ) duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_STRICT)

Definition at line 8415 of file duktape-1.8.0/src/duktape.c.

8415DUK_INTERNAL_DECL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv);

8416DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv);

duk_js_touint16

DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv)

Definition duktape-1.8.0/src/duktape.c:70460

duk_js_toint32

DUK_INTERNAL_DECL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv)

Definition duktape-1.8.0/src/duktape.c:70424

◆ DUK_JSON_DEC_REQSTACK

#define DUK_JSON_DEC_REQSTACK 32

Definition at line 8318 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_ENC_LOOPARRAY

#define DUK_JSON_ENC_LOOPARRAY 64

Definition at line 8321 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_ENC_REQSTACK

#define DUK_JSON_ENC_REQSTACK 32

Definition at line 8315 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_FLAG_ASCII_ONLY

#define DUK_JSON_FLAG_ASCII_ONLY (1 << 0) /* escape any non-ASCII characters */

Definition at line 8309 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_FLAG_AVOID_KEY_QUOTES

#define DUK_JSON_FLAG_AVOID_KEY_QUOTES (1 << 1) /* avoid key quotes when key is an ASCII Identifier */

Definition at line 8310 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_FLAG_EXT_COMPATIBLE

#define DUK_JSON_FLAG_EXT_COMPATIBLE (1 << 3) /* extended types: compatible encoding */

Definition at line 8312 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_FLAG_EXT_CUSTOM

#define DUK_JSON_FLAG_EXT_CUSTOM (1 << 2) /* extended types: custom encoding */

Definition at line 8311 of file duktape-1.8.0/src/duktape.c.

◆ DUK_JSON_H_INCLUDED

#define DUK_JSON_H_INCLUDED

Definition at line 8306 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LABEL_FLAG_ALLOW_BREAK

#define DUK_LABEL_FLAG_ALLOW_BREAK (1 << 0)

Definition at line 3238 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LABEL_FLAG_ALLOW_CONTINUE

#define DUK_LABEL_FLAG_ALLOW_CONTINUE (1 << 1)

Definition at line 3239 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LEXER_BUFFER_SIZE

#define DUK_LEXER_BUFFER_SIZE 64

Definition at line 2761 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__fill_lexer_buffer().

◆ DUK_LEXER_GETPOINT

#define DUK_LEXER_GETPOINT	(		ctx,
			pt )

Value:

do { (pt)->offset = (ctx)->window[0].offset; \

(pt)->line = (ctx)->window[0].line; } while (0)

Definition at line 2755 of file duktape-1.8.0/src/duktape.c.

2755#define DUK_LEXER_GETPOINT(ctx,pt) do { (pt)->offset = (ctx)->window[0].offset; \

2756 (pt)->line = (ctx)->window[0].line; } while (0)

Referenced by duk__parse_func_body().

◆ DUK_LEXER_H_INCLUDED

#define DUK_LEXER_H_INCLUDED

Definition at line 2728 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LEXER_INITCTX

#define DUK_LEXER_INITCTX ( ctx ) duk_lexer_initctx((ctx))

Definition at line 2751 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LEXER_SETPOINT

#define DUK_LEXER_SETPOINT	(		ctx,
			pt ) duk_lexer_setpoint((ctx), (pt))

Definition at line 2753 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK_LEXER_TEMP_BUF_LIMIT

#define DUK_LEXER_TEMP_BUF_LIMIT 256

Definition at line 3067 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__appendbuffer().

◆ DUK_LEXER_WINDOW_SIZE

#define DUK_LEXER_WINDOW_SIZE 6

Definition at line 2759 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_FLAGS_GET_LENGTH

#define DUK_LFUNC_FLAGS_GET_LENGTH ( lf_flags ) (((lf_flags) >> 4) & 0x0f)

Definition at line 850 of file duktape-1.8.0/src/duktape.c.

850#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags) \

851 (((lf_flags) >> 4) & 0x0f)

◆ DUK_LFUNC_FLAGS_GET_MAGIC

#define DUK_LFUNC_FLAGS_GET_MAGIC ( lf_flags ) ((((duk_int32_t) (lf_flags)) << 16) >> 24)

Definition at line 848 of file duktape-1.8.0/src/duktape.c.

848#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags) \

849 ((((duk_int32_t) (lf_flags)) << 16) >> 24)

◆ DUK_LFUNC_FLAGS_GET_NARGS

#define DUK_LFUNC_FLAGS_GET_NARGS ( lf_flags ) ((lf_flags) & 0x0f)

Definition at line 852 of file duktape-1.8.0/src/duktape.c.

852#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags) \

853 ((lf_flags) & 0x0f)

◆ DUK_LFUNC_FLAGS_PACK

#define DUK_LFUNC_FLAGS_PACK	(	magic,
		length,
		nargs ) (((magic) & 0xff) << 8) \| ((length) << 4) \| (nargs)

Definition at line 854 of file duktape-1.8.0/src/duktape.c.

854#define DUK_LFUNC_FLAGS_PACK(magic,length,nargs) \

855 (((magic) & 0xff) << 8) | ((length) << 4) | (nargs)

◆ DUK_LFUNC_LENGTH_MAX

#define DUK_LFUNC_LENGTH_MAX 0x0f

Definition at line 861 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_LENGTH_MIN

#define DUK_LFUNC_LENGTH_MIN 0x00

Definition at line 860 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_MAGIC_MAX

#define DUK_LFUNC_MAGIC_MAX 0x7f

Definition at line 863 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_MAGIC_MIN

#define DUK_LFUNC_MAGIC_MIN (-0x80)

Definition at line 862 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_NARGS_MAX

#define DUK_LFUNC_NARGS_MAX 0x0e /* max, excl. varargs marker */

Definition at line 859 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_NARGS_MIN

#define DUK_LFUNC_NARGS_MIN 0x00

Definition at line 858 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LFUNC_NARGS_VARARGS

#define DUK_LFUNC_NARGS_VARARGS 0x0f /* varargs marker */

Definition at line 857 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_BREAK

#define DUK_LJ_TYPE_BREAK 4 /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */

Definition at line 6734 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_CONTINUE

#define DUK_LJ_TYPE_CONTINUE 5 /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */

Definition at line 6735 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_NORMAL

#define DUK_LJ_TYPE_NORMAL 7 /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */

Definition at line 6737 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_RESUME

#define DUK_LJ_TYPE_RESUME 3 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */

Definition at line 6733 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_RETURN

#define DUK_LJ_TYPE_RETURN 6 /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */

Definition at line 6736 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_THROW

#define DUK_LJ_TYPE_THROW 1 /* value1 -> error object */

Definition at line 6731 of file duktape-1.8.0/src/duktape.c.

◆ DUK_LJ_TYPE_UNKNOWN

#define DUK_LJ_TYPE_UNKNOWN 0 /* unused */

Definition at line 6730 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_call_protected().

◆ DUK_LJ_TYPE_YIELD

#define DUK_LJ_TYPE_YIELD 2 /* value1 -> yield value, iserror -> error / normal */

Definition at line 6732 of file duktape-1.8.0/src/duktape.c.

◆ DUK_MS_FLAG_EMERGENCY

#define DUK_MS_FLAG_EMERGENCY (1 << 0) /* emergency mode: try extra hard */

Definition at line 6747 of file duktape-1.8.0/src/duktape.c.

◆ DUK_MS_FLAG_NO_FINALIZERS

#define DUK_MS_FLAG_NO_FINALIZERS (1 << 3) /* don't run finalizers; leave finalizable objects in finalize_list for next round */

Definition at line 6750 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_MS_FLAG_NO_OBJECT_COMPACTION

#define DUK_MS_FLAG_NO_OBJECT_COMPACTION (1 << 2) /* don't compact objects; needed during object property allocation resize */

Definition at line 6749 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__realloc_props().

◆ DUK_MS_FLAG_NO_STRINGTABLE_RESIZE

#define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE (1 << 1) /* don't resize stringtable (but may sweep it); needed during stringtable resize */

Definition at line 6748 of file duktape-1.8.0/src/duktape.c.

◆ DUK_MS_FLAG_SKIP_FINALIZERS

#define DUK_MS_FLAG_SKIP_FINALIZERS (1 << 4) /* don't run finalizers; queue finalizable objects back to heap_allocated */

Definition at line 6751 of file duktape-1.8.0/src/duktape.c.

◆ DUK_N2S_FLAG_FIXED_FORMAT

#define DUK_N2S_FLAG_FIXED_FORMAT (1 << 0)

Definition at line 8481 of file duktape-1.8.0/src/duktape.c.

◆ DUK_N2S_FLAG_FORCE_EXP

#define DUK_N2S_FLAG_FORCE_EXP (1 << 1)

Definition at line 8484 of file duktape-1.8.0/src/duktape.c.

◆ DUK_N2S_FLAG_FRACTION_DIGITS

#define DUK_N2S_FLAG_FRACTION_DIGITS (1 << 3)

Definition at line 8497 of file duktape-1.8.0/src/duktape.c.

◆ DUK_N2S_FLAG_NO_ZERO_PAD

#define DUK_N2S_FLAG_NO_ZERO_PAD (1 << 2)

Definition at line 8491 of file duktape-1.8.0/src/duktape.c.

◆ DUK_NUM_ALL_BUILTINS

#define DUK_NUM_ALL_BUILTINS 71

Definition at line 1709 of file duktape-1.8.0/src/duktape.c.

◆ DUK_NUM_BIDX_BUILTINS

#define DUK_NUM_BIDX_BUILTINS 71

Definition at line 1708 of file duktape-1.8.0/src/duktape.c.

◆ DUK_NUM_BUILTINS

#define DUK_NUM_BUILTINS 71

Definition at line 1707 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hthread_terminate().

◆ DUK_NUMCONV_H_INCLUDED

#define DUK_NUMCONV_H_INCLUDED

Definition at line 8471 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_ADD

#define DUK_OP_ADD 26

Definition at line 2620 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_BAND

#define DUK_OP_BAND 31

Definition at line 2625 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_BASL

#define DUK_OP_BASL 34

Definition at line 2628 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_BASR

#define DUK_OP_BASR 36

Definition at line 2630 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_BLSR

#define DUK_OP_BLSR 35

Definition at line 2629 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_BOR

#define DUK_OP_BOR 32

Definition at line 2626 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_BXOR

#define DUK_OP_BXOR 33

Definition at line 2627 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CALL

#define DUK_OP_CALL 48

Definition at line 2642 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CALLI

#define DUK_OP_CALLI 49

Definition at line 2643 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CLOSURE

#define DUK_OP_CLOSURE 20

Definition at line 2614 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_OP_CSPROP

#define DUK_OP_CSPROP 24

Definition at line 2618 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CSPROPI

#define DUK_OP_CSPROPI 25

Definition at line 2619 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CSREG

#define DUK_OP_CSREG 12

Definition at line 2606 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CSREGI

#define DUK_OP_CSREGI 13

Definition at line 2607 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CSVAR

#define DUK_OP_CSVAR 18

Definition at line 2612 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_CSVARI

#define DUK_OP_CSVARI 19

Definition at line 2613 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_DECLVAR

#define DUK_OP_DECLVAR 16

Definition at line 2610 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_OP_DELPROP

#define DUK_OP_DELPROP 23

Definition at line 2617 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_DELVAR

#define DUK_OP_DELVAR 17

Definition at line 2611 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_DIV

#define DUK_OP_DIV 29

Definition at line 2623 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_EQ

#define DUK_OP_EQ 37

Definition at line 2631 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_EXTRA

#define DUK_OP_EXTRA 51

Definition at line 2645 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_GE

#define DUK_OP_GE 42

Definition at line 2636 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_GETPROP

#define DUK_OP_GETPROP 21

Definition at line 2615 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_GETVAR

#define DUK_OP_GETVAR 14

Definition at line 2608 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_GT

#define DUK_OP_GT 41

Definition at line 2635 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_IF

#define DUK_OP_IF 45

Definition at line 2639 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__emit_invalid().

◆ DUK_OP_JUMP

#define DUK_OP_JUMP 46

Definition at line 2640 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_LDCONST

#define DUK_OP_LDCONST 2

Definition at line 2596 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK_OP_LDINT

#define DUK_OP_LDINT 3

Definition at line 2597 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__emit_load_int32().

◆ DUK_OP_LDINTX

#define DUK_OP_LDINTX 4

Definition at line 2598 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_LDREG

#define DUK_OP_LDREG 0

Definition at line 2594 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw().

◆ DUK_OP_LE

#define DUK_OP_LE 44

Definition at line 2638 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_LT

#define DUK_OP_LT 43

Definition at line 2637 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_MOD

#define DUK_OP_MOD 30

Definition at line 2624 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_MPUTARR

#define DUK_OP_MPUTARR 7

Definition at line 2601 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_MPUTARRI

#define DUK_OP_MPUTARRI 8

Definition at line 2602 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_MPUTOBJ

#define DUK_OP_MPUTOBJ 5

Definition at line 2599 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_MPUTOBJI

#define DUK_OP_MPUTOBJI 6

Definition at line 2600 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_MUL

#define DUK_OP_MUL 28

Definition at line 2622 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_NEQ

#define DUK_OP_NEQ 38

Definition at line 2632 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_NEW

#define DUK_OP_NEW 9

Definition at line 2603 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_NEWI

#define DUK_OP_NEWI 10

Definition at line 2604 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_NONE

#define DUK_OP_NONE 64 /* dummy value used as marker */

Definition at line 2658 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_POSTDECP

#define DUK_OP_POSTDECP 63

Definition at line 2657 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_POSTDECR

#define DUK_OP_POSTDECR 55

Definition at line 2649 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_POSTDECV

#define DUK_OP_POSTDECV 59

Definition at line 2653 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_POSTINCP

#define DUK_OP_POSTINCP 62

Definition at line 2656 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_POSTINCR

#define DUK_OP_POSTINCR 54

Definition at line 2648 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_POSTINCV

#define DUK_OP_POSTINCV 58

Definition at line 2652 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PREDECP

#define DUK_OP_PREDECP 61

Definition at line 2655 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PREDECR

#define DUK_OP_PREDECR 53 /* see duk_js_executor.c */

Definition at line 2647 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PREDECV

#define DUK_OP_PREDECV 57

Definition at line 2651 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PREINCP

#define DUK_OP_PREINCP 60

Definition at line 2654 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PREINCR

#define DUK_OP_PREINCR 52 /* pre/post opcode values have constraints, */

Definition at line 2646 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PREINCV

#define DUK_OP_PREINCV 56

Definition at line 2650 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PUTPROP

#define DUK_OP_PUTPROP 22

Definition at line 2616 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_PUTVAR

#define DUK_OP_PUTVAR 15

Definition at line 2609 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_var_decl().

◆ DUK_OP_REGEXP

#define DUK_OP_REGEXP 11

Definition at line 2605 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_RETURN

#define DUK_OP_RETURN 47

Definition at line 2641 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK_OP_SEQ

#define DUK_OP_SEQ 39

Definition at line 2633 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_SNEQ

#define DUK_OP_SNEQ 40

Definition at line 2634 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_STREG

#define DUK_OP_STREG 1

Definition at line 2595 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_SUB

#define DUK_OP_SUB 27

Definition at line 2621 of file duktape-1.8.0/src/duktape.c.

◆ DUK_OP_TRYCATCH

#define DUK_OP_TRYCATCH 50

Definition at line 2644 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PANIC

#define DUK_PANIC	(		code,
			msg ) duk_default_panic_handler((code),(msg))

Definition at line 7750 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PC2LINE_MAX_DIFF_LENGTH

#define DUK_PC2LINE_MAX_DIFF_LENGTH (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8)

Definition at line 5319 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PC2LINE_SKIP

#define DUK_PC2LINE_SKIP 64

Definition at line 5316 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAG_ACCESSOR

#define DUK_PROPDESC_FLAG_ACCESSOR (1 << 3) /* accessor */

Definition at line 4890 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_PROPDESC_FLAG_CONFIGURABLE

#define DUK_PROPDESC_FLAG_CONFIGURABLE (1 << 2) /* E5 Section 8.6.1 */

Definition at line 4889 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__delvar_helper(), duk__get_own_propdesc_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__realloc_props(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_PROPDESC_FLAG_ENUMERABLE

#define DUK_PROPDESC_FLAG_ENUMERABLE (1 << 1) /* E5 Section 8.6.1 */

Definition at line 4888 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__realloc_props(), and duk_hobject_define_property_helper().

◆ DUK_PROPDESC_FLAG_NO_OVERWRITE

#define DUK_PROPDESC_FLAG_NO_OVERWRITE (1 << 4) /* internal define property: skip write silently if exists */

Definition at line 4900 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_internal().

◆ DUK_PROPDESC_FLAG_VIRTUAL

#define DUK_PROPDESC_FLAG_VIRTUAL

Value:

                                                             (1 << 4)    /* property is virtual: used in duk_propdesc, never stored
                                                             * (used by e.g. buffer virtual properties)
                                                             */

Definition at line 4891 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_PROPDESC_FLAG_WRITABLE

#define DUK_PROPDESC_FLAG_WRITABLE (1 << 0) /* E5 Section 8.6.1 */

Definition at line 4887 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__putvar_helper(), duk__realloc_props(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_PROPDESC_FLAGS_C

#define DUK_PROPDESC_FLAGS_C (DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4906 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_E

#define DUK_PROPDESC_FLAGS_E (DUK_PROPDESC_FLAG_ENUMERABLE)

Definition at line 4905 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_EC

#define DUK_PROPDESC_FLAGS_EC (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4909 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_MASK

#define DUK_PROPDESC_FLAGS_MASK

Value:

                                                 (DUK_PROPDESC_FLAG_WRITABLE | \
                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \
                                                 DUK_PROPDESC_FLAG_CONFIGURABLE | \
                                                 DUK_PROPDESC_FLAG_ACCESSOR)

Definition at line 4892 of file duktape-1.8.0/src/duktape.c.

                                                             * (used by e.g. buffer virtual properties)
                                                             */
#define DUK_PROPDESC_FLAGS_MASK                 (DUK_PROPDESC_FLAG_WRITABLE | \
                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \

Referenced by duk_hobject_define_property_internal().

◆ DUK_PROPDESC_FLAGS_NONE

#define DUK_PROPDESC_FLAGS_NONE 0

Definition at line 4903 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared(), and duk_bi_string_constructor_from_char_code().

◆ DUK_PROPDESC_FLAGS_W

#define DUK_PROPDESC_FLAGS_W (DUK_PROPDESC_FLAG_WRITABLE)

Definition at line 4904 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_WC

#define DUK_PROPDESC_FLAGS_WC (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4908 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_WE

#define DUK_PROPDESC_FLAGS_WE (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE)

Definition at line 4907 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_WEC

#define DUK_PROPDESC_FLAGS_WEC

Value:

                                                 (DUK_PROPDESC_FLAG_WRITABLE | \
                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \
                                                 DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4910 of file duktape-1.8.0/src/duktape.c.

#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                  (DUK_PROPDESC_FLAG_WRITABLE | \

Referenced by duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ DUK_PROPDESC_IS_ACCESSOR

#define DUK_PROPDESC_IS_ACCESSOR ( p ) (((p)->flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0)

Definition at line 5173 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_IS_CONFIGURABLE

#define DUK_PROPDESC_IS_CONFIGURABLE ( p ) (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)

Definition at line 5172 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_IS_ENUMERABLE

#define DUK_PROPDESC_IS_ENUMERABLE ( p ) (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)

Definition at line 5171 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PROPDESC_IS_WRITABLE

#define DUK_PROPDESC_IS_WRITABLE ( p ) (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0)

Definition at line 5170 of file duktape-1.8.0/src/duktape.c.

◆ duk_push_hcompiledfunction

#define duk_push_hcompiledfunction	(		ctx,
			h ) duk_push_hobject((ctx), (duk_hobject *) (h))

Definition at line 4350 of file duktape-1.8.0/src/duktape.c.

4350#define duk_push_hcompiledfunction(ctx,h) \

4351 duk_push_hobject((ctx), (duk_hobject *) (h))

◆ duk_push_hnativefunction

#define duk_push_hnativefunction	(		ctx,
			h ) duk_push_hobject((ctx), (duk_hobject *) (h))

Definition at line 4352 of file duktape-1.8.0/src/duktape.c.

4352#define duk_push_hnativefunction(ctx,h) \

4353 duk_push_hobject((ctx), (duk_hobject *) (h))

◆ duk_push_hthread

#define duk_push_hthread	(		ctx,
			h ) duk_push_hobject((ctx), (duk_hobject *) (h))

Definition at line 4348 of file duktape-1.8.0/src/duktape.c.

4348#define duk_push_hthread(ctx,h) \

4349 duk_push_hobject((ctx), (duk_hobject *) (h))

◆ duk_push_i32

#define duk_push_i32	(		ctx,
			val ) duk_push_int((ctx), (duk_int_t) (val))

Definition at line 4287 of file duktape-1.8.0/src/duktape.c.

4287#define duk_push_i32(ctx,val) \

4288 duk_push_int((ctx), (duk_int_t) (val))

◆ duk_push_i64

#define duk_push_i64	(		ctx,
			val ) duk_push_number((ctx), (duk_double_t) (val))

Definition at line 4281 of file duktape-1.8.0/src/duktape.c.

4281#define duk_push_i64(ctx,val) \

4282 duk_push_number((ctx), (duk_double_t) (val))

Referenced by duk_bi_buffer_readfield().

◆ duk_push_idx

#define duk_push_idx	(		ctx,
			val ) duk_push_int((ctx), (duk_int_t) (val))

Definition at line 4291 of file duktape-1.8.0/src/duktape.c.

4291#define duk_push_idx(ctx,val) \

4292 duk_push_int((ctx), (duk_int_t) (val))

◆ duk_push_size_t

#define duk_push_size_t	(		ctx,
			val ) duk_push_uint((ctx), (duk_uint_t) (val)) /* XXX: assumed to fit for now */

Definition at line 4295 of file duktape-1.8.0/src/duktape.c.

4295#define duk_push_size_t(ctx,val) \

4296 duk_push_uint((ctx), (duk_uint_t) (val)) /* XXX: assumed to fit for now */

Referenced by duk_bi_duktape_object_info().

◆ DUK_PUSH_SPRINTF_INITIAL_SIZE

#define DUK_PUSH_SPRINTF_INITIAL_SIZE 256L

Definition at line 4232 of file duktape-1.8.0/src/duktape.c.

◆ DUK_PUSH_SPRINTF_SANITY_LIMIT

#define DUK_PUSH_SPRINTF_SANITY_LIMIT (1L * 1024L * 1024L * 1024L)

Definition at line 4233 of file duktape-1.8.0/src/duktape.c.

◆ duk_push_u32

#define duk_push_u32	(		ctx,
			val ) duk_push_uint((ctx), (duk_uint_t) (val))

Definition at line 4285 of file duktape-1.8.0/src/duktape.c.

4285#define duk_push_u32(ctx,val) \

4286 duk_push_uint((ctx), (duk_uint_t) (val))

Referenced by duk_hobject_define_property_helper(), and duk_hobject_get_length().

◆ duk_push_u64

#define duk_push_u64	(		ctx,
			val ) duk_push_number((ctx), (duk_double_t) (val))

Definition at line 4279 of file duktape-1.8.0/src/duktape.c.

4279#define duk_push_u64(ctx,val) \

4280 duk_push_number((ctx), (duk_double_t) (val))

◆ duk_push_uarridx

#define duk_push_uarridx	(		ctx,
			val ) duk_push_uint((ctx), (duk_uint_t) (val))

Definition at line 4293 of file duktape-1.8.0/src/duktape.c.

4293#define duk_push_uarridx(ctx,val) \

4294 duk_push_uint((ctx), (duk_uint_t) (val))

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_RAW_READ_DOUBLE_BE

#define DUK_RAW_READ_DOUBLE_BE ( ptr ) duk_raw_read_double_be(&(ptr));

Definition at line 1822 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RAW_READ_U16_BE

#define DUK_RAW_READ_U16_BE ( ptr ) duk_raw_read_u16_be(&(ptr));

Definition at line 1820 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RAW_READ_U32_BE

#define DUK_RAW_READ_U32_BE ( ptr ) duk_raw_read_u32_be(&(ptr));

Definition at line 1821 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__load_buffer_raw().

◆ DUK_RAW_READ_U8

#define DUK_RAW_READ_U8 ( ptr ) ((duk_uint8_t) (*(ptr)++))

Definition at line 1819 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RAW_WRITE_CESU8

#define DUK_RAW_WRITE_CESU8	(		ptr,
			val )

Value:

        do { \
        /* 'ptr' is evaluated both as LHS and RHS. */ \
        duk_uint8_t *duk__ptr; \
        duk_small_int_t duk__len; \
        duk__ptr = (duk_uint8_t *) (ptr); \
        duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \
        duk__ptr += duk__len; \
        (ptr) = duk__ptr; \
    } while (0)

Definition at line 1809 of file duktape-1.8.0/src/duktape.c.

#define DUK_RAW_WRITE_CESU8(ptr,val)  do { \
        /* 'ptr' is evaluated both as LHS and RHS. */ \
        duk_uint8_t *duk__ptr; \
        duk_small_int_t duk__len; \
        duk__ptr = (duk_uint8_t *) (ptr); \
        duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \
        duk__ptr += duk__len; \
        (ptr) = duk__ptr; \
    } while (0)

◆ DUK_RAW_WRITE_DOUBLE_BE

#define DUK_RAW_WRITE_DOUBLE_BE	(		ptr,
			val ) duk_raw_write_double_be(&(ptr), (duk_double_t) (val))

Definition at line 1799 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RAW_WRITE_U16_BE

#define DUK_RAW_WRITE_U16_BE	(		ptr,
			val ) duk_raw_write_u16_be(&(ptr), (duk_uint16_t) (val))

Definition at line 1797 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RAW_WRITE_U32_BE

#define DUK_RAW_WRITE_U32_BE	(		ptr,
			val ) duk_raw_write_u32_be(&(ptr), (duk_uint32_t) (val))

Definition at line 1798 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__dump_hbuffer_raw().

◆ DUK_RAW_WRITE_U8

#define DUK_RAW_WRITE_U8	(		ptr,
			val )

Value:

        do { \
        *(ptr)++ = (duk_uint8_t) (val); \
    } while (0)

Definition at line 1794 of file duktape-1.8.0/src/duktape.c.

#define DUK_RAW_WRITE_U8(ptr,val)  do { \
        *(ptr)++ = (duk_uint8_t) (val); \
    } while (0)

◆ DUK_RAW_WRITE_XUTF8

#define DUK_RAW_WRITE_XUTF8	(		ptr,
			val )

Value:

        do { \
        /* 'ptr' is evaluated both as LHS and RHS. */ \
        duk_uint8_t *duk__ptr; \
        duk_small_int_t duk__len; \
        duk__ptr = (duk_uint8_t *) (ptr); \
        duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \
        duk__ptr += duk__len; \
        (ptr) = duk__ptr; \
    } while (0)

Definition at line 1800 of file duktape-1.8.0/src/duktape.c.

#define DUK_RAW_WRITE_XUTF8(ptr,val)  do { \
        /* 'ptr' is evaluated both as LHS and RHS. */ \
        duk_uint8_t *duk__ptr; \
        duk_small_int_t duk__len; \
        duk__ptr = (duk_uint8_t *) (ptr); \
        duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \
        duk__ptr += duk__len; \
        (ptr) = duk__ptr; \
    } while (0)

◆ DUK_RE_COMPILE_TOKEN_LIMIT

#define DUK_RE_COMPILE_TOKEN_LIMIT 100000000L /* 1e8 */

Definition at line 3395 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RE_EXECUTE_STEPS_LIMIT

#define DUK_RE_EXECUTE_STEPS_LIMIT 1000000000L /* 1e9 */

Definition at line 3398 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RE_FLAG_GLOBAL

#define DUK_RE_FLAG_GLOBAL (1 << 0)

Definition at line 3422 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RE_FLAG_IGNORE_CASE

#define DUK_RE_FLAG_IGNORE_CASE (1 << 1)

Definition at line 3423 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__generate_ranges(), duk__inp_get_prev_cp(), and duk__parse_disjunction().

◆ DUK_RE_FLAG_MULTILINE

#define DUK_RE_FLAG_MULTILINE (1 << 2)

Definition at line 3424 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RE_MAX_ATOM_COPIES

#define DUK_RE_MAX_ATOM_COPIES 1000

Definition at line 3392 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RE_QUANTIFIER_INFINITE

#define DUK_RE_QUANTIFIER_INFINITE ((duk_uint32_t) 0xffffffffUL)

Definition at line 3086 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REALLOC

#define DUK_REALLOC	(	heap,
		ptr,
		newsize ) duk_heap_mem_realloc((heap), (ptr), (newsize))

Definition at line 6893 of file duktape-1.8.0/src/duktape.c.

◆ DUK_REALLOC_INDIRECT

#define DUK_REALLOC_INDIRECT	(	heap,
		cb,
		ud,
		newsize ) duk_heap_mem_realloc_indirect((heap), (cb), (ud), (newsize))

Definition at line 6894 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__resize_valstack(), and duk_hbuffer_resize().

◆ DUK_REALLOC_RAW

#define DUK_REALLOC_RAW	(	heap,
		ptr,
		newsize ) ((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize)))

Definition at line 6854 of file duktape-1.8.0/src/duktape.c.

6854

6855/*

Referenced by duk_free().

◆ DUK_REGEXP_H_INCLUDED

#define DUK_REGEXP_H_INCLUDED

Definition at line 3389 of file duktape-1.8.0/src/duktape.c.

◆ DUK_REOP_ASSERT_END

#define DUK_REOP_ASSERT_END 17

Definition at line 3417 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_ASSERT_NOT_WORD_BOUNDARY

#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY 19

Definition at line 3419 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_ASSERT_START

#define DUK_REOP_ASSERT_START 16

Definition at line 3416 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_ASSERT_WORD_BOUNDARY

#define DUK_REOP_ASSERT_WORD_BOUNDARY 18

Definition at line 3418 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_BACKREFERENCE

#define DUK_REOP_BACKREFERENCE 15

Definition at line 3415 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_CHAR

#define DUK_REOP_CHAR 2

Definition at line 3402 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_INVRANGES

#define DUK_REOP_INVRANGES 5

Definition at line 3405 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_JUMP

#define DUK_REOP_JUMP 6

Definition at line 3406 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_LOOKNEG

#define DUK_REOP_LOOKNEG 14

Definition at line 3414 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_LOOKPOS

#define DUK_REOP_LOOKPOS 13

Definition at line 3413 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_MATCH

#define DUK_REOP_MATCH 1

Definition at line 3401 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_PERIOD

#define DUK_REOP_PERIOD 3

Definition at line 3403 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_RANGES

#define DUK_REOP_RANGES 4

Definition at line 3404 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SAVE

#define DUK_REOP_SAVE 11

Definition at line 3411 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SPLIT1

#define DUK_REOP_SPLIT1 7

Definition at line 3407 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SPLIT2

#define DUK_REOP_SPLIT2 8

Definition at line 3408 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SQGREEDY

#define DUK_REOP_SQGREEDY 10

Definition at line 3410 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SQMINIMAL

#define DUK_REOP_SQMINIMAL 9

Definition at line 3409 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_WIPERANGE

#define DUK_REOP_WIPERANGE 12

Definition at line 3412 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REPLACEMENTS_H_INCLUDED

#define DUK_REPLACEMENTS_H_INCLUDED

Definition at line 162 of file duktape-1.8.0/src/duktape.c.

◆ DUK_RETOK_ASSERT_END

#define DUK_RETOK_ASSERT_END 4

Definition at line 3046 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY

#define DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY 6

Definition at line 3048 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ASSERT_START

#define DUK_RETOK_ASSERT_START 3

Definition at line 3045 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD

#define DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD 8

Definition at line 3050 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ASSERT_START_POS_LOOKAHEAD

#define DUK_RETOK_ASSERT_START_POS_LOOKAHEAD 7

Definition at line 3049 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ASSERT_WORD_BOUNDARY

#define DUK_RETOK_ASSERT_WORD_BOUNDARY 5

Definition at line 3047 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_BACKREFERENCE

#define DUK_RETOK_ATOM_BACKREFERENCE 17

Definition at line 3059 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_CHAR

#define DUK_RETOK_ATOM_CHAR 10

Definition at line 3052 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_DIGIT

#define DUK_RETOK_ATOM_DIGIT 11

Definition at line 3053 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_END_GROUP

#define DUK_RETOK_ATOM_END_GROUP 22

Definition at line 3064 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_NOT_DIGIT

#define DUK_RETOK_ATOM_NOT_DIGIT 12

Definition at line 3054 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_NOT_WHITE

#define DUK_RETOK_ATOM_NOT_WHITE 14

Definition at line 3056 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_NOT_WORD_CHAR

#define DUK_RETOK_ATOM_NOT_WORD_CHAR 16

Definition at line 3058 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_PERIOD

#define DUK_RETOK_ATOM_PERIOD 9

Definition at line 3051 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_START_CAPTURE_GROUP

#define DUK_RETOK_ATOM_START_CAPTURE_GROUP 18

Definition at line 3060 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_START_CHARCLASS

#define DUK_RETOK_ATOM_START_CHARCLASS 20

Definition at line 3062 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_START_CHARCLASS_INVERTED

#define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED 21

Definition at line 3063 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_START_NONCAPTURE_GROUP

#define DUK_RETOK_ATOM_START_NONCAPTURE_GROUP 19

Definition at line 3061 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_WHITE

#define DUK_RETOK_ATOM_WHITE 13

Definition at line 3055 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_ATOM_WORD_CHAR

#define DUK_RETOK_ATOM_WORD_CHAR 15

Definition at line 3057 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_DISJUNCTION

#define DUK_RETOK_DISJUNCTION 1

Definition at line 3043 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_EOF

#define DUK_RETOK_EOF 0

Definition at line 3042 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_QUANTIFIER

#define DUK_RETOK_QUANTIFIER 2

Definition at line 3044 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT

#define DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT (1 << 11)

Definition at line 8545 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT

#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT (1 << 12)

Definition at line 8550 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO

#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO (1 << 9)

Definition at line 8537 of file duktape-1.8.0/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_EMPTY_FRAC

#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC (1 << 8)

Definition at line 8534 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_EXP

#define DUK_S2N_FLAG_ALLOW_EXP (1 << 1)

Definition at line 8513 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__tonumber_string_raw(), and duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_FRAC

#define DUK_S2N_FLAG_ALLOW_FRAC (1 << 6)

Definition at line 8528 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_GARBAGE

#define DUK_S2N_FLAG_ALLOW_GARBAGE (1 << 2)

Definition at line 8516 of file duktape-1.8.0/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_INF

#define DUK_S2N_FLAG_ALLOW_INF (1 << 5)

Definition at line 8525 of file duktape-1.8.0/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_LEADING_ZERO

#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO (1 << 10)

Definition at line 8540 of file duktape-1.8.0/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_MINUS

#define DUK_S2N_FLAG_ALLOW_MINUS (1 << 4)

Definition at line 8522 of file duktape-1.8.0/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_NAKED_FRAC

#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC (1 << 7)

Definition at line 8531 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_PLUS

#define DUK_S2N_FLAG_ALLOW_PLUS (1 << 3)

Definition at line 8519 of file duktape-1.8.0/src/duktape.c.

◆ DUK_S2N_FLAG_TRIM_WHITE

#define DUK_S2N_FLAG_TRIM_WHITE (1 << 0)

Definition at line 8510 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__tonumber_string_raw().

◆ DUK_S2N_MAX_EXPONENT

#define DUK_S2N_MAX_EXPONENT 1000000000

Definition at line 8507 of file duktape-1.8.0/src/duktape.c.

◆ DUK_SELFTEST_H_INCLUDED

#define DUK_SELFTEST_H_INCLUDED

Definition at line 8636 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STEP_TYPE_INTO

#define DUK_STEP_TYPE_INTO 1

Definition at line 6926 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STEP_TYPE_NONE

#define DUK_STEP_TYPE_NONE 0

Definition at line 6925 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STEP_TYPE_OUT

#define DUK_STEP_TYPE_OUT 3

Definition at line 6928 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STEP_TYPE_OVER

#define DUK_STEP_TYPE_OVER 2

Definition at line 6927 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_ALLOC_FAILED

#define DUK_STR_ALLOC_FAILED duk_str_alloc_failed

Definition at line 2331 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_ARRAY_LENGTH_NOT_WRITABLE

#define DUK_STR_ARRAY_LENGTH_NOT_WRITABLE duk_str_array_length_not_writable

Definition at line 2385 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper().

◆ DUK_STR_ARRAY_LENGTH_OVER_2G

#define DUK_STR_ARRAY_LENGTH_OVER_2G duk_str_array_length_over_2g

Definition at line 2340 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_array_constructor().

◆ DUK_STR_ARRAY_LENGTH_WRITE_FAILED

#define DUK_STR_ARRAY_LENGTH_WRITE_FAILED duk_str_array_length_write_failed

Definition at line 2384 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_STR_BOUND_CHAIN_LIMIT

#define DUK_STR_BOUND_CHAIN_LIMIT duk_str_bound_chain_limit

Definition at line 2481 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_instanceof().

◆ DUK_STR_BUFFER_TOO_LONG

#define DUK_STR_BUFFER_TOO_LONG duk_str_buffer_too_long

Definition at line 2329 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_BYTECODE_LIMIT

#define DUK_STR_BYTECODE_LIMIT duk_str_bytecode_limit

Definition at line 2484 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_C_CALLSTACK_LIMIT

#define DUK_STR_C_CALLSTACK_LIMIT duk_str_c_callstack_limit

Definition at line 2482 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_CALLSTACK_LIMIT

#define DUK_STR_CALLSTACK_LIMIT duk_str_callstack_limit

Definition at line 2478 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hthread_callstack_grow().

◆ DUK_STR_CANNOT_DELETE_IDENTIFIER

#define DUK_STR_CANNOT_DELETE_IDENTIFIER duk_str_cannot_delete_identifier

Definition at line 2411 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_CATCHSTACK_LIMIT

#define DUK_STR_CATCHSTACK_LIMIT duk_str_catchstack_limit

Definition at line 2479 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_COMPILER_RECURSION_LIMIT

#define DUK_STR_COMPILER_RECURSION_LIMIT duk_str_compiler_recursion_limit

Definition at line 2483 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_CONCAT_RESULT_TOO_LONG

#define DUK_STR_CONCAT_RESULT_TOO_LONG duk_str_concat_result_too_long

Definition at line 2337 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_CONST_LIMIT

#define DUK_STR_CONST_LIMIT duk_str_const_limit

Definition at line 2487 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_CYCLIC_INPUT

#define DUK_STR_CYCLIC_INPUT duk_str_cyclic_input

Definition at line 2369 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_DECODE_FAILED

#define DUK_STR_DECODE_FAILED duk_str_decode_failed

Definition at line 2335 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_DEFAULTVALUE_COERCE_FAILED

#define DUK_STR_DEFAULTVALUE_COERCE_FAILED duk_str_defaultvalue_coerce_failed

Definition at line 2325 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_DUPLICATE_LABEL

#define DUK_STR_DUPLICATE_LABEL duk_str_duplicate_label

Definition at line 2406 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_EMPTY_EXPR_NOT_ALLOWED

#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED duk_str_empty_expr_not_allowed

Definition at line 2415 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_ENCODE_FAILED

#define DUK_STR_ENCODE_FAILED duk_str_encode_failed

Definition at line 2334 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_EXPECTED_IDENTIFIER

#define DUK_STR_EXPECTED_IDENTIFIER duk_str_expected_identifier

Definition at line 2414 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_FMT_INVALID_JSON

#define DUK_STR_FMT_INVALID_JSON duk_str_fmt_invalid_json

Definition at line 2366 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__dec_eat_white().

◆ DUK_STR_FMT_PTR

#define DUK_STR_FMT_PTR duk_str_fmt_ptr

Definition at line 2365 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_FUNC_LIMIT

#define DUK_STR_FUNC_LIMIT duk_str_func_limit

Definition at line 2488 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_FUNC_NAME_REQUIRED

#define DUK_STR_FUNC_NAME_REQUIRED duk_str_func_name_required

Definition at line 2428 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_FUNC_STMT_NOT_ALLOWED

#define DUK_STR_FUNC_STMT_NOT_ALLOWED duk_str_func_stmt_not_allowed

Definition at line 2423 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INTERNAL_ERROR

#define DUK_STR_INTERNAL_ERROR duk_str_internal_error

Definition at line 2287 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_ARG_NAME

#define DUK_STR_INVALID_ARG_NAME duk_str_invalid_arg_name

Definition at line 2425 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_STR_INVALID_ARRAY_LENGTH

#define DUK_STR_INVALID_ARRAY_LENGTH duk_str_invalid_array_length

Definition at line 2383 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_ARRAY_LITERAL

#define DUK_STR_INVALID_ARRAY_LITERAL duk_str_invalid_array_literal

Definition at line 2408 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_BACKREFS

#define DUK_STR_INVALID_BACKREFS duk_str_invalid_backrefs

Definition at line 2464 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_BASE

#define DUK_STR_INVALID_BASE duk_str_invalid_base

Definition at line 2380 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_STR_INVALID_BREAK_CONT_LABEL

#define DUK_STR_INVALID_BREAK_CONT_LABEL duk_str_invalid_break_cont_label

Definition at line 2418 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_CALL_ARGS

#define DUK_STR_INVALID_CALL_ARGS duk_str_invalid_call_args

Definition at line 2289 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__pcall_prop_raw(), duk_handle_ecma_call_setup(), and duk_is_constructor_call().

◆ DUK_STR_INVALID_CONTEXT

#define DUK_STR_INVALID_CONTEXT duk_str_invalid_context

Definition at line 2307 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_COUNT

#define DUK_STR_INVALID_COUNT duk_str_invalid_count

Definition at line 2288 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_DESCRIPTOR

#define DUK_STR_INVALID_DESCRIPTOR duk_str_invalid_descriptor

Definition at line 2388 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor().

◆ DUK_STR_INVALID_EXPRESSION

#define DUK_STR_INVALID_EXPRESSION duk_str_invalid_expression

Definition at line 2412 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_FOR

#define DUK_STR_INVALID_FOR duk_str_invalid_for

Definition at line 2416 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_FUNC_NAME

#define DUK_STR_INVALID_FUNC_NAME duk_str_invalid_func_name

Definition at line 2426 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body().

◆ DUK_STR_INVALID_GETSET_NAME

#define DUK_STR_INVALID_GETSET_NAME duk_str_invalid_getset_name

Definition at line 2427 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_INDEX

#define DUK_STR_INVALID_INDEX duk_str_invalid_call_args

Definition at line 2308 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_LABEL

#define DUK_STR_INVALID_LABEL duk_str_invalid_label

Definition at line 2407 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_LVALUE

#define DUK_STR_INVALID_LVALUE duk_str_invalid_lvalue

Definition at line 2413 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_OBJECT_LITERAL

#define DUK_STR_INVALID_OBJECT_LITERAL duk_str_invalid_object_literal

Definition at line 2409 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_QUANTIFIER_NO_ATOM

#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM duk_str_invalid_quantifier_no_atom

Definition at line 2457 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_INVALID_QUANTIFIER_VALUES

#define DUK_STR_INVALID_QUANTIFIER_VALUES duk_str_invalid_quantifier_values

Definition at line 2458 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_INVALID_REGEXP_FLAGS

#define DUK_STR_INVALID_REGEXP_FLAGS duk_str_invalid_regexp_flags

Definition at line 2463 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_RETURN

#define DUK_STR_INVALID_RETURN duk_str_invalid_return

Definition at line 2419 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_SWITCH

#define DUK_STR_INVALID_SWITCH duk_str_invalid_switch

Definition at line 2417 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_THROW

#define DUK_STR_INVALID_THROW duk_str_invalid_throw

Definition at line 2421 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_try_stmt().

◆ DUK_STR_INVALID_TRY

#define DUK_STR_INVALID_TRY duk_str_invalid_try

Definition at line 2420 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_INVALID_VAR_DECLARATION

#define DUK_STR_INVALID_VAR_DECLARATION duk_str_invalid_var_declaration

Definition at line 2410 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_JSONDEC_RECLIMIT

#define DUK_STR_JSONDEC_RECLIMIT duk_str_jsondec_reclimit

Definition at line 2367 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_JSONENC_RECLIMIT

#define DUK_STR_JSONENC_RECLIMIT duk_str_jsonenc_reclimit

Definition at line 2368 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NO_SOURCECODE

#define DUK_STR_NO_SOURCECODE duk_str_no_sourcecode

Definition at line 2336 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_BOOLEAN

#define DUK_STR_NOT_BOOLEAN duk_str_unexpected_type

Definition at line 2312 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_get_number().

◆ DUK_STR_NOT_BUFFER

#define DUK_STR_NOT_BUFFER duk_str_not_buffer /* still in use with verbose messages */

Definition at line 2317 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_require_hthread().

◆ DUK_STR_NOT_C_FUNCTION

#define DUK_STR_NOT_C_FUNCTION duk_str_unexpected_type

Definition at line 2322 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_CALLABLE

#define DUK_STR_NOT_CALLABLE duk_str_not_callable

Definition at line 2291 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_COMPILEDFUNCTION

#define DUK_STR_NOT_COMPILEDFUNCTION duk_str_unexpected_type

Definition at line 2320 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_require_hnativefunction().

◆ DUK_STR_NOT_CONFIGURABLE

#define DUK_STR_NOT_CONFIGURABLE duk_str_not_configurable

Definition at line 2294 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_CONSTRUCTABLE

#define DUK_STR_NOT_CONSTRUCTABLE duk_str_not_constructable

Definition at line 2290 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_EXTENSIBLE

#define DUK_STR_NOT_EXTENSIBLE duk_str_not_extensible

Definition at line 2292 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_STR_NOT_FUNCTION

#define DUK_STR_NOT_FUNCTION duk_str_unexpected_type

Definition at line 2323 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_get_heapptr().

◆ DUK_STR_NOT_NATIVEFUNCTION

#define DUK_STR_NOT_NATIVEFUNCTION duk_str_unexpected_type

Definition at line 2321 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_NULL

#define DUK_STR_NOT_NULL duk_str_unexpected_type

Definition at line 2311 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_NUMBER

#define DUK_STR_NOT_NUMBER duk_str_unexpected_type

Definition at line 2313 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_normalize_index().

◆ DUK_STR_NOT_OBJECT

#define DUK_STR_NOT_OBJECT duk_str_unexpected_type

Definition at line 2315 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_get_hobject_with_class().

◆ DUK_STR_NOT_OBJECT_COERCIBLE

#define DUK_STR_NOT_OBJECT_COERCIBLE duk_str_not_object_coercible

Definition at line 2327 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_POINTER

#define DUK_STR_NOT_POINTER duk_str_unexpected_type

Definition at line 2316 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_REGEXP

#define DUK_STR_NOT_REGEXP duk_str_unexpected_type

Definition at line 2324 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_STRING

#define DUK_STR_NOT_STRING duk_str_unexpected_type

Definition at line 2314 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_NOT_THREAD

#define DUK_STR_NOT_THREAD duk_str_unexpected_type

Definition at line 2319 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_require_hcompiledfunction().

◆ DUK_STR_NOT_UNDEFINED

#define DUK_STR_NOT_UNDEFINED duk_str_unexpected_type

Definition at line 2310 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_require_null().

◆ DUK_STR_NOT_WRITABLE

#define DUK_STR_NOT_WRITABLE duk_str_not_writable

Definition at line 2293 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_STR_NUMBER_OUTSIDE_RANGE

#define DUK_STR_NUMBER_OUTSIDE_RANGE duk_str_number_outside_range

Definition at line 2326 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_to_string().

◆ DUK_STR_PARSE_ERROR

#define DUK_STR_PARSE_ERROR duk_str_parse_error

Definition at line 2405 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_POP_TOO_MANY

#define DUK_STR_POP_TOO_MANY duk_str_pop_too_many

Definition at line 2332 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_PROPERTY_IS_VIRTUAL

#define DUK_STR_PROPERTY_IS_VIRTUAL duk_str_property_is_virtual

Definition at line 2389 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper().

◆ DUK_STR_PROTOTYPE_CHAIN_LIMIT

#define DUK_STR_PROTOTYPE_CHAIN_LIMIT duk_str_prototype_chain_limit

Definition at line 2480 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_propdesc(), duk_hobject_putprop(), and duk_js_instanceof().

◆ DUK_STR_PROXY_REJECTED

#define DUK_STR_PROXY_REJECTED duk_str_proxy_rejected

Definition at line 2382 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_STR_PROXY_REVOKED

#define DUK_STR_PROXY_REVOKED duk_str_proxy_revoked

Definition at line 2379 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_PUSH_BEYOND_ALLOC_STACK

#define DUK_STR_PUSH_BEYOND_ALLOC_STACK duk_str_push_beyond_alloc_stack

Definition at line 2309 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_QUANTIFIER_TOO_MANY_COPIES

#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES duk_str_quantifier_too_many_copies

Definition at line 2459 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_REDEFINE_VIRT_PROP

#define DUK_STR_REDEFINE_VIRT_PROP duk_str_redefine_virt_prop

Definition at line 2387 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_REG_LIMIT

#define DUK_STR_REG_LIMIT duk_str_reg_limit

Definition at line 2485 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT

#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT duk_str_regexp_compiler_recursion_limit

Definition at line 2489 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT

#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT duk_str_regexp_executor_recursion_limit

Definition at line 2490 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT

#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT duk_str_regexp_executor_step_limit

Definition at line 2491 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_SETTER_UNDEFINED

#define DUK_STR_SETTER_UNDEFINED duk_str_setter_undefined

Definition at line 2386 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ DUK_STR_SPRINTF_TOO_LONG

#define DUK_STR_SPRINTF_TOO_LONG duk_str_sprintf_too_long

Definition at line 2330 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_sprintf().

◆ DUK_STR_STRICT_CALLER_READ

#define DUK_STR_STRICT_CALLER_READ duk_str_strict_caller_read

Definition at line 2381 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_STRING_TOO_LONG

#define DUK_STR_STRING_TOO_LONG duk_str_string_too_long

Definition at line 2328 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_TEMP_LIMIT

#define DUK_STR_TEMP_LIMIT duk_str_temp_limit

Definition at line 2486 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__settemp_checkmax().

◆ DUK_STR_UNEXPECTED_CLOSING_PAREN

#define DUK_STR_UNEXPECTED_CLOSING_PAREN duk_str_unexpected_closing_paren

Definition at line 2460 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_UNEXPECTED_END_OF_PATTERN

#define DUK_STR_UNEXPECTED_END_OF_PATTERN duk_str_unexpected_end_of_pattern

Definition at line 2461 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_UNEXPECTED_REGEXP_TOKEN

#define DUK_STR_UNEXPECTED_REGEXP_TOKEN duk_str_unexpected_regexp_token

Definition at line 2462 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_STR_UNEXPECTED_TYPE

#define DUK_STR_UNEXPECTED_TYPE duk_str_unexpected_type

Definition at line 2318 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_is_null_or_undefined().

◆ DUK_STR_UNIMPLEMENTED

#define DUK_STR_UNIMPLEMENTED duk_str_unimplemented

Definition at line 2338 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_UNSUPPORTED

#define DUK_STR_UNSUPPORTED duk_str_unsupported

Definition at line 2339 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_UNTERMINATED_STMT

#define DUK_STR_UNTERMINATED_STMT duk_str_unterminated_stmt

Definition at line 2424 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_VALSTACK_LIMIT

#define DUK_STR_VALSTACK_LIMIT duk_str_valstack_limit

Definition at line 2477 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_WITH_IN_STRICT_MODE

#define DUK_STR_WITH_IN_STRICT_MODE duk_str_with_in_strict_mode

Definition at line 2422 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STR_WRONG_BUFFER_TYPE

#define DUK_STR_WRONG_BUFFER_TYPE duk_str_wrong_buffer_type

Definition at line 2333 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRDATA_DATA_LENGTH

#define DUK_STRDATA_DATA_LENGTH 1049

Definition at line 1472 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRDATA_MAX_STRLEN

#define DUK_STRDATA_MAX_STRLEN 17

Definition at line 1471 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_PROTO

#define DUK_STRIDX___PROTO__ 76 /* '__proto__' */

Definition at line 1114 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ARRAY

#define DUK_STRIDX_ARRAY 5 /* 'Array' */

Definition at line 901 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ARRAY_BUFFER

#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */

Definition at line 931 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_BASE64

#define DUK_STRIDX_BASE64 124 /* 'base64' */

Definition at line 1258 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_BRACKETED_ELLIPSIS

#define DUK_STRIDX_BRACKETED_ELLIPSIS 65 /* '[...]' */

Definition at line 1081 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_STRIDX_BREAK

#define DUK_STRIDX_BREAK 146 /* 'break' */

Definition at line 1324 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_BYTE_LENGTH

#define DUK_STRIDX_BYTE_LENGTH 86 /* 'byteLength' */

Definition at line 1144 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_BYTE_OFFSET

#define DUK_STRIDX_BYTE_OFFSET 87 /* 'byteOffset' */

Definition at line 1147 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_BYTES_PER_ELEMENT

#define DUK_STRIDX_BYTES_PER_ELEMENT 88 /* 'BYTES_PER_ELEMENT' */

Definition at line 1150 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CALLEE

#define DUK_STRIDX_CALLEE 68 /* 'callee' */

Definition at line 1090 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CALLER

#define DUK_STRIDX_CALLER 69 /* 'caller' */

Definition at line 1093 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CASE

#define DUK_STRIDX_CASE 147 /* 'case' */

Definition at line 1327 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CATCH

#define DUK_STRIDX_CATCH 148 /* 'catch' */

Definition at line 1330 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CLASS

#define DUK_STRIDX_CLASS 173 /* 'class' */

Definition at line 1405 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CLOG

#define DUK_STRIDX_CLOG 138 /* 'clog' */

Definition at line 1300 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_COMMA

#define DUK_STRIDX_COMMA 62 /* ',' */

Definition at line 1072 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_COMPILE

#define DUK_STRIDX_COMPILE 116 /* 'compile' */

Definition at line 1234 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CONFIGURABLE

#define DUK_STRIDX_CONFIGURABLE 36 /* 'configurable' */

Definition at line 994 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor().

◆ DUK_STRIDX_CONST

#define DUK_STRIDX_CONST 169 /* 'const' */

Definition at line 1393 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CONSTRUCTOR

#define DUK_STRIDX_CONSTRUCTOR 51 /* 'constructor' */

Definition at line 1039 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_CONTINUE

#define DUK_STRIDX_CONTINUE 149 /* 'continue' */

Definition at line 1333 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DATA

#define DUK_STRIDX_DATA 84 /* 'data' */

Definition at line 1138 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DATA_VIEW

#define DUK_STRIDX_DATA_VIEW 16 /* 'DataView' */

Definition at line 934 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DATE

#define DUK_STRIDX_DATE 9 /* 'Date' */

Definition at line 913 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DEBUGGER

#define DUK_STRIDX_DEBUGGER 150 /* 'debugger' */

Definition at line 1336 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DEC_ENV

#define DUK_STRIDX_DEC_ENV 28 /* 'DecEnv' */

Definition at line 970 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DEFAULT

#define DUK_STRIDX_DEFAULT 151 /* 'default' */

Definition at line 1339 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DEFINE_PROPERTY

#define DUK_STRIDX_DEFINE_PROPERTY 33 /* 'defineProperty' */

Definition at line 985 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DELETE

#define DUK_STRIDX_DELETE 152 /* 'delete' */

Definition at line 1342 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DELETE_PROPERTY

#define DUK_STRIDX_DELETE_PROPERTY 72 /* 'deleteProperty' */

Definition at line 1102 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_DO

#define DUK_STRIDX_DO 153 /* 'do' */

Definition at line 1345 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ELSE

#define DUK_STRIDX_ELSE 154 /* 'else' */

Definition at line 1348 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_EMPTY_STRING

#define DUK_STRIDX_EMPTY_STRING 14 /* '' */

Definition at line 928 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_string_constructor().

◆ DUK_STRIDX_END_RESERVED

#define DUK_STRIDX_END_RESERVED 191 /* exclusive endpoint */

Definition at line 1463 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_STRIDX_ENUM

#define DUK_STRIDX_ENUM 174 /* 'enum' */

Definition at line 1408 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ENUMERABLE

#define DUK_STRIDX_ENUMERABLE 37 /* 'enumerable' */

Definition at line 997 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor().

◆ DUK_STRIDX_ENUMERATE

#define DUK_STRIDX_ENUMERATE 73 /* 'enumerate' */

Definition at line 1105 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ENV

#define DUK_STRIDX_ENV 122 /* 'env' */

Definition at line 1252 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ERR_CREATE

#define DUK_STRIDX_ERR_CREATE 118 /* 'errCreate' */

Definition at line 1240 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ERR_THROW

#define DUK_STRIDX_ERR_THROW 119 /* 'errThrow' */

Definition at line 1243 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_longjmp().

◆ DUK_STRIDX_ESCAPED_EMPTY_REGEXP

#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 48 /* '(?:)' */

Definition at line 1030 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__create_escaped_source().

◆ DUK_STRIDX_EVAL

#define DUK_STRIDX_EVAL 32 /* 'eval' */

Definition at line 982 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_EXPORT

#define DUK_STRIDX_EXPORT 175 /* 'export' */

Definition at line 1411 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_EXPORTS

#define DUK_STRIDX_EXPORTS 79 /* 'exports' */

Definition at line 1123 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_EXTENDS

#define DUK_STRIDX_EXTENDS 176 /* 'extends' */

Definition at line 1414 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FALSE

#define DUK_STRIDX_FALSE 181 /* 'false' */

Definition at line 1429 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FILE_NAME

#define DUK_STRIDX_FILE_NAME 95 /* 'fileName' */

Definition at line 1171 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_js_push_closure().

◆ DUK_STRIDX_FILENAME

#define DUK_STRIDX_FILENAME 80 /* 'filename' */

Definition at line 1126 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FINALLY

#define DUK_STRIDX_FINALLY 155 /* 'finally' */

Definition at line 1351 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FLOAT32_ARRAY

#define DUK_STRIDX_FLOAT32_ARRAY 24 /* 'Float32Array' */

Definition at line 958 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FLOAT64_ARRAY

#define DUK_STRIDX_FLOAT64_ARRAY 25 /* 'Float64Array' */

Definition at line 961 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FMT

#define DUK_STRIDX_FMT 128 /* 'fmt' */

Definition at line 1270 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_FOR

#define DUK_STRIDX_FOR 156 /* 'for' */

Definition at line 1354 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_GET

#define DUK_STRIDX_GET 71 /* 'get' */

Definition at line 1099 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor().

◆ DUK_STRIDX_GLOBAL

#define DUK_STRIDX_GLOBAL 26 /* 'global' */

Definition at line 964 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_HAS

#define DUK_STRIDX_HAS 70 /* 'has' */

Definition at line 1096 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_HEX

#define DUK_STRIDX_HEX 123 /* 'hex' */

Definition at line 1255 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_ID

#define DUK_STRIDX_ID 78 /* 'id' */

Definition at line 1120 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_IF

#define DUK_STRIDX_IF 158 /* 'if' */

Definition at line 1360 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_IGNORE_CASE

#define DUK_STRIDX_IGNORE_CASE 45 /* 'ignoreCase' */

Definition at line 1021 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_IMPLEMENTS

#define DUK_STRIDX_IMPLEMENTS 182 /* 'implements' */

Definition at line 1432 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_IMPORT

#define DUK_STRIDX_IMPORT 177 /* 'import' */

Definition at line 1417 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_IN

#define DUK_STRIDX_IN 159 /* 'in' */

Definition at line 1363 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INDEX

#define DUK_STRIDX_INDEX 49 /* 'index' */

Definition at line 1033 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INFINITY

#define DUK_STRIDX_INFINITY 59 /* 'Infinity' */

Definition at line 1063 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INPUT

#define DUK_STRIDX_INPUT 117 /* 'input' */

Definition at line 1237 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INSTANCEOF

#define DUK_STRIDX_INSTANCEOF 160 /* 'instanceof' */

Definition at line 1366 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT16_ARRAY

#define DUK_STRIDX_INT16_ARRAY 20 /* 'Int16Array' */

Definition at line 946 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT32_ARRAY

#define DUK_STRIDX_INT32_ARRAY 22 /* 'Int32Array' */

Definition at line 952 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT8_ARRAY

#define DUK_STRIDX_INT8_ARRAY 17 /* 'Int8Array' */

Definition at line 937 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_ARGS

#define DUK_STRIDX_INT_ARGS 107 /* '\xffArgs' */

Definition at line 1207 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_BYTECODE

#define DUK_STRIDX_INT_BYTECODE 100 /* '\xffBytecode' */

Definition at line 1186 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_CALLEE

#define DUK_STRIDX_INT_CALLEE 111 /* '\xffCallee' */

Definition at line 1219 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_FINALIZER

#define DUK_STRIDX_INT_FINALIZER 109 /* '\xffFinalizer' */

Definition at line 1213 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__finalize_helper().

◆ DUK_STRIDX_INT_FORMALS

#define DUK_STRIDX_INT_FORMALS 101 /* '\xffFormals' */

Definition at line 1189 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_push_closure().

◆ DUK_STRIDX_INT_HANDLER

#define DUK_STRIDX_INT_HANDLER 110 /* '\xffHandler' */

Definition at line 1216 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_LEXENV

#define DUK_STRIDX_INT_LEXENV 103 /* '\xffLexenv' */

Definition at line 1195 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_MAP

#define DUK_STRIDX_INT_MAP 108 /* '\xffMap' */

Definition at line 1210 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_NEXT

#define DUK_STRIDX_INT_NEXT 99 /* '\xffNext' */

Definition at line 1183 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_PC2LINE

#define DUK_STRIDX_INT_PC2LINE 106 /* '\xffPc2line' */

Definition at line 1204 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_push_closure().

◆ DUK_STRIDX_INT_REGBASE

#define DUK_STRIDX_INT_REGBASE 113 /* '\xffRegbase' */

Definition at line 1225 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_SOURCE

#define DUK_STRIDX_INT_SOURCE 105 /* '\xffSource' */

Definition at line 1201 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_push_closure().

◆ DUK_STRIDX_INT_TARGET

#define DUK_STRIDX_INT_TARGET 114 /* '\xffTarget' */

Definition at line 1228 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_instanceof().

◆ DUK_STRIDX_INT_THIS

#define DUK_STRIDX_INT_THIS 115 /* '\xffThis' */

Definition at line 1231 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_THREAD

#define DUK_STRIDX_INT_THREAD 112 /* '\xffThread' */

Definition at line 1222 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_TRACEDATA

#define DUK_STRIDX_INT_TRACEDATA 93 /* '\xffTracedata' */

Definition at line 1165 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_STRIDX_INT_VALUE

#define DUK_STRIDX_INT_VALUE 98 /* '\xffValue' */

Definition at line 1180 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__format_parts_iso8601(), duk_bi_boolean_constructor(), and duk_bi_string_constructor_from_char_code().

◆ DUK_STRIDX_INT_VARENV

#define DUK_STRIDX_INT_VARENV 104 /* '\xffVarenv' */

Definition at line 1198 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INT_VARMAP

#define DUK_STRIDX_INT_VARMAP 102 /* '\xffVarmap' */

Definition at line 1192 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_push_closure().

◆ DUK_STRIDX_INTERFACE

#define DUK_STRIDX_INTERFACE 183 /* 'interface' */

Definition at line 1435 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_INVALID_DATE

#define DUK_STRIDX_INVALID_DATE 66 /* 'Invalid Date' */

Definition at line 1084 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JC

#define DUK_STRIDX_JC 126 /* 'jc' */

Definition at line 1264 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JOIN

#define DUK_STRIDX_JOIN 38 /* 'join' */

Definition at line 1000 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON

#define DUK_STRIDX_JSON 13 /* 'JSON' */

Definition at line 925 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON_EXT_FUNCTION1

#define DUK_STRIDX_JSON_EXT_FUNCTION1 144 /* '{"_func":true}' */

Definition at line 1318 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON_EXT_FUNCTION2

#define DUK_STRIDX_JSON_EXT_FUNCTION2 145 /* '{_func:true}' */

Definition at line 1321 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON_EXT_NAN

#define DUK_STRIDX_JSON_EXT_NAN 141 /* '{"_nan":true}' */

Definition at line 1309 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON_EXT_NEGINF

#define DUK_STRIDX_JSON_EXT_NEGINF 143 /* '{"_ninf":true}' */

Definition at line 1315 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON_EXT_POSINF

#define DUK_STRIDX_JSON_EXT_POSINF 142 /* '{"_inf":true}' */

Definition at line 1312 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JSON_EXT_UNDEFINED

#define DUK_STRIDX_JSON_EXT_UNDEFINED 140 /* '{"_undef":true}' */

Definition at line 1306 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_JX

#define DUK_STRIDX_JX 125 /* 'jx' */

Definition at line 1261 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LAST_INDEX

#define DUK_STRIDX_LAST_INDEX 47 /* 'lastIndex' */

Definition at line 1027 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_ARGUMENTS

#define DUK_STRIDX_LC_ARGUMENTS 67 /* 'arguments' */

Definition at line 1087 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ DUK_STRIDX_LC_BOOLEAN

#define DUK_STRIDX_LC_BOOLEAN 53 /* 'boolean' */

Definition at line 1045 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_BUFFER

#define DUK_STRIDX_LC_BUFFER 96 /* 'buffer' */

Definition at line 1174 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ DUK_STRIDX_LC_DEBUG

#define DUK_STRIDX_LC_DEBUG 131 /* 'debug' */

Definition at line 1279 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_ERROR

#define DUK_STRIDX_LC_ERROR 134 /* 'error' */

Definition at line 1288 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_FATAL

#define DUK_STRIDX_LC_FATAL 135 /* 'fatal' */

Definition at line 1291 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_FUNCTION

#define DUK_STRIDX_LC_FUNCTION 157 /* 'function' */

Definition at line 1357 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_INFO

#define DUK_STRIDX_LC_INFO 132 /* 'info' */

Definition at line 1282 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_L

#define DUK_STRIDX_LC_L 137 /* 'l' */

Definition at line 1297 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_N

#define DUK_STRIDX_LC_N 136 /* 'n' */

Definition at line 1294 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_logger_prototype_fmt().

◆ DUK_STRIDX_LC_NULL

#define DUK_STRIDX_LC_NULL 179 /* 'null' */

Definition at line 1423 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_NUMBER

#define DUK_STRIDX_LC_NUMBER 54 /* 'number' */

Definition at line 1048 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_OBJECT

#define DUK_STRIDX_LC_OBJECT 56 /* 'object' */

Definition at line 1054 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_POINTER

#define DUK_STRIDX_LC_POINTER 97 /* 'pointer' */

Definition at line 1177 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_STRING

#define DUK_STRIDX_LC_STRING 55 /* 'string' */

Definition at line 1051 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_TRACE

#define DUK_STRIDX_LC_TRACE 130 /* 'trace' */

Definition at line 1276 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_UNDEFINED

#define DUK_STRIDX_LC_UNDEFINED 57 /* 'undefined' */

Definition at line 1057 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LC_WARN

#define DUK_STRIDX_LC_WARN 133 /* 'warn' */

Definition at line 1285 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LENGTH

#define DUK_STRIDX_LENGTH 85 /* 'length' */

Definition at line 1141 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__push_this_obj_len_u32_limited(), and duk_hobject_get_length().

◆ DUK_STRIDX_LET

#define DUK_STRIDX_LET 184 /* 'let' */

Definition at line 1438 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_LINE_NUMBER

#define DUK_STRIDX_LINE_NUMBER 92 /* 'lineNumber' */

Definition at line 1162 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MATH

#define DUK_STRIDX_MATH 12 /* 'Math' */

Definition at line 922 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MESSAGE

#define DUK_STRIDX_MESSAGE 52 /* 'message' */

Definition at line 1042 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MINUS_INFINITY

#define DUK_STRIDX_MINUS_INFINITY 60 /* '-Infinity' */

Definition at line 1066 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MINUS_ZERO

#define DUK_STRIDX_MINUS_ZERO 61 /* '-0' */

Definition at line 1069 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MOD_LOADED

#define DUK_STRIDX_MOD_LOADED 121 /* 'modLoaded' */

Definition at line 1249 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MOD_SEARCH

#define DUK_STRIDX_MOD_SEARCH 120 /* 'modSearch' */

Definition at line 1246 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_MULTILINE

#define DUK_STRIDX_MULTILINE 46 /* 'multiline' */

Definition at line 1024 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_NAME

#define DUK_STRIDX_NAME 94 /* 'name' */

Definition at line 1168 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_js_push_closure().

◆ DUK_STRIDX_NAN

#define DUK_STRIDX_NAN 58 /* 'NaN' */

Definition at line 1060 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_NEW

#define DUK_STRIDX_NEW 161 /* 'new' */

Definition at line 1369 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_NEWLINE_4SPACE

#define DUK_STRIDX_NEWLINE_4SPACE 64 /* '\n ' */

Definition at line 1078 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_STRIDX_OBJ_ENV

#define DUK_STRIDX_OBJ_ENV 27 /* 'ObjEnv' */

Definition at line 967 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_OWN_KEYS

#define DUK_STRIDX_OWN_KEYS 74 /* 'ownKeys' */

Definition at line 1108 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_PACKAGE

#define DUK_STRIDX_PACKAGE 185 /* 'package' */

Definition at line 1441 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_PC

#define DUK_STRIDX_PC 91 /* 'pc' */

Definition at line 1159 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_PRIVATE

#define DUK_STRIDX_PRIVATE 186 /* 'private' */

Definition at line 1444 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_PROTECTED

#define DUK_STRIDX_PROTECTED 187 /* 'protected' */

Definition at line 1447 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_PROTOTYPE

#define DUK_STRIDX_PROTOTYPE 50 /* 'prototype' */

Definition at line 1036 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_instanceof().

◆ DUK_STRIDX_PUBLIC

#define DUK_STRIDX_PUBLIC 188 /* 'public' */

Definition at line 1450 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_RAW

#define DUK_STRIDX_RAW 129 /* 'raw' */

Definition at line 1273 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_REG_EXP

#define DUK_STRIDX_REG_EXP 10 /* 'RegExp' */

Definition at line 916 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_REQUIRE

#define DUK_STRIDX_REQUIRE 77 /* 'require' */

Definition at line 1117 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_RESUME

#define DUK_STRIDX_RESUME 127 /* 'resume' */

Definition at line 1267 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_RETURN

#define DUK_STRIDX_RETURN 162 /* 'return' */

Definition at line 1372 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_SET

#define DUK_STRIDX_SET 89 /* 'set' */

Definition at line 1153 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor(), and duk_hobject_putprop().

◆ DUK_STRIDX_SET_PROTOTYPE_OF

#define DUK_STRIDX_SET_PROTOTYPE_OF 75 /* 'setPrototypeOf' */

Definition at line 1111 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_SOURCE

#define DUK_STRIDX_SOURCE 44 /* 'source' */

Definition at line 1018 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_SPACE

#define DUK_STRIDX_SPACE 63 /* ' ' */

Definition at line 1075 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_STACK

#define DUK_STRIDX_STACK 90 /* 'stack' */

Definition at line 1156 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_START_RESERVED

#define DUK_STRIDX_START_RESERVED 146

Definition at line 1461 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_STRIDX_START_STRICT_RESERVED

#define DUK_STRIDX_START_STRICT_RESERVED 182

Definition at line 1462 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_STRIDX_STATIC

#define DUK_STRIDX_STATIC 189 /* 'static' */

Definition at line 1453 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_SUPER

#define DUK_STRIDX_SUPER 178 /* 'super' */

Definition at line 1420 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_SWITCH

#define DUK_STRIDX_SWITCH 163 /* 'switch' */

Definition at line 1375 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_THIS

#define DUK_STRIDX_THIS 164 /* 'this' */

Definition at line 1378 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_THROW

#define DUK_STRIDX_THROW 165 /* 'throw' */

Definition at line 1381 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TO_GMT_STRING

#define DUK_STRIDX_TO_GMT_STRING 43 /* 'toGMTString' */

Definition at line 1015 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TO_ISO_STRING

#define DUK_STRIDX_TO_ISO_STRING 42 /* 'toISOString' */

Definition at line 1012 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TO_JSON

#define DUK_STRIDX_TO_JSON 82 /* 'toJSON' */

Definition at line 1132 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TO_LOCALE_STRING

#define DUK_STRIDX_TO_LOCALE_STRING 39 /* 'toLocaleString' */

Definition at line 1003 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TO_LOG_STRING

#define DUK_STRIDX_TO_LOG_STRING 139 /* 'toLogString' */

Definition at line 1303 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TO_STRING

#define DUK_STRIDX_TO_STRING 81 /* 'toString' */

Definition at line 1129 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_object_prototype_is_prototype_of(), and duk_to_undefined().

◆ DUK_STRIDX_TO_TOK

#define DUK_STRIDX_TO_TOK ( x ) ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED)

Definition at line 2897 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_STRIDX_TO_UTC_STRING

#define DUK_STRIDX_TO_UTC_STRING 41 /* 'toUTCString' */

Definition at line 1009 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TRUE

#define DUK_STRIDX_TRUE 180 /* 'true' */

Definition at line 1426 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TRY

#define DUK_STRIDX_TRY 166 /* 'try' */

Definition at line 1384 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TYPE

#define DUK_STRIDX_TYPE 83 /* 'type' */

Definition at line 1135 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_TYPEOF

#define DUK_STRIDX_TYPEOF 167 /* 'typeof' */

Definition at line 1387 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_ARGUMENTS

#define DUK_STRIDX_UC_ARGUMENTS 2 /* 'Arguments' */

Definition at line 892 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_BOOLEAN

#define DUK_STRIDX_UC_BOOLEAN 7 /* 'Boolean' */

Definition at line 907 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_BUFFER

#define DUK_STRIDX_UC_BUFFER 29 /* 'Buffer' */

Definition at line 973 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_ERROR

#define DUK_STRIDX_UC_ERROR 11 /* 'Error' */

Definition at line 919 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_FUNCTION

#define DUK_STRIDX_UC_FUNCTION 4 /* 'Function' */

Definition at line 898 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_NULL

#define DUK_STRIDX_UC_NULL 1 /* 'Null' */

Definition at line 889 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_NUMBER

#define DUK_STRIDX_UC_NUMBER 8 /* 'Number' */

Definition at line 910 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_OBJECT

#define DUK_STRIDX_UC_OBJECT 3 /* 'Object' */

Definition at line 895 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_POINTER

#define DUK_STRIDX_UC_POINTER 30 /* 'Pointer' */

Definition at line 976 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_STRING

#define DUK_STRIDX_UC_STRING 6 /* 'String' */

Definition at line 904 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_THREAD

#define DUK_STRIDX_UC_THREAD 31 /* 'Thread' */

Definition at line 979 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UC_UNDEFINED

#define DUK_STRIDX_UC_UNDEFINED 0 /* 'Undefined' */

Definition at line 886 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UINT16_ARRAY

#define DUK_STRIDX_UINT16_ARRAY 21 /* 'Uint16Array' */

Definition at line 949 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UINT32_ARRAY

#define DUK_STRIDX_UINT32_ARRAY 23 /* 'Uint32Array' */

Definition at line 955 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UINT8_ARRAY

#define DUK_STRIDX_UINT8_ARRAY 18 /* 'Uint8Array' */

Definition at line 940 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_UINT8_CLAMPED_ARRAY

#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 19 /* 'Uint8ClampedArray' */

Definition at line 943 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_VALUE

#define DUK_STRIDX_VALUE 34 /* 'value' */

Definition at line 988 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor().

◆ DUK_STRIDX_VALUE_OF

#define DUK_STRIDX_VALUE_OF 40 /* 'valueOf' */

Definition at line 1006 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_to_undefined().

◆ DUK_STRIDX_VAR

#define DUK_STRIDX_VAR 168 /* 'var' */

Definition at line 1390 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_VOID

#define DUK_STRIDX_VOID 170 /* 'void' */

Definition at line 1396 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_WHILE

#define DUK_STRIDX_WHILE 171 /* 'while' */

Definition at line 1399 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_WITH

#define DUK_STRIDX_WITH 172 /* 'with' */

Definition at line 1402 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRIDX_WRITABLE

#define DUK_STRIDX_WRITABLE 35 /* 'writable' */

Definition at line 991 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_prepare_property_descriptor().

◆ DUK_STRIDX_YIELD

#define DUK_STRIDX_YIELD 190 /* 'yield' */

Definition at line 1456 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_CHAIN_SIZE

#define DUK_STRTAB_CHAIN_SIZE DUK_USE_STRTAB_CHAIN_SIZE

Definition at line 6827 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_DELETED_MARKER

#define DUK_STRTAB_DELETED_MARKER ( heap ) ((duk_hstring *) heap)

Definition at line 6812 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_GROW_ST_SIZE

#define DUK_STRTAB_GROW_ST_SIZE ( n ) ((n) + (n)) /* used entries + approx 100% -> reset load to 50% */

Definition at line 6817 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_HASH_INITIAL

#define DUK_STRTAB_HASH_INITIAL	(		hash,
			h_size ) ((hash) % (h_size))

Definition at line 6823 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_HASH_PROBE_STEP

#define DUK_STRTAB_HASH_PROBE_STEP ( hash ) DUK_UTIL_GET_HASH_PROBE_STEP((hash))

Definition at line 6824 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_HIGHEST_32BIT_PRIME

#define DUK_STRTAB_HIGHEST_32BIT_PRIME 0xfffffffbUL

Definition at line 6820 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__recheck_strtab_size_probe().

◆ DUK_STRTAB_INITIAL_SIZE

#define DUK_STRTAB_INITIAL_SIZE 17

Definition at line 6809 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_MIN_FREE_DIVISOR

#define DUK_STRTAB_MIN_FREE_DIVISOR 4 /* load factor max 75% */

Definition at line 6815 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_MIN_USED_DIVISOR

#define DUK_STRTAB_MIN_USED_DIVISOR 4 /* load factor min 25% */

Definition at line 6816 of file duktape-1.8.0/src/duktape.c.

◆ DUK_STRTAB_U32_MAX_STRLEN

#define DUK_STRTAB_U32_MAX_STRLEN 10 /* 4'294'967'295 */

Definition at line 6819 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_heap_string_intern_u32_checked().

◆ DUK_TAG_BOOLEAN

#define DUK_TAG_BOOLEAN 4

Definition at line 649 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TAG_BUFFER

#define DUK_TAG_BUFFER 10

Definition at line 655 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), duk_hobject_putprop(), duk_js_toboolean(), and duk_require_hthread().

◆ DUK_TAG_LIGHTFUNC

#define DUK_TAG_LIGHTFUNC 6

Definition at line 651 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__ispec_toregconst_raw(), duk_hobject_putprop(), duk_is_function(), and duk_js_toboolean().

◆ DUK_TAG_NULL

#define DUK_TAG_NULL 3

Definition at line 648 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__ispec_toregconst_raw(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TAG_OBJECT

#define DUK_TAG_OBJECT 9

Definition at line 654 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__ispec_toregconst_raw(), duk_get_c_function(), duk_get_hcompiledfunction(), duk_get_hnativefunction(), duk_hobject_putprop(), duk_js_toboolean(), duk_require_hbuffer(), duk_require_hcompiledfunction(), and duk_require_hnativefunction().

◆ DUK_TAG_POINTER

#define DUK_TAG_POINTER 5

Definition at line 650 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TAG_STRING

#define DUK_TAG_STRING 8 /* first heap allocated, match bit boundary */

Definition at line 653 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), duk_hobject_putprop(), duk_is_buffer_data(), duk_js_toboolean(), and duk_require_hobject().

◆ DUK_TAG_UNDEFINED

#define DUK_TAG_UNDEFINED 2

Definition at line 647 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__ispec_toregconst_raw(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TAG_UNUSED

#define DUK_TAG_UNUSED 7 /* marker; not actual tagged type */

Definition at line 652 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TB_FLAG_NOBLAME_FILELINE

#define DUK_TB_FLAG_NOBLAME_FILELINE (1 << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */

Definition at line 6027 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_TOK_ADD

#define DUK_TOK_ADD 66

Definition at line 2855 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_ADD_EQ

#define DUK_TOK_ADD_EQ 86

Definition at line 2875 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_ALSHIFT

#define DUK_TOK_ALSHIFT 73 /* named "arithmetic" because result is signed */

Definition at line 2862 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_ALSHIFT_EQ

#define DUK_TOK_ALSHIFT_EQ 91

Definition at line 2880 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_ARSHIFT

#define DUK_TOK_ARSHIFT 74

Definition at line 2863 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_ARSHIFT_EQ

#define DUK_TOK_ARSHIFT_EQ 92

Definition at line 2881 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BAND

#define DUK_TOK_BAND 76

Definition at line 2865 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BAND_EQ

#define DUK_TOK_BAND_EQ 94

Definition at line 2883 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BNOT

#define DUK_TOK_BNOT 80

Definition at line 2869 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BOR

#define DUK_TOK_BOR 77

Definition at line 2866 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BOR_EQ

#define DUK_TOK_BOR_EQ 95

Definition at line 2884 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BREAK

#define DUK_TOK_BREAK 2

Definition at line 2774 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_BXOR

#define DUK_TOK_BXOR 78

Definition at line 2867 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_BXOR_EQ

#define DUK_TOK_BXOR_EQ 96

Definition at line 2885 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_CASE

#define DUK_TOK_CASE 3

Definition at line 2775 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_CATCH

#define DUK_TOK_CATCH 4

Definition at line 2776 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_CLASS

#define DUK_TOK_CLASS 29

Definition at line 2803 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_COLON

#define DUK_TOK_COLON 84

Definition at line 2873 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_COMMA

#define DUK_TOK_COMMA 57

Definition at line 2846 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_for_stmt(), duk__parse_func_formals(), and duk_lexer_parse_js_input_element().

◆ DUK_TOK_CONST

#define DUK_TOK_CONST 25

Definition at line 2797 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_CONTINUE

#define DUK_TOK_CONTINUE 5

Definition at line 2777 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_DEBUGGER

#define DUK_TOK_DEBUGGER 6

Definition at line 2778 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_DECREMENT

#define DUK_TOK_DECREMENT 72

Definition at line 2861 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_DEFAULT

#define DUK_TOK_DEFAULT 7

Definition at line 2779 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_DELETE

#define DUK_TOK_DELETE 8

Definition at line 2780 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_DIV

#define DUK_TOK_DIV 69

Definition at line 2858 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_DIV_EQ

#define DUK_TOK_DIV_EQ 89

Definition at line 2878 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_DO

#define DUK_TOK_DO 9

Definition at line 2781 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_ELSE

#define DUK_TOK_ELSE 10

Definition at line 2782 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_END_RESERVED

#define DUK_TOK_END_RESERVED 47 /* exclusive */

Definition at line 2829 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_ENUM

#define DUK_TOK_ENUM 30

Definition at line 2804 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_EOF

#define DUK_TOK_EOF 0

Definition at line 2767 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_EQ

#define DUK_TOK_EQ 62

Definition at line 2851 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_EQUALSIGN

#define DUK_TOK_EQUALSIGN 85

Definition at line 2874 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_var_decl(), and duk_lexer_parse_js_input_element().

◆ DUK_TOK_EXPORT

#define DUK_TOK_EXPORT 31

Definition at line 2805 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_EXTENDS

#define DUK_TOK_EXTENDS 32

Definition at line 2806 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_FALSE

#define DUK_TOK_FALSE 37

Definition at line 2815 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_FINALLY

#define DUK_TOK_FINALLY 11

Definition at line 2783 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_FOR

#define DUK_TOK_FOR 12

Definition at line 2784 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_FUNCTION

#define DUK_TOK_FUNCTION 13

Definition at line 2785 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_GE

#define DUK_TOK_GE 61

Definition at line 2850 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_GET

#define DUK_TOK_GET 47

Definition at line 2834 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_GT

#define DUK_TOK_GT 59

Definition at line 2848 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_IDENTIFIER

#define DUK_TOK_IDENTIFIER 1

Definition at line 2770 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_formals(), duk__parse_var_decl(), and duk_lexer_parse_js_input_element().

◆ DUK_TOK_IF

#define DUK_TOK_IF 14

Definition at line 2786 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_IMPLEMENTS

#define DUK_TOK_IMPLEMENTS 38

Definition at line 2819 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_IMPORT

#define DUK_TOK_IMPORT 33

Definition at line 2807 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_IN

#define DUK_TOK_IN 15

Definition at line 2787 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_INCREMENT

#define DUK_TOK_INCREMENT 71

Definition at line 2860 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_INSTANCEOF

#define DUK_TOK_INSTANCEOF 16

Definition at line 2788 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_INTERFACE

#define DUK_TOK_INTERFACE 39

Definition at line 2820 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_LAND

#define DUK_TOK_LAND 81

Definition at line 2870 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LBRACKET

#define DUK_TOK_LBRACKET 51

Definition at line 2840 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LCURLY

#define DUK_TOK_LCURLY 49

Definition at line 2838 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_body(), and duk_lexer_parse_js_input_element().

◆ DUK_TOK_LE

#define DUK_TOK_LE 60

Definition at line 2849 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LET

#define DUK_TOK_LET 40

Definition at line 2821 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_LNOT

#define DUK_TOK_LNOT 79

Definition at line 2868 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LOR

#define DUK_TOK_LOR 82

Definition at line 2871 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LPAREN

#define DUK_TOK_LPAREN 53

Definition at line 2842 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LT

#define DUK_TOK_LT 58

Definition at line 2847 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_MAXVAL

#define DUK_TOK_MAXVAL 99 /* inclusive */

Definition at line 2894 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_MINVAL

#define DUK_TOK_MINVAL 0

Definition at line 2764 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_MOD

#define DUK_TOK_MOD 70

Definition at line 2859 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_MOD_EQ

#define DUK_TOK_MOD_EQ 90

Definition at line 2879 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_MUL

#define DUK_TOK_MUL 68

Definition at line 2857 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_MUL_EQ

#define DUK_TOK_MUL_EQ 88

Definition at line 2877 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_NEQ

#define DUK_TOK_NEQ 63

Definition at line 2852 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_NEW

#define DUK_TOK_NEW 17

Definition at line 2789 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_NULL

#define DUK_TOK_NULL 35

Definition at line 2813 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_NUMBER

#define DUK_TOK_NUMBER 97

Definition at line 2890 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_PACKAGE

#define DUK_TOK_PACKAGE 41

Definition at line 2822 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_PERIOD

#define DUK_TOK_PERIOD 55

Definition at line 2844 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_PRIVATE

#define DUK_TOK_PRIVATE 42

Definition at line 2823 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_PROTECTED

#define DUK_TOK_PROTECTED 43

Definition at line 2824 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_PUBLIC

#define DUK_TOK_PUBLIC 44

Definition at line 2825 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_QUESTION

#define DUK_TOK_QUESTION 83

Definition at line 2872 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_RBRACKET

#define DUK_TOK_RBRACKET 52

Definition at line 2841 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_RCURLY

#define DUK_TOK_RCURLY 50

Definition at line 2839 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_REGEXP

#define DUK_TOK_REGEXP 99

Definition at line 2892 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_RETURN

#define DUK_TOK_RETURN 18

Definition at line 2790 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_RPAREN

#define DUK_TOK_RPAREN 54

Definition at line 2843 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_func_formals(), and duk_lexer_parse_js_input_element().

◆ DUK_TOK_RSHIFT

#define DUK_TOK_RSHIFT 75

Definition at line 2864 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_RSHIFT_EQ

#define DUK_TOK_RSHIFT_EQ 93

Definition at line 2882 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_SEMICOLON

#define DUK_TOK_SEMICOLON 56

Definition at line 2845 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_SEQ

#define DUK_TOK_SEQ 64

Definition at line 2853 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_SET

#define DUK_TOK_SET 48

Definition at line 2835 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_SNEQ

#define DUK_TOK_SNEQ 65

Definition at line 2854 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_START_RESERVED

#define DUK_TOK_START_RESERVED 2

Definition at line 2773 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_START_STRICT_RESERVED

#define DUK_TOK_START_STRICT_RESERVED 38 /* inclusive */

Definition at line 2818 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_STATIC

#define DUK_TOK_STATIC 45

Definition at line 2826 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_STRING

#define DUK_TOK_STRING 98

Definition at line 2891 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_SUB

#define DUK_TOK_SUB 67

Definition at line 2856 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_SUB_EQ

#define DUK_TOK_SUB_EQ 87

Definition at line 2876 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_SUPER

#define DUK_TOK_SUPER 34

Definition at line 2808 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_SWITCH

#define DUK_TOK_SWITCH 19

Definition at line 2791 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_THIS

#define DUK_TOK_THIS 20

Definition at line 2792 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_THROW

#define DUK_TOK_THROW 21

Definition at line 2793 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_TRUE

#define DUK_TOK_TRUE 36

Definition at line 2814 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_TRY

#define DUK_TOK_TRY 22

Definition at line 2794 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_TYPEOF

#define DUK_TOK_TYPEOF 23

Definition at line 2795 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_VAR

#define DUK_TOK_VAR 24

Definition at line 2796 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_VOID

#define DUK_TOK_VOID 26

Definition at line 2798 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_WHILE

#define DUK_TOK_WHILE 27

Definition at line 2799 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_WITH

#define DUK_TOK_WITH 28

Definition at line 2800 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TOK_YIELD

#define DUK_TOK_YIELD 46

Definition at line 2827 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_CHKFAST_INPLACE

#define DUK_TVAL_CHKFAST_INPLACE ( v ) do { } while (0)

Definition at line 726 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_DECREF

#define DUK_TVAL_DECREF	(		thr,
			tv ) DUK_TVAL_DECREF_FAST((thr),(tv))

Definition at line 3826 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_define_property_helper().

◆ DUK_TVAL_DECREF_FAST

#define DUK_TVAL_DECREF_FAST	(		thr,
			tv )

Value:

        do { \
        duk_tval *duk__tv = (tv); \
        DUK_ASSERT(duk__tv != NULL); \
        if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
            duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
            DUK_ASSERT(duk__h != NULL); \
            DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
            DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
            if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
                duk_heaphdr_refzero((thr), duk__h); \
            } \
        } \
    } while (0)

Definition at line 3771 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
        duk_tval *duk__tv = (tv); \
        DUK_ASSERT(duk__tv != NULL); \
        if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
            duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
            DUK_ASSERT(duk__h != NULL); \
            DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
            DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
            if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
                duk_heaphdr_refzero((thr), duk__h); \
            } \
        } \
    } while (0)

◆ DUK_TVAL_DECREF_SLOW

#define DUK_TVAL_DECREF_SLOW	(		thr,
			tv )

Value:

        do { \
        duk_tval_decref((thr), (tv)); \
    } while (0)

Definition at line 3810 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \
        duk_tval_decref((thr), (tv)); \
    } while (0)

◆ DUK_TVAL_GET_BOOLEAN

#define DUK_TVAL_GET_BOOLEAN ( tv ) ((tv)->v.i)

Definition at line 764 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), duk_get_number(), and duk_js_toboolean().

◆ DUK_TVAL_GET_BUFFER

#define DUK_TVAL_GET_BUFFER ( tv ) ((tv)->v.hbuffer)

Definition at line 794 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TVAL_GET_DOUBLE

#define DUK_TVAL_GET_DOUBLE ( tv ) ((tv)->v.d)

Definition at line 783 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_toboolean(), and duk_js_tointeger_number().

◆ DUK_TVAL_GET_HEAPHDR

#define DUK_TVAL_GET_HEAPHDR ( tv ) ((tv)->v.heaphdr)

Definition at line 795 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_buffer_helper(), duk_bi_duktape_object_info(), duk_require_heapptr(), and duk_tval_decref().

◆ DUK_TVAL_GET_LIGHTFUNC

#define DUK_TVAL_GET_LIGHTFUNC	(	tv,
		out_fp,
		out_flags )

Value:

        do { \
        (out_flags) = (duk_uint32_t) (tv)->v_extra; \
        (out_fp) = (tv)->v.lightfunc; \
    } while (0)

Definition at line 786 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_GET_LIGHTFUNC(tv,out_fp,out_flags)  do { \
        (out_flags) = (duk_uint32_t) (tv)->v_extra; \
        (out_fp) = (tv)->v.lightfunc; \
    } while (0)

◆ DUK_TVAL_GET_LIGHTFUNC_FLAGS

#define DUK_TVAL_GET_LIGHTFUNC_FLAGS ( tv ) ((duk_uint32_t) ((tv)->v_extra))

Definition at line 791 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_GET_LIGHTFUNC_FUNCPTR

#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR ( tv ) ((tv)->v.lightfunc)

Definition at line 790 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_GET_NUMBER

#define DUK_TVAL_GET_NUMBER ( tv ) ((tv)->v.d)

Definition at line 782 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs(), and duk__ispec_toregconst_raw().

◆ DUK_TVAL_GET_OBJECT

#define DUK_TVAL_GET_OBJECT ( tv ) ((tv)->v.hobject)

Definition at line 793 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__getid_open_decl_env_regs(), duk_bi_boolean_prototype_tostring_shared(), duk_get_hobject_with_class(), and duk_hobject_putprop().

◆ DUK_TVAL_GET_POINTER

#define DUK_TVAL_GET_POINTER ( tv ) ((tv)->v.voidptr)

Definition at line 785 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_js_toboolean().

◆ DUK_TVAL_GET_STRING

#define DUK_TVAL_GET_STRING ( tv ) ((tv)->v.hstring)

Definition at line 792 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__ispec_toregconst_raw(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TVAL_GET_TAG

#define DUK_TVAL_GET_TAG ( tv ) ((tv)->t)

Definition at line 798 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__ispec_toregconst_raw(), duk_bi_duktape_object_info(), duk_hobject_putprop(), and duk_js_toboolean().

◆ DUK_TVAL_H_INCLUDED

#define DUK_TVAL_H_INCLUDED

Definition at line 378 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_INCREF

#define DUK_TVAL_INCREF	(		thr,
			tv ) DUK_TVAL_INCREF_FAST((thr),(tv))

Definition at line 3825 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__inc_data_inner_refcounts(), duk_dup_top(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_TVAL_INCREF_FAST

#define DUK_TVAL_INCREF_FAST	(		thr,
			tv )

Value:

        do { \
        duk_tval *duk__tv = (tv); \
        DUK_ASSERT(duk__tv != NULL); \
        if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
            duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
            DUK_ASSERT(duk__h != NULL); \
            DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
            DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
        } \
    } while (0)

Definition at line 3761 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_INCREF_FAST(thr,tv) do { \
        duk_tval *duk__tv = (tv); \
        DUK_ASSERT(duk__tv != NULL); \
        if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
            duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
            DUK_ASSERT(duk__h != NULL); \
            DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
            DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
        } \
    } while (0)

◆ DUK_TVAL_INCREF_SLOW

#define DUK_TVAL_INCREF_SLOW	(		thr,
			tv )

Value:

        do { \
        duk_tval_incref((tv)); \
    } while (0)

Definition at line 3807 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \
        duk_tval_incref((tv)); \
    } while (0)

◆ DUK_TVAL_IS_BOOLEAN

#define DUK_TVAL_IS_BOOLEAN ( tv ) ((tv)->t == DUK_TAG_BOOLEAN)

Definition at line 802 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_boolean_prototype_tostring_shared(), and duk_get_number().

◆ DUK_TVAL_IS_BOOLEAN_FALSE

#define DUK_TVAL_IS_BOOLEAN_FALSE ( tv ) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i == 0))

Definition at line 804 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_IS_BOOLEAN_TRUE

#define DUK_TVAL_IS_BOOLEAN_TRUE ( tv ) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0))

Definition at line 803 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_IS_BUFFER

#define DUK_TVAL_IS_BUFFER ( tv ) ((tv)->t == DUK_TAG_BUFFER)

Definition at line 818 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_IS_DOUBLE

#define DUK_TVAL_IS_DOUBLE ( v ) DUK_TVAL_IS_NUMBER((v))

Definition at line 812 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getprop_shallow_fastpath_array_tval(), duk_js_toboolean(), and duk_js_tointeger_number().

◆ DUK_TVAL_IS_HEAP_ALLOCATED

#define DUK_TVAL_IS_HEAP_ALLOCATED ( tv ) ((tv)->t & 0x08)

Definition at line 828 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__coerce_effective_this_binding(), duk__get_buffer_helper(), duk_bi_duktape_object_info(), and duk_require_heapptr().

◆ DUK_TVAL_IS_LIGHTFUNC

#define DUK_TVAL_IS_LIGHTFUNC ( tv ) ((tv)->t == DUK_TAG_LIGHTFUNC)

Definition at line 815 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_get_hobject_with_class(), and duk_push_string_funcptr().

◆ DUK_TVAL_IS_NULL

#define DUK_TVAL_IS_NULL ( tv ) ((tv)->t == DUK_TAG_NULL)

Definition at line 801 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_IS_NUMBER

#define DUK_TVAL_IS_NUMBER ( tv ) ((tv)->t == DUK__TAG_NUMBER)

Definition at line 811 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__getid_open_decl_env_regs(), duk__ispec_toregconst_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_TVAL_IS_OBJECT

#define DUK_TVAL_IS_OBJECT ( tv ) ((tv)->t == DUK_TAG_OBJECT)

Definition at line 817 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__getid_open_decl_env_regs(), duk_bi_boolean_prototype_tostring_shared(), and duk_get_hobject_with_class().

◆ DUK_TVAL_IS_POINTER

#define DUK_TVAL_IS_POINTER ( tv ) ((tv)->t == DUK_TAG_POINTER)

Definition at line 814 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_IS_STRING

#define DUK_TVAL_IS_STRING ( tv ) ((tv)->t == DUK_TAG_STRING)

Definition at line 816 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_IS_UNDEFINED

#define DUK_TVAL_IS_UNDEFINED ( tv ) ((tv)->t == DUK_TAG_UNDEFINED)

Definition at line 799 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_handle_call_protected(), duk_hobject_prepare_property_descriptor(), and duk_require_null().

◆ DUK_TVAL_IS_UNUSED

#define DUK_TVAL_IS_UNUSED ( tv ) ((tv)->t == DUK_TAG_UNUSED)

Definition at line 800 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk__ispec_toregconst_raw(), duk__realloc_props(), duk_hobject_putprop(), duk_js_toboolean(), and duk_js_tointeger_number().

◆ DUK_TVAL_NEEDS_REFCOUNT_UPDATE

#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE ( tv ) DUK_TVAL_IS_HEAP_ALLOCATED((tv))

Definition at line 3752 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_tval_decref().

◆ DUK_TVAL_SET_BOOLEAN

#define DUK_TVAL_SET_BOOLEAN	(		tv,
			val )

Value:

        do { \
        (tv)->t = DUK_TAG_BOOLEAN; \
        (tv)->v.i = (val); \
    } while (0)

Definition at line 676 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_BOOLEAN(tv,val)  do { \
        (tv)->t = DUK_TAG_BOOLEAN; \
        (tv)->v.i = (val); \
    } while (0)

◆ DUK_TVAL_SET_BOOLEAN_FALSE

#define DUK_TVAL_SET_BOOLEAN_FALSE ( v ) DUK_TVAL_SET_BOOLEAN(v, 0)

Definition at line 844 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_BOOLEAN_TRUE

#define DUK_TVAL_SET_BOOLEAN_TRUE ( v ) DUK_TVAL_SET_BOOLEAN(v, 1)

Definition at line 843 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_BOOLEAN_UPDREF

#define DUK_TVAL_SET_BOOLEAN_UPDREF DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0

Definition at line 4024 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0

#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3893 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_BUFFER

#define DUK_TVAL_SET_BUFFER	(		tv,
			hptr )

Value:

        do { \
        (tv)->t = DUK_TAG_BUFFER; \
        (tv)->v.hbuffer = (hptr); \
    } while (0)

Definition at line 750 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_BUFFER(tv,hptr)  do { \
        (tv)->t = DUK_TAG_BUFFER; \
        (tv)->v.hbuffer = (hptr); \
    } while (0)

◆ DUK_TVAL_SET_BUFFER_UPDREF

#define DUK_TVAL_SET_BUFFER_UPDREF DUK_TVAL_SET_BUFFER_UPDREF_ALT0

Definition at line 4041 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_BUFFER_UPDREF_ALT0

#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
        DUK_HBUFFER_INCREF((thr), (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3971 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
        DUK_HBUFFER_INCREF((thr), (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_DOUBLE

#define DUK_TVAL_SET_DOUBLE	(		tv,
			d ) DUK_TVAL_SET_NUMBER((tv), (d))

Definition at line 712 of file duktape-1.8.0/src/duktape.c.

712#define DUK_TVAL_SET_DOUBLE(tv,d) \

713 DUK_TVAL_SET_NUMBER((tv), (d))

◆ DUK_TVAL_SET_DOUBLE_CAST_UPDREF

#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF	(	thr,
		tvptr_dst,
		newval ) DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))

Definition at line 3944 of file duktape-1.8.0/src/duktape.c.

3944#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \

3945 DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))

◆ DUK_TVAL_SET_DOUBLE_UPDREF

#define DUK_TVAL_SET_DOUBLE_UPDREF DUK_TVAL_SET_DOUBLE_UPDREF_ALT0

Definition at line 4027 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_DOUBLE_UPDREF_ALT0

#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3912 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_FASTINT

#define DUK_TVAL_SET_FASTINT	(		tv,
			val ) DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val)) /* XXX: fast int-to-double */

Definition at line 714 of file duktape-1.8.0/src/duktape.c.

714#define DUK_TVAL_SET_FASTINT(tv,val) \

715 DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val)) /* XXX: fast int-to-double */

◆ DUK_TVAL_SET_FASTINT_I32

#define DUK_TVAL_SET_FASTINT_I32	(		tv,
			val ) DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))

Definition at line 718 of file duktape-1.8.0/src/duktape.c.

718#define DUK_TVAL_SET_FASTINT_I32(tv,val) \

719 DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))

◆ DUK_TVAL_SET_FASTINT_I32_UPDREF

#define DUK_TVAL_SET_FASTINT_I32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF

Definition at line 4035 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_to_uint32().

◆ DUK_TVAL_SET_FASTINT_U32

#define DUK_TVAL_SET_FASTINT_U32	(		tv,
			val ) DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))

Definition at line 716 of file duktape-1.8.0/src/duktape.c.

716#define DUK_TVAL_SET_FASTINT_U32(tv,val) \

717 DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))

Referenced by duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_TVAL_SET_FASTINT_U32_UPDREF

#define DUK_TVAL_SET_FASTINT_U32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF

Definition at line 4036 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__handle_catch(), and duk_to_uint16().

◆ DUK_TVAL_SET_FASTINT_UPDREF

#define DUK_TVAL_SET_FASTINT_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast int-to-double */

Definition at line 4034 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_LIGHTFUNC

#define DUK_TVAL_SET_LIGHTFUNC	(	tv,
		fp,
		flags )

Value:

        do { \
        (tv)->t = DUK_TAG_LIGHTFUNC; \
        (tv)->v_extra = (flags); \
        (tv)->v.lightfunc = (duk_c_function) (fp); \
    } while (0)

Definition at line 734 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags)  do { \
        (tv)->t = DUK_TAG_LIGHTFUNC; \
        (tv)->v_extra = (flags); \
        (tv)->v.lightfunc = (duk_c_function) (fp); \
    } while (0)

◆ DUK_TVAL_SET_LIGHTFUNC_UPDREF

#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0

Definition at line 4038 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0

#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0	(	thr,
		tvptr_dst,
		lf_v,
		lf_fp,
		lf_flags )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3948 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_NAN

#define DUK_TVAL_SET_NAN ( tv )

Value:

        do { \
        /* in non-packed representation we don't care about which NaN is used */ \
        (tv)->t = DUK__TAG_NUMBER; \
        (tv)->v.d = DUK_DOUBLE_NAN; \
    } while (0)

Definition at line 755 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NAN(tv)  do { \
        /* in non-packed representation we don't care about which NaN is used */ \
        (tv)->t = DUK__TAG_NUMBER; \
        (tv)->v.d = DUK_DOUBLE_NAN; \
    } while (0)

◆ DUK_TVAL_SET_NAN_UPDREF

#define DUK_TVAL_SET_NAN_UPDREF DUK_TVAL_SET_NAN_UPDREF_ALT0

Definition at line 4028 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_NAN_UPDREF_ALT0

#define DUK_TVAL_SET_NAN_UPDREF_ALT0	(		thr,
			tvptr_dst )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NAN(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3918 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NAN(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_NULL

#define DUK_TVAL_SET_NULL ( tv )

Value:

        do { \
        (tv)->t = DUK_TAG_NULL; \
    } while (0)

Definition at line 672 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NULL(tv)  do { \
        (tv)->t = DUK_TAG_NULL; \
    } while (0)

◆ DUK_TVAL_SET_NULL_UPDREF

#define DUK_TVAL_SET_NULL_UPDREF DUK_TVAL_SET_NULL_UPDREF_ALT0

Definition at line 4023 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_NULL_UPDREF_ALT0

#define DUK_TVAL_SET_NULL_UPDREF_ALT0	(		thr,
			tvptr_dst )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NULL(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3886 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NULL(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_NUMBER

#define DUK_TVAL_SET_NUMBER	(		tv,
			val )

Value:

        do { \
        (tv)->t = DUK__TAG_NUMBER; \
        (tv)->v.d = (val); \
    } while (0)

Definition at line 720 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NUMBER(tv,val)  do { \
        (tv)->t = DUK__TAG_NUMBER; \
        (tv)->v.d = (val); \
    } while (0)

◆ DUK_TVAL_SET_NUMBER_CHKFAST

#define DUK_TVAL_SET_NUMBER_CHKFAST	(		tv,
			d ) DUK_TVAL_SET_NUMBER((tv), (d))

Definition at line 724 of file duktape-1.8.0/src/duktape.c.

724#define DUK_TVAL_SET_NUMBER_CHKFAST(tv,d) \

725 DUK_TVAL_SET_NUMBER((tv), (d))

◆ DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF

#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0

Definition at line 4026 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0

#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3906 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_NUMBER_UPDREF

#define DUK_TVAL_SET_NUMBER_UPDREF DUK_TVAL_SET_NUMBER_UPDREF_ALT0

Definition at line 4025 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_NUMBER_UPDREF_ALT0

#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3900 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_OBJECT

#define DUK_TVAL_SET_OBJECT	(		tv,
			hptr )

Value:

        do { \
        (tv)->t = DUK_TAG_OBJECT; \
        (tv)->v.hobject = (hptr); \
    } while (0)

Definition at line 745 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_OBJECT(tv,hptr)  do { \
        (tv)->t = DUK_TAG_OBJECT; \
        (tv)->v.hobject = (hptr); \
    } while (0)

Referenced by duk__coerce_effective_this_binding(), duk__getvar_helper(), duk__putvar_helper(), duk_handle_ecma_call_setup(), duk_hobject_putprop(), and duk_push_hobject_bidx().

◆ DUK_TVAL_SET_OBJECT_UPDREF

#define DUK_TVAL_SET_OBJECT_UPDREF DUK_TVAL_SET_OBJECT_UPDREF_ALT0

Definition at line 4040 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_OBJECT_UPDREF_ALT0

#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
        DUK_HOBJECT_INCREF((thr), (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3963 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
        DUK_HOBJECT_INCREF((thr), (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_POINTER

#define DUK_TVAL_SET_POINTER	(		tv,
			hptr )

Value:

        do { \
        (tv)->t = DUK_TAG_POINTER; \
        (tv)->v.voidptr = (hptr); \
    } while (0)

Definition at line 729 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_POINTER(tv,hptr)  do { \
        (tv)->t = DUK_TAG_POINTER; \
        (tv)->v.voidptr = (hptr); \
    } while (0)

◆ DUK_TVAL_SET_POINTER_UPDREF

#define DUK_TVAL_SET_POINTER_UPDREF DUK_TVAL_SET_POINTER_UPDREF_ALT0

Definition at line 4042 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_POINTER_UPDREF_ALT0

#define DUK_TVAL_SET_POINTER_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3979 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_STRING

#define DUK_TVAL_SET_STRING	(		tv,
			hptr )

Value:

        do { \
        (tv)->t = DUK_TAG_STRING; \
        (tv)->v.hstring = (hptr); \
    } while (0)

Definition at line 740 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_STRING(tv,hptr)  do { \
        (tv)->t = DUK_TAG_STRING; \
        (tv)->v.hstring = (hptr); \
    } while (0)

Referenced by duk__getvar_helper(), and duk__putvar_helper().

◆ DUK_TVAL_SET_STRING_UPDREF

#define DUK_TVAL_SET_STRING_UPDREF DUK_TVAL_SET_STRING_UPDREF_ALT0

Definition at line 4039 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_STRING_UPDREF_ALT0

#define DUK_TVAL_SET_STRING_UPDREF_ALT0	(	thr,
		tvptr_dst,
		newval )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_STRING(tv__dst, (newval)); \
        DUK_HSTRING_INCREF((thr), (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3955 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_STRING(tv__dst, (newval)); \
        DUK_HSTRING_INCREF((thr), (newval)); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_TVAL

#define DUK_TVAL_SET_TVAL	(		v,
			x ) do { (v) = (x); } while (0)

Definition at line 761 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__realloc_props(), duk_dup_top(), duk_hobject_define_property_helper(), duk_hobject_putprop(), and duk_push_undefined().

◆ DUK_TVAL_SET_TVAL_UPDREF

#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT1

Definition at line 4046 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__handle_catch(), duk__putvar_helper(), duk_handle_ecma_call_setup(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_putprop(), and duk_remove().

◆ DUK_TVAL_SET_TVAL_UPDREF_ALT0

#define DUK_TVAL_SET_TVAL_UPDREF_ALT0	(	thr,
		tvptr_dst,
		tvptr_src )

Value:

        do { \
        duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \
        tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
        DUK_TVAL_INCREF((thr), tv__src); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3994 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
        duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \
        tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
        DUK_TVAL_INCREF((thr), tv__src); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_TVAL_UPDREF_ALT1

#define DUK_TVAL_SET_TVAL_UPDREF_ALT1	(	thr,
		tvptr_dst,
		tvptr_src )

Value:

        do { \
        duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \
        tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
        DUK_TVAL_INCREF_FAST((thr), tv__src); \
        if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv__dst)) { \
            h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \
            DUK_ASSERT(h__obj != NULL); \
            DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
            DUK_HEAPHDR_DECREF_FAST((thr), h__obj);  /* side effects */ \
        } else { \
            DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
        } \
    } while (0)

Definition at line 4006 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr,tvptr_dst,tvptr_src) do { \
        duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \
        tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
        DUK_TVAL_INCREF_FAST((thr), tv__src); \
        if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv__dst)) { \
            h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \
            DUK_ASSERT(h__obj != NULL); \
            DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
            DUK_HEAPHDR_DECREF_FAST((thr), h__obj);  /* side effects */ \
        } else { \
            DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
        } \
    } while (0)

◆ DUK_TVAL_SET_TVAL_UPDREF_FAST

#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT1

Definition at line 4047 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_TVAL_UPDREF_SLOW

#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0

Definition at line 4048 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_UNDEFINED

#define DUK_TVAL_SET_UNDEFINED ( tv )

Value:

        do { \
        (tv)->t = DUK_TAG_UNDEFINED; \
    } while (0)

Definition at line 664 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_UNDEFINED(tv)  do { \
        (tv)->t = DUK_TAG_UNDEFINED; \
    } while (0)

Referenced by duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_require_undefined().

◆ DUK_TVAL_SET_UNDEFINED_UPDREF

#define DUK_TVAL_SET_UNDEFINED_UPDREF DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0

Definition at line 4021 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper().

◆ DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0

#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0	(		thr,
			tvptr_dst )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_UNDEFINED(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3872 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_UNDEFINED(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_TVAL_SET_UNUSED

#define DUK_TVAL_SET_UNUSED ( tv )

Value:

        do { \
        (tv)->t = DUK_TAG_UNUSED; \
    } while (0)

Definition at line 668 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_UNUSED(tv)  do { \
        (tv)->t = DUK_TAG_UNUSED; \
    } while (0)

Referenced by duk__realloc_props().

◆ DUK_TVAL_SET_UNUSED_UPDREF

#define DUK_TVAL_SET_UNUSED_UPDREF DUK_TVAL_SET_UNUSED_UPDREF_ALT0

Definition at line 4022 of file duktape-1.8.0/src/duktape.c.

◆ DUK_TVAL_SET_UNUSED_UPDREF_ALT0

#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0	(		thr,
			tvptr_dst )

Value:

        do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_UNUSED(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

Definition at line 3879 of file duktape-1.8.0/src/duktape.c.

#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
        duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
        DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
        DUK_TVAL_SET_UNUSED(tv__dst); \
        DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
    } while (0)

◆ DUK_UNICODE_CP_REPLACEMENT_CHARACTER

#define DUK_UNICODE_CP_REPLACEMENT_CHARACTER 0xfffdL /* http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */

Definition at line 8058 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_CP_ZWJ

#define DUK_UNICODE_CP_ZWJ 0x200dL /* zero-width joiner */

Definition at line 8057 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_CP_ZWNJ

#define DUK_UNICODE_CP_ZWNJ 0x200cL /* zero-width non-joiner */

Definition at line 8056 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_H_INCLUDED

#define DUK_UNICODE_H_INCLUDED

Definition at line 8038 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_MAX_CESU8_BMP_LENGTH

#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */

Definition at line 8047 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_MAX_CESU8_LENGTH

#define DUK_UNICODE_MAX_CESU8_LENGTH 6 /* all codepoints up to U+10FFFF */

Definition at line 8046 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_MAX_XUTF8_BMP_LENGTH

#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */

Definition at line 8045 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UNICODE_MAX_XUTF8_LENGTH

#define DUK_UNICODE_MAX_XUTF8_LENGTH 7 /* up to 36 bit codepoints */

Definition at line 8044 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UTIL_GET_HASH_PROBE_STEP

#define DUK_UTIL_GET_HASH_PROBE_STEP ( hash ) (duk_util_probe_steps[(hash) & 0x1f])

Definition at line 1742 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UTIL_H_INCLUDED

#define DUK_UTIL_H_INCLUDED

Definition at line 1738 of file duktape-1.8.0/src/duktape.c.

◆ DUK_UTIL_MIN_HASH_PRIME

#define DUK_UTIL_MIN_HASH_PRIME 17 /* must match genhashsizes.py */

Definition at line 1740 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_API_ENTRY_MINIMUM

#define DUK_VALSTACK_API_ENTRY_MINIMUM DUK_API_ENTRY_STACK

Definition at line 5986 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_ASSERT_EXTRA

#define DUK_VALSTACK_ASSERT_EXTRA

Value:

                                       5  /* this is added to checks to allow for Duktape
                                       * API calls in addition to function's own use
                                       */

Definition at line 7836 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_DEFAULT_MAX

#define DUK_VALSTACK_DEFAULT_MAX 1000000L

Definition at line 5996 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_GROW_STEP

#define DUK_VALSTACK_GROW_STEP 128 /* roughly 1 kiB */

Definition at line 5981 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_INITIAL_SIZE

#define DUK_VALSTACK_INITIAL_SIZE 128 /* roughly 1.0 kiB -> but rounds up to DUK_VALSTACK_GROW_STEP in practice */

Definition at line 5984 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_INTERNAL_EXTRA

#define DUK_VALSTACK_INTERNAL_EXTRA

Value:

                                                 64      /* internal extra elements assumed on function entry,
                                                 * always added to user-defined 'extra' for e.g. the
                                                 * duk_check_stack() call.
                                                 */

Definition at line 5985 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_SHRINK_SPARE

#define DUK_VALSTACK_SHRINK_SPARE 64 /* roughly 0.5 kiB */

Definition at line 5983 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VALSTACK_SHRINK_THRESHOLD

#define DUK_VALSTACK_SHRINK_THRESHOLD 256 /* roughly 2 kiB */

Definition at line 5982 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VSRESIZE_FLAG_COMPACT

#define DUK_VSRESIZE_FLAG_COMPACT (1 << 1)

Definition at line 4242 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VSRESIZE_FLAG_SHRINK

#define DUK_VSRESIZE_FLAG_SHRINK (1 << 0)

Definition at line 4241 of file duktape-1.8.0/src/duktape.c.

◆ DUK_VSRESIZE_FLAG_THROW

#define DUK_VSRESIZE_FLAG_THROW (1 << 2)

Definition at line 4243 of file duktape-1.8.0/src/duktape.c.

◆ duk_xdef_prop_index_wec

#define duk_xdef_prop_index_wec	(	ctx,
		obj_index,
		arr_index ) duk_xdef_prop_index((ctx), (obj_index), (arr_index), DUK_PROPDESC_FLAGS_WEC)

Definition at line 4390 of file duktape-1.8.0/src/duktape.c.

4390#define duk_xdef_prop_index_wec(ctx,obj_index,arr_index) \

4391 duk_xdef_prop_index((ctx), (obj_index), (arr_index), DUK_PROPDESC_FLAGS_WEC)

Referenced by duk_bi_array_constructor_is_array().

◆ duk_xdef_prop_stridx_wec

#define duk_xdef_prop_stridx_wec	(	ctx,
		obj_index,
		stridx ) duk_xdef_prop_stridx((ctx), (obj_index), (stridx), DUK_PROPDESC_FLAGS_WEC)

Definition at line 4392 of file duktape-1.8.0/src/duktape.c.

4392#define duk_xdef_prop_stridx_wec(ctx,obj_index,stridx) \

4393 duk_xdef_prop_stridx((ctx), (obj_index), (stridx), DUK_PROPDESC_FLAGS_WEC)

◆ duk_xdef_prop_wec

#define duk_xdef_prop_wec	(		ctx,
			obj_index ) duk_xdef_prop((ctx), (obj_index), DUK_PROPDESC_FLAGS_WEC)

Definition at line 4388 of file duktape-1.8.0/src/duktape.c.

4388#define duk_xdef_prop_wec(ctx,obj_index) \

4389 duk_xdef_prop((ctx), (obj_index), DUK_PROPDESC_FLAGS_WEC)

Typedef Documentation

◆ duk__compile_raw_args

typedef struct duk__compile_raw_args duk__compile_raw_args

Definition at line 13589 of file duktape-1.8.0/src/duktape.c.

◆ duk__one_arg_func

typedef double(* duk__one_arg_func) (double)

Definition at line 32554 of file duktape-1.8.0/src/duktape.c.

◆ duk__toint_coercer

typedef duk_double_t(* duk__toint_coercer) (duk_hthread *thr, duk_tval *tv)

Definition at line 16923 of file duktape-1.8.0/src/duktape.c.

◆ duk__transform_callback

typedef void(* duk__transform_callback) (duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp)

Definition at line 27901 of file duktape-1.8.0/src/duktape.c.

◆ duk__two_arg_func

typedef double(* duk__two_arg_func) (double, double)

Definition at line 32555 of file duktape-1.8.0/src/duktape.c.

◆ duk_activation

typedef struct duk_activation duk_activation

Definition at line 328 of file duktape-1.8.0/src/duktape.c.

◆ duk_bitdecoder_ctx

typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx

Definition at line 338 of file duktape-1.8.0/src/duktape.c.

◆ duk_bitencoder_ctx

typedef struct duk_bitencoder_ctx duk_bitencoder_ctx

Definition at line 339 of file duktape-1.8.0/src/duktape.c.

◆ duk_breakpoint

typedef struct duk_breakpoint duk_breakpoint

Definition at line 326 of file duktape-1.8.0/src/duktape.c.

◆ duk_bufwriter_ctx

typedef struct duk_bufwriter_ctx duk_bufwriter_ctx

Definition at line 340 of file duktape-1.8.0/src/duktape.c.

◆ duk_catcher

typedef struct duk_catcher duk_catcher

Definition at line 329 of file duktape-1.8.0/src/duktape.c.

◆ duk_compiler_ctx

typedef struct duk_compiler_ctx duk_compiler_ctx

Definition at line 350 of file duktape-1.8.0/src/duktape.c.

◆ duk_compiler_func

typedef struct duk_compiler_func duk_compiler_func

Definition at line 349 of file duktape-1.8.0/src/duktape.c.

◆ duk_compiler_instr

typedef struct duk_compiler_instr duk_compiler_instr

Definition at line 348 of file duktape-1.8.0/src/duktape.c.

◆ duk_hbuffer

typedef struct duk_hbuffer duk_hbuffer

Definition at line 316 of file duktape-1.8.0/src/duktape.c.

◆ duk_hbuffer_dynamic

typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic

Definition at line 318 of file duktape-1.8.0/src/duktape.c.

◆ duk_hbuffer_external

typedef struct duk_hbuffer_external duk_hbuffer_external

Definition at line 319 of file duktape-1.8.0/src/duktape.c.

◆ duk_hbuffer_fixed

typedef struct duk_hbuffer_fixed duk_hbuffer_fixed

Definition at line 317 of file duktape-1.8.0/src/duktape.c.

◆ duk_hbufferobject

typedef struct duk_hbufferobject duk_hbufferobject

Definition at line 314 of file duktape-1.8.0/src/duktape.c.

◆ duk_hcompiledfunction

typedef struct duk_hcompiledfunction duk_hcompiledfunction

Definition at line 312 of file duktape-1.8.0/src/duktape.c.

◆ duk_heap

typedef struct duk_heap duk_heap

Definition at line 325 of file duktape-1.8.0/src/duktape.c.

◆ duk_heaphdr

typedef struct duk_heaphdr duk_heaphdr

Definition at line 307 of file duktape-1.8.0/src/duktape.c.

◆ duk_heaphdr_string

typedef struct duk_heaphdr_string duk_heaphdr_string

Definition at line 308 of file duktape-1.8.0/src/duktape.c.

◆ duk_hnativefunction

typedef struct duk_hnativefunction duk_hnativefunction

Definition at line 313 of file duktape-1.8.0/src/duktape.c.

◆ duk_hobject

typedef struct duk_hobject duk_hobject

Definition at line 311 of file duktape-1.8.0/src/duktape.c.

◆ duk_hstring

typedef struct duk_hstring duk_hstring

Definition at line 309 of file duktape-1.8.0/src/duktape.c.

◆ duk_hstring_external

typedef struct duk_hstring_external duk_hstring_external

Definition at line 310 of file duktape-1.8.0/src/duktape.c.

◆ duk_hthread

typedef struct duk_hthread duk_hthread

Definition at line 315 of file duktape-1.8.0/src/duktape.c.

◆ duk_instr_t

typedef duk_uint32_t duk_instr_t

Definition at line 2548 of file duktape-1.8.0/src/duktape.c.

◆ duk_internal_thread_state

typedef struct duk_internal_thread_state duk_internal_thread_state

Definition at line 14048 of file duktape-1.8.0/src/duktape.c.

◆ duk_jmpbuf

typedef struct duk_jmpbuf duk_jmpbuf

Definition at line 303 of file duktape-1.8.0/src/duktape.c.

◆ duk_lexer_codepoint

typedef struct duk_lexer_codepoint duk_lexer_codepoint

Definition at line 346 of file duktape-1.8.0/src/duktape.c.

◆ duk_lexer_ctx

typedef struct duk_lexer_ctx duk_lexer_ctx

Definition at line 345 of file duktape-1.8.0/src/duktape.c.

◆ duk_lexer_point

typedef struct duk_lexer_point duk_lexer_point

Definition at line 344 of file duktape-1.8.0/src/duktape.c.

◆ duk_ljstate

typedef struct duk_ljstate duk_ljstate

Definition at line 331 of file duktape-1.8.0/src/duktape.c.

◆ duk_mem_getptr

typedef void *(* duk_mem_getptr) (duk_heap *heap, void *ud)

Definition at line 6889 of file duktape-1.8.0/src/duktape.c.

◆ duk_propaccessor

typedef struct duk_propaccessor duk_propaccessor

Definition at line 321 of file duktape-1.8.0/src/duktape.c.

◆ duk_propdesc

typedef struct duk_propdesc duk_propdesc

Definition at line 323 of file duktape-1.8.0/src/duktape.c.

◆ duk_propvalue

typedef union duk_propvalue duk_propvalue

Definition at line 322 of file duktape-1.8.0/src/duktape.c.

◆ duk_re_compiler_ctx

typedef struct duk_re_compiler_ctx duk_re_compiler_ctx

Definition at line 353 of file duktape-1.8.0/src/duktape.c.

◆ duk_re_matcher_ctx

typedef struct duk_re_matcher_ctx duk_re_matcher_ctx

Definition at line 352 of file duktape-1.8.0/src/duktape.c.

◆ duk_re_range_callback

typedef void(* duk_re_range_callback) (void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct)

Definition at line 2730 of file duktape-1.8.0/src/duktape.c.

◆ duk_re_token

typedef struct duk_re_token duk_re_token

Definition at line 343 of file duktape-1.8.0/src/duktape.c.

◆ duk_reg_t

typedef duk_int32_t duk_reg_t

Definition at line 3198 of file duktape-1.8.0/src/duktape.c.

◆ duk_regconst_t

typedef duk_uint32_t duk_regconst_t

Definition at line 3195 of file duktape-1.8.0/src/duktape.c.

◆ duk_strcache

typedef struct duk_strcache duk_strcache

Definition at line 330 of file duktape-1.8.0/src/duktape.c.

◆ duk_strtab_entry

typedef struct duk_strtab_entry duk_strtab_entry

Definition at line 332 of file duktape-1.8.0/src/duktape.c.

◆ duk_token

typedef struct duk_token duk_token

Definition at line 342 of file duktape-1.8.0/src/duktape.c.

◆ duk_tval

typedef struct duk_tval_struct duk_tval

Definition at line 620 of file duktape-1.8.0/src/duktape.c.

Function Documentation

◆ duk__abandon_array_checked()

DUK_LOCAL void duk__abandon_array_checked	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 48415 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_uint32_t new_e_size;
    duk_uint32_t new_a_size;
    duk_uint32_t new_h_size;
    duk_uint32_t e_used;  /* actually used, non-NULL keys */
    duk_uint32_t a_used;
    duk_uint32_t a_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
 
    e_used = duk__count_used_e_keys(thr, obj);
    duk__compute_a_stats(thr, obj, &a_used, &a_size);
 
    /*
     *  Must guarantee all actually used array entries will fit into
     *  new entry part.  Add one growth step to ensure we don't run out
     *  of space right away.
     */
 

Referenced by duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ duk__abandon_array_density_check()

DUK_LOCAL duk_bool_t duk__abandon_array_density_check	(	duk_uint32_t	a_used,
		duk_uint32_t	a_size )

Definition at line 47689 of file duktape-1.8.0/src/duktape.c.

                                     {
            used++;
            highest_idx = i;
        }
    }
 
    /* Initial value for highest_idx is -1 coerced to unsigned.  This
     * is a bit odd, but (highest_idx + 1) will then wrap to 0 below
     * for out_min_size as intended.
     */
 
    *out_used = used;
    *out_min_size = highest_idx + 1;  /* 0 if no used entries */
}
 
/* Check array density and indicate whether or not the array part should be abandoned. */
DUK_LOCAL duk_bool_t duk__abandon_array_density_check(duk_uint32_t a_used, duk_uint32_t a_size) {
    /*

Referenced by duk_hobject_putprop().

◆ duk__abandon_array_slow_check_required()

DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required	(	duk_uint32_t	arr_idx,
		duk_uint32_t	old_size )

Definition at line 47710 of file duktape-1.8.0/src/duktape.c.

                                                :8
     *    new_used < limit' * (new_size / 8)
     *
     *  Here, new_used = a_used, new_size = a_size.
     *
     *  Note: some callers use approximate values for a_used and/or a_size
     *  (e.g. dropping a '+1' term).  This doesn't affect the usefulness
     *  of the check, but may confuse debugging.
     */
 
    return (a_used < DUK_HOBJECT_A_ABANDON_LIMIT * (a_size >> 3));
}
 
/* Fast check for extending array: check whether or not a slow density check is required. */
DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required(duk_uint32_t arr_idx, duk_uint32_t old_size) {
    /*
     *  In a fast check we assume old_size equals old_used (i.e., existing
     *  array is fully dense).
     *
     *  Slow check if:
     *

Referenced by duk_hobject_putprop().

◆ duk__acos()

DUK_LOCAL double duk__acos ( double x )

Definition at line 32738 of file duktape-1.8.0/src/duktape.c.

◆ duk__add_compiler_error_line()

DUK_LOCAL void duk__add_compiler_error_line ( duk_hthread * thr )

Definition at line 40251 of file duktape-1.8.0/src/duktape.c.

             :
    /* [ ... error lineNumber fileName ] */
#if defined(DUK_USE_ASSERTIONS)
    DUK_ASSERT(duk_get_top(ctx) == entry_top + 2);
#endif
    duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
}
#endif  /* !DUK_USE_TRACEBACKS */
 
/*
 *  Add line number to a compiler error.
 */
 
DUK_LOCAL void duk__add_compiler_error_line(duk_hthread *thr) {
    duk_context *ctx;
 
    /* Append a "(line NNN)" to the "message" property of any error
     * thrown during compilation.  Usually compilation errors are
     * SyntaxErrors but they can also be out-of-memory errors and
     * the like.
     */
 
    /* [ ... error ] */
 
    ctx = (duk_context *) thr;
    DUK_ASSERT(duk_is_object(ctx, -1));
 
    if (!(thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL)) {

◆ duk__add_label()

DUK_LOCAL_DECL void duk__add_label	(	duk_compiler_ctx *	comp_ctx,
		duk_hstring *	h_label,
		duk_int_t	pc_label,
		duk_int_t	label_id )

Definition at line 60252 of file duktape-1.8.0/src/duktape.c.

           {
        rc_varname = duk__getconst(comp_ctx);
        *out_reg_varbind = -1;
        *out_rc_varname = rc_varname;
        return 0;
    }
}
 
/*
 *  Label handling
 *
 *  Labels are initially added with flags prohibiting both break and continue.
 *  When the statement type is finally uncovered (after potentially multiple
 *  labels), all the labels are updated to allow/prohibit break and continue.
 */
 
DUK_LOCAL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_size_t n;
    duk_size_t new_size;
    duk_uint8_t *p;
    duk_labelinfo *li_start, *li;
 
    /* Duplicate (shadowing) labels are not allowed, except for the empty
     * labels (which are used as default labels for switch and iteration
     * statements).
     *
     * We could also allow shadowing of non-empty pending labels without any
     * other issues than breaking the required label shadowing requirements
     * of the E5 specification, see Section 12.12.
     */
 
    p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
    li_start = (duk_labelinfo *) (void *) p;
    li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
    n = (duk_size_t) (li - li_start);
 
    while (li > li_start) {
        li--;
 
        if (li->h_label == h_label && h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) {
            DUK_ERROR_SYNTAX(thr, DUK_STR_DUPLICATE_LABEL);
        }
    }
 
    duk_push_hstring(ctx, h_label);
    DUK_ASSERT(n <= DUK_UARRIDX_MAX);  /* label limits */
    (void) duk_put_prop_index(ctx, comp_ctx->curr_func.labelnames_idx, (duk_uarridx_t) n);
 
    new_size = (n + 1) * sizeof(duk_labelinfo);
    duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size);
    /* XXX: spare handling, slow now */
 
    /* relookup after possible realloc */
    p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
    li_start = (duk_labelinfo *) (void *) p;
    DUK_UNREF(li_start);  /* silence scan-build warning */
    li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
    li--;
 

◆ duk__add_traceback()

DUK_LOCAL void duk__add_traceback	(	duk_hthread *	thr,
		duk_hthread *	thr_callstack,
		const char *	c_filename,
		duk_int_t	c_line,
		duk_bool_t	noblame_fileline )

Definition at line 40000 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                       {
    duk_context *ctx = (duk_context *) thr;
    duk_small_uint_t depth;
    duk_int_t i, i_min;
    duk_uarridx_t arr_idx;
    duk_double_t d;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr_callstack != NULL);
    DUK_ASSERT(ctx != NULL);
 
    /* [ ... error ] */
 
    /*
     *  The traceback format is pretty arcane in an attempt to keep it compact
     *  and cheap to create.  It may change arbitrarily from version to version.
     *  It should be decoded/accessed through version specific accessors only.
     *
     *  See doc/error-objects.rst.
     */
 
    DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk_push_array(ctx);  /* XXX: specify array size, as we know it */
    arr_idx = 0;
 
    /* Compiler SyntaxErrors (and other errors) come first, and are
     * blamed by default (not flagged "noblame").
     */
    if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
        duk_push_hstring(ctx, thr->compile_ctx->h_filename);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
 
        duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);  /* (flags<<32) + (line), flags = 0 */
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
    }
 
    /* Filename/line from C macros (__FILE__, __LINE__) are added as an
     * entry with a special format: (string, number).  The number contains
     * the line and flags.
     */
 
    /* XXX: optimize: allocate an array part to the necessary size (upwards
     * estimate) and fill in the values directly into the array part; finally
     * update 'length'.
     */
 
    /* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype
     * has write-protected array index named properties.  This was seen as DoubleErrors
     * in e.g. some test262 test cases.  Using duk_xdef_prop_index() is better but heavier.
     * The best fix is to fill in the tracedata directly into the array part.  There are
     * no side effect concerns if the array part is allocated directly and only INCREFs
     * happen after that.
     */
 
    /* [ ... error arr ] */
 
    if (c_filename) {
        duk_push_string(ctx, c_filename);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
 
        d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
            (duk_double_t) c_line;
        duk_push_number(ctx, d);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
    }
 
    /* traceback depth doesn't take into account the filename/line
     * special handling above (intentional)
     */
    depth = DUK_USE_TRACEBACK_DEPTH;
    i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
    DUK_ASSERT(i_min >= 0);
 
    /* [ ... error arr ] */
 
    DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX);  /* callstack limits */
    for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
        duk_uint32_t pc;
 
        /*
         *  Note: each API operation potentially resizes the callstack,
         *  so be careful to re-lookup after every operation.  Currently
         *  these is no issue because we don't store a temporary 'act'
         *  pointer at all.  (This would be a non-issue if we operated
         *  directly on the array part.)
         */
 
        /* [... arr] */
 
        DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0);  /* unsigned */
 
        /* Add function object. */
        duk_push_tval(ctx, &(thr_callstack->callstack + i)->tv_func);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
 
        /* Add a number containing: pc, activation flags.
         *
         * PC points to next instruction, find offending PC.  Note that
         * PC == 0 for native code.
         */

◆ duk__adjust_valstack_and_top()

DUK_LOCAL void duk__adjust_valstack_and_top	(	duk_hthread *	thr,
		duk_idx_t	num_stack_args,
		duk_idx_t	idx_args,
		duk_idx_t	nregs,
		duk_idx_t	nargs,
		duk_hobject *	func )

Definition at line 55766 of file duktape-1.8.0/src/duktape.c.

                   :
    DUK_ASSERT(tv_func != NULL);
#if defined(DUK_USE_PARANOID_ERRORS)
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_CALLABLE);
#else
    DUK_ERROR_FMT1(thr, DUK_ERR_TYPE_ERROR, "%s not callable", duk_push_string_tval_readable(ctx, tv_func));
#endif
    DUK_UNREACHABLE();
    return NULL;  /* never executed */
}
 
/*
 *  Value stack resize and stack top adjustment helper.
 *
 *  XXX: This should all be merged to duk_valstack_resize_raw().
 */
 
DUK_LOCAL void duk__adjust_valstack_and_top(duk_hthread *thr,
                                            duk_idx_t num_stack_args,
                                            duk_idx_t idx_args,
                                            duk_idx_t nregs,
                                            duk_idx_t nargs,
                                            duk_hobject *func) {
    duk_context *ctx = (duk_context *) thr;
    duk_size_t vs_min_size;
    duk_bool_t adjusted_top = 0;
 
    vs_min_size = (thr->valstack_bottom - thr->valstack) +  /* bottom of current func */
                  idx_args;                                 /* bottom of new func */
 
    if (nregs >= 0) {
        DUK_ASSERT(nargs >= 0);
        DUK_ASSERT(nregs >= nargs);
        vs_min_size += nregs;
    } else {
        /* 'func' wants stack "as is" */
        vs_min_size += num_stack_args;  /* num entries of new func at entry */
    }
    if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
        vs_min_size += DUK_VALSTACK_API_ENTRY_MINIMUM;  /* Duktape/C API guaranteed entries (on top of args) */
    }
    vs_min_size += DUK_VALSTACK_INTERNAL_EXTRA;             /* + spare */
 
    /* XXX: We can't resize the value stack to a size smaller than the
     * current top, so the order of the resize and adjusting the stack
     * top depends on the current vs. final size of the value stack.
     * The operations could be combined to avoid this, but the proper
     * fix is to only grow the value stack on a function call, and only
     * shrink it (without throwing if the shrink fails) on function
     * return.
     */
 
    if (vs_min_size < (duk_size_t) (thr->valstack_top  - thr->valstack)) {
        DUK_DDD(DUK_DDDPRINT(("final size smaller, set top before resize")));
 
        DUK_ASSERT(nregs >= 0);  /* can't happen when keeping current stack size */
        duk_set_top(ctx, idx_args + nargs);  /* clamp anything above nargs */
        duk_set_top(ctx, idx_args + nregs);  /* extend with undefined */

Referenced by duk_handle_ecma_call_setup().

◆ duk__advance()

DUK_LOCAL_DECL void duk__advance ( duk_compiler_ctx * ctx )

Definition at line 58194 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_for_stmt(), duk__parse_func_body(), duk__parse_try_stmt(), and duk__parse_var_decl().

◆ duk__advance_bytes()

DUK_LOCAL void duk__advance_bytes	(	duk_lexer_ctx *	lex_ctx,
		duk_small_uint_t	count_bytes )

Definition at line 73633 of file duktape-1.8.0/src/duktape.c.

              :   /* clipped codepoint */
 error_encoding:  /* invalid codepoint encoding or codepoint */
    lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input);
    lex_ctx->input_line = input_line;
 
    DUK_ERROR_SYNTAX(lex_ctx->thr, "utf-8 decode failed");
}
 
DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) {
    duk_small_uint_t used_bytes, avail_bytes;
 
    DUK_ASSERT_DISABLE(count_bytes >= 0);  /* unsigned */
    DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint)));
    DUK_ASSERT(lex_ctx->window >= lex_ctx->buffer);
    DUK_ASSERT(lex_ctx->window < lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE);
    DUK_ASSERT((duk_uint8_t *) lex_ctx->window + count_bytes <= (duk_uint8_t *) lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint));
 
    /* Zero 'count' is also allowed to make call sites easier.

◆ duk__advance_expect()

DUK_LOCAL_DECL void duk__advance_expect	(	duk_compiler_ctx *	comp_ctx,
		duk_small_int_t	expect )

Definition at line 58189 of file duktape-1.8.0/src/duktape.c.

                                 : curr: tok=%ld/%ld,%ld,term=%ld,%!T,%!T "
                         "prev: tok=%ld/%ld,%ld,term=%ld,%!T,%!T",
                         (long) comp_ctx->curr_token.t,

Referenced by duk__parse_func_body(), and duk__parse_func_formals().

◆ duk__advance_helper()

DUK_LOCAL_DECL void duk__advance_helper	(	duk_compiler_ctx *	comp_ctx,
		duk_small_int_t	expect )

Definition at line 58130 of file duktape-1.8.0/src/duktape.c.

                                                                                                                  {
    DUK_ASSERT(h != NULL);
    return (comp_ctx->curr_func.is_strict &&
            DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h));
}
 
/*
 *  Parser duk__advance() token eating functions
 */
 
/* XXX: valstack handling is awkward.  Add a valstack helper which
 * avoids dup():ing; valstack_copy(src, dst)?
 */
 
DUK_LOCAL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t regexp;
 
    DUK_ASSERT(comp_ctx->curr_token.t >= 0 && comp_ctx->curr_token.t <= DUK_TOK_MAXVAL);  /* MAXVAL is inclusive */
 
    /*
     *  Use current token to decide whether a RegExp can follow.
     *
     *  We can use either 't' or 't_nores'; the latter would not
     *  recognize keywords.  Some keywords can be followed by a
     *  RegExp (e.g. "return"), so using 't' is better.  This is
     *  not trivial, see doc/compiler.rst.
     */
 
    regexp = 1;
    if (duk__token_lbp[comp_ctx->curr_token.t] & DUK__TOKEN_LBP_FLAG_NO_REGEXP) {
        regexp = 0;
    }
    if (comp_ctx->curr_func.reject_regexp_in_adv) {
        comp_ctx->curr_func.reject_regexp_in_adv = 0;
        regexp = 0;
    }
 
    if (expect >= 0 && comp_ctx->curr_token.t != expect) {
        DUK_D(DUK_DPRINT("parse error: expect=%ld, got=%ld",
                         (long) expect, (long) comp_ctx->curr_token.t));
        DUK_ERROR_SYNTAX(thr, DUK_STR_PARSE_ERROR);
    }
 
    /* make current token the previous; need to fiddle with valstack "backing store" */
    DUK_MEMCPY(&comp_ctx->prev_token, &comp_ctx->curr_token, sizeof(duk_token));
    duk_copy(ctx, comp_ctx->tok11_idx, comp_ctx->tok21_idx);
    duk_copy(ctx, comp_ctx->tok12_idx, comp_ctx->tok22_idx);
 
    /* parse new token */
    duk_lexer_parse_js_input_element(&comp_ctx->lex,
                                     &comp_ctx->curr_token,
                                     comp_ctx->curr_func.is_strict,

◆ duk__alloc_entry_checked()

DUK_LOCAL duk_bool_t duk__alloc_entry_checked	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key )

Definition at line 48674 of file duktape-1.8.0/src/duktape.c.

                                         {
        return NULL;
    }
    tv = DUK_HOBJECT_A_GET_VALUE_PTR(heap, obj, i);
    return tv;
}
 
/*
 *  Allocate and initialize a new entry, resizing the properties allocation
 *  if necessary.  Returns entry index (e_idx) or throws an error if alloc fails.
 *
 *  Sets the key of the entry (increasing the key's refcount), and updates
 *  the hash part if it exists.  Caller must set value and flags, and update
 *  the entry value refcount.  A decref for the previous value is not necessary.
 */
 
DUK_LOCAL duk_bool_t duk__alloc_entry_checked(duk_hthread *thr, duk_hobject *obj, duk_hstring *key) {
    duk_uint32_t idx;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(obj) <= DUK_HOBJECT_GET_ESIZE(obj));
 
#ifdef DUK_USE_ASSERTIONS
    /* key must not already exist in entry part */
    {
        duk_uint_fast32_t i;
        for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
            DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != key);
        }
    }
#endif
 
    if (DUK_HOBJECT_GET_ENEXT(obj) >= DUK_HOBJECT_GET_ESIZE(obj)) {
        /* only need to guarantee 1 more slot, but allocation growth is in chunks */
        DUK_DDD(DUK_DDDPRINT("entry part full, allocate space for one more entry"));
        duk__grow_props_for_new_entry_item(thr, obj);
    }
    DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(obj) < DUK_HOBJECT_GET_ESIZE(obj));
    idx = DUK_HOBJECT_POSTINC_ENEXT(obj);
 
    /* previous value is assumed to be garbage, so don't touch it */
    DUK_HOBJECT_E_SET_KEY(thr->heap, obj, idx, key);
    DUK_HSTRING_INCREF(thr, key);
 
#if defined(DUK_USE_HOBJECT_HASH_PART)
    if (DUK_UNLIKELY(DUK_HOBJECT_GET_HSIZE(obj) > 0)) {
        duk_uint32_t n;
        duk_uint32_t i, step;
        duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj);
 
        n = DUK_HOBJECT_GET_HSIZE(obj);
        i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n);
        step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key));
 
        for (;;) {
            duk_uint32_t t = h_base[i];
            if (t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED) {
                DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() inserted key into hash part, %ld -> %ld",
                                     (long) i, (long) idx));
                DUK_ASSERT_DISABLE(i >= 0);  /* unsigned */
                DUK_ASSERT(i < DUK_HOBJECT_GET_HSIZE(obj));
                DUK_ASSERT_DISABLE(idx >= 0);
                DUK_ASSERT(idx < DUK_HOBJECT_GET_ESIZE(obj));
                h_base[i] = idx;
                break;
            }
            DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() miss %ld", (long) i));

Referenced by duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ duk__alloc_init_hstring()

DUK_LOCAL duk_hstring * duk__alloc_init_hstring	(	duk_heap *	heap,
		const duk_uint8_t *	str,
		duk_uint32_t	blen,
		duk_uint32_t	strhash,
		const duk_uint8_t *	extdata )

Definition at line 45037 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_hstring *res = NULL;
    duk_uint8_t *data;
    duk_size_t alloc_size;
    duk_uarridx_t dummy;
    duk_uint32_t clen;
 
#if defined(DUK_USE_STRLEN16)
    /* If blen <= 0xffffUL, clen is also guaranteed to be <= 0xffffUL. */
    if (blen > 0xffffUL) {
        DUK_D(DUK_DPRINT("16-bit string blen/clen active and blen over 16 bits, reject intern"));
        return NULL;
    }
#endif
 
    if (extdata) {
        alloc_size = (duk_size_t) sizeof(duk_hstring_external);
        res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
        if (!res) {
            goto alloc_error;
        }
        DUK_MEMZERO(res, sizeof(duk_hstring_external));
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
        DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
#endif
        DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, DUK_HSTRING_FLAG_EXTDATA);
 
        ((duk_hstring_external *) res)->extdata = extdata;
    } else {
        /* NUL terminate for convenient C access */
        alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1);
        res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
        if (!res) {
            goto alloc_error;
        }
        DUK_MEMZERO(res, sizeof(duk_hstring));
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
        DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
#endif
        DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0);
 
        data = (duk_uint8_t *) (res + 1);
        DUK_MEMCPY(data, str, blen);
        data[blen] = (duk_uint8_t) 0;
    }
 
    DUK_ASSERT(!DUK_HSTRING_HAS_ARRIDX(res));
    if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
        DUK_HSTRING_SET_ARRIDX(res);
    }
 
    /* All strings beginning with 0xff are treated as "internal",
     * even strings interned by the user.  This allows user code to
     * create internal properties too, and makes behavior consistent
     * in case user code happens to use a string also used by Duktape
     * (such as string has already been interned and has the 'internal'
     * flag set).
     */
    DUK_ASSERT(!DUK_HSTRING_HAS_INTERNAL(res));
    if (blen > 0 && str[0] == (duk_uint8_t) 0xff) {
        DUK_HSTRING_SET_INTERNAL(res);
    }
 
    DUK_HSTRING_SET_HASH(res, strhash);
    DUK_HSTRING_SET_BYTELEN(res, blen);
 
    clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen);
    DUK_ASSERT(clen <= blen);
#if defined(DUK_USE_HSTRING_CLEN)
    DUK_HSTRING_SET_CHARLEN(res, clen);
#endif
 
    /* Using an explicit 'ASCII' flag has larger footprint (one call site
     * only) but is quite useful for the case when there's no explicit
     * 'clen' in duk_hstring.
     */
    DUK_ASSERT(!DUK_HSTRING_HAS_ASCII(res));

References DUK_ALLOC, DUK_ASSERT, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, DUK_FREE, DUK_HEAPHDR_SET_TYPE_AND_FLAGS, DUK_HEAPHDR_STRING_INIT_NULLS, DUK_HSTRING_FLAG_EXTDATA, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_CHARLEN, DUK_HSTRING_GET_HASH, DUK_HSTRING_HAS_ARRIDX, DUK_HSTRING_HAS_ASCII, DUK_HSTRING_HAS_EXTDATA, DUK_HSTRING_HAS_INTERNAL, DUK_HSTRING_SET_ARRIDX, DUK_HSTRING_SET_ASCII, DUK_HSTRING_SET_BYTELEN, DUK_HSTRING_SET_CHARLEN, DUK_HSTRING_SET_HASH, DUK_HSTRING_SET_INTERNAL, DUK_HTYPE_STRING, duk_js_to_arrayindex_raw_string(), DUK_MEMCPY, DUK_MEMZERO, duk_unicode_unvalidated_utf8_length(), dummy, duk_hstring::hdr, and NULL.

◆ duk__alloctemp()

DUK_LOCAL_DECL duk_reg_t duk__alloctemp ( duk_compiler_ctx * comp_ctx )

Definition at line 59589 of file duktape-1.8.0/src/duktape.c.

◆ duk__alloctemps()

DUK_LOCAL_DECL duk_reg_t duk__alloctemps	(	duk_compiler_ctx *	comp_ctx,
		duk_small_int_t	num )

Definition at line 59571 of file duktape-1.8.0/src/duktape.c.

                                                                     {
        /* Don't allow negative zero as it will cause trouble with
         * LDINT+LDINTX.  But positive zero is OK.
         */
        t = (duk_int32_t) x;
        if ((duk_double_t) t == x) {
            *ival = t;
            return 1;
        }
    }
 
    return 0;
}
 

◆ duk__api_coerce_d2i()

DUK_LOCAL duk_int_t duk__api_coerce_d2i	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_bool_t	require )

Definition at line 15054 of file duktape-1.8.0/src/duktape.c.

                              { \
        DUK_ASSERT(!(thr->valstack_top >= thr->valstack_end)); \
    } while (0)
#else
#define DUK__CHECK_SPACE() do { \
        if (DUK_UNLIKELY(thr->valstack_top >= thr->valstack_end)) { \
            DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \
        } \
    } while (0)
#endif
 
DUK_LOCAL_DECL duk_heaphdr *duk__get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t tag);
 
DUK_LOCAL duk_int_t duk__api_coerce_d2i(duk_context *ctx, duk_idx_t index, duk_bool_t require) {
    duk_hthread *thr;
    duk_tval *tv;
    duk_small_int_t c;
    duk_double_t d;
 
    thr = (duk_hthread *) ctx;
 
    tv = duk_get_tval(ctx, index);
    if (tv == NULL) {
        goto error_notnumber;
    }
 
    /*
     *  Special cases like NaN and +/- Infinity are handled explicitly
     *  because a plain C coercion from double to int handles these cases
     *  in undesirable ways.  For instance, NaN may coerce to INT_MIN
     *  (not zero), and INT_MAX + 1 may coerce to INT_MIN (not INT_MAX).
     *
     *  This double-to-int coercion differs from ToInteger() because it
     *  has a finite range (ToInteger() allows e.g. +/- Infinity).  It
     *  also differs from ToInt32() because the INT_MIN/INT_MAX clamping
     *  depends on the size of the int type on the platform.  In particular,
     *  on platforms with a 64-bit int type, the full range is allowed.
     */
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv)) {
        duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
#if (DUK_INT_MAX <= 0x7fffffffL)
        /* Clamping only necessary for 32-bit ints. */
        if (t < DUK_INT_MIN) {
            t = DUK_INT_MIN;
        } else if (t > DUK_INT_MAX) {
            t = DUK_INT_MAX;
        }
#endif
        return (duk_int_t) t;
    }
#endif
 
    if (DUK_TVAL_IS_NUMBER(tv)) {
        d = DUK_TVAL_GET_NUMBER(tv);
        c = (duk_small_int_t) DUK_FPCLASSIFY(d);
        if (c == DUK_FP_NAN) {
            return 0;
        } else if (d < (duk_double_t) DUK_INT_MIN) {
            /* covers -Infinity */
            return DUK_INT_MIN;

◆ duk__api_coerce_d2ui()

DUK_LOCAL duk_uint_t duk__api_coerce_d2ui	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_bool_t	require )

Definition at line 15121 of file duktape-1.8.0/src/duktape.c.

               {
            /* coerce towards zero */
            return (duk_int_t) d;
        }
    }
 
 error_notnumber:
 
    if (require) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER);
        /* not reachable */
    }
    return 0;
}
 
DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk_bool_t require) {
    duk_hthread *thr;
    duk_tval *tv;
    duk_small_int_t c;
    duk_double_t d;
 
    /* Same as above but for unsigned int range. */
 
    thr = (duk_hthread *) ctx;
 
    tv = duk_get_tval(ctx, index);
    if (tv == NULL) {
        goto error_notnumber;
    }
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv)) {
        duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
        if (t < 0) {
            t = 0;
        }
#if (DUK_UINT_MAX <= 0xffffffffUL)
        /* Clamping only necessary for 32-bit ints. */
        else if (t > DUK_UINT_MAX) {
            t = DUK_UINT_MAX;
        }
#endif
        return (duk_uint_t) t;
    }
#endif
 
    if (DUK_TVAL_IS_NUMBER(tv)) {
        d = DUK_TVAL_GET_NUMBER(tv);
        c = (duk_small_int_t) DUK_FPCLASSIFY(d);
        if (c == DUK_FP_NAN) {
            return 0;
        } else if (d < 0.0) {
            /* covers -Infinity */
            return (duk_uint_t) 0;

◆ duk__append_jump_offset()

DUK_LOCAL duk_uint32_t duk__append_jump_offset	(	duk_re_compiler_ctx *	re_ctx,
		duk_int32_t	skip )

Definition at line 77815 of file duktape-1.8.0/src/duktape.c.

77817 {

References duk__encode_i32(), duk__insert_i32(), DUK_ASSERT, and duk_unicode_get_xutf8_length().

Referenced by duk__parse_disjunction().

◆ duk__append_slice()

DUK_LOCAL void duk__append_slice	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	data_offset,
		duk_uint32_t	data_length )

Definition at line 77779 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ duk__append_u16_list()

DUK_LOCAL void duk__append_u16_list	(	duk_re_compiler_ctx *	re_ctx,
		const duk_uint16_t *	values,
		duk_uint32_t	count )

Definition at line 77767 of file duktape-1.8.0/src/duktape.c.

77773 {

Referenced by duk__parse_disjunction().

◆ duk__append_u32()

DUK_LOCAL duk_uint32_t duk__append_u32	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	x )

Definition at line 77747 of file duktape-1.8.0/src/duktape.c.

           {
        return ((duk_uint32_t) x) * 2;
    }
}
 
/* XXX: return type should probably be duk_size_t, or explicit checks are needed for
 * maximum size.
 */

Referenced by duk__generate_ranges(), duk__parse_disjunction(), and duk__remove_slice().

◆ duk__appendbuffer()

DUK_LOCAL void duk__appendbuffer	(	duk_lexer_ctx *	lex_ctx,
		duk_codepoint_t	x )

Definition at line 73845 of file duktape-1.8.0/src/duktape.c.

                                                       {
    /* Reuse buffer as is unless buffer has grown large. */
    if (DUK_HBUFFER_DYNAMIC_GET_SIZE(lex_ctx->buf) < DUK_LEXER_TEMP_BUF_LIMIT) {
        /* Keep current size */
    } else {
        duk_hbuffer_resize(lex_ctx->thr, lex_ctx->buf, DUK_LEXER_TEMP_BUF_LIMIT);
    }
 
    DUK_BW_INIT_WITHBUF(lex_ctx->thr, &lex_ctx->bw, lex_ctx->buf);
}
 
/*
 *  Append a Unicode codepoint to the temporary byte buffer.  Performs
 *  CESU-8 surrogate pair encoding for codepoints above the BMP.
 *  Existing surrogate pairs are allowed and also encoded into CESU-8.

References duk_lexer_ctx::buf, duk_lexer_ctx::bw, DUK_BW_INIT_WITHBUF, DUK_HBUFFER_DYNAMIC_GET_SIZE, duk_hbuffer_resize(), DUK_LEXER_TEMP_BUF_LIMIT, and duk_lexer_ctx::thr.

◆ duk__array_qsort()

DUK_LOCAL void duk__array_qsort	(	duk_context *	ctx,
		duk_int_t	lo,
		duk_int_t	hi )

Definition at line 20814 of file duktape-1.8.0/src/duktape.c.

                            {
            *ptr++ = '>';
        } else if (i >= lo && i <= hi) {
            *ptr++ = '-';
        } else {
            *ptr++ = ' ';
        }
    }
    *ptr++ = ']';
    *ptr++ = '\0';
 
    DUK_DDD(DUK_DDDPRINT("%s   (lo=%ld, hi=%ld, pivot=%ld)",
                         (const char *) buf, (long) lo, (long) hi, (long) pivot));
}
#endif
 
DUK_LOCAL void duk__array_qsort(duk_context *ctx, duk_int_t lo, duk_int_t hi) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_int_t p, l, r;
 
    /* The lo/hi indices may be crossed and hi < 0 is possible at entry. */
 
    DUK_DDD(DUK_DDDPRINT("duk__array_qsort: lo=%ld, hi=%ld, obj=%!T",
                         (long) lo, (long) hi, (duk_tval *) duk_get_tval(ctx, 1)));
 
    DUK_ASSERT_TOP(ctx, 3);
 
    /* In some cases it may be that lo > hi, or hi < 0; these
     * degenerate cases happen e.g. for empty arrays, and in
     * recursion leaves.
     */
 
    /* trivial cases */
    if (hi - lo < 1) {
        DUK_DDD(DUK_DDDPRINT("degenerate case, return immediately"));
        return;
    }
    DUK_ASSERT(hi > lo);
    DUK_ASSERT(hi - lo + 1 >= 2);
 
    /* randomized pivot selection */
    p = lo + (duk_util_tinyrandom_get_bits(thr, 30) % (hi - lo + 1));  /* rnd in [lo,hi] */
    DUK_ASSERT(p >= lo && p <= hi);
    DUK_DDD(DUK_DDDPRINT("lo=%ld, hi=%ld, chose pivot p=%ld",
                         (long) lo, (long) hi, (long) p));
 
    /* move pivot out of the way */
    duk__array_sort_swap(ctx, p, lo);
    p = lo;
    DUK_DDD(DUK_DDDPRINT("pivot moved out of the way: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
 
    l = lo + 1;
    r = hi;
    for (;;) {
        /* find elements to swap */
        for (;;) {
            DUK_DDD(DUK_DDDPRINT("left scan: l=%ld, r=%ld, p=%ld",
                                 (long) l, (long) r, (long) p));
            if (l >= hi) {
                break;
            }
            if (duk__array_sort_compare(ctx, l, p) >= 0) {  /* !(l < p) */
                break;
            }
            l++;
        }
        for (;;) {
            DUK_DDD(DUK_DDDPRINT("right scan: l=%ld, r=%ld, p=%ld",
                                 (long) l, (long) r, (long) p));
            if (r <= lo) {
                break;
            }
            if (duk__array_sort_compare(ctx, p, r) >= 0) {  /* !(p < r) */
                break;
            }
            r--;
        }
        if (l >= r) {
            goto done;
        }
        DUK_ASSERT(l < r);
 
        DUK_DDD(DUK_DDDPRINT("swap %ld and %ld", (long) l, (long) r));
 
        duk__array_sort_swap(ctx, l, r);
 
        DUK_DDD(DUK_DDDPRINT("after swap: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
        l++;
        r--;
    }
 done:
    /* Note that 'l' and 'r' may cross, i.e. r < l */
    DUK_ASSERT(l >= lo && l <= hi);
    DUK_ASSERT(r >= lo && r <= hi);
 
    /* XXX: there's no explicit recursion bound here now.  For the average

◆ duk__array_sort_compare()

DUK_LOCAL duk_small_int_t duk__array_sort_compare	(	duk_context *	ctx,
		duk_int_t	idx1,
		duk_int_t	idx2 )

Definition at line 20636 of file duktape-1.8.0/src/duktape.c.

                                                                                                    {
    duk_bool_t have1, have2;
    duk_bool_t undef1, undef2;
    duk_small_int_t ret;
    duk_idx_t idx_obj = 1;  /* fixed offsets in valstack */
    duk_idx_t idx_fn = 0;
    duk_hstring *h1, *h2;
 
    /* Fast exit if indices are identical.  This is valid for a non-existent property,
     * for an undefined value, and almost always for ToString() coerced comparison of
     * arbitrary values (corner cases where this is not the case include e.g. a an
     * object with varying ToString() coercion).
     *
     * The specification does not prohibit "caching" of values read from the array, so
     * assuming equality for comparing an index with itself falls into the category of
     * "caching".
     *
     * Also, compareFn may be inconsistent, so skipping a call to compareFn here may
     * have an effect on the final result.  The specification does not require any
     * specific behavior for inconsistent compare functions, so again, this fast path
     * is OK.
     */
 
    if (idx1 == idx2) {
        DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld -> indices identical, quick exit",
                             (long) idx1, (long) idx2));
        return 0;
    }
 
    have1 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx1);
    have2 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx2);
 
    DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld, have1=%ld, have2=%ld, val1=%!T, val2=%!T",
                         (long) idx1, (long) idx2, (long) have1, (long) have2,
                         (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
 
    if (have1) {
        if (have2) {
            ;
        } else {
            ret = -1;
            goto pop_ret;
        }
    } else {
        if (have2) {
            ret = 1;
            goto pop_ret;
        } else {
            ret = 0;
            goto pop_ret;
        }
    }
 
    undef1 = duk_is_undefined(ctx, -2);
    undef2 = duk_is_undefined(ctx, -1);
    if (undef1) {
        if (undef2) {
            ret = 0;
            goto pop_ret;
        } else {
            ret = 1;
            goto pop_ret;
        }
    } else {
        if (undef2) {
            ret = -1;
            goto pop_ret;
        } else {
            ;
        }
    }
 
    if (!duk_is_undefined(ctx, idx_fn)) {
        duk_double_t d;
 
        /* no need to check callable; duk_call() will do that */
        duk_dup(ctx, idx_fn);    /* -> [ ... x y fn ] */
        duk_insert(ctx, -3);     /* -> [ ... fn x y ] */
        duk_call(ctx, 2);        /* -> [ ... res ] */
 
        /* The specification is a bit vague what to do if the return
         * value is not a number.  Other implementations seem to
         * tolerate non-numbers but e.g. V8 won't apparently do a
         * ToNumber().
         */
 
        /* XXX: best behavior for real world compatibility? */
 
        d = duk_to_number(ctx, -1);
        if (d < 0.0) {
            ret = -1;
        } else if (d > 0.0) {
            ret = 1;
        } else {
            ret = 0;
        }
 
        duk_pop(ctx);
        DUK_DDD(DUK_DDDPRINT("-> result %ld (from comparefn, after coercion)", (long) ret));
        return ret;

◆ duk__array_sort_swap()

DUK_LOCAL void duk__array_sort_swap	(	duk_context *	ctx,
		duk_int_t	l,
		duk_int_t	r )

Definition at line 20754 of file duktape-1.8.0/src/duktape.c.

        :
    duk_pop_2(ctx);
    DUK_DDD(DUK_DDDPRINT("-> result %ld", (long) ret));
    return ret;
}
 
DUK_LOCAL void duk__array_sort_swap(duk_context *ctx, duk_int_t l, duk_int_t r) {
    duk_bool_t have_l, have_r;
    duk_idx_t idx_obj = 1;  /* fixed offset in valstack */
 
    if (l == r) {
        return;
    }
 
    /* swap elements; deal with non-existent elements correctly */
    have_l = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) l);

◆ duk__asin()

DUK_LOCAL double duk__asin ( double x )

Definition at line 32741 of file duktape-1.8.0/src/duktape.c.

32743 :

32744

◆ duk__atan()

DUK_LOCAL double duk__atan ( double x )

Definition at line 32744 of file duktape-1.8.0/src/duktape.c.

◆ duk__atan2()

DUK_LOCAL double duk__atan2	(	double	x,
		double	y )

Definition at line 32771 of file duktape-1.8.0/src/duktape.c.

32773 {

◆ duk__base64_decode_helper()

DUK_LOCAL duk_bool_t duk__base64_decode_helper	(	const duk_uint8_t *	src,
		duk_size_t	srclen,
		duk_uint8_t *	dst,
		duk_uint8_t **	out_dst_final )

Definition at line 13082 of file duktape-1.8.0/src/duktape.c.

                                {
                y = x - 26 + 'a';
            } else if (x <= 61) {
                y = x - 52 + '0';
            } else if (x == 62) {
                y = '+';
            } else {
                y = '/';
            }
 
            *dst++ = (duk_uint8_t) y;
        }
    }
}
#endif  /* DUK_USE_BASE64_FASTPATH */
 
#if defined(DUK_USE_BASE64_FASTPATH)
DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst, duk_uint8_t **out_dst_final) {
    duk_int_t x;
    duk_int_t t;
    duk_small_uint_t n_equal;
    duk_small_uint_t n_chars;
    const duk_uint8_t *src_end;
    const duk_uint8_t *src_end_safe;
 
    src_end = src + srclen;
    src_end_safe = src_end - 4;  /* if 'src < src_end_safe', safe to read 4 bytes */
 
    /* Innermost fast path processes 4 valid base-64 characters at a time
     * but bails out on whitespace, padding chars ('=') and invalid chars.
     * Once the slow path segment has been processed, we return to the
     * inner fast path again.  This handles e.g. base64 with newlines
     * reasonably well because the majority of a line is in the fast path.
     */
    for (;;) {
        /* Fast path, handle units with just actual encoding characters. */
 
        while (src <= src_end_safe) {
            /* The lookup byte is intentionally sign extended to (at least)
             * 32 bits and then ORed.  This ensures that is at least 1 byte
             * is negative, the highest bit of 't' will be set at the end
             * and we don't need to check every byte.
             */
            DUK_DDD(DUK_DDDPRINT("fast loop: src=%p, src_end_safe=%p, src_end=%p",
                                 (const void *) src, (const void *) src_end_safe, (const void *) src_end));
 
            t = (duk_int_t) duk_base64_dectab[*src++];
            t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++];
            t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++];
            t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++];
 
            if (DUK_UNLIKELY(t < 0)) {
                DUK_DDD(DUK_DDDPRINT("fast loop unit was not clean, process one slow path unit"));
                src -= 4;
                break;
            }
 
            DUK_ASSERT(t <= 0xffffffL);
            DUK_ASSERT((t >> 24) == 0);
            *dst++ = (duk_uint8_t) (t >> 16);
            *dst++ = (duk_uint8_t) ((t >> 8) & 0xff);
            *dst++ = (duk_uint8_t) (t & 0xff);
        }
 
        /* Handle one slow path unit (or finish if we're done). */
 
        n_equal = 0;
        n_chars = 0;
        t = 0;
        for (;;) {
            DUK_DDD(DUK_DDDPRINT("slow loop: src=%p, src_end=%p, n_chars=%ld, n_equal=%ld, t=%ld",
                                 (const void *) src, (const void *) src_end, (long) n_chars, (long) n_equal, (long) t));
 
            if (DUK_UNLIKELY(src >= src_end)) {
                goto done;  /* two level break */
            }
 
            x = duk_base64_dectab[*src++];
            if (DUK_UNLIKELY(x < 0)) {
                if (x == -2) {
                    continue;  /* allowed ascii whitespace */
                } else if (x == -3) {
                    n_equal++;
                    t <<= 6;
                } else {
                    DUK_ASSERT(x == -1);
                    goto error;
                }
            } else {
                DUK_ASSERT(x >= 0 && x <= 63);
                if (n_equal > 0) {
                    /* Don't allow actual chars after equal sign. */
                    goto error;
                }
                t = (t << 6) + x;
            }
 
            if (DUK_UNLIKELY(n_chars == 3)) {
                /* Emit 3 bytes and backtrack if there was padding.  There's
                 * always space for the whole 3 bytes so no check needed.
                 */
                DUK_ASSERT(t <= 0xffffffL);
                DUK_ASSERT((t >> 24) == 0);
                *dst++ = (duk_uint8_t) (t >> 16);
                *dst++ = (duk_uint8_t) ((t >> 8) & 0xff);
                *dst++ = (duk_uint8_t) (t & 0xff);
 
                if (DUK_UNLIKELY(n_equal > 0)) {
                    DUK_ASSERT(n_equal <= 4);
 
                    /* There may be whitespace between the equal signs. */
                    if (n_equal == 1) {
                        /* XXX= */
                        dst -= 1;
                    } else if (n_equal == 2) {
                        /* XX== */
                        dst -= 2;
                    } else {
                        goto error;  /* invalid padding */
                    }
 
                    /* Continue parsing after padding, allows concatenated,
                     * padded base64.
                     */
                }
                break;  /* back to fast loop */
            } else {
                n_chars++;
            }
        }
    }
 done:
    DUK_DDD(DUK_DDDPRINT("done; src=%p, src_end=%p, n_chars=%ld",
                         (const void *) src, (const void *) src_end, (long) n_chars));

◆ duk__base64_encode_helper()

DUK_LOCAL void duk__base64_encode_helper	(	const duk_uint8_t *	src,
		duk_size_t	srclen,
		duk_uint8_t *	dst )

Definition at line 12968 of file duktape-1.8.0/src/duktape.c.

                                                                                                         {
    DUK_ASSERT(duk_is_valid_index(ctx, index));  /* checked by caller */
    if (duk_is_buffer(ctx, index)) {
        return (const duk_uint8_t *) duk_get_buffer(ctx, index, out_len);
    } else {
        return (const duk_uint8_t *) duk_to_lstring(ctx, index, out_len);
    }
}
 
#if defined(DUK_USE_BASE64_FASTPATH)
DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst) {
    duk_uint_t t;
    duk_size_t n_full, n_full3, n_final;
    const duk_uint8_t *src_end_fast;
 
    n_full = srclen / 3;  /* full 3-byte -> 4-char conversions */
    n_full3 = n_full * 3;
    n_final = srclen - n_full3;
    DUK_ASSERT_DISABLE(n_final >= 0);
    DUK_ASSERT(n_final <= 2);
 
    src_end_fast = src + n_full3;
    while (DUK_UNLIKELY(src != src_end_fast)) {
        t = (duk_uint_t) (*src++);
        t = (t << 8) + (duk_uint_t) (*src++);
        t = (t << 8) + (duk_uint_t) (*src++);
 
        *dst++ = duk_base64_enctab[t >> 18];
        *dst++ = duk_base64_enctab[(t >> 12) & 0x3f];
        *dst++ = duk_base64_enctab[(t >> 6) & 0x3f];
        *dst++ = duk_base64_enctab[t & 0x3f];
 
#if 0  /* Tested: not faster on x64 */
        /* aaaaaabb bbbbcccc ccdddddd */
        dst[0] = duk_base64_enctab[(src[0] >> 2) & 0x3f];
        dst[1] = duk_base64_enctab[((src[0] << 4) & 0x30) | ((src[1] >> 4) & 0x0f)];
        dst[2] = duk_base64_enctab[((src[1] << 2) & 0x3f) | ((src[2] >> 6) & 0x03)];
        dst[3] = duk_base64_enctab[src[2] & 0x3f];
        src += 3; dst += 4;
#endif
    }
 
    switch (n_final) {
    /* case 0: nop */
    case 1: {
        /* XX== */
        t = (duk_uint_t) (*src++);
        *dst++ = duk_base64_enctab[t >> 2];           /* XXXXXX-- */

References DUK_ASSERT, duk_get_buffer(), duk_is_buffer(), duk_is_valid_index(), duk_to_lstring(), and index.

◆ duk__bc_get_i32()

DUK_LOCAL duk_int32_t duk__bc_get_i32	(	duk_re_matcher_ctx *	re_ctx,
		const duk_uint8_t **	pc )

Definition at line 78758 of file duktape-1.8.0/src/duktape.c.

◆ duk__bc_get_u32()

DUK_LOCAL duk_uint32_t duk__bc_get_u32	(	duk_re_matcher_ctx *	re_ctx,
		const duk_uint8_t **	pc )

Definition at line 78754 of file duktape-1.8.0/src/duktape.c.

◆ duk__bi_add()

DUK_LOCAL void duk__bi_add	(	duk__bigint *	x,
		duk__bigint *	y,
		duk__bigint *	z )

Definition at line 75615 of file duktape-1.8.0/src/duktape.c.

                    {
            tmp += z->v[i];
        }
        x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL);
        tmp = tmp >> 32;
    }
    if (tmp != 0U) {
        DUK_ASSERT(i < DUK__BI_MAX_PARTS);
        x->v[i++] = (duk_uint32_t) tmp;
    }
    x->n = i;
    DUK_ASSERT(x->n <= DUK__BI_MAX_PARTS);
 
    /* no need to normalize */
    DUK_ASSERT(duk__bi_is_valid(x));
}
#else  /* DUK_USE_64BIT_OPS */
DUK_LOCAL void duk__bi_add(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
    duk_uint32_t carry, tmp1, tmp2;
    duk_small_int_t i, ny, nz;
 
    DUK_ASSERT(duk__bi_is_valid(y));
    DUK_ASSERT(duk__bi_is_valid(z));
 
    if (z->n > y->n) {
        duk__bigint *t;
        t = y; y = z; z = t;
    }
    DUK_ASSERT(y->n >= z->n);
 
    ny = y->n; nz = z->n;
    carry = 0U;
    for (i = 0; i < ny; i++) {
        /* Carry is detected based on wrapping which relies on exact 32-bit
         * types.
         */
        DUK_ASSERT(i < DUK__BI_MAX_PARTS);
        tmp1 = y->v[i];
        tmp2 = tmp1;
        if (i < nz) {
            tmp2 += z->v[i];
        }
 
        /* Careful with carry condition:
         *  - If carry not added: 0x12345678 + 0 + 0xffffffff = 0x12345677 (< 0x12345678)
         *  - If carry added:     0x12345678 + 1 + 0xffffffff = 0x12345678 (== 0x12345678)
         */
        if (carry) {
            tmp2++;
            carry = (tmp2 <= tmp1 ? 1U : 0U);

References duk__bigint::v.

◆ duk__bi_add_small()

DUK_LOCAL void duk__bi_add_small	(	duk__bigint *	x,
		duk__bigint *	y,
		duk_uint32_t	z )

Definition at line 75668 of file duktape-1.8.0/src/duktape.c.

               {
        DUK_ASSERT(i < DUK__BI_MAX_PARTS);
        DUK_ASSERT(carry == 1U);
        x->v[i++] = carry;
    }
    x->n = i;
    DUK_ASSERT(x->n <= DUK__BI_MAX_PARTS);
 

◆ duk__bi_compare()

DUK_LOCAL int duk__bi_compare	(	duk__bigint *	x,
		duk__bigint *	y )

Definition at line 75542 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    if (v == 0U) {
        x->n = 0;
    } else {
        x->n = 1;
        x->v[0] = v;
    }
    DUK_ASSERT(duk__bi_is_valid(x));
}
 
/* Return value: <0  <=>  x < y
 *                0  <=>  x == y
 *               >0  <=>  x > y
 */
DUK_LOCAL int duk__bi_compare(duk__bigint *x, duk__bigint *y) {
    duk_small_int_t i, nx, ny;
    duk_uint32_t tx, ty;
 
    DUK_ASSERT(duk__bi_is_valid(x));
    DUK_ASSERT(duk__bi_is_valid(y));
 
    nx = x->n;
    ny = y->n;
    if (nx > ny) {
        goto ret_gt;
    }
    if (nx < ny) {
        goto ret_lt;
    }
    for (i = nx - 1; i >= 0; i--) {
        tx = x->v[i];
        ty = y->v[i];

◆ duk__bi_copy()

DUK_LOCAL void duk__bi_copy	(	duk__bigint *	x,
		duk__bigint *	y )

Definition at line 75517 of file duktape-1.8.0/src/duktape.c.

                                                 {
    duk_small_int_t i;
 
    for (i = x->n - 1; i >= 0; i--) {
        if (x->v[i] != 0) {
            break;
        }
    }

References duk__bigint::n, and duk__bigint::v.

Referenced by duk__bi_is_zero().

◆ duk__bi_exp_small()

DUK_LOCAL void duk__bi_exp_small	(	duk__bigint *	x,
		duk_small_int_t	b,
		duk_small_int_t	y,
		duk__bigint *	t1,
		duk__bigint *	t2 )

Definition at line 75957 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_small_int_t n, r;
 
    n = (y / 32) + 1;
    DUK_ASSERT(n > 0);
    r = y % 32;
    DUK_MEMZERO((void *) x->v, sizeof(duk_uint32_t) * n);
    x->n = n;
    x->v[n - 1] = (((duk_uint32_t) 1) << r);
}
 
/* x <- b^y; use t1 and t2 as temps */
DUK_LOCAL void duk__bi_exp_small(duk__bigint *x, duk_small_int_t b, duk_small_int_t y, duk__bigint *t1, duk__bigint *t2) {
    /* Fast path the binary case */
 
    DUK_ASSERT(x != t1 && x != t2 && t1 != t2);  /* distinct bignums, easy mistake to make */
    DUK_ASSERT(b >= 0);
    DUK_ASSERT(y >= 0);
 
    if (b == 2) {
        duk__bi_twoexp(x, y);
        return;
    }
 
    /* http://en.wikipedia.org/wiki/Exponentiation_by_squaring */
 
    DUK_DDD(DUK_DDDPRINT("exp_small: b=%ld, y=%ld", (long) b, (long) y));
 
    duk__bi_set_small(x, 1);
    duk__bi_set_small(t1, b);

◆ duk__bi_global_resolve_module_id()

DUK_LOCAL void duk__bi_global_resolve_module_id	(	duk_context *	ctx,
		const char *	req_id,
		const char *	mod_id )

Definition at line 28644 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    DUK_UNREF(ctx);
    return 0;
}
#else  /* print provider */
DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* print provider */
 
/*
 *  CommonJS require() and modules support
 */
 
#if defined(DUK_USE_COMMONJS_MODULES)
DUK_LOCAL void duk__bi_global_resolve_module_id(duk_context *ctx, const char *req_id, const char *mod_id) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uint8_t buf[DUK_BI_COMMONJS_MODULE_ID_LIMIT];
    duk_uint8_t *p;
    duk_uint8_t *q;
    duk_uint8_t *q_last;  /* last component */
    duk_int_t int_rc;
 
    DUK_ASSERT(req_id != NULL);
    /* mod_id may be NULL */
 
    /*
     *  A few notes on the algorithm:
     *
     *    - Terms are not allowed to begin with a period unless the term
     *      is either '.' or '..'.  This simplifies implementation (and
     *      is within CommonJS modules specification).
     *
     *    - There are few output bound checks here.  This is on purpose:
     *      the resolution input is length checked and the output is never
     *      longer than the input.  The resolved output is written directly
     *      over the input because it's never longer than the input at any
     *      point in the algorithm.
     *
     *    - Non-ASCII characters are processed as individual bytes and
     *      need no special treatment.  However, U+0000 terminates the
     *      algorithm; this is not an issue because U+0000 is not a
     *      desirable term character anyway.
     */
 
    /*
     *  Set up the resolution input which is the requested ID directly
     *  (if absolute or no current module path) or with current module
     *  ID prepended (if relative and current module path exists).
     *
     *  Suppose current module is 'foo/bar' and relative path is './quux'.
     *  The 'bar' component must be replaced so the initial input here is
     *  'foo/bar/.././quux'.
     */
 
    if (mod_id != NULL && req_id[0] == '.') {
        int_rc = DUK_SNPRINTF((char *) buf, sizeof(buf), "%s/../%s", mod_id, req_id);
    } else {
        int_rc = DUK_SNPRINTF((char *) buf, sizeof(buf), "%s", req_id);
    }
    if (int_rc >= (duk_int_t) sizeof(buf) || int_rc < 0) {
        /* Potentially truncated, NUL not guaranteed in any case.
         * The (int_rc < 0) case should not occur in practice.
         */
        DUK_DD(DUK_DDPRINT("resolve error: temporary working module ID doesn't fit into resolve buffer"));
        goto resolve_error;
    }
    DUK_ASSERT(DUK_STRLEN((const char *) buf) < sizeof(buf));  /* at most sizeof(buf) - 1 */
 
    DUK_DDD(DUK_DDDPRINT("input module id: '%s'", (const char *) buf));
 
    /*
     *  Resolution loop.  At the top of the loop we're expecting a valid
     *  term: '.', '..', or a non-empty identifier not starting with a period.
     */
 
    p = buf;
    q = buf;
    for (;;) {
        duk_uint_fast8_t c;
 
        /* Here 'p' always points to the start of a term.
         *
         * We can also unconditionally reset q_last here: if this is
         * the last (non-empty) term q_last will have the right value
         * on loop exit.
         */
 
        DUK_ASSERT(p >= q);  /* output is never longer than input during resolution */
 
        DUK_DDD(DUK_DDDPRINT("resolve loop top: p -> '%s', q=%p, buf=%p",
                             (const char *) p, (void *) q, (void *) buf));
 
        q_last = q;
 
        c = *p++;
        if (DUK_UNLIKELY(c == 0)) {
            DUK_DD(DUK_DDPRINT("resolve error: requested ID must end with a non-empty term"));
            goto resolve_error;
        } else if (DUK_UNLIKELY(c == '.')) {
            c = *p++;
            if (c == '/') {
                /* Term was '.' and is eaten entirely (including dup slashes). */
                goto eat_dup_slashes;
            }
            if (c == '.' && *p == '/') {
                /* Term was '..', backtrack resolved name by one component.
                 *  q[-1] = previous slash (or beyond start of buffer)
                 *  q[-2] = last char of previous component (or beyond start of buffer)
                 */
                p++;  /* eat (first) input slash */
                DUK_ASSERT(q >= buf);
                if (q == buf) {
                    DUK_DD(DUK_DDPRINT("resolve error: term was '..' but nothing to backtrack"));
                    goto resolve_error;
                }
                DUK_ASSERT(*(q - 1) == '/');
                q--;  /* backtrack to last output slash (dups already eliminated) */
                for (;;) {
                    /* Backtrack to previous slash or start of buffer. */
                    DUK_ASSERT(q >= buf);
                    if (q == buf) {
                        break;
                    }
                    if (*(q - 1) == '/') {
                        break;
                    }
                    q--;
                }
                goto eat_dup_slashes;
            }
            DUK_DD(DUK_DDPRINT("resolve error: term begins with '.' but is not '.' or '..' (not allowed now)"));
            goto resolve_error;
        } else if (DUK_UNLIKELY(c == '/')) {
            /* e.g. require('/foo'), empty terms not allowed */
            DUK_DD(DUK_DDPRINT("resolve error: empty term (not allowed now)"));
            goto resolve_error;
        } else {
            for (;;) {
                /* Copy term name until end or '/'. */
                *q++ = c;
                c = *p++;
                if (DUK_UNLIKELY(c == 0)) {
                    /* This was the last term, and q_last was
                     * updated to match this term at loop top.
                     */
                    goto loop_done;
                } else if (DUK_UNLIKELY(c == '/')) {
                    *q++ = '/';
                    break;
                } else {
                    /* write on next loop */
                }
            }
        }
 
     eat_dup_slashes:
        for (;;) {
            /* eat dup slashes */
            c = *p;
            if (DUK_LIKELY(c != '/')) {
                break;
            }
            p++;
        }
    }

References DUK_UNREF.

◆ duk__bi_is_2to52()

DUK_LOCAL duk_small_int_t duk__bi_is_2to52 ( duk__bigint * x )

Definition at line 75938 of file duktape-1.8.0/src/duktape.c.

                                              {
    DUK_ASSERT(duk__bi_is_valid(x));
    return (x->n == 0) || ((x->v[0] & 0x01) == 0);
}

References DUK_ASSERT, duk__bigint::n, and duk__bigint::v.

◆ duk__bi_is_even()

DUK_LOCAL int duk__bi_is_even ( duk__bigint * x )

Definition at line 75922 of file duktape-1.8.0/src/duktape.c.

◆ duk__bi_is_zero()

DUK_LOCAL int duk__bi_is_zero ( duk__bigint * x )

Definition at line 75927 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk__bi_mul(t, x, y);
    duk__bi_copy(x, t);

References duk__bi_copy(), and duk__bi_mul().

◆ duk__bi_mul()

DUK_LOCAL void duk__bi_mul	(	duk__bigint *	x,
		duk__bigint *	y,
		duk__bigint *	z )

Definition at line 75784 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk__bi_sub(t, x, y);
    duk__bi_copy(x, t);
}
 
/* x <- y * z */
DUK_LOCAL void duk__bi_mul(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
    duk_small_int_t i, j, nx, nz;
 
    DUK_ASSERT(duk__bi_is_valid(y));
    DUK_ASSERT(duk__bi_is_valid(z));
 
    nx = y->n + z->n;  /* max possible */
    DUK_ASSERT(nx <= DUK__BI_MAX_PARTS);
 
    if (nx == 0) {
        /* Both inputs are zero; cases where only one is zero can go
         * through main algorithm.
         */
        x->n = 0;
        return;
    }
 
    DUK_MEMZERO((void *) x->v, (size_t) (sizeof(duk_uint32_t) * nx));
    x->n = nx;
 
    nz = z->n;
    for (i = 0; i < y->n; i++) {
#ifdef DUK_USE_64BIT_OPS
        duk_uint64_t tmp = 0U;
        for (j = 0; j < nz; j++) {
            tmp += (duk_uint64_t) y->v[i] * (duk_uint64_t) z->v[j] + x->v[i+j];
            x->v[i+j] = (duk_uint32_t) (tmp & 0xffffffffUL);
            tmp = tmp >> 32;
        }
        if (tmp > 0) {
            DUK_ASSERT(i + j < nx);
            DUK_ASSERT(i + j < DUK__BI_MAX_PARTS);
            DUK_ASSERT(x->v[i+j] == 0U);
            x->v[i+j] = (duk_uint32_t) tmp;
        }
#else
        /*
         *  Multiply + add + carry for 32-bit components using only 16x16->32
         *  multiplies and carry detection based on unsigned overflow.
         *
         *    1st mult, 32-bit: (A*2^16 + B)
         *    2nd mult, 32-bit: (C*2^16 + D)
         *    3rd add, 32-bit: E
         *    4th add, 32-bit: F
         *
         *      (AC*2^16 + B) * (C*2^16 + D) + E + F
         *    = AC*2^32 + AD*2^16 + BC*2^16 + BD + E + F
         *    = AC*2^32 + (AD + BC)*2^16 + (BD + E + F)
         *    = AC*2^32 + AD*2^16 + BC*2^16 + (BD + E + F)
         */
        duk_uint32_t a, b, c, d, e, f;
        duk_uint32_t r, s, t;
 
        a = y->v[i]; b = a & 0xffffUL; a = a >> 16;
 
        f = 0;
        for (j = 0; j < nz; j++) {
            c = z->v[j]; d = c & 0xffffUL; c = c >> 16;
            e = x->v[i+j];
 
            /* build result as: (r << 32) + s: start with (BD + E + F) */
            r = 0;
            s = b * d;
 
            /* add E */
            t = s + e;
            if (t < s) { r++; }  /* carry */
            s = t;
 
            /* add F */
            t = s + f;
            if (t < s) { r++; }  /* carry */
            s = t;
 
            /* add BC*2^16 */
            t = b * c;
            r += (t >> 16);
            t = s + ((t & 0xffffUL) << 16);
            if (t < s) { r++; }  /* carry */
            s = t;
 
            /* add AD*2^16 */
            t = a * d;
            r += (t >> 16);
            t = s + ((t & 0xffffUL) << 16);
            if (t < s) { r++; }  /* carry */
            s = t;
 
            /* add AC*2^32 */
            t = a * c;
            r += t;
 
            DUK_DDD(DUK_DDDPRINT("ab=%08lx cd=%08lx ef=%08lx -> rs=%08lx %08lx",
                                 (unsigned long) y->v[i], (unsigned long) z->v[j],
                                 (unsigned long) x->v[i+j], (unsigned long) r,

Referenced by duk__bi_is_zero().

◆ duk__bi_mul_copy()

DUK_LOCAL void duk__bi_mul_copy	(	duk__bigint *	x,
		duk__bigint *	y,
		duk__bigint *	t )

Definition at line 75911 of file duktape-1.8.0/src/duktape.c.

◆ duk__bi_mul_small()

DUK_LOCAL void duk__bi_mul_small	(	duk__bigint *	x,
		duk__bigint *	y,
		duk_uint32_t	z )

Definition at line 75898 of file duktape-1.8.0/src/duktape.c.

                    {
            DUK_ASSERT(i + j < nx);
            DUK_ASSERT(i + j < DUK__BI_MAX_PARTS);
            DUK_ASSERT(x->v[i+j] == 0U);
            x->v[i+j] = (duk_uint32_t) f;
        }
#endif  /* DUK_USE_64BIT_OPS */
    }

◆ duk__bi_mul_small_copy()

DUK_LOCAL void duk__bi_mul_small_copy	(	duk__bigint *	x,
		duk_uint32_t	y,
		duk__bigint *	t )

Definition at line 75917 of file duktape-1.8.0/src/duktape.c.

◆ duk__bi_normalize()

DUK_LOCAL void duk__bi_normalize ( duk__bigint * x )

Definition at line 75502 of file duktape-1.8.0/src/duktape.c.

                                    {
        p += DUK_SPRINTF(p, " %08lx", (unsigned long) x->v[i]);
    }
 
    DUK_DDD(DUK_DDDPRINT("%s: %s", (const char *) name, (const char *) buf));
}
#endif
 
#ifdef DUK_USE_ASSERTIONS
DUK_LOCAL duk_small_int_t duk__bi_is_valid(duk__bigint *x) {
    return (duk_small_int_t)
           ( ((x->n >= 0) && (x->n <= DUK__BI_MAX_PARTS)) /* is valid size */ &&

Referenced by duk__dragon4_ctx_to_double().

◆ duk__bi_set_small()

DUK_LOCAL void duk__bi_set_small	(	duk__bigint *	x,
		duk_uint32_t	v )

Definition at line 75528 of file duktape-1.8.0/src/duktape.c.

                                                            {
    duk_small_int_t n;
 

◆ duk__bi_sub()

DUK_LOCAL void duk__bi_sub	(	duk__bigint *	x,
		duk__bigint *	y,
		duk__bigint *	z )

Definition at line 75720 of file duktape-1.8.0/src/duktape.c.

                    {
            tz = z->v[i];
        } else {
            tz = 0;
        }
        tmp = (duk_int64_t) ty - (duk_int64_t) tz + tmp;
        x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL);
        tmp = tmp >> 32;  /* 0 or -1 */
    }
    DUK_ASSERT(tmp == 0);
 
    x->n = i;
    duk__bi_normalize(x);  /* need to normalize, may even cancel to 0 */
    DUK_ASSERT(duk__bi_is_valid(x));
}
#else
DUK_LOCAL void duk__bi_sub(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
    duk_small_int_t i, ny, nz;
    duk_uint32_t tmp1, tmp2, borrow;
 
    DUK_ASSERT(duk__bi_is_valid(y));
    DUK_ASSERT(duk__bi_is_valid(z));
    DUK_ASSERT(duk__bi_compare(y, z) >= 0);
    DUK_ASSERT(y->n >= z->n);
 
    ny = y->n; nz = z->n;
    borrow = 0U;
    for (i = 0; i < ny; i++) {
        /* Borrow is detected based on wrapping which relies on exact 32-bit
         * types.
         */
        tmp1 = y->v[i];
        tmp2 = tmp1;
        if (i < nz) {
            tmp2 -= z->v[i];
        }
 
        /* Careful with borrow condition:
         *  - If borrow not subtracted: 0x12345678 - 0 - 0xffffffff = 0x12345679 (> 0x12345678)

References duk__bigint::v.

◆ duk__bi_sub_copy()

DUK_LOCAL void duk__bi_sub_copy	(	duk__bigint *	x,
		duk__bigint *	y,
		duk__bigint *	t )

Definition at line 75778 of file duktape-1.8.0/src/duktape.c.

75781 {

◆ duk__bi_twoexp()

DUK_LOCAL void duk__bi_twoexp	(	duk__bigint *	x,
		duk_small_int_t	y )

Definition at line 75945 of file duktape-1.8.0/src/duktape.c.

◆ duk__bw_update_ptrs()

DUK_LOCAL void duk__bw_update_ptrs	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx,
		duk_size_t	curr_offset,
		duk_size_t	new_length )

Definition at line 86494 of file duktape-1.8.0/src/duktape.c.

                  {
        duk_be_encode(ctx, 0, npad);
    }
    DUK_ASSERT(ctx->currbits == 0);
}
#line 1 "duk_util_bufwriter.c"
/*
 *  Fast buffer writer with spare management.
 */
 
/* include removed: duk_internal.h */
 

References duk_be_encode().

◆ duk__call_prop_prep_stack()

DUK_LOCAL void duk__call_prop_prep_stack	(	duk_context *	ctx,
		duk_idx_t	normalized_obj_index,
		duk_idx_t	nargs )

Definition at line 12388 of file duktape-1.8.0/src/duktape.c.

                                                      {
    DUK_ERROR_UNSUPPORTED_DEFMSG((duk_hthread *) ctx);
}
 
#endif  /* DUK_USE_BYTECODE_DUMP_SUPPORT */
#line 1 "duk_api_call.c"
/*
 *  Calls.
 *
 *  Protected variants should avoid ever throwing an error.
 */
 
/* include removed: duk_internal.h */
 
/* Prepare value stack for a method call through an object property.
 * May currently throw an error e.g. when getting the property.
 */
DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_index=%ld, nargs=%ld, stacktop=%ld",
                         (long) normalized_obj_index, (long) nargs, (long) duk_get_top(ctx)));
 
    /* [... key arg1 ... argN] */
 

References DUK_ERROR_UNSUPPORTED_DEFMSG.

◆ duk__case_transform_helper()

DUK_LOCAL duk_codepoint_t duk__case_transform_helper	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_codepoint_t	cp,
		duk_codepoint_t	prev,
		duk_codepoint_t	next,
		duk_bool_t	uppercase )

Definition at line 10845 of file duktape-1.8.0/src/duktape.c.

                    {
        DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp);
    }
    return cp;
}
 
/*
 *  Case conversion helper, with context/local sensitivity.
 *  For proper case conversion, one needs to know the character
 *  and the preceding and following characters, as well as
 *  locale/language.
 */
 
/* XXX: add 'language' argument when locale/language sensitive rule
 * support added.
 */
DUK_LOCAL
duk_codepoint_t duk__case_transform_helper(duk_hthread *thr,
                                           duk_bufwriter_ctx *bw,
                                           duk_codepoint_t cp,
                                           duk_codepoint_t prev,
                                           duk_codepoint_t next,
                                           duk_bool_t uppercase) {
    duk_bitdecoder_ctx bd_ctx;
 
    /* fast path for ASCII */
    if (cp < 0x80L) {
        /* XXX: there are language sensitive rules for the ASCII range.
         * If/when language/locale support is implemented, they need to
         * be implemented here for the fast path.  There are no context
         * sensitive rules for ASCII range.
         */
 
        if (uppercase) {
            if (cp >= 'a' && cp <= 'z') {
                cp = cp - 'a' + 'A';
            }
        } else {
            if (cp >= 'A' && cp <= 'Z') {
                cp = cp - 'A' + 'a';
            }
        }
 
        if (bw != NULL) {
            DUK_BW_WRITE_RAW_U8(thr, bw, (duk_uint8_t) cp);
        }
        return cp;
    }
 
    /* context and locale specific rules which cannot currently be represented
     * in the caseconv bitstream: hardcoded rules in C
     */
    if (uppercase) {
        /* XXX: turkish / azeri */
    } else {
        /*
         *  Final sigma context specific rule.  This is a rather tricky
         *  rule and this handling is probably not 100% correct now.
         *  The rule is not locale/language specific so it is supported.
         */
 
        if (cp == 0x03a3L &&    /* U+03A3 = GREEK CAPITAL LETTER SIGMA */
            duk_unicode_is_letter(prev) &&        /* prev exists and is not a letter */
            !duk_unicode_is_letter(next)) {       /* next does not exist or next is not a letter */
            /* Capital sigma occurred at "end of word", lowercase to
             * U+03C2 = GREEK SMALL LETTER FINAL SIGMA.  Otherwise
             * fall through and let the normal rules lowercase it to
             * U+03C3 = GREEK SMALL LETTER SIGMA.
             */
            cp = 0x03c2L;
            goto singlechar;
        }
 
        /* XXX: lithuanian not implemented */
        /* XXX: lithuanian, explicit dot rules */
        /* XXX: turkish / azeri, lowercase rules */
    }
 
    /* 1:1 or special conversions, but not locale/context specific: script generated rules */
    DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
    if (uppercase) {
        bd_ctx.data = (const duk_uint8_t *) duk_unicode_caseconv_uc;
        bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_uc);
    } else {

References DUK_BW_WRITE_RAW_XUTF8.

◆ duk__ceil()

DUK_LOCAL double duk__ceil ( double x )

Definition at line 32747 of file duktape-1.8.0/src/duktape.c.

◆ duk__check_arguments_map_for_delete()

DUK_LOCAL_DECL void duk__check_arguments_map_for_delete	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_propdesc *	temp_desc )

Definition at line 48945 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                  {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *map;
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    if (!duk_hobject_get_own_propdesc(thr, obj, DUK_HTHREAD_STRING_INT_MAP(thr), temp_desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {

◆ duk__check_arguments_map_for_get()

DUK_LOCAL_DECL duk_bool_t duk__check_arguments_map_for_get	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_propdesc *	temp_desc )

Definition at line 48863 of file duktape-1.8.0/src/duktape.c.

                                             : %!dO", (duk_heaphdr *) varenv));
 
    /* success: leave varname in stack */
    *out_map = map;
    *out_varenv = varenv;
    return 1;  /* [... varname] */
}
 
/* Lookup 'key' from arguments internal 'map', and leave replacement value
 * on stack top if mapped (and return non-zero).
 * Used in E5 Section 10.6 algorithm for [[GetOwnProperty]] (used by [[Get]]).
 */
DUK_LOCAL duk_bool_t duk__check_arguments_map_for_get(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc) {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *map;
    duk_hobject *varenv;
    duk_hstring *varname;
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) {
        DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic get behavior"));
        return 0;
    }
 
    /* [... varname] */
 
    varname = duk_require_hstring(ctx, -1);

◆ duk__check_arguments_map_for_put()

DUK_LOCAL_DECL void duk__check_arguments_map_for_put	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_propdesc *	temp_desc,
		duk_bool_t	throw_flag )

Definition at line 48901 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                      {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *map;
    duk_hobject *varenv;
    duk_hstring *varname;
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) {
        DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic put behavior"));
        return;
    }
 
    /* [... put_value varname] */
 
    varname = duk_require_hstring(ctx, -1);
    DUK_ASSERT(varname != NULL);
    duk_pop(ctx);  /* varname is still reachable */
 
    DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; "
                         "key=%!O, varname=%!O, value=%!T",
                         (duk_heaphdr *) key,

Referenced by duk_hobject_putprop().

◆ duk__clamp_startend_negidx_shifted()

DUK_LOCAL void duk__clamp_startend_negidx_shifted	(	duk_context *	ctx,
		duk_hbufferobject *	h_bufobj,
		duk_idx_t	idx_start,
		duk_idx_t	idx_end,
		duk_int_t *	out_start_offset,
		duk_int_t *	out_end_offset )

Definition at line 22057 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_int_t buffer_length;
    duk_int_t start_offset;
    duk_int_t end_offset;
 
    DUK_ASSERT(out_start_offset != NULL);
    DUK_ASSERT(out_end_offset != NULL);
 
    buffer_length = (duk_int_t) h_bufobj->length;
    buffer_length >>= h_bufobj->shift;  /* as elements */
 
    /* Resolve start/end offset as element indices first; arguments
     * at idx_start/idx_end are element offsets.  Working with element
     * indices first also avoids potential for wrapping.
     */
 
    start_offset = duk_to_int(ctx, idx_start);
    if (start_offset < 0) {
        start_offset = buffer_length + start_offset;
    }
    if (duk_is_undefined(ctx, idx_end)) {
        end_offset = buffer_length;
    } else {
        end_offset = duk_to_int(ctx, idx_end);
        if (end_offset < 0) {
            end_offset = buffer_length + end_offset;
        }
    }
    /* Note: start_offset/end_offset can still be < 0 here. */
 
    if (start_offset < 0) {
        start_offset = 0;
    } else if (start_offset > buffer_length) {
        start_offset = buffer_length;
    }
    if (end_offset < start_offset) {

Referenced by duk_bi_buffer_slice_shared().

◆ duk__clamp_startend_nonegidx_noshift()

DUK_LOCAL void duk__clamp_startend_nonegidx_noshift	(	duk_context *	ctx,
		duk_hbufferobject *	h_bufobj,
		duk_idx_t	idx_start,
		duk_idx_t	idx_end,
		duk_int_t *	out_start_offset,
		duk_int_t *	out_end_offset )

Definition at line 22015 of file duktape-1.8.0/src/duktape.c.

           :
    DUK_ERROR_RANGE(thr, DUK_STR_INVALID_CALL_ARGS);
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
/* Shared lenient buffer length clamping helper.  No negative indices, no
 * element/byte shifting.
 */
DUK_LOCAL void duk__clamp_startend_nonegidx_noshift(duk_context *ctx,
                                                    duk_hbufferobject *h_bufobj,
                                                    duk_idx_t idx_start,
                                                    duk_idx_t idx_end,
                                                    duk_int_t *out_start_offset,
                                                    duk_int_t *out_end_offset) {
    duk_int_t buffer_length;
    duk_int_t start_offset;
    duk_int_t end_offset;
 
    DUK_ASSERT(out_start_offset != NULL);
    DUK_ASSERT(out_end_offset != NULL);
 
    buffer_length = (duk_int_t) h_bufobj->length;
 

◆ duk__cleanup_varmap()

DUK_LOCAL_DECL duk_int_t duk__cleanup_varmap ( duk_compiler_ctx * comp_ctx )

Definition at line 58295 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *h_varmap;
    duk_hstring *h_key;
    duk_tval *tv;
    duk_uint32_t i, e_next;
    duk_int_t ret;
 
    /* [ ... varmap ] */
 
    h_varmap = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
    DUK_ASSERT(h_varmap != NULL);
 
    ret = 0;
    e_next = DUK_HOBJECT_GET_ENEXT(h_varmap);
    for (i = 0; i < e_next; i++) {
        h_key = DUK_HOBJECT_E_GET_KEY(thr->heap, h_varmap, i);
        if (!h_key) {
            continue;
        }
 
        DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h_varmap, i));
 
        /* The entries can either be register numbers or 'null' values.
         * Thus, no need to DECREF them and get side effects.  DECREF'ing
         * the keys (strings) can cause memory to be freed but no side
         * effects as strings don't have finalizers.  This is why we can
         * rely on the object properties not changing from underneath us.

◆ duk__clear_finalize_list_flags()

DUK_LOCAL void duk__clear_finalize_list_flags ( duk_heap * heap )

Definition at line 42684 of file duktape-1.8.0/src/duktape.c.

◆ duk__clear_refzero_list_flags()

DUK_LOCAL void duk__clear_refzero_list_flags ( duk_heap * heap )

Definition at line 42657 of file duktape-1.8.0/src/duktape.c.

                                                                                       : %p", (void *) hdr));
            duk_heaphdr_refcount_finalize(thr, hdr);
        }
 
        hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
    }
}
#endif  /* DUK_USE_REFERENCE_COUNTING */
 
/*
 *  Clear (reachable) flags of refzero work list.

◆ duk__coerce_effective_this_binding()

DUK_LOCAL void duk__coerce_effective_this_binding	(	duk_hthread *	thr,
		duk_hobject *	func,
		duk_idx_t	idx_this )

Definition at line 55649 of file duktape-1.8.0/src/duktape.c.

                      :
 *
 *    - global code: this=global object
 *    - direct eval: this=copy from eval() caller's this binding
 *    - other eval:  this=global object
 *
 *  Note: this function may cause a recursive function call with arbitrary
 *  side effects, because ToObject() may be called.
 */
 
DUK_LOCAL void duk__coerce_effective_this_binding(duk_hthread *thr,
                                                  duk_hobject *func,
                                                  duk_idx_t idx_this) {
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_this;
    duk_hobject *obj_global;
 
    if (func == NULL || DUK_HOBJECT_HAS_STRICT(func)) {
        /* Lightfuncs are always considered strict. */
        DUK_DDD(DUK_DDDPRINT("this binding: strict -> use directly"));
        return;
    }
 
    /* XXX: byte offset */
    tv_this = thr->valstack_bottom + idx_this;
    switch (DUK_TVAL_GET_TAG(tv_this)) {
    case DUK_TAG_OBJECT:
    case DUK_TAG_LIGHTFUNC:  /* lightfuncs are treated like objects and not coerced */
        DUK_DDD(DUK_DDDPRINT("this binding: non-strict, object -> use directly"));
        break;
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
        DUK_DDD(DUK_DDDPRINT("this binding: non-strict, undefined/null -> use global object"));
        obj_global = thr->builtins[DUK_BIDX_GLOBAL];
        /* XXX: avoid this check somehow */
        if (DUK_LIKELY(obj_global != NULL)) {
            DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_this));  /* no need to decref previous value */
            DUK_TVAL_SET_OBJECT(tv_this, obj_global);

References duk_hthread::builtins, DUK_ASSERT, DUK_BIDX_GLOBAL, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, DUK_HOBJECT_HAS_STRICT, DUK_HOBJECT_INCREF, DUK_LIKELY, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_UNDEFINED, DUK_TVAL_GET_TAG, DUK_TVAL_IS_HEAP_ALLOCATED, DUK_TVAL_SET_OBJECT, NULL, and duk_hthread::valstack_bottom.

Referenced by duk_handle_ecma_call_setup().

◆ duk__compact_object_list()

DUK_LOCAL void duk__compact_object_list	(	duk_heap *	heap,
		duk_hthread *	thr,
		duk_heaphdr *	start )

Definition at line 43137 of file duktape-1.8.0/src/duktape.c.

                                                              {
    /* XXX: for threads, compact value stack, call stack, catch stack? */
 
    duk_hobject *obj = duk_get_hobject(ctx, -1);
    DUK_ASSERT(obj != NULL);
    duk_hobject_compact_props((duk_hthread *) ctx, obj);
    return 0;
}
 
#ifdef DUK_USE_DEBUG
DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start, duk_size_t *p_count_check, duk_size_t *p_count_compact, duk_size_t *p_count_bytes_saved) {
#else
DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start) {
#endif
    duk_heaphdr *curr;
#ifdef DUK_USE_DEBUG
    duk_size_t old_size, new_size;
#endif
    duk_hobject *obj;
 
    DUK_UNREF(heap);
 
    curr = start;
    while (curr) {
        DUK_DDD(DUK_DDDPRINT("mark-and-sweep compact: %p", (void *) curr));
 
        if (DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_OBJECT) {
            goto next;
        }
        obj = (duk_hobject *) curr;
 
#ifdef DUK_USE_DEBUG
        old_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
                                              DUK_HOBJECT_GET_ASIZE(obj),
                                              DUK_HOBJECT_GET_HSIZE(obj));
#endif
 
        DUK_DD(DUK_DDPRINT("compact object: %p", (void *) obj));
        duk_push_hobject((duk_context *) thr, obj);
        /* XXX: disable error handlers for duration of compaction? */
        duk_safe_call((duk_context *) thr, duk__protected_compact_object, 1, 0);
 
#ifdef DUK_USE_DEBUG

References DUK_ASSERT, duk_get_hobject(), duk_hobject_compact_props(), and NULL.

◆ duk__compact_objects()

DUK_LOCAL void duk__compact_objects ( duk_heap * heap )

Definition at line 43186 of file duktape-1.8.0/src/duktape.c.

         :
        curr = DUK_HEAPHDR_GET_NEXT(heap, curr);
#ifdef DUK_USE_DEBUG
        (*p_count_check)++;
#endif
    }
}
 
DUK_LOCAL void duk__compact_objects(duk_heap *heap) {
    /* XXX: which lists should participate?  to be finalized? */
#ifdef DUK_USE_DEBUG
    duk_size_t count_check = 0;
    duk_size_t count_compact = 0;
    duk_size_t count_bytes_saved = 0;
#endif
    duk_hthread *thr;
 
    DUK_DD(DUK_DDPRINT("duk__compact_objects: %p", (void *) heap));
 
    thr = duk__get_temp_hthread(heap);
    DUK_ASSERT(thr != NULL);
 
#ifdef DUK_USE_DEBUG
    duk__compact_object_list(heap, thr, heap->heap_allocated, &count_check, &count_compact, &count_bytes_saved);

◆ duk__compute_a_stats()

DUK_LOCAL void duk__compute_a_stats	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_uint32_t *	out_used,
		duk_uint32_t *	out_min_size )

Definition at line 47659 of file duktape-1.8.0/src/duktape.c.

                                                     {
        if (*e++) {
            n++;
        }
    }
    return (duk_uint32_t) n;
}
 
/* Count actually used array part entries and array minimum size.
 * NOTE: 'out_min_size' can be computed much faster by starting from the
 * end and breaking out early when finding first used entry, but this is
 * not needed now.
 */
DUK_LOCAL void duk__compute_a_stats(duk_hthread *thr, duk_hobject *obj, duk_uint32_t *out_used, duk_uint32_t *out_min_size) {
    duk_uint_fast32_t i;
    duk_uint_fast32_t used = 0;
    duk_uint_fast32_t highest_idx = (duk_uint_fast32_t) -1;  /* see below */
    duk_tval *a;
 
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(out_used != NULL);
    DUK_ASSERT(out_min_size != NULL);
    DUK_UNREF(thr);
 

Referenced by duk_hobject_putprop().

◆ duk__compute_mod()

DUK_LOCAL duk_double_t duk__compute_mod	(	duk_double_t	d1,
		duk_double_t	d2 )

Definition at line 65609 of file duktape-1.8.0/src/duktape.c.

◆ duk__concat_and_join_helper()

DUK_LOCAL void duk__concat_and_join_helper	(	duk_context *	ctx,
		duk_idx_t	count_in,
		duk_bool_t	is_join )

Definition at line 19800 of file duktape-1.8.0/src/duktape.c.

                                                                                     {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk_push_string_tval_readable(ctx, duk_get_tval(ctx, index));
}
#endif  /* !DUK_USE_PARANOID_ERRORS */
 
#undef DUK__CHECK_SPACE
#undef DUK__PACK_ARGS
#undef DUK__READABLE_STRING_MAXCHARS
#line 1 "duk_api_string.c"
/*
 *  String manipulation
 */
 
/* include removed: duk_internal.h */
 
DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, duk_bool_t is_join) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uint_t count;
    duk_uint_t i;
    duk_size_t idx;
    duk_size_t len;
    duk_hstring *h;
    duk_uint8_t *buf;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (DUK_UNLIKELY(count_in <= 0)) {
        if (count_in < 0) {
            DUK_ERROR_API(thr, DUK_STR_INVALID_COUNT);
            return;
        }
        DUK_ASSERT(count_in == 0);
        duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
        return;
    }
    count = (duk_uint_t) count_in;
 
    if (is_join) {
        duk_size_t t1, t2, limit;
        h = duk_to_hstring(ctx, -((duk_idx_t) count) - 1);
        DUK_ASSERT(h != NULL);
 
        /* A bit tricky overflow test, see doc/code-issues.rst. */
        t1 = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
        t2 = (duk_size_t) (count - 1);
        limit = (duk_size_t) DUK_HSTRING_MAX_BYTELEN;
        if (DUK_UNLIKELY(t2 != 0 && t1 > limit / t2)) {
            /* Combined size of separators already overflows */
            goto error_overflow;
        }
        len = (duk_size_t) (t1 * t2);
    } else {
        len = (duk_size_t) 0;
    }
 
    for (i = count; i >= 1; i--) {
        duk_size_t new_len;
        duk_to_string(ctx, -((duk_idx_t) i));
        h = duk_require_hstring(ctx, -((duk_idx_t) i));
        new_len = len + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
 
        /* Impose a string maximum length, need to handle overflow
         * correctly.
         */
        if (new_len < len ||  /* wrapped */
            new_len > (duk_size_t) DUK_HSTRING_MAX_BYTELEN) {
            goto error_overflow;
        }
        len = new_len;
    }
 
    DUK_DDD(DUK_DDDPRINT("join/concat %lu strings, total length %lu bytes",
                         (unsigned long) count, (unsigned long) len));
 
    /* use stack allocated buffer to ensure reachability in errors (e.g. intern error) */
    buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, len);
    DUK_ASSERT(buf != NULL);
 
    /* [... (sep) str1 str2 ... strN buf] */
 
    idx = 0;
    for (i = count; i >= 1; i--) {
        if (is_join && i != count) {
            h = duk_require_hstring(ctx, -((duk_idx_t) count) - 2);  /* extra -1 for buffer */
            DUK_MEMCPY(buf + idx, DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
            idx += DUK_HSTRING_GET_BYTELEN(h);
        }
        h = duk_require_hstring(ctx, -((duk_idx_t) i) - 1);  /* extra -1 for buffer */
        DUK_MEMCPY(buf + idx, DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
        idx += DUK_HSTRING_GET_BYTELEN(h);
    }
 
    DUK_ASSERT(idx == len);
 
    /* [... (sep) str1 str2 ... strN buf] */
 
    /* get rid of the strings early to minimize memory use before intern */
 
    if (is_join) {

References DUK_ASSERT_CTX_VALID, duk_get_tval(), duk_push_string_tval_readable(), and index.

Referenced by duk_decode_string().

◆ duk__convert_to_func_template()

DUK_LOCAL_DECL void duk__convert_to_func_template	(	duk_compiler_ctx *	comp_ctx,
		duk_bool_t	force_no_namebind )

Definition at line 58346 of file duktape-1.8.0/src/duktape.c.

               {
            ret++;
        }
    }
 
    duk_compact(ctx, -1);
 
    return ret;
}
 
/* convert duk_compiler_func into a function template, leaving the result
 * on top of stack.
 */
/* XXX: awkward and bloated asm -- use faster internal accesses */
DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind) {
    duk_compiler_func *func = &comp_ctx->curr_func;
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_hcompiledfunction *h_res;
    duk_hbuffer_fixed *h_data;
    duk_size_t consts_count;
    duk_size_t funcs_count;
    duk_size_t code_count;
    duk_size_t code_size;
    duk_size_t data_size;
    duk_size_t i;
    duk_tval *p_const;
    duk_hobject **p_func;
    duk_instr_t *p_instr;
    duk_compiler_instr *q_instr;
    duk_tval *tv;
 
    DUK_DDD(DUK_DDDPRINT("converting duk_compiler_func to function/template"));
 
    /*
     *  Push result object and init its flags
     */
 
    /* Valstack should suffice here, required on function valstack init */
 
    (void) duk_push_compiledfunction(ctx);
    h_res = (duk_hcompiledfunction *) DUK_GET_HOBJECT_NEGIDX(ctx, -1);  /* XXX: specific getter */
    DUK_ASSERT(h_res != NULL);
 
    if (func->is_function) {
        DUK_DDD(DUK_DDDPRINT("function -> set NEWENV"));
        DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res);
 
        if (!func->is_arguments_shadowed) {
            /* arguments object would be accessible; note that shadowing
             * bindings are arguments or function declarations, neither
             * of which are deletable, so this is safe.
             */
 
            if (func->id_access_arguments || func->may_direct_eval) {
                DUK_DDD(DUK_DDDPRINT("function may access 'arguments' object directly or "
                                     "indirectly -> set CREATEARGS"));
                DUK_HOBJECT_SET_CREATEARGS((duk_hobject *) h_res);
            }
        }
    } else if (func->is_eval && func->is_strict) {
        DUK_DDD(DUK_DDDPRINT("strict eval code -> set NEWENV"));
        DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res);
    } else {
        /* non-strict eval: env is caller's env or global env (direct vs. indirect call)
         * global code: env is is global env
         */
        DUK_DDD(DUK_DDDPRINT("non-strict eval code or global code -> no NEWENV"));
        DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) h_res));
    }
 
    if (func->is_function && !func->is_decl && func->h_name != NULL && !force_no_namebind) {
        /* Object literal set/get functions have a name (property
         * name) but must not have a lexical name binding, see
         * test-bug-getset-func-name.js.
         */
        DUK_DDD(DUK_DDDPRINT("function expression with a name -> set NAMEBINDING"));
        DUK_HOBJECT_SET_NAMEBINDING((duk_hobject *) h_res);
    }
 
    if (func->is_strict) {
        DUK_DDD(DUK_DDDPRINT("function is strict -> set STRICT"));
        DUK_HOBJECT_SET_STRICT((duk_hobject *) h_res);
    }
 
    if (func->is_notail) {
        DUK_DDD(DUK_DDDPRINT("function is notail -> set NOTAIL"));
        DUK_HOBJECT_SET_NOTAIL((duk_hobject *) h_res);
    }
 
    /*
     *  Build function fixed size 'data' buffer, which contains bytecode,
     *  constants, and inner function references.
     *
     *  During the building phase 'data' is reachable but incomplete.
     *  Only incref's occur during building (no refzero or GC happens),
     *  so the building process is atomic.
     */
 
    consts_count = duk_hobject_get_length(thr, func->h_consts);
    funcs_count = duk_hobject_get_length(thr, func->h_funcs) / 3;
    code_count = DUK_BW_GET_SIZE(thr, &func->bw_code) / sizeof(duk_compiler_instr);
    code_size = code_count * sizeof(duk_instr_t);
 
    data_size = consts_count * sizeof(duk_tval) +
                funcs_count * sizeof(duk_hobject *) +
                code_size;
 
    DUK_DDD(DUK_DDDPRINT("consts_count=%ld, funcs_count=%ld, code_size=%ld -> "
                         "data_size=%ld*%ld + %ld*%ld + %ld = %ld",
                         (long) consts_count, (long) funcs_count, (long) code_size,
                         (long) consts_count, (long) sizeof(duk_tval),
                         (long) funcs_count, (long) sizeof(duk_hobject *),
                         (long) code_size, (long) data_size));
 
    duk_push_fixed_buffer(ctx, data_size);
    h_data = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1);
    DUK_ASSERT(h_data != NULL);
 
    DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_res, (duk_hbuffer *) h_data);
    DUK_HEAPHDR_INCREF(thr, h_data);
 
    p_const = (duk_tval *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data);
    for (i = 0; i < consts_count; i++) {
        DUK_ASSERT(i <= DUK_UARRIDX_MAX);  /* const limits */
        tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_consts, (duk_uarridx_t) i);
        DUK_ASSERT(tv != NULL);
        DUK_TVAL_SET_TVAL(p_const, tv);
        p_const++;
        DUK_TVAL_INCREF(thr, tv);  /* may be a string constant */
 
        DUK_DDD(DUK_DDDPRINT("constant: %!T", (duk_tval *) tv));
    }
 
    p_func = (duk_hobject **) p_const;
    DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_res, p_func);
    for (i = 0; i < funcs_count; i++) {
        duk_hobject *h;
        DUK_ASSERT(i * 3 <= DUK_UARRIDX_MAX);  /* func limits */
        tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_funcs, (duk_uarridx_t) (i * 3));
        DUK_ASSERT(tv != NULL);
        DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
        h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(h));
        *p_func++ = h;
        DUK_HOBJECT_INCREF(thr, h);
 
        DUK_DDD(DUK_DDDPRINT("inner function: %p -> %!iO",
                             (void *) h, (duk_heaphdr *) h));
    }
 
    p_instr = (duk_instr_t *) p_func;
    DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_res, p_instr);
 
    /* copy bytecode instructions one at a time */
    q_instr = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(thr, &func->bw_code);
    for (i = 0; i < code_count; i++) {
        p_instr[i] = q_instr[i].ins;
    }
    /* Note: 'q_instr' is still used below */
 
    DUK_ASSERT((duk_uint8_t *) (p_instr + code_count) == DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data) + data_size);
 
    duk_pop(ctx);  /* 'data' (and everything in it) is reachable through h_res now */
 
    /*
     *  Init object properties
     *
     *  Properties should be added in decreasing order of access frequency.
     *  (Not very critical for function templates.)
     */
 
    DUK_DDD(DUK_DDDPRINT("init function properties"));
 
    /* [ ... res ] */
 
    /* _Varmap: omitted if function is guaranteed not to do slow path identifier
     * accesses or if it would turn out to be empty of actual register mappings
     * after a cleanup.  When debugging is enabled, we always need the varmap to
     * be able to lookup variables at any point.
     */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    if (1) {
#else
    if (func->id_access_slow ||     /* directly uses slow accesses */
        func->may_direct_eval ||    /* may indirectly slow access through a direct eval */
        funcs_count > 0) {          /* has inner functions which may slow access (XXX: this can be optimized by looking at the inner functions) */
#endif
        duk_int_t num_used;
        duk_dup(ctx, func->varmap_idx);
        num_used = duk__cleanup_varmap(comp_ctx);
        DUK_DDD(DUK_DDDPRINT("cleaned up varmap: %!T (num_used=%ld)",
                             (duk_tval *) duk_get_tval(ctx, -1), (long) num_used));
 
        if (num_used > 0) {
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE);
        } else {
            DUK_DDD(DUK_DDDPRINT("varmap is empty after cleanup -> no need to add"));
            duk_pop(ctx);
        }
    }
 
    /* _Formals: omitted if function is guaranteed not to need a (non-strict) arguments object */
    if (1) {
        /* XXX: Add a proper condition.  If formals list is omitted, recheck
         * handling for 'length' in duk_js_push_closure(); it currently relies
         * on _Formals being set.  Removal may need to be conditional to debugging
         * being enabled/disabled too.
         */
        duk_dup(ctx, func->argnames_idx);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE);
    }
 
    /* name */
    if (func->h_name) {
        duk_push_hstring(ctx, func->h_name);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
    }
 
    /* _Source */
#if defined(DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY)
    if (0) {
        /* XXX: Currently function source code is not stored, as it is not
         * required by the standard.  Source code should not be stored by
         * default (user should enable it explicitly), and the source should
         * probably be compressed with a trivial text compressor; average
         * compression of 20-30% is quite easy to achieve even with a trivial
         * compressor (RLE + backwards lookup).
         *
         * Debugging needs source code to be useful: sometimes input code is
         * not found in files as it may be generated and then eval()'d, given
         * by dynamic C code, etc.
         *
         * Other issues:
         *
         *   - Need tokenizer indices for start and end to substring
         *   - Always normalize function declaration part?
         *   - If we keep _Formals, only need to store body
         */
 
        /*
         *  For global or eval code this is straightforward.  For functions
         *  created with the Function constructor we only get the source for
         *  the body and must manufacture the "function ..." part.
         *
         *  For instance, for constructed functions (v8):
         *
         *    > a = new Function("foo", "bar", "print(foo)");
         *    [Function]
         *    > a.toString()
         *    'function anonymous(foo,bar) {\nprint(foo)\n}'
         *
         *  Similarly for e.g. getters (v8):
         *
         *    > x = { get a(foo,bar) { print(foo); } }
         *    { a: [Getter] }
         *    > Object.getOwnPropertyDescriptor(x, 'a').get.toString()
         *    'function a(foo,bar) { print(foo); }'
         */
 
#if 0
        duk_push_string(ctx, "XXX");
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_SOURCE, DUK_PROPDESC_FLAGS_NONE);
#endif
    }
#endif  /* DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY */
 
    /* _Pc2line */
#if defined(DUK_USE_PC2LINE)
    if (1) {
        /*
         *  Size-optimized pc->line mapping.
         */
 
        DUK_ASSERT(code_count <= DUK_COMPILER_MAX_BYTECODE_LENGTH);
        duk_hobject_pc2line_pack(thr, q_instr, (duk_uint_fast32_t) code_count);  /* -> pushes fixed buffer */
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_NONE);
 
        /* XXX: if assertions enabled, walk through all valid PCs
         * and check line mapping.
         */
    }
#endif  /* DUK_USE_PC2LINE */
 
    /* fileName */
    if (comp_ctx->h_filename) {
        /*
         *  Source filename (or equivalent), for identifying thrown errors.
         */
 
        duk_push_hstring(ctx, comp_ctx->h_filename);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_NONE);
    }
 
    /*
     *  Init remaining result fields
     *
     *  'nregs' controls how large a register frame is allocated.
     *
     *  'nargs' controls how many formal arguments are written to registers:
     *  r0, ... r(nargs-1).  The remaining registers are initialized to
     *  undefined.
     */
 
    DUK_ASSERT(func->temp_max >= 0);
    h_res->nregs = (duk_uint16_t) func->temp_max;
    h_res->nargs = (duk_uint16_t) duk_hobject_get_length(thr, func->h_argnames);
    DUK_ASSERT(h_res->nregs >= h_res->nargs);  /* pass2 allocation handles this */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    h_res->start_line = (duk_uint32_t) func->min_line;
    h_res->end_line = (duk_uint32_t) func->max_line;
#endif
 
    DUK_DD(DUK_DDPRINT("converted function: %!ixT",
                       (duk_tval *) duk_get_tval(ctx, -1)));
 
    /*
     *  Compact the function template.
     */
 
    duk_compact(ctx, -1);
 
    /*
     *  Debug dumping
     */
 
#ifdef DUK_USE_DDDPRINT
    {
        duk_hcompiledfunction *h;
        duk_instr_t *p, *p_start, *p_end;
 
        h = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
        p_start = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, h);
        p_end = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, h);

◆ duk__copy_ispec()

DUK_LOCAL_DECL void duk__copy_ispec	(	duk_compiler_ctx *	comp_ctx,
		duk_ispec *	src,
		duk_ispec *	dst )

Definition at line 59530 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    DUK_D(DUK_DPRINT("ivalue dump: t=%ld op=%ld "
                     "x1={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T} "
                     "x2={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T}",
                 (long) x->t, (long) x->op,

◆ duk__copy_ivalue()

DUK_LOCAL_DECL void duk__copy_ivalue	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	src,
		duk_ivalue *	dst )

Definition at line 59538 of file duktape-1.8.0/src/duktape.c.

                                       {} while (0)
#define DUK__DUMP_IVALUE(comp_ctx,x) do {} while (0)
#endif
 
DUK_LOCAL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst) {
    duk_context *ctx = (duk_context *) comp_ctx->thr;
 

◆ duk__cos()

DUK_LOCAL double duk__cos ( double x )

Definition at line 32750 of file duktape-1.8.0/src/duktape.c.

32752 {

◆ duk__count_used_e_keys()

DUK_LOCAL duk_uint32_t duk__count_used_e_keys	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 47637 of file duktape-1.8.0/src/duktape.c.

                                                                {
    duk_uint32_t res;
 
    DUK_ASSERT((duk_size_t) a_size <= DUK_HOBJECT_MAX_PROPERTIES);
 
    res = (a_size + DUK_HOBJECT_A_MIN_GROW_ADD) / DUK_HOBJECT_A_MIN_GROW_DIVISOR;
    DUK_ASSERT(res >= 1);  /* important for callers */
    return res;
}
 

◆ duk__count_used_probe()

DUK_LOCAL duk_int_t duk__count_used_probe ( duk_heap * heap )

Definition at line 45474 of file duktape-1.8.0/src/duktape.c.

                                                          {
    duk_int_t res = 0;
    duk_uint_fast32_t i, n;

◆ duk__create_arguments_object()

DUK_LOCAL void duk__create_arguments_object	(	duk_hthread *	thr,
		duk_hobject *	func,
		duk_hobject *	varenv,
		duk_idx_t	idx_argbase,
		duk_idx_t	num_stack_args )

Definition at line 55091 of file duktape-1.8.0/src/duktape.c.

                                                                      {   /* num args starting from idx_argbase */
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *arg;          /* 'arguments' */
    duk_hobject *formals;      /* formals for 'func' (may be NULL if func is a C function) */
    duk_idx_t i_arg;
    duk_idx_t i_map;
    duk_idx_t i_mappednames;
    duk_idx_t i_formals;
    duk_idx_t i_argbase;
    duk_idx_t n_formals;
    duk_idx_t idx;
    duk_bool_t need_map;
 
    DUK_DDD(DUK_DDDPRINT("creating arguments object for func=%!iO, varenv=%!iO, "
                         "idx_argbase=%ld, num_stack_args=%ld",
                         (duk_heaphdr *) func, (duk_heaphdr *) varenv,
                         (long) idx_argbase, (long) num_stack_args));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_NONBOUND_FUNCTION(func));
    DUK_ASSERT(varenv != NULL);
    DUK_ASSERT(idx_argbase >= 0);  /* assumed to bottom relative */
    DUK_ASSERT(num_stack_args >= 0);
 
    need_map = 0;
 
    i_argbase = idx_argbase;
    DUK_ASSERT(i_argbase >= 0);
 
    duk_push_hobject(ctx, func);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_FORMALS);
    formals = duk_get_hobject(ctx, -1);
    n_formals = 0;
    if (formals) {
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);
        n_formals = (duk_idx_t) duk_require_int(ctx, -1);
        duk_pop(ctx);
    }
    duk_remove(ctx, -2);  /* leave formals on stack for later use */
    i_formals = duk_require_top_index(ctx);
 
    DUK_ASSERT(n_formals >= 0);
    DUK_ASSERT(formals != NULL || n_formals == 0);
 
    DUK_DDD(DUK_DDDPRINT("func=%!O, formals=%!O, n_formals=%ld",
                         (duk_heaphdr *) func, (duk_heaphdr *) formals,
                         (long) n_formals));
 
    /* [ ... formals ] */
 
    /*
     *  Create required objects:
     *    - 'arguments' object: array-like, but not an array
     *    - 'map' object: internal object, tied to 'arguments'
     *    - 'mappedNames' object: temporary value used during construction
     */
 
    i_arg = duk_push_object_helper(ctx,
                                   DUK_HOBJECT_FLAG_EXTENSIBLE |
                                   DUK_HOBJECT_FLAG_ARRAY_PART |
                                   DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARGUMENTS),
                                   DUK_BIDX_OBJECT_PROTOTYPE);
    DUK_ASSERT(i_arg >= 0);
    arg = duk_require_hobject(ctx, -1);
    DUK_ASSERT(arg != NULL);
 
    i_map = duk_push_object_helper(ctx,
                                   DUK_HOBJECT_FLAG_EXTENSIBLE |
                                   DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                   -1);  /* no prototype */
    DUK_ASSERT(i_map >= 0);
 
    i_mappednames = duk_push_object_helper(ctx,
                                           DUK_HOBJECT_FLAG_EXTENSIBLE |
                                           DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                           -1);  /* no prototype */
    DUK_ASSERT(i_mappednames >= 0);
 
    /* [ ... formals arguments map mappedNames ] */
 
    DUK_DDD(DUK_DDDPRINT("created arguments related objects: "
                         "arguments at index %ld -> %!O "
                         "map at index %ld -> %!O "
                         "mappednames at index %ld -> %!O",
                         (long) i_arg, (duk_heaphdr *) duk_get_hobject(ctx, i_arg),
                         (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map),
                         (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames)));
 
    /*
     *  Init arguments properties, map, etc.
     */
 
    duk_push_int(ctx, num_stack_args);
    duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC);
 
    /*
     *  Init argument related properties
     */
 
    /* step 11 */
    idx = num_stack_args - 1;
    while (idx >= 0) {
        DUK_DDD(DUK_DDDPRINT("arg idx %ld, argbase=%ld, argidx=%ld",
                             (long) idx, (long) i_argbase, (long) (i_argbase + idx)));
 
        DUK_DDD(DUK_DDDPRINT("define arguments[%ld]=arg", (long) idx));
        duk_dup(ctx, i_argbase + idx);
        duk_xdef_prop_index_wec(ctx, i_arg, (duk_uarridx_t) idx);
        DUK_DDD(DUK_DDDPRINT("defined arguments[%ld]=arg", (long) idx));
 
        /* step 11.c is relevant only if non-strict (checked in 11.c.ii) */
        if (!DUK_HOBJECT_HAS_STRICT(func) && idx < n_formals) {
            DUK_ASSERT(formals != NULL);
 
            DUK_DDD(DUK_DDDPRINT("strict function, index within formals (%ld < %ld)",
                                 (long) idx, (long) n_formals));
 
            duk_get_prop_index(ctx, i_formals, idx);
            DUK_ASSERT(duk_is_string(ctx, -1));
 
            duk_dup(ctx, -1);  /* [ ... name name ] */
 
            if (!duk_has_prop(ctx, i_mappednames)) {
                /* steps 11.c.ii.1 - 11.c.ii.4, but our internal book-keeping
                 * differs from the reference model
                 */
 
                /* [ ... name ] */
 
                need_map = 1;
 
                DUK_DDD(DUK_DDDPRINT("set mappednames[%s]=%ld",
                                     (const char *) duk_get_string(ctx, -1),
                                     (long) idx));
                duk_dup(ctx, -1);                      /* name */
                duk_push_uint(ctx, (duk_uint_t) idx);  /* index */
                duk_to_string(ctx, -1);
                duk_xdef_prop_wec(ctx, i_mappednames);  /* out of spec, must be configurable */
 
                DUK_DDD(DUK_DDDPRINT("set map[%ld]=%s",
                                     (long) idx,
                                     duk_get_string(ctx, -1)));
                duk_dup(ctx, -1);         /* name */
                duk_xdef_prop_index_wec(ctx, i_map, (duk_uarridx_t) idx);  /* out of spec, must be configurable */
            } else {
                /* duk_has_prop() popped the second 'name' */
            }
 
            /* [ ... name ] */
            duk_pop(ctx);  /* pop 'name' */
        }
 
        idx--;
    }
 
    DUK_DDD(DUK_DDDPRINT("actual arguments processed"));
 
    /* step 12 */
    if (need_map) {
        DUK_DDD(DUK_DDDPRINT("adding 'map' and 'varenv' to arguments object"));
 
        /* should never happen for a strict callee */
        DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(func));
 
        duk_dup(ctx, i_map);
        duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_MAP, DUK_PROPDESC_FLAGS_NONE);  /* out of spec, don't care */
 
        /* The variable environment for magic variable bindings needs to be
         * given by the caller and recorded in the arguments object.
         *
         * See E5 Section 10.6, the creation of setters/getters.
         *
         * The variable environment also provides access to the callee, so
         * an explicit (internal) callee property is not needed.
         */
 
        duk_push_hobject(ctx, varenv);
        duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_NONE);  /* out of spec, don't care */
    }
 
    /* steps 13-14 */
    if (DUK_HOBJECT_HAS_STRICT(func)) {
        /* Callee/caller are throwers and are not deletable etc.  They
         * could be implemented as virtual properties, but currently
         * there is no support for virtual properties which are accessors
         * (only plain virtual properties).  This would not be difficult
         * to change in duk_hobject_props, but we can make the throwers
         * normal, concrete properties just as easily.
         *
         * Note that the specification requires that the *same* thrower
         * built-in object is used here!  See E5 Section 10.6 main
         * algoritm, step 14, and Section 13.2.3 which describes the
         * thrower.  See test case test-arguments-throwers.js.
         */
 
        DUK_DDD(DUK_DDDPRINT("strict function, setting caller/callee to throwers"));
 
        duk_xdef_prop_stridx_thrower(ctx, i_arg, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
        duk_xdef_prop_stridx_thrower(ctx, i_arg, DUK_STRIDX_CALLEE, DUK_PROPDESC_FLAGS_NONE);
    } else {
        DUK_DDD(DUK_DDDPRINT("non-strict function, setting callee to actual value"));
        duk_push_hobject(ctx, func);
        duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_CALLEE, DUK_PROPDESC_FLAGS_WC);
    }
 
    /* set exotic behavior only after we're done */
    if (need_map) {
        /* Exotic behaviors are only enabled for arguments objects
         * which have a parameter map (see E5 Section 10.6 main
         * algorithm, step 12).
         *
         * In particular, a non-strict arguments object with no
         * mapped formals does *NOT* get exotic behavior, even
         * for e.g. "caller" property.  This seems counterintuitive
         * but seems to be the case.
         */
 
        /* cannot be strict (never mapped variables) */
        DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(func));
 
        DUK_DDD(DUK_DDDPRINT("enabling exotic behavior for arguments object"));
        DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(arg);
    } else {
        DUK_DDD(DUK_DDDPRINT("not enabling exotic behavior for arguments object"));

◆ duk__create_escaped_source()

DUK_LOCAL void duk__create_escaped_source	(	duk_hthread *	thr,
		int	idx_pattern )

Definition at line 78487 of file duktape-1.8.0/src/duktape.c.

              :)') and otherwise replace unescaped '/' characters
 *  with '\/' regardless of where they occur in the regexp.
 *
 *  Note that normalization does not seem to be necessary for
 *  RegExp literals (e.g. '/foo/') because to be acceptable as
 *  a RegExp literal, the text between forward slashes must
 *  already match the escaping requirements (e.g. must not contain
 *  unescaped forward slashes or be empty).  Escaping IS needed
 *  for expressions like 'new Regexp("...", "")' however.
 *  Currently, we re-escape in either case.
 *
 *  Also note that we process the source here in UTF-8 encoded
 *  form.  This is correct, because any non-ASCII characters are
 *  passed through without change.
 */
 
DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern) {
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *h;
    const duk_uint8_t *p;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
    duk_uint8_t *q;
    duk_size_t i, n;
    duk_uint_fast8_t c_prev, c;
 
    h = duk_get_hstring(ctx, idx_pattern);
    DUK_ASSERT(h != NULL);
    p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
    n = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
 
    if (n == 0) {
        /* return '(?:)' */
        duk_push_hstring_stridx(ctx, DUK_STRIDX_ESCAPED_EMPTY_REGEXP);
        return;
    }
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(thr, bw, n);
    q = DUK_BW_GET_PTR(thr, bw);
 
    c_prev = (duk_uint_fast8_t) 0;
 
    for (i = 0; i < n; i++) {
        c = p[i];

References DUK_ASC_BACKSLASH, DUK_ASSERT, DUK_BW_ENSURE_RAW, DUK_BW_GET_PTR, DUK_BW_INIT_PUSHBUF, DUK_BW_SETPTR_AND_COMPACT, duk_get_hstring(), DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_push_hstring_stridx(), DUK_STRIDX_ESCAPED_EMPTY_REGEXP, duk_to_string(), and NULL.

◆ duk__date_get_indirect_magic()

DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic ( duk_context * ctx )

Definition at line 26035 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_date_prototype_get_timezone_offset(), duk_bi_date_prototype_set_time(), and duk_bi_date_prototype_to_json().

◆ duk__day_from_year()

DUK_LOCAL duk_int_t duk__day_from_year ( duk_int_t year )

Definition at line 25108 of file duktape-1.8.0/src/duktape.c.

                                                             {
    DUK_ASSERT(b > 0);
    if (a >= 0) {
        return a / b;
    } else {
        /* e.g. a = -4, b = 5  -->  -4 - 5 + 1 / 5  -->  -8 / 5  -->  -1

◆ duk__dec_array()

DUK_LOCAL_DECL void duk__dec_array ( duk_json_dec_ctx * js_ctx )

Definition at line 29902 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__dec_buffer()

DUK_LOCAL_DECL void duk__dec_buffer ( duk_json_dec_ctx * js_ctx )

Definition at line 29674 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__dec_decode_hex_escape()

DUK_LOCAL_DECL duk_uint_fast32_t duk__dec_decode_hex_escape	(	duk_json_dec_ctx *	js_ctx,
		duk_small_uint_t	n )

Definition at line 29347 of file duktape-1.8.0/src/duktape.c.

                                                              {
    DUK_ASSERT(js_ctx->p <= js_ctx->p_end);
    return *js_ctx->p;
}
 
DUK_LOCAL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx) {
    DUK_ASSERT(js_ctx->p <= js_ctx->p_end);
    return *js_ctx->p++;
}
 
DUK_LOCAL duk_uint8_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) {
    duk__dec_eat_white(js_ctx);
    return duk__dec_get(js_ctx);
}
 
/* For JX, expressing the whole unsigned 32-bit range matters. */
DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n) {
    duk_small_uint_t i;
    duk_uint_fast32_t res = 0;
    duk_uint8_t x;
    duk_small_int_t t;
 
    for (i = 0; i < n; i++) {
        /* XXX: share helper from lexer; duk_lexer.c / hexval(). */
 
        x = duk__dec_get(js_ctx);
        DUK_DDD(DUK_DDDPRINT("decode_hex_escape: i=%ld, n=%ld, res=%ld, x=%ld",
                             (long) i, (long) n, (long) res, (long) x));
 
        /* x == 0x00 (EOF) causes syntax_error */
        DUK_ASSERT(duk_hex_dectab[0] == -1);

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

◆ duk__dec_eat_white()

DUK_LOCAL_DECL void duk__dec_eat_white ( duk_json_dec_ctx * js_ctx )

Definition at line 29301 of file duktape-1.8.0/src/duktape.c.

                                                               {
    /* Shared handler to minimize parser size.  Cause will be
     * hidden, unfortunately, but we'll have an offset which
     * is often quite enough.
     */
    DUK_ERROR_FMT1(js_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FMT_INVALID_JSON,
                   (long) (js_ctx->p - js_ctx->p_start));
}
 
DUK_LOCAL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx) {
    const duk_uint8_t *p;
    duk_uint8_t t;
 
    p = js_ctx->p;
    for (;;) {
        DUK_ASSERT(p <= js_ctx->p_end);
        t = *p;
 
#if defined(DUK_USE_JSON_EATWHITE_FASTPATH)
        /* This fast path is pretty marginal in practice.
         * XXX: candidate for removal.

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

◆ duk__dec_get()

DUK_LOCAL_DECL duk_uint8_t duk__dec_get ( duk_json_dec_ctx * js_ctx )

Definition at line 29336 of file duktape-1.8.0/src/duktape.c.

                                                                 {
            /* NUL also comes here.  Comparison order matters, 0x20
             * is most common whitespace.
             */

◆ duk__dec_get_nonwhite()

DUK_LOCAL_DECL duk_uint8_t duk__dec_get_nonwhite ( duk_json_dec_ctx * js_ctx )

Definition at line 29341 of file duktape-1.8.0/src/duktape.c.

◆ duk__dec_number()

DUK_LOCAL_DECL void duk__dec_number ( duk_json_dec_ctx * js_ctx )

Definition at line 29732 of file duktape-1.8.0/src/duktape.c.

             :
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}
#endif  /* DUK_USE_JX */
 
/* Parse a number, other than NaN or +/- Infinity */
DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    const duk_uint8_t *p_start;
    const duk_uint8_t *p;
    duk_uint8_t x;
    duk_small_uint_t s2n_flags;
 
    DUK_DDD(DUK_DDDPRINT("parse_number"));
 
    p_start = js_ctx->p;
 
    /* First pass parse is very lenient (e.g. allows '1.2.3') and extracts a
     * string for strict number parsing.
     */
 
    p = js_ctx->p;
    for (;;) {
        x = *p;
 
        DUK_DDD(DUK_DDDPRINT("parse_number: p_start=%p, p=%p, p_end=%p, x=%ld",
                             (const void *) p_start, (const void *) p,
                             (const void *) js_ctx->p_end, (long) x));
 
#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH)
        /* This fast path is pretty marginal in practice.
         * XXX: candidate for removal.
         */
        DUK_ASSERT(duk__json_decnumber_lookup[0x00] == 0x00);  /* end-of-input breaks */
        if (duk__json_decnumber_lookup[x] == 0) {
            break;
        }
#else  /* DUK_USE_JSON_DECNUMBER_FASTPATH */
        if (!((x >= DUK_ASC_0 && x <= DUK_ASC_9) ||
              (x == DUK_ASC_PERIOD || x == DUK_ASC_LC_E ||
               x == DUK_ASC_UC_E || x == DUK_ASC_MINUS || x == DUK_ASC_PLUS))) {
            /* Plus sign must be accepted for positive exponents
             * (e.g. '1.5e+2').  This clause catches NULs.
             */
            break;
        }
#endif  /* DUK_USE_JSON_DECNUMBER_FASTPATH */
        p++;  /* safe, because matched (NUL causes a break) */
    }
    js_ctx->p = p;
 
    DUK_ASSERT(js_ctx->p > p_start);
    duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (p - p_start));

◆ duk__dec_objarr_entry()

DUK_LOCAL_DECL void duk__dec_objarr_entry ( duk_json_dec_ctx * js_ctx )

Definition at line 29797 of file duktape-1.8.0/src/duktape.c.

                                      : string before parsing: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
    duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags);
    if (duk_is_nan(ctx, -1)) {
        duk__dec_syntax_error(js_ctx);
    }
    DUK_ASSERT(duk_is_number(ctx, -1));
    DUK_DDD(DUK_DDDPRINT("parse_number: final number: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));

◆ duk__dec_objarr_exit()

DUK_LOCAL_DECL void duk__dec_objarr_exit ( duk_json_dec_ctx * js_ctx )

Definition at line 29811 of file duktape-1.8.0/src/duktape.c.

                                                               {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_require_stack(ctx, DUK_JSON_DEC_REQSTACK);
 

◆ duk__dec_object()

DUK_LOCAL_DECL void duk__dec_object ( duk_json_dec_ctx * js_ctx )

Definition at line 29819 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__dec_peek()

DUK_LOCAL_DECL duk_uint8_t duk__dec_peek ( duk_json_dec_ctx * js_ctx )

Definition at line 29331 of file duktape-1.8.0/src/duktape.c.

                                               {
            break;
        }

◆ duk__dec_plain_string()

DUK_LOCAL_DECL void duk__dec_plain_string ( duk_json_dec_ctx * js_ctx )

Definition at line 29577 of file duktape-1.8.0/src/duktape.c.

             :
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}
 
#ifdef DUK_USE_JX
/* Decode a plain string consisting entirely of identifier characters.
 * Used to parse plain keys (e.g. "foo: 123").
 */
DUK_LOCAL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx) {
    duk_hthread *thr = js_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    const duk_uint8_t *p;
    duk_small_int_t x;
 
    /* Caller has already eaten the first char so backtrack one byte. */
 
    js_ctx->p--;  /* safe */
    p = js_ctx->p;
 
    /* Here again we parse bytes, and non-ASCII UTF-8 will cause end of
     * parsing (which is correct except if there are non-shortest encodings).
     * There is also no need to check explicitly for end of input buffer as
     * the input is NUL padded and NUL will exit the parsing loop.
     *
     * Because no unescaping takes place, we can just scan to the end of the
     * plain string and intern from the input buffer.
     */
 
    for (;;) {
        x = *p;
 

◆ duk__dec_pointer()

DUK_LOCAL_DECL void duk__dec_pointer ( duk_json_dec_ctx * js_ctx )

Definition at line 29620 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__dec_req_stridx()

DUK_LOCAL_DECL void duk__dec_req_stridx	(	duk_json_dec_ctx *	js_ctx,
		duk_small_uint_t	stridx )

Definition at line 29380 of file duktape-1.8.0/src/duktape.c.

                                {
            res = (res * 16) + t;
        } else {
            /* catches EOF and invalid digits */
            goto syntax_error;
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("final hex decoded value: %ld", (long) res));
    return res;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
    return 0;
}
 
DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx) {
    duk_hstring *h;
    const duk_uint8_t *p;
    duk_uint8_t x, y;
 
    /* First character has already been eaten and checked by the caller.
     * We can scan until a NUL in stridx string because no built-in strings
     * have internal NULs.
     */
 
    DUK_ASSERT_DISABLE(stridx >= 0);  /* unsigned */
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx);
    DUK_ASSERT(h != NULL);
 
    p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h) + 1;
    DUK_ASSERT(*(js_ctx->p - 1) == *(p - 1));  /* first character has been matched */
 
    for (;;) {
        x = *p;

◆ duk__dec_reviver_walk()

DUK_LOCAL_DECL void duk__dec_reviver_walk ( duk_json_dec_ctx * js_ctx )

Definition at line 30042 of file duktape-1.8.0/src/duktape.c.

             :
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}
 
/* Recursive value reviver, implements the Walk() algorithm.  No C recursion
 * check is done here because the initial parsing step will already ensure
 * there is a reasonable limit on C recursion depth and hence object depth.
 */
DUK_LOCAL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx) {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hobject *h;
    duk_uarridx_t i, arr_len;
 
    DUK_DDD(DUK_DDDPRINT("walk: top=%ld, holder=%!T, name=%!T",
                         (long) duk_get_top(ctx),
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk_dup_top(ctx);
    duk_get_prop(ctx, -3);  /* -> [ ... holder name val ] */
 
    h = duk_get_hobject(ctx, -1);
    if (h != NULL) {
        if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
            arr_len = (duk_uarridx_t) duk_get_length(ctx, -1);
            for (i = 0; i < arr_len; i++) {
                /* [ ... holder name val ] */
 
                DUK_DDD(DUK_DDDPRINT("walk: array, top=%ld, i=%ld, arr_len=%ld, holder=%!T, name=%!T, val=%!T",
                                     (long) duk_get_top(ctx), (long) i, (long) arr_len,
                                     (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
                                     (duk_tval *) duk_get_tval(ctx, -1)));
 
                /* XXX: push_uint_string / push_u32_string */
                duk_dup_top(ctx);
                duk_push_uint(ctx, (duk_uint_t) i);
                duk_to_string(ctx, -1);  /* -> [ ... holder name val val ToString(i) ] */
                duk__dec_reviver_walk(js_ctx);  /* -> [ ... holder name val new_elem ] */
 
                if (duk_is_undefined(ctx, -1)) {
                    duk_pop(ctx);
                    duk_del_prop_index(ctx, -1, i);
                } else {
                    /* XXX: duk_xdef_prop_index_wec() would be more appropriate
                     * here but it currently makes some assumptions that might
                     * not hold (e.g. that previous property is not an accessor).
                     */
                    duk_put_prop_index(ctx, -2, i);
                }
            }
        } else {
            /* [ ... holder name val ] */
            duk_enum(ctx, -1, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/);
            while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) {
                DUK_DDD(DUK_DDDPRINT("walk: object, top=%ld, holder=%!T, name=%!T, val=%!T, enum=%!iT, obj_key=%!T",
                                     (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -5),
                                     (duk_tval *) duk_get_tval(ctx, -4), (duk_tval *) duk_get_tval(ctx, -3),
                                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
 
                /* [ ... holder name val enum obj_key ] */
                duk_dup(ctx, -3);
                duk_dup(ctx, -2);
 
                /* [ ... holder name val enum obj_key val obj_key ] */
                duk__dec_reviver_walk(js_ctx);
 
                /* [ ... holder name val enum obj_key new_elem ] */
                if (duk_is_undefined(ctx, -1)) {
                    duk_pop(ctx);
                    duk_del_prop(ctx, -3);
                } else {
                    /* XXX: duk_xdef_prop_index_wec() would be more appropriate
                     * here but it currently makes some assumptions that might
                     * not hold (e.g. that previous property is not an accessor).
                     *
                     * Using duk_put_prop() works incorrectly with '__proto__'
                     * if the own property with that name has been deleted.  This
                     * does not happen normally, but a clever reviver can trigger
                     * that, see complex reviver case in: test-bug-json-parse-__proto__.js.

◆ duk__dec_string()

DUK_LOCAL_DECL void duk__dec_string ( duk_json_dec_ctx * js_ctx )

Definition at line 29467 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__dec_string_escape()

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

Definition at line 29418 of file duktape-1.8.0/src/duktape.c.

                    {
            /* Catches EOF of JSON input. */
            goto syntax_error;
        }
        p++;
    }
 
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}
 
DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_uint8_t **ext_p) {
    duk_uint_fast32_t cp;
 
    /* EOF (-1) will be cast to an unsigned value first
     * and then re-cast for the switch.  In any case, it
     * will match the default case (syntax error).
     */
    cp = (duk_uint_fast32_t) duk__dec_get(js_ctx);
    switch ((int) cp) {
    case DUK_ASC_BACKSLASH: break;
    case DUK_ASC_DOUBLEQUOTE: break;
    case DUK_ASC_SLASH: break;
    case DUK_ASC_LC_T: cp = 0x09; break;
    case DUK_ASC_LC_N: cp = 0x0a; break;
    case DUK_ASC_LC_R: cp = 0x0d; break;
    case DUK_ASC_LC_F: cp = 0x0c; break;
    case DUK_ASC_LC_B: cp = 0x08; break;
    case DUK_ASC_LC_U: {
        cp = duk__dec_decode_hex_escape(js_ctx, 4);
        break;
    }
#ifdef DUK_USE_JX
    case DUK_ASC_UC_U: {
        if (js_ctx->flag_ext_custom) {
            cp = duk__dec_decode_hex_escape(js_ctx, 8);
        } else {
            return 1;  /* syntax error */
        }
        break;
    }
    case DUK_ASC_LC_X: {

◆ duk__dec_syntax_error()

DUK_LOCAL_DECL void duk__dec_syntax_error ( duk_json_dec_ctx * js_ctx )

Definition at line 29292 of file duktape-1.8.0/src/duktape.c.

◆ duk__dec_value()

DUK_LOCAL_DECL void duk__dec_value ( duk_json_dec_ctx * js_ctx )

Definition at line 29970 of file duktape-1.8.0/src/duktape.c.

                                     : final array is %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk__dec_objarr_exit(js_ctx);
    return;
 
 syntax_error:
    duk__dec_syntax_error(js_ctx);
    DUK_UNREACHABLE();
}
 
DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_uint8_t x;
 
    x = duk__dec_get_nonwhite(js_ctx);
 
    DUK_DDD(DUK_DDDPRINT("parse_value: initial x=%ld", (long) x));
 
    /* Note: duk__dec_req_stridx() backtracks one char */
 
    if (x == DUK_ASC_DOUBLEQUOTE) {
        duk__dec_string(js_ctx);
    } else if ((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_MINUS)) {
#ifdef DUK_USE_JX
        if (js_ctx->flag_ext_custom && x == DUK_ASC_MINUS && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) {
            duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY);  /* "-Infinity", '-' has been eaten */
            duk_push_number(ctx, -DUK_DOUBLE_INFINITY);
        } else {
#else
        {  /* unconditional block */
#endif
            /* We already ate 'x', so backup one byte. */
            js_ctx->p--;  /* safe */
            duk__dec_number(js_ctx);
        }
    } else if (x == DUK_ASC_LC_T) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_TRUE);
        duk_push_true(ctx);
    } else if (x == DUK_ASC_LC_F) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_FALSE);
        duk_push_false(ctx);
    } else if (x == DUK_ASC_LC_N) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_NULL);
        duk_push_null(ctx);
#ifdef DUK_USE_JX
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LC_U) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_UNDEFINED);
        duk_push_undefined(ctx);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_N) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_NAN);
        duk_push_nan(ctx);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_I) {
        duk__dec_req_stridx(js_ctx, DUK_STRIDX_INFINITY);
        duk_push_number(ctx, DUK_DOUBLE_INFINITY);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LPAREN) {
        duk__dec_pointer(js_ctx);
    } else if (js_ctx->flag_ext_custom && x == DUK_ASC_PIPE) {
        duk__dec_buffer(js_ctx);
#endif
    } else if (x == DUK_ASC_LCURLY) {

◆ duk__declvar_helper()

DUK_LOCAL duk_bool_t duk__declvar_helper	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_hstring *	name,
		duk_tval *	val,
		duk_small_int_t	prop_flags,
		duk_bool_t	is_func_decl )

Definition at line 73045 of file duktape-1.8.0/src/duktape.c.

                                                        {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *holder;
    duk_bool_t parents;
    duk__id_lookup_result ref;
    duk_tval *tv;
 
    DUK_DDD(DUK_DDDPRINT("declvar: thr=%p, env=%p, name=%!O, val=%!T, prop_flags=0x%08lx, is_func_decl=%ld "
                         "(env -> %!iO)",
                         (void *) thr, (void *) env, (duk_heaphdr *) name,
                         (duk_tval *) val, (unsigned long) prop_flags,
                         (unsigned int) is_func_decl, (duk_heaphdr *) env));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(env != NULL);
    DUK_ASSERT(name != NULL);
    DUK_ASSERT(val != NULL);
 
    /* Note: in strict mode the compiler should reject explicit
     * declaration of 'eval' or 'arguments'.  However, internal
     * bytecode may declare 'arguments' in the function prologue.
     * We don't bother checking (or asserting) for these now.
     */
 
    /* Note: val is a stable duk_tval pointer.  The caller makes
     * a value copy into its stack frame, so 'tv_val' is not subject
     * to side effects here.
     */
 
    /*
     *  Check whether already declared.
     *
     *  We need to check whether the binding exists in the environment
     *  without walking its parents.  However, we still need to check
     *  register-bound identifiers and the prototype chain of an object
     *  environment target object.
     */
 
    parents = 0;  /* just check 'env' */
    if (duk__get_identifier_reference(thr, env, name, NULL, parents, &ref)) {
        duk_int_t e_idx;
        duk_int_t h_idx;
        duk_small_int_t flags;
 
        /*
         *  Variable already declared, ignore re-declaration.
         *  The only exception is the updated behavior of E5.1 for
         *  global function declarations, E5.1 Section 10.5, step 5.e.
         *  This behavior does not apply to global variable declarations.
         */
 
        if (!(is_func_decl && env == thr->builtins[DUK_BIDX_GLOBAL_ENV])) {
            DUK_DDD(DUK_DDDPRINT("re-declare a binding, ignoring"));
            return 1;  /* 1 -> needs a PUTVAR */
        }
 
        /*
         *  Special behavior in E5.1.
         *
         *  Note that even though parents == 0, the conflicting property
         *  may be an inherited property (currently our global object's
         *  prototype is Object.prototype).  Step 5.e first operates on
         *  the existing property (which is potentially in an ancestor)
         *  and then defines a new property in the global object (and
         *  never modifies the ancestor).
         *
         *  Also note that this logic would become even more complicated
         *  if the conflicting property might be a virtual one.  Object
         *  prototype has no virtual properties, though.
         *
         *  XXX: this is now very awkward, rework.
         */
 
        DUK_DDD(DUK_DDDPRINT("re-declare a function binding in global object, "
                             "updated E5.1 processing"));
 
        DUK_ASSERT(ref.holder != NULL);
        holder = ref.holder;
 
        /* holder will be set to the target object, not the actual object
         * where the property was found (see duk__get_identifier_reference()).
         */
        DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(holder) == DUK_HOBJECT_CLASS_GLOBAL);
        DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(holder));  /* global object doesn't have array part */
 
        /* XXX: use a helper for prototype traversal; no loop check here */
        /* must be found: was found earlier, and cannot be inherited */
        for (;;) {
            DUK_ASSERT(holder != NULL);
            duk_hobject_find_existing_entry(thr->heap, holder, name, &e_idx, &h_idx);
            if (e_idx >= 0) {
                break;
            }
            /* SCANBUILD: NULL pointer dereference, doesn't actually trigger,
             * asserted above.
             */
            holder = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, holder);
        }
        DUK_ASSERT(holder != NULL);
        DUK_ASSERT(e_idx >= 0);
        /* SCANBUILD: scan-build produces a NULL pointer dereference warning
         * below; it never actually triggers because holder is actually never
         * NULL.
         */
 
        /* ref.holder is global object, holder is the object with the
         * conflicting property.
         */
 
        flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, holder, e_idx);
        if (!(flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
            if (flags & DUK_PROPDESC_FLAG_ACCESSOR) {
                DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable "
                                     "accessor -> reject"));
                goto fail_existing_attributes;
            }
            if (!((flags & DUK_PROPDESC_FLAG_WRITABLE) &&
                  (flags & DUK_PROPDESC_FLAG_ENUMERABLE))) {
                DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable "
                                     "plain property which is not writable and "
                                     "enumerable -> reject"));
                goto fail_existing_attributes;
            }
 
            DUK_DDD(DUK_DDDPRINT("existing property is not configurable but "
                                 "is plain, enumerable, and writable -> "
                                 "allow redeclaration"));
        }
 
        if (holder == ref.holder) {
            /* XXX: if duk_hobject_define_property_internal() was updated
             * to handle a pre-existing accessor property, this would be
             * a simple call (like for the ancestor case).
             */
            DUK_DDD(DUK_DDDPRINT("redefine, offending property in global object itself"));
 
            if (flags & DUK_PROPDESC_FLAG_ACCESSOR) {
                duk_hobject *tmp;
 
                tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, holder, e_idx);
                DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, holder, e_idx, NULL);
                DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
                DUK_UNREF(tmp);
                tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, holder, e_idx);
                DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, holder, e_idx, NULL);
                DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
                DUK_UNREF(tmp);
            } else {
                tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx);
                DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv);
            }
 
            /* Here val would be potentially invalid if we didn't make
             * a value copy at the caller.
             */
 
            tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx);
            DUK_TVAL_SET_TVAL(tv, val);
            DUK_TVAL_INCREF(thr, tv);
            DUK_HOBJECT_E_SET_FLAGS(thr->heap, holder, e_idx, prop_flags);
 
            DUK_DDD(DUK_DDDPRINT("updated global binding, final result: "
                                 "value -> %!T, prop_flags=0x%08lx",
                                 (duk_tval *) DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx),
                                 (unsigned long) prop_flags));
        } else {
            DUK_DDD(DUK_DDDPRINT("redefine, offending property in ancestor"));
 
            DUK_ASSERT(ref.holder == thr->builtins[DUK_BIDX_GLOBAL]);
            duk_push_tval(ctx, val);
            duk_hobject_define_property_internal(thr, ref.holder, name, prop_flags);
        }
 
        return 0;
    }
 
    /*
     *  Not found (in registers or record objects).  Declare
     *  to current variable environment.
     */
 
    /*
     *  Get holder object
     */
 
    if (DUK_HOBJECT_IS_DECENV(env)) {
        holder = env;
    } else {
        DUK_ASSERT(DUK_HOBJECT_IS_OBJENV(env));
 
        tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr));
        DUK_ASSERT(tv != NULL);
        DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
        holder = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(holder != NULL);
    }
 
    /*
     *  Define new property
     *
     *  Note: this may fail if the holder is not extensible.
     */
 
    /* XXX: this is awkward as we use an internal method which doesn't handle
     * extensibility etc correctly.  Basically we'd want to do a [[DefineOwnProperty]]
     * or Object.defineProperty() here.
     */
 

References duk_hthread::builtins, duk__get_identifier_reference(), DUK_ASSERT, DUK_BIDX_GLOBAL, DUK_BIDX_GLOBAL_ENV, DUK_DDD, DUK_DDDPRINT, DUK_HOBJECT_CLASS_GLOBAL, DUK_HOBJECT_DECREF_ALLOWNULL, duk_hobject_define_property_internal(), DUK_HOBJECT_E_GET_FLAGS, DUK_HOBJECT_E_GET_VALUE_GETTER, DUK_HOBJECT_E_GET_VALUE_SETTER, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, DUK_HOBJECT_E_SET_FLAGS, DUK_HOBJECT_E_SET_VALUE_GETTER, DUK_HOBJECT_E_SET_VALUE_SETTER, duk_hobject_find_existing_entry(), duk_hobject_find_existing_entry_tval_ptr(), DUK_HOBJECT_GET_CLASS_NUMBER, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_HOBJECT_HAS_EXTENSIBLE, DUK_HOBJECT_IS_DECENV, DUK_HOBJECT_IS_OBJENV, DUK_HTHREAD_STRING_INT_TARGET, DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, duk_push_tval(), DUK_TVAL_GET_OBJECT, DUK_TVAL_INCREF, DUK_TVAL_IS_OBJECT, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_UNDEFINED_UPDREF, DUK_UNREF, duk_hthread::heap, duk__id_lookup_result::holder, name, and NULL.

◆ duk__decode_hex_escape()

DUK_LOCAL duk_small_int_t duk__decode_hex_escape	(	const duk_uint8_t *	p,
		duk_small_int_t	n )

Definition at line 27904 of file duktape-1.8.0/src/duktape.c.

               {
    duk_hthread *thr;
    duk_hstring *h_str;
    duk_bufwriter_ctx bw;
    const duk_uint8_t *p;
    const duk_uint8_t *p_start;
    const duk_uint8_t *p_end;
} duk__transform_context;
 
typedef void (*duk__transform_callback)(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp);
 

◆ duk__decode_hexesc_from_window()

DUK_LOCAL duk_codepoint_t duk__decode_hexesc_from_window	(	duk_lexer_ctx *	lex_ctx,
		duk_small_int_t	lookup_offset )

Definition at line 73938 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ duk__decode_uniesc_from_window()

DUK_LOCAL duk_codepoint_t duk__decode_uniesc_from_window	(	duk_lexer_ctx *	lex_ctx,
		duk_small_int_t	lookup_offset )

Definition at line 73944 of file duktape-1.8.0/src/duktape.c.

                                                          {
    if (DUK_LIKELY(x >= 0 && x <= 0xff)) {
        return (duk_hex_dectab[x] >= 0);

Referenced by duk_lexer_parse_js_input_element().

◆ duk__defaultvalue_coerce_attempt()

DUK_LOCAL duk_bool_t duk__defaultvalue_coerce_attempt	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_int_t	func_stridx )

Definition at line 16783 of file duktape-1.8.0/src/duktape.c.

            {
        return;
    }
 
    duk_hobject_set_length(thr, h, (duk_uint32_t) length);  /* XXX: typing */
}
 
/*
 *  Conversions and coercions
 *
 *  The conversion/coercions are in-place operations on the value stack.
 *  Some operations are implemented here directly, while others call a
 *  helper in duk_js_ops.c after validating arguments.
 */
 
/* E5 Section 8.12.8 */

◆ duk__delvar_helper()

DUK_LOCAL duk_bool_t duk__delvar_helper	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_activation *	act,
		duk_hstring *	name )

Definition at line 72931 of file duktape-1.8.0/src/duktape.c.

                   :
 *    11.4.1 The delete operator
 *    10.2.1.1.5 DeleteBinding (N)  [declarative environment record]
 *    10.2.1.2.5 DeleteBinding (N)  [object environment record]
 *
 *  Variable bindings established inside eval() are deletable (configurable),
 *  other bindings are not, including variables declared in global level.
 *  Registers are always non-deletable, and the deletion of other bindings
 *  is controlled by the configurable flag.
 *
 *  For strict mode code, the 'delete' operator should fail with a compile
 *  time SyntaxError if applied to identifiers.  Hence, no strict mode
 *  run-time deletion of identifiers should ever happen.  This function
 *  should never be called from strict mode code!
 */
 
DUK_LOCAL
duk_bool_t duk__delvar_helper(duk_hthread *thr,
                              duk_hobject *env,
                              duk_activation *act,
                              duk_hstring *name) {
    duk__id_lookup_result ref;
    duk_bool_t parents;
 
    DUK_DDD(DUK_DDDPRINT("delvar: thr=%p, env=%p, act=%p, name=%!O "
                         "(env -> %!dO)",
                         (void *) thr, (void *) env, (void *) act,
                         (duk_heaphdr *) name, (duk_heaphdr *) env));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(name != NULL);
    /* env and act may be NULL */
 
        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
 
    parents = 1;     /* follow parent chain */
 
    if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
        if (ref.value && !(ref.attrs & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
            /* Identifier found in registers (always non-deletable)
             * or declarative environment record and non-configurable.
             */
            return 0;
        }
        DUK_ASSERT(ref.holder != NULL);

References duk__id_lookup_result::attrs, duk__get_identifier_reference(), DUK_ASSERT, DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR, DUK_DDD, DUK_DDDPRINT, duk_hobject_delprop_raw(), DUK_PROPDESC_FLAG_CONFIGURABLE, duk__id_lookup_result::holder, name, NULL, and duk__id_lookup_result::value.

◆ duk__div_floor()

DUK_LOCAL duk_int_t duk__div_floor	(	duk_int_t	a,
		duk_int_t	b )

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

                                                     {
    if (!DUK_ISFINITE(x)) {
        return DUK_DOUBLE_NAN;
    }
 
    if (!duk_bi_date_timeval_in_valid_range(x)) {
        return DUK_DOUBLE_NAN;
    }
 
    x = duk_js_tointeger_number(x);
 

References duk_bi_date_timeval_in_valid_range(), DUK_DOUBLE_NAN, DUK_ISFINITE, and duk_js_tointeger_number().

◆ duk__do_compile()

DUK_LOCAL duk_ret_t duk__do_compile ( duk_context * ctx )

Definition at line 13643 of file duktape-1.8.0/src/duktape.c.

           {
        duk_call_method(ctx, 0);
        rc = DUK_EXEC_SUCCESS;
    }
 
    /* [ ... result/error ] */
 
 got_rc:
    if (flags & DUK_COMPILE_NORESULT) {
        duk_pop(ctx);
    }
 
    return rc;
}
 
/* Helper which can be called both directly and with duk_safe_call(). */
DUK_LOCAL duk_ret_t duk__do_compile(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk__compile_raw_args *comp_args;
    duk_uint_t flags;
    duk_small_uint_t comp_flags;
    duk_hcompiledfunction *h_templ;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: strictness is not inherited from the current Duktape/C
     * context.  Otherwise it would not be possible to compile
     * non-strict code inside a Duktape/C activation (which is
     * always strict now).  See tests/api/test-eval-strictness.c
     * for discussion.
     */
 
    /* [ ... source? filename? &comp_args ] (depends on flags) */
 
    comp_args = (duk__compile_raw_args *) duk_require_pointer(ctx, -1);
    flags = comp_args->flags;
    duk_pop(ctx);
 
    /* [ ... source? filename? ] */
 
    if (flags & DUK_COMPILE_NOFILENAME) {
        /* Automatic filename: 'eval' or 'input'. */
        duk_push_hstring_stridx(ctx, (flags & DUK_COMPILE_EVAL) ? DUK_STRIDX_EVAL : DUK_STRIDX_INPUT);
    }
 
    /* [ ... source? filename ] */
 
    if (!comp_args->src_buffer) {
        duk_hstring *h_sourcecode;
 
        h_sourcecode = duk_get_hstring(ctx, -2);
        if ((flags & DUK_COMPILE_NOSOURCE) ||  /* args incorrect */
            (h_sourcecode == NULL)) {          /* e.g. duk_push_string_file_raw() pushed undefined */
            /* XXX: when this error is caused by a nonexistent
             * file given to duk_peval_file() or similar, the
             * error message is not the best possible.
             */
            DUK_ERROR_API(thr, DUK_STR_NO_SOURCECODE);
        }
        DUK_ASSERT(h_sourcecode != NULL);
        comp_args->src_buffer = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode);
        comp_args->src_length = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode);
    }
    DUK_ASSERT(comp_args->src_buffer != NULL);
 
    /* XXX: unnecessary translation of flags */
    comp_flags = 0;
    if (flags & DUK_COMPILE_EVAL) {
        comp_flags |= DUK_JS_COMPILE_FLAG_EVAL;
    }
    if (flags & DUK_COMPILE_FUNCTION) {
        comp_flags |= DUK_JS_COMPILE_FLAG_EVAL |
                      DUK_JS_COMPILE_FLAG_FUNCEXPR;
    }
    if (flags & DUK_COMPILE_STRICT) {
        comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
    }
 
    /* [ ... source? filename ] */
 
    duk_js_compile(thr, comp_args->src_buffer, comp_args->src_length, comp_flags);
 
    /* [ ... source? func_template ] */
 
    if (flags & DUK_COMPILE_NOSOURCE) {
        ;
    } else {
        duk_remove(ctx, -2);

◆ duk__do_intern()

DUK_LOCAL duk_hstring * duk__do_intern	(	duk_heap *	heap,
		const duk_uint8_t *	str,
		duk_uint32_t	blen,
		duk_uint32_t	strhash )

Definition at line 45838 of file duktape-1.8.0/src/duktape.c.

                                                                                                                       {
    duk_hstring *res;
    const duk_uint8_t *extdata;
#if defined(DUK_USE_MARK_AND_SWEEP)
    duk_small_uint_t prev_mark_and_sweep_base_flags;
#endif
 
    /* Prevent any side effects on the string table and the caller provided
     * str/blen arguments while interning is in progress.  For example, if
     * the caller provided str/blen from a dynamic buffer, a finalizer might
     * resize that dynamic buffer, invalidating the call arguments.
     */
#if defined(DUK_USE_MARK_AND_SWEEP)
    DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0);
    prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
    DUK__PREVENT_MS_SIDE_EFFECTS(heap);
#endif
 
#if defined(DUK_USE_STRTAB_PROBE)
    if (duk__recheck_strtab_size_probe(heap, heap->st_used + 1)) {
        goto failed;
    }
#endif
 
    /* For manual testing only. */
#if 0
    {
        duk_size_t i;
        DUK_PRINTF("INTERN: \"");
        for (i = 0; i < blen; i++) {
            duk_uint8_t x = str[i];
            if (x >= 0x20 && x <= 0x7e && x != '"' && x != '\\') {
                DUK_PRINTF("%c", (int) x);  /* char: use int cast */
            } else {
                DUK_PRINTF("\\x%02lx", (long) x);
            }
        }
        DUK_PRINTF("\"\n");
    }
#endif
 
#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_INTERN_CHECK)
    extdata = (const duk_uint8_t *) DUK_USE_EXTSTR_INTERN_CHECK(heap->heap_udata, (void *) DUK_LOSE_CONST(str), (duk_size_t) blen);
#else
    extdata = (const duk_uint8_t *) NULL;
#endif
    res = duk__alloc_init_hstring(heap, str, blen, strhash, extdata);
    if (!res) {
        goto failed;
    }
 
#if defined(DUK_USE_STRTAB_CHAIN)
    if (duk__insert_hstring_chain(heap, res)) {
        /* failed */
        DUK_FREE(heap, res);
        goto failed;
    }
#elif defined(DUK_USE_STRTAB_PROBE)
    /* guaranteed to succeed */
    duk__insert_hstring_probe(heap,
#if defined(DUK_USE_HEAPPTR16)
                              heap->strtable16,
#else
                              heap->strtable,
#endif
                              heap->st_size,
                              &heap->st_used,
                              res);
#else
#error internal error, invalid strtab options

Referenced by duk_heap_string_intern_checked().

◆ duk__do_lookup()

DUK_LOCAL duk_hstring * duk__do_lookup	(	duk_heap *	heap,
		const duk_uint8_t *	str,
		duk_uint32_t	blen,
		duk_uint32_t *	out_strhash )

Definition at line 45926 of file duktape-1.8.0/src/duktape.c.

     :
#if defined(DUK_USE_MARK_AND_SWEEP)
    heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
#endif
    return res;
 
 failed:
    res = NULL;
    goto done;
}
 
DUK_LOCAL duk_hstring *duk__do_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t *out_strhash) {
    duk_hstring *res;
 
    DUK_ASSERT(out_strhash);
 
    *out_strhash = duk_heap_hashstring(heap, str, (duk_size_t) blen);
 
#if defined(DUK_USE_ROM_STRINGS)
    {
        duk_small_uint_t i;
        /* XXX: This is VERY inefficient now, and should be e.g. a
         * binary search or perfect hash, to be fixed.
         */
        for (i = 0; i < (duk_small_uint_t) (sizeof(duk_rom_strings) / sizeof(duk_hstring *)); i++) {
            duk_hstring *romstr;
            romstr = (duk_hstring *) DUK_LOSE_CONST(duk_rom_strings[i]);
            if (blen == DUK_HSTRING_GET_BYTELEN(romstr) &&
                DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(romstr), blen) == 0) {
                DUK_DD(DUK_DDPRINT("intern check: rom string: %!O, computed hash 0x%08lx, rom hash 0x%08lx",
                                   romstr, (unsigned long) *out_strhash, (unsigned long) DUK_HSTRING_GET_HASH(romstr)));
                DUK_ASSERT(*out_strhash == DUK_HSTRING_GET_HASH(romstr));
                *out_strhash = DUK_HSTRING_GET_HASH(romstr);
                return romstr;
            }
        }
    }
#endif  /* DUK_USE_ROM_STRINGS */
 
#if defined(DUK_USE_STRTAB_CHAIN)
    res = duk__find_matching_string_chain(heap, str, blen, *out_strhash);

Referenced by duk_heap_string_intern_checked().

◆ duk__dragon4_convert_and_push()

DUK_LOCAL void duk__dragon4_convert_and_push	(	duk__numconv_stringify_ctx *	nc_ctx,
		duk_context *	ctx,
		duk_small_int_t	radix,
		duk_small_int_t	digits,
		duk_small_uint_t	flags,
		duk_small_int_t	neg )

Definition at line 76585 of file duktape-1.8.0/src/duktape.c.

                                                    : %ld", (long) t));
            if (++t < nc_ctx->B) {
                DUK_DDD(DUK_DDDPRINT("rounding carry terminated"));
                *p = (duk_uint8_t) t;
                break;
            }
 
            DUK_DDD(DUK_DDDPRINT("wraps, carry to next digit"));
        }
    }
 
    return ret;
}
 
#define DUK__NO_EXP  (65536)  /* arbitrary marker, outside valid exp range */
 
DUK_LOCAL void duk__dragon4_convert_and_push(duk__numconv_stringify_ctx *nc_ctx,
                                          duk_context *ctx,
                                          duk_small_int_t radix,
                                          duk_small_int_t digits,
                                          duk_small_uint_t flags,
                                          duk_small_int_t neg) {
    duk_small_int_t k;
    duk_small_int_t pos, pos_end;
    duk_small_int_t expt;
    duk_small_int_t dig;
    duk_uint8_t *q;
    duk_uint8_t *buf;
 
    /*
     *  The string conversion here incorporates all the necessary Ecmascript
     *  semantics without attempting to be generic.  nc_ctx->digits contains
     *  nc_ctx->count digits (>= 1), with the topmost digit's 'position'
     *  indicated by nc_ctx->k as follows:
     *
     *    digits="123" count=3 k=0   -->   0.123
     *    digits="123" count=3 k=1   -->   1.23
     *    digits="123" count=3 k=5   -->   12300
     *    digits="123" count=3 k=-1  -->   0.0123
     *
     *  Note that the identifier names used for format selection are different
     *  in Burger-Dybvig paper and Ecmascript specification (quite confusingly
     *  so, because e.g. 'k' has a totally different meaning in each).  See
     *  documentation for discussion.
     *
     *  Ecmascript doesn't specify any specific behavior for format selection
     *  (e.g. when to use exponent notation) for non-base-10 numbers.
     *
     *  The bigint space in the context is reused for string output, as there
     *  is more than enough space for that (>1kB at the moment), and we avoid
     *  allocating even more stack.
     */
 
    DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= DUK__MAX_FORMATTED_LENGTH);
    DUK_ASSERT(nc_ctx->count >= 1);
 
    k = nc_ctx->k;
    buf = (duk_uint8_t *) &nc_ctx->f;  /* XXX: union would be more correct */
    q = buf;
 
    /* Exponent handling: if exponent format is used, record exponent value and
     * fake k such that one leading digit is generated (e.g. digits=123 -> "1.23").
     *
     * toFixed() prevents exponent use; otherwise apply a set of criteria to
     * match the other API calls (toString(), toPrecision, etc).
     */
 
    expt = DUK__NO_EXP;
    if (!nc_ctx->abs_pos /* toFixed() */) {
        if ((flags & DUK_N2S_FLAG_FORCE_EXP) ||             /* exponential notation forced */
            ((flags & DUK_N2S_FLAG_NO_ZERO_PAD) &&          /* fixed precision and zero padding would be required */
                 (k - digits >= 1)) ||                          /* (e.g. k=3, digits=2 -> "12X") */
            ((k > 21 || k <= -6) && (radix == 10))) {       /* toString() conditions */
            DUK_DDD(DUK_DDDPRINT("use exponential notation: k=%ld -> expt=%ld",
                                 (long) k, (long) (k - 1)));
            expt = k - 1;  /* e.g. 12.3 -> digits="123" k=2 -> 1.23e1 */
            k = 1;  /* generate mantissa with a single leading whole number digit */
        }
    }
 
    if (neg) {
        *q++ = '-';
    }
 
    /* Start position (inclusive) and end position (exclusive) */
    pos = (k >= 1 ? k : 1);
    if (nc_ctx->is_fixed) {
        if (nc_ctx->abs_pos) {
            /* toFixed() */
            pos_end = -digits;
        } else {
            pos_end = k - digits;
        }
    } else {
        pos_end = k - nc_ctx->count;
    }
    if (pos_end > 0) {
        pos_end = 0;
    }
 
    DUK_DDD(DUK_DDDPRINT("expt=%ld, k=%ld, count=%ld, pos=%ld, pos_end=%ld, is_fixed=%ld, "
                         "digits=%ld, abs_pos=%ld",
                         (long) expt, (long) k, (long) nc_ctx->count, (long) pos, (long) pos_end,
                         (long) nc_ctx->is_fixed, (long) digits, (long) nc_ctx->abs_pos));
 
    /* Digit generation */
    while (pos > pos_end) {
        DUK_DDD(DUK_DDDPRINT("digit generation: pos=%ld, pos_end=%ld",
                             (long) pos, (long) pos_end));
        if (pos == 0) {
            *q++ = (duk_uint8_t) '.';
        }
        if (pos > k) {
            *q++ = (duk_uint8_t) '0';
        } else if (pos <= k - nc_ctx->count) {
            *q++ = (duk_uint8_t) '0';
        } else {
            dig = nc_ctx->digits[k - pos];
            DUK_ASSERT(dig >= 0 && dig < nc_ctx->B);
            *q++ = (duk_uint8_t) DUK__DIGITCHAR(dig);
        }
 
        pos--;
    }
    DUK_ASSERT(pos <= 1);
 
    /* Exponent */
    if (expt != DUK__NO_EXP) {
        /*
         *  Exponent notation for non-base-10 numbers isn't specified in Ecmascript
         *  specification, as it never explicitly turns up: non-decimal numbers can
         *  only be formatted with Number.prototype.toString([radix]) and for that,
         *  behavior is not explicitly specified.
         *
         *  Logical choices include formatting the exponent as decimal (e.g. binary
         *  100000 as 1e+5) or in current radix (e.g. binary 100000 as 1e+101).
         *  The Dragon4 algorithm (in the original paper) prints the exponent value
         *  in the target radix B.  However, for radix values 15 and above, the
         *  exponent separator 'e' is no longer easily parseable.  Consider, for
         *  instance, the number "1.faecee+1c".
         */
 

◆ duk__dragon4_ctx_to_double()

DUK_LOCAL void duk__dragon4_ctx_to_double	(	duk__numconv_stringify_ctx *	nc_ctx,
		duk_double_t *	x )

Definition at line 76778 of file duktape-1.8.0/src/duktape.c.

                   {
        /* denormal */
        expt = DUK__IEEE_DOUBLE_EXP_MIN - 52;
        duk__bi_normalize(&nc_ctx->f);
    } else {
        /* normal: implicit leading 1-bit */
        nc_ctx->f.v[1] |= 0x00100000UL;
        expt = expt - DUK__IEEE_DOUBLE_EXP_BIAS - 52;
        DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f));  /* true, because v[1] has at least one bit set */
    }
 
    DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f));
 
    nc_ctx->e = expt;
}
 
DUK_LOCAL void duk__dragon4_ctx_to_double(duk__numconv_stringify_ctx *nc_ctx, duk_double_t *x) {
    duk_double_union u;
    duk_small_int_t expt;
    duk_small_int_t i;
    duk_small_int_t bitstart;
    duk_small_int_t bitround;
    duk_small_int_t bitidx;
    duk_small_int_t skip_round;
    duk_uint32_t t, v;
 
    DUK_ASSERT(nc_ctx->count == 53 + 1);
 
    /* Sometimes this assert is not true right now; it will be true after
     * rounding.  See: test-bug-numconv-mantissa-assert.js.
     */
    DUK_ASSERT_DISABLE(nc_ctx->digits[0] == 1);  /* zero handled by caller */
 
    /* Should not be required because the code below always sets both high
     * and low parts, but at least gcc-4.4.5 fails to deduce this correctly
     * (perhaps because the low part is set (seemingly) conditionally in a
     * loop), so this is here to avoid the bogus warning.
     */
    DUK_MEMZERO((void *) &u, sizeof(u));
 
    /*
     *  Figure out how generated digits match up with the mantissa,
     *  and then perform rounding.  If mantissa overflows, need to
     *  recompute the exponent (it is bumped and may overflow to
     *  infinity).
     *
     *  For normal numbers the leading '1' is hidden and ignored,
     *  and the last bit is used for rounding:
     *
     *                          rounding pt
     *       <--------52------->|
     *     1 x x x x ... x x x x|y  ==>  x x x x ... x x x x
     *
     *  For denormals, the leading '1' is included in the number,
     *  and the rounding point is different:
     *
     *                      rounding pt
     *     <--52 or less--->|
     *     1 x x x x ... x x|x x y  ==>  0 0 ... 1 x x ... x x
     *
     *  The largest denormals will have a mantissa beginning with
     *  a '1' (the explicit leading bit); smaller denormals will
     *  have leading zero bits.
     *
     *  If the exponent would become too high, the result becomes
     *  Infinity.  If the exponent is so small that the entire
     *  mantissa becomes zero, the result becomes zero.
     *
     *  Note: the Dragon4 'k' is off-by-one with respect to the IEEE
     *  exponent.  For instance, k==0 indicates that the leading '1'
     *  digit is at the first binary fraction position (0.1xxx...);
     *  the corresponding IEEE exponent would be -1.
     */
 
    skip_round = 0;
 
 recheck_exp:
 
    expt = nc_ctx->k - 1;   /* IEEE exp without bias */
    if (expt > 1023) {
        /* Infinity */
        bitstart = -255;  /* needed for inf: causes mantissa to become zero,
                           * and rounding to be skipped.
                           */
        expt = 2047;
    } else if (expt >= -1022) {
        /* normal */
        bitstart = 1;  /* skip leading digit */
        expt += DUK__IEEE_DOUBLE_EXP_BIAS;
        DUK_ASSERT(expt >= 1 && expt <= 2046);
    } else {
        /* denormal or zero */
        bitstart = 1023 + expt;  /* expt==-1023 -> bitstart=0 (leading 1);
                                  * expt==-1024 -> bitstart=-1 (one left of leading 1), etc
                                  */
        expt = 0;
    }
    bitround = bitstart + 52;
 
    DUK_DDD(DUK_DDDPRINT("ieee expt=%ld, bitstart=%ld, bitround=%ld",
                         (long) expt, (long) bitstart, (long) bitround));
 
    if (!skip_round) {
        if (duk__dragon4_fixed_format_round(nc_ctx, bitround)) {
            /* Corner case: see test-numconv-parse-mant-carry.js.  We could
             * just bump the exponent and update bitstart, but it's more robust
             * to recompute (but avoid rounding twice).
             */
            DUK_DDD(DUK_DDDPRINT("rounding caused exponent to be bumped, recheck exponent"));
            skip_round = 1;
            goto recheck_exp;
        }
    }
 
    /*
     *  Create mantissa
     */
 
    t = 0;
    for (i = 0; i < 52; i++) {
        bitidx = bitstart + 52 - 1 - i;
        if (bitidx >= nc_ctx->count) {
            v = 0;
        } else if (bitidx < 0) {
            v = 0;
        } else {
            v = nc_ctx->digits[bitidx];
        }
        DUK_ASSERT(v == 0 || v == 1);
        t += v << (i % 32);
        if (i == 31) {
            /* low 32 bits is complete */
            DUK_DBLUNION_SET_LOW32(&u, t);
            t = 0;
        }
    }
    /* t has high mantissa */
 
    DUK_DDD(DUK_DDDPRINT("mantissa is complete: %08lx %08lx",
                         (unsigned long) t,

References duk__bi_normalize(), DUK__IEEE_DOUBLE_EXP_MIN, and duk__numconv_stringify_ctx::f.

◆ duk__dragon4_double_to_ctx()

DUK_LOCAL void duk__dragon4_double_to_ctx	(	duk__numconv_stringify_ctx *	nc_ctx,
		duk_double_t	x )

Definition at line 76733 of file duktape-1.8.0/src/duktape.c.

               {
            expt_sign = '-';
            expt = -expt;
        }
        *q++ = (duk_uint8_t) expt_sign;
        len = duk__dragon4_format_uint32(q, (duk_uint32_t) expt, radix);
        q += len;
    }
 
    duk_push_lstring(ctx, (const char *) buf, (size_t) (q - buf));
}
 
/*
 *  Conversion helpers
 */
 
DUK_LOCAL void duk__dragon4_double_to_ctx(duk__numconv_stringify_ctx *nc_ctx, duk_double_t x) {
    duk_double_union u;
    duk_uint32_t tmp;
    duk_small_int_t expt;
 
    /*
     *    seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff
     *       A        B        C        D        E        F        G        H
     *
     *    s       sign bit
     *    eee...  exponent field
     *    fff...  fraction
     *
     *    ieee value = 1.ffff... * 2^(e - 1023)  (normal)
     *               = 0.ffff... * 2^(-1022)     (denormal)
     *
     *    algorithm v = f * b^e
     */
 
    DUK_DBLUNION_SET_DOUBLE(&u, x);
 
    nc_ctx->f.n = 2;
 
    tmp = DUK_DBLUNION_GET_LOW32(&u);
    nc_ctx->f.v[0] = tmp;
    tmp = DUK_DBLUNION_GET_HIGH32(&u);
    nc_ctx->f.v[1] = tmp & 0x000fffffUL;

◆ duk__dragon4_fixed_format_round()

DUK_LOCAL duk_small_int_t duk__dragon4_fixed_format_round	(	duk__numconv_stringify_ctx *	nc_ctx,
		duk_small_int_t	round_idx )

Definition at line 76514 of file duktape-1.8.0/src/duktape.c.

                                                                                                                         {
    duk_small_int_t t;
    duk_uint8_t *p;
    duk_uint8_t roundup_limit;
    duk_small_int_t ret = 0;
 
    /*
     *  round_idx points to the digit which is considered for rounding; the
     *  digit to its left is the final digit of the rounded value.  If round_idx
     *  is zero, rounding will be performed; the result will either be an empty
     *  rounded value or if carry happens a '1' digit is generated.
     */
 
    if (round_idx >= nc_ctx->count) {
        DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld >= %ld (count)) -> no rounding",
                             (long) round_idx, (long) nc_ctx->count));
        return 0;
    } else if (round_idx < 0) {
        DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld < 0) -> no rounding",
                             (long) round_idx));
        return 0;
    }
 
    /*
     *  Round-up limit.
     *
     *  For even values, divides evenly, e.g. 10 -> roundup_limit=5.
     *
     *  For odd values, rounds up, e.g. 3 -> roundup_limit=2.
     *  If radix is 3, 0/3 -> down, 1/3 -> down, 2/3 -> up.
     */
    roundup_limit = (duk_uint8_t) ((nc_ctx->B + 1) / 2);
 
    p = &nc_ctx->digits[round_idx];
    if (*p >= roundup_limit) {
        DUK_DDD(DUK_DDDPRINT("fixed-format rounding carry required"));
        /* carry */
        for (;;) {
            *p = 0;
            if (p == &nc_ctx->digits[0]) {
                DUK_DDD(DUK_DDDPRINT("carry propagated to first digit -> special case handling"));
                DUK_MEMMOVE((void *) (&nc_ctx->digits[1]),
                            (const void *) (&nc_ctx->digits[0]),
                            (size_t) (sizeof(char) * nc_ctx->count));
                nc_ctx->digits[0] = 1;  /* don't increase 'count' */
                nc_ctx->k++;  /* position of highest digit changed */
                nc_ctx->count++;  /* number of digits changed */
                ret = 1;
                break;
            }
 

◆ duk__dragon4_format_uint32()

DUK_LOCAL duk_size_t duk__dragon4_format_uint32	(	duk_uint8_t *	buf,
		duk_uint32_t	x,
		duk_small_int_t	radix )

Definition at line 76059 of file duktape-1.8.0/src/duktape.c.

                                                            { \
        DUK_ASSERT((preinc_idx) - 1 >= 0); \
        DUK_ASSERT((preinc_idx) - 1 < DUK__MAX_OUTPUT_DIGITS); \
        ((nc_ctx)->digits[(preinc_idx) - 1]) = (duk_uint8_t) (x); \
    } while (0)
 
DUK_LOCAL duk_size_t duk__dragon4_format_uint32(duk_uint8_t *buf, duk_uint32_t x, duk_small_int_t radix) {
    duk_uint8_t *p;
    duk_size_t len;
    duk_small_int_t dig;
    duk_small_int_t t;
 
    DUK_ASSERT(radix >= 2 && radix <= 36);
 
    /* A 32-bit unsigned integer formats to at most 32 digits (the
     * worst case happens with radix == 2).  Output the digits backwards,
     * and use a memmove() to get them in the right place.
     */
 
    p = buf + 32;
    for (;;) {

◆ duk__dragon4_generate()

DUK_LOCAL void duk__dragon4_generate ( duk__numconv_stringify_ctx * nc_ctx )

Definition at line 76339 of file duktape-1.8.0/src/duktape.c.

           :
 
    if (!nc_ctx->unequal_gaps) {
        DUK_DDD(DUK_DDDPRINT("equal gaps, copy m- from m+"));
        duk__bi_copy(&nc_ctx->mm, &nc_ctx->mp);  /* mm <- mp */
    }
    nc_ctx->k = k;
 
    DUK_DDD(DUK_DDDPRINT("final k: %ld", (long) k));
    DUK__BI_PRINT("r(final)", &nc_ctx->r);
    DUK__BI_PRINT("s(final)", &nc_ctx->s);
    DUK__BI_PRINT("mp(final)", &nc_ctx->mp);
    DUK__BI_PRINT("mm(final)", &nc_ctx->mm);
}
 
DUK_LOCAL void duk__dragon4_generate(duk__numconv_stringify_ctx *nc_ctx) {
    duk_small_int_t tc1, tc2;    /* terminating conditions */
    duk_small_int_t d;           /* current digit */
    duk_small_int_t count = 0;   /* digit count */
 
    /*
     *  Digit generation loop.
     *
     *  Different termination conditions:
     *
     *    1. Free format output.  Terminate when shortest accurate
     *       representation found.
     *
     *    2. Fixed format output, with specific number of digits.
     *       Ignore termination conditions, terminate when digits
     *       generated.  Caller requests an extra digit and rounds.
     *
     *    3. Fixed format output, with a specific absolute cut-off
     *       position (e.g. 10 digits after decimal point).  Note
     *       that we always generate at least one digit, even if
     *       the digit is below the cut-off point already.
     */
 
    for (;;) {
        DUK_DDD(DUK_DDDPRINT("generate loop, count=%ld, k=%ld, B=%ld, low_ok=%ld, high_ok=%ld",
                             (long) count, (long) nc_ctx->k, (long) nc_ctx->B,
                             (long) nc_ctx->low_ok, (long) nc_ctx->high_ok));
        DUK__BI_PRINT("r", &nc_ctx->r);
        DUK__BI_PRINT("s", &nc_ctx->s);
        DUK__BI_PRINT("m+", &nc_ctx->mp);
        DUK__BI_PRINT("m-", &nc_ctx->mm);
 
        /* (quotient-remainder (* r B) s) using a dummy subtraction loop */
        duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, nc_ctx->B);       /* t1 <- (* r B) */
        d = 0;
        for (;;) {
            if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) {
                break;
            }
            duk__bi_sub_copy(&nc_ctx->t1, &nc_ctx->s, &nc_ctx->t2);  /* t1 <- t1 - s */
            d++;
        }
        duk__bi_copy(&nc_ctx->r, &nc_ctx->t1);  /* r <- (remainder (* r B) s) */
                                                /* d <- (quotient (* r B) s)   (in range 0...B-1) */
        DUK_DDD(DUK_DDDPRINT("-> d(quot)=%ld", (long) d));
        DUK__BI_PRINT("r(rem)", &nc_ctx->r);
 
        duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t2); /* m+ <- (* m+ B) */
        duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t2); /* m- <- (* m- B) */
        DUK__BI_PRINT("mp(upd)", &nc_ctx->mp);
        DUK__BI_PRINT("mm(upd)", &nc_ctx->mm);
 
        /* Terminating conditions.  For fixed width output, we just ignore the
         * terminating conditions (and pretend that tc1 == tc2 == false).  The
         * the current shortcut for fixed-format output is to generate a few
         * extra digits and use rounding (with carry) to finish the output.
         */
 
        if (nc_ctx->is_fixed == 0) {
            /* free-form */
            tc1 = (duk__bi_compare(&nc_ctx->r, &nc_ctx->mm) <= (nc_ctx->low_ok ? 0 : -1));
 
            duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp);  /* t1 <- (+ r m+) */
            tc2 = (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1));
 
            DUK_DDD(DUK_DDDPRINT("tc1=%ld, tc2=%ld", (long) tc1, (long) tc2));
        } else {
            /* fixed-format */
            tc1 = 0;
            tc2 = 0;
        }
 
        /* Count is incremented before DUK__DRAGON4_OUTPUT_PREINC() call
         * on purpose, which is taken into account by the macro.
         */
        count++;
 
        if (tc1) {
            if (tc2) {
                /* tc1 = true, tc2 = true */
                duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, 2);
                if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) {  /* (< (* r 2) s) */
                    DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r > s: output d --> %ld (k=%ld)",
                                         (long) d, (long) nc_ctx->k));
                    DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
                } else {
                    DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r <= s: output d+1 --> %ld (k=%ld)",
                                         (long) (d + 1), (long) nc_ctx->k));
                    DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1);
                }
                break;
            } else {
                /* tc1 = true, tc2 = false */
                DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=false: output d --> %ld (k=%ld)",
                                     (long) d, (long) nc_ctx->k));
                DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
                break;
            }
        } else {
            if (tc2) {
                /* tc1 = false, tc2 = true */
                DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=true: output d+1 --> %ld (k=%ld)",
                                     (long) (d + 1), (long) nc_ctx->k));
                DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1);
                break;
            } else {
                /* tc1 = false, tc2 = false */
                DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=false: output d --> %ld (k=%ld)",
                                     (long) d, (long) nc_ctx->k));
                DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
 
                /* r <- r    (updated above: r <- (remainder (* r B) s)
                 * s <- s
                 * m+ <- m+  (updated above: m+ <- (* m+ B)
                 * m- <- m-  (updated above: m- <- (* m- B)
                 * B, low_ok, high_ok are fixed
                 */
 
                /* fall through and continue for-loop */
            }
        }
 
        /* fixed-format termination conditions */
        if (nc_ctx->is_fixed) {
            if (nc_ctx->abs_pos) {
                int pos = nc_ctx->k - count + 1;  /* count is already incremented, take into account */
                DUK_DDD(DUK_DDDPRINT("fixed format, absolute: abs pos=%ld, k=%ld, count=%ld, req=%ld",
                                     (long) pos, (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits));
                if (pos <= nc_ctx->req_digits) {
                    DUK_DDD(DUK_DDDPRINT("digit position reached req_digits, end generate loop"));
                    break;
                }
            } else {
                DUK_DDD(DUK_DDDPRINT("fixed format, relative: k=%ld, count=%ld, req=%ld",
                                     (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits));
                if (count >= nc_ctx->req_digits) {
                    DUK_DDD(DUK_DDDPRINT("digit count reached req_digits, end generate loop"));
                    break;
                }
            }
        }
    }  /* for */
 
    nc_ctx->count = count;
 
    DUK_DDD(DUK_DDDPRINT("generate finished"));
 
#ifdef DUK_USE_DDDPRINT

◆ duk__dragon4_prepare()

DUK_LOCAL void duk__dragon4_prepare ( duk__numconv_stringify_ctx * nc_ctx )

Definition at line 76092 of file duktape-1.8.0/src/duktape.c.

                    {
            break;
        }
    }
    len = (duk_size_t) ((buf + 32) - p);
 
    DUK_MEMMOVE((void *) buf, (const void *) p, (size_t) len);
 
    return len;
}
 
DUK_LOCAL void duk__dragon4_prepare(duk__numconv_stringify_ctx *nc_ctx) {
    duk_small_int_t lowest_mantissa;
 
#if 1
    /* Assume IEEE round-to-even, so that shorter encoding can be used
     * when round-to-even would produce correct result.  By removing
     * this check (and having low_ok == high_ok == 0) the results would
     * still be accurate but in some cases longer than necessary.
     */
    if (duk__bi_is_even(&nc_ctx->f)) {
        DUK_DDD(DUK_DDDPRINT("f is even"));
        nc_ctx->low_ok = 1;
        nc_ctx->high_ok = 1;
    } else {
        DUK_DDD(DUK_DDDPRINT("f is odd"));
        nc_ctx->low_ok = 0;
        nc_ctx->high_ok = 0;
    }
#else
    /* Note: not honoring round-to-even should work but now generates incorrect
     * results.  For instance, 1e23 serializes to "a000...", i.e. the first digit
     * equals the radix (10).  Scaling stops one step too early in this case.
     * Don't know why this is the case, but since this code path is unused, it
     * doesn't matter.
     */
    nc_ctx->low_ok = 0;
    nc_ctx->high_ok = 0;
#endif
 
    /* For string-to-number, pretend we never have the lowest mantissa as there
     * is no natural "precision" for inputs.  Having lowest_mantissa == 0, we'll
     * fall into the base cases for both e >= 0 and e < 0.
     */
    if (nc_ctx->is_s2n) {
        lowest_mantissa = 0;
    } else {
        lowest_mantissa = duk__bi_is_2to52(&nc_ctx->f);
    }
 
    nc_ctx->unequal_gaps = 0;
    if (nc_ctx->e >= 0) {
        /* exponent non-negative (and thus not minimum exponent) */
 
        if (lowest_mantissa) {
            /* (>= e 0) AND (= f (expt b (- p 1)))
             *
             * be <- (expt b e) == b^e
             * be1 <- (* be b) == (expt b (+ e 1)) == b^(e+1)
             * r <- (* f be1 2) == 2 * f * b^(e+1)    [if b==2 -> f * b^(e+2)]
             * s <- (* b 2)                           [if b==2 -> 4]
             * m+ <- be1 == b^(e+1)
             * m- <- be == b^e
             * k <- 0
             * B <- B
             * low_ok <- round
             * high_ok <- round
             */
 
            DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); "
                                 "lowest mantissa value for this exponent -> "
                                 "unequal gaps"));
 
            duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2);  /* mm <- b^e */
            duk__bi_mul_small(&nc_ctx->mp, &nc_ctx->mm, nc_ctx->b);  /* mp <- b^(e+1) */
            duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2);
            duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp);       /* r <- (2 * f) * b^(e+1) */
            duk__bi_set_small(&nc_ctx->s, nc_ctx->b * 2);            /* s <- 2 * b */
            nc_ctx->unequal_gaps = 1;
        } else {
            /* (>= e 0) AND (not (= f (expt b (- p 1))))
             *
             * be <- (expt b e) == b^e
             * r <- (* f be 2) == 2 * f * b^e    [if b==2 -> f * b^(e+1)]
             * s <- 2
             * m+ <- be == b^e
             * m- <- be == b^e
             * k <- 0
             * B <- B
             * low_ok <- round
             * high_ok <- round
             */
 
            DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); "
                                 "not lowest mantissa for this exponent -> "
                                 "equal gaps"));
 
            duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2);  /* mm <- b^e */
            duk__bi_copy(&nc_ctx->mp, &nc_ctx->mm);                /* mp <- b^e */
            duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2);
            duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp);     /* r <- (2 * f) * b^e */
            duk__bi_set_small(&nc_ctx->s, 2);                      /* s <- 2 */
        }
    } else {
        /* When doing string-to-number, lowest_mantissa is always 0 so
         * the exponent check, while incorrect, won't matter.
         */
        if (nc_ctx->e > DUK__IEEE_DOUBLE_EXP_MIN /*not minimum exponent*/ &&
            lowest_mantissa /* lowest mantissa for this exponent*/) {
            /* r <- (* f b 2)                                [if b==2 -> (* f 4)]
             * s <- (* (expt b (- 1 e)) 2) == b^(1-e) * 2    [if b==2 -> b^(2-e)]
             * m+ <- b == 2
             * m- <- 1
             * k <- 0
             * B <- B
             * low_ok <- round
             * high_ok <- round
             */
 
            DUK_DDD(DUK_DDDPRINT("negative exponent; not minimum exponent and "
                                 "lowest mantissa for this exponent -> "
                                 "unequal gaps"));
 
            duk__bi_mul_small(&nc_ctx->r, &nc_ctx->f, nc_ctx->b * 2);  /* r <- (2 * b) * f */
            duk__bi_exp_small(&nc_ctx->t1, nc_ctx->b, 1 - nc_ctx->e, &nc_ctx->s, &nc_ctx->t2);  /* NB: use 's' as temp on purpose */
            duk__bi_mul_small(&nc_ctx->s, &nc_ctx->t1, 2);             /* s <- b^(1-e) * 2 */
            duk__bi_set_small(&nc_ctx->mp, 2);
            duk__bi_set_small(&nc_ctx->mm, 1);
            nc_ctx->unequal_gaps = 1;
        } else {
            /* r <- (* f 2)
             * s <- (* (expt b (- e)) 2) == b^(-e) * 2    [if b==2 -> b^(1-e)]
             * m+ <- 1
             * m- <- 1
             * k <- 0

◆ duk__dragon4_scale()

DUK_LOCAL void duk__dragon4_scale ( duk__numconv_stringify_ctx * nc_ctx )

Definition at line 76234 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_small_int_t k = 0;
 
    /* This is essentially the 'scale' algorithm, with recursion removed.
     * Note that 'k' is either correct immediately, or will move in one
     * direction in the loop.  There's no need to do the low/high checks
     * on every round (like the Scheme algorithm does).
     *
     * The scheme algorithm finds 'k' and updates 's' simultaneously,
     * while the logical algorithm finds 'k' with 's' having its initial
     * value, after which 's' is updated separately (see the Burger-Dybvig
     * paper, Section 3.1, steps 2 and 3).
     *
     * The case where m+ == m- (almost always) is optimized for, because
     * it reduces the bigint operations considerably and almost always
     * applies.  The scale loop only needs to work with m+, so this works.
     */
 
    /* XXX: this algorithm could be optimized quite a lot by using e.g.
     * a logarithm based estimator for 'k' and performing B^n multiplication
     * using a lookup table or using some bit-representation based exp
     * algorithm.  Currently we just loop, with significant performance
     * impact for very large and very small numbers.
     */
 
    DUK_DDD(DUK_DDDPRINT("scale: B=%ld, low_ok=%ld, high_ok=%ld",
                         (long) nc_ctx->B, (long) nc_ctx->low_ok, (long) nc_ctx->high_ok));
    DUK__BI_PRINT("r(init)", &nc_ctx->r);
    DUK__BI_PRINT("s(init)", &nc_ctx->s);
    DUK__BI_PRINT("mp(init)", &nc_ctx->mp);
    DUK__BI_PRINT("mm(init)", &nc_ctx->mm);
 
    for (;;) {
        DUK_DDD(DUK_DDDPRINT("scale loop (inc k), k=%ld", (long) k));
        DUK__BI_PRINT("r", &nc_ctx->r);
        DUK__BI_PRINT("s", &nc_ctx->s);
        DUK__BI_PRINT("m+", &nc_ctx->mp);
        DUK__BI_PRINT("m-", &nc_ctx->mm);
 
        duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp);  /* t1 = (+ r m+) */
        if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1)) {
            DUK_DDD(DUK_DDDPRINT("k is too low"));
            /* r <- r
             * s <- (* s B)
             * m+ <- m+
             * m- <- m-
             * k <- (+ k 1)
             */
 
            duk__bi_mul_small_copy(&nc_ctx->s, nc_ctx->B, &nc_ctx->t1);
            k++;
        } else {
            break;
        }
    }
 
    /* k > 0 -> k was too low, and cannot be too high */
    if (k > 0) {
        goto skip_dec_k;
    }
 
    for (;;) {
        DUK_DDD(DUK_DDDPRINT("scale loop (dec k), k=%ld", (long) k));
        DUK__BI_PRINT("r", &nc_ctx->r);
        DUK__BI_PRINT("s", &nc_ctx->s);
        DUK__BI_PRINT("m+", &nc_ctx->mp);
        DUK__BI_PRINT("m-", &nc_ctx->mm);
 
        duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp);  /* t1 = (+ r m+) */
        duk__bi_mul_small(&nc_ctx->t2, &nc_ctx->t1, nc_ctx->B);   /* t2 = (* (+ r m+) B) */
        if (duk__bi_compare(&nc_ctx->t2, &nc_ctx->s) <= (nc_ctx->high_ok ? -1 : 0)) {
            DUK_DDD(DUK_DDDPRINT("k is too high"));
            /* r <- (* r B)
             * s <- s
             * m+ <- (* m+ B)
             * m- <- (* m- B)
             * k <- (- k 1)
             */
            duk__bi_mul_small_copy(&nc_ctx->r, nc_ctx->B, &nc_ctx->t1);
            duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t1);
            if (nc_ctx->unequal_gaps) {
                DUK_DDD(DUK_DDDPRINT("m+ != m- -> need to update m- too"));
                duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t1);
            }
            k--;
        } else {
            break;

◆ duk__dump_buffer_prop()

DUK_LOCAL duk_uint8_t * duk__dump_buffer_prop	(	duk_hthread *	thr,
		duk_uint8_t *	p,
		duk_bufwriter_ctx *	bw_ctx,
		duk_hobject *	func,
		duk_small_uint_t	stridx )

Definition at line 11750 of file duktape-1.8.0/src/duktape.c.

                                              {
        h_str = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h_str != NULL);
    } else {
        h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr);
        DUK_ASSERT(h_str != NULL);
    }
    DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
    p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(h_str), p);
    p = duk__dump_hstring_raw(p, h_str);
    return p;
}
 

◆ duk__dump_formals()

DUK_LOCAL duk_uint8_t * duk__dump_formals	(	duk_hthread *	thr,
		duk_uint8_t *	p,
		duk_bufwriter_ctx *	bw_ctx,
		duk_hobject *	func )

Definition at line 11829 of file duktape-1.8.0/src/duktape.c.

                                                                                                                         {
    duk_tval *tv;
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_STRING_INT_FORMALS(thr));
    if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h;
        duk_uint_fast32_t i;
 
        h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
 
        /* We know _Formals is dense and all entries will be in the
         * array part.  GC and finalizers shouldn't affect _Formals
         * so side effects should be fine.
         */
        for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
            duk_tval *tv_val;
            duk_hstring *varname;
 
            tv_val = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i);
            DUK_ASSERT(tv_val != NULL);

◆ duk__dump_func()

static duk_uint8_t * duk__dump_func	(	duk_context *	ctx,
		duk_hcompiledfunction *	func,
		duk_bufwriter_ctx *	bw_ctx,
		duk_uint8_t *	p )

static

Definition at line 11868 of file duktape-1.8.0/src/duktape.c.

                                                                                                                             {
    duk_hthread *thr;
    duk_tval *tv, *tv_end;
    duk_instr_t *ins, *ins_end;
    duk_hobject **fn, **fn_end;
    duk_hstring *h_str;
    duk_uint32_t count_instr;
    duk_uint32_t tmp32;
    duk_uint16_t tmp16;
    duk_double_t d;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(ctx);
    DUK_UNREF(thr);
 
    DUK_DD(DUK_DDPRINT("dumping function %p to %p: "
                       "consts=[%p,%p[ (%ld bytes, %ld items), "
                       "funcs=[%p,%p[ (%ld bytes, %ld items), "
                       "code=[%p,%p[ (%ld bytes, %ld items)",
                       (void *) func,
                       (void *) p,
                       (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func),
                       (long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(thr->heap, func),
                       (long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func),
                       (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(thr->heap, func),
                       (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func),
                       (long) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(thr->heap, func),
                       (long) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func)));
 
    DUK_ASSERT(DUK_USE_ESBC_MAX_BYTES <= 0x7fffffffUL);  /* ensures no overflow */
    count_instr = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func);
    p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 3 * 4 + 2 * 2 + 3 * 4 + count_instr * 4, p);
 
    /* Fixed header info. */
    tmp32 = count_instr;
    DUK_RAW_WRITE_U32_BE(p, tmp32);
    tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func);
    DUK_RAW_WRITE_U32_BE(p, tmp32);
    tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func);
    DUK_RAW_WRITE_U32_BE(p, tmp32);
    tmp16 = func->nregs;
    DUK_RAW_WRITE_U16_BE(p, tmp16);
    tmp16 = func->nargs;
    DUK_RAW_WRITE_U16_BE(p, tmp16);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    tmp32 = func->start_line;
    DUK_RAW_WRITE_U32_BE(p, tmp32);
    tmp32 = func->end_line;
    DUK_RAW_WRITE_U32_BE(p, tmp32);
#else
    DUK_RAW_WRITE_U32_BE(p, 0);
    DUK_RAW_WRITE_U32_BE(p, 0);
#endif
    tmp32 = ((duk_heaphdr *) func)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK;
    DUK_RAW_WRITE_U32_BE(p, tmp32);
 
    /* Bytecode instructions: endian conversion needed unless
     * platform is big endian.
     */
    ins = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func);
    ins_end = DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func);
    DUK_ASSERT((duk_size_t) (ins_end - ins) == (duk_size_t) count_instr);
#if defined(DUK_USE_INTEGER_BE)
    DUK_MEMCPY((void *) p, (const void *) ins, (size_t) (ins_end - ins));
    p += (size_t) (ins_end - ins);
#else
    while (ins != ins_end) {
        tmp32 = (duk_uint32_t) (*ins);
        DUK_RAW_WRITE_U32_BE(p, tmp32);
        ins++;
    }
#endif
 
    /* Constants: variable size encoding. */
    tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func);
    tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func);
    while (tv != tv_end) {
        /* constants are strings or numbers now */
        DUK_ASSERT(DUK_TVAL_IS_STRING(tv) ||
                   DUK_TVAL_IS_NUMBER(tv));
 
        if (DUK_TVAL_IS_STRING(tv)) {
            h_str = DUK_TVAL_GET_STRING(tv);
            DUK_ASSERT(h_str != NULL);
            DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
            p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 4 + DUK_HSTRING_GET_BYTELEN(h_str), p),
            *p++ = DUK__SER_STRING;
            p = duk__dump_hstring_raw(p, h_str);
        } else {
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
            p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 8, p);
            *p++ = DUK__SER_NUMBER;
            d = DUK_TVAL_GET_NUMBER(tv);
            DUK_RAW_WRITE_DOUBLE_BE(p, d);
        }
        tv++;
    }
 
    /* Inner functions recursively. */
    fn = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func);
    fn_end = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func);
    while (fn != fn_end) {
        /* XXX: This causes recursion up to inner function depth
         * which is normally not an issue, e.g. mark-and-sweep uses
         * a recursion limiter to avoid C stack issues.  Avoiding
         * this would mean some sort of a work list or just refusing
         * to serialize deep functions.
         */
        DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(*fn));
        p = duk__dump_func(ctx, (duk_hcompiledfunction *) *fn, bw_ctx, p);
        fn++;
    }
 
    /* Object extra properties.

◆ duk__dump_hbuffer_raw()

DUK_LOCAL duk_uint8_t * duk__dump_hbuffer_raw	(	duk_hthread *	thr,
		duk_uint8_t *	p,
		duk_hbuffer *	h )

Definition at line 11713 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_size_t len;
    duk_uint32_t tmp32;
 
    DUK_ASSERT(h != NULL);
 
    len = DUK_HSTRING_GET_BYTELEN(h);
    DUK_ASSERT(len <= 0xffffffffUL);  /* string limits */
    tmp32 = (duk_uint32_t) len;
    DUK_RAW_WRITE_U32_BE(p, tmp32);
    DUK_MEMCPY((void *) p,
               (const void *) DUK_HSTRING_GET_DATA(h),
               len);
    p += len;
    return p;
}
 
DUK_LOCAL duk_uint8_t *duk__dump_hbuffer_raw(duk_hthread *thr, duk_uint8_t *p, duk_hbuffer *h) {

References DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_MEMCPY, DUK_RAW_WRITE_U32_BE, and NULL.

◆ duk__dump_hstring_raw()

DUK_LOCAL duk_uint8_t * duk__dump_hstring_raw	(	duk_uint8_t *	p,
		duk_hstring *	h )

Definition at line 11696 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_uint32_t len;
    duk_uint8_t *buf;
 
    len = DUK_RAW_READ_U32_BE(p);
    buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
    DUK_ASSERT(buf != NULL);
    DUK_MEMCPY((void *) buf, (const void *) p, (size_t) len);
    p += len;
    return p;
}

◆ duk__dump_string_prop()

DUK_LOCAL duk_uint8_t * duk__dump_string_prop	(	duk_hthread *	thr,
		duk_uint8_t *	p,
		duk_bufwriter_ctx *	bw_ctx,
		duk_hobject *	func,
		duk_small_uint_t	stridx )

Definition at line 11732 of file duktape-1.8.0/src/duktape.c.

◆ duk__dump_uint32_prop()

DUK_LOCAL duk_uint8_t * duk__dump_uint32_prop	(	duk_hthread *	thr,
		duk_uint8_t *	p,
		duk_bufwriter_ctx *	bw_ctx,
		duk_hobject *	func,
		duk_small_uint_t	stridx,
		duk_uint32_t	def_value )

Definition at line 11768 of file duktape-1.8.0/src/duktape.c.

                                              {
        duk_hbuffer *h_buf;
        h_buf = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h_buf != NULL);
        DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
        p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HBUFFER_GET_SIZE(h_buf), p);
        p = duk__dump_hbuffer_raw(thr, p, h_buf);
    } else {
        p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p);
        DUK_RAW_WRITE_U32_BE(p, 0);
    }

◆ duk__dump_varmap()

DUK_LOCAL duk_uint8_t * duk__dump_varmap	(	duk_hthread *	thr,
		duk_uint8_t *	p,
		duk_bufwriter_ctx *	bw_ctx,
		duk_hobject *	func )

Definition at line 11783 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                                              {
    duk_tval *tv;
    duk_uint32_t val;
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx));
    if (tv != NULL && DUK_TVAL_IS_NUMBER(tv)) {
        val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv);
    } else {
        val = def_value;
    }
    p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p);
    DUK_RAW_WRITE_U32_BE(p, val);
    return p;
}
 
DUK_LOCAL duk_uint8_t *duk__dump_varmap(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func) {
    duk_tval *tv;
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_STRING_INT_VARMAP(thr));
    if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h;
        duk_uint_fast32_t i;
 
        h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
 
        /* We know _Varmap only has own properties so walk property
         * table directly.  We also know _Varmap is dense and all
         * values are numbers; assert for these.  GC and finalizers
         * shouldn't affect _Varmap so side effects should be fine.
         */
        for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
            duk_hstring *key;
            duk_tval *tv_val;
            duk_uint32_t val;
 
            key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
            DUK_ASSERT(key != NULL);  /* _Varmap is dense */
            DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i));
            tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i);
            DUK_ASSERT(tv_val != NULL);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_val));  /* known to be number; in fact an integer */
#if defined(DUK_USE_FASTINT)

◆ duk__emit()

DUK_LOCAL_DECL void duk__emit	(	duk_compiler_ctx *	comp_ctx,
		duk_instr_t	ins )

Definition at line 58747 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    duk_compiler_func *func;
    func = &comp_ctx->curr_func;
    return (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &func->bw_code) / sizeof(duk_compiler_instr));
}
 
DUK_LOCAL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc) {
    DUK_ASSERT(pc >= 0);
    DUK_ASSERT((duk_size_t) pc < (duk_size_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr)));
    return ((duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code)) + pc;
}
 
/* emit instruction; could return PC but that's not needed in the majority
 * of cases.
 */
DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) {
#if defined(DUK_USE_PC2LINE)
    duk_int_t line;
#endif
    duk_compiler_instr *instr;
 
    DUK_DDD(DUK_DDDPRINT("duk__emit: 0x%08lx curr_token.start_line=%ld prev_token.start_line=%ld pc=%ld --> %!I",
                         (unsigned long) ins,
                         (long) comp_ctx->curr_token.start_line,
                         (long) comp_ctx->prev_token.start_line,
                         (long) duk__get_current_pc(comp_ctx),
                         (duk_instr_t) ins));
 
    instr = (duk_compiler_instr *) (void *) DUK_BW_ENSURE_GETPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
    DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
 
#if defined(DUK_USE_PC2LINE)
    /* The line number tracking is a bit inconsistent right now, which
     * affects debugger accuracy.  Mostly call sites emit opcodes when
     * they have parsed a token (say a terminating semicolon) and called
     * duk__advance().  In this case the line number of the previous
     * token is the most accurate one (except in prologue where
     * prev_token.start_line is 0).  This is probably not 100% correct
     * right now.
     */
    /* approximation, close enough */
    line = comp_ctx->prev_token.start_line;
    if (line == 0) {
        line = comp_ctx->curr_token.start_line;
    }
#endif
 
    instr->ins = ins;
#if defined(DUK_USE_PC2LINE)
    instr->line = line;
#endif
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    if (line < comp_ctx->curr_func.min_line) {
        comp_ctx->curr_func.min_line = line;
    }
    if (line > comp_ctx->curr_func.max_line) {
        comp_ctx->curr_func.max_line = line;
    }
#endif
 
    /* Limit checks for bytecode byte size and line number. */
    if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) {
        goto fail_bc_limit;
    }
#if defined(DUK_USE_PC2LINE) && defined(DUK_USE_ESBC_LIMITS)

References duk_compiler_func::bw_code, duk_compiler_ctx::curr_func, DUK_BW_GET_SIZE, and duk_compiler_ctx::thr.

◆ duk__emit_1()

DUK_LOCAL_DECL void duk__emit_1	(	duk_json_enc_ctx *	js_ctx,
		duk_uint_fast8_t	ch )

Definition at line 30144 of file duktape-1.8.0/src/duktape.c.

                              : top=%ld, result=%!T",
                         (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -1)));
}

◆ duk__emit_2()

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

Definition at line 30148 of file duktape-1.8.0/src/duktape.c.

◆ duk__emit_a_b()

DUK_LOCAL_DECL void duk__emit_a_b	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	op_flags,
		duk_regconst_t	a,
		duk_regconst_t	b )

Definition at line 59094 of file duktape-1.8.0/src/duktape.c.

59095 {

59096 DUK_ASSERT(a_out < 0);

Referenced by duk__parse_func_body().

◆ duk__emit_a_b_c()

DUK_LOCAL_DECL void duk__emit_a_b_c	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	op_flags,
		duk_regconst_t	a,
		duk_regconst_t	b,
		duk_regconst_t	c )

Definition at line 58846 of file duktape-1.8.0/src/duktape.c.

                                             {
        comp_ctx->curr_func.max_line = line;
    }
#else
    DUK_UNREF(comp_ctx);
#endif
}
 
#if 0 /* unused */
DUK_LOCAL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op) {
    duk__emit(comp_ctx, DUK_ENC_OP_ABC(op, 0));
}
#endif
 
/* Important main primitive. */
DUK_LOCAL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c) {
    duk_instr_t ins = 0;
    duk_int_t a_out = -1;
    duk_int_t b_out = -1;
    duk_int_t c_out = -1;
    duk_int_t tmp;
 
    DUK_DDD(DUK_DDDPRINT("emit: op_flags=%04lx, a=%ld, b=%ld, c=%ld",
                         (unsigned long) op_flags, (long) a, (long) b, (long) c));
 
    /* We could rely on max temp/const checks: if they don't exceed BC
     * limit, nothing here can either (just asserts would be enough).
     * Currently we check for the limits, which provides additional
     * protection against creating invalid bytecode due to compiler
     * bugs.
     */
 
    DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN);  /* unsigned */
    DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
 
    /* Input shuffling happens before the actual operation, while output
     * shuffling happens afterwards.  Output shuffling decisions are still
     * made at the same time to reduce branch clutter; output shuffle decisions
     * are recorded into X_out variables.
     */
 
    /* Slot A */
 
#if defined(DUK_USE_SHUFFLE_TORTURE)
    if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
#else
    if (a <= DUK_BC_A_MAX) {
#endif
        ;
    } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
        DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but shuffle prohibited, a: %ld", (long) a));
        goto error_outofregs;
    } else if (a <= DUK_BC_BC_MAX) {
        comp_ctx->curr_func.needs_shuffle = 1;
        tmp = comp_ctx->curr_func.shuffle1;
        if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) {
            duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
        } else {
            duk_small_int_t op = op_flags & 0xff;
            if (op == DUK_OP_CSVAR || op == DUK_OP_CSREG || op == DUK_OP_CSPROP) {
                /* Special handling for call setup instructions.  The target
                 * is expressed indirectly, but there is no output shuffling.
                 */
                DUK_ASSERT((op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) == 0);
                duk__emit_load_int32_noshuffle(comp_ctx, tmp, a);
                DUK_ASSERT(DUK_OP_CSVARI == DUK_OP_CSVAR + 1);
                DUK_ASSERT(DUK_OP_CSREGI == DUK_OP_CSREG + 1);
                DUK_ASSERT(DUK_OP_CSPROPI == DUK_OP_CSPROP + 1);
                op_flags++;  /* indirect opcode follows direct */
            } else {
                /* Output shuffle needed after main operation */
                a_out = a;
            }
        }
        a = tmp;
    } else {
        DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but does not fit into BC, a: %ld", (long) a));
        goto error_outofregs;
    }
 
    /* Slot B */
 
    if (b & DUK__CONST_MARKER) {
        DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) == 0);
        DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
        DUK_ASSERT((op_flags & 0xff) != DUK_OP_CALL);
        DUK_ASSERT((op_flags & 0xff) != DUK_OP_NEW);
        b = b & ~DUK__CONST_MARKER;
#if defined(DUK_USE_SHUFFLE_TORTURE)
        if (0) {
#else
        if (b <= 0xff) {
#endif
            ins |= DUK_ENC_OP_A_B_C(0, 0, 0x100, 0);  /* const flag for B */
        } else if (b <= DUK_BC_BC_MAX) {
            comp_ctx->curr_func.needs_shuffle = 1;
            tmp = comp_ctx->curr_func.shuffle2;
            duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, b));
            b = tmp;
        } else {
            DUK_D(DUK_DPRINT("out of regs: 'b' (const) needs shuffling but does not fit into BC, b: %ld", (long) b));
            goto error_outofregs;
        }
    } else {
#if defined(DUK_USE_SHUFFLE_TORTURE)
        if (b <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B)) {
#else
        if (b <= 0xff) {
#endif
            ;
        } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) {
            if (b > DUK_BC_B_MAX) {
                /* Note: 0xff != DUK_BC_B_MAX */
                DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but shuffle prohibited, b: %ld", (long) b));
                goto error_outofregs;
            }
        } else if (b <= DUK_BC_BC_MAX) {
            comp_ctx->curr_func.needs_shuffle = 1;
            tmp = comp_ctx->curr_func.shuffle2;
            if (op_flags & DUK__EMIT_FLAG_B_IS_TARGET) {
                /* Output shuffle needed after main operation */
                b_out = b;
            }
            if (!(op_flags & DUK__EMIT_FLAG_B_IS_TARGET) || (op_flags & DUK__EMIT_FLAG_B_IS_TARGETSOURCE)) {
                duk_small_int_t op = op_flags & 0xff;
                if (op == DUK_OP_CALL || op == DUK_OP_NEW ||
                    op == DUK_OP_MPUTOBJ || op == DUK_OP_MPUTARR) {
                    /* Special handling for CALL/NEW/MPUTOBJ/MPUTARR shuffling.
                     * For each, slot B identifies the first register of a range
                     * of registers, so normal shuffling won't work.  Instead,
                     * an indirect version of the opcode is used.
                     */
                    DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
                    duk__emit_load_int32_noshuffle(comp_ctx, tmp, b);
                    DUK_ASSERT(DUK_OP_CALLI == DUK_OP_CALL + 1);
                    DUK_ASSERT(DUK_OP_NEWI == DUK_OP_NEW + 1);
                    DUK_ASSERT(DUK_OP_MPUTOBJI == DUK_OP_MPUTOBJ + 1);
                    DUK_ASSERT(DUK_OP_MPUTARRI == DUK_OP_MPUTARR + 1);
                    op_flags++;  /* indirect opcode follows direct */
                } else {
                    duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, b));
                }
            }
            b = tmp;
        } else {
            DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but does not fit into BC, b: %ld", (long) b));
            goto error_outofregs;
        }
    }
 
    /* Slot C */
 
    if (c & DUK__CONST_MARKER) {
        DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) == 0);
        DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
        c = c & ~DUK__CONST_MARKER;
#if defined(DUK_USE_SHUFFLE_TORTURE)
        if (0) {
#else
        if (c <= 0xff) {
#endif
            ins |= DUK_ENC_OP_A_B_C(0, 0, 0, 0x100);  /* const flag for C */
        } else if (c <= DUK_BC_BC_MAX) {
            comp_ctx->curr_func.needs_shuffle = 1;
            tmp = comp_ctx->curr_func.shuffle3;
            duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, c));
            c = tmp;
        } else {
            DUK_D(DUK_DPRINT("out of regs: 'c' (const) needs shuffling but does not fit into BC, c: %ld", (long) c));
            goto error_outofregs;
        }
    } else {
#if defined(DUK_USE_SHUFFLE_TORTURE)
        if (c <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C)) {
#else
        if (c <= 0xff) {
#endif
            ;
        } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) {
            if (c > DUK_BC_C_MAX) {
                /* Note: 0xff != DUK_BC_C_MAX */
                DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but shuffle prohibited, c: %ld", (long) c));
                goto error_outofregs;
            }
        } else if (c <= DUK_BC_BC_MAX) {
            comp_ctx->curr_func.needs_shuffle = 1;
            tmp = comp_ctx->curr_func.shuffle3;
            if (op_flags & DUK__EMIT_FLAG_C_IS_TARGET) {
                /* Output shuffle needed after main operation */
                c_out = c;
            } else {
                duk_small_int_t op = op_flags & 0xff;
                if (op == DUK_OP_EXTRA &&
                    (a == DUK_EXTRAOP_INITGET || a == DUK_EXTRAOP_INITSET)) {
                    /* Special shuffling for INITGET/INITSET, where slot C
                     * identifies a register pair and cannot be shuffled
                     * normally.  Use an indirect variant instead.
                     */
                    DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
                    duk__emit_load_int32_noshuffle(comp_ctx, tmp, c);
                    DUK_ASSERT(DUK_EXTRAOP_INITGETI == DUK_EXTRAOP_INITGET + 1);
                    DUK_ASSERT(DUK_EXTRAOP_INITSETI == DUK_EXTRAOP_INITSET + 1);
                    a++;  /* indirect opcode follows direct */
                } else {
                    duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, c));
                }
            }
            c = tmp;
        } else {
            DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but does not fit into BC, c: %ld", (long) c));
            goto error_outofregs;
        }
    }
 
    /* Main operation */
 
    DUK_ASSERT_DISABLE(a >= DUK_BC_A_MIN);  /* unsigned */
    DUK_ASSERT(a <= DUK_BC_A_MAX);
    DUK_ASSERT_DISABLE(b >= DUK_BC_B_MIN);  /* unsigned */
    DUK_ASSERT(b <= DUK_BC_B_MAX);
    DUK_ASSERT_DISABLE(c >= DUK_BC_C_MIN);  /* unsigned */
    DUK_ASSERT(c <= DUK_BC_C_MAX);
 
    ins |= DUK_ENC_OP_A_B_C(op_flags & 0xff, a, b, c);
    duk__emit(comp_ctx, ins);
 
    /* NEXTENUM needs a jump slot right after the main instruction.
     * When the JUMP is taken, output spilling is not needed so this
     * workaround is possible.  The jump slot PC is exceptionally
     * plumbed through comp_ctx to minimize call sites.
     */
    if (op_flags & DUK__EMIT_FLAG_RESERVE_JUMPSLOT) {
        comp_ctx->emit_jumpslot_pc = duk__get_current_pc(comp_ctx);
        duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
    }
 
    /* Output shuffling: only one output register is realistically possible.
     *
     * (Zero would normally be an OK marker value: if the target register
     * was zero, it would never be shuffled.  But with DUK_USE_SHUFFLE_TORTURE
     * this is no longer true, so use -1 as a marker instead.)
     */
 
    if (a_out >= 0) {
        DUK_ASSERT(b_out < 0);

Referenced by duk__emit_invalid(), and duk__init_varmap_and_prologue_for_pass2().

◆ duk__emit_a_bc()

DUK_LOCAL_DECL void duk__emit_a_bc	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	op_flags,
		duk_regconst_t	a,
		duk_regconst_t	bc )

Definition at line 59104 of file duktape-1.8.0/src/duktape.c.

                :
    DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
}
 
DUK_LOCAL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b) {
    duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, b, 0);
}
 
#if 0  /* unused */
DUK_LOCAL void duk__emit_a(duk_compiler_ctx *comp_ctx, int op_flags, int a) {
    duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_B | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, 0, 0);
}
#endif
 
DUK_LOCAL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc) {
    duk_instr_t ins;
    duk_int_t tmp;
 
    /* allow caller to give a const number with the DUK__CONST_MARKER */
    bc = bc & (~DUK__CONST_MARKER);
 
    DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN);  /* unsigned */
    DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
    DUK_ASSERT_DISABLE(bc >= DUK_BC_BC_MIN);  /* unsigned */
    DUK_ASSERT(bc <= DUK_BC_BC_MAX);
    DUK_ASSERT((bc & DUK__CONST_MARKER) == 0);
 
    if (bc <= DUK_BC_BC_MAX) {
        ;
    } else {
        /* No BC shuffling now. */
        goto error_outofregs;
    }
 
#if defined(DUK_USE_SHUFFLE_TORTURE)
    if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
#else
    if (a <= DUK_BC_A_MAX) {
#endif
        ins = DUK_ENC_OP_A_BC(op_flags & 0xff, a, bc);
        duk__emit(comp_ctx, ins);
    } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
        goto error_outofregs;
    } else if (a <= DUK_BC_BC_MAX) {
        comp_ctx->curr_func.needs_shuffle = 1;

Referenced by duk__emit_load_int32(), duk__init_varmap_and_prologue_for_pass2(), duk__ispec_toregconst_raw(), and duk__parse_var_decl().

◆ duk__emit_abc()

DUK_LOCAL_DECL void duk__emit_abc	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	op,
		duk_regconst_t	abc )

Definition at line 59153 of file duktape-1.8.0/src/duktape.c.

                                                   {
            duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
            duk__emit(comp_ctx, ins);
        } else {
            duk__emit(comp_ctx, ins);
            duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, tmp, a));
        }
    } else {
        goto error_outofregs;
    }
    return;
 
 error_outofregs:
    DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
}
 
DUK_LOCAL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc) {
    duk_instr_t ins;
 
    DUK_ASSERT_DISABLE(op >= DUK_BC_OP_MIN);  /* unsigned */
    DUK_ASSERT(op <= DUK_BC_OP_MAX);
    DUK_ASSERT_DISABLE(abc >= DUK_BC_ABC_MIN);  /* unsigned */
    DUK_ASSERT(abc <= DUK_BC_ABC_MAX);
    DUK_ASSERT((abc & DUK__CONST_MARKER) == 0);

◆ duk__emit_cstring()

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

Definition at line 30157 of file duktape-1.8.0/src/duktape.c.

◆ duk__emit_esc_auto_fast()

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

Definition at line 30183 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__emit_extraop_b()

DUK_LOCAL_DECL void duk__emit_extraop_b	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	extraop_flags,
		duk_regconst_t	b )

Definition at line 59192 of file duktape-1.8.0/src/duktape.c.

                :
    DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
}
 
DUK_LOCAL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c) {
    DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
    DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
    /* Setting "no shuffle A" is covered by the assert, but it's needed
     * with DUK_USE_SHUFFLE_TORTURE.
     */
    duk__emit_a_b_c(comp_ctx,
                    DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff),  /* transfer flags */

◆ duk__emit_extraop_b_c()

DUK_LOCAL_DECL void duk__emit_extraop_b_c	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	extraop_flags,
		duk_regconst_t	b,
		duk_regconst_t	c )

Definition at line 59179 of file duktape-1.8.0/src/duktape.c.

                               {
        ;
    } else {
        goto error_outofregs;
    }
    ins = DUK_ENC_OP_ABC(op, abc);
    DUK_DDD(DUK_DDDPRINT("duk__emit_abc: 0x%08lx line=%ld pc=%ld op=%ld (%!C) abc=%ld (%!I)",
                         (unsigned long) ins, (long) comp_ctx->curr_token.start_line,
                         (long) duk__get_current_pc(comp_ctx), (long) op, (long) op,
                         (long) abc, (duk_instr_t) ins));
    duk__emit(comp_ctx, ins);
    return;

◆ duk__emit_extraop_bc()

DUK_LOCAL_DECL void duk__emit_extraop_bc	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	extraop,
		duk_regconst_t	bc )

Definition at line 59205 of file duktape-1.8.0/src/duktape.c.

                                                                                                                 {
    DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
    DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
    /* Setting "no shuffle A" is covered by the assert, but it's needed
     * with DUK_USE_SHUFFLE_TORTURE.
     */
    duk__emit_a_b_c(comp_ctx,

Referenced by duk__ispec_toregconst_raw(), duk__parse_func_body(), and duk__parse_try_stmt().

◆ duk__emit_extraop_only()

DUK_LOCAL_DECL void duk__emit_extraop_only	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	extraop_flags )

Definition at line 59217 of file duktape-1.8.0/src/duktape.c.

                                                                                                             {
    DUK_ASSERT_DISABLE(extraop >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
    DUK_ASSERT(extraop <= DUK_BC_EXTRAOP_MAX);
    /* Setting "no shuffle A" is covered by the assert, but it's needed
     * with DUK_USE_SHUFFLE_TORTURE.
     */
    duk__emit_a_bc(comp_ctx,
                   DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A,

◆ duk__emit_hstring()

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

Definition at line 30152 of file duktape-1.8.0/src/duktape.c.

◆ duk__emit_if_false_skip()

DUK_LOCAL_DECL void duk__emit_if_false_skip	(	duk_compiler_ctx *	comp_ctx,
		duk_regconst_t	regconst )

Definition at line 59396 of file duktape-1.8.0/src/duktape.c.

           {
        /* No catch variable, e.g. a try-finally; replace LDCONST with
         * NOP to avoid a bogus LDCONST.
         */

◆ duk__emit_if_true_skip()

DUK_LOCAL_DECL void duk__emit_if_true_skip	(	duk_compiler_ctx *	comp_ctx,
		duk_regconst_t	regconst )

Definition at line 59404 of file duktape-1.8.0/src/duktape.c.

◆ duk__emit_invalid()

DUK_LOCAL_DECL void duk__emit_invalid ( duk_compiler_ctx * comp_ctx )

Definition at line 59412 of file duktape-1.8.0/src/duktape.c.

59413 {

59414 duk__emit_a_b_c(comp_ctx,

References duk__emit_a_b_c(), DUK__EMIT_FLAG_NO_SHUFFLE_A, DUK__EMIT_FLAG_NO_SHUFFLE_C, and DUK_OP_IF.

◆ duk__emit_jump()

DUK_LOCAL_DECL void duk__emit_jump	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	target_pc )

Definition at line 59273 of file duktape-1.8.0/src/duktape.c.

                                                                                                          {
    duk__emit_load_int32_raw(comp_ctx, reg, val, DUK__EMIT_FLAG_NO_SHUFFLE_A /*op_flags*/);
}
#else
DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
    /* When torture not enabled, can just use the same helper because

References DUK__EMIT_FLAG_NO_SHUFFLE_A, and duk__emit_load_int32_raw().

◆ duk__emit_jump_empty()

DUK_LOCAL_DECL duk_int_t duk__emit_jump_empty ( duk_compiler_ctx * comp_ctx )

Definition at line 59284 of file duktape-1.8.0/src/duktape.c.

59290 {

◆ duk__emit_load_int32()

DUK_LOCAL_DECL void duk__emit_load_int32	(	duk_compiler_ctx *	comp_ctx,
		duk_reg_t	reg,
		duk_int32_t	val )

Definition at line 59252 of file duktape-1.8.0/src/duktape.c.

References duk__emit_a_bc(), DUK_BC_LDINT_BIAS, DUK_DDD, DUK_DDDPRINT, and DUK_OP_LDINT.

Referenced by duk__ispec_toregconst_raw().

◆ duk__emit_load_int32_noshuffle()

DUK_LOCAL_DECL void duk__emit_load_int32_noshuffle	(	duk_compiler_ctx *	comp_ctx,
		duk_reg_t	reg,
		duk_int32_t	val )

Definition at line 59264 of file duktape-1.8.0/src/duktape.c.

59269 {

59270 duk__emit_load_int32_raw(comp_ctx, reg, val, 0 /*op_flags*/);

◆ duk__emit_load_int32_raw()

DUK_LOCAL void duk__emit_load_int32_raw	(	duk_compiler_ctx *	comp_ctx,
		duk_reg_t	reg,
		duk_int32_t	val,
		duk_small_uint_t	op_flags )

Definition at line 59231 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
    DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
    /* Setting "no shuffle A" is covered by the assert, but it's needed
     * with DUK_USE_SHUFFLE_TORTURE.
     */
    duk__emit_a_b_c(comp_ctx,
                    DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_B |
                        DUK__EMIT_FLAG_NO_SHUFFLE_C | (extraop_flags & ~0xff),  /* transfer flags */
                    extraop_flags & 0xff,
                    0,
                    0);
}
 
DUK_LOCAL void duk__emit_load_int32_raw(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val, duk_small_uint_t op_flags) {
    /* XXX: Shuffling support could be implemented here so that LDINT+LDINTX
     * would only shuffle once (instead of twice).  The current code works

Referenced by duk__emit_jump().

◆ duk__emit_stridx()

DUK_LOCAL_DECL void duk__emit_stridx	(	duk_json_enc_ctx *	js_ctx,
		duk_small_uint_t	stridx )

Definition at line 30162 of file duktape-1.8.0/src/duktape.c.

                                                                                                 {
    DUK_BW_WRITE_ENSURE_U8_2(js_ctx->thr, &js_ctx->bw, ch1, ch2);
}
 
DUK_LOCAL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h) {
    DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h);
}

◆ duk__emit_u16_direct_ranges()

DUK_LOCAL void duk__emit_u16_direct_ranges	(	duk_lexer_ctx *	lex_ctx,
		duk_re_range_callback	gen_range,
		void *	userdata,
		const duk_uint16_t *	ranges,
		duk_small_int_t	num )

Definition at line 75187 of file duktape-1.8.0/src/duktape.c.

◆ duk__enc_allow_into_proplist()

DUK_LOCAL_DECL duk_bool_t duk__enc_allow_into_proplist ( duk_tval * tv )

Definition at line 31278 of file duktape-1.8.0/src/duktape.c.

             :
    duk_pop_2(ctx); /* [ ... key val ] -> [ ... ] */
    return 1;  /* emitted */
 
 pop2_undef:
    duk_pop_2(ctx);  /* [ ... key val ] -> [ ... ] */
    return 0;  /* not emitted */
}
 
/* E5 Section 15.12.3, main algorithm, step 4.b.ii steps 1-4. */
DUK_LOCAL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv) {

◆ duk__enc_array()

DUK_LOCAL_DECL void duk__enc_array ( duk_json_enc_ctx * js_ctx )

Definition at line 30954 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__enc_buffer()

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

Definition at line 30648 of file duktape-1.8.0/src/duktape.c.

30652 {

References DUK_ASSERT, DUK_MEMCPY, and duk_json_enc_ctx::flag_ext_compatible.

◆ duk__enc_buffer_data()

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

Definition at line 30594 of file duktape-1.8.0/src/duktape.c.

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

References duk_lc_digits.

◆ duk__enc_buffer_data_hex()

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

Definition at line 30517 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__enc_bufferobject()

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

Definition at line 30693 of file duktape-1.8.0/src/duktape.c.

    {
        DUK_ASSERT(js_ctx->flag_ext_compatible);
        fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}";
    }
#endif
 
    /* When ptr == NULL, the format argument is unused. */
    DUK_SNPRINTF(buf, sizeof(buf) - 1, fmt, ptr);  /* must not truncate */

References DUK_ASSERT, and duk_json_enc_ctx::flag_ext_compatible.

◆ duk__enc_double()

DUK_LOCAL_DECL void duk__enc_double ( duk_json_enc_ctx * js_ctx )

Definition at line 30425 of file duktape-1.8.0/src/duktape.c.

                       {
                    /* as is */
                    DUK_RAW_WRITE_XUTF8(q, cp);
                }
            }
        }
 
        DUK_BW_SET_PTR(thr, &js_ctx->bw, q);
    }
 
    DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE);
}
 
/* Encode a double (checked by caller) from stack top.  Stack top may be
 * replaced by serialized string but is not popped (caller does that).
 */
DUK_LOCAL void duk__enc_double(duk_json_enc_ctx *js_ctx) {
    duk_hthread *thr;
    duk_context *ctx;
    duk_tval *tv;
    duk_double_t d;
    duk_small_int_t c;
    duk_small_int_t s;
    duk_small_uint_t stridx;
    duk_small_uint_t n2s_flags;
    duk_hstring *h_str;
 
    DUK_ASSERT(js_ctx != NULL);
    thr = js_ctx->thr;
    DUK_ASSERT(thr != NULL);
    ctx = (duk_context *) thr;
 
    /* Caller must ensure 'tv' is indeed a double and not a fastint! */
    tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
    DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
    d = DUK_TVAL_GET_DOUBLE(tv);
 
    c = (duk_small_int_t) DUK_FPCLASSIFY(d);
    s = (duk_small_int_t) DUK_SIGNBIT(d);
    DUK_UNREF(s);
 
    if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) {
        DUK_ASSERT(DUK_ISFINITE(d));
 
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
        /* Negative zero needs special handling in JX/JC because
         * it would otherwise serialize to '0', not '-0'.
         */
        if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 &&
                         (js_ctx->flag_ext_custom_or_compatible))) {
            duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_ZERO);  /* '-0' */
        } else
#endif  /* DUK_USE_JX || DUK_USE_JC */
        {
            n2s_flags = 0;
            /* [ ... number ] -> [ ... string ] */
            duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags);
        }
        h_str = duk_to_hstring(ctx, -1);
        DUK_ASSERT(h_str != NULL);
        DUK__EMIT_HSTR(js_ctx, h_str);
        return;
    }

◆ duk__enc_key_autoquote()

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

Definition at line 30237 of file duktape-1.8.0/src/duktape.c.

                    {
        tmp--;
        dig = (duk_small_uint_t) ((cp >> (4 * tmp)) & 0x0f);
        *q++ = duk_lc_digits[dig];
    }
 
    return q;
}
 
DUK_LOCAL void duk__enc_key_autoquote(duk_json_enc_ctx *js_ctx, duk_hstring *k) {
    const duk_int8_t *p, *p_start, *p_end;  /* Note: intentionally signed. */
    duk_size_t k_len;
    duk_codepoint_t cp;
 
    DUK_ASSERT(k != NULL);
 
    /* Accept ASCII strings which conform to identifier requirements
     * as being emitted without key quotes.  Since we only accept ASCII
     * there's no need for actual decoding: 'p' is intentionally signed
     * so that bytes >= 0x80 extend to negative values and are rejected
     * as invalid identifier codepoints.
     */
 
    if (js_ctx->flag_avoid_key_quotes) {
        k_len = DUK_HSTRING_GET_BYTELEN(k);
        p_start = (const duk_int8_t *) DUK_HSTRING_GET_DATA(k);
        p_end = p_start + k_len;
        p = p_start;
 
        if (p == p_end) {
            /* Zero length string is not accepted without quotes */
            goto quote_normally;
        }
        cp = (duk_codepoint_t) (*p++);
        if (DUK_UNLIKELY(!duk_unicode_is_identifier_start(cp))) {
            goto quote_normally;
        }

◆ duk__enc_newline_indent()

DUK_LOCAL_DECL void duk__enc_newline_indent	(	duk_json_enc_ctx *	js_ctx,
		duk_int_t	depth )

Definition at line 30721 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__enc_objarr_entry()

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

Definition at line 30774 of file duktape-1.8.0/src/duktape.c.

                                      {
        DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) avail_bytes);
        p += avail_bytes;
        need_bytes -= avail_bytes;
        avail_bytes <<= 1;
    }
 
    DUK_ASSERT(need_bytes < avail_bytes);  /* need_bytes may be zero */
    DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) need_bytes);
    p += need_bytes;
    /*avail_bytes += need_bytes*/
 
    DUK_BW_SET_PTR(js_ctx->thr, &js_ctx->bw, p);
}
#endif  /* DUK_USE_PREFER_SIZE */
 
/* Shared entry handling for object/array serialization. */
DUK_LOCAL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top) {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hobject *h_target;
    duk_uint_fast32_t i, n;
 
    *entry_top = duk_get_top(ctx);
 
    duk_require_stack(ctx, DUK_JSON_ENC_REQSTACK);
 
    /* Loop check using a hybrid approach: a fixed-size visited[] array
     * with overflow in a loop check object.
     */
 
    h_target = duk_get_hobject(ctx, -1);  /* object or array */
    DUK_ASSERT(h_target != NULL);
 
    n = js_ctx->recursion_depth;
    if (DUK_UNLIKELY(n > DUK_JSON_ENC_LOOPARRAY)) {
        n = DUK_JSON_ENC_LOOPARRAY;
    }
    for (i = 0; i < n; i++) {
        if (DUK_UNLIKELY(js_ctx->visiting[i] == h_target)) {
            DUK_DD(DUK_DDPRINT("slow path loop detect"));
            DUK_ERROR_TYPE((duk_hthread *) ctx, DUK_STR_CYCLIC_INPUT);
        }
    }
    if (js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY) {
        js_ctx->visiting[js_ctx->recursion_depth] = h_target;
    } else {
        duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
        duk_dup_top(ctx);  /* -> [ ... voidp voidp ] */
        if (duk_has_prop(ctx, js_ctx->idx_loop)) {
            DUK_ERROR_TYPE((duk_hthread *) ctx, DUK_STR_CYCLIC_INPUT);

References DUK_MEMCPY.

◆ duk__enc_objarr_exit()

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

Definition at line 30826 of file duktape-1.8.0/src/duktape.c.

                                                            {
        DUK_ERROR_RANGE((duk_hthread *) ctx, DUK_STR_JSONENC_RECLIMIT);
    }
    js_ctx->recursion_depth++;
 
    DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
                         (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
}
 
/* Shared exit handling for object/array serialization. */
DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top) {
    duk_context *ctx = (duk_context *) js_ctx->thr;
    duk_hobject *h_target;
 
    /* C recursion check. */
 
    DUK_ASSERT(js_ctx->recursion_depth > 0);
    DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
    js_ctx->recursion_depth--;
 
    /* Loop check. */

◆ duk__enc_object()

DUK_LOCAL_DECL void duk__enc_object ( duk_json_enc_ctx * js_ctx )

Definition at line 30859 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__enc_pointer()

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

Definition at line 30656 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    duk__enc_buffer_data(js_ctx,
                         (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(js_ctx->thr->heap, h),
                         (duk_size_t) DUK_HBUFFER_GET_SIZE(h));
}
#endif  /* DUK_USE_JX || DUK_USE_JC */
 
#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
DUK_LOCAL void duk__enc_pointer(duk_json_enc_ctx *js_ctx, void *ptr) {
    char buf[64];  /* XXX: how to figure correct size? */
    const char *fmt;
 
    DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);  /* caller checks */
    DUK_ASSERT(js_ctx->flag_ext_custom_or_compatible);
 
    DUK_MEMZERO(buf, sizeof(buf));
 
    /* The #ifdef clutter here needs to handle the three cases:
     * (1) JX+JC, (2) JX only, (3) JC only.
     */
#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
    if (js_ctx->flag_ext_custom)
#endif
#if defined(DUK_USE_JX)
    {

◆ duk__enc_quote_string()

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

Definition at line 30288 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__enc_value()

DUK_LOCAL_DECL duk_bool_t duk__enc_value	(	duk_json_enc_ctx *	js_ctx,
		duk_idx_t	idx_holder )

Definition at line 31022 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__encode_i32()

DUK_LOCAL duk_uint32_t duk__encode_i32 ( duk_int32_t x )

Definition at line 77727 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__append_jump_offset().

◆ duk__err_augment_builtin_create()

DUK_LOCAL void duk__err_augment_builtin_create	(	duk_hthread *	thr,
		duk_hthread *	thr_callstack,
		const char *	c_filename,
		duk_int_t	c_line,
		duk_small_int_t	noblame_fileline,
		duk_hobject *	obj )

Definition at line 40290 of file duktape-1.8.0/src/duktape.c.

           {
        duk_pop(ctx);
    }
 
    DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
}
 
/*
 *  Augment an error being created using Duktape specific properties
 *  like _Tracedata or .fileName/.lineNumber.
 */
 
#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
DUK_LOCAL void duk__err_augment_builtin_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) {
    duk_context *ctx = (duk_context *) thr;
#if defined(DUK_USE_ASSERTIONS)
    duk_int_t entry_top;
#endif
 
#if defined(DUK_USE_ASSERTIONS)
    entry_top = duk_get_top(ctx);
#endif
    DUK_ASSERT(obj != NULL);
 
    DUK_UNREF(obj);  /* unreferenced w/o tracebacks */
    DUK_UNREF(ctx);  /* unreferenced w/o asserts */
 
    duk__add_compiler_error_line(thr);
 
#if defined(DUK_USE_TRACEBACKS)
    /* If tracebacks are enabled, the '_Tracedata' property is the only
     * thing we need: 'fileName' and 'lineNumber' are virtual properties
     * which use '_Tracedata'.

Referenced by duk_err_augment_error_create().

◆ duk__err_augment_user()

DUK_LOCAL void duk__err_augment_user	(	duk_hthread *	thr,
		duk_small_uint_t	stridx_cb )

Definition at line 39904 of file duktape-1.8.0/src/duktape.c.

        : since further longjmp()s may occur while calling the error handler
 *  (for many reasons, e.g. a labeled 'break' inside the handler), the
 *  caller can make no assumptions on the thr->heap->lj state after the
 *  call (this affects especially duk_error_throw.c).  This is not an issue
 *  as long as the caller writes to the lj state only after the error handler
 *  finishes.
 */
 
#if defined(DUK_USE_ERRTHROW) || defined(DUK_USE_ERRCREATE)
DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb) {
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_hnd;
    duk_small_uint_t call_flags;
    duk_int_t rc;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT_DISABLE(stridx_cb >= 0);  /* unsigned */
    DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS);
 
    if (DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)) {
        DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore"));
        return;
    }
 
    /*
     *  Check whether or not we have an error handler.
     *
     *  We must be careful of not triggering an error when looking up the
     *  property.  For instance, if the property is a getter, we don't want
     *  to call it, only plain values are allowed.  The value, if it exists,
     *  is not checked.  If the value is not a function, a TypeError happens
     *  when it is called and that error replaces the original one.
     */
 
    DUK_ASSERT_VALSTACK_SPACE(thr, 4);  /* 3 entries actually needed below */
 
    /* [ ... errval ] */
 
    if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) {
        /* When creating built-ins, some of the built-ins may not be set
         * and we want to tolerate that when throwing errors.
         */
        DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring"));
        return;
    }
    tv_hnd = duk_hobject_find_existing_entry_tval_ptr(thr->heap,
                                                      thr->builtins[DUK_BIDX_DUKTAPE],
                                                      DUK_HTHREAD_GET_STRING(thr, stridx_cb));
    if (tv_hnd == NULL) {
        DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T",
                           (duk_tval *) tv_hnd));
        return;
    }
    DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T",
                         (duk_tval *) tv_hnd));
    duk_push_tval(ctx, tv_hnd);
 
    /* [ ... errval errhandler ] */
 
    duk_insert(ctx, -2);  /* -> [ ... errhandler errval ] */
    duk_push_undefined(ctx);
    duk_insert(ctx, -2);  /* -> [ ... errhandler undefined(= this) errval ] */
 
    /* [ ... errhandler undefined errval ] */
 
    /*
     *  DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C
     *  recursion depth limit (and won't increase it either).  This is
     *  dangerous, but useful because it allows the error handler to run
     *  even if the original error is caused by C recursion depth limit.
     *
     *  The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the
     *  duration of the error handler and cleared afterwards.  This flag
     *  prevents the error handler from running recursively.  The flag is
     *  heap level so that the flag properly controls even coroutines
     *  launched by an error handler.  Since the flag is heap level, it is
     *  critical to restore it correctly.
     *
     *  We ignore errors now: a success return and an error value both
     *  replace the original error value.  (This would be easy to change.)

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_ASSERT_VALSTACK_SPACE, DUK_BIDX_DUKTAPE, DUK_CALL_FLAG_IGNORE_RECLIMIT, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_HEAP_HAS_ERRHANDLER_RUNNING, DUK_HEAP_NUM_STRINGS, DUK_HEAP_SET_ERRHANDLER_RUNNING, duk_hobject_find_existing_entry_tval_ptr(), DUK_HTHREAD_GET_STRING, duk_insert(), duk_push_tval(), duk_push_undefined(), duk_hthread::heap, and NULL.

Referenced by duk_err_longjmp().

◆ duk__error_getter_helper()

DUK_LOCAL duk_ret_t duk__error_getter_helper	(	duk_context *	ctx,
		duk_small_int_t	output_type )

Definition at line 27189 of file duktape-1.8.0/src/duktape.c.

        : although _Tracedata is an internal property, user code can currently
 *  write to the array (or replace it with something other than an array).
 *  The code below must tolerate arbitrary _Tracedata.  It can throw errors
 *  etc, but cannot cause a segfault or memory unsafe behavior.
 */
 
/* constants arbitrary, chosen for small loads */
#define DUK__OUTPUT_TYPE_TRACEBACK   (-1)
#define DUK__OUTPUT_TYPE_FILENAME    0
#define DUK__OUTPUT_TYPE_LINENUMBER  1
 
DUK_LOCAL duk_ret_t duk__error_getter_helper(duk_context *ctx, duk_small_int_t output_type) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t idx_td;
    duk_small_int_t i;  /* traceback depth fits into 16 bits */
    duk_small_int_t t;  /* stack type fits into 16 bits */
    duk_small_int_t count_func = 0;  /* traceback depth ensures fits into 16 bits */
    const char *str_tailcall = " tailcall";
    const char *str_strict = " strict";
    const char *str_construct = " construct";
    const char *str_prevyield = " preventsyield";
    const char *str_directeval = " directeval";
    const char *str_empty = "";
 
    DUK_ASSERT_TOP(ctx, 0);  /* fixed arg count */
    DUK_UNREF(thr);
 
    duk_push_this(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TRACEDATA);
    idx_td = duk_get_top_index(ctx);
 
    duk_push_hstring_stridx(ctx, DUK_STRIDX_NEWLINE_4SPACE);
    duk_push_this(ctx);
 
    /* [ ... this tracedata sep this ] */
 
    /* XXX: skip null filename? */
 
    if (duk_check_type(ctx, idx_td, DUK_TYPE_OBJECT)) {
        /* Current tracedata contains 2 entries per callstack entry. */
        for (i = 0; ; i += 2) {
            duk_int_t pc;
            duk_int_t line;
            duk_int_t flags;
            duk_double_t d;
            const char *funcname;
            const char *filename;
            duk_hobject *h_func;
            duk_hstring *h_name;
 
            duk_require_stack(ctx, 5);
            duk_get_prop_index(ctx, idx_td, i);
            duk_get_prop_index(ctx, idx_td, i + 1);
            d = duk_to_number(ctx, -1);
            pc = (duk_int_t) DUK_FMOD(d, DUK_DOUBLE_2TO32);
            flags = (duk_int_t) DUK_FLOOR(d / DUK_DOUBLE_2TO32);
            t = (duk_small_int_t) duk_get_type(ctx, -2);
 
            if (t == DUK_TYPE_OBJECT || t == DUK_TYPE_LIGHTFUNC) {
                /*
                 *  Ecmascript/native function call or lightfunc call
                 */
 
                count_func++;
 
                /* [ ... v1(func) v2(pc+flags) ] */
 
                h_func = duk_get_hobject(ctx, -2);  /* NULL for lightfunc */
 
                duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
                duk_get_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME);
 
#if defined(DUK_USE_PC2LINE)
                line = duk_hobject_pc2line_query(ctx, -4, (duk_uint_fast32_t) pc);
#else
                line = 0;
#endif
 
                /* [ ... v1 v2 name filename ] */
 
                /* When looking for .fileName/.lineNumber, blame first
                 * function which has a .fileName.
                 */
                if (duk_is_string(ctx, -1)) {
                    if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
                        return 1;
                    } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
                        duk_push_int(ctx, line);
                        return 1;
                    }
                }
 
                /* XXX: Change 'anon' handling here too, to use empty string for anonymous functions? */
                /* XXX: Could be improved by coercing to a readable duk_tval (especially string escaping) */
                h_name = duk_get_hstring(ctx, -2);  /* may be NULL */
                funcname = (h_name == NULL || h_name == DUK_HTHREAD_STRING_EMPTY_STRING(thr)) ?
                           "[anon]" : (const char *) DUK_HSTRING_GET_DATA(h_name);
                filename = duk_get_string(ctx, -1);
                filename = filename ? filename : "";
                DUK_ASSERT(funcname != NULL);
                DUK_ASSERT(filename != NULL);
 
                if (h_func == NULL) {
                    duk_push_sprintf(ctx, "at %s light%s%s%s%s%s",
                                     (const char *) funcname,
                                     (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
                } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h_func)) {
                    duk_push_sprintf(ctx, "at %s (%s) native%s%s%s%s%s",
                                     (const char *) funcname,
                                     (const char *) filename,
                                     (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
                } else {
                    duk_push_sprintf(ctx, "at %s (%s:%ld)%s%s%s%s%s",
                                     (const char *) funcname,
                                     (const char *) filename,
                                     (long) line,
                                     (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
                }
                duk_replace(ctx, -5);   /* [ ... v1 v2 name filename str ] -> [ ... str v2 name filename ] */
                duk_pop_n(ctx, 3);      /* -> [ ... str ] */
            } else if (t == DUK_TYPE_STRING) {
                /*
                 *  __FILE__ / __LINE__ entry, here 'pc' is line number directly.
                 *  Sometimes __FILE__ / __LINE__ is reported as the source for
                 *  the error (fileName, lineNumber), sometimes not.
                 */
 
                /* [ ... v1(filename) v2(line+flags) ] */
 
                /* When looking for .fileName/.lineNumber, blame compilation
                 * or C call site unless flagged not to do so.
                 */
                if (!(flags & DUK_TB_FLAG_NOBLAME_FILELINE)) {
                    if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
                        duk_pop(ctx);
                        return 1;
                    } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
                        duk_push_int(ctx, pc);
                        return 1;
                    }
                }
 
                duk_push_sprintf(ctx, "at [anon] (%s:%ld) internal",
                                 (const char *) duk_get_string(ctx, -2), (long) pc);
                duk_replace(ctx, -3);  /* [ ... v1 v2 str ] -> [ ... str v2 ] */
                duk_pop(ctx);          /* -> [ ... str ] */
            } else {
                /* unknown, ignore */
                duk_pop_2(ctx);
                break;
            }
        }
 
        if (count_func >= DUK_USE_TRACEBACK_DEPTH) {
            /* Possibly truncated; there is no explicit truncation
             * marker so this is the best we can do.
             */
 

References DUK__OUTPUT_TYPE_FILENAME, DUK__OUTPUT_TYPE_LINENUMBER, DUK_ACT_FLAG_CONSTRUCT, DUK_ACT_FLAG_DIRECT_EVAL, DUK_ACT_FLAG_PREVENT_YIELD, DUK_ACT_FLAG_STRICT, DUK_ACT_FLAG_TAILCALLED, DUK_ASSERT, DUK_ASSERT_TOP, duk_check_type(), DUK_DOUBLE_2TO32, DUK_FLOOR, DUK_FMOD, duk_get_hobject(), duk_get_hstring(), duk_get_prop_index(), duk_get_prop_stridx(), duk_get_string(), duk_get_top_index(), duk_get_type(), DUK_HOBJECT_HAS_NATIVEFUNCTION, duk_hobject_pc2line_query(), DUK_HSTRING_GET_DATA, DUK_HTHREAD_STRING_EMPTY_STRING, duk_is_string(), duk_pop(), duk_pop_2(), duk_pop_n(), duk_push_hstring_stridx(), duk_push_int(), duk_push_sprintf(), duk_push_this(), duk_replace(), duk_require_stack(), DUK_STRIDX_BRACKETED_ELLIPSIS, DUK_STRIDX_FILE_NAME, DUK_STRIDX_INT_TRACEDATA, DUK_STRIDX_NAME, DUK_STRIDX_NEWLINE_4SPACE, DUK_TB_FLAG_NOBLAME_FILELINE, duk_to_number(), DUK_TYPE_LIGHTFUNC, DUK_TYPE_OBJECT, DUK_TYPE_STRING, DUK_UNREF, DUK_USE_TRACEBACK_DEPTH, funcname(), and NULL.

◆ duk__error_setter_helper()

DUK_LOCAL duk_ret_t duk__error_setter_helper	(	duk_context *	ctx,
		duk_small_uint_t	stridx_key )

Definition at line 27419 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    DUK_UNREF(ctx);
    return 0;
}
 
DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx) {
    DUK_UNREF(ctx);
    return 0;
}
 
#endif  /* DUK_USE_TRACEBACKS */
 
DUK_LOCAL duk_ret_t duk__error_setter_helper(duk_context *ctx, duk_small_uint_t stridx_key) {
    /* Attempt to write 'stack', 'fileName', 'lineNumber' works as if
     * user code called Object.defineProperty() to create an overriding
     * own property.  This allows user code to overwrite .fileName etc
     * intuitively as e.g. "err.fileName = 'dummy'" as one might expect.
     * See https://github.com/svaarala/duktape/issues/387.
     */
 

◆ duk__exp()

DUK_LOCAL double duk__exp ( double x )

Definition at line 32753 of file duktape-1.8.0/src/duktape.c.

32755 {

◆ duk__expr()

DUK_LOCAL_DECL void duk__expr	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62480 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_ivalue tmp_alloc;   /* 'res' is used for "left", and 'tmp' for "right" */
    duk_ivalue *tmp = &tmp_alloc;
    duk_small_uint_t rbp;
 
    DUK__RECURSION_INCREASE(comp_ctx, thr);
 
    duk_require_stack(ctx, DUK__PARSE_EXPR_SLOTS);
 
    /* filter out flags from exprtop rbp_flags here to save space */
    rbp = rbp_flags & DUK__EXPR_RBP_MASK;
 
    DUK_DDD(DUK_DDDPRINT("duk__expr(), rbp_flags=%ld, rbp=%ld, allow_in=%ld, paren_level=%ld",
                         (long) rbp_flags, (long) rbp, (long) comp_ctx->curr_func.allow_in,
                         (long) comp_ctx->curr_func.paren_level));
 
    DUK_MEMZERO(&tmp_alloc, sizeof(tmp_alloc));
    tmp->x1.valstack_idx = duk_get_top(ctx);
    tmp->x2.valstack_idx = tmp->x1.valstack_idx + 1;
    duk_push_undefined(ctx);
    duk_push_undefined(ctx);
 
    /* XXX: where to release temp regs in intermediate expressions?
     * e.g. 1+2+3 -> don't inflate temp register count when parsing this.
     * that particular expression temp regs can be forced here.
     */
 
    /* XXX: increase ctx->expr_tokens here for every consumed token
     * (this would be a nice statistic)?
     */
 
    if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
        /* XXX: possibly incorrect handling of empty expression */
        DUK_DDD(DUK_DDDPRINT("empty expression"));
        if (!(rbp_flags & DUK__EXPR_FLAG_ALLOW_EMPTY)) {
            DUK_ERROR_SYNTAX(thr, DUK_STR_EMPTY_EXPR_NOT_ALLOWED);
        }
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_VALUE;
        duk_push_undefined(ctx);
        duk_replace(ctx, res->x1.valstack_idx);
        goto cleanup;

Referenced by duk__expr_toforcedreg(), duk__expr_toplain_ignore(), duk__exprtop_toforcedreg(), and duk__exprtop_toreg().

◆ duk__expr_is_empty()

DUK_LOCAL_DECL duk_bool_t duk__expr_is_empty ( duk_compiler_ctx * comp_ctx )

Definition at line 60953 of file duktape-1.8.0/src/duktape.c.

◆ duk__expr_lbp()

DUK_LOCAL_DECL duk_small_uint_t duk__expr_lbp ( duk_compiler_ctx * comp_ctx )

Definition at line 62436 of file duktape-1.8.0/src/duktape.c.

             :
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_EXPRESSION);
    return;
 
 syntax_error_lvalue:
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_LVALUE);
    return;
}
 
DUK_LOCAL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx) {
    duk_small_int_t tok = comp_ctx->curr_token.t;
 
    DUK_ASSERT(tok >= DUK_TOK_MINVAL && tok <= DUK_TOK_MAXVAL);
    DUK_ASSERT(sizeof(duk__token_lbp) == DUK_TOK_MAXVAL + 1);
 
    /* XXX: integrate support for this into led() instead?
     * Similar issue as post-increment/post-decrement.
     */
 
    /* prevent duk__expr_led() by using a binding power less than anything valid */

◆ duk__expr_led()

DUK_LOCAL_DECL void duk__expr_led	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	left,
		duk_ivalue *	res )

Definition at line 61483 of file duktape-1.8.0/src/duktape.c.

            :
    {
        /* Stack top contains plain value */
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_VALUE;
        duk_replace(ctx, res->x1.valstack_idx);
        return;
    }
 
 syntax_error:
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_EXPRESSION);
}
 
/* XXX: add flag to indicate whether caller cares about return value; this
 * affects e.g. handling of assignment expressions.  This change needs API
 * changes elsewhere too.
 */
DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_token *tk;
    duk_small_int_t tok;
    duk_uint32_t args;  /* temp variable to pass constants and flags to shared code */
 
    /*
     *  ctx->prev_token     token to process with duk__expr_led()
     *  ctx->curr_token     updated by caller
     */
 
    comp_ctx->curr_func.led_count++;
 
    /* The token in the switch has already been eaten here */
    tk = &comp_ctx->prev_token;
    tok = tk->t;
 
    DUK_DDD(DUK_DDDPRINT("duk__expr_led(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld",
                         (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level));
 
    /* XXX: default priority for infix operators is duk__expr_lbp(tok) -> get it here? */
 
    switch (tok) {
 
    /* PRIMARY EXPRESSIONS */
 
    case DUK_TOK_PERIOD: {
        /* Property access expressions are critical for correct LHS ordering,
         * see comments in duk__expr()!
         *
         * A conservative approach would be to use duk__ivalue_totempconst()
         * for 'left'.  However, allowing a reg-bound variable seems safe here
         * and is nice because "foo.bar" is a common expression.  If the ivalue
         * is used in an expression a GETPROP will occur before any changes to
         * the base value can occur.  If the ivalue is used as an assignment
         * LHS, the assignment code will ensure the base value is safe from
         * RHS mutation.
         */
 
        /* XXX: This now coerces an identifier into a GETVAR to a temp, which
         * causes an extra LDREG in call setup.  It's sufficient to coerce to a
         * unary ivalue?
         */
        duk__ivalue_toplain(comp_ctx, left);
 
        /* NB: must accept reserved words as property name */
        if (comp_ctx->curr_token.t_nores != DUK_TOK_IDENTIFIER) {
            DUK_ERROR_SYNTAX(thr, DUK_STR_EXPECTED_IDENTIFIER);
        }
 
        res->t = DUK_IVAL_PROP;
        duk__copy_ispec(comp_ctx, &left->x1, &res->x1);  /* left.x1 -> res.x1 */
        DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
        duk_push_hstring(ctx, comp_ctx->curr_token.str1);
        duk_replace(ctx, res->x2.valstack_idx);
        res->x2.t = DUK_ISPEC_VALUE;
 
        /* special RegExp literal handling after IdentifierName */
        comp_ctx->curr_func.reject_regexp_in_adv = 1;
 
        duk__advance(comp_ctx);
        return;
    }
    case DUK_TOK_LBRACKET: {
        /* Property access expressions are critical for correct LHS ordering,
         * see comments in duk__expr()!
         */
 
        /* XXX: optimize temp reg use */
        /* XXX: similar coercion issue as in DUK_TOK_PERIOD */
        /* XXX: coerce to regs? it might be better for enumeration use, where the
         * same PROP ivalue is used multiple times.  Or perhaps coerce PROP further
         * there?
         */
        /* XXX: for simple cases like x['y'] an unnecessary LDREG is
         * emitted for the base value; could avoid it if we knew that
         * the key expression is safe (e.g. just a single literal).
         */
 
        /* The 'left' value must not be a register bound variable
         * because it may be mutated during the rest of the expression
         * and E5.1 Section 11.2.1 specifies the order of evaluation
         * so that the base value is evaluated first.
         * See: test-bug-nested-prop-mutate.js.
         */
        duk__ivalue_totempconst(comp_ctx, left);
        duk__expr_toplain(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);  /* Expression, ']' terminates */
        duk__advance_expect(comp_ctx, DUK_TOK_RBRACKET);
 
        res->t = DUK_IVAL_PROP;
        duk__copy_ispec(comp_ctx, &res->x1, &res->x2);   /* res.x1 -> res.x2 */
        duk__copy_ispec(comp_ctx, &left->x1, &res->x1);  /* left.x1 -> res.x1 */
        return;
    }
    case DUK_TOK_LPAREN: {
        /* function call */
        duk_reg_t reg_cs = DUK__ALLOCTEMPS(comp_ctx, 2);
        duk_int_t nargs;
        duk_small_uint_t call_flags = 0;
 
        /*
         *  XXX: attempt to get the call result to "next temp" whenever
         *  possible to avoid unnecessary register shuffles.
         *
         *  XXX: CSPROP (and CSREG) can overwrite the call target register, and save one temp,
         *  if the call target is a temporary register and at the top of the temp reg "stack".
         */
 
        /*
         *  Setup call: target and 'this' binding.  Three cases:
         *
         *    1. Identifier base (e.g. "foo()")
         *    2. Property base (e.g. "foo.bar()")
         *    3. Register base (e.g. "foo()()"; i.e. when a return value is a function)
         */
 
        if (left->t == DUK_IVAL_VAR) {
            duk_hstring *h_varname;
            duk_reg_t reg_varbind;
            duk_regconst_t rc_varname;
 
            DUK_DDD(DUK_DDDPRINT("function call with identifier base"));
 
            h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
            DUK_ASSERT(h_varname != NULL);
            if (h_varname == DUK_HTHREAD_STRING_EVAL(thr)) {
                /* Potential direct eval call detected, flag the CALL
                 * so that a run-time "direct eval" check is made and
                 * special behavior may be triggered.  Note that this
                 * does not prevent 'eval' from being register bound.
                 */
                DUK_DDD(DUK_DDDPRINT("function call with identifier 'eval' "
                                     "-> enabling EVALCALL flag, marking function "
                                     "as may_direct_eval"));
                call_flags |= DUK_BC_CALL_FLAG_EVALCALL;
 
                comp_ctx->curr_func.may_direct_eval = 1;
            }
 
            duk_dup(ctx, left->x1.valstack_idx);
            if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
                duk__emit_a_b(comp_ctx,
                              DUK_OP_CSREG,
                              (duk_regconst_t) (reg_cs + 0),
                              (duk_regconst_t) reg_varbind);
            } else {
                duk__emit_a_b(comp_ctx,
                              DUK_OP_CSVAR,
                              (duk_regconst_t) (reg_cs + 0),
                              rc_varname);
            }
        } else if (left->t == DUK_IVAL_PROP) {
            DUK_DDD(DUK_DDDPRINT("function call with property base"));
 
            duk__ispec_toforcedreg(comp_ctx, &left->x1, reg_cs + 0);  /* base */
            duk__ispec_toforcedreg(comp_ctx, &left->x2, reg_cs + 1);  /* key */
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_CSPROP,
                            (duk_regconst_t) (reg_cs + 0),
                            (duk_regconst_t) (reg_cs + 0),
                            (duk_regconst_t) (reg_cs + 1));  /* in-place setup */
        } else {
            DUK_DDD(DUK_DDDPRINT("function call with register base"));
 
            duk__ivalue_toforcedreg(comp_ctx, left, reg_cs + 0);
            duk__emit_a_b(comp_ctx,
                          DUK_OP_CSREG,
                          (duk_regconst_t) (reg_cs + 0),
                          (duk_regconst_t) (reg_cs + 0));  /* in-place setup */
        }
 
        DUK__SETTEMP(comp_ctx, reg_cs + 2);
        nargs = duk__parse_arguments(comp_ctx, res);  /* parse args starting from "next temp" */
 
        /* Tailcalls are handled by back-patching the TAILCALL flag to the
         * already emitted instruction later (in return statement parser).
         * Since A and C have a special meaning here, they cannot be "shuffled".
         */
 
        duk__emit_a_b_c(comp_ctx,
                        DUK_OP_CALL | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
                        (duk_regconst_t) call_flags /*flags*/,
                        (duk_regconst_t) reg_cs /*basereg*/,
                        (duk_regconst_t) nargs /*numargs*/);
        DUK__SETTEMP(comp_ctx, reg_cs + 1);    /* result in csreg */
 
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_cs;
        return;
    }
 
    /* POSTFIX EXPRESSION */
 
    case DUK_TOK_INCREMENT: {
        args = (DUK_OP_POSTINCR << 8) + 0;
        goto postincdec;
    }
    case DUK_TOK_DECREMENT: {
        args = (DUK_OP_POSTDECR << 8) + 0;
        goto postincdec;
    }
 
    /* MULTIPLICATIVE EXPRESSION */
 
    case DUK_TOK_MUL: {
        args = (DUK_OP_MUL << 8) + DUK__BP_MULTIPLICATIVE;  /* UnaryExpression */
        goto binary;
    }
    case DUK_TOK_DIV: {
        args = (DUK_OP_DIV << 8) + DUK__BP_MULTIPLICATIVE;  /* UnaryExpression */
        goto binary;
    }
    case DUK_TOK_MOD: {
        args = (DUK_OP_MOD << 8) + DUK__BP_MULTIPLICATIVE;  /* UnaryExpression */
        goto binary;
    }
 
    /* ADDITIVE EXPRESSION */
 
    case DUK_TOK_ADD: {
        args = (DUK_OP_ADD << 8) + DUK__BP_ADDITIVE;  /* MultiplicativeExpression */
        goto binary;
    }
    case DUK_TOK_SUB: {
        args = (DUK_OP_SUB << 8) + DUK__BP_ADDITIVE;  /* MultiplicativeExpression */
        goto binary;
    }
 
    /* SHIFT EXPRESSION */
 
    case DUK_TOK_ALSHIFT: {
        /* << */
        args = (DUK_OP_BASL << 8) + DUK__BP_SHIFT;
        goto binary;
    }
    case DUK_TOK_ARSHIFT: {
        /* >> */
        args = (DUK_OP_BASR << 8) + DUK__BP_SHIFT;
        goto binary;
    }
    case DUK_TOK_RSHIFT: {
        /* >>> */
        args = (DUK_OP_BLSR << 8) + DUK__BP_SHIFT;
        goto binary;
    }
 
    /* RELATIONAL EXPRESSION */
 
    case DUK_TOK_LT: {
        /* < */
        args = (DUK_OP_LT << 8) + DUK__BP_RELATIONAL;
        goto binary;
    }
    case DUK_TOK_GT: {
        args = (DUK_OP_GT << 8) + DUK__BP_RELATIONAL;
        goto binary;
    }
    case DUK_TOK_LE: {
        args = (DUK_OP_LE << 8) + DUK__BP_RELATIONAL;
        goto binary;
    }
    case DUK_TOK_GE: {
        args = (DUK_OP_GE << 8) + DUK__BP_RELATIONAL;
        goto binary;
    }
    case DUK_TOK_INSTANCEOF: {
        args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_INSTOF << 8) + DUK__BP_RELATIONAL;
        goto binary;
    }
    case DUK_TOK_IN: {
        args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_IN << 8) + DUK__BP_RELATIONAL;
        goto binary;
    }
 
    /* EQUALITY EXPRESSION */
 
    case DUK_TOK_EQ: {
        args = (DUK_OP_EQ << 8) + DUK__BP_EQUALITY;
        goto binary;
    }
    case DUK_TOK_NEQ: {
        args = (DUK_OP_NEQ << 8) + DUK__BP_EQUALITY;
        goto binary;
    }
    case DUK_TOK_SEQ: {
        args = (DUK_OP_SEQ << 8) + DUK__BP_EQUALITY;
        goto binary;
    }
    case DUK_TOK_SNEQ: {
        args = (DUK_OP_SNEQ << 8) + DUK__BP_EQUALITY;
        goto binary;
    }
 
    /* BITWISE EXPRESSIONS */
 
    case DUK_TOK_BAND: {
        args = (DUK_OP_BAND << 8) + DUK__BP_BAND;
        goto binary;
    }
    case DUK_TOK_BXOR: {
        args = (DUK_OP_BXOR << 8) + DUK__BP_BXOR;
        goto binary;
    }
    case DUK_TOK_BOR: {
        args = (DUK_OP_BOR << 8) + DUK__BP_BOR;
        goto binary;
    }
 
    /* LOGICAL EXPRESSIONS */
 
    case DUK_TOK_LAND: {
        /* syntactically left-associative but parsed as right-associative */
        args = (1 << 8) + DUK__BP_LAND - 1;
        goto binary_logical;
    }
    case DUK_TOK_LOR: {
        /* syntactically left-associative but parsed as right-associative */
        args = (0 << 8) + DUK__BP_LOR - 1;
        goto binary_logical;
    }
 
    /* CONDITIONAL EXPRESSION */
 
    case DUK_TOK_QUESTION: {
        /* XXX: common reg allocation need is to reuse a sub-expression's temp reg,
         * but only if it really is a temp.  Nothing fancy here now.
         */
        duk_reg_t reg_temp;
        duk_int_t pc_jump1;
        duk_int_t pc_jump2;
 
        reg_temp = DUK__ALLOCTEMP(comp_ctx);
        duk__ivalue_toforcedreg(comp_ctx, left, reg_temp);
        duk__emit_if_true_skip(comp_ctx, reg_temp);
        pc_jump1 = duk__emit_jump_empty(comp_ctx);  /* jump to false */
        duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);  /* AssignmentExpression */
        duk__advance_expect(comp_ctx, DUK_TOK_COLON);
        pc_jump2 = duk__emit_jump_empty(comp_ctx);  /* jump to end */
        duk__patch_jump_here(comp_ctx, pc_jump1);
        duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);  /* AssignmentExpression */
        duk__patch_jump_here(comp_ctx, pc_jump2);
 
        DUK__SETTEMP(comp_ctx, reg_temp + 1);
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_temp;
        return;
    }
 
    /* ASSIGNMENT EXPRESSION */
 
    case DUK_TOK_EQUALSIGN: {
        /*
         *  Assignments are right associative, allows e.g.
         *    a = 5;
         *    a += b = 9;   // same as a += (b = 9)
         *  -> expression value 14, a = 14, b = 9
         *
         *  Right associativiness is reflected in the BP for recursion,
         *  "-1" ensures assignment operations are allowed.
         *
         *  XXX: just use DUK__BP_COMMA (i.e. no need for 2-step bp levels)?
         */
        args = (DUK_OP_NONE << 8) + DUK__BP_ASSIGNMENT - 1;   /* DUK_OP_NONE marks a 'plain' assignment */
        goto assign;
    }
    case DUK_TOK_ADD_EQ: {
        /* right associative */
        args = (DUK_OP_ADD << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_SUB_EQ: {
        /* right associative */
        args = (DUK_OP_SUB << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_MUL_EQ: {
        /* right associative */
        args = (DUK_OP_MUL << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_DIV_EQ: {
        /* right associative */
        args = (DUK_OP_DIV << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_MOD_EQ: {
        /* right associative */
        args = (DUK_OP_MOD << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_ALSHIFT_EQ: {
        /* right associative */
        args = (DUK_OP_BASL << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_ARSHIFT_EQ: {
        /* right associative */
        args = (DUK_OP_BASR << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_RSHIFT_EQ: {
        /* right associative */
        args = (DUK_OP_BLSR << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_BAND_EQ: {
        /* right associative */
        args = (DUK_OP_BAND << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_BOR_EQ: {
        /* right associative */
        args = (DUK_OP_BOR << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
    case DUK_TOK_BXOR_EQ: {
        /* right associative */
        args = (DUK_OP_BXOR << 8) + DUK__BP_ASSIGNMENT - 1;
        goto assign;
    }
 
    /* COMMA */
 
    case DUK_TOK_COMMA: {
        /* right associative */
 
        duk__ivalue_toplain_ignore(comp_ctx, left);  /* need side effects, not value */
        duk__expr_toplain(comp_ctx, res, DUK__BP_COMMA - 1 /*rbp_flags*/);
 
        /* return 'res' (of right part) as our result */
        return;
    }
 
    default: {
        break;
    }
    }
 
    DUK_D(DUK_DPRINT("parse error: unexpected token: %ld", (long) tok));
    DUK_ERROR_SYNTAX(thr, DUK_STR_PARSE_ERROR);
    return;
 
#if 0
    /* XXX: shared handling for 'duk__expr_lhs'? */
    if (comp_ctx->curr_func.paren_level == 0 && XXX) {
        comp_ctx->curr_func.duk__expr_lhs = 0;
    }
#endif
 
 binary:
    /*
     *  Shared handling of binary operations
     *
     *  args = (is_extraop << 16) + (opcode << 8) + rbp
     */
    {
        duk__ivalue_toplain(comp_ctx, left);
        duk__expr_toplain(comp_ctx, res, args & 0xff /*rbp_flags*/);
 
        /* combine left->x1 and res->x1 (right->x1, really) -> (left->x1 OP res->x1) */
        DUK_ASSERT(left->t == DUK_IVAL_PLAIN);
        DUK_ASSERT(res->t == DUK_IVAL_PLAIN);
 
        res->t = (args >> 16) ? DUK_IVAL_ARITH_EXTRAOP : DUK_IVAL_ARITH;
        res->op = (args >> 8) & 0xff;
 
        res->x2.t = res->x1.t;
        res->x2.regconst = res->x1.regconst;
        duk_copy(ctx, res->x1.valstack_idx, res->x2.valstack_idx);
 
        res->x1.t = left->x1.t;
        res->x1.regconst = left->x1.regconst;
        duk_copy(ctx, left->x1.valstack_idx, res->x1.valstack_idx);
 
        DUK_DDD(DUK_DDDPRINT("binary op, res: t=%ld, x1.t=%ld, x1.regconst=0x%08lx, x2.t=%ld, x2.regconst=0x%08lx",
                             (long) res->t, (long) res->x1.t, (unsigned long) res->x1.regconst, (long) res->x2.t, (unsigned long) res->x2.regconst));
        return;
    }
 
 binary_logical:
    /*
     *  Shared handling for logical AND and logical OR.
     *
     *  args = (truthval << 8) + rbp
     *
     *  Truthval determines when to skip right-hand-side.
     *  For logical AND truthval=1, for logical OR truthval=0.
     *
     *  See doc/compiler.rst for discussion on compiling logical
     *  AND and OR expressions.  The approach here is very simplistic,
     *  generating extra jumps and multiple evaluations of truth values,
     *  but generates code on-the-fly with only local back-patching.
     *
     *  Both logical AND and OR are syntactically left-associated.
     *  However, logical ANDs are compiled as right associative
     *  expressions, i.e. "A && B && C" as "A && (B && C)", to allow
     *  skip jumps to skip over the entire tail.  Similarly for logical OR.
     */
 
    {
        duk_reg_t reg_temp;
        duk_int_t pc_jump;
        duk_small_uint_t args_truthval = args >> 8;
        duk_small_uint_t args_rbp = args & 0xff;
 
        /* XXX: unoptimal use of temps, resetting */
 
        reg_temp = DUK__ALLOCTEMP(comp_ctx);
 
        duk__ivalue_toforcedreg(comp_ctx, left, reg_temp);
        duk__emit_a_b(comp_ctx,
                      DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A,
                      (duk_regconst_t) args_truthval,
                      (duk_regconst_t) reg_temp);  /* skip jump conditionally */
        pc_jump = duk__emit_jump_empty(comp_ctx);
        duk__expr_toforcedreg(comp_ctx, res, args_rbp /*rbp_flags*/, reg_temp /*forced_reg*/);
        duk__patch_jump_here(comp_ctx, pc_jump);
 
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_temp;
        return;
    }
 
 assign:
    /*
     *  Shared assignment expression handling
     *
     *  args = (opcode << 8) + rbp
     *
     *  If 'opcode' is DUK_OP_NONE, plain assignment without arithmetic.
     *  Syntactically valid left-hand-side forms which are not accepted as
     *  left-hand-side values (e.g. as in "f() = 1") must NOT cause a
     *  SyntaxError, but rather a run-time ReferenceError.
     *
     *  When evaluating X <op>= Y, the LHS (X) is conceptually evaluated
     *  to a temporary first.  The RHS is then evaluated.  Finally, the
     *  <op> is applied to the initial value of RHS (not the value after
     *  RHS evaluation), and written to X.  Doing so concretely generates
     *  inefficient code so we'd like to avoid the temporary when possible.
     *  See: https://github.com/svaarala/duktape/pull/992.
     *
     *  The expression value (final LHS value, written to RHS) is
     *  conceptually copied into a fresh temporary so that it won't
     *  change even if the LHS/RHS values change in outer expressions.
     *  For example, it'd be generally incorrect for the expression value
     *  to be the RHS register binding, unless there's a guarantee that it
     *  won't change during further expression evaluation.  Using the
     *  temporary concretely produces inefficient bytecode, so we try to
     *  avoid the extra temporary for some known-to-be-safe cases.
     *  Currently the only safe case we detect is a "top level assignment",
     *  for example "x = y + z;", where the assignment expression value is
     *  ignored.
     *  See: test-dev-assign-expr.js and test-bug-assign-mutate-gh381.js.
     */
 
    {
        duk_small_uint_t args_op = args >> 8;
        duk_small_uint_t args_rbp = args & 0xff;
        duk_bool_t toplevel_assign;
 
        /* XXX: here we need to know if 'left' is left-hand-side compatible.
         * That information is no longer available from current expr parsing
         * state; it would need to be carried into the 'left' ivalue or by
         * some other means.
         */
 
        /* A top-level assignment is e.g. "x = y;".  For these it's safe
         * to use the RHS as-is as the expression value, even if the RHS
         * is a reg-bound identifier.  The RHS ('res') is right associative
         * so it has consumed all other assignment level operations; the
         * only relevant lower binding power construct is comma operator
         * which will ignore the expression value provided here.  Usually
         * the top level assignment expression value is ignored, but it
         * is relevant for e.g. eval code.
         */
        toplevel_assign = (comp_ctx->curr_func.nud_count == 1 && /* one token before */
                           comp_ctx->curr_func.led_count == 1);  /* one operator (= assign) */
        DUK_DDD(DUK_DDDPRINT("assignment: nud_count=%ld, led_count=%ld, toplevel_assign=%ld",
                             (long) comp_ctx->curr_func.nud_count,
                             (long) comp_ctx->curr_func.led_count,
                             (long) toplevel_assign));
 
        if (left->t == DUK_IVAL_VAR) {
            duk_hstring *h_varname;
            duk_reg_t reg_varbind;
            duk_regconst_t rc_varname;
 
            DUK_ASSERT(left->x1.t == DUK_ISPEC_VALUE);  /* LHS is already side effect free */
 
            h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
            DUK_ASSERT(h_varname != NULL);
            if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
                /* E5 Section 11.13.1 (and others for other assignments), step 4. */
                goto syntax_error_lvalue;
            }
            duk_dup(ctx, left->x1.valstack_idx);
            (void) duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname);
 
            if (args_op == DUK_OP_NONE) {
                duk__expr(comp_ctx, res, args_rbp /*rbp_flags*/);
                if (toplevel_assign) {
                    /* Any 'res' will do. */
                    DUK_DDD(DUK_DDDPRINT("plain assignment, toplevel assign, use as is"));
                } else {
                    /* 'res' must be a plain ivalue, and not register-bound variable. */
                    DUK_DDD(DUK_DDDPRINT("plain assignment, not toplevel assign, ensure not a reg-bound identifier"));
                    if (res->t != DUK_IVAL_PLAIN || (res->x1.t == DUK_ISPEC_REGCONST &&
                                                     (res->x1.regconst & DUK__CONST_MARKER) == 0 &&
                                                     !DUK__ISTEMP(comp_ctx, res->x1.regconst))) {
                        duk__ivalue_totempconst(comp_ctx, res);
                    }
                }
            } else {
                /* For X <op>= Y we need to evaluate the pre-op
                 * value of X before evaluating the RHS: the RHS
                 * can change X, but when we do <op> we must use
                 * the pre-op value.
                 */
                duk_reg_t reg_temp;
 
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
 
                if (reg_varbind >= 0) {
                    duk_reg_t reg_res;
                    duk_reg_t reg_src;
                    duk_int_t pc_temp_load;
                    duk_int_t pc_before_rhs;
                    duk_int_t pc_after_rhs;
 
                    if (toplevel_assign) {
                        /* 'reg_varbind' is the operation result and can also
                         * become the expression value for top level assignments
                         * such as: "var x; x += y;".
                         */
                        DUK_DD(DUK_DDPRINT("<op>= expression is top level, write directly to reg_varbind"));
                        reg_res = reg_varbind;
                    } else {
                        /* Not safe to use 'reg_varbind' as assignment expression
                         * value, so go through a temp.
                         */
                        DUK_DD(DUK_DDPRINT("<op>= expression is not top level, write to reg_temp"));
                        reg_res = reg_temp;  /* reg_res should be smallest possible */
                        reg_temp = DUK__ALLOCTEMP(comp_ctx);
                    }
 
                    /* Try to optimize X <op>= Y for reg-bound
                     * variables.  Detect side-effect free RHS
                     * narrowly by seeing whether it emits code.
                     * If not, rewind the code emitter and overwrite
                     * the unnecessary temp reg load.
                     */
 
                    pc_temp_load = duk__get_current_pc(comp_ctx);
                    duk__emit_a_bc(comp_ctx,
                                   DUK_OP_LDREG,
                                   (duk_regconst_t) reg_temp,
                                   reg_varbind);
 
                    pc_before_rhs = duk__get_current_pc(comp_ctx);
                    duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
                    DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
                    pc_after_rhs = duk__get_current_pc(comp_ctx);
 
                    DUK_DD(DUK_DDPRINT("pc_temp_load=%ld, pc_before_rhs=%ld, pc_after_rhs=%ld",
                                       (long) pc_temp_load, (long) pc_before_rhs,
                                       (long) pc_after_rhs));
 
                    if (pc_after_rhs == pc_before_rhs) {
                        /* Note: if the reg_temp load generated shuffling
                         * instructions, we may need to rewind more than
                         * one instruction, so use explicit PC computation.
                         */
                        DUK_DD(DUK_DDPRINT("rhs is side effect free, rewind and avoid unnecessary temp for reg-based <op>="));
                        DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, (pc_temp_load - pc_before_rhs) * sizeof(duk_compiler_instr));
                        reg_src = reg_varbind;
                    } else {
                        DUK_DD(DUK_DDPRINT("rhs evaluation emitted code, not sure if rhs is side effect free; use temp reg for LHS"));
                        reg_src = reg_temp;
                    }
 
                    duk__emit_a_b_c(comp_ctx,
                                    args_op,
                                    (duk_regconst_t) reg_res,
                                    (duk_regconst_t) reg_src,
                                    res->x1.regconst);
 
                    res->x1.regconst = (duk_regconst_t) reg_res;
 
                    /* Ensure compact use of temps. */
                    if (DUK__ISTEMP(comp_ctx, reg_res)) {
                        DUK__SETTEMP(comp_ctx, reg_res + 1);
                    }
                } else {
                    /* When LHS is not register bound, always go through a
                     * temporary.  No optimization for top level assignment.
                     */
 
                    duk__emit_a_bc(comp_ctx,
                                   DUK_OP_GETVAR,
                                   (duk_regconst_t) reg_temp,
                                   rc_varname);
 
                    duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
                    DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
 
                    duk__emit_a_b_c(comp_ctx,
                                    args_op,
                                    (duk_regconst_t) reg_temp,
                                    (duk_regconst_t) reg_temp,
                                    res->x1.regconst);
                    res->x1.regconst = (duk_regconst_t) reg_temp;
                }
 
                DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
            }
 
            /* At this point 'res' holds the potential expression value.
             * It can be basically any ivalue here, including a reg-bound
             * identifier (if code above deems it safe) or a unary/binary
             * operation.  Operations must be resolved to a side effect free
             * plain value, and the side effects must happen exactly once.
             */
 
            if (reg_varbind >= 0) {
                if (res->t != DUK_IVAL_PLAIN) {
                    /* Resolve 'res' directly into the LHS binding, and use
                     * that as the expression value if safe.  If not safe,
                     * resolve to a temp/const and copy to LHS.
                     */
                    if (toplevel_assign) {
                        duk__ivalue_toforcedreg(comp_ctx, res, (duk_int_t) reg_varbind);
                    } else {
                        duk__ivalue_totempconst(comp_ctx, res);
                        duk__copy_ivalue(comp_ctx, res, left);  /* use 'left' as a temp */
                        duk__ivalue_toforcedreg(comp_ctx, left, (duk_int_t) reg_varbind);
                    }
                } else {
                    /* Use 'res' as the expression value (it's side effect
                     * free and may be a plain value, a register, or a
                     * constant) and write it to the LHS binding too.
                     */
                    duk__copy_ivalue(comp_ctx, res, left);  /* use 'left' as a temp */
                    duk__ivalue_toforcedreg(comp_ctx, left, (duk_int_t) reg_varbind);
                }
            } else {
                /* Only a reg fits into 'A' so coerce 'res' into a register
                 * for PUTVAR.
                 *
                 * XXX: here the current A/B/C split is suboptimal: we could
                 * just use 9 bits for reg_res (and support constants) and 17
                 * instead of 18 bits for the varname const index.
                 */
 
                duk__ivalue_toreg(comp_ctx, res);
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
                               res->x1.regconst,
                               rc_varname);
            }
 
            /* 'res' contains expression value */
        } else if (left->t == DUK_IVAL_PROP) {
            /* E5 Section 11.13.1 (and others) step 4 never matches for prop writes -> no check */
            duk_reg_t reg_obj;
            duk_regconst_t rc_key;
            duk_regconst_t rc_res;
            duk_reg_t reg_temp;
 
            /* Property access expressions ('a[b]') are critical to correct
             * LHS evaluation ordering, see test-dev-assign-eval-order*.js.
             * We must make sure that the LHS target slot (base object and
             * key) don't change during RHS evaluation.  The only concrete
             * problem is a register reference to a variable-bound register
             * (i.e., non-temp).  Require temp regs for both key and base.
             *
             * Don't allow a constant for the object (even for a number
             * etc), as it goes into the 'A' field of the opcode.
             */
 
            reg_obj = duk__ispec_toregconst_raw(comp_ctx,
                                                &left->x1,
                                                -1 /*forced_reg*/,
                                                DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
 
            rc_key = duk__ispec_toregconst_raw(comp_ctx,
                                               &left->x2,
                                               -1 /*forced_reg*/,
                                               DUK__IVAL_FLAG_REQUIRE_TEMP | DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
 
            /* Evaluate RHS only when LHS is safe. */
 
            if (args_op == DUK_OP_NONE) {
                duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
                DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
                rc_res = res->x1.regconst;
            } else {
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_a_b_c(comp_ctx,
                                DUK_OP_GETPROP,
                                (duk_regconst_t) reg_temp,
                                (duk_regconst_t) reg_obj,
                                rc_key);
 
                duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
                DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
 
                duk__emit_a_b_c(comp_ctx,
                                args_op,
                                (duk_regconst_t) reg_temp,
                                (duk_regconst_t) reg_temp,
                                res->x1.regconst);
                rc_res = (duk_regconst_t) reg_temp;
            }
 
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_PUTPROP | DUK__EMIT_FLAG_A_IS_SOURCE,
                            (duk_regconst_t) reg_obj,
                            rc_key,
                            rc_res);
 
            res->t = DUK_IVAL_PLAIN;
            res->x1.t = DUK_ISPEC_REGCONST;
            res->x1.regconst = rc_res;
        } else {
            /* No support for lvalues returned from new or function call expressions.
             * However, these must NOT cause compile-time SyntaxErrors, but run-time
             * ReferenceErrors.  Both left and right sides of the assignment must be
             * evaluated before throwing a ReferenceError.  For instance:
             *
             *     f() = g();
             *
             * must result in f() being evaluated, then g() being evaluated, and
             * finally, a ReferenceError being thrown.  See E5 Section 11.13.1.
             */
 
            duk_regconst_t rc_res;
 
            /* First evaluate LHS fully to ensure all side effects are out. */
            duk__ivalue_toplain_ignore(comp_ctx, left);
 
            /* Then evaluate RHS fully (its value becomes the expression value too).
             * Technically we'd need the side effect safety check here too, but because
             * we always throw using INVLHS the result doesn't matter.
             */
            rc_res = duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
 
            duk__emit_extraop_only(comp_ctx,
                                   DUK_EXTRAOP_INVLHS);
 
            res->t = DUK_IVAL_PLAIN;
            res->x1.t = DUK_ISPEC_REGCONST;
            res->x1.regconst = rc_res;
        }
 
        return;
    }
 
 postincdec:
    {
        /*
         *  Post-increment/decrement will return the original value as its
         *  result value.  However, even that value will be coerced using
         *  ToNumber() which is quite awkward.  Specific bytecode opcodes
         *  are used to handle these semantics.
         *
         *  Note that post increment/decrement has a "no LineTerminator here"
         *  restriction.  This is handled by duk__expr_lbp(), which forcibly terminates
         *  the previous expression if a LineTerminator occurs before '++'/'--'.
         */
 
        duk_reg_t reg_res;
        duk_small_uint_t args_op = args >> 8;
 
        /* Specific assumptions for opcode numbering. */
        DUK_ASSERT(DUK_OP_POSTINCR + 4 == DUK_OP_POSTINCV);
        DUK_ASSERT(DUK_OP_POSTDECR + 4 == DUK_OP_POSTDECV);
        DUK_ASSERT(DUK_OP_POSTINCR + 8 == DUK_OP_POSTINCP);
        DUK_ASSERT(DUK_OP_POSTDECR + 8 == DUK_OP_POSTDECP);
 
        reg_res = DUK__ALLOCTEMP(comp_ctx);
 
        if (left->t == DUK_IVAL_VAR) {
            duk_hstring *h_varname;
            duk_reg_t reg_varbind;
            duk_regconst_t rc_varname;
 
            h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
            DUK_ASSERT(h_varname != NULL);
 
            if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
                goto syntax_error;
            }
 
            duk_dup(ctx, left->x1.valstack_idx);
            if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
                duk__emit_a_bc(comp_ctx,
                               args_op,  /* e.g. DUK_OP_POSTINCR */
                               (duk_regconst_t) reg_res,
                               (duk_regconst_t) reg_varbind);
            } else {
                duk__emit_a_bc(comp_ctx,
                               args_op + 4,  /* e.g. DUK_OP_POSTINCV */
                               (duk_regconst_t) reg_res,
                               rc_varname);
            }
 
            DUK_DDD(DUK_DDDPRINT("postincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
                                 (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
        } else if (left->t == DUK_IVAL_PROP) {
            duk_reg_t reg_obj;  /* allocate to reg only (not const) */
            duk_regconst_t rc_key;
 
            reg_obj = duk__ispec_toregconst_raw(comp_ctx, &left->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
            rc_key = duk__ispec_toregconst_raw(comp_ctx, &left->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
            duk__emit_a_b_c(comp_ctx,
                            args_op + 8,  /* e.g. DUK_OP_POSTINCP */
                            (duk_regconst_t) reg_res,
                            (duk_regconst_t) reg_obj,
                            rc_key);
        } else {
            /* Technically return value is not needed because INVLHS will
             * unconditially throw a ReferenceError.  Coercion is necessary
             * for proper semantics (consider ToNumber() called for an object).
             * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber().
             */
            duk__ivalue_toforcedreg(comp_ctx, left, reg_res);
            duk__emit_extraop_bc(comp_ctx,
                                 DUK_EXTRAOP_UNP,
                                 reg_res);  /* for side effects, result ignored */
            duk__emit_extraop_only(comp_ctx,
                                   DUK_EXTRAOP_INVLHS);

References DUK_ISPEC_VALUE, DUK_IVAL_PLAIN, duk_replace(), duk_ispec::t, duk_ivalue::t, duk_ispec::valstack_idx, and duk_ivalue::x1.

◆ duk__expr_nud()

DUK_LOCAL_DECL void duk__expr_nud	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 60959 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    /* empty expressions can be detected conveniently with nud/led counts */
    return (comp_ctx->curr_func.nud_count == 0) &&
           (comp_ctx->curr_func.led_count == 0);
}
 
DUK_LOCAL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_token *tk;
    duk_reg_t temp_at_entry;
    duk_small_int_t tok;
    duk_uint32_t args;  /* temp variable to pass constants and flags to shared code */
 
    /*
     *  ctx->prev_token     token to process with duk__expr_nud()
     *  ctx->curr_token     updated by caller
     *
     *  Note: the token in the switch below has already been eaten.
     */
 
    temp_at_entry = DUK__GETTEMP(comp_ctx);
 
    comp_ctx->curr_func.nud_count++;
 
    tk = &comp_ctx->prev_token;
    tok = tk->t;
    res->t = DUK_IVAL_NONE;
 
    DUK_DDD(DUK_DDDPRINT("duk__expr_nud(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld",
                         (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level));
 
    switch (tok) {
 
    /* PRIMARY EXPRESSIONS */
 
    case DUK_TOK_THIS: {
        duk_reg_t reg_temp;
        reg_temp = DUK__ALLOCTEMP(comp_ctx);
        duk__emit_extraop_bc(comp_ctx,
                             DUK_EXTRAOP_LDTHIS,
                             (duk_regconst_t) reg_temp);
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_temp;
        return;
    }
    case DUK_TOK_IDENTIFIER: {
        res->t = DUK_IVAL_VAR;
        res->x1.t = DUK_ISPEC_VALUE;
        duk_push_hstring(ctx, tk->str1);
        duk_replace(ctx, res->x1.valstack_idx);
        return;
    }
    case DUK_TOK_NULL: {
        duk_push_null(ctx);
        goto plain_value;
    }
    case DUK_TOK_TRUE: {
        duk_push_true(ctx);
        goto plain_value;
    }
    case DUK_TOK_FALSE: {
        duk_push_false(ctx);
        goto plain_value;
    }
    case DUK_TOK_NUMBER: {
        duk_push_number(ctx, tk->num);
        goto plain_value;
    }
    case DUK_TOK_STRING: {
        DUK_ASSERT(tk->str1 != NULL);
        duk_push_hstring(ctx, tk->str1);
        goto plain_value;
    }
    case DUK_TOK_REGEXP: {
#ifdef DUK_USE_REGEXP_SUPPORT
        duk_reg_t reg_temp;
        duk_regconst_t rc_re_bytecode;  /* const */
        duk_regconst_t rc_re_source;    /* const */
 
        DUK_ASSERT(tk->str1 != NULL);
        DUK_ASSERT(tk->str2 != NULL);
 
        DUK_DDD(DUK_DDDPRINT("emitting regexp op, str1=%!O, str2=%!O",
                             (duk_heaphdr *) tk->str1,
                             (duk_heaphdr *) tk->str2));
 
        reg_temp = DUK__ALLOCTEMP(comp_ctx);
        duk_push_hstring(ctx, tk->str1);
        duk_push_hstring(ctx, tk->str2);
 
        /* [ ... pattern flags ] */
 
        duk_regexp_compile(thr);
 
        /* [ ... escaped_source bytecode ] */
 
        rc_re_bytecode = duk__getconst(comp_ctx);
        rc_re_source = duk__getconst(comp_ctx);
 
        duk__emit_a_b_c(comp_ctx,
                        DUK_OP_REGEXP,
                        (duk_regconst_t) reg_temp /*a*/,
                        rc_re_bytecode /*b*/,
                        rc_re_source /*c*/);
 
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_temp;
        return;
#else  /* DUK_USE_REGEXP_SUPPORT */
        goto syntax_error;
#endif  /* DUK_USE_REGEXP_SUPPORT */
    }
    case DUK_TOK_LBRACKET: {
        DUK_DDD(DUK_DDDPRINT("parsing array literal"));
        duk__nud_array_literal(comp_ctx, res);
        return;
    }
    case DUK_TOK_LCURLY: {
        DUK_DDD(DUK_DDDPRINT("parsing object literal"));
        duk__nud_object_literal(comp_ctx, res);
        return;
    }
    case DUK_TOK_LPAREN: {
        duk_bool_t prev_allow_in;
 
        comp_ctx->curr_func.paren_level++;
        prev_allow_in = comp_ctx->curr_func.allow_in;
        comp_ctx->curr_func.allow_in = 1; /* reset 'allow_in' for parenthesized expression */
 
        duk__expr(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);  /* Expression, terminates at a ')' */
 
        duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
        comp_ctx->curr_func.allow_in = prev_allow_in;
        comp_ctx->curr_func.paren_level--;
        return;
    }
 
    /* MEMBER/NEW/CALL EXPRESSIONS */
 
    case DUK_TOK_NEW: {
        /*
         *  Parsing an expression starting with 'new' is tricky because
         *  there are multiple possible productions deriving from
         *  LeftHandSideExpression which begin with 'new'.
         *
         *  We currently resort to one-token lookahead to distinguish the
         *  cases.  Hopefully this is correct.  The binding power must be
         *  such that parsing ends at an LPAREN (CallExpression) but not at
         *  a PERIOD or LBRACKET (MemberExpression).
         *
         *  See doc/compiler.rst for discussion on the parsing approach,
         *  and testcases/test-dev-new.js for a bunch of documented tests.
         */
 
        duk_reg_t reg_target;
        duk_int_t nargs;
 
        DUK_DDD(DUK_DDDPRINT("begin parsing new expression"));
 
        reg_target = DUK__ALLOCTEMP(comp_ctx);
        duk__expr_toforcedreg(comp_ctx, res, DUK__BP_CALL /*rbp_flags*/, reg_target /*forced_reg*/);
        DUK__SETTEMP(comp_ctx, reg_target + 1);
 
        if (comp_ctx->curr_token.t == DUK_TOK_LPAREN) {
            /* 'new' MemberExpression Arguments */
            DUK_DDD(DUK_DDDPRINT("new expression has argument list"));
            duk__advance(comp_ctx);
            nargs = duk__parse_arguments(comp_ctx, res);  /* parse args starting from "next temp", reg_target + 1 */
            /* right paren eaten */
        } else {
            /* 'new' MemberExpression */
            DUK_DDD(DUK_DDDPRINT("new expression has no argument list"));
            nargs = 0;
        }
 
        /* Opcode slot C is used in a non-standard way, so shuffling
         * is not allowed.
         */
        duk__emit_a_b_c(comp_ctx,
                      DUK_OP_NEW | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
                      0 /*unused*/,
                      reg_target /*target*/,
                      nargs /*num_args*/);
 
        DUK_DDD(DUK_DDDPRINT("end parsing new expression"));
 
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_target;
        return;
    }
 
    /* FUNCTION EXPRESSIONS */
 
    case DUK_TOK_FUNCTION: {
        /* Function expression.  Note that any statement beginning with 'function'
         * is handled by the statement parser as a function declaration, or a
         * non-standard function expression/statement (or a SyntaxError).  We only
         * handle actual function expressions (occurring inside an expression) here.
         *
         * O(depth^2) parse count for inner functions is handled by recording a
         * lexer offset on the first compilation pass, so that the function can
         * be efficiently skipped on the second pass.  This is encapsulated into
         * duk__parse_func_like_fnum().
         */
 
        duk_reg_t reg_temp;
        duk_int_t fnum;
 
        reg_temp = DUK__ALLOCTEMP(comp_ctx);
 
        /* curr_token follows 'function' */
        fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 0 /*is_setget*/);
        DUK_DDD(DUK_DDDPRINT("parsed inner function -> fnum %ld", (long) fnum));
 
        duk__emit_a_bc(comp_ctx,
                       DUK_OP_CLOSURE,
                       (duk_regconst_t) reg_temp /*a*/,
                       (duk_regconst_t) fnum /*bc*/);
 
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_temp;
        return;
    }
 
    /* UNARY EXPRESSIONS */
 
    case DUK_TOK_DELETE: {
        /* Delete semantics are a bit tricky.  The description in E5 specification
         * is kind of confusing, because it distinguishes between resolvability of
         * a reference (which is only known at runtime) seemingly at compile time
         * (= SyntaxError throwing).
         */
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        if (res->t == DUK_IVAL_VAR) {
            /* not allowed in strict mode, regardless of whether resolves;
             * in non-strict mode DELVAR handles both non-resolving and
             * resolving cases (the specification description is a bit confusing).
             */
 
            duk_reg_t reg_temp;
            duk_reg_t reg_varbind;
            duk_regconst_t rc_varname;
 
            if (comp_ctx->curr_func.is_strict) {
                DUK_ERROR_SYNTAX(thr, DUK_STR_CANNOT_DELETE_IDENTIFIER);
            }
 
            DUK__SETTEMP(comp_ctx, temp_at_entry);
            reg_temp = DUK__ALLOCTEMP(comp_ctx);
 
            duk_dup(ctx, res->x1.valstack_idx);
            if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
                /* register bound variables are non-configurable -> always false */
                duk__emit_extraop_bc(comp_ctx,
                                     DUK_EXTRAOP_LDFALSE,
                                     (duk_regconst_t) reg_temp);
            } else {
                duk_dup(ctx, res->x1.valstack_idx);
                rc_varname = duk__getconst(comp_ctx);
                duk__emit_a_b(comp_ctx,
                              DUK_OP_DELVAR,
                              (duk_regconst_t) reg_temp,
                              (duk_regconst_t) rc_varname);
            }
            res->t = DUK_IVAL_PLAIN;
            res->x1.t = DUK_ISPEC_REGCONST;
            res->x1.regconst = (duk_regconst_t) reg_temp;
        } else if (res->t == DUK_IVAL_PROP) {
            duk_reg_t reg_temp;
            duk_reg_t reg_obj;
            duk_regconst_t rc_key;
 
            DUK__SETTEMP(comp_ctx, temp_at_entry);
            reg_temp = DUK__ALLOCTEMP(comp_ctx);
            reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
            rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_DELPROP,
                            (duk_regconst_t) reg_temp,
                            (duk_regconst_t) reg_obj,
                            rc_key);
 
            res->t = DUK_IVAL_PLAIN;
            res->x1.t = DUK_ISPEC_REGCONST;
            res->x1.regconst = (duk_regconst_t) reg_temp;
        } else {
            /* non-Reference deletion is always 'true', even in strict mode */
            duk_push_true(ctx);
            goto plain_value;
        }
        return;
    }
    case DUK_TOK_VOID: {
        duk__expr_toplain_ignore(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        duk_push_undefined(ctx);
        goto plain_value;
    }
    case DUK_TOK_TYPEOF: {
        /* 'typeof' must handle unresolvable references without throwing
         * a ReferenceError (E5 Section 11.4.3).  Register mapped values
         * will never be unresolvable so special handling is only required
         * when an identifier is a "slow path" one.
         */
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
 
        if (res->t == DUK_IVAL_VAR) {
            duk_reg_t reg_varbind;
            duk_regconst_t rc_varname;
            duk_reg_t reg_temp;
 
            duk_dup(ctx, res->x1.valstack_idx);
            if (!duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
                DUK_DDD(DUK_DDDPRINT("typeof for an identifier name which could not be resolved "
                                     "at compile time, need to use special run-time handling"));
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_extraop_b_c(comp_ctx,
                                      DUK_EXTRAOP_TYPEOFID | DUK__EMIT_FLAG_B_IS_TARGET,
                                      reg_temp,
                                      rc_varname);
                res->t = DUK_IVAL_PLAIN;
                res->x1.t = DUK_ISPEC_REGCONST;
                res->x1.regconst = (duk_regconst_t) reg_temp;
                return;
            }
        }
 
        args = (DUK_EXTRAOP_TYPEOF << 8) + 0;
        goto unary_extraop;
    }
    case DUK_TOK_INCREMENT: {
        args = (DUK_OP_PREINCR << 8) + 0;
        goto preincdec;
    }
    case DUK_TOK_DECREMENT: {
        args = (DUK_OP_PREDECR << 8) + 0;
        goto preincdec;
    }
    case DUK_TOK_ADD: {
        /* unary plus */
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE &&
            duk_is_number(ctx, res->x1.valstack_idx)) {
            /* unary plus of a number is identity */
            ;
            return;
        }
        args = (DUK_EXTRAOP_UNP << 8) + 0;
        goto unary_extraop;
    }
    case DUK_TOK_SUB: {
        /* unary minus */
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE &&
            duk_is_number(ctx, res->x1.valstack_idx)) {
            /* this optimization is important to handle negative literals
             * (which are not directly provided by the lexical grammar)
             */
            duk_tval *tv_num;
            duk_double_union du;
 
            tv_num = DUK_GET_TVAL_POSIDX(ctx, res->x1.valstack_idx);
            DUK_ASSERT(tv_num != NULL);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_num));
            du.d = DUK_TVAL_GET_NUMBER(tv_num);
            du.d = -du.d;
            DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
            DUK_TVAL_SET_NUMBER(tv_num, du.d);
            return;
        }
        args = (DUK_EXTRAOP_UNM << 8) + 0;
        goto unary_extraop;
    }
    case DUK_TOK_BNOT: {
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        args = (DUK_EXTRAOP_BNOT << 8) + 0;
        goto unary_extraop;
    }
    case DUK_TOK_LNOT: {
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE) {
            /* Very minimal inlining to handle common idioms '!0' and '!1',
             * and also boolean arguments like '!false' and '!true'.
             */
            duk_tval *tv_val;
 
            tv_val = DUK_GET_TVAL_POSIDX(ctx, res->x1.valstack_idx);
            DUK_ASSERT(tv_val != NULL);
            if (DUK_TVAL_IS_NUMBER(tv_val)) {
                duk_double_t d;
                d = DUK_TVAL_GET_NUMBER(tv_val);
                if (d == 0.0) {
                    /* Matches both +0 and -0 on purpose. */
                    DUK_DDD(DUK_DDDPRINT("inlined lnot: !0 -> true"));
                    DUK_TVAL_SET_BOOLEAN_TRUE(tv_val);
                    return;
                } else if (d == 1.0) {
                    DUK_DDD(DUK_DDDPRINT("inlined lnot: !1 -> false"));
                    DUK_TVAL_SET_BOOLEAN_FALSE(tv_val);
                    return;
                }
            } else if (DUK_TVAL_IS_BOOLEAN(tv_val)) {
                duk_small_int_t v;
                v = DUK_TVAL_GET_BOOLEAN(tv_val);
                DUK_DDD(DUK_DDDPRINT("inlined lnot boolean: %ld", (long) v));
                DUK_ASSERT(v == 0 || v == 1);
                DUK_TVAL_SET_BOOLEAN(tv_val, v ^ 0x01);
                return;
            }
        }
        args = (DUK_EXTRAOP_LNOT << 8) + 0;
        goto unary_extraop;
    }
 
    }  /* end switch */
 
    DUK_ERROR_SYNTAX(thr, DUK_STR_PARSE_ERROR);
    return;
 
 unary_extraop:
    {
        /* Note: must coerce to a (writable) temp register, so that e.g. "!x" where x
         * is a reg-mapped variable works correctly (does not mutate the variable register).
         */
 
        duk_reg_t reg_temp;
        reg_temp = duk__ivalue_toregconst_raw(comp_ctx, res, -1 /*forced_reg*/, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
        duk__emit_extraop_bc(comp_ctx,
                             (args >> 8),
                             (duk_regconst_t) reg_temp);
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;
        res->x1.regconst = (duk_regconst_t) reg_temp;
        return;
    }
 
 preincdec:
    {
        /* preincrement and predecrement */
        duk_reg_t reg_res;
        duk_small_uint_t args_op = args >> 8;
 
        /* Specific assumptions for opcode numbering. */
        DUK_ASSERT(DUK_OP_PREINCR + 4 == DUK_OP_PREINCV);
        DUK_ASSERT(DUK_OP_PREDECR + 4 == DUK_OP_PREDECV);
        DUK_ASSERT(DUK_OP_PREINCR + 8 == DUK_OP_PREINCP);
        DUK_ASSERT(DUK_OP_PREDECR + 8 == DUK_OP_PREDECP);
 
        reg_res = DUK__ALLOCTEMP(comp_ctx);
 
        duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
        if (res->t == DUK_IVAL_VAR) {
            duk_hstring *h_varname;
            duk_reg_t reg_varbind;
            duk_regconst_t rc_varname;
 
            h_varname = duk_get_hstring(ctx, res->x1.valstack_idx);
            DUK_ASSERT(h_varname != NULL);
 
            if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
                goto syntax_error;
            }
 
            duk_dup(ctx, res->x1.valstack_idx);
            if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
                duk__emit_a_bc(comp_ctx,
                               args_op,  /* e.g. DUK_OP_PREINCR */
                               (duk_regconst_t) reg_res,
                               (duk_regconst_t) reg_varbind);
            } else {
                duk__emit_a_bc(comp_ctx,
                                args_op + 4,  /* e.g. DUK_OP_PREINCV */
                                (duk_regconst_t) reg_res,
                                rc_varname);
            }
 
            DUK_DDD(DUK_DDDPRINT("preincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
                                 (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
        } else if (res->t == DUK_IVAL_PROP) {
            duk_reg_t reg_obj;  /* allocate to reg only (not const) */
            duk_regconst_t rc_key;
            reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
            rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
            duk__emit_a_b_c(comp_ctx,
                            args_op + 8,  /* e.g. DUK_OP_PREINCP */
                            (duk_regconst_t) reg_res,
                            (duk_regconst_t) reg_obj,
                            rc_key);
        } else {
            /* Technically return value is not needed because INVLHS will
             * unconditially throw a ReferenceError.  Coercion is necessary
             * for proper semantics (consider ToNumber() called for an object).
             * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber().
             */
 
            duk__ivalue_toforcedreg(comp_ctx, res, reg_res);
            duk__emit_extraop_bc(comp_ctx,
                                 DUK_EXTRAOP_UNP,
                                 reg_res);  /* for side effects, result ignored */
            duk__emit_extraop_only(comp_ctx,
                                   DUK_EXTRAOP_INVLHS);
        }
        res->t = DUK_IVAL_PLAIN;
        res->x1.t = DUK_ISPEC_REGCONST;

◆ duk__expr_toforcedreg()

DUK_LOCAL_DECL void duk__expr_toforcedreg	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags,
		duk_reg_t	forced_reg )

Definition at line 62581 of file duktape-1.8.0/src/duktape.c.

62585 {

References duk__expr().

◆ duk__expr_toplain()

DUK_LOCAL_DECL void duk__expr_toplain	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62599 of file duktape-1.8.0/src/duktape.c.

◆ duk__expr_toplain_ignore()

DUK_LOCAL_DECL void duk__expr_toplain_ignore	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62604 of file duktape-1.8.0/src/duktape.c.

                                                                                                                       {
    duk__expr(comp_ctx, res, rbp_flags);
    return duk__ivalue_toregconst(comp_ctx, res);
}

References duk__expr(), and duk__ivalue_toregconst().

◆ duk__expr_toregconst()

DUK_LOCAL_DECL duk_regconst_t duk__expr_toregconst	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62587 of file duktape-1.8.0/src/duktape.c.

◆ duk__exprtop()

DUK_LOCAL_DECL void duk__exprtop	(	duk_compiler_ctx *	ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62542 of file duktape-1.8.0/src/duktape.c.

                                          {
        duk__advance(comp_ctx);
        duk__expr_led(comp_ctx, res, tmp);
        duk__copy_ivalue(comp_ctx, tmp, res);  /* tmp -> res */
    }
 
 cleanup:
    /* final result is already in 'res' */
 
    duk_pop_2(ctx);
 
    DUK__RECURSION_DECREASE(comp_ctx, thr);
}
 
DUK_LOCAL void duk__exprtop(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {

Referenced by duk__parse_var_decl().

◆ duk__exprtop_toforcedreg()

DUK_LOCAL_DECL void duk__exprtop_toforcedreg	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags,
		duk_reg_t	forced_reg )

Definition at line 62621 of file duktape-1.8.0/src/duktape.c.

                                                                                                                 {
    duk__expr(comp_ctx, res, rbp_flags);
    duk__ivalue_toplain_ignore(comp_ctx, res);
}
 

References duk__expr(), and duk__ivalue_toplain_ignore().

◆ duk__exprtop_toreg()

DUK_LOCAL_DECL duk_reg_t duk__exprtop_toreg	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62609 of file duktape-1.8.0/src/duktape.c.

                                                                                                                        {
    duk__expr(comp_ctx, res, rbp_flags);
    return duk__ivalue_totempconst(comp_ctx, res);

References duk__expr(), and duk__ivalue_totempconst().

Referenced by duk__parse_try_stmt().

◆ duk__exprtop_toregconst()

DUK_LOCAL_DECL duk_regconst_t duk__exprtop_toregconst	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	rbp_flags )

Definition at line 62627 of file duktape-1.8.0/src/duktape.c.

◆ duk__fabs()

DUK_LOCAL double duk__fabs ( double x )

Definition at line 32735 of file duktape-1.8.0/src/duktape.c.

◆ duk__fill_lexer_buffer()

DUK_LOCAL void duk__fill_lexer_buffer	(	duk_lexer_ctx *	lex_ctx,
		duk_small_uint_t	start_offset_bytes )

Definition at line 73493 of file duktape-1.8.0/src/duktape.c.

               :
 *
 *    * Reject other invalid Unicode sequences (see Wikipedia entry for examples)
 *      in strict UTF-8 mode.
 *
 *    * Size optimize.  An attempt to use a 16-byte lookup table for the first
 *      byte resulted in a code increase though.
 *
 *    * Is checking against maximum 0x10ffff really useful?  4-byte encoding
 *      imposes a certain limit anyway.
 *
 *    * Support chunked streaming of source code.  Can be implemented either
 *      by streaming chunks of bytes or chunks of codepoints.
 */
 
#if defined(DUK_USE_LEXER_SLIDING_WINDOW)
DUK_LOCAL void duk__fill_lexer_buffer(duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes) {
    duk_lexer_codepoint *cp, *cp_end;
    duk_ucodepoint_t x;
    duk_small_uint_t contlen;
    const duk_uint8_t *p, *p_end;
#if defined(DUK_USE_STRICT_UTF8_SOURCE)
    duk_ucodepoint_t mincp;
#endif
    duk_int_t input_line;
 
    /* Use temporaries and update lex_ctx only when finished. */
    input_line = lex_ctx->input_line;
    p = lex_ctx->input + lex_ctx->input_offset;
    p_end = lex_ctx->input + lex_ctx->input_length;
 
    cp = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->buffer + start_offset_bytes);
    cp_end = lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE;
 
    for (; cp != cp_end; cp++) {
        cp->offset = (duk_size_t) (p - lex_ctx->input);
        cp->line = input_line;
 
        /* XXX: potential issue with signed pointers, p_end < p. */
        if (DUK_UNLIKELY(p >= p_end)) {
            /* If input_offset were assigned a negative value, it would
             * result in a large positive value.  Most likely it would be
             * larger than input_length and be caught here.  In any case
             * no memory unsafe behavior would happen.
             */
            cp->codepoint = -1;
            continue;
        }
 
        x = (duk_ucodepoint_t) (*p++);
 
        /* Fast path. */
 
        if (DUK_LIKELY(x < 0x80UL)) {
            DUK_ASSERT(x != 0x2028UL && x != 0x2029UL);  /* not LS/PS */
            if (DUK_UNLIKELY(x <= 0x000dUL)) {
                if ((x == 0x000aUL) ||
                    ((x == 0x000dUL) && (p >= p_end || *p != 0x000aUL))) {
                    /* lookup for 0x000a above assumes shortest encoding now */
 
                    /* E5 Section 7.3, treat the following as newlines:
                     *   LF
                     *   CR [not followed by LF]
                     *   LS
                     *   PS
                     *
                     * For CR LF, CR is ignored if it is followed by LF, and the LF will bump
                     * the line number.
                     */
                    input_line++;
                }
            }
 
            cp->codepoint = (duk_codepoint_t) x;
            continue;
        }
 
        /* Slow path. */
 
        if (x < 0xc0UL) {
            /* 10xx xxxx -> invalid */
            goto error_encoding;
        } else if (x < 0xe0UL) {
            /* 110x xxxx   10xx xxxx  */
            contlen = 1;
#if defined(DUK_USE_STRICT_UTF8_SOURCE)
            mincp = 0x80UL;
#endif
            x = x & 0x1fUL;
        } else if (x < 0xf0UL) {
            /* 1110 xxxx   10xx xxxx   10xx xxxx */
            contlen = 2;
#if defined(DUK_USE_STRICT_UTF8_SOURCE)
            mincp = 0x800UL;
#endif
            x = x & 0x0fUL;
        } else if (x < 0xf8UL) {
            /* 1111 0xxx   10xx xxxx   10xx xxxx   10xx xxxx */
            contlen = 3;
#if defined(DUK_USE_STRICT_UTF8_SOURCE)
            mincp = 0x10000UL;
#endif
            x = x & 0x07UL;
        } else {
            /* no point in supporting encodings of 5 or more bytes */
            goto error_encoding;
        }
 
        DUK_ASSERT(p_end >= p);
        if ((duk_size_t) contlen > (duk_size_t) (p_end - p)) {
            goto error_clipped;
        }
 
        while (contlen > 0) {
            duk_small_uint_t y;
            y = *p++;
            if ((y & 0xc0U) != 0x80U) {
                /* check that byte has the form 10xx xxxx */
                goto error_encoding;
            }
            x = x << 6;
            x += y & 0x3fUL;
            contlen--;
        }
 
        /* check final character validity */
 
        if (x > 0x10ffffUL) {
            goto error_encoding;
        }
#if defined(DUK_USE_STRICT_UTF8_SOURCE)
        if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) {
            goto error_encoding;
        }
#endif
 
        DUK_ASSERT(x != 0x000aUL && x != 0x000dUL);
        if ((x == 0x2028UL) || (x == 0x2029UL)) {

References duk_lexer_ctx::buffer, duk_lexer_codepoint::codepoint, DUK_ASSERT, DUK_LEXER_BUFFER_SIZE, DUK_LIKELY, DUK_UNLIKELY, duk_lexer_ctx::input, duk_lexer_ctx::input_length, duk_lexer_ctx::input_line, duk_lexer_ctx::input_offset, duk_lexer_codepoint::line, and duk_lexer_codepoint::offset.

Referenced by duk__init_lexer_window().

◆ duk__finalize_helper()

DUK_LOCAL duk_ret_t duk__finalize_helper ( duk_context * ctx )

Definition at line 47027 of file duktape-1.8.0/src/duktape.c.

         :
 *
 *    - The thread used for calling the finalizer is the same as the
 *      'thr' argument.  This may need to change later.
 *
 *    - The finalizer thread 'top' assertions are there because it is
 *      critical that strict stack policy is observed (i.e. no cruft
 *      left on the finalizer stack).
 */
 
/* include removed: duk_internal.h */
 
DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx) {
    duk_hthread *thr;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
 
    DUK_DDD(DUK_DDDPRINT("protected finalization helper running"));
 
    /* [... obj] */
 
    /* XXX: Finalizer lookup should traverse the prototype chain (to allow
     * inherited finalizers) but should not invoke accessors or proxy object
     * behavior.  At the moment this lookup will invoke proxy behavior, so
     * caller must ensure that this function is not called if the target is
     * a Proxy.
     */
 

References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_get_prop_stridx(), DUK_STRIDX_INT_FINALIZER, and NULL.

◆ duk__finalize_refcounts()

DUK_LOCAL void duk__finalize_refcounts ( duk_heap * heap )

Definition at line 42620 of file duktape-1.8.0/src/duktape.c.

                                                       {
    duk_hthread *thr;
    duk_heaphdr *hdr;
 
    thr = duk__get_temp_hthread(heap);
    DUK_ASSERT(thr != NULL);
 
    DUK_DD(DUK_DDPRINT("duk__finalize_refcounts: heap=%p, hthread=%p",
                       (void *) heap, (void *) thr));
 
    hdr = heap->heap_allocated;
    while (hdr) {
        if (!DUK_HEAPHDR_HAS_REACHABLE(hdr)) {

◆ duk__find_matching_string_probe()

DUK_LOCAL duk_hstring * duk__find_matching_string_probe	(	duk_heap *	heap,
		duk_hstring **	entries,
		duk_uint32_t	size,
		const duk_uint8_t *	str,
		duk_uint32_t	blen,
		duk_uint32_t	strhash )

Definition at line 45559 of file duktape-1.8.0/src/duktape.c.

                                         : %ld", (long) i));
        i = (i + step) % size;
 
        /* looping should never happen */
        DUK_ASSERT(i != DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size));
    }
}
 
#if defined(DUK_USE_HEAPPTR16)
DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
#else
DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
#endif
    duk_uint32_t i;
    duk_uint32_t step;
 
    DUK_ASSERT(size > 0);
 
    i = DUK__HASH_INITIAL(strhash, size);
    step = DUK__HASH_PROBE_STEP(strhash);
    for (;;) {
        duk_hstring *e;
#if defined(DUK_USE_HEAPPTR16)
        e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, entries16[i]);
#else
        e = entries[i];
#endif
 
        if (!e) {
            return NULL;

◆ duk__floor()

DUK_LOCAL double duk__floor ( double x )

Definition at line 32756 of file duktape-1.8.0/src/duktape.c.

32758 {

◆ duk__fmax_fixed()

DUK_LOCAL double duk__fmax_fixed	(	double	x,
		double	y )

Definition at line 32607 of file duktape-1.8.0/src/duktape.c.

                          {
        /* XXX: what's the safest way of creating a negative zero? */
        if (DUK_SIGNBIT(x) != 0 || DUK_SIGNBIT(y) != 0) {
            return -0.0;
        } else {
            return +0.0;
        }
    }
#ifdef DUK_USE_MATH_FMIN
    return DUK_FMIN(x, y);
#else
    return (x < y ? x : y);
#endif
}
 

References DUK_SIGNBIT.

◆ duk__fmin_fixed()

DUK_LOCAL double duk__fmin_fixed	(	double	x,
		double	y )

Definition at line 32588 of file duktape-1.8.0/src/duktape.c.

                            {
        t = duk_to_number(ctx, i);
        if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) {
            /* Note: not normalized, but duk_push_number() will normalize */
            res = (duk_double_t) DUK_DOUBLE_NAN;
        } else {
            res = (duk_double_t) min_max(res, (double) t);
        }
    }
 
    duk_push_number(ctx, res);
    return 1;
}
 
DUK_LOCAL double duk__fmin_fixed(double x, double y) {

References DUK_DOUBLE_NAN, DUK_FP_NAN, DUK_FPCLASSIFY, and duk_to_number().

◆ duk__format_parts_iso8601()

DUK_LOCAL void duk__format_parts_iso8601	(	duk_int_t *	parts,
		duk_int_t	tzoffset,
		duk_small_uint_t	flags,
		duk_uint8_t *	out_buf )

Definition at line 25566 of file duktape-1.8.0/src/duktape.c.

                                                                                                                      {
    duk_double_t d;
 
    /* [ ... this ] */
 
    d = duk_bi_date_get_timeval_from_dparts(dparts, flags);
    duk_push_number(ctx, d);  /* -> [ ... this timeval_new ] */
    duk_dup_top(ctx);         /* -> [ ... this timeval_new timeval_new ] */
    duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE);
 
    /* stack top: new time value, return 1 to allow tail calls */
    return 1;
}
 
/* 'out_buf' must be at least DUK_BI_DATE_ISO8601_BUFSIZE long. */
DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags, duk_uint8_t *out_buf) {
    char yearstr[8];   /* "-123456\0" */
    char tzstr[8];     /* "+11:22\0" */
    char sep = (flags & DUK_DATE_FLAG_SEP_T) ? DUK_ASC_UC_T : DUK_ASC_SPACE;
 
    DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12);
    DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31);
    DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= -999999 && parts[DUK_DATE_IDX_YEAR] <= 999999);
 
    /* Note: %06d for positive value, %07d for negative value to include
     * sign and 6 digits.
     */
    DUK_SNPRINTF(yearstr,
                 sizeof(yearstr),
                 (parts[DUK_DATE_IDX_YEAR] >= 0 && parts[DUK_DATE_IDX_YEAR] <= 9999) ? "%04ld" :
                        ((parts[DUK_DATE_IDX_YEAR] >= 0) ? "+%06ld" : "%07ld"),
                 (long) parts[DUK_DATE_IDX_YEAR]);
    yearstr[sizeof(yearstr) - 1] = (char) 0;
 
    if (flags & DUK_DATE_FLAG_LOCALTIME) {
        /* tzoffset seconds are dropped; 16 bits suffice for
         * time offset in minutes
         */
        if (tzoffset >= 0) {
            duk_small_int_t tmp = tzoffset / 60;
            DUK_SNPRINTF(tzstr, sizeof(tzstr), "+%02d:%02d", (int) (tmp / 60), (int) (tmp % 60));
        } else {
            duk_small_int_t tmp = -tzoffset / 60;
            DUK_SNPRINTF(tzstr, sizeof(tzstr), "-%02d:%02d", (int) (tmp / 60), (int) (tmp % 60));
        }
        tzstr[sizeof(tzstr) - 1] = (char) 0;
    } else {
        tzstr[0] = DUK_ASC_UC_Z;
        tzstr[1] = (char) 0;
    }
 
    /* Unlike year, the other parts fit into 16 bits so %d format
     * is portable.

References duk_bi_date_get_timeval_from_dparts(), duk_dup_top(), duk_push_number(), duk_put_prop_stridx(), and DUK_STRIDX_INT_VALUE.

◆ duk__free_allocated()

DUK_LOCAL void duk__free_allocated ( duk_heap * heap )

Definition at line 41131 of file duktape-1.8.0/src/duktape.c.

◆ duk__free_markandsweep_finalize_list()

DUK_LOCAL void duk__free_markandsweep_finalize_list ( duk_heap * heap )

Definition at line 41166 of file duktape-1.8.0/src/duktape.c.

                                                      {
    duk_heaphdr *curr;
    duk_heaphdr *next;
 
    curr = heap->refzero_list;
    while (curr) {
        DUK_DDD(DUK_DDDPRINT("FINALFREE (refzero_list): %!iO",
                             (duk_heaphdr *) curr));
        next = DUK_HEAPHDR_GET_NEXT(heap, curr);
        duk_heap_free_heaphdr_raw(heap, curr);
        curr = next;
    }

References DUK_DDD, DUK_DDDPRINT, duk_heap_free_heaphdr_raw(), DUK_HEAPHDR_GET_NEXT, next, and duk_heap::refzero_list.

◆ duk__free_refzero_list()

DUK_LOCAL void duk__free_refzero_list ( duk_heap * heap )

Definition at line 41150 of file duktape-1.8.0/src/duktape.c.

                 {
        /* We don't log or warn about freeing zero refcount objects
         * because they may happen with finalizer processing.
         */
 
        DUK_DDD(DUK_DDDPRINT("FINALFREE (allocated): %!iO",
                             (duk_heaphdr *) curr));
        next = DUK_HEAPHDR_GET_NEXT(heap, curr);
        duk_heap_free_heaphdr_raw(heap, curr);
        curr = next;

References DUK_DDD, DUK_DDDPRINT, duk_heap_free_heaphdr_raw(), DUK_HEAPHDR_GET_NEXT, and next.

◆ duk__free_run_finalizers()

DUK_LOCAL void duk__free_run_finalizers ( duk_heap * heap )

Definition at line 41186 of file duktape-1.8.0/src/duktape.c.

                 {
        DUK_DDD(DUK_DDDPRINT("FINALFREE (finalize_list): %!iO",
                             (duk_heaphdr *) curr));
        next = DUK_HEAPHDR_GET_NEXT(heap, curr);
        duk_heap_free_heaphdr_raw(heap, curr);
        curr = next;
    }
}
#endif
 
DUK_LOCAL void duk__free_stringtable(duk_heap *heap) {
    /* strings are only tracked by stringtable */
    duk_heap_free_strtab(heap);
}
 
DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) {
    duk_hthread *thr;
    duk_heaphdr *curr;
    duk_uint_t round_no;
    duk_size_t count_all;
    duk_size_t count_finalized;
    duk_size_t curr_limit;
 
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(heap->heap_thread != NULL);
 
#if defined(DUK_USE_REFERENCE_COUNTING)
    DUK_ASSERT(heap->refzero_list == NULL);  /* refzero not running -> must be empty */
#endif
#if defined(DUK_USE_MARK_AND_SWEEP)
    DUK_ASSERT(heap->finalize_list == NULL);  /* mark-and-sweep not running -> must be empty */
#endif
 
    /* XXX: here again finalizer thread is the heap_thread which needs
     * to be coordinated with finalizer thread fixes.
     */
    thr = heap->heap_thread;
    DUK_ASSERT(thr != NULL);
 
    /* Prevent mark-and-sweep for the pending finalizers, also prevents
     * refzero handling from moving objects away from the heap_allocated
     * list.  (The flag meaning is slightly abused here.)
     */
    DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap));
    DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap);
 
    curr_limit = 0;  /* suppress warning, not used */
    for (round_no = 0; ; round_no++) {
        curr = heap->heap_allocated;
        count_all = 0;
        count_finalized = 0;
        while (curr) {
            count_all++;
            if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) {
                /* Only objects in heap_allocated may have finalizers.  Check that
                 * the object itself has a _Finalizer property (own or inherited)
                 * so that we don't execute finalizers for e.g. Proxy objects.
                 */
                DUK_ASSERT(thr != NULL);
                DUK_ASSERT(curr != NULL);
 
                if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
                    if (!DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) curr)) {
                        DUK_ASSERT(DUK_HEAP_HAS_FINALIZER_NORESCUE(heap));  /* maps to finalizer 2nd argument */
                        duk_hobject_run_finalizer(thr, (duk_hobject *) curr);
                        count_finalized++;
                    }
                }
            }
            curr = DUK_HEAPHDR_GET_NEXT(heap, curr);
        }
 
        /* Each round of finalizer execution may spawn new finalizable objects
         * which is normal behavior for some applications.  Allow multiple
         * rounds of finalization, but use a shrinking limit based on the
         * first round to detect the case where a runaway finalizer creates
         * an unbounded amount of new finalizable objects.  Finalizer rescue
         * is not supported: the semantics are unclear because most of the
         * objects being finalized here are already reachable.  The finalizer
         * is given a boolean to indicate that rescue is not possible.
         *
         * See discussion in: https://github.com/svaarala/duktape/pull/473
         */
 
        if (round_no == 0) {
            /* Cannot wrap: each object is at least 8 bytes so count is
             * at most 1/8 of that.
             */
            curr_limit = count_all * 2;
        } else {
            curr_limit = (curr_limit * 3) / 4;   /* Decrease by 25% every round */

References DUK_DDD, DUK_DDDPRINT, duk_heap_free_heaphdr_raw(), DUK_HEAPHDR_GET_NEXT, and next.

◆ duk__free_stringtable()

DUK_LOCAL void duk__free_stringtable ( duk_heap * heap )

Definition at line 41181 of file duktape-1.8.0/src/duktape.c.

41183 {

41184 duk_heaphdr *curr;

References next.

◆ duk__generate_ranges()

DUK_LOCAL void duk__generate_ranges	(	void *	userdata,
		duk_codepoint_t	r1,
		duk_codepoint_t	r2,
		duk_bool_t	direct )

Definition at line 77838 of file duktape-1.8.0/src/duktape.c.

                                                            {] is
 *  continuous but [X-{] is not).  The current algorithm creates the
 *  canonicalized range(s) space efficiently at the cost of compile
 *  time execution time (see doc/regexp.rst for discussion).
 *
 *  Note that the ctx->nranges is a context-wide temporary value
 *  (this is OK because there cannot be multiple character classes
 *  being parsed simultaneously).
 */
 
DUK_LOCAL void duk__generate_ranges(void *userdata, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct) {
    duk_re_compiler_ctx *re_ctx = (duk_re_compiler_ctx *) userdata;
 
    DUK_DD(DUK_DDPRINT("duk__generate_ranges(): re_ctx=%p, range=[%ld,%ld] direct=%ld",
                       (void *) re_ctx, (long) r1, (long) r2, (long) direct));
 
    if (!direct && (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE)) {
        /*
         *  Canonicalize a range, generating result ranges as necessary.
         *  Needs to exhaustively scan the entire range (at most 65536
         *  code points).  If 'direct' is set, caller (lexer) has ensured
         *  that the range is already canonicalization compatible (this
         *  is used to avoid unnecessary canonicalization of built-in
         *  ranges like \W, which are not affected by canonicalization).
         *
         *  NOTE: here is one place where we don't want to support chars
         *  outside the BMP, because the exhaustive search would be
         *  massively larger.
         */
 
        duk_codepoint_t i;
        duk_codepoint_t t;
        duk_codepoint_t r_start, r_end;
 
        r_start = duk_unicode_re_canonicalize_char(re_ctx->thr, r1);
        r_end = r_start;
        for (i = r1 + 1; i <= r2; i++) {
            t = duk_unicode_re_canonicalize_char(re_ctx->thr, i);
            if (t == r_end + 1) {
                r_end = t;
            } else {
                DUK_DD(DUK_DDPRINT("canonicalized, emit range: [%ld,%ld]", (long) r_start, (long) r_end));
                duk__append_u32(re_ctx, (duk_uint32_t) r_start);

References duk__append_u32(), DUK_DD, DUK_DDPRINT, DUK_RE_FLAG_IGNORE_CASE, duk_unicode_re_canonicalize_char(), duk_re_compiler_ctx::nranges, duk_re_compiler_ctx::re_flags, and duk_re_compiler_ctx::thr.

Referenced by duk__parse_disjunction().

◆ duk__get_buffer_data_helper()

DUK_LOCAL void * duk__get_buffer_data_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_bool_t	throw_flag )

Definition at line 16340 of file duktape-1.8.0/src/duktape.c.

                    {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "buffer", DUK_STR_NOT_BUFFER);
    }
    return NULL;
}
 
DUK_EXTERNAL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
    return duk__get_buffer_helper(ctx, index, out_size, 0 /*throw_flag*/);
}
 
DUK_EXTERNAL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
    return duk__get_buffer_helper(ctx, index, out_size, 1 /*throw_flag*/);
}
 
DUK_LOCAL void *duk__get_buffer_data_helper(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    if (out_size != NULL) {
        *out_size = 0;
    }
 
    tv = duk_get_tval(ctx, index);
    if (tv == NULL) {
        goto fail;
    }
 
    if (DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        if (out_size) {
            *out_size = DUK_HBUFFER_GET_SIZE(h);
        }
        return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);  /* may be NULL (but only if size is 0) */
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
            /* XXX: this is probably a useful shared helper: for a
             * duk_hbufferobject, get a validated buffer pointer/length.
             */
            duk_hbufferobject *h_bufobj = (duk_hbufferobject *) h;
            DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
            if (h_bufobj->buf != NULL &&
                DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) {
                duk_uint8_t *p;

◆ duk__get_buffer_helper()

DUK_LOCAL void * duk__get_buffer_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_bool_t	throw_flag )

Definition at line 16305 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
        duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(h != NULL);
        return (void *) h;
    }
 
    return NULL;
}
#endif
 
DUK_LOCAL void *duk__get_buffer_helper(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    if (out_size != NULL) {
        *out_size = 0;

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_GET_HEAPHDR, DUK_TVAL_IS_HEAP_ALLOCATED, index, and NULL.

◆ duk__get_bufobj_this()

DUK_LOCAL duk_hbufferobject * duk__get_bufobj_this ( duk_context * ctx )

Definition at line 21863 of file duktape-1.8.0/src/duktape.c.

21865 {

◆ duk__get_current_pc()

DUK_LOCAL_DECL duk_int_t duk__get_current_pc ( duk_compiler_ctx * comp_ctx )

Definition at line 58732 of file duktape-1.8.0/src/duktape.c.

◆ duk__get_default_h_size()

DUK_LOCAL duk_uint32_t duk__get_default_h_size ( duk_uint32_t e_size )

Definition at line 47596 of file duktape-1.8.0/src/duktape.c.

                                                                                       {
    DUK_UNREF(thr);
    return (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
            key == DUK_HTHREAD_STRING_NAME(thr));
}
 
/*
 *  Helpers for managing property storage size
 */
 
/* Get default hash part size for a certain entry part size. */

◆ duk__get_identifier_reference()

DUK_LOCAL duk_bool_t duk__get_identifier_reference	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_hstring *	name,
		duk_activation *	act,
		duk_bool_t	parents,
		duk__id_lookup_result *	out )

Definition at line 72380 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_tval *tv;
    duk_tval *tv_target;
    duk_tval tv_name;
    duk_uint_t sanity;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(env != NULL || act != NULL);
    DUK_ASSERT(name != NULL);
    DUK_ASSERT(out != NULL);
 
    DUK_ASSERT(!env || DUK_HOBJECT_IS_ENV(env));
    DUK_ASSERT(!env || !DUK_HOBJECT_HAS_ARRAY_PART(env));
 
    /*
     *  Conceptually, we look for the identifier binding by starting from
     *  'env' and following to chain of environment records (represented
     *  by the prototype chain).
     *
     *  If 'env' is NULL, the current activation does not yet have an
     *  allocated declarative environment record; this should be treated
     *  exactly as if the environment record existed but had no bindings
     *  other than register bindings.
     *
     *  Note: we assume that with the DUK_HOBJECT_FLAG_NEWENV cleared
     *  the environment will always be initialized immediately; hence
     *  a NULL 'env' should only happen with the flag set.  This is the
     *  case for: (1) function calls, and (2) strict, direct eval calls.
     */
 
    if (env == NULL && act != NULL) {
        duk_hobject *func;
 
        DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference: env is NULL, activation is non-NULL -> "
                             "delayed env case, look up activation regs first"));
 
        /*
         *  Try registers
         */
 
        if (duk__getid_activation_regs(thr, name, act, out)) {
            DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
                                 "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
                                 "(found from register bindings when env=NULL)",
                                 (duk_heaphdr *) name, (duk_tval *) out->value,
                                 (long) out->attrs, (duk_tval *) out->this_binding,
                                 (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
            return 1;
        }
 
        DUK_DDD(DUK_DDDPRINT("not found in current activation regs"));
 
        /*
         *  Not found in registers, proceed to the parent record.
         *  Here we need to determine what the parent would be,
         *  if 'env' was not NULL (i.e. same logic as when initializing
         *  the record).
         *
         *  Note that environment initialization is only deferred when
         *  DUK_HOBJECT_HAS_NEWENV is set, and this only happens for:
         *    - Function code
         *    - Strict eval code
         *
         *  We only need to check _Lexenv here; _Varenv exists only if it
         *  differs from _Lexenv (and thus _Lexenv will also be present).
         */
 
        if (!parents) {
            DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal "
                                 "(not found from register bindings when env=NULL)"));
            goto fail_not_found;
        }
 
        func = DUK_ACT_GET_FUNC(act);
        DUK_ASSERT(func != NULL);
        DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
 
        tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr));
        if (tv) {
            DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
            env = DUK_TVAL_GET_OBJECT(tv);
        } else {
            DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARENV(thr)) == NULL);
            env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
        }
 
        DUK_DDD(DUK_DDDPRINT("continue lookup from env: %!iO",
                             (duk_heaphdr *) env));
    }
 
    /*
     *  Prototype walking starting from 'env'.
     *
     *  ('act' is not needed anywhere here.)
     */
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    while (env != NULL) {
        duk_small_int_t cl;
        duk_int_t attrs;
 
        DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference, name=%!O, considering env=%p -> %!iO",
                             (duk_heaphdr *) name,
                             (void *) env,
                             (duk_heaphdr *) env));
 
        DUK_ASSERT(env != NULL);
        DUK_ASSERT(DUK_HOBJECT_IS_ENV(env));
        DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(env));
 
        cl = DUK_HOBJECT_GET_CLASS_NUMBER(env);
        DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV || cl == DUK_HOBJECT_CLASS_DECENV);
        if (cl == DUK_HOBJECT_CLASS_DECENV) {
            /*
             *  Declarative environment record.
             *
             *  Identifiers can never be stored in ancestors and are
             *  always plain values, so we can use an internal helper
             *  and access the value directly with an duk_tval ptr.
             *
             *  A closed environment is only indicated by it missing
             *  the "book-keeping" properties required for accessing
             *  register-bound variables.
             */
 
            if (DUK_HOBJECT_HAS_ENVRECCLOSED(env)) {
                /* already closed */
                goto skip_regs;
            }
 
            if (duk__getid_open_decl_env_regs(thr, name, env, out)) {
                DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
                                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
                                     "(declarative environment record, scope open, found in regs)",
                                     (duk_heaphdr *) name, (duk_tval *) out->value,
                                     (long) out->attrs, (duk_tval *) out->this_binding,
                                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
                return 1;
            }
         skip_regs:
 
            tv = duk_hobject_find_existing_entry_tval_ptr_and_attrs(thr->heap, env, name, &attrs);
            if (tv) {
                out->value = tv;
                out->attrs = attrs;
                out->this_binding = NULL;  /* implicit this value always undefined for
                                            * declarative environment records.
                                            */
                out->env = env;
                out->holder = env;
 
                DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
                                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
                                     "(declarative environment record, found in properties)",
                                     (duk_heaphdr *) name, (duk_tval *) out->value,
                                     (long) out->attrs, (duk_tval *) out->this_binding,
                                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
                return 1;
            }
        } else {
            /*
             *  Object environment record.
             *
             *  Binding (target) object is an external, uncontrolled object.
             *  Identifier may be bound in an ancestor property, and may be
             *  an accessor.  Target can also be a Proxy which we must support
             *  here.
             */
 
            /* XXX: we could save space by using _Target OR _This.  If _Target, assume
             * this binding is undefined.  If _This, assumes this binding is _This, and
             * target is also _This.  One property would then be enough.
             */
 
            duk_hobject *target;
            duk_bool_t found;
 
            DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV);
 
            tv_target = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr));
            DUK_ASSERT(tv_target != NULL);
            DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_target));
            target = DUK_TVAL_GET_OBJECT(tv_target);
            DUK_ASSERT(target != NULL);
 
            /* Target may be a Proxy or property may be an accessor, so we must
             * use an actual, Proxy-aware hasprop check here.
             *
             * out->holder is NOT set to the actual duk_hobject where the
             * property is found, but rather the object binding target object.
             */
 
            if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(target)) {
                DUK_ASSERT(name != NULL);
                DUK_TVAL_SET_STRING(&tv_name, name);
 
                found = duk_hobject_hasprop(thr, tv_target, &tv_name);
            } else {
                /* XXX: duk_hobject_hasprop() would be correct for
                 * non-Proxy objects too, but it is about ~20-25%
                 * slower at present so separate code paths for
                 * Proxy and non-Proxy now.
                 */
                found = duk_hobject_hasprop_raw(thr, target, name);
            }
 
            if (found) {
                out->value = NULL;  /* can't get value, may be accessor */
                out->attrs = 0;     /* irrelevant when out->value == NULL */
                tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THIS(thr));
                out->this_binding = tv;  /* may be NULL */
                out->env = env;
                out->holder = target;
 
                DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
                                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
                                     "(object environment record)",
                                     (duk_heaphdr *) name, (duk_tval *) out->value,
                                     (long) out->attrs, (duk_tval *) out->this_binding,
                                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
                return 1;
            }
        }
 
        if (!parents) {
            DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal "

Referenced by duk__declvar_helper(), duk__delvar_helper(), duk__getvar_helper(), and duk__putvar_helper().

◆ duk__get_idx_func()

DUK_LOCAL duk_idx_t duk__get_idx_func	(	duk_hthread *	thr,
		duk_idx_t	num_stack_args )

Definition at line 55906 of file duktape-1.8.0/src/duktape.c.

                                    {
            /* XXX: inefficient; block insert primitive */
            duk_push_undefined(ctx);
            duk_insert(ctx, idx_rcbase);
        }
    }
}
 
/*
 *  Misc shared helpers.
 */
 
/* Get valstack index for the func argument or throw if insane stack. */
DUK_LOCAL duk_idx_t duk__get_idx_func(duk_hthread *thr, duk_idx_t num_stack_args) {
    duk_size_t off_stack_top;
    duk_size_t off_stack_args;
    duk_size_t off_stack_all;

Referenced by duk_handle_call_protected().

◆ duk__get_instr_ptr()

DUK_LOCAL_DECL duk_compiler_instr * duk__get_instr_ptr	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	pc )

Definition at line 58738 of file duktape-1.8.0/src/duktape.c.

◆ duk__get_min_grow_a()

DUK_LOCAL duk_uint32_t duk__get_min_grow_a ( duk_uint32_t a_size )

Definition at line 47626 of file duktape-1.8.0/src/duktape.c.

                                                                {
    duk_uint32_t res;
 

◆ duk__get_min_grow_e()

DUK_LOCAL duk_uint32_t duk__get_min_grow_e ( duk_uint32_t e_size )

Definition at line 47615 of file duktape-1.8.0/src/duktape.c.

                                                {
        duk_uint32_t res;
 
        /* result: hash_prime(floor(1.2 * e_size)) */
        res = duk_util_get_hash_prime(e_size + e_size / DUK_HOBJECT_H_SIZE_DIVISOR);
 
        /* if fails, e_size will be zero = not an issue, except performance-wise */
        DUK_ASSERT(res == 0 || res > e_size);

References DUK_ASSERT, DUK_HOBJECT_H_SIZE_DIVISOR, and duk_util_get_hash_prime().

◆ duk__get_old_array_length()

DUK_LOCAL duk_uint32_t duk__get_old_array_length	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_propdesc *	temp_desc )

Definition at line 50286 of file duktape-1.8.0/src/duktape.c.

                                                                                                              {
    duk_bool_t rc;
    duk_tval *tv;
    duk_uint32_t res;
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /* This function is only called for objects with array exotic behavior.
     * The [[DefineOwnProperty]] algorithm for arrays requires that
     * 'length' can never have a value outside the unsigned 32-bit range,
     * attempt to write such a value is a RangeError.  Here we can thus
     * assert for this.  When Duktape internals go around the official
     * property write interface (doesn't happen often) this assumption is
     * easy to accidentally break, so such code must be written carefully.
     * See test-bi-array-push-maxlen.js.
     */
 
    rc = duk__get_own_propdesc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, temp_desc, 0 /*flags*/);  /* don't push value */
    DUK_UNREF(rc);
    DUK_ASSERT(rc != 0);  /* arrays MUST have a 'length' property */
    DUK_ASSERT(temp_desc->e_idx >= 0);
 
    tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, temp_desc->e_idx);
    DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));  /* array 'length' is always a number, as we coerce it */
    DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) >= 0.0);
    DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) <= (double) 0xffffffffUL);
    DUK_ASSERT((duk_double_t) (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv) == DUK_TVAL_GET_NUMBER(tv));

Referenced by duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ duk__get_own_propdesc_raw()

DUK_LOCAL_DECL duk_bool_t duk__get_own_propdesc_raw	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_uint32_t	arr_idx,
		duk_propdesc *	out_desc,
		duk_small_uint_t	flags )

Definition at line 49009 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                                           {
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv;
 
    DUK_DDD(DUK_DDDPRINT("duk_hobject_get_own_propdesc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, "
                         "arr_idx=%ld (obj -> %!O, key -> %!O)",
                         (void *) thr, (void *) obj, (void *) key, (void *) out_desc,
                         (long) flags, (long) arr_idx,
                         (duk_heaphdr *) obj, (duk_heaphdr *) key));
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(out_desc != NULL);
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /* XXX: optimize this filling behavior later */
    out_desc->flags = 0;
    out_desc->get = NULL;
    out_desc->set = NULL;
    out_desc->e_idx = -1;
    out_desc->h_idx = -1;
    out_desc->a_idx = -1;
 
    /*
     *  Array part
     */
 
    if (DUK_HOBJECT_HAS_ARRAY_PART(obj) && arr_idx != DUK__NO_ARRAY_INDEX) {
        if (arr_idx < DUK_HOBJECT_GET_ASIZE(obj)) {
            tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
            if (!DUK_TVAL_IS_UNUSED(tv)) {
                DUK_DDD(DUK_DDDPRINT("-> found in array part"));
                if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                    duk_push_tval(ctx, tv);
                }
                /* implicit attributes */
                out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE |
                                  DUK_PROPDESC_FLAG_CONFIGURABLE |
                                  DUK_PROPDESC_FLAG_ENUMERABLE;
                out_desc->a_idx = arr_idx;
                goto prop_found;
            }
        }
        /* assume array part is comprehensive (contains all array indexed elements
         * or none of them); hence no need to check the entries part here.
         */
        DUK_DDD(DUK_DDDPRINT("-> not found as a concrete property (has array part, "
                             "should be there if present)"));
        goto prop_not_found_concrete;
    }
 
    /*
     *  Entries part
     */
 
    duk_hobject_find_existing_entry(thr->heap, obj, key, &out_desc->e_idx, &out_desc->h_idx);
    if (out_desc->e_idx >= 0) {
        duk_int_t e_idx = out_desc->e_idx;
        out_desc->flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, e_idx);
        if (out_desc->flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            DUK_DDD(DUK_DDDPRINT("-> found accessor property in entry part"));
            out_desc->get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, e_idx);
            out_desc->set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, e_idx);
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                /* a dummy undefined value is pushed to make valstack
                 * behavior uniform for caller
                 */
                duk_push_undefined(ctx);
            }
        } else {
            DUK_DDD(DUK_DDDPRINT("-> found plain property in entry part"));
            tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                duk_push_tval(ctx, tv);
            }
        }
        goto prop_found;
    }
 
    /*
     *  Not found as a concrete property, check whether a String object
     *  virtual property matches.
     */
 
 prop_not_found_concrete:
 
    if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj)) {
        DUK_DDD(DUK_DDDPRINT("string object exotic property get for key: %!O, arr_idx: %ld",
                             (duk_heaphdr *) key, (long) arr_idx));
 
        if (arr_idx != DUK__NO_ARRAY_INDEX) {
            duk_hstring *h_val;
 
            DUK_DDD(DUK_DDDPRINT("array index exists"));
 
            h_val = duk_hobject_get_internal_value_string(thr->heap, obj);
            DUK_ASSERT(h_val);
            if (arr_idx < DUK_HSTRING_GET_CHARLEN(h_val)) {
                DUK_DDD(DUK_DDDPRINT("-> found, array index inside string"));
                if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                    duk_push_hstring(ctx, h_val);
                    duk_substring(ctx, -1, arr_idx, arr_idx + 1);  /* [str] -> [substr] */
                }
                out_desc->flags = DUK_PROPDESC_FLAG_ENUMERABLE |  /* E5 Section 15.5.5.2 */
                                  DUK_PROPDESC_FLAG_VIRTUAL;
 
                DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
                return 1;  /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */
            } else {
                /* index is above internal string length -> property is fully normal */
                DUK_DDD(DUK_DDDPRINT("array index outside string -> normal property"));
            }
        } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            duk_hstring *h_val;
 
            DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
 
            h_val = duk_hobject_get_internal_value_string(thr->heap, obj);
            DUK_ASSERT(h_val != NULL);
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h_val));
            }
            out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;  /* E5 Section 15.5.5.1 */
 
            DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
            return 1;  /* cannot be arguments exotic */
        }
    } else if (DUK_HOBJECT_IS_BUFFEROBJECT(obj)) {
        duk_hbufferobject *h_bufobj;
        duk_uint_t byte_off;
        duk_small_uint_t elem_size;
 
        h_bufobj = (duk_hbufferobject *) obj;
        DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
        DUK_DDD(DUK_DDDPRINT("bufferobject property get for key: %!O, arr_idx: %ld",
                             (duk_heaphdr *) key, (long) arr_idx));
 
        if (arr_idx != DUK__NO_ARRAY_INDEX) {
            DUK_DDD(DUK_DDDPRINT("array index exists"));
 
            /* Careful with wrapping: arr_idx upshift may easily wrap, whereas
             * length downshift won't.
             */
            if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) {
                byte_off = arr_idx << h_bufobj->shift;  /* no wrap assuming h_bufobj->length is valid */
                elem_size = 1 << h_bufobj->shift;
                if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                    duk_uint8_t *data;
 
                    if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) {
                        data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
                        duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size);
                    } else {
                        DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)"));
                        duk_push_uint(ctx, 0);
                    }
                }
                out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE |
                                  DUK_PROPDESC_FLAG_ENUMERABLE |
                                  DUK_PROPDESC_FLAG_VIRTUAL;
 
                DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
                return 1;  /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */
            } else {
                /* index is above internal buffer length -> property is fully normal */
                DUK_DDD(DUK_DDDPRINT("array index outside buffer -> normal property"));
            }
        } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
 
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                /* Length in elements: take into account shift, but
                 * intentionally don't check the underlying buffer here.
                 */
                duk_push_uint(ctx, h_bufobj->length >> h_bufobj->shift);
            }
            out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
 
            DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
            return 1;  /* cannot be arguments exotic */
        } else if (key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) {
            /* If neutered must return 0; length is zeroed during
             * neutering.
             */
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                duk_push_uint(ctx, h_bufobj->length);
            }
            out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
            return 1;  /* cannot be arguments exotic */
        } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) {
            /* If neutered must return 0; offset is zeroed during
             * neutering.
             */
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                duk_push_uint(ctx, h_bufobj->offset);
            }
            out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
            return 1;  /* cannot be arguments exotic */
        } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) {
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                duk_push_uint(ctx, 1 << h_bufobj->shift);
            }
            out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
            return 1;  /* cannot be arguments exotic */
        }
    } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj)) {
        DUK_DDD(DUK_DDDPRINT("duktape/c object exotic property get for key: %!O, arr_idx: %ld",
                             (duk_heaphdr *) key, (long) arr_idx));
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
 
            if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
                duk_int16_t func_nargs = ((duk_hnativefunction *) obj)->nargs;
                duk_push_int(ctx, func_nargs == DUK_HNATIVEFUNCTION_NARGS_VARARGS ? 0 : func_nargs);
            }
            out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;  /* not enumerable */
 
            DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
            return 1;  /* cannot be arguments exotic */
        }
    }
 
    /* Array properties have exotic behavior but they are concrete,
     * so no special handling here.
     *
     * Arguments exotic behavior (E5 Section 10.6, [[GetOwnProperty]]
     * is only relevant as a post-check implemented below; hence no
     * check here.
     */
 
    /*
     *  Not found as concrete or virtual
     */
 
    DUK_DDD(DUK_DDDPRINT("-> not found (virtual, entry part, or array part)"));
    return 0;
 
    /*
     *  Found
     *
     *  Arguments object has exotic post-processing, see E5 Section 10.6,
     *  description of [[GetOwnProperty]] variant for arguments.
     */
 
 prop_found:
    DUK_DDD(DUK_DDDPRINT("-> property found, checking for arguments exotic post-behavior"));
 
    /* Notes:
     *  - only numbered indices are relevant, so arr_idx fast reject is good
     *    (this is valid unless there are more than 4**32-1 arguments).
     *  - since variable lookup has no side effects, this can be skipped if
     *    DUK_GETDESC_FLAG_PUSH_VALUE is not set.
     */
 
    if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) &&
        arr_idx != DUK__NO_ARRAY_INDEX &&
        (flags & DUK_GETDESC_FLAG_PUSH_VALUE)) {
        duk_propdesc temp_desc;
 
        /* Magically bound variable cannot be an accessor.  However,
         * there may be an accessor property (or a plain property) in
         * place with magic behavior removed.  This happens e.g. when
         * a magic property is redefined with defineProperty().

References duk_propdesc::a_idx, duk_hbufferobject::buf, DUK__NO_ARRAY_INDEX, DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_ASSERT_VALSTACK_SPACE, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, DUK_GETDESC_FLAG_PUSH_VALUE, DUK_HBUFFER_GET_DATA_PTR, duk_hbufferobject_push_validated_read(), DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL, DUK_HNATIVEFUNCTION_NARGS_VARARGS, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_E_GET_FLAGS, DUK_HOBJECT_E_GET_VALUE_GETTER, DUK_HOBJECT_E_GET_VALUE_SETTER, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, duk_hobject_find_existing_entry(), DUK_HOBJECT_GET_ASIZE, duk_hobject_get_internal_value_string(), DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_DUKFUNC, DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ, DUK_HOBJECT_IS_BUFFEROBJECT, DUK_HSTRING_GET_CHARLEN, DUK_HTHREAD_STRING_BYTE_LENGTH, DUK_HTHREAD_STRING_BYTE_OFFSET, DUK_HTHREAD_STRING_BYTES_PER_ELEMENT, DUK_HTHREAD_STRING_LENGTH, DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_VIRTUAL, DUK_PROPDESC_FLAG_WRITABLE, duk_push_hstring(), duk_push_int(), duk_push_tval(), duk_push_uint(), duk_push_undefined(), duk_substring(), DUK_TVAL_IS_UNUSED, duk_propdesc::e_idx, duk_propdesc::flags, duk_propdesc::get, duk_propdesc::h_idx, duk_hthread::heap, duk_hbufferobject::length, NULL, duk_hbufferobject::offset, duk_propdesc::set, and duk_hbufferobject::shift.

Referenced by duk__get_propdesc(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ duk__get_part_helper()

DUK_LOCAL duk_ret_t duk__get_part_helper	(	duk_context *	ctx,
		duk_small_uint_t	flags_and_idx )

Definition at line 25682 of file duktape-1.8.0/src/duktape.c.

                                                                                           {
    duk_double_t d;
    duk_int_t parts[DUK_DATE_IDX_NUM_PARTS];
    duk_small_uint_t idx_part = (duk_small_uint_t) (flags_and_idx >> DUK_DATE_FLAG_VALUE_SHIFT);  /* unpack args */
 
    DUK_ASSERT_DISABLE(idx_part >= 0);  /* unsigned */
    DUK_ASSERT(idx_part < DUK_DATE_IDX_NUM_PARTS);

Referenced by duk_bi_date_prototype_get_timezone_offset().

◆ duk__get_propdesc()

DUK_LOCAL_DECL duk_bool_t duk__get_propdesc	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_propdesc *	out_desc,
		duk_small_uint_t	flags )

Definition at line 49323 of file duktape-1.8.0/src/duktape.c.

                        :
 *    - Fills descriptor fields to 'out_desc'
 *    - If DUK_GETDESC_FLAG_PUSH_VALUE is set, pushes a value related to the
 *      property onto the stack ('undefined' for accessor properties).
 *    - Returns non-zero
 *
 *  If property is not found:
 *    - 'out_desc' is left in untouched state (possibly garbage)
 *    - Nothing is pushed onto the stack (not even with DUK_GETDESC_FLAG_PUSH_VALUE
 *      set)
 *    - Returns zero
 *
 *  May cause arbitrary side effects and invalidate (most) duk_tval
 *  pointers.
 */
 
DUK_LOCAL duk_bool_t duk__get_propdesc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags) {
    duk_hobject *curr;
    duk_uint32_t arr_idx;
    duk_uint_t sanity;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(out_desc != NULL);
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
 
    DUK_DDD(DUK_DDDPRINT("duk__get_propdesc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, "
                         "arr_idx=%ld (obj -> %!O, key -> %!O)",
                         (void *) thr, (void *) obj, (void *) key, (void *) out_desc,
                         (long) flags, (long) arr_idx,
                         (duk_heaphdr *) obj, (duk_heaphdr *) key));
 
    curr = obj;
    DUK_ASSERT(curr != NULL);
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        if (duk__get_own_propdesc_raw(thr, curr, key, arr_idx, out_desc, flags)) {
            /* stack contains value (if requested), 'out_desc' is set */
            return 1;
        }
 
        /* not found in 'curr', next in prototype chain; impose max depth */

References duk__get_own_propdesc_raw(), DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_RANGE, DUK_GETDESC_FLAG_IGNORE_PROTOLOOP, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY, DUK_HSTRING_GET_ARRIDX_FAST, DUK_STR_PROTOTYPE_CHAIN_LIMIT, duk_hthread::heap, and NULL.

◆ duk__get_tagged_heaphdr_raw()

DUK_LOCAL_DECL duk_heaphdr * duk__get_tagged_heaphdr_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_uint_t	tag )

Definition at line 16407 of file duktape-1.8.0/src/duktape.c.

                                                                                                {
    return duk__get_buffer_data_helper(ctx, index, out_size, 0 /*throw_flag*/);
}
 
DUK_EXTERNAL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
    return duk__get_buffer_data_helper(ctx, index, out_size, 1 /*throw_flag*/);
}
 
/* Raw helper for getting a value from the stack, checking its tag.
 * The tag cannot be a number because numbers don't have an internal
 * tag in the packed representation.

Referenced by duk_get_c_function(), duk_get_hcompiledfunction(), duk_get_hnativefunction(), duk_require_hbuffer(), duk_require_hcompiledfunction(), duk_require_hnativefunction(), duk_require_hobject(), and duk_require_hthread().

◆ duk__get_temp_hthread()

DUK_LOCAL duk_hthread * duk__get_temp_hthread ( duk_heap * heap )

Definition at line 42195 of file duktape-1.8.0/src/duktape.c.

◆ duk__get_this_regexp()

DUK_LOCAL void duk__get_this_regexp ( duk_context * ctx )

Definition at line 33855 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_ES6_PROXY */
#line 1 "duk_bi_regexp.c"

◆ duk__getconst()

DUK_LOCAL_DECL duk_regconst_t duk__getconst ( duk_compiler_ctx * comp_ctx )

Definition at line 59601 of file duktape-1.8.0/src/duktape.c.

                                                               {
    return duk__alloctemps(comp_ctx, 1);
}
 
DUK_LOCAL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next) {
    comp_ctx->curr_func.temp_next = temp_next;
    if (temp_next > comp_ctx->curr_func.temp_max) {
        comp_ctx->curr_func.temp_max = temp_next;
    }
}
 
/* get const for value at valstack top */
DUK_LOCAL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_compiler_func *f = &comp_ctx->curr_func;
    duk_tval *tv1;
    duk_int_t i, n, n_check;
 
    n = (duk_int_t) duk_get_length(ctx, f->consts_idx);
 
    tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
    DUK_ASSERT(tv1 != NULL);
 
#if defined(DUK_USE_FASTINT)
    /* Explicit check for fastint downgrade. */
    DUK_TVAL_CHKFAST_INPLACE(tv1);
#endif
 
    /* Sanity workaround for handling functions with a large number of
     * constants at least somewhat reasonably.  Otherwise checking whether
     * we already have the constant would grow very slow (as it is O(N^2)).
     */
    n_check = (n > DUK__GETCONST_MAX_CONSTS_CHECK ? DUK__GETCONST_MAX_CONSTS_CHECK : n);
    for (i = 0; i < n_check; i++) {
        duk_tval *tv2 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, f->h_consts, i);
 
        /* Strict equality is NOT enough, because we cannot use the same
         * constant for e.g. +0 and -0.
         */

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__ispec_toregconst_raw().

◆ duk__getid_activation_regs()

DUK_LOCAL duk_bool_t duk__getid_activation_regs	(	duk_hthread *	thr,
		duk_hstring *	name,
		duk_activation *	act,
		duk__id_lookup_result *	out )

Definition at line 72324 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    duk_tval *tv;
    duk_hobject *func;
    duk_hobject *varmap;
    duk_size_t reg_rel;
    duk_size_t idx;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(name != NULL);
    DUK_ASSERT(act != NULL);
    DUK_ASSERT(out != NULL);
 
    func = DUK_ACT_GET_FUNC(act);
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
 
    if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
        return 0;
    }
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARMAP(thr));
    if (!tv) {
        return 0;
    }
    DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
    varmap = DUK_TVAL_GET_OBJECT(tv);
    DUK_ASSERT(varmap != NULL);
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, varmap, name);
    if (!tv) {
        return 0;
    }
    DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
    reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv);

◆ duk__getid_open_decl_env_regs()

DUK_LOCAL duk_bool_t duk__getid_open_decl_env_regs	(	duk_hthread *	thr,
		duk_hstring *	name,
		duk_hobject *	env,
		duk__id_lookup_result *	out )

Definition at line 72239 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_hthread *env_thr;
    duk_hobject *env_func;
    duk_size_t env_regbase;
    duk_hobject *varmap;
    duk_tval *tv;
    duk_size_t reg_rel;
    duk_size_t idx;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(name != NULL);
    DUK_ASSERT(env != NULL);
    DUK_ASSERT(out != NULL);
 
    DUK_ASSERT(DUK_HOBJECT_IS_DECENV(env));
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_CALLEE(thr));
    if (!tv) {
        /* env is closed, should be missing _Callee, _Thread, _Regbase */
        DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL);
        DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL);
        DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL);
        return 0;
    }
 
    DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
    DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_TVAL_GET_OBJECT(tv)));
    env_func = DUK_TVAL_GET_OBJECT(tv);
    DUK_ASSERT(env_func != NULL);
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env_func, DUK_HTHREAD_STRING_INT_VARMAP(thr));
    if (!tv) {
        return 0;
    }
    DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
    varmap = DUK_TVAL_GET_OBJECT(tv);
    DUK_ASSERT(varmap != NULL);
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, varmap, name);
    if (!tv) {
        return 0;
    }
    DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
    reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv);
    DUK_ASSERT_DISABLE(reg_rel >= 0);  /* unsigned */
    DUK_ASSERT(reg_rel < ((duk_hcompiledfunction *) env_func)->nregs);
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THREAD(thr));
    DUK_ASSERT(tv != NULL);
    DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
    DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_THREAD(DUK_TVAL_GET_OBJECT(tv)));
    env_thr = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv);
    DUK_ASSERT(env_thr != NULL);
 
    /* Note: env_thr != thr is quite possible and normal, so careful
     * with what thread is used for valstack lookup.
     */
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_REGBASE(thr));
    DUK_ASSERT(tv != NULL);

References DUK_ASSERT, DUK_ASSERT_DISABLE, duk_hobject_find_existing_entry_tval_ptr(), DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_HOBJECT_IS_DECENV, DUK_HOBJECT_IS_THREAD, DUK_HTHREAD_STRING_INT_CALLEE, DUK_HTHREAD_STRING_INT_REGBASE, DUK_HTHREAD_STRING_INT_THREAD, DUK_HTHREAD_STRING_INT_VARMAP, DUK_TVAL_GET_NUMBER, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_OBJECT, duk_hthread::heap, name, and NULL.

◆ duk__getprop_fastpath_bufobj_tval()

DUK_LOCAL duk_bool_t duk__getprop_fastpath_bufobj_tval	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_tval *	tv_key )

Definition at line 49519 of file duktape-1.8.0/src/duktape.c.

           {
        ;
    }
 
    tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx);
    DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val);  /* side effects */
 
    DUK_DDD(DUK_DDDPRINT("array fast path success for index %ld", (long) idx));
    return 1;
}
 
/*
 *  Fast path for bufferobject getprop/putprop
 */
 
DUK_LOCAL duk_bool_t duk__getprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key) {
    duk_context *ctx;
    duk_uint32_t idx;
    duk_hbufferobject *h_bufobj;
    duk_uint_t byte_off;
    duk_small_uint_t elem_size;
    duk_uint8_t *data;
 
    ctx = (duk_context *) thr;
 
    if (!DUK_HOBJECT_IS_BUFFEROBJECT(obj)) {
        return 0;
    }
    h_bufobj = (duk_hbufferobject *) obj;
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_key)) {
        idx = duk__tval_fastint_to_arr_idx(tv_key);
    } else
#endif
    if (DUK_TVAL_IS_DOUBLE(tv_key)) {
        idx = duk__tval_number_to_arr_idx(tv_key);
    } else {
        return 0;
    }
 
    /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
     * is 0xffffffffUL.  We don't need to check for that explicitly
     * because 0xffffffffUL will never be inside bufferobject length.
     */
 
    /* Careful with wrapping (left shifting idx would be unsafe). */
    if (idx >= (h_bufobj->length >> h_bufobj->shift)) {

◆ duk__getprop_shallow_fastpath_array_tval()

DUK_LOCAL duk_tval * duk__getprop_shallow_fastpath_array_tval	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_tval *	tv_key )

Definition at line 49391 of file duktape-1.8.0/src/duktape.c.

                                                                :
 *    - Object has array part, index is within array allocation, and
 *      value is not unused (= key exists)
 *    - Object has no interfering exotic behavior (e.g. arguments or
 *      string object exotic behaviors interfere, array exotic
 *      behavior does not).
 *
 *  Current shortcoming: if key does not exist (even if it is within
 *  the array allocation range) a slow path lookup with interning is
 *  always required.  This can probably be fixed so that there is a
 *  quick fast path for non-existent elements as well, at least for
 *  standard Array objects.
 */
 
DUK_LOCAL duk_tval *duk__getprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key) {
    duk_tval *tv;
    duk_uint32_t idx;
 
    DUK_UNREF(thr);
 
    if (!(DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
         !DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) &&
         !DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj) &&
         !DUK_HOBJECT_IS_BUFFEROBJECT(obj) &&
         !DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
        /* Must have array part and no conflicting exotic behaviors.
         * Doesn't need to have array special behavior, e.g. Arguments
         * object has array part.
         */
        return NULL;
    }
 
    /* Arrays never have other exotic behaviors. */
 
    DUK_DDD(DUK_DDDPRINT("fast path attempt (no exotic string/arguments/buffer "
                         "behavior, object has array part)"));
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_key)) {
        idx = duk__tval_fastint_to_arr_idx(tv_key);
    } else
#endif
    if (DUK_TVAL_IS_DOUBLE(tv_key)) {
        idx = duk__tval_number_to_arr_idx(tv_key);
    } else {
        DUK_DDD(DUK_DDDPRINT("key is not a number"));
        return NULL;
    }
 
    /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
     * is 0xffffffffUL.  We don't need to check for that explicitly
     * because 0xffffffffUL will never be inside object 'a_size'.
     */
 
    if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
        DUK_DDD(DUK_DDDPRINT("key is not an array index or outside array part"));
        return NULL;
    }

References duk__tval_number_to_arr_idx(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ, DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ, DUK_HOBJECT_IS_BUFFEROBJECT, DUK_TVAL_IS_DOUBLE, DUK_UNREF, and NULL.

◆ duk__getrequire_bufobj_this()

DUK_LOCAL duk_hbufferobject * duk__getrequire_bufobj_this	(	duk_context *	ctx,
		duk_bool_t	throw_flag )

Definition at line 21835 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    duk_hthread *thr;
    duk_tval *tv;
    duk_hbufferobject *h_this;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;

Referenced by duk__require_bufobj_value().

◆ duk__getvar_helper()

DUK_LOCAL duk_bool_t duk__getvar_helper	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_activation *	act,
		duk_hstring *	name,
		duk_bool_t	throw_flag )

Definition at line 72700 of file duktape-1.8.0/src/duktape.c.

                                                                : [val this].
 *
 *  If 'throw' is false, returns 0 if identifier cannot be resolved, and the
 *  stack will be unaffected in this case.  If identifier is resolved, returns
 *  1 and leaves [val this] on top of stack.
 *
 *  Note: the 'strict' flag of a reference returned by GetIdentifierReference
 *  is ignored by GetValue.  Hence we don't take a 'strict' parameter.
 *
 *  The 'throw' flag is needed for implementing 'typeof' for an unreferenced
 *  identifier.  An unreference identifier in other contexts generates a
 *  ReferenceError.
 */
 
DUK_LOCAL
duk_bool_t duk__getvar_helper(duk_hthread *thr,
                              duk_hobject *env,
                              duk_activation *act,
                              duk_hstring *name,
                              duk_bool_t throw_flag) {
    duk_context *ctx = (duk_context *) thr;
    duk__id_lookup_result ref;
    duk_tval tv_tmp_obj;
    duk_tval tv_tmp_key;
    duk_bool_t parents;
 
    DUK_DDD(DUK_DDDPRINT("getvar: thr=%p, env=%p, act=%p, name=%!O "
                         "(env -> %!dO)",
                         (void *) thr, (void *) env, (void *) act,
                         (duk_heaphdr *) name, (duk_heaphdr *) env));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(name != NULL);
    /* env and act may be NULL */
 
        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env);
        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
 
    parents = 1;     /* follow parent chain */
    if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
        if (ref.value) {
            DUK_ASSERT(ref.this_binding == NULL);  /* always for register bindings */
            duk_push_tval(ctx, ref.value);
            duk_push_undefined(ctx);
        } else {
            DUK_ASSERT(ref.holder != NULL);
 
            /* Note: getprop may invoke any getter and invalidate any
             * duk_tval pointers, so this must be done first.
             */
 
            if (ref.this_binding) {
                duk_push_tval(ctx, ref.this_binding);
            } else {
                duk_push_undefined(ctx);
            }
 
            DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder);
            DUK_TVAL_SET_STRING(&tv_tmp_key, name);
            (void) duk_hobject_getprop(thr, &tv_tmp_obj, &tv_tmp_key);  /* [this value] */

References duk__get_identifier_reference(), DUK_ASSERT, DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR, DUK_DDD, DUK_DDDPRINT, duk_hobject_getprop(), duk_push_tval(), duk_push_undefined(), DUK_TVAL_SET_OBJECT, DUK_TVAL_SET_STRING, duk__id_lookup_result::holder, name, NULL, duk__id_lookup_result::this_binding, and duk__id_lookup_result::value.

◆ duk__grow_props_for_array_item()

DUK_LOCAL void duk__grow_props_for_array_item	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_uint32_t	highest_arr_idx )

Definition at line 48391 of file duktape-1.8.0/src/duktape.c.

48408 {

Referenced by duk_hobject_define_property_internal(), and duk_hobject_putprop().

◆ duk__grow_props_for_new_entry_item()

DUK_LOCAL void duk__grow_props_for_new_entry_item	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 48361 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
    duk_uint32_t old_e_used;  /* actually used, non-NULL entries */
    duk_uint32_t new_e_size;
    duk_uint32_t new_a_size;
    duk_uint32_t new_h_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
 
    /* Duktape 0.11.0 and prior tried to optimize the resize by not
     * counting the number of actually used keys prior to the resize.

◆ duk__handle_bound_chain_for_call()

DUK_LOCAL void duk__handle_bound_chain_for_call	(	duk_hthread *	thr,
		duk_idx_t	idx_func,
		duk_idx_t *	p_num_stack_args,
		duk_bool_t	is_constructor_call )

Definition at line 55388 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk_context *ctx = (duk_context *) thr;
    duk_idx_t num_stack_args;
    duk_tval *tv_func;
    duk_hobject *func;
    duk_uint_t sanity;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(p_num_stack_args != NULL);
 
    /* On entry, item at idx_func is a bound, non-lightweight function,
     * but we don't rely on that below.
     */
 
    num_stack_args = *p_num_stack_args;
 
    sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY;
    do {
        duk_idx_t i, len;
 
        tv_func = duk_require_tval(ctx, idx_func);
        DUK_ASSERT(tv_func != NULL);
 
        if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
            /* Lightweight function: never bound, so terminate. */
            break;
        } else if (DUK_TVAL_IS_OBJECT(tv_func)) {
            func = DUK_TVAL_GET_OBJECT(tv_func);
            if (!DUK_HOBJECT_HAS_BOUND(func)) {
                /* Normal non-bound function. */
                break;
            }
        } else {
            /* Function.prototype.bind() should never let this happen,
             * ugly error message is enough.
             */
            DUK_ERROR_INTERNAL_DEFMSG(thr);
        }
        DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv_func) != NULL);
 
        /* XXX: this could be more compact by accessing the internal properties
         * directly as own properties (they cannot be inherited, and are not
         * externally visible).
         */
 
        DUK_DDD(DUK_DDDPRINT("bound function encountered, ptr=%p, num_stack_args=%ld: %!T",
                             (void *) DUK_TVAL_GET_OBJECT(tv_func), (long) num_stack_args, tv_func));
 
        /* [ ... func this arg1 ... argN ] */
 
        if (is_constructor_call) {
            /* See: tests/ecmascript/test-spec-bound-constructor.js */
            DUK_DDD(DUK_DDDPRINT("constructor call: don't update this binding"));
        } else {
            duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_THIS);
            duk_replace(ctx, idx_func + 1);  /* idx_this = idx_func + 1 */
        }
 
        /* [ ... func this arg1 ... argN ] */
 
        /* XXX: duk_get_length? */
        duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_ARGS);  /* -> [ ... func this arg1 ... argN _Args ] */
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);          /* -> [ ... func this arg1 ... argN _Args length ] */
        len = (duk_idx_t) duk_require_int(ctx, -1);
        duk_pop(ctx);
 
        duk_require_stack(ctx, len);
        for (i = 0; i < len; i++) {
            /* XXX: very slow - better to bulk allocate a gap, and copy
             * from args_array directly (we know it has a compact array
             * part, etc).
             */
 
            /* [ ... func this <some bound args> arg1 ... argN _Args ] */
            duk_get_prop_index(ctx, -1, i);
            duk_insert(ctx, idx_func + 2 + i);  /* idx_args = idx_func + 2 */
        }
        num_stack_args += len;  /* must be updated to work properly (e.g. creation of 'arguments') */
        duk_pop(ctx);
 
        /* [ ... func this <bound args> arg1 ... argN ] */
 
        duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_TARGET);
        duk_replace(ctx, idx_func);  /* replace in stack */
 
        DUK_DDD(DUK_DDDPRINT("bound function handled, num_stack_args=%ld, idx_func=%ld, curr func=%!T",
                             (long) num_stack_args, (long) idx_func, duk_get_tval(ctx, idx_func)));
    } while (--sanity > 0);
 
    if (sanity == 0) {
        DUK_ERROR_RANGE(thr, DUK_STR_BOUND_CHAIN_LIMIT);
    }
 

◆ duk__handle_break_or_continue()

DUK_LOCAL void duk__handle_break_or_continue	(	duk_hthread *	thr,
		duk_uint_t	label_id,
		duk_small_uint_t	lj_type )

Definition at line 66803 of file duktape-1.8.0/src/duktape.c.

            :
    return retval;
 
 convert_to_internal_error:
    /* This could also be thrown internally (set the error, goto check_longjmp),
     * but it's better for internal errors to bubble outwards so that we won't
     * infinite loop in this catchpoint.
     */
    DUK_ERROR_INTERNAL_DEFMSG(thr);
    DUK_UNREACHABLE();
    return retval;
}
 
/* Handle a BREAK/CONTINUE opcode.  Avoid using longjmp() for BREAK/CONTINUE
 * handling because it has a measurable performance impact in ordinary
 * environments and an extreme impact in Emscripten (GH-342).
 */
DUK_LOCAL void duk__handle_break_or_continue(duk_hthread *thr,
                                             duk_uint_t label_id,
                                             duk_small_uint_t lj_type) {
    duk_catcher *cat;
    duk_size_t orig_callstack_index;
 
    DUK_ASSERT(thr != NULL);
 
    /*
     *  Find a matching label catcher or 'finally' catcher in
     *  the same function.
     *
     *  A label catcher must always exist and will match unless
     *  a 'finally' captures the break/continue first.  It is the
     *  compiler's responsibility to ensure that labels are used
     *  correctly.
     */
 
    /* Note: thr->catchstack_top may be 0, so that cat < thr->catchstack
     * initially.  This is OK and intended.
     */
    cat = thr->catchstack + thr->catchstack_top - 1;
    DUK_ASSERT(thr->callstack_top > 0);
    orig_callstack_index = thr->callstack_top - 1;
 
    DUK_DDD(DUK_DDDPRINT("handling break/continue with label=%ld, callstack index=%ld",
                         (long) label_id, (long) cat->callstack_index));
 
    while (cat >= thr->catchstack) {
        if (cat->callstack_index != orig_callstack_index) {
            break;
        }
        DUK_DDD(DUK_DDDPRINT("considering catcher %ld: type=%ld label=%ld",
                             (long) (cat - thr->catchstack),
                             (long) DUK_CAT_GET_TYPE(cat),
                             (long) DUK_CAT_GET_LABEL(cat)));
 
        if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF &&
            DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
            duk_size_t cat_idx;
            duk_tval tv_tmp;
 
            cat_idx = (duk_size_t) (cat - thr->catchstack);  /* get before side effects */
 
            DUK_TVAL_SET_FASTINT_U32(&tv_tmp, (duk_uint32_t) label_id);
            duk__handle_finally(thr, cat_idx, &tv_tmp, lj_type);
 
            DUK_DD(DUK_DDPRINT("-> break/continue caught by 'finally', restart execution"));
            return;
        }
        if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL &&

◆ duk__handle_call_error()

DUK_LOCAL void duk__handle_call_error	(	duk_hthread *	thr,
		duk_size_t	entry_valstack_bottom_index,
		duk_size_t	entry_valstack_end,
		duk_size_t	entry_catchstack_top,
		duk_size_t	entry_callstack_top,
		duk_int_t	entry_call_recursion_depth,
		duk_hthread *	entry_curr_thread,
		duk_uint_fast8_t	entry_thread_state,
		duk_instr_t **	entry_ptr_curr_pc,
		duk_idx_t	idx_func,
		duk_jmpbuf *	old_jmpbuf_ptr )

Definition at line 56719 of file duktape-1.8.0/src/duktape.c.

                   :
    DUK_ERROR_FMT1(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for call (%ld)", (long) thr->state);
    DUK_UNREACHABLE();
    return;  /* never executed */
}
 
DUK_LOCAL void duk__handle_call_error(duk_hthread *thr,
                                      duk_size_t entry_valstack_bottom_index,
                                      duk_size_t entry_valstack_end,
                                      duk_size_t entry_catchstack_top,
                                      duk_size_t entry_callstack_top,
                                      duk_int_t entry_call_recursion_depth,
                                      duk_hthread *entry_curr_thread,
                                      duk_uint_fast8_t entry_thread_state,
                                      duk_instr_t **entry_ptr_curr_pc,
                                      duk_idx_t idx_func,
                                      duk_jmpbuf *old_jmpbuf_ptr) {
    duk_context *ctx;
    duk_tval *tv_ret;
 
    ctx = (duk_context *) thr;
 
    DUK_DDD(DUK_DDDPRINT("error caught during duk__handle_call_inner(): %!T",
                         (duk_tval *) &thr->heap->lj.value1));
 
    /* Other longjmp types are handled by executor before propagating
     * the error here.
     */
    DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW);
    DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
    DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
 
    /* We don't need to sync back thr->ptr_curr_pc here because
     * the bytecode executor always has a setjmp catchpoint which
     * does that before errors propagate to here.
     */
    DUK_ASSERT(thr->ptr_curr_pc == NULL);
 
    /* Restore the previous setjmp catcher so that any error in
     * error handling will propagate outwards rather than re-enter
     * the same handler.  However, the error handling path must be
     * designed to be error free so that sandboxing guarantees are
     * reliable, see e.g. https://github.com/svaarala/duktape/issues/476.
     */
    thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
 
    /* XXX: callstack unwind may now throw an error when closing
     * scopes; this is a sandboxing issue, described in:
     * https://github.com/svaarala/duktape/issues/476
     */
    duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
    duk_hthread_catchstack_shrink_check(thr);
    duk_hthread_callstack_unwind(thr, entry_callstack_top);
    duk_hthread_callstack_shrink_check(thr);
 
    thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
    tv_ret = thr->valstack_bottom + idx_func;  /* XXX: byte offset? */
    DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, &thr->heap->lj.value1);  /* side effects */
#if defined(DUK_USE_FASTINT)
    /* Explicit check for fastint downgrade. */
    DUK_TVAL_CHKFAST_INPLACE(tv_ret);
#endif
    duk_set_top(ctx, idx_func + 1);  /* XXX: could be eliminated with valstack adjust */
 
    /* [ ... errobj ] */
 
    /* Ensure there is internal valstack spare before we exit; this may
     * throw an alloc error.  The same guaranteed size must be available
     * as before the call.  This is not optimal now: we store the valstack
     * allocated size during entry; this value may be higher than the
     * minimal guarantee for an application.
     */
 
    /* XXX: this needs to be reworked so that we never shrink the value
     * stack on function entry so that we never need to grow it here.
     * Needing to grow here is a sandboxing issue because we need to
     * allocate which may cause an error in the error handling path
     * and thus propagate an error out of a protected call.
     */
 
    (void) duk_valstack_resize_raw((duk_context *) thr,
                                   entry_valstack_end,                    /* same as during entry */
                                   DUK_VSRESIZE_FLAG_SHRINK |             /* flags */
                                   DUK_VSRESIZE_FLAG_COMPACT |
                                   DUK_VSRESIZE_FLAG_THROW);
 
 
    /* These are just convenience "wiping" of state.  Side effects should
     * not be an issue here: thr->heap and thr->heap->lj have a stable
     * pointer.  Finalizer runs etc capture even out-of-memory errors so
     * nothing should throw here.
     */
    thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN;
    thr->heap->lj.iserror = 0;
    DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value1);  /* side effects */
    DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value2);  /* side effects */
 
    /* Restore entry thread executor curr_pc stack frame pointer. */
    thr->ptr_curr_pc = entry_ptr_curr_pc;
 
    DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread);  /* may be NULL */
    thr->state = (duk_uint8_t) entry_thread_state;
 
    DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) ||  /* first call */
               (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) ||  /* other call */
               (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr));     /* current thread */
 
    thr->heap->call_recursion_depth = entry_call_recursion_depth;
 
    /* If the debugger is active we need to force an interrupt so that
     * debugger breakpoints are rechecked.  This is important for function
     * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see
     * GH-303.  Only needed for success path, error path always causes a
     * breakpoint recheck in the executor.  It would be enough to set this

Referenced by duk_handle_call_protected().

◆ duk__handle_call_inner()

DUK_LOCAL void duk__handle_call_inner	(	duk_hthread *	thr,
		duk_idx_t	num_stack_args,
		duk_small_uint_t	call_flags,
		duk_idx_t	idx_func )

Definition at line 56142 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_idx_t idx_func;         /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
 
    /* Argument validation and func/args offset. */
    idx_func = duk__get_idx_func(thr, num_stack_args);
 
    duk__handle_call_inner(thr, num_stack_args, call_flags, idx_func);
}
 
DUK_LOCAL void duk__handle_call_inner(duk_hthread *thr,
                                      duk_idx_t num_stack_args,
                                      duk_small_uint_t call_flags,
                                      duk_idx_t idx_func) {
    duk_context *ctx;
    duk_size_t entry_valstack_bottom_index;
    duk_size_t entry_valstack_end;
    duk_size_t entry_callstack_top;
    duk_size_t entry_catchstack_top;
    duk_int_t entry_call_recursion_depth;
    duk_hthread *entry_curr_thread;
    duk_uint_fast8_t entry_thread_state;
    duk_instr_t **entry_ptr_curr_pc;
    duk_idx_t nargs;            /* # argument registers target function wants (< 0 => "as is") */
    duk_idx_t nregs;            /* # total registers target function wants on entry (< 0 => "as is") */
    duk_hobject *func;          /* 'func' on stack (borrowed reference) */
    duk_tval *tv_func;          /* duk_tval ptr for 'func' on stack (borrowed reference) or tv_func_copy */
    duk_tval tv_func_copy;      /* to avoid relookups */
    duk_activation *act;
    duk_hobject *env;
    duk_ret_t rc;
 
    ctx = (duk_context *) thr;
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(num_stack_args >= 0);
    /* XXX: currently NULL allocations are not supported; remove if later allowed */
    DUK_ASSERT(thr->valstack != NULL);
    DUK_ASSERT(thr->callstack != NULL);
    DUK_ASSERT(thr->catchstack != NULL);
 
    DUK_DD(DUK_DDPRINT("duk__handle_call_inner: num_stack_args=%ld, call_flags=0x%08lx, top=%ld",
                       (long) num_stack_args, (long) call_flags, (long) duk_get_top(ctx)));
 
    /*
     *  Store entry state.
     */
 
    entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
#if defined(DUK_USE_PREFER_SIZE)
    entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack);
#else
    DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
    entry_valstack_end = thr->valstack_size;
#endif
    entry_callstack_top = thr->callstack_top;
    entry_catchstack_top = thr->catchstack_top;
    entry_call_recursion_depth = thr->heap->call_recursion_depth;
    entry_curr_thread = thr->heap->curr_thread;  /* Note: may be NULL if first call */
    entry_thread_state = thr->state;
    entry_ptr_curr_pc = thr->ptr_curr_pc;  /* may be NULL */
 
    /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc.  Then NULL
     * thr->ptr_curr_pc so that it's not accidentally used with an incorrect
     * activation when side effects occur.
     */
    duk_hthread_sync_and_null_currpc(thr);
 
    DUK_DD(DUK_DDPRINT("duk__handle_call_inner: thr=%p, num_stack_args=%ld, "
                       "call_flags=0x%08lx (ignorerec=%ld, constructor=%ld), "
                       "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, "
                       "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
                       "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
                       (void *) thr,
                       (long) num_stack_args,
                       (unsigned long) call_flags,
                       (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0),
                       (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0),
                       (long) duk_get_top(ctx),
                       (long) idx_func,
                       (long) (idx_func + 2),
                       (long) thr->heap->call_recursion_depth,
                       (long) thr->heap->call_recursion_limit,
                       (long) entry_valstack_bottom_index,
                       (long) entry_callstack_top,
                       (long) entry_catchstack_top,
                       (long) entry_call_recursion_depth,
                       (void *) entry_curr_thread,
                       (long) entry_thread_state));
 
 
    /*
     *  Thread state check and book-keeping.
     */
 
    if (thr == thr->heap->curr_thread) {
        /* same thread */
        if (thr->state != DUK_HTHREAD_STATE_RUNNING) {
            /* should actually never happen, but check anyway */
            goto thread_state_error;
        }
    } else {
        /* different thread */
        DUK_ASSERT(thr->heap->curr_thread == NULL ||
                   thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING);
        if (thr->state != DUK_HTHREAD_STATE_INACTIVE) {
            goto thread_state_error;
        }
        DUK_HEAP_SWITCH_THREAD(thr->heap, thr);
        thr->state = DUK_HTHREAD_STATE_RUNNING;
 
        /* Note: multiple threads may be simultaneously in the RUNNING
         * state, but not in the same "resume chain".
         */
    }
    DUK_ASSERT(thr->heap->curr_thread == thr);
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
 
    /*
     *  C call recursion depth check, which provides a reasonable upper
     *  bound on maximum C stack size (arbitrary C stack growth is only
     *  possible by recursive handle_call / handle_safe_call calls).
     */
 
    /* XXX: remove DUK_CALL_FLAG_IGNORE_RECLIMIT flag: there's now the
     * reclimit bump?
     */
 
    DUK_ASSERT(thr->heap->call_recursion_depth >= 0);
    DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit);
    if (call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) {
        DUK_DD(DUK_DDPRINT("ignoring reclimit for this call (probably an errhandler call)"));
    } else {
        if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) {
            /* XXX: error message is a bit misleading: we reached a recursion
             * limit which is also essentially the same as a C callstack limit
             * (except perhaps with some relaxed threading assumptions).
             */
            DUK_ERROR_RANGE(thr, DUK_STR_C_CALLSTACK_LIMIT);
        }
        thr->heap->call_recursion_depth++;
    }
 
    /*
     *  Check the function type, handle bound function chains, and prepare
     *  parameters for the rest of the call handling.  Also figure out the
     *  effective 'this' binding, which replaces the current value at
     *  idx_func + 1.
     *
     *  If the target function is a 'bound' one, follow the chain of 'bound'
     *  functions until a non-bound function is found.  During this process,
     *  bound arguments are 'prepended' to existing ones, and the "this"
     *  binding is overridden.  See E5 Section 15.3.4.5.1.
     *
     *  Lightfunc detection happens here too.  Note that lightweight functions
     *  can be wrapped by (non-lightweight) bound functions so we must resolve
     *  the bound function chain first.
     */
 
    func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags);
    DUK_TVAL_SET_TVAL(&tv_func_copy, tv_func);
    tv_func = &tv_func_copy;  /* local copy to avoid relookups */
 
    DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
    DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) ||
                                DUK_HOBJECT_IS_NATIVEFUNCTION(func)));
 
    duk__coerce_effective_this_binding(thr, func, idx_func + 1);
    DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T",
                         (duk_tval *) duk_get_tval(ctx, idx_func + 1)));
 
    /* [ ... func this arg1 ... argN ] */
 
    /*
     *  Setup a preliminary activation and figure out nargs/nregs.
     *
     *  Don't touch valstack_bottom or valstack_top yet so that Duktape API
     *  calls work normally.
     */
 
    duk_hthread_callstack_grow(thr);
 
    if (thr->callstack_top > 0) {
        /*
         *  Update idx_retval of current activation.
         *
         *  Although it might seem this is not necessary (bytecode executor
         *  does this for Ecmascript-to-Ecmascript calls; other calls are
         *  handled here), this turns out to be necessary for handling yield
         *  and resume.  For them, an Ecmascript-to-native call happens, and
         *  the Ecmascript call's idx_retval must be set for things to work.
         */
 
        (thr->callstack + thr->callstack_top - 1)->idx_retval = entry_valstack_bottom_index + idx_func;
    }
 
    DUK_ASSERT(thr->callstack_top < thr->callstack_size);
    act = thr->callstack + thr->callstack_top;
    thr->callstack_top++;
    DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
    DUK_ASSERT(thr->valstack_top > thr->valstack_bottom);  /* at least effective 'this' */
    DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
 
    act->flags = 0;
 
    /* For now all calls except Ecma-to-Ecma calls prevent a yield. */
    act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;
    if (call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) {
        act->flags |= DUK_ACT_FLAG_CONSTRUCT;
    }
    if (call_flags & DUK_CALL_FLAG_DIRECT_EVAL) {
        act->flags |= DUK_ACT_FLAG_DIRECT_EVAL;
    }
 
    /* These base values are never used, but if the compiler doesn't know
     * that DUK_ERROR() won't return, these are needed to silence warnings.
     * On the other hand, scan-build will warn about the values not being
     * used, so add a DUK_UNREF.
     */
    nargs = 0; DUK_UNREF(nargs);
    nregs = 0; DUK_UNREF(nregs);
 
    if (DUK_LIKELY(func != NULL)) {
        if (DUK_HOBJECT_HAS_STRICT(func)) {
            act->flags |= DUK_ACT_FLAG_STRICT;
        }
        if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
            nargs = ((duk_hcompiledfunction *) func)->nargs;
            nregs = ((duk_hcompiledfunction *) func)->nregs;
            DUK_ASSERT(nregs >= nargs);
        } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
            /* Note: nargs (and nregs) may be negative for a native,
             * function, which indicates that the function wants the
             * input stack "as is" (i.e. handles "vararg" arguments).
             */
            nargs = ((duk_hnativefunction *) func)->nargs;
            nregs = nargs;
        } else {
            /* XXX: this should be an assert */
            DUK_ERROR_TYPE(thr, DUK_STR_NOT_CALLABLE);
        }
    } else {
        duk_small_uint_t lf_flags;
 
        DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func));
        lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_func);
        nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
        if (nargs == DUK_LFUNC_NARGS_VARARGS) {
            nargs = -1;  /* vararg */
        }
        nregs = nargs;
 
        act->flags |= DUK_ACT_FLAG_STRICT;
    }
 
    act->func = func;  /* NULL for lightfunc */
    act->var_env = NULL;
    act->lex_env = NULL;
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
    act->prev_caller = NULL;
#endif
    act->curr_pc = NULL;
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    act->prev_line = 0;
#endif
    act->idx_bottom = entry_valstack_bottom_index + idx_func + 2;
#if 0  /* topmost activation idx_retval is considered garbage, no need to init */
    act->idx_retval = 0;
#endif
    DUK_TVAL_SET_TVAL(&act->tv_func, tv_func);  /* borrowed, no refcount */
 
    /* XXX: remove the preventcount and make yield walk the callstack?
     * Or perhaps just use a single flag, not a counter, faster to just
     * set and restore?
     */
    if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
        /* duk_hthread_callstack_unwind() will decrease this on unwind */
        thr->callstack_preventcount++;
    }
 
    /* XXX: Is this INCREF necessary? 'func' is always a borrowed
     * reference reachable through the value stack?  If changed, stack
     * unwind code also needs to be fixed to match.
     */
    DUK_HOBJECT_INCREF_ALLOWNULL(thr, func);  /* act->func */
 
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
    if (func) {
        duk__update_func_caller_prop(thr, func);
        act = thr->callstack + thr->callstack_top - 1;
    }
#endif
 
    /* [ ... func this arg1 ... argN ] */
 
    /*
     *  Environment record creation and 'arguments' object creation.
     *  Named function expression name binding is handled by the
     *  compiler; the compiled function's parent env will contain
     *  the (immutable) binding already.
     *
     *  This handling is now identical for C and Ecmascript functions.
     *  C functions always have the 'NEWENV' flag set, so their
     *  environment record initialization is delayed (which is good).
     *
     *  Delayed creation (on demand) is handled in duk_js_var.c.
     */
 
    DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));  /* bound function chain has already been resolved */
 
    if (DUK_LIKELY(func != NULL)) {
        if (DUK_LIKELY(DUK_HOBJECT_HAS_NEWENV(func))) {
            if (DUK_LIKELY(!DUK_HOBJECT_HAS_CREATEARGS(func))) {
                /* Use a new environment but there's no 'arguments' object;
                 * delayed environment initialization.  This is the most
                 * common case.
                 */
                DUK_ASSERT(act->lex_env == NULL);
                DUK_ASSERT(act->var_env == NULL);
            } else {
                /* Use a new environment and there's an 'arguments' object.
                 * We need to initialize it right now.
                 */
 
                /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */
                env = duk_create_activation_environment_record(thr, func, act->idx_bottom);
                DUK_ASSERT(env != NULL);
 
                /* [ ... func this arg1 ... argN envobj ] */
 
                DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func));
                duk__handle_createargs_for_call(thr, func, env, num_stack_args);
 
                /* [ ... func this arg1 ... argN envobj ] */
 
                act = thr->callstack + thr->callstack_top - 1;
                act->lex_env = env;
                act->var_env = env;
                DUK_HOBJECT_INCREF(thr, env);
                DUK_HOBJECT_INCREF(thr, env);  /* XXX: incref by count (2) directly */
                duk_pop(ctx);
            }
        } else {
            /* Use existing env (e.g. for non-strict eval); cannot have
             * an own 'arguments' object (but can refer to an existing one).
             */
 
            DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func));
 
            duk__handle_oldenv_for_call(thr, func, act);
            /* No need to re-lookup 'act' at present: no side effects. */
 
            DUK_ASSERT(act->lex_env != NULL);
            DUK_ASSERT(act->var_env != NULL);
        }
    } else {
        /* Lightfuncs are always native functions and have "newenv". */
        DUK_ASSERT(act->lex_env == NULL);
        DUK_ASSERT(act->var_env == NULL);
    }
 
    /* [ ... func this arg1 ... argN ] */
 
    /*
     *  Setup value stack: clamp to 'nargs', fill up to 'nregs'
     *
     *  Value stack may either grow or shrink, depending on the
     *  number of func registers and the number of actual arguments.
     *  If nregs >= 0, func wants args clamped to 'nargs'; else it
     *  wants all args (= 'num_stack_args').
     */
 
    /* XXX: optimize value stack operation */
    /* XXX: don't want to shrink allocation here */
 
    duk__adjust_valstack_and_top(thr,
                                 num_stack_args,
                                 idx_func + 2,
                                 nregs,
                                 nargs,
                                 func);
 
    /*
     *  Determine call type, then finalize activation, shift to
     *  new value stack bottom, and call the target.
     */
 
    act = thr->callstack + thr->callstack_top - 1;
    if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
        /*
         *  Ecmascript call
         */
 
        duk_tval *tv_ret;
        duk_tval *tv_funret;
 
        DUK_ASSERT(func != NULL);
        DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
        act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func);
 
        thr->valstack_bottom = thr->valstack_bottom + idx_func + 2;
        /* keep current valstack_top */
        DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
        DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
        DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
        /* [ ... func this | arg1 ... argN ] ('this' must precede new bottom) */
 
        /*
         *  Bytecode executor call.
         *
         *  Execute bytecode, handling any recursive function calls and
         *  thread resumptions.  Returns when execution would return from
         *  the entry level activation.  When the executor returns, a
         *  single return value is left on the stack top.
         *
         *  The only possible longjmp() is an error (DUK_LJ_TYPE_THROW),
         *  other types are handled internally by the executor.
         */
 
        /* thr->ptr_curr_pc is set by bytecode executor early on entry */
        DUK_ASSERT(thr->ptr_curr_pc == NULL);
        DUK_DDD(DUK_DDDPRINT("entering bytecode execution"));
        duk_js_execute_bytecode(thr);
        DUK_DDD(DUK_DDDPRINT("returned from bytecode execution"));
 
        /* Unwind. */
 
        DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);  /* may need unwind */
        DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
        DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
        duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
        duk_hthread_catchstack_shrink_check(thr);
        duk_hthread_callstack_unwind(thr, entry_callstack_top);
        duk_hthread_callstack_shrink_check(thr);
 
        thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
        /* keep current valstack_top */
        DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
        DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
        DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
        DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1);
 
        /* Return value handling. */
 
        /* [ ... func this (crud) retval ] */
 
        tv_ret = thr->valstack_bottom + idx_func;
        tv_funret = thr->valstack_top - 1;
#if defined(DUK_USE_FASTINT)
        /* Explicit check for fastint downgrade. */
        DUK_TVAL_CHKFAST_INPLACE(tv_funret);
#endif
        DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, tv_funret);  /* side effects */
    } else {
        /*
         *  Native call.
         */
 
        duk_tval *tv_ret;
        duk_tval *tv_funret;
 
        thr->valstack_bottom = thr->valstack_bottom + idx_func + 2;
        /* keep current valstack_top */
        DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
        DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
        DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
        DUK_ASSERT(func == NULL || ((duk_hnativefunction *) func)->func != NULL);
 
        /* [ ... func this | arg1 ... argN ] ('this' must precede new bottom) */
 
        /* For native calls must be NULL so we don't sync back */
        DUK_ASSERT(thr->ptr_curr_pc == NULL);
 
        if (func) {
            rc = ((duk_hnativefunction *) func)->func((duk_context *) thr);
        } else {
            duk_c_function funcptr = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func);
            rc = funcptr((duk_context *) thr);
        }
 
        /* Automatic error throwing, retval check. */
 
        if (rc < 0) {
            duk_error_throw_from_negative_rc(thr, rc);
            DUK_UNREACHABLE();
        } else if (rc > 1) {
            DUK_ERROR_API(thr, "c function returned invalid rc");
        }
        DUK_ASSERT(rc == 0 || rc == 1);
 
        /* Unwind. */
 
        DUK_ASSERT(thr->catchstack_top == entry_catchstack_top);  /* no need to unwind */
        DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
        duk_hthread_callstack_unwind(thr, entry_callstack_top);
        duk_hthread_callstack_shrink_check(thr);
 
        thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
        /* keep current valstack_top */
        DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
        DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
        DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
        DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1);
 
        /* Return value handling. */
 
        /* XXX: should this happen in the callee's activation or after unwinding? */
        tv_ret = thr->valstack_bottom + idx_func;
        if (rc == 0) {
            DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv_ret);  /* side effects */
        } else {
            /* [ ... func this (crud) retval ] */
            tv_funret = thr->valstack_top - 1;
#if defined(DUK_USE_FASTINT)
            /* Explicit check for fastint downgrade. */
            DUK_TVAL_CHKFAST_INPLACE(tv_funret);
#endif
            DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, tv_funret);  /* side effects */
        }
    }
 
    duk_set_top(ctx, idx_func + 1);  /* XXX: unnecessary, handle in adjust */
 
    /* [ ... retval ] */
 
    /* Ensure there is internal valstack spare before we exit; this may
     * throw an alloc error.  The same guaranteed size must be available
     * as before the call.  This is not optimal now: we store the valstack
     * allocated size during entry; this value may be higher than the
     * minimal guarantee for an application.
     */
 
    /* XXX: we should never shrink here; when we error out later, we'd
     * need to potentially grow the value stack in error unwind which could
     * cause another error.
     */
 
    (void) duk_valstack_resize_raw((duk_context *) thr,
                                   entry_valstack_end,                    /* same as during entry */
                                   DUK_VSRESIZE_FLAG_SHRINK |             /* flags */
                                   DUK_VSRESIZE_FLAG_COMPACT |
                                   DUK_VSRESIZE_FLAG_THROW);
 
    /* Restore entry thread executor curr_pc stack frame pointer. */
    thr->ptr_curr_pc = entry_ptr_curr_pc;
 
    DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread);  /* may be NULL */
    thr->state = (duk_uint8_t) entry_thread_state;
 
    DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) ||  /* first call */
               (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) ||  /* other call */
               (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr));     /* current thread */
 
    thr->heap->call_recursion_depth = entry_call_recursion_depth;
 
    /* If the debugger is active we need to force an interrupt so that
     * debugger breakpoints are rechecked.  This is important for function
     * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see
     * GH-303.  Only needed for success path, error path always causes a
     * breakpoint recheck in the executor.  It would be enough to set this
     * only when returning to an Ecmascript activation, but setting the flag
     * on every return should have no ill effect.
     */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
        DUK_DD(DUK_DDPRINT("returning with debugger enabled, force interrupt"));
        DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init);

Referenced by duk_handle_call_protected().

◆ duk__handle_catch()

DUK_LOCAL void duk__handle_catch	(	duk_hthread *	thr,
		duk_size_t	cat_idx,
		duk_tval *	tv_val_unstable,
		duk_small_uint_t	lj_type )

Definition at line 66241 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                {
    duk_tval *tv1;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(tv_val_unstable != NULL);
 
    tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base;
    DUK_ASSERT(tv1 < thr->valstack_top);
    DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv_val_unstable);  /* side effects */
 
    tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base + 1;
    DUK_ASSERT(tv1 < thr->valstack_top);
 
    DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) lj_type);  /* side effects */
}
 
DUK_LOCAL void duk__handle_catch(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) {
    duk_context *ctx;
    duk_activation *act;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(tv_val_unstable != NULL);
    ctx = (duk_context *) thr;
 
    duk__set_catcher_regs(thr, cat_idx, tv_val_unstable, lj_type);
 
    duk_hthread_catchstack_unwind(thr, cat_idx + 1);
    duk_hthread_callstack_unwind(thr, thr->catchstack[cat_idx].callstack_index + 1);
 
    DUK_ASSERT(thr->callstack_top >= 1);
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
 
    duk__reconfig_valstack_ecma_catcher(thr, thr->callstack_top - 1, cat_idx);
 
    DUK_ASSERT(thr->callstack_top >= 1);
    act = thr->callstack + thr->callstack_top - 1;
    act->curr_pc = thr->catchstack[cat_idx].pc_base + 0;  /* +0 = catch */
    act = NULL;
 
    /*
     *  If entering a 'catch' block which requires an automatic
     *  catch variable binding, create the lexical environment.
     *
     *  The binding is mutable (= writable) but not deletable.
     *  Step 4 for the catch production in E5 Section 12.14;
     *  no value is given for CreateMutableBinding 'D' argument,
     *  which implies the binding is not deletable.
     */
 
    if (DUK_CAT_HAS_CATCH_BINDING_ENABLED(&thr->catchstack[cat_idx])) {
        duk_hobject *new_env;
        duk_hobject *act_lex_env;
 
        DUK_DDD(DUK_DDDPRINT("catcher has an automatic catch binding"));
 
        /* Note: 'act' is dangerous here because it may get invalidate at many
         * points, so we re-lookup it multiple times.
         */
        DUK_ASSERT(thr->callstack_top >= 1);
        act = thr->callstack + thr->callstack_top - 1;
 
        if (act->lex_env == NULL) {
            DUK_ASSERT(act->var_env == NULL);
            DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
 
            /* this may have side effects, so re-lookup act */
            duk_js_init_activation_environment_records_delayed(thr, act);
            act = thr->callstack + thr->callstack_top - 1;
        }
        DUK_ASSERT(act->lex_env != NULL);
        DUK_ASSERT(act->var_env != NULL);
        DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL);
        DUK_UNREF(act);  /* unreferenced without assertions */
 
        act = thr->callstack + thr->callstack_top - 1;
        act_lex_env = act->lex_env;
        act = NULL;  /* invalidated */
 
        (void) duk_push_object_helper_proto(ctx,
                                            DUK_HOBJECT_FLAG_EXTENSIBLE |
                                            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
                                            act_lex_env);
        new_env = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
        DUK_ASSERT(new_env != NULL);
        DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO", (duk_heaphdr *) new_env));
 
        /* Note: currently the catch binding is handled without a register
         * binding because we don't support dynamic register bindings (they
         * must be fixed for an entire function).  So, there is no need to
         * record regbases etc.
         */
 
        DUK_ASSERT(thr->catchstack[cat_idx].h_varname != NULL);

References duk_hthread::catchstack, DUK_ASSERT, DUK_TVAL_SET_FASTINT_U32_UPDREF, DUK_TVAL_SET_TVAL_UPDREF, duk_catcher::idx_base, NULL, and duk_hthread::valstack.

◆ duk__handle_createargs_for_call()

DUK_LOCAL void duk__handle_createargs_for_call	(	duk_hthread *	thr,
		duk_hobject *	func,
		duk_hobject *	env,
		duk_idx_t	num_stack_args )

Definition at line 55342 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    duk_context *ctx = (duk_context *) thr;
 
    DUK_DDD(DUK_DDDPRINT("creating arguments object for function call"));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(env != NULL);
    DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func));
    DUK_ASSERT(duk_get_top(ctx) >= num_stack_args + 1);
 

Referenced by duk_handle_ecma_call_setup().

◆ duk__handle_executor_error()

DUK_LOCAL void duk__handle_executor_error	(	duk_heap *	heap,
		duk_hthread *	entry_thread,
		duk_size_t	entry_callstack_top,
		duk_int_t	entry_call_recursion_depth,
		duk_jmpbuf *	entry_jmpbuf_ptr )

Definition at line 67563 of file duktape-1.8.0/src/duktape.c.

                                     { \
        goto internal_error; \
    } while (0)
#endif
 
#define DUK__SYNC_CURR_PC()  do { \
        duk_activation *act; \
        act = thr->callstack + thr->callstack_top - 1; \
        act->curr_pc = curr_pc; \
    } while (0)
#define DUK__SYNC_AND_NULL_CURR_PC()  do { \
        duk_activation *act; \
        act = thr->callstack + thr->callstack_top - 1; \
        act->curr_pc = curr_pc; \
        thr->ptr_curr_pc = NULL; \
    } while (0)
 
DUK_LOCAL void duk__handle_executor_error(duk_heap *heap,
                                          duk_hthread *entry_thread,
                                          duk_size_t entry_callstack_top,
                                          duk_int_t entry_call_recursion_depth,
                                          duk_jmpbuf *entry_jmpbuf_ptr) {
    duk_small_uint_t lj_ret;
 
    /* Longjmp callers are required to sync-and-null thr->ptr_curr_pc
     * before longjmp.
     */
    DUK_ASSERT(heap->curr_thread != NULL);
    DUK_ASSERT(heap->curr_thread->ptr_curr_pc == NULL);
 
    /* XXX: signalling the need to shrink check (only if unwound) */
 
    /* Must be restored here to handle e.g. yields properly. */
    heap->call_recursion_depth = entry_call_recursion_depth;
 
    /* Switch to caller's setjmp() catcher so that if an error occurs
     * during error handling, it is always propagated outwards instead
     * of causing an infinite loop in our own handler.
     */
    heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr;
 

References duk_heap::call_recursion_depth, duk_heap::curr_thread, duk__handle_longjmp(), DUK_ASSERT, duk_ljstate::jmpbuf_ptr, duk_heap::lj, NULL, and duk_hthread::ptr_curr_pc.

◆ duk__handle_finally()

DUK_LOCAL void duk__handle_finally	(	duk_hthread *	thr,
		duk_size_t	cat_idx,
		duk_tval *	tv_val_unstable,
		duk_small_uint_t	lj_type )

Definition at line 66337 of file duktape-1.8.0/src/duktape.c.

                                              : %!iO", (duk_heaphdr *) new_env));
    }
 
    DUK_CAT_CLEAR_CATCH_ENABLED(&thr->catchstack[cat_idx]);
}
 
DUK_LOCAL void duk__handle_finally(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) {
    duk_activation *act;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(tv_val_unstable != NULL);
 
    duk__set_catcher_regs(thr, cat_idx, tv_val_unstable, lj_type);

◆ duk__handle_label()

DUK_LOCAL void duk__handle_label	(	duk_hthread *	thr,
		duk_size_t	cat_idx,
		duk_small_uint_t	lj_type )

Definition at line 66362 of file duktape-1.8.0/src/duktape.c.

                                                                                                 {
    duk_activation *act;
 
    DUK_ASSERT(thr != NULL);
 
    DUK_ASSERT(thr->callstack_top >= 1);
    act = thr->callstack + thr->callstack_top - 1;
 
    DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL);

◆ duk__handle_longjmp()

DUK_LOCAL duk_small_uint_t duk__handle_longjmp	(	duk_hthread *	thr,
		duk_hthread *	entry_thread,
		duk_size_t	entry_callstack_top )

Definition at line 66413 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_size_t entry_callstack_index;
    duk_small_uint_t retval = DUK__LONGJMP_RESTART;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(entry_thread != NULL);
    DUK_ASSERT(entry_callstack_top > 0);  /* guarantees entry_callstack_top - 1 >= 0 */
 
    entry_callstack_index = entry_callstack_top - 1;
 
    /* 'thr' is the current thread, as no-one resumes except us and we
     * switch 'thr' in that case.
     */
    DUK_ASSERT(thr == thr->heap->curr_thread);
 
    /*
     *  (Re)try handling the longjmp.
     *
     *  A longjmp handler may convert the longjmp to a different type and
     *  "virtually" rethrow by goto'ing to 'check_longjmp'.  Before the goto,
     *  the following must be updated:
     *    - the heap 'lj' state
     *    - 'thr' must reflect the "throwing" thread
     */
 
 check_longjmp:
 
    DUK_DD(DUK_DDPRINT("handling longjmp: type=%ld, value1=%!T, value2=%!T, iserror=%ld",
                       (long) thr->heap->lj.type,
                       (duk_tval *) &thr->heap->lj.value1,
                       (duk_tval *) &thr->heap->lj.value2,
                       (long) thr->heap->lj.iserror));
 
    switch (thr->heap->lj.type) {
 
    case DUK_LJ_TYPE_RESUME: {
        /*
         *  Note: lj.value1 is 'value', lj.value2 is 'resumee'.
         *  This differs from YIELD.
         */
 
        duk_tval *tv;
        duk_tval *tv2;
        duk_size_t act_idx;
        duk_hthread *resumee;
 
        /* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */
 
        DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);                                                         /* unchanged by Duktape.Thread.resume() */
        DUK_ASSERT(thr->callstack_top >= 2);                                                                         /* Ecmascript activation + Duktape.Thread.resume() activation */
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL &&
                   DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)) &&
                   ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->func == duk_bi_thread_resume);
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL &&
                   DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));      /* an Ecmascript function */
        DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0);                              /* unsigned */
 
        tv = &thr->heap->lj.value2;  /* resumee */
        DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
        DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL);
        DUK_ASSERT(DUK_HOBJECT_IS_THREAD(DUK_TVAL_GET_OBJECT(tv)));
        resumee = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv);
 
        DUK_ASSERT(resumee != NULL);
        DUK_ASSERT(resumee->resumer == NULL);
        DUK_ASSERT(resumee->state == DUK_HTHREAD_STATE_INACTIVE ||
                   resumee->state == DUK_HTHREAD_STATE_YIELDED);                                                     /* checked by Duktape.Thread.resume() */
        DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
                   resumee->callstack_top >= 2);                                                                     /* YIELDED: Ecmascript activation + Duktape.Thread.yield() activation */
        DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
                   (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1) != NULL &&
                    DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1)) &&
                    ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1))->func == duk_bi_thread_yield));
        DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
                   (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2) != NULL &&
                    DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2))));      /* an Ecmascript function */
        DUK_ASSERT_DISABLE(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
                   (resumee->callstack + resumee->callstack_top - 2)->idx_retval >= 0);                              /* idx_retval unsigned */
        DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_INACTIVE ||
                   resumee->callstack_top == 0);                                                                     /* INACTIVE: no activation, single function value on valstack */
        DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_INACTIVE ||
                   (resumee->valstack_top == resumee->valstack + 1 &&
                    DUK_TVAL_IS_OBJECT(resumee->valstack_top - 1) &&
                    DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_TVAL_GET_OBJECT(resumee->valstack_top - 1))));
 
        if (thr->heap->lj.iserror) {
            /*
             *  Throw the error in the resumed thread's context; the
             *  error value is pushed onto the resumee valstack.
             *
             *  Note: the callstack of the target may empty in this case
             *  too (i.e. the target thread has never been resumed).  The
             *  value stack will contain the initial function in that case,
             *  which we simply ignore.
             */
 
            resumee->resumer = thr;
            resumee->state = DUK_HTHREAD_STATE_RUNNING;
            thr->state = DUK_HTHREAD_STATE_RESUMED;
            DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
            thr = resumee;
 
            thr->heap->lj.type = DUK_LJ_TYPE_THROW;
 
            /* thr->heap->lj.value1 is already the value to throw */
            /* thr->heap->lj.value2 is 'thread', will be wiped out at the end */
 
            DUK_ASSERT(thr->heap->lj.iserror);  /* already set */
 
            DUK_DD(DUK_DDPRINT("-> resume with an error, converted to a throw in the resumee, propagate"));
            goto check_longjmp;
        } else if (resumee->state == DUK_HTHREAD_STATE_YIELDED) {
            act_idx = resumee->callstack_top - 2;  /* Ecmascript function */
            DUK_ASSERT_DISABLE(resumee->callstack[act_idx].idx_retval >= 0);  /* unsigned */
 
            tv = resumee->valstack + resumee->callstack[act_idx].idx_retval;  /* return value from Duktape.Thread.yield() */
            DUK_ASSERT(tv >= resumee->valstack && tv < resumee->valstack_top);
            tv2 = &thr->heap->lj.value1;
            DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv2);  /* side effects */
 
            duk_hthread_callstack_unwind(resumee, act_idx + 1);  /* unwind to 'yield' caller */
 
            /* no need to unwind catchstack */
 
            duk__reconfig_valstack_ecma_return(resumee, act_idx);
 
            resumee->resumer = thr;
            resumee->state = DUK_HTHREAD_STATE_RUNNING;
            thr->state = DUK_HTHREAD_STATE_RESUMED;
            DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
#if 0
            thr = resumee;  /* not needed, as we exit right away */
#endif
            DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee"));
            retval = DUK__LONGJMP_RESTART;
            goto wipe_and_return;
        } else {
            duk_small_uint_t call_flags;
            duk_bool_t setup_rc;
 
            /* resumee: [... initial_func]  (currently actually: [initial_func]) */
 
            duk_push_undefined((duk_context *) resumee);
            tv = &thr->heap->lj.value1;
            duk_push_tval((duk_context *) resumee, tv);
 
            /* resumee: [... initial_func undefined(= this) resume_value ] */
 
            call_flags = DUK_CALL_FLAG_IS_RESUME;  /* is resume, not a tail call */
 
            setup_rc = duk_handle_ecma_call_setup(resumee,
                                                  1,              /* num_stack_args */
                                                  call_flags);    /* call_flags */
            if (setup_rc == 0) {
                /* Shouldn't happen but check anyway. */
                DUK_ERROR_INTERNAL_DEFMSG(thr);
            }
 
            resumee->resumer = thr;
            resumee->state = DUK_HTHREAD_STATE_RUNNING;
            thr->state = DUK_HTHREAD_STATE_RESUMED;
            DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
#if 0
            thr = resumee;  /* not needed, as we exit right away */
#endif
            DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee"));
            retval = DUK__LONGJMP_RESTART;
            goto wipe_and_return;
        }
        DUK_UNREACHABLE();
        break;  /* never here */
    }
 
    case DUK_LJ_TYPE_YIELD: {
        /*
         *  Currently only allowed only if yielding thread has only
         *  Ecmascript activations (except for the Duktape.Thread.yield()
         *  call at the callstack top) and none of them constructor
         *  calls.
         *
         *  This excludes the 'entry' thread which will always have
         *  a preventcount > 0.
         */
 
        duk_hthread *resumer;
 
        /* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */
 
        DUK_ASSERT(thr != entry_thread);                                                                             /* Duktape.Thread.yield() should prevent */
        DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);                                                         /* unchanged from Duktape.Thread.yield() */
        DUK_ASSERT(thr->callstack_top >= 2);                                                                         /* Ecmascript activation + Duktape.Thread.yield() activation */
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL &&
                   DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)) &&
                   ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->func == duk_bi_thread_yield);
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL &&
                   DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));      /* an Ecmascript function */
        DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0);                              /* unsigned */
 
        resumer = thr->resumer;
 
        DUK_ASSERT(resumer != NULL);
        DUK_ASSERT(resumer->state == DUK_HTHREAD_STATE_RESUMED);                                                     /* written by a previous RESUME handling */
        DUK_ASSERT(resumer->callstack_top >= 2);                                                                     /* Ecmascript activation + Duktape.Thread.resume() activation */
        DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1) != NULL &&
                   DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1)) &&
                   ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1))->func == duk_bi_thread_resume);
        DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2) != NULL &&
                   DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2)));        /* an Ecmascript function */
        DUK_ASSERT_DISABLE((resumer->callstack + resumer->callstack_top - 2)->idx_retval >= 0);                      /* unsigned */
 
        if (thr->heap->lj.iserror) {
            thr->state = DUK_HTHREAD_STATE_YIELDED;
            thr->resumer = NULL;
            resumer->state = DUK_HTHREAD_STATE_RUNNING;
            DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
            thr = resumer;
 
            thr->heap->lj.type = DUK_LJ_TYPE_THROW;
            /* lj.value1 is already set */
            DUK_ASSERT(thr->heap->lj.iserror);  /* already set */
 
            DUK_DD(DUK_DDPRINT("-> yield an error, converted to a throw in the resumer, propagate"));
            goto check_longjmp;
        } else {
            duk__handle_yield(thr, resumer, resumer->callstack_top - 2, &thr->heap->lj.value1);
 
            thr->state = DUK_HTHREAD_STATE_YIELDED;
            thr->resumer = NULL;
            resumer->state = DUK_HTHREAD_STATE_RUNNING;
            DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
#if 0
            thr = resumer;  /* not needed, as we exit right away */
#endif
 
            DUK_DD(DUK_DDPRINT("-> yield a value, restart execution in resumer"));
            retval = DUK__LONGJMP_RESTART;
            goto wipe_and_return;
        }
        DUK_UNREACHABLE();
        break;  /* never here */
    }
 
    case DUK_LJ_TYPE_THROW: {
        /*
         *  Three possible outcomes:
         *    * A try or finally catcher is found => resume there.
         *      (or)
         *    * The error propagates to the bytecode executor entry
         *      level (and we're in the entry thread) => rethrow
         *      with a new longjmp(), after restoring the previous
         *      catchpoint.
         *    * The error is not caught in the current thread, so
         *      the thread finishes with an error.  This works like
         *      a yielded error, except that the thread is finished
         *      and can no longer be resumed.  (There is always a
         *      resumer in this case.)
         *
         *  Note: until we hit the entry level, there can only be
         *  Ecmascript activations.
         */
 
        duk_catcher *cat;
        duk_hthread *resumer;
 
        cat = thr->catchstack + thr->catchstack_top - 1;
        while (cat >= thr->catchstack) {
            if (thr == entry_thread &&
                cat->callstack_index < entry_callstack_index) {
                /* entry level reached */
                break;
            }
 
            if (DUK_CAT_HAS_CATCH_ENABLED(cat)) {
                DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF);
 
                duk__handle_catch(thr,
                                  cat - thr->catchstack,
                                  &thr->heap->lj.value1,
                                  DUK_LJ_TYPE_THROW);
 
                DUK_DD(DUK_DDPRINT("-> throw caught by a 'catch' clause, restart execution"));
                retval = DUK__LONGJMP_RESTART;
                goto wipe_and_return;
            }
 
            if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
                DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF);
                DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat));
 
                duk__handle_finally(thr,
                                    cat - thr->catchstack,
                                    &thr->heap->lj.value1,
                                    DUK_LJ_TYPE_THROW);
 
                DUK_DD(DUK_DDPRINT("-> throw caught by a 'finally' clause, restart execution"));
                retval = DUK__LONGJMP_RESTART;
                goto wipe_and_return;
            }
 
            cat--;
        }
 
        if (thr == entry_thread) {
            /* not caught by anything before entry level; rethrow and let the
             * final catcher unwind everything
             */
#if 0
            duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1);  /* leave 'cat' as top catcher (also works if catchstack exhausted) */
            duk_hthread_callstack_unwind(thr, entry_callstack_index + 1);
 
#endif
            DUK_D(DUK_DPRINT("-> throw propagated up to entry level, rethrow and exit bytecode executor"));
            retval = DUK__LONGJMP_RETHROW;
            goto just_return;
            /* Note: MUST NOT wipe_and_return here, as heap->lj must remain intact */
        }
 
        DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
 
        /* not caught by current thread, thread terminates (yield error to resumer);
         * note that this may cause a cascade if the resumer terminates with an uncaught
         * exception etc (this is OK, but needs careful testing)
         */
 
        DUK_ASSERT(thr->resumer != NULL);
        DUK_ASSERT(thr->resumer->callstack_top >= 2);  /* Ecmascript activation + Duktape.Thread.resume() activation */
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL &&
                   DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) &&
                   ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume);  /* Duktape.Thread.resume() */
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL &&
                   DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2)));  /* an Ecmascript function */
 
        resumer = thr->resumer;
 
        /* reset longjmp */
 
        DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW);  /* already set */
        /* lj.value1 already set */
 
        duk_hthread_terminate(thr);  /* updates thread state, minimizes its allocations */
        DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED);
 
        thr->resumer = NULL;
        resumer->state = DUK_HTHREAD_STATE_RUNNING;
        DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
        thr = resumer;
        goto check_longjmp;
    }
 
    case DUK_LJ_TYPE_BREAK:  /* pseudotypes, not used in actual longjmps */
    case DUK_LJ_TYPE_CONTINUE:
    case DUK_LJ_TYPE_RETURN:
    case DUK_LJ_TYPE_NORMAL:
    default: {
        /* should never happen, but be robust */
        DUK_D(DUK_DPRINT("caught unknown longjmp type %ld, treat as internal error", (long) thr->heap->lj.type));
        goto convert_to_internal_error;
    }
 
    }  /* end switch */
 
    DUK_UNREACHABLE();
 
 wipe_and_return:
    /* this is not strictly necessary, but helps debugging */
    thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN;

Referenced by duk__handle_executor_error().

◆ duk__handle_oldenv_for_call()

DUK_LOCAL void duk__handle_oldenv_for_call	(	duk_hthread *	thr,
		duk_hobject *	func,
		duk_activation *	act )

Definition at line 55507 of file duktape-1.8.0/src/duktape.c.

                                                                {
    duk_tval *tv;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(act != NULL);
    DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV(func));
    DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func));
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr));
    if (tv) {
        DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
        DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv)));
        act->lex_env = DUK_TVAL_GET_OBJECT(tv);

Referenced by duk_handle_ecma_call_setup().

◆ duk__handle_put_array_length()

DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 50543 of file duktape-1.8.0/src/duktape.c.

                                                                        : update length (done by caller)"));
 
        *out_result_len = target_len;
 
        if (target_len == new_len) {
            DUK_DDD(DUK_DDDPRINT("target_len matches new_len, return success"));
            return 1;
        }
        DUK_DDD(DUK_DDDPRINT("target_len does not match new_len (some entry prevented "
                             "full length adjustment), return error"));
        return 0;
    }
 
    DUK_UNREACHABLE();
}
 
/* XXX: is valstack top best place for argument? */
DUK_LOCAL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj) {
    duk_context *ctx = (duk_context *) thr;
    duk_propdesc desc;
    duk_uint32_t old_len;
    duk_uint32_t new_len;
    duk_uint32_t result_len;
    duk_tval *tv;
    duk_bool_t rc;
 
    DUK_DDD(DUK_DDDPRINT("handling a put operation to array 'length' exotic property, "
                         "new val: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(obj != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    DUK_ASSERT(duk_is_valid_index(ctx, -1));
 
    /*
     *  Get old and new length
     */
 
    old_len = duk__get_old_array_length(thr, obj, &desc);
    duk_dup(ctx, -1);  /* [in_val in_val] */
    new_len = duk__to_new_array_length_checked(thr);  /* -> [in_val] */
    DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) old_len, (long) new_len));
 
    /*
     *  Writability check
     */
 
    if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
        DUK_DDD(DUK_DDDPRINT("length is not writable, fail"));
        return 0;
    }
 
    /*
     *  New length not lower than old length => no changes needed
     *  (not even array allocation).
     */
 
    if (new_len >= old_len) {
        DUK_DDD(DUK_DDDPRINT("new length is higher than old length, just update length, no deletions"));
 
        DUK_ASSERT(desc.e_idx >= 0);
        DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx));
        tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        /* no decref needed for a number */
        DUK_TVAL_SET_FASTINT_U32(tv, new_len);
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        return 1;
    }
 
    DUK_DDD(DUK_DDDPRINT("new length is lower than old length, probably must delete entries"));
 
    /*
     *  New length lower than old length => delete elements, then
     *  update length.
     *
     *  Note: even though a bunch of elements have been deleted, the 'desc' is
     *  still valid as properties haven't been resized (and entries compacted).

Referenced by duk_hobject_putprop().

◆ duk__handle_put_array_length_smaller()

DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length_smaller	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_uint32_t	old_len,
		duk_uint32_t	new_len,
		duk_bool_t	force_flag,
		duk_uint32_t *	out_result_len )

Definition at line 50360 of file duktape-1.8.0/src/duktape.c.

                                 {
        DUK_ERROR_RANGE(thr, DUK_STR_INVALID_ARRAY_LENGTH);
    }
    duk_pop(ctx);
    return res;
}
 
/* Delete elements required by a smaller length, taking into account
 * potentially non-configurable elements.  Returns non-zero if all
 * elements could be deleted, and zero if all or some elements could
 * not be deleted.  Also writes final "target length" to 'out_result_len'.
 * This is the length value that should go into the 'length' property
 * (must be set by the caller).  Never throws an error.
 */
DUK_LOCAL
duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr,
                                                duk_hobject *obj,
                                                duk_uint32_t old_len,
                                                duk_uint32_t new_len,
                                                duk_bool_t force_flag,
                                                duk_uint32_t *out_result_len) {
    duk_uint32_t target_len;
    duk_uint_fast32_t i;
    duk_uint32_t arr_idx;
    duk_hstring *key;
    duk_tval *tv;
    duk_bool_t rc;
 
    DUK_DDD(DUK_DDDPRINT("new array length smaller than old (%ld -> %ld), "
                         "probably need to remove elements",
                         (long) old_len, (long) new_len));
 
    /*
     *  New length is smaller than old length, need to delete properties above
     *  the new length.
     *
     *  If array part exists, this is straightforward: array entries cannot
     *  be non-configurable so this is guaranteed to work.
     *
     *  If array part does not exist, array-indexed values are scattered
     *  in the entry part, and some may not be configurable (preventing length
     *  from becoming lower than their index + 1).  To handle the algorithm
     *  in E5 Section 15.4.5.1, step l correctly, we scan the entire property
     *  set twice.
     */
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(new_len < old_len);
    DUK_ASSERT(out_result_len != NULL);
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
        /*
         *  All defined array-indexed properties are in the array part
         *  (we assume the array part is comprehensive), and all array
         *  entries are writable, configurable, and enumerable.  Thus,
         *  nothing can prevent array entries from being deleted.
         */
 
        DUK_DDD(DUK_DDDPRINT("have array part, easy case"));
 
        if (old_len < DUK_HOBJECT_GET_ASIZE(obj)) {
            /* XXX: assertion that entries >= old_len are already unused */
            i = old_len;
        } else {
            i = DUK_HOBJECT_GET_ASIZE(obj);
        }
        DUK_ASSERT(i <= DUK_HOBJECT_GET_ASIZE(obj));
 
        while (i > new_len) {
            i--;
            tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
            DUK_TVAL_SET_UNUSED_UPDREF(thr, tv);  /* side effects */
        }
 
        *out_result_len = new_len;
        return 1;
    } else {
        /*
         *  Entries part is a bit more complex
         */
 
        /* Stage 1: find highest preventing non-configurable entry (if any).
         * When forcing, ignore non-configurability.
         */
 
        DUK_DDD(DUK_DDDPRINT("no array part, slow case"));
 
        DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 1: find target_len "
                             "(highest preventing non-configurable entry (if any))"));
 
        target_len = new_len;
        if (force_flag) {
            DUK_DDD(DUK_DDDPRINT("array length write, no array part; force flag -> skip stage 1"));
            goto skip_stage1;
        }
        for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
            key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
            if (!key) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i));
                continue;
            }
            if (!DUK_HSTRING_HAS_ARRIDX(key)) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i));
                continue;
            }
 
            DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key));  /* XXX: macro checks for array index flag, which is unnecessary here */
            arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
            DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);
            DUK_ASSERT(arr_idx < old_len);  /* consistency requires this */
 
            if (arr_idx < new_len) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below new_len",
                                     (long) i, (long) arr_idx));
                continue;
            }
            if (DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i)) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is a relevant array index %ld, but configurable",
                                     (long) i, (long) arr_idx));
                continue;
            }
 
            /* relevant array index is non-configurable, blocks write */
            if (arr_idx >= target_len) {
                DUK_DDD(DUK_DDDPRINT("entry at index %ld has arr_idx %ld, is not configurable, "
                                     "update target_len %ld -> %ld",
                                     (long) i, (long) arr_idx, (long) target_len,
                                     (long) (arr_idx + 1)));
                target_len = arr_idx + 1;
            }
        }
     skip_stage1:
 
        /* stage 2: delete configurable entries above target length */
 
        DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld, target_len=%ld",
                             (long) old_len, (long) new_len, (long) target_len));
 
        DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 2: remove "
                             "entries >= target_len"));
 
        for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
            key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
            if (!key) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i));
                continue;
            }
            if (!DUK_HSTRING_HAS_ARRIDX(key)) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i));
                continue;
            }
 
            DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key));  /* XXX: macro checks for array index flag, which is unnecessary here */
            arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
            DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);
            DUK_ASSERT(arr_idx < old_len);  /* consistency requires this */
 
            if (arr_idx < target_len) {
                DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below target_len",
                                     (long) i, (long) arr_idx));
                continue;
            }
            DUK_ASSERT(force_flag || DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i));  /* stage 1 guarantees */
 
            DUK_DDD(DUK_DDDPRINT("delete entry index %ld: key is array index %ld",
                                 (long) i, (long) arr_idx));
 
            /*
             *  Slow delete, but we don't care as we're already in a very slow path.
             *  The delete always succeeds: key has no exotic behavior, property
             *  is configurable, and no resize occurs.
             */
            rc = duk_hobject_delprop_raw(thr, obj, key, force_flag ? DUK_DELPROP_FLAG_FORCE : 0);
            DUK_UNREF(rc);
            DUK_ASSERT(rc != 0);
        }
 

Referenced by duk_hobject_define_property_helper().

◆ duk__handle_return()

DUK_LOCAL duk_small_uint_t duk__handle_return	(	duk_hthread *	thr,
		duk_hthread *	entry_thread,
		duk_size_t	entry_callstack_top )

Definition at line 66876 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_tval *tv1;
    duk_tval *tv2;
    duk_hthread *resumer;
    duk_catcher *cat;
    duk_size_t new_cat_top;
    duk_size_t orig_callstack_index;
 
    /* We can directly access value stack here. */
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(entry_thread != NULL);
    DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom);
    tv1 = thr->valstack_top - 1;
    DUK_TVAL_CHKFAST_INPLACE(tv1);  /* fastint downgrade check for return values */
 
    /*
     *  Four possible outcomes:
     *
     *    1. A 'finally' in the same function catches the 'return'.
     *       It may continue to propagate when 'finally' is finished,
     *       or it may be neutralized by 'finally' (both handled by
     *       ENDFIN).
     *
     *    2. The return happens at the entry level of the bytecode
     *       executor, so return from the executor (in C stack).
     *
     *    3. There is a calling (Ecmascript) activation in the call
     *       stack => return to it, in the same executor instance.
     *
     *    4. There is no calling activation, and the thread is
     *       terminated.  There is always a resumer in this case,
     *       which gets the return value similarly to a 'yield'
     *       (except that the current thread can no longer be
     *       resumed).
     */
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->callstack_top >= 1);
    DUK_ASSERT(thr->catchstack != NULL);
 
    /* XXX: does not work if thr->catchstack is NULL */
    /* XXX: does not work if thr->catchstack is allocated but lowest pointer */
 
    cat = thr->catchstack + thr->catchstack_top - 1;  /* may be < thr->catchstack initially */
    DUK_ASSERT(thr->callstack_top > 0);  /* ensures callstack_top - 1 >= 0 */
    orig_callstack_index = thr->callstack_top - 1;
 
    while (cat >= thr->catchstack) {
        if (cat->callstack_index != orig_callstack_index) {
            break;
        }
        if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF &&
            DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
            duk_size_t cat_idx;
 
            cat_idx = (duk_size_t) (cat - thr->catchstack);  /* get before side effects */
 
            DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom);
            duk__handle_finally(thr, cat_idx, thr->valstack_top - 1, DUK_LJ_TYPE_RETURN);
 
            DUK_DD(DUK_DDPRINT("-> return caught by 'finally', restart execution"));
            return DUK__RETHAND_RESTART;
        }
        cat--;
    }
    /* If out of catchstack, cat = thr->catchstack - 1;
     * new_cat_top will be 0 in that case.
     */
    new_cat_top = (duk_size_t) ((cat + 1) - thr->catchstack);
    cat = NULL;  /* avoid referencing, invalidated */
 
    DUK_DDD(DUK_DDDPRINT("no catcher in catch stack, return to calling activation / yield"));
 
    if (thr == entry_thread &&
        thr->callstack_top == entry_callstack_top) {
        /* Return to the bytecode executor caller which will unwind stacks.
         * Return value is already on the stack top: [ ... retval ].
         */
 
        /* XXX: could unwind catchstack here, so that call handling
         * didn't need to do that?
         */
        DUK_DDD(DUK_DDDPRINT("-> return propagated up to entry level, exit bytecode executor"));
        return DUK__RETHAND_FINISHED;
    }
 
    if (thr->callstack_top >= 2) {
        /* There is a caller; it MUST be an Ecmascript caller (otherwise it would
         * match entry level check)
         */
 
        DUK_DDD(DUK_DDDPRINT("return to Ecmascript caller, idx_retval=%ld, lj_value1=%!T",
                             (long) (thr->callstack + thr->callstack_top - 2)->idx_retval,
                             (duk_tval *) &thr->heap->lj.value1));
 
        DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));   /* must be ecmascript */
 
        tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval;
        DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom);
        tv2 = thr->valstack_top - 1;
        DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2);  /* side effects */
 
        DUK_DDD(DUK_DDDPRINT("return value at idx_retval=%ld is %!T",
                             (long) (thr->callstack + thr->callstack_top - 2)->idx_retval,
                             (duk_tval *) (thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval)));
 
        duk_hthread_catchstack_unwind(thr, new_cat_top);  /* leave 'cat' as top catcher (also works if catchstack exhausted) */
        duk_hthread_callstack_unwind(thr, thr->callstack_top - 1);
        duk__reconfig_valstack_ecma_return(thr, thr->callstack_top - 1);
 
        DUK_DD(DUK_DDPRINT("-> return not intercepted, restart execution in caller"));
        return DUK__RETHAND_RESTART;
    }
 
    DUK_DD(DUK_DDPRINT("no calling activation, thread finishes (similar to yield)"));
 
    DUK_ASSERT(thr->resumer != NULL);
    DUK_ASSERT(thr->resumer->callstack_top >= 2);  /* Ecmascript activation + Duktape.Thread.resume() activation */
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL &&
               DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) &&
               ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume);  /* Duktape.Thread.resume() */
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL &&
               DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2)));  /* an Ecmascript function */
    DUK_ASSERT_DISABLE((thr->resumer->callstack + thr->resumer->callstack_top - 2)->idx_retval >= 0);                /* unsigned */
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
    DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
 
    resumer = thr->resumer;
 

◆ duk__handle_safe_call_error()

DUK_LOCAL void duk__handle_safe_call_error	(	duk_hthread *	thr,
		duk_idx_t	idx_retbase,
		duk_idx_t	num_stack_rets,
		duk_size_t	entry_valstack_bottom_index,
		duk_size_t	entry_callstack_top,
		duk_size_t	entry_catchstack_top,
		duk_jmpbuf *	old_jmpbuf_ptr )

Definition at line 57133 of file duktape-1.8.0/src/duktape.c.

                               {
        DUK_ERROR_API(thr, "not enough stack values for safe_call rc");
    }
 
    DUK_ASSERT(thr->catchstack_top == entry_catchstack_top);  /* no need to unwind */
    DUK_ASSERT(thr->callstack_top == entry_callstack_top);
 
    duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, rc);
    return;
 
 thread_state_error:
    DUK_ERROR_FMT1(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for safe_call (%ld)", (long) thr->state);
    DUK_UNREACHABLE();
}
 
DUK_LOCAL void duk__handle_safe_call_error(duk_hthread *thr,
                                           duk_idx_t idx_retbase,
                                           duk_idx_t num_stack_rets,
                                           duk_size_t entry_valstack_bottom_index,
                                           duk_size_t entry_callstack_top,
                                           duk_size_t entry_catchstack_top,
                                           duk_jmpbuf *old_jmpbuf_ptr) {
    duk_context *ctx;
 
    DUK_ASSERT(thr != NULL);
    ctx = (duk_context *) thr;
    DUK_ASSERT_CTX_VALID(ctx);
 
    /*
     *  Error during call.  The error value is at heap->lj.value1.
     *
     *  The very first thing we do is restore the previous setjmp catcher.
     *  This means that any error in error handling will propagate outwards
     *  instead of causing a setjmp() re-entry above.
     */
 
    DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_safe_call()"));
 
    /* Other longjmp types are handled by executor before propagating
     * the error here.
     */
    DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW);
    DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
    DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
 
    /* Note: either pointer may be NULL (at entry), so don't assert. */
    thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
 
    DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
    DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
    duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
    duk_hthread_catchstack_shrink_check(thr);
    duk_hthread_callstack_unwind(thr, entry_callstack_top);
    duk_hthread_callstack_shrink_check(thr);
    thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
 
    /* [ ... | (crud) ] */
 
    /* XXX: space in valstack?  see discussion in duk_handle_call_xxx(). */
    duk_push_tval(ctx, &thr->heap->lj.value1);
 
    /* [ ... | (crud) errobj ] */
 
    DUK_ASSERT(duk_get_top(ctx) >= 1);  /* at least errobj must be on stack */
 
    /* check that the valstack has space for the final amount and any
     * intermediate space needed; this is unoptimal but should be safe
     */

◆ duk__handle_safe_call_inner()

DUK_LOCAL void duk__handle_safe_call_inner	(	duk_hthread *	thr,
		duk_safe_call_function	func,
		duk_idx_t	idx_retbase,
		duk_idx_t	num_stack_rets,
		duk_size_t	entry_valstack_bottom_index,
		duk_size_t	entry_callstack_top,
		duk_size_t	entry_catchstack_top )

Definition at line 57024 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    duk_context *ctx;
    duk_ret_t rc;
 
    DUK_ASSERT(thr != NULL);
    ctx = (duk_context *) thr;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(entry_valstack_bottom_index);
    DUK_UNREF(entry_callstack_top);
    DUK_UNREF(entry_catchstack_top);
 
    /*
     *  Thread state check and book-keeping.
     */
 
    if (thr == thr->heap->curr_thread) {
        /* same thread */
        if (thr->state != DUK_HTHREAD_STATE_RUNNING) {
            /* should actually never happen, but check anyway */
            goto thread_state_error;
        }
    } else {
        /* different thread */
        DUK_ASSERT(thr->heap->curr_thread == NULL ||
                   thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING);
        if (thr->state != DUK_HTHREAD_STATE_INACTIVE) {
            goto thread_state_error;
        }
        DUK_HEAP_SWITCH_THREAD(thr->heap, thr);
        thr->state = DUK_HTHREAD_STATE_RUNNING;
 
        /* Note: multiple threads may be simultaneously in the RUNNING
         * state, but not in the same "resume chain".
         */
    }
 
    DUK_ASSERT(thr->heap->curr_thread == thr);
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
 
    /*
     *  Recursion limit check.
     *
     *  Note: there is no need for an "ignore recursion limit" flag
     *  for duk_handle_safe_call now.
     */
 
    DUK_ASSERT(thr->heap->call_recursion_depth >= 0);
    DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit);
    if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) {
        /* XXX: error message is a bit misleading: we reached a recursion
         * limit which is also essentially the same as a C callstack limit
         * (except perhaps with some relaxed threading assumptions).
         */
        DUK_ERROR_RANGE(thr, DUK_STR_C_CALLSTACK_LIMIT);
    }
    thr->heap->call_recursion_depth++;
 
    /*
     *  Valstack spare check
     */
 
    duk_require_stack(ctx, 0);  /* internal spare */
 
    /*
     *  Make the C call
     */
 
    rc = func(ctx);
 
    DUK_DDD(DUK_DDDPRINT("safe_call, func rc=%ld", (long) rc));
 
    /*
     *  Valstack manipulation for results.
     */
 
    /* we're running inside the caller's activation, so no change in call/catch stack or valstack bottom */
    DUK_ASSERT(thr->callstack_top == entry_callstack_top);
    DUK_ASSERT(thr->catchstack_top == entry_catchstack_top);
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT((duk_size_t) (thr->valstack_bottom - thr->valstack) == entry_valstack_bottom_index);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
    if (rc < 0) {
        duk_error_throw_from_negative_rc(thr, rc);

◆ duk__handle_safe_call_shared()

DUK_LOCAL void duk__handle_safe_call_shared	(	duk_hthread *	thr,
		duk_idx_t	idx_retbase,
		duk_idx_t	num_stack_rets,
		duk_int_t	entry_call_recursion_depth,
		duk_hthread *	entry_curr_thread,
		duk_uint_fast8_t	entry_thread_state,
		duk_instr_t **	entry_ptr_curr_pc )

Definition at line 57204 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_context *ctx;
 
    DUK_ASSERT(thr != NULL);
    ctx = (duk_context *) thr;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(ctx);
    DUK_UNREF(idx_retbase);
    DUK_UNREF(num_stack_rets);
 
    /* Restore entry thread executor curr_pc stack frame pointer. */
    thr->ptr_curr_pc = entry_ptr_curr_pc;
 
    /* XXX: because we unwind stacks above, thr->heap->curr_thread is at
     * risk of pointing to an already freed thread.  This was indeed the
     * case in test-bug-multithread-valgrind.c, until duk_handle_call()
     * was fixed to restore thr->heap->curr_thread before rethrowing an
     * uncaught error.
     */
    DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread);  /* may be NULL */
    thr->state = (duk_uint8_t) entry_thread_state;
 

◆ duk__handle_temproot()

DUK_LOCAL void duk__handle_temproot	(	duk_heap *	heap,
		duk_heaphdr *	hdr )

Definition at line 42548 of file duktape-1.8.0/src/duktape.c.

42563 {

◆ duk__handle_yield()

DUK_LOCAL void duk__handle_yield	(	duk_hthread *	thr,
		duk_hthread *	resumer,
		duk_size_t	act_idx,
		duk_tval *	tv_val_unstable )

Definition at line 66392 of file duktape-1.8.0/src/duktape.c.

66409 {

66410 duk_tval *tv1;

◆ duk__hexval()

DUK_LOCAL duk_codepoint_t duk__hexval	(	duk_lexer_ctx *	lex_ctx,
		duk_codepoint_t	x )

Definition at line 73912 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    DUK_ASSERT_DISABLE(pt->offset >= 0);  /* unsigned */
    DUK_ASSERT(pt->line >= 1);
    lex_ctx->input_offset = pt->offset;
    lex_ctx->input_line = pt->line;
    duk__init_lexer_window(lex_ctx);
}
 
/*
 *  Lexing helpers
 */
 
/* numeric value of a hex digit (also covers octal and decimal digits) */

References duk__init_lexer_window(), DUK_ASSERT, DUK_ASSERT_DISABLE, duk_lexer_ctx::input_line, duk_lexer_ctx::input_offset, duk_lexer_point::line, and duk_lexer_point::offset.

Referenced by duk_lexer_parse_js_input_element().

◆ duk__hobject_pc2line_query_raw()

DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw	(	duk_hthread *	thr,
		duk_hbuffer_fixed *	buf,
		duk_uint_fast32_t	pc )

Definition at line 47300 of file duktape-1.8.0/src/duktape.c.

                                            : pc_limit=%ld, length=%ld, %lf bits/opcode --> %!ixT",
                         (long) length, (long) new_size, (double) new_size * 8.0 / (double) length,
                         (duk_tval *) duk_get_tval(ctx, -1)));
}
 
/* PC is unsigned.  If caller does PC arithmetic and gets a negative result,
 * it will map to a large PC which is out of bounds and causes a zero to be
 * returned.
 */
DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw(duk_hthread *thr, duk_hbuffer_fixed *buf, duk_uint_fast32_t pc) {
    duk_bitdecoder_ctx bd_ctx_alloc;
    duk_bitdecoder_ctx *bd_ctx = &bd_ctx_alloc;
    duk_uint32_t *hdr;
    duk_uint_fast32_t start_offset;
    duk_uint_fast32_t pc_limit;
    duk_uint_fast32_t hdr_index;
    duk_uint_fast32_t pc_base;
    duk_uint_fast32_t n;
    duk_uint_fast32_t curr_line;
 
    DUK_ASSERT(buf != NULL);
    DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) buf));
    DUK_UNREF(thr);
 
    /*
     *  Use the index in the header to find the right starting point
     */
 
    hdr_index = pc / DUK_PC2LINE_SKIP;
    pc_base = hdr_index * DUK_PC2LINE_SKIP;
    n = pc - pc_base;
 
    if (DUK_HBUFFER_FIXED_GET_SIZE(buf) <= sizeof(duk_uint32_t)) {
        DUK_DD(DUK_DDPRINT("pc2line lookup failed: buffer is smaller than minimal header"));
        goto error;
    }
 
    hdr = (duk_uint32_t *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf);
    pc_limit = hdr[0];
    if (pc >= pc_limit) {
        /* Note: pc is unsigned and cannot be negative */
        DUK_DD(DUK_DDPRINT("pc2line lookup failed: pc out of bounds (pc=%ld, limit=%ld)",
                           (long) pc, (long) pc_limit));
        goto error;
    }
 
    curr_line = hdr[1 + hdr_index * 2];
    start_offset = hdr[1 + hdr_index * 2 + 1];
    if ((duk_size_t) start_offset > DUK_HBUFFER_FIXED_GET_SIZE(buf)) {
        DUK_DD(DUK_DDPRINT("pc2line lookup failed: start_offset out of bounds (start_offset=%ld, buffer_size=%ld)",
                           (long) start_offset, (long) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) buf)));
        goto error;
    }
 
    /*
     *  Iterate the bitstream (line diffs) until PC is reached
     */
 
    DUK_MEMZERO(bd_ctx, sizeof(*bd_ctx));
    bd_ctx->data = ((duk_uint8_t *) hdr) + start_offset;
    bd_ctx->length = (duk_size_t) (DUK_HBUFFER_FIXED_GET_SIZE(buf) - start_offset);
 
#if 0
    DUK_DDD(DUK_DDDPRINT("pc2line lookup: pc=%ld -> hdr_index=%ld, pc_base=%ld, n=%ld, start_offset=%ld",
                         (long) pc, (long) hdr_index, (long) pc_base, (long) n, (long) start_offset));
#endif
 
    while (n > 0) {
#if 0
        DUK_DDD(DUK_DDDPRINT("lookup: n=%ld, curr_line=%ld", (long) n, (long) curr_line));
#endif
 
        if (duk_bd_decode_flag(bd_ctx)) {
            if (duk_bd_decode_flag(bd_ctx)) {
                if (duk_bd_decode_flag(bd_ctx)) {
                    /* 1 1 1 <32 bits> */
                    duk_uint_fast32_t t;
                    t = duk_bd_decode(bd_ctx, 16);  /* workaround: max nbits = 24 now */
                    t = (t << 16) + duk_bd_decode(bd_ctx, 16);
                    curr_line = t;
                } else {
                    /* 1 1 0 <8 bits> */
                    duk_uint_fast32_t t;
                    t = duk_bd_decode(bd_ctx, 8);
                    curr_line = curr_line + t - 0x80;
                }
            } else {
                /* 1 0 <2 bits> */
                duk_uint_fast32_t t;

◆ duk__hstring_is_eval_or_arguments()

DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments	(	duk_compiler_ctx *	comp_ctx,
		duk_hstring *	h )

Definition at line 58110 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    DUK_ASSERT(comp_ctx != NULL);
    DUK_ASSERT(comp_ctx->recursion_depth >= 0);

References DUK_ASSERT, NULL, duk_compiler_ctx::recursion_depth, and duk_compiler_ctx::recursion_limit.

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__parse_func_body().

◆ duk__hstring_is_eval_or_arguments_in_strict_mode()

DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments_in_strict_mode	(	duk_compiler_ctx *	comp_ctx,
		duk_hstring *	h )

Definition at line 58116 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_var_decl().

◆ duk__inc_data_inner_refcounts()

DUK_LOCAL void duk__inc_data_inner_refcounts	(	duk_hthread *	thr,
		duk_hcompiledfunction *	f )

Definition at line 71558 of file duktape-1.8.0/src/duktape.c.

         :
 *
 *   * Order of internal properties should match frequency of use, since the
 *     properties will be linearly scanned on lookup (functions usually don't
 *     have enough properties to warrant a hash part).
 *
 *   * The created closure is independent of its template; they do share the
 *     same 'data' buffer object, but the template object itself can be freed
 *     even if the closure object remains reachable.
 */
 
DUK_LOCAL void duk__inc_data_inner_refcounts(duk_hthread *thr, duk_hcompiledfunction *f) {
    duk_tval *tv, *tv_end;
    duk_hobject **funcs, **funcs_end;
 
    /* If function creation fails due to out-of-memory, the data buffer
     * pointer may be NULL in some cases.  That's actually possible for
     * GC code, but shouldn't be possible here because the incomplete
     * function will be unwound from the value stack and never instantiated.
     */

References DUK_ASSERT, DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE, DUK_HCOMPILEDFUNCTION_GET_CONSTS_END, DUK_HCOMPILEDFUNCTION_GET_DATA, DUK_TVAL_INCREF, DUK_UNREF, funcs, duk_hthread::heap, and NULL.

◆ duk__init_func_valstack_slots()

DUK_LOCAL_DECL void duk__init_func_valstack_slots ( duk_compiler_ctx * comp_ctx )

Definition at line 58203 of file duktape-1.8.0/src/duktape.c.

                                                                                       {
    duk__advance_helper(comp_ctx, expect);
}
 
/* advance, whatever the current token is; parse next token in regexp context */
DUK_LOCAL void duk__advance(duk_compiler_ctx *comp_ctx) {
    duk__advance_helper(comp_ctx, -1);
}
 
/*
 *  Helpers for duk_compiler_func.
 */
 
/* init function state: inits valstack allocations */
DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) {
    duk_compiler_func *func = &comp_ctx->curr_func;
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_idx_t entry_top;
 
    entry_top = duk_get_top(ctx);
 
    DUK_MEMZERO(func, sizeof(*func));  /* intentional overlap with earlier memzero */
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    func->h_name = NULL;
    func->h_consts = NULL;
    func->h_funcs = NULL;
    func->h_decls = NULL;
    func->h_labelnames = NULL;
    func->h_labelinfos = NULL;
    func->h_argnames = NULL;
    func->h_varmap = NULL;
#endif
 
    duk_require_stack(ctx, DUK__FUNCTION_INIT_REQUIRE_SLOTS);
 
    DUK_BW_INIT_PUSHBUF(thr, &func->bw_code, DUK__BC_INITIAL_INSTS * sizeof(duk_compiler_instr));
    /* code_idx = entry_top + 0 */
 
    duk_push_array(ctx);
    func->consts_idx = entry_top + 1;
    func->h_consts = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 1);
    DUK_ASSERT(func->h_consts != NULL);
 
    duk_push_array(ctx);
    func->funcs_idx = entry_top + 2;
    func->h_funcs = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 2);
    DUK_ASSERT(func->h_funcs != NULL);
    DUK_ASSERT(func->fnum_next == 0);
 
    duk_push_array(ctx);
    func->decls_idx = entry_top + 3;
    func->h_decls = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 3);
    DUK_ASSERT(func->h_decls != NULL);
 
    duk_push_array(ctx);
    func->labelnames_idx = entry_top + 4;
    func->h_labelnames = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 4);
    DUK_ASSERT(func->h_labelnames != NULL);

◆ duk__init_heap_strings()

DUK_LOCAL duk_bool_t duk__init_heap_strings ( duk_heap * heap )

Definition at line 41383 of file duktape-1.8.0/src/duktape.c.

                                                                                {
        duk_uint32_t hash;
        const duk_hstring *h;
        h = duk_rom_strings[i];
        DUK_ASSERT(h != NULL);
        hash = duk_heap_hashstring(heap, (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
        DUK_DD(DUK_DDPRINT("duk_rom_strings[%d] -> hash 0x%08lx, computed 0x%08lx",
                           (int) i, (unsigned long) DUK_HSTRING_GET_HASH(h), (unsigned long) hash));
        DUK_ASSERT(hash == (duk_uint32_t) DUK_HSTRING_GET_HASH(h));
    }
#endif
    return 1;
}
#else  /* DUK_USE_ROM_STRINGS */
DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) {
    duk_bitdecoder_ctx bd_ctx;
    duk_bitdecoder_ctx *bd = &bd_ctx;  /* convenience */
    duk_small_uint_t i, j;
 
    DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
    bd->data = (const duk_uint8_t *) duk_strings_data;
    bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH;
 
    for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
        duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN];
        duk_hstring *h;
        duk_small_uint_t len;
        duk_small_uint_t mode;
        duk_small_uint_t t;
 
        len = duk_bd_decode(bd, 5);
        mode = 32;  /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */
        for (j = 0; j < len; j++) {
            t = duk_bd_decode(bd, 5);
            if (t < DUK__BITPACK_LETTER_LIMIT) {
                t = t + DUK_ASC_UC_A + mode;
            } else if (t == DUK__BITPACK_UNDERSCORE) {
                t = DUK_ASC_UNDERSCORE;
            } else if (t == DUK__BITPACK_FF) {
                /* Internal keys are prefixed with 0xFF in the stringtable
                 * (which makes them invalid UTF-8 on purpose).
                 */
                t = 0xff;
            } else if (t == DUK__BITPACK_SWITCH1) {
                t = duk_bd_decode(bd, 5);
                DUK_ASSERT_DISABLE(t >= 0);  /* unsigned */
                DUK_ASSERT(t <= 25);
                t = t + DUK_ASC_UC_A + (mode ^ 32);
            } else if (t == DUK__BITPACK_SWITCH) {
                mode = mode ^ 32;
                t = duk_bd_decode(bd, 5);
                DUK_ASSERT_DISABLE(t >= 0);
                DUK_ASSERT(t <= 25);
                t = t + DUK_ASC_UC_A + mode;
            } else if (t == DUK__BITPACK_SEVENBIT) {
                t = duk_bd_decode(bd, 7);
            }
            tmp[j] = (duk_uint8_t) t;
        }
 
        /* No need to length check string: it will never exceed even
         * the 16-bit length maximum.
         */
        DUK_ASSERT(len <= 0xffffUL);
        DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i));
        h = duk_heap_string_intern(heap, tmp, len);
        if (!h) {
            goto error;
        }
        DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) h));
 
        /* Special flags checks.  Since these strings are always
         * reachable and a string cannot appear twice in the string
         * table, there's no need to check/set these flags elsewhere.
         * The 'internal' flag is set by string intern code.
         */
        if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) {
            DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h);
        }
        if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) {
            DUK_HSTRING_SET_RESERVED_WORD(h);
            if (i >= DUK_STRIDX_START_STRICT_RESERVED) {
                DUK_HSTRING_SET_STRICT_RESERVED_WORD(h);
            }
        }
 
        DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h));
 

◆ duk__init_heap_thread()

DUK_LOCAL duk_bool_t duk__init_heap_thread ( duk_heap * heap )

Definition at line 41476 of file duktape-1.8.0/src/duktape.c.

      :
    return 0;
}
#endif  /* DUK_USE_ROM_STRINGS */
 
DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap) {
    duk_hthread *thr;
 
    DUK_DD(DUK_DDPRINT("heap init: alloc heap thread"));
    thr = duk_hthread_alloc(heap,
                            DUK_HOBJECT_FLAG_EXTENSIBLE |
                            DUK_HOBJECT_FLAG_THREAD |
                            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD));
    if (!thr) {
        DUK_D(DUK_DPRINT("failed to alloc heap_thread"));
        return 0;
    }
    thr->state = DUK_HTHREAD_STATE_INACTIVE;
#if defined(DUK_USE_ROM_STRINGS)
    /* No strs[] pointer. */
#else  /* DUK_USE_ROM_STRINGS */
#if defined(DUK_USE_HEAPPTR16)
    thr->strs16 = heap->strs16;
#else
    thr->strs = heap->strs;
#endif
#endif  /* DUK_USE_ROM_STRINGS */
 

◆ duk__init_lexer_window()

DUK_LOCAL void duk__init_lexer_window ( duk_lexer_ctx * lex_ctx )

Definition at line 73661 of file duktape-1.8.0/src/duktape.c.

References duk_lexer_ctx::buffer, duk__fill_lexer_buffer(), DUK_MEMMOVE, and duk_lexer_ctx::window.

Referenced by duk__hexval().

◆ duk__init_object_parts()

DUK_LOCAL void duk__init_object_parts	(	duk_heap *	heap,
		duk_hobject *	obj,
		duk_uint_t	hobject_flags )

Definition at line 46198 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    DUK_HOBJECT_SET_PROPS(heap, obj, NULL);
#endif
 
    /* XXX: macro? sets both heaphdr and object flags */
    obj->hdr.h_flags = hobject_flags;
    DUK_HEAPHDR_SET_TYPE(&obj->hdr, DUK_HTYPE_OBJECT);  /* also goes into flags */
 

References DUK_ASSERT_HEAPHDR_LINKS, DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED, DUK_HEAPHDR_SET_NEXT, DUK_HEAPHDR_SET_PREV, DUK_HEAPHDR_SET_TYPE, DUK_HOBJECT_SET_PROPS, DUK_HTYPE_OBJECT, duk_heaphdr::h_flags, duk_hobject::hdr, and NULL.

◆ duk__init_varmap_and_prologue_for_pass2()

DUK_LOCAL_DECL void duk__init_varmap_and_prologue_for_pass2	(	duk_compiler_ctx *	comp_ctx,
		duk_reg_t *	out_stmt_value_reg )

Definition at line 64521 of file duktape-1.8.0/src/duktape.c.

                                           :
 *
 *    - The 'arguments' binding, established only if no shadowing argument
 *      or function declaration exists.  We handle 'arguments' creation
 *      and binding through an explicit slow path environment record.
 *
 *    - The "name" binding for a named function expression.  This is also
 *      handled through an explicit slow path environment record.
 */
 
/* XXX: add support for variables to not be register bound always, to
 * handle cases with a very large number of variables?
 */
 
DUK_LOCAL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *h_name;
    duk_bool_t configurable_bindings;
    duk_uarridx_t num_args;
    duk_uarridx_t num_decls;
    duk_regconst_t rc_name;
    duk_small_uint_t declvar_flags;
    duk_uarridx_t i;
#ifdef DUK_USE_ASSERTIONS
    duk_idx_t entry_top;
#endif
 
#ifdef DUK_USE_ASSERTIONS
    entry_top = duk_get_top(ctx);
#endif
 
    /*
     *  Preliminaries
     */
 
    configurable_bindings = comp_ctx->curr_func.is_eval;
    DUK_DDD(DUK_DDDPRINT("configurable_bindings=%ld", (long) configurable_bindings));
 
    /* varmap is already in comp_ctx->curr_func.varmap_idx */
 
    /*
     *  Function formal arguments, always bound to registers
     *  (there's no support for shuffling them now).
     */
 
    num_args = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx);
    DUK_DDD(DUK_DDDPRINT("num_args=%ld", (long) num_args));
    /* XXX: check num_args */
 
    for (i = 0; i < num_args; i++) {
        duk_get_prop_index(ctx, comp_ctx->curr_func.argnames_idx, i);
        h_name = duk_get_hstring(ctx, -1);
        DUK_ASSERT(h_name != NULL);
 
        if (comp_ctx->curr_func.is_strict) {
            if (duk__hstring_is_eval_or_arguments(comp_ctx, h_name)) {
                DUK_DDD(DUK_DDDPRINT("arg named 'eval' or 'arguments' in strict mode -> SyntaxError"));
                goto error_argname;
            }
            duk_dup_top(ctx);
            if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
                DUK_DDD(DUK_DDDPRINT("duplicate arg name in strict mode -> SyntaxError"));
                goto error_argname;
            }
 
            /* Ensure argument name is not a reserved word in current
             * (final) strictness.  Formal argument parsing may not
             * catch reserved names if strictness changes during
             * parsing.
             *
             * We only need to do this in strict mode because non-strict
             * keyword are always detected in formal argument parsing.
             */
 
            if (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(h_name)) {
                goto error_argname;
            }
        }
 
        /* overwrite any previous binding of the same name; the effect is
         * that last argument of a certain name wins.
         */
 
        /* only functions can have arguments */
        DUK_ASSERT(comp_ctx->curr_func.is_function);
        duk_push_uarridx(ctx, i);  /* -> [ ... name index ] */
        duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* -> [ ... ] */
 
        /* no code needs to be emitted, the regs already have values */
    }
 
    /* use temp_next for tracking register allocations */
    DUK__SETTEMP_CHECKMAX(comp_ctx, (duk_reg_t) num_args);
 
    /*
     *  After arguments, allocate special registers (like shuffling temps)
     */
 
    if (out_stmt_value_reg) {
        *out_stmt_value_reg = DUK__ALLOCTEMP(comp_ctx);
    }
    if (comp_ctx->curr_func.needs_shuffle) {
        duk_reg_t shuffle_base = DUK__ALLOCTEMPS(comp_ctx, 3);
        comp_ctx->curr_func.shuffle1 = shuffle_base;
        comp_ctx->curr_func.shuffle2 = shuffle_base + 1;
        comp_ctx->curr_func.shuffle3 = shuffle_base + 2;
        DUK_D(DUK_DPRINT("shuffle registers needed by function, allocated: %ld %ld %ld",
                         (long) comp_ctx->curr_func.shuffle1,
                         (long) comp_ctx->curr_func.shuffle2,
                         (long) comp_ctx->curr_func.shuffle3));
    }
    if (comp_ctx->curr_func.temp_next > 0x100) {
        DUK_D(DUK_DPRINT("not enough 8-bit regs: temp_next=%ld", (long) comp_ctx->curr_func.temp_next));
        goto error_outofregs;
    }
 
    /*
     *  Function declarations
     */
 
    num_decls = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
    DUK_DDD(DUK_DDDPRINT("num_decls=%ld -> %!T",
                         (long) num_decls,
                         (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.decls_idx)));
    for (i = 0; i < num_decls; i += 2) {
        duk_int_t decl_type;
        duk_int_t fnum;
 
        duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1);  /* decl type */
        decl_type = duk_to_int(ctx, -1);
        fnum = decl_type >> 8;  /* XXX: macros */
        decl_type = decl_type & 0xff;
        duk_pop(ctx);
 
        if (decl_type != DUK_DECL_TYPE_FUNC) {
            continue;
        }
 
        duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i);  /* decl name */
 
        /* XXX: spilling */
        if (comp_ctx->curr_func.is_function) {
            duk_reg_t reg_bind;
            duk_dup_top(ctx);
            if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
                /* shadowed; update value */
                duk_dup_top(ctx);
                duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
                reg_bind = duk_to_int(ctx, -1);  /* [ ... name reg_bind ] */
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_CLOSURE,
                               (duk_regconst_t) reg_bind,
                               (duk_regconst_t) fnum);
            } else {
                /* function: always register bound */
                reg_bind = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_CLOSURE,
                               (duk_regconst_t) reg_bind,
                               (duk_regconst_t) fnum);
                duk_push_int(ctx, (duk_int_t) reg_bind);
            }
        } else {
            /* Function declaration for global/eval code is emitted even
             * for duplicates, because of E5 Section 10.5, step 5.e of
             * E5.1 (special behavior for variable bound to global object).
             *
             * DECLVAR will not re-declare a variable as such, but will
             * update the binding value.
             */
 
            duk_reg_t reg_temp = DUK__ALLOCTEMP(comp_ctx);
            duk_dup_top(ctx);
            rc_name = duk__getconst(comp_ctx);
            duk_push_null(ctx);
 
            duk__emit_a_bc(comp_ctx,
                           DUK_OP_CLOSURE,
                           (duk_regconst_t) reg_temp,
                           (duk_regconst_t) fnum);
 
            declvar_flags = DUK_PROPDESC_FLAG_WRITABLE |
                            DUK_PROPDESC_FLAG_ENUMERABLE |
                            DUK_BC_DECLVAR_FLAG_FUNC_DECL;
 
            if (configurable_bindings) {
                declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
            }
 
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_DECLVAR | DUK__EMIT_FLAG_NO_SHUFFLE_A,
                            (duk_regconst_t) declvar_flags /*flags*/,
                            rc_name /*name*/,
                            (duk_regconst_t) reg_temp /*value*/);
 
            DUK__SETTEMP(comp_ctx, reg_temp);  /* forget temp */
        }
 
        DUK_DDD(DUK_DDDPRINT("function declaration to varmap: %!T -> %!T",
                             (duk_tval *) duk_get_tval(ctx, -2),
                             (duk_tval *) duk_get_tval(ctx, -1)));
 
        duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);  /* [ ... name reg/null ] -> [ ... ] */
    }
 
    /*
     *  'arguments' binding is special; if a shadowing argument or
     *  function declaration exists, an arguments object will
     *  definitely not be needed, regardless of whether the identifier
     *  'arguments' is referenced inside the function body.
     */
 
    if (duk_has_prop_stridx(ctx, comp_ctx->curr_func.varmap_idx, DUK_STRIDX_LC_ARGUMENTS)) {
        DUK_DDD(DUK_DDDPRINT("'arguments' is shadowed by argument or function declaration "
                             "-> arguments object creation can be skipped"));
        comp_ctx->curr_func.is_arguments_shadowed = 1;
    }
 
    /*
     *  Variable declarations.
     *
     *  Unlike function declarations, variable declaration values don't get
     *  assigned on entry.  If a binding of the same name already exists, just
     *  ignore it silently.
     */
 
    for (i = 0; i < num_decls; i += 2) {
        duk_int_t decl_type;
 
        duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1);  /* decl type */
        decl_type = duk_to_int(ctx, -1);
        decl_type = decl_type & 0xff;
        duk_pop(ctx);
 
        if (decl_type != DUK_DECL_TYPE_VAR) {
            continue;
        }
 
        duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i);  /* decl name */
 
        if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
            /* shadowed, ignore */
        } else {
            duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i);  /* decl name */
            h_name = duk_get_hstring(ctx, -1);
            DUK_ASSERT(h_name != NULL);
 
            if (h_name == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) &&
                !comp_ctx->curr_func.is_arguments_shadowed) {
                /* E5 Section steps 7-8 */
                DUK_DDD(DUK_DDDPRINT("'arguments' not shadowed by a function declaration, "
                                     "but appears as a variable declaration -> treat as "
                                     "a no-op for variable declaration purposes"));
                duk_pop(ctx);
                continue;
            }
 
            /* XXX: spilling */
            if (comp_ctx->curr_func.is_function) {
                duk_reg_t reg_bind = DUK__ALLOCTEMP(comp_ctx);
                /* no need to init reg, it will be undefined on entry */
                duk_push_int(ctx, (duk_int_t) reg_bind);
            } else {
                duk_dup_top(ctx);
                rc_name = duk__getconst(comp_ctx);
                duk_push_null(ctx);
 
                declvar_flags = DUK_PROPDESC_FLAG_WRITABLE |
                                    DUK_PROPDESC_FLAG_ENUMERABLE |
                                DUK_BC_DECLVAR_FLAG_UNDEF_VALUE;
                if (configurable_bindings) {
                    declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
                }
 
                duk__emit_a_b_c(comp_ctx,
                                DUK_OP_DECLVAR | DUK__EMIT_FLAG_NO_SHUFFLE_A,
                                (duk_regconst_t) declvar_flags /*flags*/,
                                rc_name /*name*/,
                                (duk_regconst_t) 0 /*value*/);
            }
 
            duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);  /* [ ... name reg/null ] -> [ ... ] */
        }
    }
 
    /*
     *  Wrap up
     */
 

References duk_compiler_func::argnames_idx, duk_compiler_ctx::curr_func, duk_compiler_func::decls_idx, DUK__ALLOCTEMP, DUK__ALLOCTEMPS, duk__emit_a_b_c(), duk__emit_a_bc(), DUK__EMIT_FLAG_NO_SHUFFLE_A, duk__getconst(), duk__hstring_is_eval_or_arguments(), DUK__SETTEMP, DUK__SETTEMP_CHECKMAX, DUK_ASSERT, DUK_ASSERT_TOP, DUK_BC_DECLVAR_FLAG_FUNC_DECL, DUK_BC_DECLVAR_FLAG_UNDEF_VALUE, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DECL_TYPE_FUNC, DUK_DECL_TYPE_VAR, DUK_DPRINT, duk_dup_top(), DUK_ERROR_RANGE, DUK_ERROR_SYNTAX, duk_get_hstring(), duk_get_length(), duk_get_prop(), duk_get_prop_index(), duk_get_top(), duk_get_tval(), duk_has_prop(), duk_has_prop_stridx(), DUK_HSTRING_HAS_STRICT_RESERVED_WORD, DUK_HTHREAD_STRING_LC_ARGUMENTS, DUK_OP_CLOSURE, DUK_OP_DECLVAR, duk_pop(), DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, duk_push_int(), duk_push_null(), duk_push_uarridx, duk_put_prop(), DUK_STR_INVALID_ARG_NAME, DUK_STR_REG_LIMIT, DUK_STRIDX_LC_ARGUMENTS, duk_to_int(), DUK_UNREACHABLE, duk_compiler_func::is_arguments_shadowed, duk_compiler_func::is_eval, duk_compiler_func::is_function, duk_compiler_func::is_strict, duk_compiler_func::needs_shuffle, NULL, duk_compiler_func::shuffle1, duk_compiler_func::shuffle2, duk_compiler_func::shuffle3, duk_compiler_func::temp_next, duk_compiler_ctx::thr, and duk_compiler_func::varmap_idx.

Referenced by duk__parse_func_body().

◆ duk__initbuffer()

DUK_LOCAL void duk__initbuffer ( duk_lexer_ctx * lex_ctx )

Definition at line 73828 of file duktape-1.8.0/src/duktape.c.

                                                              {
    /* Call with count == DUK_LEXER_WINDOW_SIZE to fill buffer initially. */
    duk__advance_bytes(lex_ctx, DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint));  /* fill window */
}

◆ duk__inp_backtrack()

DUK_LOCAL const duk_uint8_t * duk__inp_backtrack	(	duk_re_matcher_ctx *	re_ctx,
		const duk_uint8_t **	sp,
		duk_uint_fast32_t	count )

Definition at line 78847 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__match_regexp().

◆ duk__inp_get_cp()

DUK_LOCAL duk_codepoint_t duk__inp_get_cp	(	duk_re_matcher_ctx *	re_ctx,
		const duk_uint8_t **	sp )

Definition at line 78839 of file duktape-1.8.0/src/duktape.c.

     :
    DUK_ERROR_INTERNAL_DEFMSG(thr);
    return NULL;  /* never here */

Referenced by duk__match_regexp().

◆ duk__inp_get_prev_cp()

DUK_LOCAL duk_codepoint_t duk__inp_get_prev_cp	(	duk_re_matcher_ctx *	re_ctx,
		const duk_uint8_t *	sp )

Definition at line 78852 of file duktape-1.8.0/src/duktape.c.

78856 {

References DUK_RE_FLAG_IGNORE_CASE, duk_unicode_decode_xutf8_checked(), duk_unicode_re_canonicalize_char(), duk_re_matcher_ctx::input, duk_re_matcher_ctx::input_end, duk_re_matcher_ctx::re_flags, and duk_re_matcher_ctx::thr.

◆ duk__insert_hstring_probe()

DUK_LOCAL void duk__insert_hstring_probe	(	duk_heap *	heap,
		duk_hstring **	entries,
		duk_uint32_t	size,
		duk_uint32_t *	p_used,
		duk_hstring *	h )

Definition at line 45498 of file duktape-1.8.0/src/duktape.c.

                            {
#if defined(DUK_USE_HEAPPTR16)
        if (heap->strtable16[i] != null16 && heap->strtable16[i] != deleted16) {
#else
        if (heap->strtable[i] != NULL && heap->strtable[i] != DUK__DELETED_MARKER(heap)) {
#endif
            res++;
        }
    }
    return res;
}
 
#if defined(DUK_USE_HEAPPTR16)
DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
#else
DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
#endif
    duk_uint32_t i;
    duk_uint32_t step;
#if defined(DUK_USE_HEAPPTR16)
    duk_uint16_t null16 = heap->heapptr_null16;
    duk_uint16_t deleted16 = heap->heapptr_deleted16;
#endif
 
    DUK_ASSERT(size > 0);
 
    i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size);
    step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(h));
    for (;;) {
#if defined(DUK_USE_HEAPPTR16)
        duk_uint16_t e16 = entries16[i];
#else
        duk_hstring *e = entries[i];
#endif
 
#if defined(DUK_USE_HEAPPTR16)
        /* XXX: could check for e16 == 0 because NULL is guaranteed to
         * encode to zero.
         */
        if (e16 == null16) {
#else
        if (e == NULL) {
#endif
            DUK_DDD(DUK_DDDPRINT("insert hit (null): %ld", (long) i));
#if defined(DUK_USE_HEAPPTR16)
            entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
#else
            entries[i] = h;
#endif
            (*p_used)++;
            break;
#if defined(DUK_USE_HEAPPTR16)
        } else if (e16 == deleted16) {
#else
        } else if (e == DUK__DELETED_MARKER(heap)) {

◆ duk__insert_i32()

DUK_LOCAL duk_uint32_t duk__insert_i32	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	offset,
		duk_int32_t	x )

Definition at line 77756 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__append_jump_offset().

◆ duk__insert_jump_entry()

DUK_LOCAL_DECL void duk__insert_jump_entry	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	jump_pc )

Definition at line 59295 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_int_t ret;
 
    ret = duk__get_current_pc(comp_ctx);  /* useful for patching jumps later */
    duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
    return ret;
}
 
/* Insert an empty jump in the middle of code emitted earlier.  This is
 * currently needed for compiling for-in.
 */
DUK_LOCAL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
#if defined(DUK_USE_PC2LINE)
    duk_int_t line;
#endif
    duk_compiler_instr *instr;
    duk_size_t offset;
 
    offset = jump_pc * sizeof(duk_compiler_instr),
    instr = (duk_compiler_instr *) (void *)
            DUK_BW_INSERT_ENSURE_AREA(comp_ctx->thr,
                                      &comp_ctx->curr_func.bw_code,
                                      offset,
                                      sizeof(duk_compiler_instr));
 

◆ duk__insert_jump_offset()

DUK_LOCAL duk_uint32_t duk__insert_jump_offset	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	offset,
		duk_int32_t	skip )

Definition at line 77800 of file duktape-1.8.0/src/duktape.c.

                                                                                                                  {
    DUK_BW_REMOVE_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, data_offset, data_length);
}
 
/*
 *  Insert a jump offset at 'offset' to complete an instruction
 *  (the jump offset is always the last component of an instruction).
 *  The 'skip' argument must be computed relative to 'offset',
 *  -without- taking into account the skip field being inserted.
 *
 *       ... A B C ins X Y Z ...   (ins may be a JUMP, SPLIT1/SPLIT2, etc)
 *   =>  ... A B C ins SKIP X Y Z
 *
 *  Computing the final (adjusted) skip value, which is relative to the

References duk_re_compiler_ctx::bw, DUK_BW_REMOVE_ENSURE_SLICE, and duk_re_compiler_ctx::thr.

Referenced by duk__parse_disjunction().

◆ duk__insert_slice()

DUK_LOCAL void duk__insert_slice	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	offset,
		duk_uint32_t	data_offset,
		duk_uint32_t	data_length )

Definition at line 77775 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ duk__insert_u32()

DUK_LOCAL duk_uint32_t duk__insert_u32	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	offset,
		duk_uint32_t	x )

Definition at line 77738 of file duktape-1.8.0/src/duktape.c.

77744 {

77745 if (x < 0) {

Referenced by duk__parse_disjunction().

◆ duk__internbuffer()

DUK_LOCAL void duk__internbuffer	(	duk_lexer_ctx *	lex_ctx,
		duk_idx_t	valstack_idx )

Definition at line 73866 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ duk__is_hex_digit()

DUK_LOCAL duk_bool_t duk__is_hex_digit ( duk_codepoint_t x )

Definition at line 73931 of file duktape-1.8.0/src/duktape.c.

                                         {
        t = duk_hex_dectab[x];
        if (DUK_LIKELY(t >= 0)) {
            return t;

References duk_hex_dectab, and DUK_LIKELY.

◆ duk__is_whole_get_int32()

DUK_LOCAL_DECL duk_bool_t duk__is_whole_get_int32	(	duk_double_t	x,
		duk_int32_t *	ival )

Definition at line 59552 of file duktape-1.8.0/src/duktape.c.

                                                                                              {
    duk_context *ctx = (duk_context *) comp_ctx->thr;
 
    dst->t = src->t;
    dst->op = src->op;
    dst->x1.t = src->x1.t;
    dst->x1.regconst = src->x1.regconst;
    dst->x2.t = src->x2.t;
    dst->x2.regconst = src->x2.regconst;
    duk_copy(ctx, src->x1.valstack_idx, dst->x1.valstack_idx);
    duk_copy(ctx, src->x2.valstack_idx, dst->x2.valstack_idx);
}
 
/* XXX: to util */
DUK_LOCAL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival) {

Referenced by duk__ispec_toregconst_raw().

◆ duk__ispec_toforcedreg()

DUK_LOCAL_DECL void duk__ispec_toforcedreg	(	duk_compiler_ctx *	comp_ctx,
		duk_ispec *	x,
		duk_reg_t	forced_reg )

Definition at line 59835 of file duktape-1.8.0/src/duktape.c.

                                                                                          {
            duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
            duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, (duk_regconst_t) dest, x->regconst);

◆ duk__ispec_toregconst_raw()

DUK_LOCAL_DECL duk_regconst_t duk__ispec_toregconst_raw	(	duk_compiler_ctx *	comp_ctx,
		duk_ispec *	x,
		duk_reg_t	forced_reg,
		duk_small_uint_t	flags )

Definition at line 59664 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
 
    DUK_DDD(DUK_DDDPRINT("duk__ispec_toregconst_raw(): x={%ld:%ld:%!T}, "
                         "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
                         (long) x->t,
                         (long) x->regconst,
                         (duk_tval *) duk_get_tval(ctx, x->valstack_idx),
                         (long) forced_reg,
                         (unsigned long) flags,
                         (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0),
                         (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0),
                         (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0)));
 
    switch (x->t) {
    case DUK_ISPEC_VALUE: {
        duk_tval *tv;
 
        tv = DUK_GET_TVAL_POSIDX(ctx, x->valstack_idx);
        DUK_ASSERT(tv != NULL);
 
        switch (DUK_TVAL_GET_TAG(tv)) {
        case DUK_TAG_UNDEFINED: {
            /* Note: although there is no 'undefined' literal, undefined
             * values can occur during compilation as a result of e.g.
             * the 'void' operator.
             */
            duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
            duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDUNDEF, (duk_regconst_t) dest);
            return (duk_regconst_t) dest;
        }
        case DUK_TAG_NULL: {
            duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
            duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDNULL, (duk_regconst_t) dest);
            return (duk_regconst_t) dest;
        }
        case DUK_TAG_BOOLEAN: {
            duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
            duk__emit_extraop_bc(comp_ctx,
                                 (DUK_TVAL_GET_BOOLEAN(tv) ? DUK_EXTRAOP_LDTRUE : DUK_EXTRAOP_LDFALSE),
                                 (duk_regconst_t) dest);
            return (duk_regconst_t) dest;
        }
        case DUK_TAG_POINTER: {
            DUK_UNREACHABLE();
            break;
        }
        case DUK_TAG_STRING: {
            duk_hstring *h;
            duk_reg_t dest;
            duk_regconst_t constidx;
 
            h = DUK_TVAL_GET_STRING(tv);
            DUK_UNREF(h);
            DUK_ASSERT(h != NULL);
 
#if 0  /* XXX: to be implemented? */
            /* Use special opcodes to load short strings */
            if (DUK_HSTRING_GET_BYTELEN(h) <= 2) {
                /* Encode into a single opcode (18 bits can encode 1-2 bytes + length indicator) */
            } else if (DUK_HSTRING_GET_BYTELEN(h) <= 6) {
                /* Encode into a double constant (53 bits can encode 6*8 = 48 bits + 3-bit length */
            }
#endif
            duk_dup(ctx, x->valstack_idx);
            constidx = duk__getconst(comp_ctx);
 
            if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
                return constidx;
            }
 
            dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
            duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
            return (duk_regconst_t) dest;
        }
        case DUK_TAG_OBJECT: {
            DUK_UNREACHABLE();
            break;
        }
        case DUK_TAG_BUFFER: {
            DUK_UNREACHABLE();
            break;
        }
        case DUK_TAG_LIGHTFUNC: {
            DUK_UNREACHABLE();
            break;
        }
#if defined(DUK_USE_FASTINT)
        case DUK_TAG_FASTINT:
#endif
        default: {
            /* number */
            duk_reg_t dest;
            duk_regconst_t constidx;
            duk_double_t dval;
            duk_int32_t ival;
 
            DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
            dval = DUK_TVAL_GET_NUMBER(tv);
 
            if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
                /* A number can be loaded either through a constant, using
                 * LDINT, or using LDINT+LDINTX.  LDINT is always a size win,
                 * LDINT+LDINTX is not if the constant is used multiple times.
                 * Currently always prefer LDINT+LDINTX over a double constant.
                 */
 
                if (duk__is_whole_get_int32(dval, &ival)) {
                    dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
                    duk__emit_load_int32(comp_ctx, dest, ival);
                    return (duk_regconst_t) dest;
                }
            }
 
            duk_dup(ctx, x->valstack_idx);
            constidx = duk__getconst(comp_ctx);
 
            if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
                return constidx;
            } else {
                dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
                duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
                return (duk_regconst_t) dest;
            }
        }
        }  /* end switch */
    }
    case DUK_ISPEC_REGCONST: {
        if (forced_reg >= 0) {
            if (x->regconst & DUK__CONST_MARKER) {
                duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, forced_reg, x->regconst);
            } else if (x->regconst != (duk_regconst_t) forced_reg) {
                duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst);
            } else {
                ; /* already in correct reg */
            }
            return (duk_regconst_t) forced_reg;
        }
 
        DUK_ASSERT(forced_reg < 0);
        if (x->regconst & DUK__CONST_MARKER) {
            if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
                duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, x->regconst);
                return (duk_regconst_t) dest;
            }
            return x->regconst;
        }

References DUK__ALLOCTEMP, DUK__CONST_MARKER, duk__emit_a_bc(), duk__emit_extraop_bc(), duk__emit_load_int32(), duk__getconst(), duk__is_whole_get_int32(), DUK__IVAL_FLAG_ALLOW_CONST, DUK__IVAL_FLAG_REQUIRE_SHORT, DUK__IVAL_FLAG_REQUIRE_TEMP, DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_dup(), DUK_EXTRAOP_LDFALSE, DUK_EXTRAOP_LDNULL, DUK_EXTRAOP_LDTRUE, DUK_EXTRAOP_LDUNDEF, duk_get_tval(), DUK_GET_TVAL_POSIDX, DUK_HSTRING_GET_BYTELEN, DUK_ISPEC_REGCONST, DUK_ISPEC_VALUE, DUK_OP_LDCONST, DUK_OP_LDREG, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_BOOLEAN, DUK_TVAL_GET_NUMBER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_UNREACHABLE, DUK_UNREF, NULL, duk_ispec::regconst, duk_ispec::t, duk_compiler_ctx::thr, and duk_ispec::valstack_idx.

◆ duk__ivalue_toforcedreg()

DUK_LOCAL_DECL void duk__ivalue_toforcedreg	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x,
		duk_int_t	forced_reg )

Definition at line 60129 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__parse_var_decl().

◆ duk__ivalue_toplain()

DUK_LOCAL_DECL void duk__ivalue_toplain	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x )

Definition at line 60061 of file duktape-1.8.0/src/duktape.c.

◆ duk__ivalue_toplain_ignore()

DUK_LOCAL_DECL void duk__ivalue_toplain_ignore	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x )

Definition at line 60066 of file duktape-1.8.0/src/duktape.c.

                      :
    default: {
        DUK_D(DUK_DPRINT("invalid ivalue type: %ld", (long) x->t));
        break;
    }
    }
 
    DUK_ERROR_INTERNAL_DEFMSG(thr);
    return;
}

References DUK_D, DUK_DPRINT, and duk_ivalue::t.

Referenced by duk__exprtop_toforcedreg().

◆ duk__ivalue_toplain_raw()

DUK_LOCAL_DECL void duk__ivalue_toplain_raw	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x,
		duk_reg_t	forced_reg )

Definition at line 59845 of file duktape-1.8.0/src/duktape.c.

                                                                                                      {
    DUK_ASSERT(forced_reg >= 0);
    (void) duk__ispec_toregconst_raw(comp_ctx, x, forced_reg, 0 /*flags*/);
}
 
/* Coerce an duk_ivalue to a 'plain' value by generating the necessary
 * arithmetic operations, property access, or variable access bytecode.
 * The duk_ivalue argument ('x') is converted into a plain value as a
 * side effect.
 */
DUK_LOCAL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
 
    DUK_DDD(DUK_DDDPRINT("duk__ivalue_toplain_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, "
                         "forced_reg=%ld",
                         (long) x->t, (long) x->op,
                         (long) x->x1.t, (long) x->x1.regconst,
                         (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx),
                         (long) x->x2.t, (long) x->x2.regconst,
                         (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx),
                         (long) forced_reg));
 
    switch (x->t) {
    case DUK_IVAL_PLAIN: {
        return;
    }
    /* XXX: support unary arithmetic ivalues (useful?) */
    case DUK_IVAL_ARITH:
    case DUK_IVAL_ARITH_EXTRAOP: {
        duk_regconst_t arg1;
        duk_regconst_t arg2;
        duk_reg_t dest;
        duk_tval *tv1;
        duk_tval *tv2;
 
        DUK_DDD(DUK_DDDPRINT("arith to plain conversion"));
 
        /* inline arithmetic check for constant values */
        /* XXX: use the exactly same arithmetic function here as in executor */
        if (x->x1.t == DUK_ISPEC_VALUE && x->x2.t == DUK_ISPEC_VALUE && x->t == DUK_IVAL_ARITH) {
            tv1 = DUK_GET_TVAL_POSIDX(ctx, x->x1.valstack_idx);
            tv2 = DUK_GET_TVAL_POSIDX(ctx, x->x2.valstack_idx);
            DUK_ASSERT(tv1 != NULL);
            DUK_ASSERT(tv2 != NULL);
 
            DUK_DDD(DUK_DDDPRINT("arith: tv1=%!T, tv2=%!T",
                                 (duk_tval *) tv1,
                                 (duk_tval *) tv2));
 
            if (DUK_TVAL_IS_NUMBER(tv1) && DUK_TVAL_IS_NUMBER(tv2)) {
                duk_double_t d1 = DUK_TVAL_GET_NUMBER(tv1);
                duk_double_t d2 = DUK_TVAL_GET_NUMBER(tv2);
                duk_double_t d3;
                duk_bool_t accept = 1;
 
                DUK_DDD(DUK_DDDPRINT("arith inline check: d1=%lf, d2=%lf, op=%ld",
                                     (double) d1, (double) d2, (long) x->op));
                switch (x->op) {
                case DUK_OP_ADD:  d3 = d1 + d2; break;
                case DUK_OP_SUB:  d3 = d1 - d2; break;
                case DUK_OP_MUL:  d3 = d1 * d2; break;
                case DUK_OP_DIV:  d3 = d1 / d2; break;
                default:          accept = 0; break;
                }
 
                if (accept) {
                    duk_double_union du;
                    du.d = d3;
                    DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
                    d3 = du.d;
 
                    x->t = DUK_IVAL_PLAIN;
                    DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE);
                    DUK_TVAL_SET_NUMBER(tv1, d3);  /* old value is number: no refcount */
                    return;
                }
            } else if (x->op == DUK_OP_ADD && DUK_TVAL_IS_STRING(tv1) && DUK_TVAL_IS_STRING(tv2)) {
                /* inline string concatenation */
                duk_dup(ctx, x->x1.valstack_idx);
                duk_dup(ctx, x->x2.valstack_idx);
                duk_concat(ctx, 2);
                duk_replace(ctx, x->x1.valstack_idx);
                x->t = DUK_IVAL_PLAIN;
                DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE);
                return;
            }
        }
 
        arg1 = duk__ispec_toregconst_raw(comp_ctx, &x->x1, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
        arg2 = duk__ispec_toregconst_raw(comp_ctx, &x->x2, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
 
        /* If forced reg, use it as destination.  Otherwise try to
         * use either coerced ispec if it is a temporary.
         *
         * When using extraops, avoid reusing arg2 as dest because that
         * would lead to an LDREG shuffle below.  We still can't guarantee
         * dest != arg2 because we may have a forced_reg.
         */
        if (forced_reg >= 0) {
            dest = forced_reg;
        } else if (DUK__ISTEMP(comp_ctx, arg1)) {
            dest = (duk_reg_t) arg1;
        } else if (DUK__ISTEMP(comp_ctx, arg2) && x->t != DUK_IVAL_ARITH_EXTRAOP) {
            dest = (duk_reg_t) arg2;
        } else {
            dest = DUK__ALLOCTEMP(comp_ctx);
        }
 
        /* Extraop arithmetic opcodes must have destination same as
         * first source.  If second source matches destination we need
         * a temporary register to avoid clobbering the second source.
         *
         * XXX: change calling code to avoid this situation in most cases.
         */
 
        if (x->t == DUK_IVAL_ARITH_EXTRAOP) {
            if (!(DUK__ISREG(comp_ctx, arg1) && (duk_reg_t) arg1 == dest)) {
                if (DUK__ISREG(comp_ctx, arg2) && (duk_reg_t) arg2 == dest) {
                    /* arg2 would be clobbered so reassign it to a temp. */
                    duk_reg_t tempreg;
                    tempreg = DUK__ALLOCTEMP(comp_ctx);
                    duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, tempreg, arg2);
                    arg2 = tempreg;
                }
 
                if (DUK__ISREG(comp_ctx, arg1)) {
                    duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, dest, arg1);
                } else {
                    DUK_ASSERT(DUK__ISCONST(comp_ctx, arg1));
                    duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, dest, arg1);
                }
            }
 
            /* Note: special DUK__EMIT_FLAG_B_IS_TARGETSOURCE
             * used to indicate that B is both a source and a
             * target register.  When shuffled, it needs to be
             * both input and output shuffled.
             */
            DUK_ASSERT(DUK__ISREG(comp_ctx, dest));
            duk__emit_extraop_b_c(comp_ctx,
                                  x->op | DUK__EMIT_FLAG_B_IS_TARGET |
                                          DUK__EMIT_FLAG_B_IS_TARGETSOURCE,
                                  (duk_regconst_t) dest,
                                  (duk_regconst_t) arg2);
 
        } else {
            DUK_ASSERT(DUK__ISREG(comp_ctx, dest));
            duk__emit_a_b_c(comp_ctx, x->op, (duk_regconst_t) dest, arg1, arg2);
        }
 
        x->t = DUK_IVAL_PLAIN;
        x->x1.t = DUK_ISPEC_REGCONST;
        x->x1.regconst = (duk_regconst_t) dest;
        return;
    }
    case DUK_IVAL_PROP: {
        /* XXX: very similar to DUK_IVAL_ARITH - merge? */
        duk_regconst_t arg1;
        duk_regconst_t arg2;
        duk_reg_t dest;
 
        /* Need a short reg/const, does not have to be a mutable temp. */
        arg1 = duk__ispec_toregconst_raw(comp_ctx, &x->x1, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
        arg2 = duk__ispec_toregconst_raw(comp_ctx, &x->x2, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
 
        /* Pick a destination register.  If either base value or key
         * happens to be a temp value, reuse it as the destination.
         *
         * XXX: The temp must be a "mutable" one, i.e. such that no
         * other expression is using it anymore.  Here this should be
         * the case because the value of a property access expression
         * is neither the base nor the key, but the lookup result.
         */
 
        if (forced_reg >= 0) {
            dest = forced_reg;
        } else if (DUK__ISTEMP(comp_ctx, arg1)) {
            dest = (duk_reg_t) arg1;
        } else if (DUK__ISTEMP(comp_ctx, arg2)) {
            dest = (duk_reg_t) arg2;
        } else {
            dest = DUK__ALLOCTEMP(comp_ctx);
        }
 
        duk__emit_a_b_c(comp_ctx, DUK_OP_GETPROP, (duk_regconst_t) dest, arg1, arg2);
 
        x->t = DUK_IVAL_PLAIN;
        x->x1.t = DUK_ISPEC_REGCONST;
        x->x1.regconst = (duk_regconst_t) dest;
        return;
    }
    case DUK_IVAL_VAR: {
        /* x1 must be a string */
        duk_reg_t dest;
        duk_reg_t reg_varbind;
        duk_regconst_t rc_varname;
 
        DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE);
 
        duk_dup(ctx, x->x1.valstack_idx);
        if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
            x->t = DUK_IVAL_PLAIN;
            x->x1.t = DUK_ISPEC_REGCONST;
            x->x1.regconst = (duk_regconst_t) reg_varbind;
        } else {
            dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));

◆ duk__ivalue_toreg()

DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x )

Definition at line 60119 of file duktape-1.8.0/src/duktape.c.

60120 : 0),

60121 (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0),

Referenced by duk__parse_var_decl().

◆ duk__ivalue_toregconst()

DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x )

Definition at line 60134 of file duktape-1.8.0/src/duktape.c.

60136 {

Referenced by duk__expr_toplain_ignore().

◆ duk__ivalue_toregconst_raw()

DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst_raw	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x,
		duk_reg_t	forced_reg,
		duk_small_uint_t	flags )

Definition at line 60084 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_regconst_t reg;
    DUK_UNREF(thr);
    DUK_UNREF(ctx);
 
    DUK_DDD(DUK_DDDPRINT("duk__ivalue_toregconst_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, "
                         "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
                         (long) x->t, (long) x->op,
                         (long) x->x1.t, (long) x->x1.regconst,
                         (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx),
                         (long) x->x2.t, (long) x->x2.regconst,
                         (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx),

Referenced by duk__lookup_active_register_binding().

◆ duk__ivalue_totempconst()

DUK_LOCAL_DECL duk_regconst_t duk__ivalue_totempconst	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	x )

Definition at line 60138 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__exprtop_toreg().

◆ duk__js_compile_raw()

DUK_LOCAL duk_ret_t duk__js_compile_raw ( duk_context * ctx )

Definition at line 65398 of file duktape-1.8.0/src/duktape.c.

                                                          {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_filename;
    duk__compiler_stkstate *comp_stk;
    duk_compiler_ctx *comp_ctx;
    duk_lexer_point *lex_pt;
    duk_compiler_func *func;
    duk_idx_t entry_top;
    duk_bool_t is_strict;
    duk_bool_t is_eval;
    duk_bool_t is_funcexpr;
    duk_small_uint_t flags;
 
    DUK_ASSERT(thr != NULL);
 
    /*
     *  Arguments check
     */
 
    entry_top = duk_get_top(ctx);
    DUK_ASSERT(entry_top >= 2);
 
    comp_stk = (duk__compiler_stkstate *) duk_require_pointer(ctx, -1);
    comp_ctx = &comp_stk->comp_ctx_alloc;
    lex_pt = &comp_stk->lex_pt_alloc;
    DUK_ASSERT(comp_ctx != NULL);
    DUK_ASSERT(lex_pt != NULL);
 
    flags = comp_stk->flags;
    is_eval = (flags & DUK_JS_COMPILE_FLAG_EVAL ? 1 : 0);
    is_strict = (flags & DUK_JS_COMPILE_FLAG_STRICT ? 1 : 0);
    is_funcexpr = (flags & DUK_JS_COMPILE_FLAG_FUNCEXPR ? 1 : 0);
 
    h_filename = duk_get_hstring(ctx, -2);  /* may be undefined */
 
    /*
     *  Init compiler and lexer contexts
     */
 
    func = &comp_ctx->curr_func;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    comp_ctx->thr = NULL;
    comp_ctx->h_filename = NULL;
    comp_ctx->prev_token.str1 = NULL;
    comp_ctx->prev_token.str2 = NULL;
    comp_ctx->curr_token.str1 = NULL;
    comp_ctx->curr_token.str2 = NULL;
#endif
 
    duk_require_stack(ctx, DUK__COMPILE_ENTRY_SLOTS);
 
    duk_push_dynamic_buffer(ctx, 0);       /* entry_top + 0 */
    duk_push_undefined(ctx);               /* entry_top + 1 */
    duk_push_undefined(ctx);               /* entry_top + 2 */
    duk_push_undefined(ctx);               /* entry_top + 3 */
    duk_push_undefined(ctx);               /* entry_top + 4 */
 
    comp_ctx->thr = thr;
    comp_ctx->h_filename = h_filename;
    comp_ctx->tok11_idx = entry_top + 1;
    comp_ctx->tok12_idx = entry_top + 2;
    comp_ctx->tok21_idx = entry_top + 3;
    comp_ctx->tok22_idx = entry_top + 4;
    comp_ctx->recursion_limit = DUK_USE_COMPILER_RECLIMIT;
 
    /* comp_ctx->lex has been pre-initialized by caller: it has been
     * zeroed and input/input_length has been set.
     */
    comp_ctx->lex.thr = thr;
    /* comp_ctx->lex.input and comp_ctx->lex.input_length filled by caller */
    comp_ctx->lex.slot1_idx = comp_ctx->tok11_idx;
    comp_ctx->lex.slot2_idx = comp_ctx->tok12_idx;
    comp_ctx->lex.buf_idx = entry_top + 0;
    comp_ctx->lex.buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0);
    DUK_ASSERT(comp_ctx->lex.buf != NULL);
    DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(comp_ctx->lex.buf) && !DUK_HBUFFER_HAS_EXTERNAL(comp_ctx->lex.buf));
    comp_ctx->lex.token_limit = DUK_COMPILER_TOKEN_LIMIT;
 
    lex_pt->offset = 0;
    lex_pt->line = 1;
    DUK_LEXER_SETPOINT(&comp_ctx->lex, lex_pt);    /* fills window */
    comp_ctx->curr_token.start_line = 0;  /* needed for line number tracking (becomes prev_token.start_line) */
 
    /*
     *  Initialize function state for a zero-argument function
     */
 
    duk__init_func_valstack_slots(comp_ctx);
    DUK_ASSERT(func->num_formals == 0);
 
    if (is_funcexpr) {
        /* Name will be filled from function expression, not by caller.
         * This case is used by Function constructor and duk_compile()
         * API with the DUK_COMPILE_FUNCTION option.
         */
        DUK_ASSERT(func->h_name == NULL);
    } else {
        duk_push_hstring_stridx(ctx, (is_eval ? DUK_STRIDX_EVAL :
                                                DUK_STRIDX_GLOBAL));
        func->h_name = duk_get_hstring(ctx, -1);
    }
 
    /*
     *  Parse a function body or a function-like expression, depending
     *  on flags.
     */
 
    func->is_strict = is_strict;
    func->is_setget = 0;
    func->is_decl = 0;
 
    if (is_funcexpr) {
        func->is_function = 1;
        func->is_eval = 0;
        func->is_global = 0;
 
        duk__advance(comp_ctx);  /* init 'curr_token' */
        duk__advance_expect(comp_ctx, DUK_TOK_FUNCTION);
        (void) duk__parse_func_like_raw(comp_ctx,
                                        0,      /* is_decl */
                                        0);     /* is_setget */
    } else {
        func->is_function = 0;
        func->is_eval = is_eval;
        func->is_global = !is_eval;
 
        duk__parse_func_body(comp_ctx,
                             1,             /* expect_eof */
                             1,             /* implicit_return_value */

◆ duk__js_equals_number()

DUK_LOCAL duk_bool_t duk__js_equals_number	(	duk_double_t	x,
		duk_double_t	y )

Definition at line 70537 of file duktape-1.8.0/src/duktape.c.

                     :
 *
 *    - Current implementation (and spec definition) has recursion; this should
 *      be fixed if possible.
 *
 *    - String-to-number coercion should be possible without going through the
 *      value stack (and be more compact) if a shared helper is invoked.
 */
 
/* Note that this is the same operation for strict and loose equality:
 *  - E5 Section 11.9.3, step 1.c (loose)
 *  - E5 Section 11.9.6, step 4 (strict)
 */
 
DUK_LOCAL duk_bool_t duk__js_equals_number(duk_double_t x, duk_double_t y) {
#if defined(DUK_USE_PARANOID_MATH)
    /* Straightforward algorithm, makes fewer compiler assumptions. */
    duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
    if (cx == DUK_FP_NAN || cy == DUK_FP_NAN) {
        return 0;
    }
    if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
        return 1;
    }
    if (x == y) {
        return 1;
    }
    return 0;
#else  /* DUK_USE_PARANOID_MATH */
    /* Better equivalent algorithm.  If the compiler is compliant, C and
     * Ecmascript semantics are identical for this particular comparison.
     * In particular, NaNs must never compare equal and zeroes must compare
     * equal regardless of sign.  Could also use a macro, but this inlines

References DUK_FP_NAN, DUK_FP_ZERO, and DUK_FPCLASSIFY.

◆ duk__js_execute_bytecode_inner()

DUK_LOCAL_DECL void duk__js_execute_bytecode_inner	(	duk_hthread *	entry_thread,
		duk_size_t	entry_callstack_top )

Definition at line 67712 of file duktape-1.8.0/src/duktape.c.

                                                 {
                DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception"));
                DUK_UNREF(exc);
                duk__handle_executor_error(heap,
                                           entry_thread,
                                           entry_callstack_top,
                                           entry_call_recursion_depth,
                                           entry_jmpbuf_ptr);
            }
        }
#endif
    }
 
    DUK_UNREACHABLE();
}
 
/* Inner executor, performance critical. */
DUK_LOCAL DUK_NOINLINE void duk__js_execute_bytecode_inner(duk_hthread *entry_thread, duk_size_t entry_callstack_top) {
    /* Current PC, accessed by other functions through thr->ptr_to_curr_pc.
     * Critical for performance.  It would be safest to make this volatile,
     * but that eliminates performance benefits; aliasing guarantees
     * should be enough though.
     */
    duk_instr_t *curr_pc;         /* bytecode has a stable pointer */
 
    /* Hot variables for interpretation.  Critical for performance,
     * but must add sparingly to minimize register shuffling.
     */
    duk_hthread *thr;             /* stable */
    duk_tval *consts;             /* stable */
    duk_tval *consts2;            /* stable; precalculated for faster lookups */
    duk_uint_fast32_t ins;
    /* 'funcs' is quite rarely used, so no local for it */
#if defined(DUK_USE_EXEC_FUN_LOCAL)
    duk_hcompiledfunction *fun;
#else
    /* 'fun' is quite rarely used, so no local for it */
#endif
 
#ifdef DUK_USE_INTERRUPT_COUNTER
    duk_int_t int_ctr;
#endif
 
#ifdef DUK_USE_ASSERTIONS
    duk_size_t valstack_top_base;    /* valstack top, should match before interpreting each op (no leftovers) */
#endif
 
    /*
     *  Restart execution by reloading thread state.
     *
     *  Note that 'thr' and any thread configuration may have changed,
     *  so all local variables are suspect and we need to reinitialize.
     *
     *  The number of local variables should be kept to a minimum: if
     *  the variables are spilled, they will need to be loaded from
     *  memory anyway.
     *
     *  Any 'goto restart_execution;' code path in opcode dispatch must
     *  ensure 'curr_pc' is synced back to act->curr_pc before the goto
     *  takes place.
     *
     *  The interpreter must be very careful with memory pointers, as
     *  many pointers are not guaranteed to be 'stable' and may be
     *  reallocated and relocated on-the-fly quite easily (e.g. by a
     *  memory allocation or a property access).
     *
     *  The following are assumed to have stable pointers:
     *    - the current thread
     *    - the current function
     *    - the bytecode, constant table, inner function table of the
     *      current function (as they are a part of the function allocation)
     *
     *  The following are assumed to have semi-stable pointers:
     *    - the current activation entry: stable as long as callstack
     *      is not changed (reallocated by growing or shrinking), or
     *      by any garbage collection invocation (through finalizers)
     *    - Note in particular that ANY DECREF can invalidate the
     *      activation pointer, so for the most part a fresh lookup
     *      is required
     *
     *  The following are not assumed to have stable pointers at all:
     *    - the value stack (registers) of the current thread
     *    - the catch stack of the current thread
     *
     *  See execution.rst for discussion.
     */
 
 restart_execution:
 
    /* Lookup current thread; use the stable 'entry_thread' for this to
     * avoid clobber warnings.  Any valid, reachable 'thr' value would be
     * fine for this, so using 'entry_thread' is just to silence warnings.
     */
    thr = entry_thread->heap->curr_thread;
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->callstack_top >= 1);
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
 
    thr->ptr_curr_pc = &curr_pc;
 
    /* Relookup and initialize dispatch loop variables.  Debugger check. */
    {
        duk_activation *act;
#if !defined(DUK_USE_EXEC_FUN_LOCAL)
        duk_hcompiledfunction *fun;
#endif
 
        /* Assume interrupt init/counter are properly initialized here. */
        /* Assume that thr->valstack_bottom has been set-up before getting here. */
 
        act = thr->callstack + thr->callstack_top - 1;
        fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
        DUK_ASSERT(fun != NULL);
        DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs);
        consts = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun);
        DUK_ASSERT(consts != NULL);
        consts2 = consts - DUK_BC_REGLIMIT;
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
        if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && !thr->heap->dbg_processing) {
            duk__executor_recheck_debugger(thr, act, fun);
            act = thr->callstack + thr->callstack_top - 1;  /* relookup after side effects (no side effects currently however) */
        }
#endif  /* DUK_USE_DEBUGGER_SUPPORT */
 
#ifdef DUK_USE_ASSERTIONS
        valstack_top_base = (duk_size_t) (thr->valstack_top - thr->valstack);
#endif
 
        /* Set up curr_pc for opcode dispatch. */
        curr_pc = act->curr_pc;
    }
 
    DUK_DD(DUK_DDPRINT("restarting execution, thr %p, act idx %ld, fun %p,"
                       "consts %p, funcs %p, lev %ld, regbot %ld, regtop %ld, catchstack_top=%ld, "
                       "preventcount=%ld",
                       (void *) thr,
                       (long) (thr->callstack_top - 1),
                       (void *) DUK__FUN(),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, DUK__FUN()),
                       (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, DUK__FUN()),
                       (long) (thr->callstack_top - 1),
                       (long) (thr->valstack_bottom - thr->valstack),
                       (long) (thr->valstack_top - thr->valstack),
                       (long) thr->catchstack_top,
                       (long) thr->callstack_preventcount));
 
    /* Dispatch loop. */
 
    for (;;) {
        DUK_ASSERT(thr->callstack_top >= 1);
        DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == DUK__FUN()->nregs);
        DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) == valstack_top_base);
 
        /* Executor interrupt counter check, used to implement breakpoints,
         * debugging interface, execution timeouts, etc.  The counter is heap
         * specific but is maintained in the current thread to make the check
         * as fast as possible.  The counter is copied back to the heap struct
         * whenever a thread switch occurs by the DUK_HEAP_SWITCH_THREAD() macro.
         */
#if defined(DUK_USE_INTERRUPT_COUNTER)
        int_ctr = thr->interrupt_counter;
        if (DUK_LIKELY(int_ctr > 0)) {
            thr->interrupt_counter = int_ctr - 1;
        } else {
            /* Trigger at zero or below */
            duk_small_uint_t exec_int_ret;
 
            /* Write curr_pc back for the debugger. */
            DUK_ASSERT(thr->callstack_top > 0);
            {
                duk_activation *act;
                act = thr->callstack + thr->callstack_top - 1;
                act->curr_pc = (duk_instr_t *) curr_pc;
            }
 
            /* Force restart caused by a function return; must recheck
             * debugger breakpoints before checking line transitions,
             * see GH-303.  Restart and then handle interrupt_counter
             * zero again.
             */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
            if (thr->heap->dbg_force_restart) {
                DUK_DD(DUK_DDPRINT("dbg_force_restart flag forced restart execution"));  /* GH-303 */
                thr->heap->dbg_force_restart = 0;
                goto restart_execution;
            }
#endif
 
            exec_int_ret = duk__executor_interrupt(thr);
            if (exec_int_ret == DUK__INT_RESTART) {
                /* curr_pc synced back above */
                goto restart_execution;
            }
        }
#endif  /* DUK_USE_INTERRUPT_COUNTER */
#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG)
        /* For cross-checking during development: ensure dispatch count
         * matches cumulative interrupt counter init value sums.
         */
        thr->heap->inst_count_exec++;
#endif
 
#if defined(DUK_USE_ASSERTIONS) || defined(DUK_USE_DEBUG)
        {
            duk_activation *act;
            act = thr->callstack + thr->callstack_top - 1;
            DUK_ASSERT(curr_pc >= DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, DUK__FUN()));
            DUK_ASSERT(curr_pc < DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, DUK__FUN()));
            DUK_UNREF(act);  /* if debugging disabled */
 
            DUK_DDD(DUK_DDDPRINT("executing bytecode: pc=%ld, ins=0x%08lx, op=%ld, valstack_top=%ld/%ld, nregs=%ld  -->  %!I",
                                 (long) (curr_pc - DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, DUK__FUN())),
                                 (unsigned long) *curr_pc,
                                 (long) DUK_DEC_OP(*curr_pc),
                                 (long) (thr->valstack_top - thr->valstack),
                                 (long) (thr->valstack_end - thr->valstack),
                                 (long) (DUK__FUN() ? DUK__FUN()->nregs : -1),
                                 (duk_instr_t) *curr_pc));
        }
#endif
 
#if defined(DUK_USE_ASSERTIONS)
        /* Quite heavy assert: check valstack policy.  Improper
         * shuffle instructions can write beyond valstack_top/end
         * so this check catches them in the act.
         */
        {
            duk_tval *tv;
            tv = thr->valstack_top;
            while (tv != thr->valstack_end) {
                DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(tv));
                tv++;
            }
        }
#endif
 
        ins = *curr_pc++;
 
        /* Typing: use duk_small_(u)int_fast_t when decoding small
         * opcode fields (op, A, B, C) and duk_(u)int_fast_t when
         * decoding larger fields (e.g. BC which is 18 bits).  Use
         * unsigned variant by default, signed when the value is used
         * in signed arithmetic.  Using variable names such as 'a', 'b',
         * 'c', 'bc', etc makes it easier to spot typing mismatches.
         */
 
        /* XXX: the best typing needs to be validated by perf measurement:
         * e.g. using a small type which is the cast to a larger duk_idx_t
         * may be slower than declaring the variable as a duk_idx_t in the
         * first place.
         */
 
        /* XXX: use macros for the repetitive tval/refcount handling. */
 
        switch ((int) DUK_DEC_OP(ins)) {
        /* XXX: switch cast? */
 
        case DUK_OP_LDREG: {
            duk_small_uint_fast_t a;
            duk_uint_fast_t bc;
            duk_tval *tv1, *tv2;
 
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc);
            DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2);  /* side effects */
            break;
        }
 
        case DUK_OP_STREG: {
            duk_small_uint_fast_t a;
            duk_uint_fast_t bc;
            duk_tval *tv1, *tv2;
 
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc);
            DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv2, tv1);  /* side effects */
            break;
        }
 
        case DUK_OP_LDCONST: {
            duk_small_uint_fast_t a;
            duk_uint_fast_t bc;
            duk_tval *tv1, *tv2;
 
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            bc = DUK_DEC_BC(ins); tv2 = DUK__CONSTP(bc);
            DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2);  /* side effects */
            break;
        }
 
        case DUK_OP_LDINT: {
            duk_small_uint_fast_t a;
            duk_int_fast_t bc;
            duk_tval *tv1;
#if defined(DUK_USE_FASTINT)
            duk_int32_t val;
#else
            duk_double_t val;
#endif
 
#if defined(DUK_USE_FASTINT)
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            bc = DUK_DEC_BC(ins); val = (duk_int32_t) (bc - DUK_BC_LDINT_BIAS);
            DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv1, val);  /* side effects */
#else
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            bc = DUK_DEC_BC(ins); val = (duk_double_t) (bc - DUK_BC_LDINT_BIAS);
            DUK_TVAL_SET_NUMBER_UPDREF(thr, tv1, val);  /* side effects */
#endif
            break;
        }
 
        case DUK_OP_LDINTX: {
            duk_small_uint_fast_t a;
            duk_tval *tv1;
            duk_double_t val;
 
            /* LDINTX is not necessarily in FASTINT range, so
             * no fast path for now.
             *
             * XXX: perhaps restrict LDINTX to fastint range, wider
             * range very rarely needed.
             */
 
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
            val = DUK_TVAL_GET_NUMBER(tv1) * ((duk_double_t) (1L << DUK_BC_LDINTX_SHIFT)) +
                  (duk_double_t) DUK_DEC_BC(ins);
#if defined(DUK_USE_FASTINT)
            DUK_TVAL_SET_NUMBER_CHKFAST(tv1, val);
#else
            DUK_TVAL_SET_NUMBER(tv1, val);
#endif
            break;
        }
 
        case DUK_OP_MPUTOBJ:
        case DUK_OP_MPUTOBJI: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a;
            duk_tval *tv1;
            duk_hobject *obj;
            duk_uint_fast_t idx;
            duk_small_uint_fast_t count;
 
            /* A -> register of target object
             * B -> first register of key/value pair list
             * C -> number of key/value pairs
             */
 
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
            obj = DUK_TVAL_GET_OBJECT(tv1);
 
            idx = (duk_uint_fast_t) DUK_DEC_B(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_MPUTOBJI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
            count = (duk_small_uint_fast_t) DUK_DEC_C(ins);
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (DUK_UNLIKELY(idx + count * 2 > (duk_uint_fast_t) duk_get_top(ctx))) {
                /* XXX: use duk_is_valid_index() instead? */
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("MPUTOBJ out of bounds");
            }
#endif
 
            duk_push_hobject(ctx, obj);
 
            while (count > 0) {
                /* XXX: faster initialization (direct access or better primitives) */
 
                duk_push_tval(ctx, DUK__REGP(idx));
                DUK_ASSERT(duk_is_string(ctx, -1));
                duk_push_tval(ctx, DUK__REGP(idx + 1));  /* -> [... obj key value] */
                duk_xdef_prop_wec(ctx, -3);              /* -> [... obj] */
 
                count--;
                idx += 2;
            }
 
            duk_pop(ctx);  /* [... obj] -> [...] */
            break;
        }
 
        case DUK_OP_MPUTARR:
        case DUK_OP_MPUTARRI: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a;
            duk_tval *tv1;
            duk_hobject *obj;
            duk_uint_fast_t idx;
            duk_small_uint_fast_t count;
            duk_uint32_t arr_idx;
 
            /* A -> register of target object
             * B -> first register of value data (start_index, value1, value2, ..., valueN)
             * C -> number of key/value pairs (N)
             */
 
            a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
            DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
            obj = DUK_TVAL_GET_OBJECT(tv1);
            DUK_ASSERT(obj != NULL);
 
            idx = (duk_uint_fast_t) DUK_DEC_B(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_MPUTARRI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
            count = (duk_small_uint_fast_t) DUK_DEC_C(ins);
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (idx + count + 1 > (duk_uint_fast_t) duk_get_top(ctx)) {
                /* XXX: use duk_is_valid_index() instead? */
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("MPUTARR out of bounds");
            }
#endif
 
            tv1 = DUK__REGP(idx);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
            arr_idx = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1);
            idx++;
 
            duk_push_hobject(ctx, obj);
 
            while (count > 0) {
                /* duk_xdef_prop() will define an own property without any array
                 * special behaviors.  We'll need to set the array length explicitly
                 * in the end.  For arrays with elisions, the compiler will emit an
                 * explicit SETALEN which will update the length.
                 */
 
                /* XXX: because we're dealing with 'own' properties of a fresh array,
                 * the array initializer should just ensure that the array has a large
                 * enough array part and write the values directly into array part,
                 * and finally set 'length' manually in the end (as already happens now).
                 */
 
                duk_push_tval(ctx, DUK__REGP(idx));          /* -> [... obj value] */
                duk_xdef_prop_index_wec(ctx, -2, arr_idx);   /* -> [... obj] */
 
                /* XXX: could use at least one fewer loop counters */
                count--;
                idx++;
                arr_idx++;
            }
 
            /* XXX: E5.1 Section 11.1.4 coerces the final length through
             * ToUint32() which is odd but happens now as a side effect of
             * 'arr_idx' type.
             */
            duk_hobject_set_length(thr, obj, (duk_uint32_t) arr_idx);
 
            duk_pop(ctx);  /* [... obj] -> [...] */
            break;
        }
 
        case DUK_OP_NEW:
        case DUK_OP_NEWI: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_uint_fast_t idx;
            duk_small_uint_fast_t i;
 
            /* A -> unused (reserved for flags, for consistency with DUK_OP_CALL)
             * B -> target register and start reg: constructor, arg1, ..., argN
             *      (for DUK_OP_NEWI, 'b' is indirect)
             * C -> num args (N)
             */
 
            /* duk_new() will call the constuctor using duk_handle_call().
             * A constructor call prevents a yield from inside the constructor,
             * even if the constructor is an Ecmascript function.
             */
 
            /* Don't need to sync curr_pc here; duk_new() will do that
             * when it augments the created error.
             */
 
            /* XXX: unnecessary copying of values?  Just set 'top' to
             * b + c, and let the return handling fix up the stack frame?
             */
 
            idx = (duk_uint_fast_t) DUK_DEC_B(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_NEWI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (idx + c + 1 > (duk_uint_fast_t) duk_get_top(ctx)) {
                /* XXX: use duk_is_valid_index() instead? */
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("NEW out of bounds");
            }
#endif
 
            duk_require_stack(ctx, (duk_idx_t) c);
            duk_push_tval(ctx, DUK__REGP(idx));
            for (i = 0; i < c; i++) {
                duk_push_tval(ctx, DUK__REGP(idx + i + 1));
            }
            duk_new(ctx, (duk_idx_t) c);  /* [... constructor arg1 ... argN] -> [retval] */
            DUK_DDD(DUK_DDDPRINT("NEW -> %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
            duk_replace(ctx, (duk_idx_t) idx);
 
            /* When debugger is enabled, we need to recheck the activation
             * status after returning.  This is now handled by call handling
             * and heap->dbg_force_restart.
             */
            break;
        }
 
        case DUK_OP_REGEXP: {
#ifdef DUK_USE_REGEXP_SUPPORT
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
 
            /* A -> target register
             * B -> bytecode (also contains flags)
             * C -> escaped source
             */
 
            duk_push_tval(ctx, DUK__REGCONSTP(c));
            duk_push_tval(ctx, DUK__REGCONSTP(b));  /* -> [ ... escaped_source bytecode ] */
            duk_regexp_create_instance(thr);   /* -> [ ... regexp_instance ] */
            DUK_DDD(DUK_DDDPRINT("regexp instance: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
            duk_replace(ctx, (duk_idx_t) a);
#else
            /* The compiler should never emit DUK_OP_REGEXP if there is no
             * regexp support.
             */
            DUK__INTERNAL_ERROR("no regexp support");
#endif
 
            break;
        }
 
        case DUK_OP_CSREG:
        case DUK_OP_CSREGI: {
            /*
             *  Assuming a register binds to a variable declared within this
             *  function (a declarative binding), the 'this' for the call
             *  setup is always 'undefined'.  E5 Section 10.2.1.1.6.
             */
 
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t b = DUK_DEC_B(ins);  /* restricted to regs */
            duk_uint_fast_t idx;
 
            /* A -> target register (A, A+1) for call setup
             *      (for DUK_OP_CSREGI, 'a' is indirect)
             * B -> register containing target function (not type checked here)
             */
 
            /* XXX: direct manipulation, or duk_replace_tval() */
 
            /* Note: target registers a and a+1 may overlap with DUK__REGP(b).
             * Careful here.
             */
 
            idx = (duk_uint_fast_t) DUK_DEC_A(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_CSREGI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
                /* XXX: use duk_is_valid_index() instead? */
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("CSREG out of bounds");
            }
#endif
 
            duk_push_tval(ctx, DUK__REGP(b));
            duk_replace(ctx, (duk_idx_t) idx);
            duk_push_undefined(ctx);
            duk_replace(ctx, (duk_idx_t) (idx + 1));
            break;
        }
 
        case DUK_OP_GETVAR: {
            duk_context *ctx = (duk_context *) thr;
            duk_activation *act;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_uint_fast_t bc = DUK_DEC_BC(ins);
            duk_tval *tv1;
            duk_hstring *name;
 
            tv1 = DUK__CONSTP(bc);
            DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
            name = DUK_TVAL_GET_STRING(tv1);
            DUK_ASSERT(name != NULL);
            DUK_DDD(DUK_DDDPRINT("GETVAR: '%!O'", (duk_heaphdr *) name));
            act = thr->callstack + thr->callstack_top - 1;
            (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/);  /* -> [... val this] */
 
            duk_pop(ctx);  /* 'this' binding is not needed here */
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_PUTVAR: {
            duk_activation *act;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_uint_fast_t bc = DUK_DEC_BC(ins);
            duk_tval *tv1;
            duk_hstring *name;
 
            tv1 = DUK__CONSTP(bc);
            DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
            name = DUK_TVAL_GET_STRING(tv1);
            DUK_ASSERT(name != NULL);
 
            /* XXX: putvar takes a duk_tval pointer, which is awkward and
             * should be reworked.
             */
 
            tv1 = DUK__REGP(a);  /* val */
            act = thr->callstack + thr->callstack_top - 1;
            duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
            break;
        }
 
        case DUK_OP_DECLVAR: {
            duk_activation *act;
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_tval *tv1;
            duk_hstring *name;
            duk_small_uint_t prop_flags;
            duk_bool_t is_func_decl;
            duk_bool_t is_undef_value;
 
            tv1 = DUK__REGCONSTP(b);
            DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
            name = DUK_TVAL_GET_STRING(tv1);
            DUK_ASSERT(name != NULL);
 
            is_undef_value = ((a & DUK_BC_DECLVAR_FLAG_UNDEF_VALUE) != 0);
            is_func_decl = ((a & DUK_BC_DECLVAR_FLAG_FUNC_DECL) != 0);
 
            /* XXX: declvar takes an duk_tval pointer, which is awkward and
             * should be reworked.
             */
 
            /* Compiler is responsible for selecting property flags (configurability,
             * writability, etc).
             */
            prop_flags = a & DUK_PROPDESC_FLAGS_MASK;
 
            if (is_undef_value) {
                duk_push_undefined(ctx);
            } else {
                duk_push_tval(ctx, DUK__REGCONSTP(c));
            }
            tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
 
            act = thr->callstack + thr->callstack_top - 1;
            if (duk_js_declvar_activation(thr, act, name, tv1, prop_flags, is_func_decl)) {
                if (is_undef_value) {
                    /* Already declared but no initializer value
                     * (e.g. 'var xyz;'), no-op.
                     */
                } else {
                    /* Already declared, update value. */
                    tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
                    duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
                }
            }
 
            duk_pop(ctx);
            break;
        }
 
        case DUK_OP_DELVAR: {
            duk_activation *act;
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_tval *tv1;
            duk_hstring *name;
            duk_bool_t rc;
 
            tv1 = DUK__REGCONSTP(b);
            DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
            name = DUK_TVAL_GET_STRING(tv1);
            DUK_ASSERT(name != NULL);
            DUK_DDD(DUK_DDDPRINT("DELVAR '%!O'", (duk_heaphdr *) name));
            act = thr->callstack + thr->callstack_top - 1;
            rc = duk_js_delvar_activation(thr, act, name);
 
            duk_push_boolean(ctx, rc);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_CSVAR:
        case DUK_OP_CSVARI: {
            /* 'this' value:
             * E5 Section 6.b.i
             *
             * The only (standard) case where the 'this' binding is non-null is when
             *   (1) the variable is found in an object environment record, and
             *   (2) that object environment record is a 'with' block.
             *
             */
 
            duk_context *ctx = (duk_context *) thr;
            duk_activation *act;
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_uint_fast_t idx;
            duk_tval *tv1;
            duk_hstring *name;
 
            tv1 = DUK__REGCONSTP(b);
            DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
            name = DUK_TVAL_GET_STRING(tv1);
            DUK_ASSERT(name != NULL);
            act = thr->callstack + thr->callstack_top - 1;
            (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/);  /* -> [... val this] */
 
            /* Note: target registers a and a+1 may overlap with DUK__REGCONSTP(b)
             * and DUK__REGCONSTP(c).  Careful here.
             */
 
            idx = (duk_uint_fast_t) DUK_DEC_A(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_CSVARI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
                /* XXX: use duk_is_valid_index() instead? */
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("CSVAR out of bounds");
            }
#endif
 
            duk_replace(ctx, (duk_idx_t) (idx + 1));  /* 'this' binding */
            duk_replace(ctx, (duk_idx_t) idx);        /* variable value (function, we hope, not checked here) */
            break;
        }
 
        case DUK_OP_CLOSURE: {
            duk_context *ctx = (duk_context *) thr;
            duk_activation *act;
            duk_hcompiledfunction *fun;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_uint_fast_t bc = DUK_DEC_BC(ins);
            duk_hobject *fun_temp;
 
            /* A -> target reg
             * BC -> inner function index
             */
 
            DUK_DDD(DUK_DDDPRINT("CLOSURE to target register %ld, fnum %ld (count %ld)",
                                 (long) a, (long) bc, (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, DUK__FUN())));
 
            DUK_ASSERT_DISABLE(bc >= 0); /* unsigned */
            DUK_ASSERT((duk_uint_t) bc < (duk_uint_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, DUK__FUN()));
 
            act = thr->callstack + thr->callstack_top - 1;
            fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
            fun_temp = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun)[bc];
            DUK_ASSERT(fun_temp != NULL);
            DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(fun_temp));
 
            DUK_DDD(DUK_DDDPRINT("CLOSURE: function template is: %p -> %!O",
                                 (void *) fun_temp, (duk_heaphdr *) fun_temp));
 
            if (act->lex_env == NULL) {
                DUK_ASSERT(act->var_env == NULL);
                duk_js_init_activation_environment_records_delayed(thr, act);
                act = thr->callstack + thr->callstack_top - 1;
            }
            DUK_ASSERT(act->lex_env != NULL);
            DUK_ASSERT(act->var_env != NULL);
 
            /* functions always have a NEWENV flag, i.e. they get a
             * new variable declaration environment, so only lex_env
             * matters here.
             */
            duk_js_push_closure(thr,
                                (duk_hcompiledfunction *) fun_temp,
                                act->var_env,
                                act->lex_env,
                                1 /*add_auto_proto*/);
            duk_replace(ctx, (duk_idx_t) a);
 
            break;
        }
 
        case DUK_OP_GETPROP: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_tval *tv_obj;
            duk_tval *tv_key;
            duk_bool_t rc;
 
            /* A -> target reg
             * B -> object reg/const (may be const e.g. in "'foo'[1]")
             * C -> key reg/const
             */
 
            tv_obj = DUK__REGCONSTP(b);
            tv_key = DUK__REGCONSTP(c);
            DUK_DDD(DUK_DDDPRINT("GETPROP: a=%ld obj=%!T, key=%!T",
                                 (long) a,
                                 (duk_tval *) DUK__REGCONSTP(b),
                                 (duk_tval *) DUK__REGCONSTP(c)));
            rc = duk_hobject_getprop(thr, tv_obj, tv_key);  /* -> [val] */
            DUK_UNREF(rc);  /* ignore */
            DUK_DDD(DUK_DDDPRINT("GETPROP --> %!T",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            tv_obj = NULL;  /* invalidated */
            tv_key = NULL;  /* invalidated */
 
            duk_replace(ctx, (duk_idx_t) a);    /* val */
            break;
        }
 
        case DUK_OP_PUTPROP: {
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_tval *tv_obj;
            duk_tval *tv_key;
            duk_tval *tv_val;
            duk_bool_t rc;
 
            /* A -> object reg
             * B -> key reg/const
             * C -> value reg/const
             *
             * Note: intentional difference to register arrangement
             * of e.g. GETPROP; 'A' must contain a register-only value.
             */
 
            tv_obj = DUK__REGP(a);
            tv_key = DUK__REGCONSTP(b);
            tv_val = DUK__REGCONSTP(c);
            DUK_DDD(DUK_DDDPRINT("PUTPROP: obj=%!T, key=%!T, val=%!T",
                                 (duk_tval *) DUK__REGP(a),
                                 (duk_tval *) DUK__REGCONSTP(b),
                                 (duk_tval *) DUK__REGCONSTP(c)));
            rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT());
            DUK_UNREF(rc);  /* ignore */
            DUK_DDD(DUK_DDDPRINT("PUTPROP --> obj=%!T, key=%!T, val=%!T",
                                 (duk_tval *) DUK__REGP(a),
                                 (duk_tval *) DUK__REGCONSTP(b),
                                 (duk_tval *) DUK__REGCONSTP(c)));
            tv_obj = NULL;  /* invalidated */
            tv_key = NULL;  /* invalidated */
            tv_val = NULL;  /* invalidated */
 
            break;
        }
 
        case DUK_OP_DELPROP: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_tval *tv_obj;
            duk_tval *tv_key;
            duk_bool_t rc;
 
            /* A -> result reg
             * B -> object reg
             * C -> key reg/const
             */
 
            tv_obj = DUK__REGP(b);
            tv_key = DUK__REGCONSTP(c);
            rc = duk_hobject_delprop(thr, tv_obj, tv_key, DUK__STRICT());
            tv_obj = NULL;  /* invalidated */
            tv_key = NULL;  /* invalidated */
 
            duk_push_boolean(ctx, rc);
            duk_replace(ctx, (duk_idx_t) a);    /* result */
            break;
        }
 
        case DUK_OP_CSPROP:
        case DUK_OP_CSPROPI: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_uint_fast_t idx;
            duk_tval *tv_obj;
            duk_tval *tv_key;
            duk_bool_t rc;
 
            /* E5 Section 11.2.3, step 6.a.i */
            /* E5 Section 10.4.3 */
 
            /* XXX: allow object to be a const, e.g. in 'foo'.toString()?
             * On the other hand, DUK_REGCONSTP() is slower and generates
             * more code.
             */
 
            tv_obj = DUK__REGP(b);
            tv_key = DUK__REGCONSTP(c);
            rc = duk_hobject_getprop(thr, tv_obj, tv_key);  /* -> [val] */
            DUK_UNREF(rc);  /* unused */
            tv_obj = NULL;  /* invalidated */
            tv_key = NULL;  /* invalidated */
 
            /* Note: target registers a and a+1 may overlap with DUK__REGP(b)
             * and DUK__REGCONSTP(c).  Careful here.
             */
 
            idx = (duk_uint_fast_t) DUK_DEC_A(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_CSPROPI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
                /* XXX: use duk_is_valid_index() instead? */
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("CSPROP out of bounds");
            }
#endif
 
            duk_push_tval(ctx, DUK__REGP(b));         /* [ ... val obj ] */
            duk_replace(ctx, (duk_idx_t) (idx + 1));  /* 'this' binding */
            duk_replace(ctx, (duk_idx_t) idx);        /* val */
            break;
        }
 
        case DUK_OP_ADD:
        case DUK_OP_SUB:
        case DUK_OP_MUL:
        case DUK_OP_DIV:
        case DUK_OP_MOD: {
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_small_uint_fast_t op = DUK_DEC_OP(ins);
 
            if (op == DUK_OP_ADD) {
                /*
                 *  Handling DUK_OP_ADD this way is more compact (experimentally)
                 *  than a separate case with separate argument decoding.
                 */
                duk__vm_arith_add(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a);
            } else {
                duk__vm_arith_binary_op(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a, op);
            }
            break;
        }
 
        case DUK_OP_BAND:
        case DUK_OP_BOR:
        case DUK_OP_BXOR:
        case DUK_OP_BASL:
        case DUK_OP_BLSR:
        case DUK_OP_BASR: {
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_small_uint_fast_t op = DUK_DEC_OP(ins);
 
            duk__vm_bitwise_binary_op(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a, op);
            break;
        }
 
        case DUK_OP_EQ:
        case DUK_OP_NEQ: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_bool_t tmp;
 
            /* E5 Sections 11.9.1, 11.9.3 */
            tmp = duk_js_equals(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c));
            if (DUK_DEC_OP(ins) == DUK_OP_NEQ) {
                tmp = !tmp;
            }
            duk_push_boolean(ctx, tmp);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_SEQ:
        case DUK_OP_SNEQ: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_bool_t tmp;
 
            /* E5 Sections 11.9.1, 11.9.3 */
            tmp = duk_js_strict_equals(DUK__REGCONSTP(b), DUK__REGCONSTP(c));
            if (DUK_DEC_OP(ins) == DUK_OP_SNEQ) {
                tmp = !tmp;
            }
            duk_push_boolean(ctx, tmp);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        /* Note: combining comparison ops must be done carefully because
         * of uncomparable values (NaN): it's not necessarily true that
         * (x >= y) === !(x < y).  Also, evaluation order matters, and
         * although it would only seem to affect the compiler this is
         * actually not the case, because there are also run-time coercions
         * of the arguments (with potential side effects).
         *
         * XXX: can be combined; check code size.
         */
 
        case DUK_OP_GT: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_bool_t tmp;
 
            /* x > y  -->  y < x */
            tmp = duk_js_compare_helper(thr,
                                        DUK__REGCONSTP(c),  /* y */
                                        DUK__REGCONSTP(b),  /* x */
                                        0);                 /* flags */
 
            duk_push_boolean(ctx, tmp);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_GE: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_bool_t tmp;
 
            /* x >= y  -->  not (x < y) */
            tmp = duk_js_compare_helper(thr,
                                        DUK__REGCONSTP(b),  /* x */
                                        DUK__REGCONSTP(c),  /* y */
                                        DUK_COMPARE_FLAG_EVAL_LEFT_FIRST |
                                        DUK_COMPARE_FLAG_NEGATE);  /* flags */
 
            duk_push_boolean(ctx, tmp);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_LT: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_bool_t tmp;
 
            /* x < y */
            tmp = duk_js_compare_helper(thr,
                                        DUK__REGCONSTP(b),  /* x */
                                        DUK__REGCONSTP(c),  /* y */
                                        DUK_COMPARE_FLAG_EVAL_LEFT_FIRST);  /* flags */
 
            duk_push_boolean(ctx, tmp);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_LE: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_bool_t tmp;
 
            /* x <= y  -->  not (x > y)  -->  not (y < x) */
            tmp = duk_js_compare_helper(thr,
                                        DUK__REGCONSTP(c),  /* y */
                                        DUK__REGCONSTP(b),  /* x */
                                        DUK_COMPARE_FLAG_NEGATE);  /* flags */
 
            duk_push_boolean(ctx, tmp);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_IF: {
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_bool_t tmp;
 
            tmp = duk_js_toboolean(DUK__REGCONSTP(b));
            if (tmp == (duk_bool_t) a) {
                /* if boolean matches A, skip next inst */
                curr_pc++;
            } else {
                ;
            }
            break;
        }
 
        case DUK_OP_JUMP: {
            duk_int_fast_t abc = DUK_DEC_ABC(ins);
 
            curr_pc += abc - DUK_BC_JUMP_BIAS;
            break;
        }
 
        case DUK_OP_RETURN: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            /* duk_small_uint_fast_t c = DUK_DEC_C(ins); */
            duk_small_uint_t ret_result;
 
            /* A -> flags
             * B -> return value reg/const
             * C -> currently unused
             */
 
            DUK__SYNC_AND_NULL_CURR_PC();
 
            /* duk__handle_return() is guaranteed never to throw, except
             * for potential out-of-memory situations which will then
             * propagate out of the executor longjmp handler.
             */
 
            if (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) {
                duk_push_tval(ctx, DUK__REGCONSTP(b));
            } else {
                duk_push_undefined(ctx);
            }
            ret_result = duk__handle_return(thr,
                                        entry_thread,
                                        entry_callstack_top);
            if (ret_result == DUK__RETHAND_RESTART) {
                goto restart_execution;
            }
            DUK_ASSERT(ret_result == DUK__RETHAND_FINISHED);
 
            DUK_DDD(DUK_DDDPRINT("exiting executor after RETURN handling"));
            return;
        }
 
        case DUK_OP_CALL:
        case DUK_OP_CALLI: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_uint_fast_t idx;
            duk_small_uint_t call_flags;
            duk_small_uint_t flag_tailcall;
            duk_small_uint_t flag_evalcall;
            duk_tval *tv_func;
            duk_hobject *obj_func;
            duk_bool_t setup_rc;
            duk_idx_t num_stack_args;
#if !defined(DUK_USE_EXEC_FUN_LOCAL)
            duk_hcompiledfunction *fun;
#endif
 
            /* A -> flags
             * B -> base register for call (base -> func, base+1 -> this, base+2 -> arg1 ... base+2+N-1 -> argN)
             *      (for DUK_OP_CALLI, 'b' is indirect)
             * C -> nargs
             */
 
            /* these are not necessarily 0 or 1 (may be other non-zero), that's ok */
            flag_tailcall = (a & DUK_BC_CALL_FLAG_TAILCALL);
            flag_evalcall = (a & DUK_BC_CALL_FLAG_EVALCALL);
 
            idx = (duk_uint_fast_t) DUK_DEC_B(ins);
            if (DUK_DEC_OP(ins) == DUK_OP_CALLI) {
                duk_tval *tv_ind = DUK__REGP(idx);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
            }
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
            if (!duk_is_valid_index(ctx, (duk_idx_t) idx)) {
                /* XXX: improve check; check against nregs, not against top */
                DUK__INTERNAL_ERROR("CALL out of bounds");
            }
#endif
 
            /*
             *  To determine whether to use an optimized Ecmascript-to-Ecmascript
             *  call, we need to know whether the final, non-bound function is an
             *  Ecmascript function.
             *
             *  This is now implemented so that we start to do an ecma-to-ecma call
             *  setup which will resolve the bound chain as the first thing.  If the
             *  final function is not eligible, the return value indicates that the
             *  ecma-to-ecma call is not possible.  The setup will overwrite the call
             *  target at DUK__REGP(idx) with the final, non-bound function (which
             *  may be a lightfunc), and fudge arguments if necessary.
             *
             *  XXX: If an ecma-to-ecma call is not possible, this initial call
             *  setup will do bound function chain resolution but won't do the
             *  "effective this binding" resolution which is quite confusing.
             *  Perhaps add a helper for doing bound function and effective this
             *  binding resolution - and call that explicitly?  Ecma-to-ecma call
             *  setup and normal function handling can then assume this prestep has
             *  been done by the caller.
             */
 
            duk_set_top(ctx, (duk_idx_t) (idx + c + 2));   /* [ ... func this arg1 ... argN ] */
 
            call_flags = 0;
            if (flag_tailcall) {
                /* We request a tail call, but in some corner cases
                 * call handling can decide that a tail call is
                 * actually not possible.
                 * See: test-bug-tailcall-preventyield-assert.c.
                 */
                call_flags |= DUK_CALL_FLAG_IS_TAILCALL;
            }
 
            /* Compared to duk_handle_call():
             *   - protected call: never
             *   - ignore recursion limit: never
             */
            num_stack_args = c;
            setup_rc = duk_handle_ecma_call_setup(thr,
                                                  num_stack_args,
                                                  call_flags);
 
            if (setup_rc) {
                /* Ecma-to-ecma call possible, may or may not be a tail call.
                 * Avoid C recursion by being clever.
                 */
                DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call setup possible, restart execution"));
                /* curr_pc synced by duk_handle_ecma_call_setup() */
                goto restart_execution;
            }
            DUK_ASSERT(thr->ptr_curr_pc != NULL);  /* restored if ecma-to-ecma setup fails */
 
            DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call not possible, target is native (may be lightfunc)"));
 
            /* Recompute argument count: bound function handling may have shifted. */
            num_stack_args = duk_get_top(ctx) - (idx + 2);
            DUK_DDD(DUK_DDDPRINT("recomputed arg count: %ld\n", (long) num_stack_args));
 
            tv_func = DUK__REGP(idx);  /* Relookup if relocated */
            if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
 
                call_flags = 0;  /* not protected, respect reclimit, not constructor */
 
                /* There is no eval() special handling here: eval() is never
                 * automatically converted to a lightfunc.
                 */
                DUK_ASSERT(DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func) != duk_bi_global_object_eval);
 
                duk_handle_call_unprotected(thr,
                                            num_stack_args,
                                            call_flags);
 
                /* duk_js_call.c is required to restore the stack reserve
                 * so we only need to reset the top.
                 */
#if !defined(DUK_USE_EXEC_FUN_LOCAL)
                fun = DUK__FUN();
#endif
                duk_set_top(ctx, (duk_idx_t) fun->nregs);
 
                /* No need to reinit setjmp() catchpoint, as call handling
                 * will store and restore our state.
                 */
            } else {
                /* Call setup checks callability. */
                DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_func));
                obj_func = DUK_TVAL_GET_OBJECT(tv_func);
                DUK_ASSERT(obj_func != NULL);
                DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(obj_func));
 
                /*
                 *  Other cases, use C recursion.
                 *
                 *  If a tail call was requested we ignore it and execute a normal call.
                 *  Since Duktape 0.11.0 the compiler emits a RETURN opcode even after
                 *  a tail call to avoid test-bug-tailcall-thread-yield-resume.js.
                 *
                 *  Direct eval call: (1) call target (before following bound function
                 *  chain) is the built-in eval() function, and (2) call was made with
                 *  the identifier 'eval'.
                 */
 
                call_flags = 0;  /* not protected, respect reclimit, not constructor */
 
                if (DUK_HOBJECT_IS_NATIVEFUNCTION(obj_func) &&
                    ((duk_hnativefunction *) obj_func)->func == duk_bi_global_object_eval) {
                    if (flag_evalcall) {
                        DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was 'eval' -> direct eval"));
                        call_flags |= DUK_CALL_FLAG_DIRECT_EVAL;
                    } else {
                        DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was not 'eval' -> indirect eval"));
                    }
                }
 
                duk_handle_call_unprotected(thr,
                                            num_stack_args,
                                            call_flags);
 
                /* duk_js_call.c is required to restore the stack reserve
                 * so we only need to reset the top.
                 */
#if !defined(DUK_USE_EXEC_FUN_LOCAL)
                fun = DUK__FUN();
#endif
                duk_set_top(ctx, (duk_idx_t) fun->nregs);
 
                /* No need to reinit setjmp() catchpoint, as call handling
                 * will store and restore our state.
                 */
            }
 
            /* When debugger is enabled, we need to recheck the activation
             * status after returning.  This is now handled by call handling
             * and heap->dbg_force_restart.
             */
            break;
        }
 
        case DUK_OP_TRYCATCH: {
            duk_context *ctx = (duk_context *) thr;
            duk_activation *act;
            duk_catcher *cat;
            duk_tval *tv1;
            duk_small_uint_fast_t a;
            duk_uint_fast_t bc;
 
            /* A -> flags
             * BC -> reg_catch; base register for two registers used both during
             *       trycatch setup and when catch is triggered
             *
             *      If DUK_BC_TRYCATCH_FLAG_CATCH_BINDING set:
             *          reg_catch + 0: catch binding variable name (string).
             *          Automatic declarative environment is established for
             *          the duration of the 'catch' clause.
             *
             *      If DUK_BC_TRYCATCH_FLAG_WITH_BINDING set:
             *          reg_catch + 0: with 'target value', which is coerced to
             *          an object and then used as a bindind object for an
             *          environment record.  The binding is initialized here, for
             *          the 'try' clause.
             *
             * Note that a TRYCATCH generated for a 'with' statement has no
             * catch or finally parts.
             */
 
            /* XXX: TRYCATCH handling should be reworked to avoid creating
             * an explicit scope unless it is actually needed (e.g. function
             * instances or eval is executed inside the catch block).  This
             * rework is not trivial because the compiler doesn't have an
             * intermediate representation.  When the rework is done, the
             * opcode format can also be made more straightforward.
             */
 
            /* XXX: side effect handling is quite awkward here */
 
            DUK_DDD(DUK_DDDPRINT("TRYCATCH: reg_catch=%ld, have_catch=%ld, "
                                 "have_finally=%ld, catch_binding=%ld, with_binding=%ld (flags=0x%02lx)",
                                 (long) DUK_DEC_BC(ins),
                                 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH ? 1 : 0),
                                 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY ? 1 : 0),
                                 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING ? 1 : 0),
                                 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_WITH_BINDING ? 1 : 0),
                                 (unsigned long) DUK_DEC_A(ins)));
 
            a = DUK_DEC_A(ins);
            bc = DUK_DEC_BC(ins);
 
            act = thr->callstack + thr->callstack_top - 1;
            DUK_ASSERT(thr->callstack_top >= 1);
 
            /* 'with' target must be created first, in case we run out of memory */
            /* XXX: refactor out? */
 
            if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) {
                DUK_DDD(DUK_DDDPRINT("need to initialize a with binding object"));
 
                if (act->lex_env == NULL) {
                    DUK_ASSERT(act->var_env == NULL);
                    DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
 
                    /* must relookup act in case of side effects */
                    duk_js_init_activation_environment_records_delayed(thr, act);
                    act = thr->callstack + thr->callstack_top - 1;
                    DUK_UNREF(act);  /* 'act' is no longer accessed, scanbuild fix */
                }
                DUK_ASSERT(act->lex_env != NULL);
                DUK_ASSERT(act->var_env != NULL);
 
                (void) duk_push_object_helper(ctx,
                                              DUK_HOBJECT_FLAG_EXTENSIBLE |
                                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV),
                                              -1);  /* no prototype, updated below */
 
                duk_push_tval(ctx, DUK__REGP(bc));
                duk_to_object(ctx, -1);
                duk_dup(ctx, -1);
 
                /* [ ... env target ] */
                /* [ ... env target target ] */
 
                duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
                duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);  /* always provideThis=true */
 
                /* [ ... env ] */
 
                DUK_DDD(DUK_DDDPRINT("environment for with binding: %!iT",
                                     (duk_tval *) duk_get_tval(ctx, -1)));
            }
 
            /* allocate catcher and populate it (should be atomic) */
 
            duk_hthread_catchstack_grow(thr);
            cat = thr->catchstack + thr->catchstack_top;
            DUK_ASSERT(thr->catchstack_top + 1 <= thr->catchstack_size);
            thr->catchstack_top++;
 
            cat->flags = DUK_CAT_TYPE_TCF;
            cat->h_varname = NULL;
 
            if (a & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) {
                cat->flags |= DUK_CAT_FLAG_CATCH_ENABLED;
            }
            if (a & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY) {
                cat->flags |= DUK_CAT_FLAG_FINALLY_ENABLED;
            }
            if (a & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING) {
                DUK_DDD(DUK_DDDPRINT("catch binding flag set to catcher"));
                cat->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED;
                tv1 = DUK__REGP(bc);
                DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
 
                /* borrowed reference; although 'tv1' comes from a register,
                 * its value was loaded using LDCONST so the constant will
                 * also exist and be reachable.
                 */
                cat->h_varname = DUK_TVAL_GET_STRING(tv1);
            } else if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) {
                /* env created above to stack top */
                duk_hobject *new_env;
 
                DUK_DDD(DUK_DDDPRINT("lexenv active flag set to catcher"));
                cat->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE;
 
                DUK_DDD(DUK_DDDPRINT("activating object env: %!iT",
                                     (duk_tval *) duk_get_tval(ctx, -1)));
                new_env = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
                DUK_ASSERT(new_env != NULL);
 
                act = thr->callstack + thr->callstack_top - 1;  /* relookup (side effects) */
                DUK_ASSERT(act->lex_env != NULL);
                DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, new_env, act->lex_env);  /* side effects */
 
                act = thr->callstack + thr->callstack_top - 1;  /* relookup (side effects) */
                act->lex_env = new_env;
                DUK_HOBJECT_INCREF(thr, new_env);
                duk_pop(ctx);
            } else {
                ;
            }
 
            /* Registers 'bc' and 'bc + 1' are written in longjmp handling
             * and if their previous values (which are temporaries) become
             * unreachable -and- have a finalizer, there'll be a function
             * call during error handling which is not supported now (GH-287).
             * Ensure that both 'bc' and 'bc + 1' have primitive values to
             * guarantee no finalizer calls in error handling.  Scrubbing also
             * ensures finalizers for the previous values run here rather than
             * later.  Error handling related values are also written to 'bc'
             * and 'bc + 1' but those values never become unreachable during
             * error handling, so there's no side effect problem even if the
             * error value has a finalizer.
             */
            duk_to_undefined(ctx, bc);
            duk_to_undefined(ctx, bc + 1);
 
            cat = thr->catchstack + thr->catchstack_top - 1;  /* relookup (side effects) */
            cat->callstack_index = thr->callstack_top - 1;
            cat->pc_base = (duk_instr_t *) curr_pc;  /* pre-incremented, points to first jump slot */
            cat->idx_base = (duk_size_t) (thr->valstack_bottom - thr->valstack) + bc;
 
            DUK_DDD(DUK_DDDPRINT("TRYCATCH catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, "
                                 "idx_base=%ld, h_varname=%!O",
                                 (unsigned long) cat->flags, (long) cat->callstack_index,
                                 (long) cat->pc_base, (long) cat->idx_base, (duk_heaphdr *) cat->h_varname));
 
            curr_pc += 2;  /* skip jump slots */
            break;
        }
 
        /* Pre/post inc/dec for register variables, important for loops. */
        case DUK_OP_PREINCR:
        case DUK_OP_PREDECR:
        case DUK_OP_POSTINCR:
        case DUK_OP_POSTDECR: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_uint_fast_t bc = DUK_DEC_BC(ins);
            duk_tval *tv1, *tv2;
            duk_double_t x, y, z;
 
            /* Two lowest bits of opcode are used to distinguish
             * variants.  Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
             */
            DUK_ASSERT((DUK_OP_PREINCR & 0x03) == 0x00);
            DUK_ASSERT((DUK_OP_PREDECR & 0x03) == 0x01);
            DUK_ASSERT((DUK_OP_POSTINCR & 0x03) == 0x02);
            DUK_ASSERT((DUK_OP_POSTDECR & 0x03) == 0x03);
 
            tv1 = DUK__REGP(bc);
#if defined(DUK_USE_FASTINT)
            if (DUK_TVAL_IS_FASTINT(tv1)) {
                duk_int64_t x_fi, y_fi, z_fi;
                x_fi = DUK_TVAL_GET_FASTINT(tv1);
                if (ins & DUK_ENC_OP(0x01)) {
                    if (x_fi == DUK_FASTINT_MIN) {
                        goto skip_fastint;
                    }
                    y_fi = x_fi - 1;
                } else {
                    if (x_fi == DUK_FASTINT_MAX) {
                        goto skip_fastint;
                    }
                    y_fi = x_fi + 1;
                }
 
                DUK_TVAL_SET_FASTINT(tv1, y_fi);  /* no need for refcount update */
 
                tv2 = DUK__REGP(a);
                z_fi = (ins & DUK_ENC_OP(0x02)) ? x_fi : y_fi;
                DUK_TVAL_SET_FASTINT_UPDREF(thr, tv2, z_fi);  /* side effects */
                break;
            }
         skip_fastint:
#endif
            if (DUK_TVAL_IS_NUMBER(tv1)) {
                /* Fast path for the case where the register
                 * is a number (e.g. loop counter).
                 */
 
                x = DUK_TVAL_GET_NUMBER(tv1);
                if (ins & DUK_ENC_OP(0x01)) {
                    y = x - 1.0;
                } else {
                    y = x + 1.0;
                }
 
                DUK_TVAL_SET_NUMBER(tv1, y);  /* no need for refcount update */
            } else {
                x = duk_to_number(ctx, bc);
 
                if (ins & DUK_ENC_OP(0x01)) {
                    y = x - 1.0;
                } else {
                    y = x + 1.0;
                }
 
                duk_push_number(ctx, y);
                duk_replace(ctx, bc);
            }
 
            tv2 = DUK__REGP(a);
            z = (ins & DUK_ENC_OP(0x02)) ? x : y;
            DUK_TVAL_SET_NUMBER_UPDREF(thr, tv2, z);  /* side effects */
            break;
        }
 
        /* Preinc/predec for var-by-name, slow path. */
        case DUK_OP_PREINCV:
        case DUK_OP_PREDECV:
        case DUK_OP_POSTINCV:
        case DUK_OP_POSTDECV: {
            duk_context *ctx = (duk_context *) thr;
            duk_activation *act;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_uint_fast_t bc = DUK_DEC_BC(ins);
            duk_double_t x, y;
            duk_tval *tv1;
            duk_hstring *name;
 
            /* Two lowest bits of opcode are used to distinguish
             * variants.  Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
             */
            DUK_ASSERT((DUK_OP_PREINCV & 0x03) == 0x00);
            DUK_ASSERT((DUK_OP_PREDECV & 0x03) == 0x01);
            DUK_ASSERT((DUK_OP_POSTINCV & 0x03) == 0x02);
            DUK_ASSERT((DUK_OP_POSTDECV & 0x03) == 0x03);
 
            tv1 = DUK__CONSTP(bc);
            DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
            name = DUK_TVAL_GET_STRING(tv1);
            DUK_ASSERT(name != NULL);
            act = thr->callstack + thr->callstack_top - 1;
            (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/);  /* -> [... val this] */
 
            /* XXX: fastint fast path would be very useful here */
 
            x = duk_to_number(ctx, -2);
            duk_pop_2(ctx);
            if (ins & DUK_ENC_OP(0x01)) {
                y = x - 1.0;
            } else {
                y = x + 1.0;
            }
 
            duk_push_number(ctx, y);
            tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
            DUK_ASSERT(tv1 != NULL);
            act = thr->callstack + thr->callstack_top - 1;
            duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
            duk_pop(ctx);
 
            duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        /* Preinc/predec for object properties. */
        case DUK_OP_PREINCP:
        case DUK_OP_PREDECP:
        case DUK_OP_POSTINCP:
        case DUK_OP_POSTDECP: {
            duk_context *ctx = (duk_context *) thr;
            duk_small_uint_fast_t a = DUK_DEC_A(ins);
            duk_small_uint_fast_t b = DUK_DEC_B(ins);
            duk_small_uint_fast_t c = DUK_DEC_C(ins);
            duk_tval *tv_obj;
            duk_tval *tv_key;
            duk_tval *tv_val;
            duk_bool_t rc;
            duk_double_t x, y;
 
            /* A -> target reg
             * B -> object reg/const (may be const e.g. in "'foo'[1]")
             * C -> key reg/const
             */
 
            /* Two lowest bits of opcode are used to distinguish
             * variants.  Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
             */
            DUK_ASSERT((DUK_OP_PREINCP & 0x03) == 0x00);
            DUK_ASSERT((DUK_OP_PREDECP & 0x03) == 0x01);
            DUK_ASSERT((DUK_OP_POSTINCP & 0x03) == 0x02);
            DUK_ASSERT((DUK_OP_POSTDECP & 0x03) == 0x03);
 
            tv_obj = DUK__REGCONSTP(b);
            tv_key = DUK__REGCONSTP(c);
            rc = duk_hobject_getprop(thr, tv_obj, tv_key);  /* -> [val] */
            DUK_UNREF(rc);  /* ignore */
            tv_obj = NULL;  /* invalidated */
            tv_key = NULL;  /* invalidated */
 
            x = duk_to_number(ctx, -1);
            duk_pop(ctx);
            if (ins & DUK_ENC_OP(0x01)) {
                y = x - 1.0;
            } else {
                y = x + 1.0;
            }
 
            duk_push_number(ctx, y);
            tv_val = DUK_GET_TVAL_NEGIDX(ctx, -1);
            DUK_ASSERT(tv_val != NULL);
            tv_obj = DUK__REGCONSTP(b);
            tv_key = DUK__REGCONSTP(c);
            rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT());
            DUK_UNREF(rc);  /* ignore */
            tv_obj = NULL;  /* invalidated */
            tv_key = NULL;  /* invalidated */
            duk_pop(ctx);
 
            duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y);
            duk_replace(ctx, (duk_idx_t) a);
            break;
        }
 
        case DUK_OP_EXTRA: {
            /* XXX: shared decoding of 'b' and 'c'? */
 
            duk_small_uint_fast_t extraop = DUK_DEC_A(ins);
            switch ((int) extraop) {
            /* XXX: switch cast? */
 
            case DUK_EXTRAOP_NOP: {
                /* nop */
                break;
            }
 
            case DUK_EXTRAOP_INVALID: {
                DUK_ERROR_FMT1(thr, DUK_ERR_INTERNAL_ERROR, "INVALID opcode (%ld)", (long) DUK_DEC_BC(ins));
                break;
            }
 
            case DUK_EXTRAOP_LDTHIS: {
                /* Note: 'this' may be bound to any value, not just an object */
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk_tval *tv1, *tv2;
 
                tv1 = DUK__REGP(bc);
                tv2 = thr->valstack_bottom - 1;  /* 'this binding' is just under bottom */
                DUK_ASSERT(tv2 >= thr->valstack);
 
                DUK_DDD(DUK_DDDPRINT("LDTHIS: %!T to r%ld", (duk_tval *) tv2, (long) bc));
 
                DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2);  /* side effects */
                break;
            }
 
            case DUK_EXTRAOP_LDUNDEF: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk_tval *tv1;
 
                tv1 = DUK__REGP(bc);
                DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1);  /* side effects */
                break;
            }
 
            case DUK_EXTRAOP_LDNULL: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk_tval *tv1;
 
                tv1 = DUK__REGP(bc);
                DUK_TVAL_SET_NULL_UPDREF(thr, tv1);  /* side effects */
                break;
            }
 
            case DUK_EXTRAOP_LDTRUE:
            case DUK_EXTRAOP_LDFALSE: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk_tval *tv1;
                duk_small_uint_fast_t bval = (extraop == DUK_EXTRAOP_LDTRUE ? 1 : 0);
 
                tv1 = DUK__REGP(bc);
                DUK_TVAL_SET_BOOLEAN_UPDREF(thr, tv1, bval);  /* side effects */
                break;
            }
 
            case DUK_EXTRAOP_NEWOBJ: {
                duk_context *ctx = (duk_context *) thr;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
 
                duk_push_object(ctx);
                duk_replace(ctx, (duk_idx_t) b);
                break;
            }
 
            case DUK_EXTRAOP_NEWARR: {
                duk_context *ctx = (duk_context *) thr;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
 
                duk_push_array(ctx);
                duk_replace(ctx, (duk_idx_t) b);
                break;
            }
 
            case DUK_EXTRAOP_SETALEN: {
                duk_small_uint_fast_t b;
                duk_small_uint_fast_t c;
                duk_tval *tv1;
                duk_hobject *h;
                duk_uint32_t len;
 
                b = DUK_DEC_B(ins); tv1 = DUK__REGP(b);
                DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
                h = DUK_TVAL_GET_OBJECT(tv1);
 
                c = DUK_DEC_C(ins); tv1 = DUK__REGP(c);
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
                len = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1);
 
                duk_hobject_set_length(thr, h, len);
 
                break;
            }
 
            case DUK_EXTRAOP_TYPEOF: {
                duk_context *ctx = (duk_context *) thr;
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk_push_hstring(ctx, duk_js_typeof(thr, DUK__REGP(bc)));
                duk_replace(ctx, (duk_idx_t) bc);
                break;
            }
 
            case DUK_EXTRAOP_TYPEOFID: {
                duk_context *ctx = (duk_context *) thr;
                duk_activation *act;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
                duk_small_uint_fast_t c = DUK_DEC_C(ins);
                duk_hstring *name;
                duk_tval *tv;
 
                /* B -> target register
                 * C -> constant index of identifier name
                 */
 
                tv = DUK__REGCONSTP(c);  /* XXX: this could be a DUK__CONSTP instead */
                DUK_ASSERT(DUK_TVAL_IS_STRING(tv));
                name = DUK_TVAL_GET_STRING(tv);
                act = thr->callstack + thr->callstack_top - 1;
                if (duk_js_getvar_activation(thr, act, name, 0 /*throw*/)) {
                    /* -> [... val this] */
                    tv = DUK_GET_TVAL_NEGIDX(ctx, -2);
                    duk_push_hstring(ctx, duk_js_typeof(thr, tv));
                    duk_replace(ctx, (duk_idx_t) b);
                    duk_pop_2(ctx);
                } else {
                    /* unresolvable, no stack changes */
                    duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED);
                    duk_replace(ctx, (duk_idx_t) b);
                }
 
                break;
            }
 
            case DUK_EXTRAOP_INITENUM: {
                duk_context *ctx = (duk_context *) thr;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
                duk_small_uint_fast_t c = DUK_DEC_C(ins);
 
                /*
                 *  Enumeration semantics come from for-in statement, E5 Section 12.6.4.
                 *  If called with 'null' or 'undefined', this opcode returns 'null' as
                 *  the enumerator, which is special cased in NEXTENUM.  This simplifies
                 *  the compiler part
                 */
 
                /* B -> register for writing enumerator object
                 * C -> value to be enumerated (register)
                 */
 
                if (duk_is_null_or_undefined(ctx, (duk_idx_t) c)) {
                    duk_push_null(ctx);
                    duk_replace(ctx, (duk_idx_t) b);
                } else {
                    duk_dup(ctx, (duk_idx_t) c);
                    duk_to_object(ctx, -1);
                    duk_hobject_enumerator_create(ctx, 0 /*enum_flags*/);  /* [ ... val ] --> [ ... enum ] */
                    duk_replace(ctx, (duk_idx_t) b);
                }
                break;
            }
 
            case DUK_EXTRAOP_NEXTENUM: {
                duk_context *ctx = (duk_context *) thr;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
                duk_small_uint_fast_t c = DUK_DEC_C(ins);
 
                /*
                 *  NEXTENUM checks whether the enumerator still has unenumerated
                 *  keys.  If so, the next key is loaded to the target register
                 *  and the next instruction is skipped.  Otherwise the next instruction
                 *  will be executed, jumping out of the enumeration loop.
                 */
 
                /* B -> target register for next key
                 * C -> enum register
                 */
 
                DUK_DDD(DUK_DDDPRINT("NEXTENUM: b->%!T, c->%!T",
                                     (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b),
                                     (duk_tval *) duk_get_tval(ctx, (duk_idx_t) c)));
 
                if (duk_is_object(ctx, (duk_idx_t) c)) {
                    /* XXX: assert 'c' is an enumerator */
                    duk_dup(ctx, (duk_idx_t) c);
                    if (duk_hobject_enumerator_next(ctx, 0 /*get_value*/)) {
                        /* [ ... enum ] -> [ ... next_key ] */
                        DUK_DDD(DUK_DDDPRINT("enum active, next key is %!T, skip jump slot ",
                                             (duk_tval *) duk_get_tval(ctx, -1)));
                        curr_pc++;
                    } else {
                        /* [ ... enum ] -> [ ... ] */
                        DUK_DDD(DUK_DDDPRINT("enum finished, execute jump slot"));
                        duk_push_undefined(ctx);
                    }
                    duk_replace(ctx, (duk_idx_t) b);
                } else {
                    /* 'null' enumerator case -> behave as with an empty enumerator */
                    DUK_ASSERT(duk_is_null(ctx, (duk_idx_t) c));
                    DUK_DDD(DUK_DDDPRINT("enum is null, execute jump slot"));
                }
                break;
            }
 
            case DUK_EXTRAOP_INITSET:
            case DUK_EXTRAOP_INITSETI:
            case DUK_EXTRAOP_INITGET:
            case DUK_EXTRAOP_INITGETI: {
                duk_context *ctx = (duk_context *) thr;
                duk_bool_t is_set = (extraop == DUK_EXTRAOP_INITSET || extraop == DUK_EXTRAOP_INITSETI);
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
                duk_uint_fast_t idx;
 
                /* B -> object register
                 * C -> C+0 contains key, C+1 closure (value)
                 */
 
                /*
                 *  INITSET/INITGET are only used to initialize object literal keys.
                 *  The compiler ensures that there cannot be a previous data property
                 *  of the same name.  It also ensures that setter and getter can only
                 *  be initialized once (or not at all).
                 */
 
                idx = (duk_uint_fast_t) DUK_DEC_C(ins);
                if (extraop == DUK_EXTRAOP_INITSETI || extraop == DUK_EXTRAOP_INITGETI) {
                    duk_tval *tv_ind = DUK__REGP(idx);
                    DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
                    idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
                }
 
#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
                if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
                    /* XXX: use duk_is_valid_index() instead? */
                    /* XXX: improve check; check against nregs, not against top */
                    DUK__INTERNAL_ERROR("INITSET/INITGET out of bounds");
                }
#endif
 
                /* XXX: this is now a very unoptimal implementation -- this can be
                 * made very simple by direct manipulation of the object internals,
                 * given the guarantees above.
                 */
 
                duk_push_hobject_bidx(ctx, DUK_BIDX_OBJECT_CONSTRUCTOR);
                duk_get_prop_stridx(ctx, -1, DUK_STRIDX_DEFINE_PROPERTY);
                duk_push_undefined(ctx);
                duk_dup(ctx, (duk_idx_t) b);
                duk_dup(ctx, (duk_idx_t) (idx + 0));
                duk_push_object(ctx);  /* -> [ Object defineProperty undefined obj key desc ] */
 
                duk_push_true(ctx);
                duk_put_prop_stridx(ctx, -2, DUK_STRIDX_ENUMERABLE);
                duk_push_true(ctx);
                duk_put_prop_stridx(ctx, -2, DUK_STRIDX_CONFIGURABLE);
                duk_dup(ctx, (duk_idx_t) (idx + 1));
                duk_put_prop_stridx(ctx, -2, (is_set ? DUK_STRIDX_SET : DUK_STRIDX_GET));
 
                DUK_DDD(DUK_DDDPRINT("INITGET/INITSET: obj=%!T, key=%!T, desc=%!T",
                                     (duk_tval *) duk_get_tval(ctx, -3),
                                     (duk_tval *) duk_get_tval(ctx, -2),
                                     (duk_tval *) duk_get_tval(ctx, -1)));
 
                duk_call_method(ctx, 3);  /* -> [ Object res ] */
                duk_pop_2(ctx);
 
                DUK_DDD(DUK_DDDPRINT("INITGET/INITSET AFTER: obj=%!T",
                                     (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b)));
                break;
            }
 
            case DUK_EXTRAOP_ENDTRY: {
                duk_catcher *cat;
                duk_tval *tv1;
 
                DUK_ASSERT(thr->catchstack_top >= 1);
                DUK_ASSERT(thr->callstack_top >= 1);
                DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
 
                cat = thr->catchstack + thr->catchstack_top - 1;
 
                DUK_DDD(DUK_DDDPRINT("ENDTRY: clearing catch active flag (regardless of whether it was set or not)"));
                DUK_CAT_CLEAR_CATCH_ENABLED(cat);
 
                if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
                    DUK_DDD(DUK_DDDPRINT("ENDTRY: finally part is active, jump through 2nd jump slot with 'normal continuation'"));
 
                    tv1 = thr->valstack + cat->idx_base;
                    DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
                    DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1);  /* side effects */
                    tv1 = NULL;
 
                    tv1 = thr->valstack + cat->idx_base + 1;
                    DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
                    DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) DUK_LJ_TYPE_NORMAL);  /* side effects */
                    tv1 = NULL;
 
                    DUK_CAT_CLEAR_FINALLY_ENABLED(cat);
                } else {
                    DUK_DDD(DUK_DDDPRINT("ENDTRY: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)"));
                    duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
                    /* no need to unwind callstack */
                }
 
                curr_pc = cat->pc_base + 1;
                break;
            }
 
            case DUK_EXTRAOP_ENDCATCH: {
                duk_activation *act;
                duk_catcher *cat;
                duk_tval *tv1;
 
                DUK_ASSERT(thr->catchstack_top >= 1);
                DUK_ASSERT(thr->callstack_top >= 1);
                DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
 
                cat = thr->catchstack + thr->catchstack_top - 1;
                DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat));  /* cleared before entering catch part */
 
                act = thr->callstack + thr->callstack_top - 1;
 
                if (DUK_CAT_HAS_LEXENV_ACTIVE(cat)) {
                    duk_hobject *prev_env;
 
                    /* 'with' binding has no catch clause, so can't be here unless a normal try-catch */
                    DUK_ASSERT(DUK_CAT_HAS_CATCH_BINDING_ENABLED(cat));
                    DUK_ASSERT(act->lex_env != NULL);
 
                    DUK_DDD(DUK_DDDPRINT("ENDCATCH: popping catcher part lexical environment"));
 
                    prev_env = act->lex_env;
                    DUK_ASSERT(prev_env != NULL);
                    act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, prev_env);
                    DUK_CAT_CLEAR_LEXENV_ACTIVE(cat);
                    DUK_HOBJECT_DECREF(thr, prev_env);  /* side effects */
                }
 
                if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
                    DUK_DDD(DUK_DDDPRINT("ENDCATCH: finally part is active, jump through 2nd jump slot with 'normal continuation'"));
 
                    tv1 = thr->valstack + cat->idx_base;
                    DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
                    DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1);  /* side effects */
                    tv1 = NULL;
 
                    tv1 = thr->valstack + cat->idx_base + 1;
                    DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
                    DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) DUK_LJ_TYPE_NORMAL);  /* side effects */
                    tv1 = NULL;
 
                    DUK_CAT_CLEAR_FINALLY_ENABLED(cat);
                } else {
                    DUK_DDD(DUK_DDDPRINT("ENDCATCH: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)"));
                    duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
                    /* no need to unwind callstack */
                }
 
                curr_pc = cat->pc_base + 1;
                break;
            }
 
            case DUK_EXTRAOP_ENDFIN: {
                duk_context *ctx = (duk_context *) thr;
                duk_catcher *cat;
                duk_tval *tv1;
                duk_small_uint_t cont_type;
                duk_small_uint_t ret_result;
 
                /* Sync and NULL early. */
                DUK__SYNC_AND_NULL_CURR_PC();
 
                DUK_ASSERT(thr->catchstack_top >= 1);
                DUK_ASSERT(thr->callstack_top >= 1);
                DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
 
                cat = thr->catchstack + thr->catchstack_top - 1;
 
                /* CATCH flag may be enabled or disabled here; it may be enabled if
                 * the statement has a catch block but the try block does not throw
                 * an error.
                 */
                DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat));  /* cleared before entering finally */
                /* XXX: assert idx_base */
 
                DUK_DDD(DUK_DDDPRINT("ENDFIN: completion value=%!T, type=%!T",
                                     (duk_tval *) (thr->valstack + cat->idx_base + 0),
                                     (duk_tval *) (thr->valstack + cat->idx_base + 1)));
 
                tv1 = thr->valstack + cat->idx_base + 1;  /* type */
                DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
                cont_type = (duk_small_uint_t) DUK_TVAL_GET_NUMBER(tv1);
 
                switch (cont_type) {
                case DUK_LJ_TYPE_NORMAL: {
                    DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'normal' (non-abrupt) completion -> "
                                         "dismantle catcher, resume execution after ENDFIN"));
                    duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
                    /* no need to unwind callstack */
                    goto restart_execution;
                }
                case DUK_LJ_TYPE_RETURN: {
                    DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'return' complation -> dismantle "
                                         "catcher, handle return, lj.value1=%!T", thr->valstack + cat->idx_base));
 
                    /* Not necessary to unwind catchstack: return handling will
                     * do it.  The finally flag of 'cat' is no longer set.  The
                     * catch flag may be set, but it's not checked by return handling.
                     */
                    DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat));  /* cleared before entering finally */
#if 0
                    duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
#endif
 
                    duk_push_tval(ctx, thr->valstack + cat->idx_base);
                    ret_result = duk__handle_return(thr,
                                                entry_thread,
                                                entry_callstack_top);
                    if (ret_result == DUK__RETHAND_RESTART) {
                        goto restart_execution;
                    }
                    DUK_ASSERT(ret_result == DUK__RETHAND_FINISHED);
 
                    DUK_DDD(DUK_DDDPRINT("exiting executor after ENDFIN and RETURN (pseudo) longjmp type"));
                    return;
                }
                case DUK_LJ_TYPE_BREAK:
                case DUK_LJ_TYPE_CONTINUE: {
                    duk_uint_t label_id;
                    duk_small_uint_t lj_type;
 
                    /* Not necessary to unwind catchstack: break/continue
                     * handling will do it.  The finally flag of 'cat' is
                     * no longer set.  The catch flag may be set, but it's
                     * not checked by break/continue handling.
                     */
#if 0
                    duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
#endif
 
                    tv1 = thr->valstack + cat->idx_base;
                    DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
#if defined(DUK_USE_FASTINT)
                    DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv1));
                    label_id = (duk_small_uint_t) DUK_TVAL_GET_FASTINT_U32(tv1);
#else
                    label_id = (duk_small_uint_t) DUK_TVAL_GET_NUMBER(tv1);
#endif
                    lj_type = cont_type;
                    duk__handle_break_or_continue(thr, label_id, lj_type);
                    goto restart_execution;
                }
                default: {
                    DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with abrupt completion, lj_type=%ld -> "
                                         "dismantle catcher, re-throw error",
                                         (long) cont_type));
 
                    duk_push_tval(ctx, thr->valstack + cat->idx_base);
 
                    duk_err_setup_heap_ljstate(thr, (duk_small_int_t) cont_type);
 
                    DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* always in executor */
                    duk_err_longjmp(thr);
                    DUK_UNREACHABLE();
                }
                }
 
                /* Must restart in all cases because we NULLed thr->ptr_curr_pc. */
                DUK_UNREACHABLE();
                break;
            }
 
            case DUK_EXTRAOP_THROW: {
                duk_context *ctx = (duk_context *) thr;
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
 
                /* Note: errors are augmented when they are created, not
                 * when they are thrown.  So, don't augment here, it would
                 * break re-throwing for instance.
                 */
 
                /* Sync so that augmentation sees up-to-date activations, NULL
                 * thr->ptr_curr_pc so that it's not used if side effects occur
                 * in augmentation or longjmp handling.
                 */
                DUK__SYNC_AND_NULL_CURR_PC();
 
                duk_dup(ctx, (duk_idx_t) bc);
                DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (before throw augment)",
                                     (duk_tval *) duk_get_tval(ctx, -1)));
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
                duk_err_augment_error_throw(thr);
                DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (after throw augment)",
                                     (duk_tval *) duk_get_tval(ctx, -1)));
#endif
 
                duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
 
                DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* always in executor */
                duk_err_longjmp(thr);
                DUK_UNREACHABLE();
                break;
            }
 
            case DUK_EXTRAOP_INVLHS: {
                DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "invalid lvalue");
 
                DUK_UNREACHABLE();
                break;
            }
 
            case DUK_EXTRAOP_UNM:
            case DUK_EXTRAOP_UNP: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk__vm_arith_unary_op(thr, DUK__REGP(bc), bc, extraop);
                break;
            }
 
            case DUK_EXTRAOP_DEBUGGER: {
                /* Opcode only emitted by compiler when debugger
                 * support is enabled.  Ignore it silently without
                 * debugger support, in case it has been loaded
                 * from precompiled bytecode.
                 */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
                if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
                    DUK_D(DUK_DPRINT("DEBUGGER statement encountered, halt execution"));
                    DUK__SYNC_AND_NULL_CURR_PC();
                    duk_debug_halt_execution(thr, 1 /*use_prev_pc*/);
                    DUK_D(DUK_DPRINT("DEBUGGER statement finished, resume execution"));
                    goto restart_execution;
                } else {
                    DUK_D(DUK_DPRINT("DEBUGGER statement ignored, debugger not attached"));
                }
#else
                DUK_D(DUK_DPRINT("DEBUGGER statement ignored, no debugger support"));
#endif
                break;
            }
 
            case DUK_EXTRAOP_BREAK: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
 
                DUK_DDD(DUK_DDDPRINT("BREAK: %ld", (long) bc));
 
                DUK__SYNC_AND_NULL_CURR_PC();
                duk__handle_break_or_continue(thr, (duk_uint_t) bc, DUK_LJ_TYPE_BREAK);
                goto restart_execution;
            }
 
            case DUK_EXTRAOP_CONTINUE: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
 
                DUK_DDD(DUK_DDDPRINT("CONTINUE: %ld", (long) bc));
 
                DUK__SYNC_AND_NULL_CURR_PC();
                duk__handle_break_or_continue(thr, (duk_uint_t) bc, DUK_LJ_TYPE_CONTINUE);
                goto restart_execution;
            }
 
            case DUK_EXTRAOP_BNOT: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
 
                duk__vm_bitwise_not(thr, DUK__REGP(bc), bc);
                break;
            }
 
            case DUK_EXTRAOP_LNOT: {
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
                duk_tval *tv1;
 
                tv1 = DUK__REGP(bc);
                duk__vm_logical_not(thr, tv1, tv1);
                break;
            }
 
            case DUK_EXTRAOP_INSTOF: {
                duk_context *ctx = (duk_context *) thr;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
                duk_small_uint_fast_t c = DUK_DEC_C(ins);
                duk_bool_t tmp;
 
                tmp = duk_js_instanceof(thr, DUK__REGP(b), DUK__REGCONSTP(c));
                duk_push_boolean(ctx, tmp);
                duk_replace(ctx, (duk_idx_t) b);
                break;
            }
 
            case DUK_EXTRAOP_IN: {
                duk_context *ctx = (duk_context *) thr;
                duk_small_uint_fast_t b = DUK_DEC_B(ins);
                duk_small_uint_fast_t c = DUK_DEC_C(ins);
                duk_bool_t tmp;
 
                tmp = duk_js_in(thr, DUK__REGP(b), DUK__REGCONSTP(c));
                duk_push_boolean(ctx, tmp);
                duk_replace(ctx, (duk_idx_t) b);
                break;
            }
 
            case DUK_EXTRAOP_LABEL: {
                duk_catcher *cat;
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
 
                /* allocate catcher and populate it (should be atomic) */
 
                duk_hthread_catchstack_grow(thr);
                cat = thr->catchstack + thr->catchstack_top;
                thr->catchstack_top++;
 
                cat->flags = DUK_CAT_TYPE_LABEL | (bc << DUK_CAT_LABEL_SHIFT);
                cat->callstack_index = thr->callstack_top - 1;
                cat->pc_base = (duk_instr_t *) curr_pc;  /* pre-incremented, points to first jump slot */
                cat->idx_base = 0;  /* unused for label */
                cat->h_varname = NULL;
 
                DUK_DDD(DUK_DDDPRINT("LABEL catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, "
                                     "idx_base=%ld, h_varname=%!O, label_id=%ld",
                                     (long) cat->flags, (long) cat->callstack_index, (long) cat->pc_base,
                                     (long) cat->idx_base, (duk_heaphdr *) cat->h_varname, (long) DUK_CAT_GET_LABEL(cat)));
 
                curr_pc += 2;  /* skip jump slots */
                break;
            }
 
            case DUK_EXTRAOP_ENDLABEL: {
                duk_catcher *cat;
#if defined(DUK_USE_DDDPRINT) || defined(DUK_USE_ASSERTIONS)
                duk_uint_fast_t bc = DUK_DEC_BC(ins);
#endif
#if defined(DUK_USE_DDDPRINT)
                DUK_DDD(DUK_DDDPRINT("ENDLABEL %ld", (long) bc));
#endif
 
                DUK_ASSERT(thr->catchstack_top >= 1);
 
                cat = thr->catchstack + thr->catchstack_top - 1;
                DUK_UNREF(cat);
                DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL);
                DUK_ASSERT((duk_uint_fast_t) DUK_CAT_GET_LABEL(cat) == bc);
 
                duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
                /* no need to unwind callstack */
                break;
            }
 
            default: {
                DUK__INTERNAL_ERROR("invalid extra opcode");
            }
 
            }  /* end switch */
 
            break;
        }
 

◆ duk__js_samevalue_number()

DUK_LOCAL duk_bool_t duk__js_samevalue_number	(	duk_double_t	x,
		duk_double_t	y )

Definition at line 70575 of file duktape-1.8.0/src/duktape.c.

                {
        /* IEEE requires that NaNs compare false */
        DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN);
        DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN);
        return 1;
    } else {
        /* IEEE requires that zeros compare the same regardless
         * of their signed, so if both x and y are zeroes, they
         * are caught above.
         */
        DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO));
        return 0;
    }
#endif  /* DUK_USE_PARANOID_MATH */
}
 
DUK_LOCAL duk_bool_t duk__js_samevalue_number(duk_double_t x, duk_double_t y) {
#if defined(DUK_USE_PARANOID_MATH)
    duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
 
    if (cx == DUK_FP_NAN && cy == DUK_FP_NAN) {
        /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
        return 1;
    }
    if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
        /* Note: cannot assume that a non-zero return value of signbit() would
         * always be the same -- hence cannot (portably) use something like:
         *
         *     signbit(x) == signbit(y)
         */
        duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
        duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
        return (sx == sy);
    }
 
    /* normal comparison; known:
     *   - both x and y are not NaNs (but one of them can be)
     *   - both x and y are not zero (but one of them can be)
     *   - x and y may be denormal or infinite
     */
 
    return (x == y);
#else  /* DUK_USE_PARANOID_MATH */
    duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
 
    if (x == y) {
        /* IEEE requires that NaNs compare false */
        DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN);
        DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN);
 
        /* Using classification has smaller footprint than direct comparison. */
        if (DUK_UNLIKELY(cx == DUK_FP_ZERO && cy == DUK_FP_ZERO)) {
            /* Note: cannot assume that a non-zero return value of signbit() would
             * always be the same -- hence cannot (portably) use something like:
             *
             *     signbit(x) == signbit(y)
             */
            duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
            duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
            return (sx == sy);
        }
        return 1;
    } else {

References DUK_ASSERT, DUK_FP_NAN, and DUK_FPCLASSIFY.

◆ duk__key_is_lightfunc_ownprop()

DUK_LOCAL duk_bool_t duk__key_is_lightfunc_ownprop	(	duk_hthread *	thr,
		duk_hstring *	key )

Definition at line 47584 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_hobject_putprop().

◆ duk__load_buffer_raw()

DUK_LOCAL duk_uint8_t * duk__load_buffer_raw	(	duk_context *	ctx,
		duk_uint8_t *	p )

Definition at line 11684 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_uint32_t len;
 

References DUK_RAW_READ_U32_BE.

◆ duk__load_func()

static duk_uint8_t * duk__load_func	(	duk_context *	ctx,
		duk_uint8_t *	p,
		duk_uint8_t *	p_end )

static

Definition at line 12019 of file duktape-1.8.0/src/duktape.c.

                               { \
        DUK_ASSERT((duk_size_t) (p_end - p) >= (duk_size_t) (n)); \
    } while (0)
 
static duk_uint8_t *duk__load_func(duk_context *ctx, duk_uint8_t *p, duk_uint8_t *p_end) {
    duk_hthread *thr;
    duk_hcompiledfunction *h_fun;
    duk_hbuffer *h_data;
    duk_size_t data_size;
    duk_uint32_t count_instr, count_const, count_funcs;
    duk_uint32_t n;
    duk_uint32_t tmp32;
    duk_small_uint_t const_type;
    duk_uint8_t *fun_data;
    duk_uint8_t *q;
    duk_idx_t idx_base;
    duk_tval *tv1;
    duk_uarridx_t arr_idx;
 
    /* XXX: There's some overlap with duk_js_closure() here, but
     * seems difficult to share code.  Ensure that the final function
     * looks the same as created by duk_js_closure().
     */
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
 
    DUK_DD(DUK_DDPRINT("loading function, p=%p, p_end=%p", (void *) p, (void *) p_end));
 
    DUK__ASSERT_LEFT(3 * 4);
    count_instr = DUK_RAW_READ_U32_BE(p);
    count_const = DUK_RAW_READ_U32_BE(p);
    count_funcs = DUK_RAW_READ_U32_BE(p);
 
    data_size = sizeof(duk_tval) * count_const +
                sizeof(duk_hobject *) * count_funcs +
                sizeof(duk_instr_t) * count_instr;
 
    DUK_DD(DUK_DDPRINT("instr=%ld, const=%ld, funcs=%ld, data_size=%ld",
                       (long) count_instr, (long) count_const,
                       (long) count_const, (long) data_size));
 
    /* Value stack is used to ensure reachability of constants and
     * inner functions being loaded.  Require enough space to handle
     * large functions correctly.
     */
    duk_require_stack(ctx, 2 + count_const + count_funcs);
    idx_base = duk_get_top(ctx);
 
    /* Push function object, init flags etc.  This must match
     * duk_js_push_closure() quite carefully.
     */
    duk_push_compiledfunction(ctx);
    h_fun = duk_get_hcompiledfunction(ctx, -1);
    DUK_ASSERT(h_fun != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) h_fun));
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, h_fun) == NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, h_fun) == NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, h_fun) == NULL);
 
    h_fun->nregs = DUK_RAW_READ_U16_BE(p);
    h_fun->nargs = DUK_RAW_READ_U16_BE(p);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    h_fun->start_line = DUK_RAW_READ_U32_BE(p);
    h_fun->end_line = DUK_RAW_READ_U32_BE(p);
#else
    p += 8;  /* skip line info */
#endif
 
    /* duk_hcompiledfunction flags; quite version specific */
    tmp32 = DUK_RAW_READ_U32_BE(p);
    DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32);
 
    /* standard prototype */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &h_fun->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
 
    /* assert just a few critical flags */
    DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h_fun) == DUK_HTYPE_OBJECT);
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&h_fun->obj));
    DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&h_fun->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&h_fun->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&h_fun->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&h_fun->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&h_fun->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&h_fun->obj));
 
    /* Create function 'data' buffer but don't attach it yet. */
    fun_data = (duk_uint8_t *) duk_push_fixed_buffer(ctx, data_size);
    DUK_ASSERT(fun_data != NULL);
 
    /* Load bytecode instructions. */
    DUK_ASSERT(sizeof(duk_instr_t) == 4);
    DUK__ASSERT_LEFT(count_instr * sizeof(duk_instr_t));
#if defined(DUK_USE_INTEGER_BE)
    q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
    DUK_MEMCPY((void *) q,
               (const void *) p,
               sizeof(duk_instr_t) * count_instr);
    p += sizeof(duk_instr_t) * count_instr;
#else
    q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
    for (n = count_instr; n > 0; n--) {
        *((duk_instr_t *) (void *) q) = DUK_RAW_READ_U32_BE(p);
        q += sizeof(duk_instr_t);
    }
#endif
 
    /* Load constants onto value stack but don't yet copy to buffer. */
    for (n = count_const; n > 0; n--) {
        DUK__ASSERT_LEFT(1);
        const_type = DUK_RAW_READ_U8(p);
        switch (const_type) {
        case DUK__SER_STRING: {
            p = duk__load_string_raw(ctx, p);
            break;
        }
        case DUK__SER_NUMBER: {
            /* Important to do a fastint check so that constants are
             * properly read back as fastints.
             */
            duk_tval tv_tmp;
            duk_double_t val;
            DUK__ASSERT_LEFT(8);
            val = DUK_RAW_READ_DOUBLE_BE(p);
            DUK_TVAL_SET_NUMBER_CHKFAST(&tv_tmp, val);
            duk_push_tval(ctx, &tv_tmp);
            break;
        }
        default: {
            goto format_error;
        }
        }
    }
 
    /* Load inner functions to value stack, but don't yet copy to buffer. */
    for (n = count_funcs; n > 0; n--) {
        p = duk__load_func(ctx, p, p_end);
        if (p == NULL) {
            goto format_error;
        }
    }
 
    /* With constants and inner functions on value stack, we can now
     * atomically finish the function 'data' buffer, bump refcounts,
     * etc.
     *
     * Here we take advantage of the value stack being just a duk_tval
     * array: we can just memcpy() the constants as long as we incref
     * them afterwards.
     */
 
    h_data = (duk_hbuffer *) duk_get_hbuffer(ctx, idx_base + 1);
    DUK_ASSERT(h_data != NULL);
    DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC(h_data));
    DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_fun, h_data);
    DUK_HBUFFER_INCREF(thr, h_data);
 
    tv1 = duk_get_tval(ctx, idx_base + 2);  /* may be NULL if no constants or inner funcs */
    DUK_ASSERT((count_const == 0 && count_funcs == 0) || tv1 != NULL);
 
    q = fun_data;
    if (count_const > 0) {
        /* Explicit zero size check to avoid NULL 'tv1'. */
        DUK_MEMCPY((void *) q, (const void *) tv1, sizeof(duk_tval) * count_const);
        for (n = count_const; n > 0; n--) {
            DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q);  /* no side effects */
            q += sizeof(duk_tval);
        }
        tv1 += count_const;
    }
 
    DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_fun, (duk_hobject **) (void *) q);
    for (n = count_funcs; n > 0; n--) {
        duk_hobject *h_obj;
 
        DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
        h_obj = DUK_TVAL_GET_OBJECT(tv1);
        DUK_ASSERT(h_obj != NULL);
        tv1++;
        DUK_HOBJECT_INCREF(thr, h_obj);
 
        *((duk_hobject **) (void *) q) = h_obj;
        q += sizeof(duk_hobject *);
    }
 
    DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_fun, (duk_instr_t *) (void *) q);
 
    /* The function object is now reachable and refcounts are fine,
     * so we can pop off all the temporaries.
     */
    DUK_DDD(DUK_DDDPRINT("function is reachable, reset top; func: %!iT", duk_get_tval(ctx, idx_base)));
    duk_set_top(ctx, idx_base + 1);
 
    /* Setup function properties. */
    tmp32 = DUK_RAW_READ_U32_BE(p);
    duk_push_u32(ctx, tmp32);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
 
    p = duk__load_string_raw(ctx, p);
    if (DUK_HOBJECT_HAS_NAMEBINDING((duk_hobject *) h_fun)) {
        /* Original function instance/template had NAMEBINDING.
         * Must create a lexical environment on loading to allow
         * recursive functions like 'function foo() { foo(); }'.
         */
        duk_hobject *proto;
 
        proto = thr->builtins[DUK_BIDX_GLOBAL_ENV];
        (void) duk_push_object_helper_proto(ctx,
                                            DUK_HOBJECT_FLAG_EXTENSIBLE |
                                            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
                                            proto);
        duk_dup(ctx, -2);                                 /* -> [ func funcname env funcname ] */
        duk_dup(ctx, idx_base);                           /* -> [ func funcname env funcname func ] */
        duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE);  /* -> [ func funcname env ] */
        duk_xdef_prop_stridx(ctx, idx_base, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
        /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
         * will be ignored anyway
         */
    }
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
 
    p = duk__load_string_raw(ctx, p);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC);
 
    duk_push_object(ctx);
    duk_dup(ctx, -2);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC);  /* func.prototype.constructor = func */
    duk_compact(ctx, -1);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W);
 
    p = duk__load_buffer_raw(ctx, p);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_WC);
 
    duk_push_object(ctx);  /* _Varmap */
    for (;;) {
        /* XXX: awkward */
        p = duk__load_string_raw(ctx, p);
        if (duk_get_length(ctx, -1) == 0) {
            duk_pop(ctx);
            break;
        }
        tmp32 = DUK_RAW_READ_U32_BE(p);
        duk_push_u32(ctx, tmp32);
        duk_put_prop(ctx, -3);
    }
    duk_compact(ctx, -1);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE);
 
    duk_push_array(ctx);  /* _Formals */
    for (arr_idx = 0; ; arr_idx++) {
        /* XXX: awkward */
        p = duk__load_string_raw(ctx, p);

◆ duk__load_string_raw()

DUK_LOCAL duk_uint8_t * duk__load_string_raw	(	duk_context *	ctx,
		duk_uint8_t *	p )

Definition at line 11675 of file duktape-1.8.0/src/duktape.c.

◆ duk__log()

DUK_LOCAL double duk__log ( double x )

Definition at line 32759 of file duktape-1.8.0/src/duktape.c.

32761 {

◆ duk__lookup_active_label()

DUK_LOCAL_DECL void duk__lookup_active_label	(	duk_compiler_ctx *	comp_ctx,
		duk_hstring *	h_label,
		duk_bool_t	is_break,
		duk_int_t *	out_label_id,
		duk_int_t *	out_label_catch_depth,
		duk_int_t *	out_label_pc,
		duk_bool_t *	out_is_closest )

Definition at line 60357 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                                                                                               {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_uint8_t *p;
    duk_labelinfo *li_start, *li_end, *li;
    duk_bool_t match = 0;
 
    DUK_DDD(DUK_DDDPRINT("looking up active label: label='%!O', is_break=%ld",
                         (duk_heaphdr *) h_label, (long) is_break));
 
    DUK_UNREF(ctx);
 
    p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
    li_start = (duk_labelinfo *) (void *) p;
    li_end = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
    li = li_end;
 
    /* Match labels starting from latest label because there can be duplicate empty
     * labels in the label set.
     */
    while (li > li_start) {
        li--;
 
        if (li->h_label != h_label) {
            DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] ->'%!O' != %!O",
                                 (long) (li - li_start),
                                 (duk_heaphdr *) li->h_label,
                                 (duk_heaphdr *) h_label));
            continue;
        }
 
        DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] -> '%!O' label name matches (still need to check type)",
                             (long) (li - li_start), (duk_heaphdr *) h_label));
 
        /* currently all labels accept a break, so no explicit check for it now */
        DUK_ASSERT(li->flags & DUK_LABEL_FLAG_ALLOW_BREAK);
 
        if (is_break) {
            /* break matches always */
            match = 1;
            break;
        } else if (li->flags & DUK_LABEL_FLAG_ALLOW_CONTINUE) {
            /* iteration statements allow continue */
            match = 1;
            break;
        } else {
            /* continue matched this label -- we can only continue if this is the empty
             * label, for which duplication is allowed, and thus there is hope of
             * finding a match deeper in the label stack.
             */
            if (h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) {
                DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_LABEL);
            } else {
                DUK_DDD(DUK_DDDPRINT("continue matched an empty label which does not "
                                     "allow a continue -> continue lookup deeper in label stack"));

◆ duk__lookup_active_register_binding()

DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding ( duk_compiler_ctx * comp_ctx )

Definition at line 60154 of file duktape-1.8.0/src/duktape.c.

                                                                                            {
    return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
}
 
/* The issues below can be solved with better flags */
 
/* XXX: many operations actually want toforcedtemp() -- brand new temp? */
/* XXX: need a toplain_ignore() which will only coerce a value to a temp
 * register if it might have a side effect.  Side-effect free values do not
 * need to be coerced.
 */
 
/*
 *  Identifier handling
 */
 
DUK_LOCAL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *h_varname;
    duk_reg_t ret;
 
    DUK_DDD(DUK_DDDPRINT("resolving identifier reference to '%!T'",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    /*
     *  Special name handling
     */
 
    h_varname = duk_get_hstring(ctx, -1);
    DUK_ASSERT(h_varname != NULL);
 
    if (h_varname == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)) {
        DUK_DDD(DUK_DDDPRINT("flagging function as accessing 'arguments'"));
        comp_ctx->curr_func.id_access_arguments = 1;
    }
 
    /*
     *  Inside one or more 'with' statements fall back to slow path always.
     *  (See e.g. test-stmt-with.js.)
     */
 
    if (comp_ctx->curr_func.with_depth > 0) {
        DUK_DDD(DUK_DDDPRINT("identifier lookup inside a 'with' -> fall back to slow path"));
        goto slow_path;
    }
 
    /*
     *  Any catch bindings ("catch (e)") also affect identifier binding.
     *
     *  Currently, the varmap is modified for the duration of the catch
     *  clause to ensure any identifier accesses with the catch variable
     *  name will use slow path.
     */
 
    duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);

References DUK__IVAL_FLAG_ALLOW_CONST, DUK__IVAL_FLAG_REQUIRE_TEMP, and duk__ivalue_toregconst_raw().

◆ duk__lookup_arguments_map()

DUK_LOCAL duk_bool_t duk__lookup_arguments_map	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_propdesc *	temp_desc,
		duk_hobject **	out_map,
		duk_hobject **	out_varenv )

Definition at line 48806 of file duktape-1.8.0/src/duktape.c.

                                                               {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *map;
    duk_hobject *varenv;
    duk_bool_t rc;
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    DUK_DDD(DUK_DDDPRINT("arguments map lookup: thr=%p, obj=%p, key=%p, temp_desc=%p "
                         "(obj -> %!O, key -> %!O)",
                         (void *) thr, (void *) obj, (void *) key, (void *) temp_desc,
                         (duk_heaphdr *) obj, (duk_heaphdr *) key));
 
    if (!duk_hobject_get_own_propdesc(thr, obj, DUK_HTHREAD_STRING_INT_MAP(thr), temp_desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
        DUK_DDD(DUK_DDDPRINT("-> no 'map'"));
        return 0;
    }
 
    map = duk_require_hobject(ctx, -1);
    DUK_ASSERT(map != NULL);
    duk_pop(ctx);  /* map is reachable through obj */
 
    if (!duk_hobject_get_own_propdesc(thr, map, key, temp_desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
        DUK_DDD(DUK_DDDPRINT("-> 'map' exists, but key not in map"));
        return 0;
    }
 
    /* [... varname] */
    DUK_DDD(DUK_DDDPRINT("-> 'map' exists, and contains key, key is mapped to argument/variable binding %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));

Referenced by duk_hobject_define_property_helper().

◆ duk__lookup_lhs()

DUK_LOCAL_DECL duk_bool_t duk__lookup_lhs	(	duk_compiler_ctx *	ctx,
		duk_reg_t *	out_reg_varbind,
		duk_regconst_t *	out_rc_varname )

Definition at line 60220 of file duktape-1.8.0/src/duktape.c.

          :
    DUK_DDD(DUK_DDDPRINT("identifier lookup -> slow path"));
 
    comp_ctx->curr_func.id_access_slow = 1;
    return (duk_reg_t) -1;
}
 
/* Lookup an identifier name in the current varmap, indicating whether the
 * identifier is register-bound and if not, allocating a constant for the
 * identifier name.  Returns 1 if register-bound, 0 otherwise.  Caller can
 * also check (out_reg_varbind >= 0) to check whether or not identifier is
 * register bound.  The caller must NOT use out_rc_varname at all unless
 * return code is 0 or out_reg_varbind is < 0; this is becuase out_rc_varname
 * is unsigned and doesn't have a "unused" / none value.
 */
DUK_LOCAL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *comp_ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_reg_t reg_varbind;
    duk_regconst_t rc_varname;
 

Referenced by duk__parse_var_decl().

◆ duk__make_day()

DUK_LOCAL duk_double_t duk__make_day	(	duk_double_t	year,
		duk_double_t	month,
		duk_double_t	day )

Definition at line 25156 of file duktape-1.8.0/src/duktape.c.

                                                                                    : 365));
            return year;
        }
 
        /* Note: this is very tricky; we must never 'overshoot' the
         * correction downwards.
         */
        year -= 1 + (diff_days - 1) / 366;  /* conservative */
    }
}
 
/* Given a (year, month, day-within-month) triple, compute day number.
 * The input triple is un-normalized and may contain non-finite values.
 */
DUK_LOCAL duk_double_t duk__make_day(duk_double_t year, duk_double_t month, duk_double_t day) {
    duk_int_t day_num;
    duk_bool_t is_leap;
    duk_small_int_t i, n;
 
    /* Assume that year, month, day are all coerced to whole numbers.
     * They may also be NaN or infinity, in which case this function
     * must return NaN or infinity to ensure time value becomes NaN.
     * If 'day' is NaN, the final return will end up returning a NaN,
     * so it doesn't need to be checked here.
     */
 
    if (!DUK_ISFINITE(year) || !DUK_ISFINITE(month)) {
        return DUK_DOUBLE_NAN;
    }
 
    year += DUK_FLOOR(month / 12.0);
 
    month = DUK_FMOD(month, 12.0);
    if (month < 0.0) {
        /* handle negative values */
        month += 12.0;
    }
 
    /* The algorithm in E5.1 Section 15.9.1.12 normalizes month, but
     * does not normalize the day-of-month (nor check whether or not
     * it is finite) because it's not necessary for finding the day
     * number which matches the (year,month) pair.
     *
     * We assume that duk__day_from_year() is exact here.
     *
     * Without an explicit infinity / NaN check in the beginning,
     * day_num would be a bogus integer here.
     *
     * It's possible for 'year' to be out of integer range here.
     * If so, we need to return NaN without integer overflow.
     * This fixes test-bug-setyear-overflow.js.
     */
 
    if (!duk_bi_date_year_in_valid_range(year)) {

◆ duk__mark_finalizable()

DUK_LOCAL void duk__mark_finalizable ( duk_heap * heap )

Definition at line 42440 of file duktape-1.8.0/src/duktape.c.

                                                     {
    duk_hthread *thr;
    duk_heaphdr *hdr;
    duk_size_t count_finalizable = 0;
 
    DUK_DD(DUK_DDPRINT("duk__mark_finalizable: %p", (void *) heap));
 
    thr = duk__get_temp_hthread(heap);
    DUK_ASSERT(thr != NULL);
 
    hdr = heap->heap_allocated;
    while (hdr) {
        /* A finalizer is looked up from the object and up its prototype chain
         * (which allows inherited finalizers).  A prototype loop must not cause
         * an error to be thrown here; duk_hobject_hasprop_raw() will ignore a
         * prototype loop silently and indicate that the property doesn't exist.
         */
 
        if (!DUK_HEAPHDR_HAS_REACHABLE(hdr) &&
            DUK_HEAPHDR_GET_TYPE(hdr) == DUK_HTYPE_OBJECT &&
            !DUK_HEAPHDR_HAS_FINALIZED(hdr) &&
            duk_hobject_hasprop_raw(thr, (duk_hobject *) hdr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
 
            /* heaphdr:
             *  - is not reachable
             *  - is an object
             *  - is not a finalized object
             *  - has a finalizer
             */
 
            DUK_DD(DUK_DDPRINT("unreachable heap object will be "
                               "finalized -> mark as finalizable "
                               "and treat as a reachability root: %p",
                               (void *) hdr));
            DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(hdr));
            DUK_HEAPHDR_SET_FINALIZABLE(hdr);
            count_finalizable ++;
        }
 
        hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
    }
 
    if (count_finalizable == 0) {

◆ duk__mark_finalize_list()

DUK_LOCAL void duk__mark_finalize_list ( duk_heap * heap )

Definition at line 42506 of file duktape-1.8.0/src/duktape.c.

                {
        if (DUK_HEAPHDR_HAS_FINALIZABLE(hdr)) {
            duk__mark_heaphdr(heap, hdr);
        }
 
        hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
    }
 
    /* Caller will finish the marking process if we hit a recursion limit. */
}
 
/*
 *  Mark objects on finalize_list.
 *
 */
 
DUK_LOCAL void duk__mark_finalize_list(duk_heap *heap) {
    duk_heaphdr *hdr;
#ifdef DUK_USE_DEBUG
    duk_size_t count_finalize_list = 0;
#endif
 
    DUK_DD(DUK_DDPRINT("duk__mark_finalize_list: %p", (void *) heap));

References duk__mark_heaphdr(), DUK_HEAPHDR_GET_NEXT, and DUK_HEAPHDR_HAS_FINALIZABLE.

◆ duk__mark_heaphdr()

DUK_LOCAL_DECL void duk__mark_heaphdr	(	duk_heap *	heap,
		duk_heaphdr *	h )

Definition at line 42319 of file duktape-1.8.0/src/duktape.c.

                                                                    {
            duk_catcher *cat = t->catchstack + i;
        }
#endif
 
        duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer);
 
        /* XXX: duk_small_uint_t would be enough for this loop */
        for (i = 0; i < DUK_NUM_BUILTINS; i++) {
            duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]);
        }
    }
}
 
/* recursion tracking happens here only */
DUK_LOCAL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h) {
    DUK_DDD(DUK_DDDPRINT("duk__mark_heaphdr %p, type %ld",
                         (void *) h,
                         (h != NULL ? (long) DUK_HEAPHDR_GET_TYPE(h) : (long) -1)));
    if (!h) {
        return;
    }
#if defined(DUK_USE_ROM_OBJECTS)
    if (DUK_HEAPHDR_HAS_READONLY(h)) {
        DUK_DDD(DUK_DDDPRINT("readonly object %p, skip", (void *) h));
        return;
    }
#endif
    if (DUK_HEAPHDR_HAS_REACHABLE(h)) {
        DUK_DDD(DUK_DDDPRINT("already marked reachable, skip"));
        return;
    }
    DUK_HEAPHDR_SET_REACHABLE(h);
 
    if (heap->mark_and_sweep_recursion_depth >= DUK_USE_MARK_AND_SWEEP_RECLIMIT) {
        /* log this with a normal debug level because this should be relatively rare */
        DUK_D(DUK_DPRINT("mark-and-sweep recursion limit reached, marking as temproot: %p", (void *) h));
        DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap);
        DUK_HEAPHDR_SET_TEMPROOT(h);
        return;
    }
 
    heap->mark_and_sweep_recursion_depth++;
 

Referenced by duk__mark_finalize_list(), and duk__mark_temproots_by_heap_scan().

◆ duk__mark_hobject()

DUK_LOCAL void duk__mark_hobject	(	duk_heap *	heap,
		duk_hobject *	h )

Definition at line 42216 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    DUK_UNREF(heap);
    DUK_UNREF(h);
 
    DUK_DDD(DUK_DDDPRINT("duk__mark_hstring: %p", (void *) h));
    DUK_ASSERT(h);
 
    /* nothing to process */
}
 
DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h) {
    duk_uint_fast32_t i;
 
    DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h));
 
    DUK_ASSERT(h);
 
    /* XXX: use advancing pointers instead of index macros -> faster and smaller? */
 
    for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
        duk_hstring *key = DUK_HOBJECT_E_GET_KEY(heap, h, i);
        if (!key) {
            continue;
        }
        duk__mark_heaphdr(heap, (duk_heaphdr *) key);
        if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) {
            duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get);
            duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set);
        } else {
            duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v);
        }
    }
 
    for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
        duk__mark_tval(heap, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i));
    }
 
    /* hash part is a 'weak reference' and does not contribute */
 
    duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h));
 
    if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
        duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
        duk_tval *tv, *tv_end;
        duk_hobject **fn, **fn_end;
 
        /* 'data' is reachable through every compiled function which
         * contains a reference.
         */
 
        duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(heap, f));
 
        if (DUK_HCOMPILEDFUNCTION_GET_DATA(heap, f) != NULL) {
            tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, f);
            tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, f);
            while (tv < tv_end) {
                duk__mark_tval(heap, tv);
                tv++;
            }
 
            fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, f);
            fn_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f);
            while (fn < fn_end) {
                duk__mark_heaphdr(heap, (duk_heaphdr *) *fn);
                fn++;
            }
        } else {
            /* May happen in some out-of-memory corner cases. */
            DUK_D(DUK_DPRINT("duk_hcompiledfunction 'data' is NULL, skipping marking"));
        }
    } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        duk_hnativefunction *f = (duk_hnativefunction *) h;
        DUK_UNREF(f);
        /* nothing to mark */
    } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
        duk_hbufferobject *b = (duk_hbufferobject *) h;
        duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf);
    } else if (DUK_HOBJECT_IS_THREAD(h)) {
        duk_hthread *t = (duk_hthread *) h;
        duk_tval *tv;
 
        tv = t->valstack;
        while (tv < t->valstack_top) {
            duk__mark_tval(heap, tv);
            tv++;
        }
 
        for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
            duk_activation *act = t->callstack + i;
            duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
            duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env);
            duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env);
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
            duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller);

◆ duk__mark_hstring()

DUK_LOCAL void duk__mark_hstring	(	duk_heap *	heap,
		duk_hstring *	h )

Definition at line 42206 of file duktape-1.8.0/src/duktape.c.

                                                             {
    if (heap->curr_thread) {
        return heap->curr_thread;

References duk_heap::curr_thread.

◆ duk__mark_refzero_list()

DUK_LOCAL void duk__mark_refzero_list ( duk_heap * heap )

Definition at line 42415 of file duktape-1.8.0/src/duktape.c.

◆ duk__mark_roots_heap()

DUK_LOCAL void duk__mark_roots_heap ( duk_heap * heap )

Definition at line 42380 of file duktape-1.8.0/src/duktape.c.

                                                            {
    DUK_DDD(DUK_DDDPRINT("duk__mark_tval %p", (void *) tv));
    if (!tv) {
        return;
    }
    if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
        duk__mark_heaphdr(heap, DUK_TVAL_GET_HEAPHDR(tv));
    }
}
 
/*
 *  Mark the heap.
 */
 
DUK_LOCAL void duk__mark_roots_heap(duk_heap *heap) {
    duk_small_uint_t i;
 
    DUK_DD(DUK_DDPRINT("duk__mark_roots_heap: %p", (void *) heap));
 

◆ duk__mark_temproots_by_heap_scan()

DUK_LOCAL void duk__mark_temproots_by_heap_scan ( duk_heap * heap )

Definition at line 42565 of file duktape-1.8.0/src/duktape.c.

                                                                      {
#endif
    if (!DUK_HEAPHDR_HAS_TEMPROOT(hdr)) {
        DUK_DDD(DUK_DDDPRINT("not a temp root: %p", (void *) hdr));
        return;
    }
 
    DUK_DDD(DUK_DDDPRINT("found a temp root: %p", (void *) hdr));
    DUK_HEAPHDR_CLEAR_TEMPROOT(hdr);
    DUK_HEAPHDR_CLEAR_REACHABLE(hdr);  /* done so that duk__mark_heaphdr() works correctly */
    duk__mark_heaphdr(heap, hdr);
 
#ifdef DUK_USE_DEBUG
    (*count)++;
#endif
}
 
DUK_LOCAL void duk__mark_temproots_by_heap_scan(duk_heap *heap) {
    duk_heaphdr *hdr;
#ifdef DUK_USE_DEBUG
    duk_size_t count;
#endif
 
    DUK_DD(DUK_DDPRINT("duk__mark_temproots_by_heap_scan: %p", (void *) heap));
 
    while (DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)) {
        DUK_DD(DUK_DDPRINT("recursion limit reached, doing heap scan to continue from temproots"));
 
#ifdef DUK_USE_DEBUG
        count = 0;
#endif
        DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap);
 
        hdr = heap->heap_allocated;
        while (hdr) {
#ifdef DUK_USE_DEBUG
            duk__handle_temproot(heap, hdr, &count);
#else
            duk__handle_temproot(heap, hdr);
#endif
            hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
        }
 
        /* must also check refzero_list */

References duk__mark_heaphdr(), DUK_DDD, DUK_DDDPRINT, DUK_HEAPHDR_CLEAR_REACHABLE, DUK_HEAPHDR_CLEAR_TEMPROOT, and DUK_HEAPHDR_HAS_TEMPROOT.

◆ duk__mark_tval()

DUK_LOCAL_DECL void duk__mark_tval	(	duk_heap *	heap,
		duk_tval *	tv )

Definition at line 42366 of file duktape-1.8.0/src/duktape.c.

                         :
        duk__mark_hstring(heap, (duk_hstring *) h);
        break;
    case DUK_HTYPE_OBJECT:
        duk__mark_hobject(heap, (duk_hobject *) h);
        break;
    case DUK_HTYPE_BUFFER:
        /* nothing to mark */
        break;

◆ duk__match_regexp()

DUK_LOCAL const duk_uint8_t * duk__match_regexp	(	duk_re_matcher_ctx *	re_ctx,
		const duk_uint8_t *	pc,
		const duk_uint8_t *	sp )

Definition at line 78869 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    /* note: caller 'sp' is intentionally not updated here */
    (void) duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) 1);
    return duk__inp_get_cp(re_ctx, &sp);
}
 
/*
 *  Regexp recursive matching function.
 *
 *  Returns 'sp' on successful match (points to character after last matched one),
 *  NULL otherwise.
 *
 *  The C recursion depth limit check is only performed in this function, this
 *  suffices because the function is present in all true recursion required by
 *  regexp execution.
 */
 
DUK_LOCAL const duk_uint8_t *duk__match_regexp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *pc, const duk_uint8_t *sp) {
    if (re_ctx->recursion_depth >= re_ctx->recursion_limit) {
        DUK_ERROR_RANGE(re_ctx->thr, DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT);
    }
    re_ctx->recursion_depth++;
 
    for (;;) {
        duk_small_int_t op;
 
        if (re_ctx->steps_count >= re_ctx->steps_limit) {
            DUK_ERROR_RANGE(re_ctx->thr, DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT);
        }
        re_ctx->steps_count++;
 
        op = (duk_small_int_t) duk__bc_get_u32(re_ctx, &pc);
 
        DUK_DDD(DUK_DDDPRINT("match: rec=%ld, steps=%ld, pc (after op)=%ld, sp=%ld, op=%ld",
                             (long) re_ctx->recursion_depth,
                             (long) re_ctx->steps_count,
                             (long) (pc - re_ctx->bytecode),
                             (long) (sp - re_ctx->input),
                             (long) op));
 
        switch (op) {
        case DUK_REOP_MATCH: {
            goto match;
        }
        case DUK_REOP_CHAR: {
            /*
             *  Byte-based matching would be possible for case-sensitive
             *  matching but not for case-insensitive matching.  So, we
             *  match by decoding the input and bytecode character normally.
             *
             *  Bytecode characters are assumed to be already canonicalized.
             *  Input characters are canonicalized automatically by
             *  duk__inp_get_cp() if necessary.
             *
             *  There is no opcode for matching multiple characters.  The
             *  regexp compiler has trouble joining strings efficiently
             *  during compilation.  See doc/regexp.rst for more discussion.
             */
            duk_codepoint_t c1, c2;
 
            c1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
            DUK_ASSERT(!(re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) ||
                       c1 == duk_unicode_re_canonicalize_char(re_ctx->thr, c1));  /* canonicalized by compiler */
            if (sp >= re_ctx->input_end) {
                goto fail;
            }
            c2 = duk__inp_get_cp(re_ctx, &sp);
            DUK_DDD(DUK_DDDPRINT("char match, c1=%ld, c2=%ld", (long) c1, (long) c2));
            if (c1 != c2) {
                goto fail;
            }
            break;
        }
        case DUK_REOP_PERIOD: {
            duk_codepoint_t c;
 
            if (sp >= re_ctx->input_end) {
                goto fail;
            }
            c = duk__inp_get_cp(re_ctx, &sp);
            if (duk_unicode_is_line_terminator(c)) {
                /* E5 Sections 15.10.2.8, 7.3 */
                goto fail;
            }
            break;
        }
        case DUK_REOP_RANGES:
        case DUK_REOP_INVRANGES: {
            duk_uint32_t n;
            duk_codepoint_t c;
            duk_small_int_t match;
 
            n = duk__bc_get_u32(re_ctx, &pc);
            if (sp >= re_ctx->input_end) {
                goto fail;
            }
            c = duk__inp_get_cp(re_ctx, &sp);
 
            match = 0;
            while (n) {
                duk_codepoint_t r1, r2;
                r1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
                r2 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
                DUK_DDD(DUK_DDDPRINT("matching ranges/invranges, n=%ld, r1=%ld, r2=%ld, c=%ld",
                                     (long) n, (long) r1, (long) r2, (long) c));
                if (c >= r1 && c <= r2) {
                    /* Note: don't bail out early, we must read all the ranges from
                     * bytecode.  Another option is to skip them efficiently after
                     * breaking out of here.  Prefer smallest code.
                     */
                    match = 1;
                }
                n--;
            }
 
            if (op == DUK_REOP_RANGES) {
                if (!match) {
                    goto fail;
                }
            } else {
                DUK_ASSERT(op == DUK_REOP_INVRANGES);
                if (match) {
                    goto fail;
                }
            }
            break;
        }
        case DUK_REOP_ASSERT_START: {
            duk_codepoint_t c;
 
            if (sp <= re_ctx->input) {
                break;
            }
            if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) {
                goto fail;
            }
            c = duk__inp_get_prev_cp(re_ctx, sp);
            if (duk_unicode_is_line_terminator(c)) {
                /* E5 Sections 15.10.2.8, 7.3 */
                break;
            }
            goto fail;
        }
        case DUK_REOP_ASSERT_END: {
            duk_codepoint_t c;
            const duk_uint8_t *tmp_sp;
 
            if (sp >= re_ctx->input_end) {
                break;
            }
            if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) {
                goto fail;
            }
            tmp_sp = sp;
            c = duk__inp_get_cp(re_ctx, &tmp_sp);
            if (duk_unicode_is_line_terminator(c)) {
                /* E5 Sections 15.10.2.8, 7.3 */
                break;
            }
            goto fail;
        }
        case DUK_REOP_ASSERT_WORD_BOUNDARY:
        case DUK_REOP_ASSERT_NOT_WORD_BOUNDARY: {
            /*
             *  E5 Section 15.10.2.6.  The previous and current character
             *  should -not- be canonicalized as they are now.  However,
             *  canonicalization does not affect the result of IsWordChar()
             *  (which depends on Unicode characters never canonicalizing
             *  into ASCII characters) so this does not matter.
             */
            duk_small_int_t w1, w2;
 
            if (sp <= re_ctx->input) {
                w1 = 0;  /* not a wordchar */
            } else {
                duk_codepoint_t c;
                c = duk__inp_get_prev_cp(re_ctx, sp);
                w1 = duk_unicode_re_is_wordchar(c);
            }
            if (sp >= re_ctx->input_end) {
                w2 = 0;  /* not a wordchar */
            } else {
                const duk_uint8_t *tmp_sp = sp;  /* dummy so sp won't get updated */
                duk_codepoint_t c;
                c = duk__inp_get_cp(re_ctx, &tmp_sp);
                w2 = duk_unicode_re_is_wordchar(c);
            }
 
            if (op == DUK_REOP_ASSERT_WORD_BOUNDARY) {
                if (w1 == w2) {
                    goto fail;
                }
            } else {
                DUK_ASSERT(op == DUK_REOP_ASSERT_NOT_WORD_BOUNDARY);
                if (w1 != w2) {
                    goto fail;
                }
            }
            break;
        }
        case DUK_REOP_JUMP: {
            duk_int32_t skip;
 
            skip = duk__bc_get_i32(re_ctx, &pc);
            pc += skip;
            break;
        }
        case DUK_REOP_SPLIT1: {
            /* split1: prefer direct execution (no jump) */
            const duk_uint8_t *sub_sp;
            duk_int32_t skip;
 
            skip = duk__bc_get_i32(re_ctx, &pc);
            sub_sp = duk__match_regexp(re_ctx, pc, sp);
            if (sub_sp) {
                sp = sub_sp;
                goto match;
            }
            pc += skip;
            break;
        }
        case DUK_REOP_SPLIT2: {
            /* split2: prefer jump execution (not direct) */
            const duk_uint8_t *sub_sp;
            duk_int32_t skip;
 
            skip = duk__bc_get_i32(re_ctx, &pc);
            sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
            if (sub_sp) {
                sp = sub_sp;
                goto match;
            }
            break;
        }
        case DUK_REOP_SQMINIMAL: {
            duk_uint32_t q, qmin, qmax;
            duk_int32_t skip;
            const duk_uint8_t *sub_sp;
 
            qmin = duk__bc_get_u32(re_ctx, &pc);
            qmax = duk__bc_get_u32(re_ctx, &pc);
            skip = duk__bc_get_i32(re_ctx, &pc);
            DUK_DDD(DUK_DDDPRINT("minimal quantifier, qmin=%lu, qmax=%lu, skip=%ld",
                                 (unsigned long) qmin, (unsigned long) qmax, (long) skip));
 
            q = 0;
            while (q <= qmax) {
                if (q >= qmin) {
                    sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
                    if (sub_sp) {
                        sp = sub_sp;
                        goto match;
                    }
                }
                sub_sp = duk__match_regexp(re_ctx, pc, sp);
                if (!sub_sp) {
                    break;
                }
                sp = sub_sp;
                q++;
            }
            goto fail;
        }
        case DUK_REOP_SQGREEDY: {
            duk_uint32_t q, qmin, qmax, atomlen;
            duk_int32_t skip;
            const duk_uint8_t *sub_sp;
 
            qmin = duk__bc_get_u32(re_ctx, &pc);
            qmax = duk__bc_get_u32(re_ctx, &pc);
            atomlen = duk__bc_get_u32(re_ctx, &pc);
            skip = duk__bc_get_i32(re_ctx, &pc);
            DUK_DDD(DUK_DDDPRINT("greedy quantifier, qmin=%lu, qmax=%lu, atomlen=%lu, skip=%ld",
                                 (unsigned long) qmin, (unsigned long) qmax, (unsigned long) atomlen, (long) skip));
 
            q = 0;
            while (q < qmax) {
                sub_sp = duk__match_regexp(re_ctx, pc, sp);
                if (!sub_sp) {
                    break;
                }
                sp = sub_sp;
                q++;
            }
            while (q >= qmin) {
                sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
                if (sub_sp) {
                    sp = sub_sp;
                    goto match;
                }
                if (q == qmin) {
                    break;
                }
 
                /* Note: if atom were to contain e.g. captures, we would need to
                 * re-match the atom to get correct captures.  Simply quantifiers
                 * do not allow captures in their atom now, so this is not an issue.
                 */
 
                DUK_DDD(DUK_DDDPRINT("greedy quantifier, backtrack %ld characters (atomlen)",
                                     (long) atomlen));
                sp = duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) atomlen);
                q--;
            }
            goto fail;
        }
        case DUK_REOP_SAVE: {
            duk_uint32_t idx;
            const duk_uint8_t *old;
            const duk_uint8_t *sub_sp;
 
            idx = duk__bc_get_u32(re_ctx, &pc);
            if (idx >= re_ctx->nsaved) {
                /* idx is unsigned, < 0 check is not necessary */
                DUK_D(DUK_DPRINT("internal error, regexp save index insane: idx=%ld", (long) idx));
                goto internal_error;
            }
            old = re_ctx->saved[idx];
            re_ctx->saved[idx] = sp;
            sub_sp = duk__match_regexp(re_ctx, pc, sp);
            if (sub_sp) {
                sp = sub_sp;
                goto match;
            }
            re_ctx->saved[idx] = old;
            goto fail;
        }
        case DUK_REOP_WIPERANGE: {
            /* Wipe capture range and save old values for backtracking.
             *
             * XXX: this typically happens with a relatively small idx_count.
             * It might be useful to handle cases where the count is small
             * (say <= 8) by saving the values in stack instead.  This would
             * reduce memory churn and improve performance, at the cost of a
             * slightly higher code footprint.
             */
            duk_uint32_t idx_start, idx_count;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
            duk_uint32_t idx_end, idx;
#endif
            duk_uint8_t **range_save;
            const duk_uint8_t *sub_sp;
 
            idx_start = duk__bc_get_u32(re_ctx, &pc);
            idx_count = duk__bc_get_u32(re_ctx, &pc);
            DUK_DDD(DUK_DDDPRINT("wipe saved range: start=%ld, count=%ld -> [%ld,%ld] (captures [%ld,%ld])",
                                 (long) idx_start, (long) idx_count,
                                 (long) idx_start, (long) (idx_start + idx_count - 1),
                                 (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
            if (idx_start + idx_count > re_ctx->nsaved || idx_count == 0) {
                /* idx is unsigned, < 0 check is not necessary */
                DUK_D(DUK_DPRINT("internal error, regexp wipe indices insane: idx_start=%ld, idx_count=%ld",
                                 (long) idx_start, (long) idx_count));
                goto internal_error;
            }
            DUK_ASSERT(idx_count > 0);
 
            duk_require_stack((duk_context *) re_ctx->thr, 1);
            range_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr,
                                                                sizeof(duk_uint8_t *) * idx_count);
            DUK_ASSERT(range_save != NULL);
            DUK_MEMCPY(range_save, re_ctx->saved + idx_start, sizeof(duk_uint8_t *) * idx_count);
#ifdef DUK_USE_EXPLICIT_NULL_INIT
            idx_end = idx_start + idx_count;
            for (idx = idx_start; idx < idx_end; idx++) {
                re_ctx->saved[idx] = NULL;
            }
#else
            DUK_MEMZERO((void *) (re_ctx->saved + idx_start), sizeof(duk_uint8_t *) * idx_count);
#endif
 
            sub_sp = duk__match_regexp(re_ctx, pc, sp);
            if (sub_sp) {
                /* match: keep wiped/resaved values */
                DUK_DDD(DUK_DDDPRINT("match: keep wiped/resaved values [%ld,%ld] (captures [%ld,%ld])",
                                     (long) idx_start, (long) (idx_start + idx_count - 1),
                                         (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
                duk_pop((duk_context *) re_ctx->thr);
                sp = sub_sp;
                goto match;
            }
 
            /* fail: restore saves */
            DUK_DDD(DUK_DDDPRINT("fail: restore wiped/resaved values [%ld,%ld] (captures [%ld,%ld])",
                                 (long) idx_start, (long) (idx_start + idx_count - 1),
                                 (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
            DUK_MEMCPY((void *) (re_ctx->saved + idx_start),
                       (const void *) range_save,
                       sizeof(duk_uint8_t *) * idx_count);
            duk_pop((duk_context *) re_ctx->thr);
            goto fail;
        }
        case DUK_REOP_LOOKPOS:
        case DUK_REOP_LOOKNEG: {
            /*
             *  Needs a save of multiple saved[] entries depending on what range
             *  may be overwritten.  Because the regexp parser does no such analysis,
             *  we currently save the entire saved array here.  Lookaheads are thus
             *  a bit expensive.  Note that the saved array is not needed for just
             *  the lookahead sub-match, but for the matching of the entire sequel.
             *
             *  The temporary save buffer is pushed on to the valstack to handle
             *  errors correctly.  Each lookahead causes a C recursion and pushes
             *  more stuff on the value stack.  If the C recursion limit is less
             *  than the value stack spare, there is no need to check the stack.
             *  We do so regardless, just in case.
             */
 
            duk_int32_t skip;
            duk_uint8_t **full_save;
            const duk_uint8_t *sub_sp;
 
            DUK_ASSERT(re_ctx->nsaved > 0);
 
            duk_require_stack((duk_context *) re_ctx->thr, 1);
            full_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr,
                                                               sizeof(duk_uint8_t *) * re_ctx->nsaved);
            DUK_ASSERT(full_save != NULL);
            DUK_MEMCPY(full_save, re_ctx->saved, sizeof(duk_uint8_t *) * re_ctx->nsaved);
 
            skip = duk__bc_get_i32(re_ctx, &pc);
            sub_sp = duk__match_regexp(re_ctx, pc, sp);
            if (op == DUK_REOP_LOOKPOS) {
                if (!sub_sp) {
                    goto lookahead_fail;
                }
            } else {
                if (sub_sp) {
                    goto lookahead_fail;
                }
            }
            sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
            if (sub_sp) {
                /* match: keep saves */
                duk_pop((duk_context *) re_ctx->thr);
                sp = sub_sp;
                goto match;
            }
 
            /* fall through */
 
         lookahead_fail:
            /* fail: restore saves */
            DUK_MEMCPY((void *) re_ctx->saved,
                       (const void *) full_save,
                       sizeof(duk_uint8_t *) * re_ctx->nsaved);
            duk_pop((duk_context *) re_ctx->thr);
            goto fail;
        }
        case DUK_REOP_BACKREFERENCE: {
            /*
             *  Byte matching for back-references would be OK in case-
             *  sensitive matching.  In case-insensitive matching we need
             *  to canonicalize characters, so back-reference matching needs
             *  to be done with codepoints instead.  So, we just decode
             *  everything normally here, too.
             *
             *  Note: back-reference index which is 0 or higher than
             *  NCapturingParens (= number of capturing parens in the
             *  -entire- regexp) is a compile time error.  However, a
             *  backreference referring to a valid capture which has
             *  not matched anything always succeeds!  See E5 Section
             *  15.10.2.9, step 5, sub-step 3.
             */
            duk_uint32_t idx;
            const duk_uint8_t *p;
 
            idx = duk__bc_get_u32(re_ctx, &pc);
            idx = idx << 1;  /* backref n -> saved indices [n*2, n*2+1] */
            if (idx < 2 || idx + 1 >= re_ctx->nsaved) {
                /* regexp compiler should catch these */
                DUK_D(DUK_DPRINT("internal error, backreference index insane"));
                goto internal_error;
            }
            if (!re_ctx->saved[idx] || !re_ctx->saved[idx+1]) {
                /* capture is 'undefined', always matches! */
                DUK_DDD(DUK_DDDPRINT("backreference: saved[%ld,%ld] not complete, always match",
                                     (long) idx, (long) (idx + 1)));
                break;
            }
            DUK_DDD(DUK_DDDPRINT("backreference: match saved[%ld,%ld]", (long) idx, (long) (idx + 1)));
 
            p = re_ctx->saved[idx];
            while (p < re_ctx->saved[idx+1]) {
                duk_codepoint_t c1, c2;
 
                /* Note: not necessary to check p against re_ctx->input_end:
                 * the memory access is checked by duk__inp_get_cp(), while
                 * valid compiled regexps cannot write a saved[] entry
                 * which points to outside the string.
                 */
                if (sp >= re_ctx->input_end) {
                    goto fail;
                }
                c1 = duk__inp_get_cp(re_ctx, &p);
                c2 = duk__inp_get_cp(re_ctx, &sp);
                if (c1 != c2) {
                    goto fail;
                }
            }
            break;
        }
        default: {
            DUK_D(DUK_DPRINT("internal error, regexp opcode error: %ld", (long) op));

References duk__inp_backtrack(), and duk__inp_get_cp().

◆ duk__math_minmax()

DUK_LOCAL duk_ret_t duk__math_minmax	(	duk_context *	ctx,
		duk_double_t	initial,
		duk__two_arg_func	min_max )

Definition at line 32557 of file duktape-1.8.0/src/duktape.c.

                                                                                                        {
    duk_idx_t n = duk_get_top(ctx);
    duk_idx_t i;
    duk_double_t res = initial;
    duk_double_t t;
 
    /*
     *  Note: fmax() does not match the E5 semantics.  E5 requires
     *  that if -any- input to Math.max() is a NaN, the result is a
     *  NaN.  fmax() will return a NaN only if -both- inputs are NaN.
     *  Same applies to fmin().
     *
     *  Note: every input value must be coerced with ToNumber(), even

References duk_get_top().

◆ duk__nonbound_func_lookup()

DUK_LOCAL duk_hobject * duk__nonbound_func_lookup	(	duk_context *	ctx,
		duk_idx_t	idx_func,
		duk_idx_t *	out_num_stack_args,
		duk_tval **	out_tv_func,
		duk_small_uint_t	call_flags )

Definition at line 55701 of file duktape-1.8.0/src/duktape.c.

           :
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_this));
        DUK_DDD(DUK_DDDPRINT("this binding: non-strict, not object/undefined/null -> use ToObject(value)"));
        duk_to_object(ctx, idx_this);  /* may have side effects */
        break;
    }
}
 
/*
 *  Shared helper for non-bound func lookup.
 *
 *  Returns duk_hobject * to the final non-bound function (NULL for lightfunc).
 */
 
DUK_LOCAL duk_hobject *duk__nonbound_func_lookup(duk_context *ctx,
                                                 duk_idx_t idx_func,
                                                 duk_idx_t *out_num_stack_args,
                                                 duk_tval **out_tv_func,
                                                 duk_small_uint_t call_flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_func;
    duk_hobject *func;
 
    for (;;) {
        /* Use loop to minimize code size of relookup after bound function case */
        tv_func = DUK_GET_TVAL_POSIDX(ctx, idx_func);
        DUK_ASSERT(tv_func != NULL);
 
        if (DUK_TVAL_IS_OBJECT(tv_func)) {
            func = DUK_TVAL_GET_OBJECT(tv_func);
            if (!DUK_HOBJECT_IS_CALLABLE(func)) {
                goto not_callable_error;
            }
            if (DUK_HOBJECT_HAS_BOUND(func)) {
                duk__handle_bound_chain_for_call(thr, idx_func, out_num_stack_args, call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL);
 
                /* The final object may be a normal function or a lightfunc.
                 * We need to re-lookup tv_func because it may have changed
                 * (also value stack may have been resized).  Loop again to
                 * do that; we're guaranteed not to come here again.
                 */
                DUK_ASSERT(DUK_TVAL_IS_OBJECT(duk_require_tval(ctx, idx_func)) ||
                           DUK_TVAL_IS_LIGHTFUNC(duk_require_tval(ctx, idx_func)));
                continue;
            }
        } else if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
            func = NULL;
        } else {
            goto not_callable_error;
        }
        break;
    }
 
    DUK_ASSERT((DUK_TVAL_IS_OBJECT(tv_func) && DUK_HOBJECT_IS_CALLABLE(DUK_TVAL_GET_OBJECT(tv_func))) ||
               DUK_TVAL_IS_LIGHTFUNC(tv_func));

Referenced by duk_handle_ecma_call_setup().

◆ duk__nud_array_literal()

DUK_LOCAL_DECL void duk__nud_array_literal	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 60455 of file duktape-1.8.0/src/duktape.c.

                                                                                   {
    duk_hthread *thr = comp_ctx->thr;
    duk_reg_t reg_obj;                 /* result reg */
    duk_reg_t reg_temp;                /* temp reg */
    duk_reg_t temp_start;              /* temp reg value for start of loop */
    duk_small_uint_t max_init_values;  /* max # of values initialized in one MPUTARR set */
    duk_small_uint_t num_values;       /* number of values in current MPUTARR set */
    duk_uarridx_t curr_idx;            /* current (next) array index */
    duk_uarridx_t start_idx;           /* start array index of current MPUTARR set */
    duk_uarridx_t init_idx;            /* last array index explicitly initialized, +1 */
    duk_bool_t require_comma;          /* next loop requires a comma */
 
    /* DUK_TOK_LBRACKET already eaten, current token is right after that */
    DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LBRACKET);
 
    max_init_values = DUK__MAX_ARRAY_INIT_VALUES;  /* XXX: depend on available temps? */
 
    reg_obj = DUK__ALLOCTEMP(comp_ctx);
    duk__emit_extraop_b_c(comp_ctx,
                          DUK_EXTRAOP_NEWARR | DUK__EMIT_FLAG_B_IS_TARGET,
                          reg_obj,
                          0);  /* XXX: patch initial size afterwards? */
    temp_start = DUK__GETTEMP(comp_ctx);
 
    /*
     *  Emit initializers in sets of maximum max_init_values.
     *  Corner cases such as single value initializers do not have
     *  special handling now.
     *
     *  Elided elements must not be emitted as 'undefined' values,
     *  because such values would be enumerable (which is incorrect).
     *  Also note that trailing elisions must be reflected in the
     *  length of the final array but cause no elements to be actually
     *  inserted.
     */
 
    curr_idx = 0;
    init_idx = 0;         /* tracks maximum initialized index + 1 */
    start_idx = 0;
    require_comma = 0;
 
    for (;;) {
        num_values = 0;
        DUK__SETTEMP(comp_ctx, temp_start);
 
        if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) {
            break;
        }
 
        for (;;) {
            if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) {
                /* the outer loop will recheck and exit */
                break;
            }
 
            /* comma check */
            if (require_comma) {
                if (comp_ctx->curr_token.t == DUK_TOK_COMMA) {
                    /* comma after a value, expected */
                    duk__advance(comp_ctx);
                    require_comma = 0;
                    continue;
                } else {
                    goto syntax_error;
                }
            } else {
                if (comp_ctx->curr_token.t == DUK_TOK_COMMA) {
                    /* elision - flush */
                    curr_idx++;
                    duk__advance(comp_ctx);
                    /* if num_values > 0, MPUTARR emitted by outer loop after break */
                    break;
                }
            }
            /* else an array initializer element */
 
            /* initial index */
            if (num_values == 0) {
                start_idx = curr_idx;
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_load_int32(comp_ctx, reg_temp, (duk_int32_t) start_idx);
            }
 
            reg_temp = DUK__ALLOCTEMP(comp_ctx);   /* alloc temp just in case, to update max temp */
            DUK__SETTEMP(comp_ctx, reg_temp);
            duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);
            DUK__SETTEMP(comp_ctx, reg_temp + 1);
 
            num_values++;
            curr_idx++;
            require_comma = 1;
 
            if (num_values >= max_init_values) {
                /* MPUTARR emitted by outer loop */
                break;
            }
        }
 
        if (num_values > 0) {
            /* - A is a source register (it's not a write target, but used
             *   to identify the target object) but can be shuffled.
             * - B cannot be shuffled normally because it identifies a range
             *   of registers, the emitter has special handling for this
             *   (the "no shuffle" flag must not be set).
             * - C is a non-register number and cannot be shuffled, but
             *   never needs to be.
             */
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_MPUTARR |
                                DUK__EMIT_FLAG_NO_SHUFFLE_C |
                                DUK__EMIT_FLAG_A_IS_SOURCE,
                            (duk_regconst_t) reg_obj,
                            (duk_regconst_t) temp_start,
                            (duk_regconst_t) num_values);
            init_idx = start_idx + num_values;
 
            /* num_values and temp_start reset at top of outer loop */
        }
    }
 
    DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RBRACKET);
    duk__advance(comp_ctx);
 
    DUK_DDD(DUK_DDDPRINT("array literal done, curridx=%ld, initidx=%ld",
                         (long) curr_idx, (long) init_idx));
 
    /* trailing elisions? */
    if (curr_idx > init_idx) {
        /* yes, must set array length explicitly */
        DUK_DDD(DUK_DDDPRINT("array literal has trailing elisions which affect its length"));
        reg_temp = DUK__ALLOCTEMP(comp_ctx);

◆ duk__nud_object_literal()

DUK_LOCAL_DECL void duk__nud_object_literal	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 60663 of file duktape-1.8.0/src/duktape.c.

                                               : getter/setter encountered twice"));
            return 1;
        }
    }
 
    new_key_flags |= key_flags;
    DUK_DDD(DUK_DDDPRINT("setting/updating key %!T flags: 0x%08lx -> 0x%08lx",
                         (duk_tval *) duk_get_tval(ctx, -1),
                         (unsigned long) key_flags,
                         (unsigned long) new_key_flags));
    duk_dup(ctx, -1);
    duk_push_int(ctx, new_key_flags);   /* [ ... key_obj key key flags ] */
    duk_put_prop(ctx, -4);              /* [ ... key_obj key ] */
 
    return 0;
}
 
DUK_LOCAL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_reg_t reg_obj;                /* result reg */
    duk_reg_t reg_key;                /* temp reg for key literal */
    duk_reg_t reg_temp;               /* temp reg */
    duk_reg_t temp_start;             /* temp reg value for start of loop */
    duk_small_uint_t max_init_pairs;  /* max # of key-value pairs initialized in one MPUTOBJ set */
    duk_small_uint_t num_pairs;       /* number of pairs in current MPUTOBJ set */
    duk_bool_t first;                 /* first value: comma must not precede the value */
    duk_bool_t is_set, is_get;        /* temps */
 
    DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LCURLY);
 
    max_init_pairs = DUK__MAX_OBJECT_INIT_PAIRS;  /* XXX: depend on available temps? */
 
    reg_obj = DUK__ALLOCTEMP(comp_ctx);
    duk__emit_extraop_b_c(comp_ctx,
                          DUK_EXTRAOP_NEWOBJ | DUK__EMIT_FLAG_B_IS_TARGET,
                          reg_obj,
                          0);  /* XXX: patch initial size afterwards? */
    temp_start = DUK__GETTEMP(comp_ctx);
 
    /* temp object for tracking / detecting duplicate keys */
    duk_push_object(ctx);
 
    /*
     *  Emit initializers in sets of maximum max_init_pairs keys.
     *  Setter/getter is handled separately and terminates the
     *  current set of initializer values.  Corner cases such as
     *  single value initializers do not have special handling now.
     */
 
    first = 1;
    for (;;) {
        num_pairs = 0;
        DUK__SETTEMP(comp_ctx, temp_start);
 
        if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
            break;
        }
 
        for (;;) {
            /*
             *  Three possible element formats:
             *    1) PropertyName : AssignmentExpression
             *    2) get PropertyName () { FunctionBody }
             *    3) set PropertyName ( PropertySetParameterList ) { FunctionBody }
             *
             *  PropertyName can be IdentifierName (includes reserved words), a string
             *  literal, or a number literal.  Note that IdentifierName allows 'get' and
             *  'set' too, so we need to look ahead to the next token to distinguish:
             *
             *     { get : 1 }
             *
             *  and
             *
             *     { get foo() { return 1 } }
             *     { get get() { return 1 } }    // 'get' as getter propertyname
             *
             *  Finally, a trailing comma is allowed.
             *
             *  Key name is coerced to string at compile time (and ends up as a
             *  a string constant) even for numeric keys (e.g. "{1:'foo'}").
             *  These could be emitted using e.g. LDINT, but that seems hardly
             *  worth the effort and would increase code size.
             */
 
            DUK_DDD(DUK_DDDPRINT("object literal inner loop, curr_token->t = %ld",
                                 (long) comp_ctx->curr_token.t));
 
            if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
                /* the outer loop will recheck and exit */
                break;
            }
            if (num_pairs >= max_init_pairs) {
                /* MPUTOBJ emitted by outer loop */
                break;
            }
 
            if (first) {
                first = 0;
            } else {
                if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
                    goto syntax_error;
                }
                duk__advance(comp_ctx);
                if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
                    /* trailing comma followed by rcurly */
                    break;
                }
            }
 
            /* advance to get one step of lookup */
            duk__advance(comp_ctx);
 
            /* NOTE: "get" and "set" are not officially ReservedWords and the lexer
             * currently treats them always like ordinary identifiers (DUK_TOK_GET
             * and DUK_TOK_SET are unused).  They need to be detected based on the
             * identifier string content.
             */
 
            is_get = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
                      comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_GET(thr));
            is_set = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
                      comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_SET(thr));
            if ((is_get || is_set) && comp_ctx->curr_token.t != DUK_TOK_COLON) {
                /* getter/setter */
                duk_int_t fnum;
 
                if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER ||
                    comp_ctx->curr_token.t_nores == DUK_TOK_STRING) {
                    /* same handling for identifiers and strings */
                    DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
                    duk_push_hstring(ctx, comp_ctx->curr_token.str1);
                } else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) {
                    duk_push_number(ctx, comp_ctx->curr_token.num);
                    duk_to_string(ctx, -1);
                } else {
                    goto syntax_error;
                }
 
                DUK_ASSERT(duk_is_string(ctx, -1));
                if (duk__nud_object_literal_key_check(comp_ctx,
                                                      (is_get ? DUK__OBJ_LIT_KEY_GET : DUK__OBJ_LIT_KEY_SET))) {
                    goto syntax_error;
                }
                reg_key = duk__getconst(comp_ctx);
 
                if (num_pairs > 0) {
                    /* - A is a source register (it's not a write target, but used
                     *   to identify the target object) but can be shuffled.
                     * - B cannot be shuffled normally because it identifies a range
                     *   of registers, the emitter has special handling for this
                     *   (the "no shuffle" flag must not be set).
                     * - C is a non-register number and cannot be shuffled, but
                     *   never needs to be.
                     */
                    duk__emit_a_b_c(comp_ctx,
                                    DUK_OP_MPUTOBJ |
                                        DUK__EMIT_FLAG_NO_SHUFFLE_C |
                                        DUK__EMIT_FLAG_A_IS_SOURCE,
                                    reg_obj,
                                    temp_start,
                                    num_pairs);
                    num_pairs = 0;
                    DUK__SETTEMP(comp_ctx, temp_start);
                }
 
                /* curr_token = get/set name */
                fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 1 /*is_setget*/);
 
                DUK_ASSERT(DUK__GETTEMP(comp_ctx) == temp_start);
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_LDCONST,
                               (duk_regconst_t) reg_temp,
                               (duk_regconst_t) reg_key);
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_CLOSURE,
                               (duk_regconst_t) reg_temp,
                               (duk_regconst_t) fnum);
 
                /* Slot C is used in a non-standard fashion (range of regs),
                 * emitter code has special handling for it (must not set the
                 * "no shuffle" flag).
                 */
                duk__emit_extraop_b_c(comp_ctx,
                                      (is_get ? DUK_EXTRAOP_INITGET : DUK_EXTRAOP_INITSET),
                                      reg_obj,
                                      temp_start);   /* temp_start+0 = key, temp_start+1 = closure */
 
                DUK__SETTEMP(comp_ctx, temp_start);
            } else {
                /* normal key/value */
                if (comp_ctx->prev_token.t_nores == DUK_TOK_IDENTIFIER ||
                    comp_ctx->prev_token.t_nores == DUK_TOK_STRING) {
                    /* same handling for identifiers and strings */
                    DUK_ASSERT(comp_ctx->prev_token.str1 != NULL);
                    duk_push_hstring(ctx, comp_ctx->prev_token.str1);
                } else if (comp_ctx->prev_token.t == DUK_TOK_NUMBER) {
                    duk_push_number(ctx, comp_ctx->prev_token.num);
                    duk_to_string(ctx, -1);
                } else {
                    goto syntax_error;
                }
 
                DUK_ASSERT(duk_is_string(ctx, -1));
                if (duk__nud_object_literal_key_check(comp_ctx, DUK__OBJ_LIT_KEY_PLAIN)) {
                    goto syntax_error;
                }
                reg_key = duk__getconst(comp_ctx);
 
                reg_temp = DUK__ALLOCTEMP(comp_ctx);
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_LDCONST,
                               (duk_regconst_t) reg_temp,
                               (duk_regconst_t) reg_key);
                duk__advance_expect(comp_ctx, DUK_TOK_COLON);
 
                reg_temp = DUK__ALLOCTEMP(comp_ctx);  /* alloc temp just in case, to update max temp */
                DUK__SETTEMP(comp_ctx, reg_temp);
                duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);
                DUK__SETTEMP(comp_ctx, reg_temp + 1);
 
                num_pairs++;
            }
        }
 
        if (num_pairs > 0) {
            /* See MPUTOBJ comments above. */
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_MPUTOBJ |
                                DUK__EMIT_FLAG_NO_SHUFFLE_C |
                                DUK__EMIT_FLAG_A_IS_SOURCE,
                            reg_obj,
                            temp_start,
                            num_pairs);
 
            /* num_pairs and temp_start reset at top of outer loop */
        }
    }
 

◆ duk__nud_object_literal_key_check()

DUK_LOCAL_DECL duk_bool_t duk__nud_object_literal_key_check	(	duk_compiler_ctx *	comp_ctx,
		duk_small_uint_t	new_key_flags )

Definition at line 60605 of file duktape-1.8.0/src/duktape.c.

             :
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_ARRAY_LITERAL);
}
 
/* duplicate/invalid key checks; returns 1 if syntax error */
DUK_LOCAL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_small_uint_t key_flags;
 
    /* [ ... key_obj key ] */
 
    DUK_ASSERT(duk_is_string(ctx, -1));
 
    /*
     *  'key_obj' tracks keys encountered so far by associating an
     *  integer with flags with already encountered keys.  The checks
     *  below implement E5 Section 11.1.5, step 4 for production:
     *
     *    PropertyNameAndValueList: PropertyNameAndValueList , PropertyAssignment
     */
 
    duk_dup(ctx, -1);       /* [ ... key_obj key key ] */
    duk_get_prop(ctx, -3);  /* [ ... key_obj key val ] */
    key_flags = duk_to_int(ctx, -1);
    duk_pop(ctx);           /* [ ... key_obj key ] */
 
    if (new_key_flags & DUK__OBJ_LIT_KEY_PLAIN) {
        if ((key_flags & DUK__OBJ_LIT_KEY_PLAIN) && comp_ctx->curr_func.is_strict) {
            /* step 4.a */
            DUK_DDD(DUK_DDDPRINT("duplicate key: plain key appears twice in strict mode"));
            return 1;
        }
        if (key_flags & (DUK__OBJ_LIT_KEY_GET | DUK__OBJ_LIT_KEY_SET)) {
            /* step 4.c */
            DUK_DDD(DUK_DDDPRINT("duplicate key: plain key encountered after setter/getter"));
            return 1;
        }
    } else {
        if (key_flags & DUK__OBJ_LIT_KEY_PLAIN) {
            /* step 4.b */
            DUK_DDD(DUK_DDDPRINT("duplicate key: getter/setter encountered after plain key"));
            return 1;
        }
        if (key_flags & new_key_flags) {

◆ duk__obj_flag_any_default_false()

DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_uint_t	flag_mask )

Definition at line 17601 of file duktape-1.8.0/src/duktape.c.

                                                                                             {
    duk_tval *tv;
 
    tv = duk_get_tval(ctx, index);

◆ duk__parse_arguments()

DUK_LOCAL_DECL duk_int_t duk__parse_arguments	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 60909 of file duktape-1.8.0/src/duktape.c.

                                               : %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
    duk_pop(ctx);
    return;
 
 syntax_error:
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_OBJECT_LITERAL);
}
 
/* Parse argument list.  Arguments are written to temps starting from
 * "next temp".  Returns number of arguments parsed.  Expects left paren
 * to be already eaten, and eats the right paren before returning.
 */
DUK_LOCAL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_int_t nargs = 0;
    duk_reg_t reg_temp;
 
    /* Note: expect that caller has already eaten the left paren */
 
    DUK_DDD(DUK_DDDPRINT("start parsing arguments, prev_token.t=%ld, curr_token.t=%ld",
                         (long) comp_ctx->prev_token.t, (long) comp_ctx->curr_token.t));
 
    for (;;) {
        if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
            break;
        }
        if (nargs > 0) {
            duk__advance_expect(comp_ctx, DUK_TOK_COMMA);
        }
 
        /* We want the argument expression value to go to "next temp"
         * without additional moves.  That should almost always be the
         * case, but we double check after expression parsing.
         *
         * This is not the cleanest possible approach.
         */
 
        reg_temp = DUK__ALLOCTEMP(comp_ctx);  /* bump up "allocated" reg count, just in case */
        DUK__SETTEMP(comp_ctx, reg_temp);

◆ duk__parse_break_or_continue_stmt()

DUK_LOCAL_DECL void duk__parse_break_or_continue_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 63447 of file duktape-1.8.0/src/duktape.c.

                                                                                              {
    duk_hthread *thr = comp_ctx->thr;
    duk_bool_t is_break = (comp_ctx->curr_token.t == DUK_TOK_BREAK);
    duk_int_t label_id;
    duk_int_t label_catch_depth;
    duk_int_t label_pc;  /* points to LABEL; pc+1 = jump site for break; pc+2 = jump site for continue */
    duk_bool_t label_is_closest;
 
    DUK_UNREF(res);
 
    duk__advance(comp_ctx);  /* eat 'break' or 'continue' */
 
    if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON ||  /* explicit semi follows */
        comp_ctx->curr_token.lineterm ||                /* automatic semi will be inserted */
        comp_ctx->curr_token.allow_auto_semi) {         /* automatic semi will be inserted */
        /* break/continue without label */
 
        duk__lookup_active_label(comp_ctx, DUK_HTHREAD_STRING_EMPTY_STRING(thr), is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest);
    } else if (comp_ctx->curr_token.t == DUK_TOK_IDENTIFIER) {
        /* break/continue with label (label cannot be a reserved word, production is 'Identifier' */
        DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
        duk__lookup_active_label(comp_ctx, comp_ctx->curr_token.str1, is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest);
        duk__advance(comp_ctx);
    } else {
        DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_BREAK_CONT_LABEL);
    }
 
    /* Use a fast break/continue when possible.  A fast break/continue is
     * just a jump to the LABEL break/continue jump slot, which then jumps
     * to an appropriate place (for break, going through ENDLABEL correctly).
     * The peephole optimizer will optimize the jump to a direct one.
     */
 
    if (label_catch_depth == comp_ctx->curr_func.catch_depth &&
        label_is_closest) {
        DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, "
                             "label_catch_depth=%ld, catch_depth=%ld "

◆ duk__parse_disjunction()

DUK_LOCAL void duk__parse_disjunction	(	duk_re_compiler_ctx *	re_ctx,
		duk_bool_t	expect_eof,
		duk__re_disjunction_info *	out_atom_info )

Definition at line 77939 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                   {
    duk_int32_t atom_start_offset = -1;                   /* negative -> no atom matched on previous round */
    duk_int32_t atom_char_length = 0;                     /* negative -> complex atom */
    duk_uint32_t atom_start_captures = re_ctx->captures;  /* value of re_ctx->captures at start of atom */
    duk_int32_t unpatched_disjunction_split = -1;
    duk_int32_t unpatched_disjunction_jump = -1;
    duk_uint32_t entry_offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);
    duk_int32_t res_charlen = 0;  /* -1 if disjunction is complex, char length if simple */
    duk__re_disjunction_info tmp_disj;
 
    DUK_ASSERT(out_atom_info != NULL);
 
    if (re_ctx->recursion_depth >= re_ctx->recursion_limit) {
        DUK_ERROR_RANGE(re_ctx->thr, DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT);
    }
    re_ctx->recursion_depth++;
 
#if 0
    out_atom_info->start_captures = re_ctx->captures;
#endif
 
    for (;;) {
        /* atom_char_length, atom_start_offset, atom_start_offset reflect the
         * atom matched on the previous loop.  If a quantifier is encountered
         * on this loop, these are needed to handle the quantifier correctly.
         * new_atom_char_length etc are for the atom parsed on this round;
         * they're written to atom_char_length etc at the end of the round.
         */
        duk_int32_t new_atom_char_length;   /* char length of the atom parsed in this loop */
        duk_int32_t new_atom_start_offset;  /* bytecode start offset of the atom parsed in this loop
                                             * (allows quantifiers to copy the atom bytecode)
                                             */
        duk_uint32_t new_atom_start_captures;  /* re_ctx->captures at the start of the atom parsed in this loop */
 
        duk_lexer_parse_re_token(&re_ctx->lex, &re_ctx->curr_token);
 
        DUK_DD(DUK_DDPRINT("re token: %ld (num=%ld, char=%c)",
                           (long) re_ctx->curr_token.t,
                           (long) re_ctx->curr_token.num,
                           (re_ctx->curr_token.num >= 0x20 && re_ctx->curr_token.num <= 0x7e) ?
                           (int) re_ctx->curr_token.num : (int) '?'));
 
        /* set by atom case clauses */
        new_atom_start_offset = -1;
        new_atom_char_length = -1;
        new_atom_start_captures = re_ctx->captures;
 
        switch (re_ctx->curr_token.t) {
        case DUK_RETOK_DISJUNCTION: {
            /*
             *  The handling here is a bit tricky.  If a previous '|' has been processed,
             *  we have a pending split1 and a pending jump (for a previous match).  These
             *  need to be back-patched carefully.  See docs for a detailed example.
             */
 
            /* patch pending jump and split */
            if (unpatched_disjunction_jump >= 0) {
                duk_uint32_t offset;
 
                DUK_ASSERT(unpatched_disjunction_split >= 0);
                offset = unpatched_disjunction_jump;
                offset += duk__insert_jump_offset(re_ctx,
                                                  offset,
                                                  (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - offset));
                /* offset is now target of the pending split (right after jump) */
                duk__insert_jump_offset(re_ctx,
                                        unpatched_disjunction_split,
                                        offset - unpatched_disjunction_split);
            }
 
            /* add a new pending split to the beginning of the entire disjunction */
            (void) duk__insert_u32(re_ctx,
                                   entry_offset,
                                   DUK_REOP_SPLIT1);   /* prefer direct execution */
            unpatched_disjunction_split = entry_offset + 1;   /* +1 for opcode */
 
            /* add a new pending match jump for latest finished alternative */
            duk__append_u32(re_ctx, DUK_REOP_JUMP);
            unpatched_disjunction_jump = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
 
            /* 'taint' result as complex */
            res_charlen = -1;
            break;
        }
        case DUK_RETOK_QUANTIFIER: {
            if (atom_start_offset < 0) {
                DUK_ERROR_SYNTAX(re_ctx->thr, DUK_STR_INVALID_QUANTIFIER_NO_ATOM);
            }
            if (re_ctx->curr_token.qmin > re_ctx->curr_token.qmax) {
                DUK_ERROR_SYNTAX(re_ctx->thr, DUK_STR_INVALID_QUANTIFIER_VALUES);
            }
            if (atom_char_length >= 0) {
                /*
                 *  Simple atom
                 *
                 *  If atom_char_length is zero, we'll have unbounded execution time for e.g.
                 *  /()*x/.exec('x').  We can't just skip the match because it might have some
                 *  side effects (for instance, if we allowed captures in simple atoms, the
                 *  capture needs to happen).  The simple solution below is to force the
                 *  quantifier to match at most once, since the additional matches have no effect.
                 *
                 *  With a simple atom there can be no capture groups, so no captures need
                 *  to be reset.
                 */
                duk_int32_t atom_code_length;
                duk_uint32_t offset;
                duk_uint32_t qmin, qmax;
 
                qmin = re_ctx->curr_token.qmin;
                qmax = re_ctx->curr_token.qmax;
                if (atom_char_length == 0) {
                    /* qmin and qmax will be 0 or 1 */
                    if (qmin > 1) {
                        qmin = 1;
                    }
                    if (qmax > 1) {
                        qmax = 1;
                    }
                }
 
                duk__append_u32(re_ctx, DUK_REOP_MATCH);   /* complete 'sub atom' */
                atom_code_length = (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - atom_start_offset);
 
                offset = atom_start_offset;
                if (re_ctx->curr_token.greedy) {
                    offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQGREEDY);
                    offset += duk__insert_u32(re_ctx, offset, qmin);
                    offset += duk__insert_u32(re_ctx, offset, qmax);
                    offset += duk__insert_u32(re_ctx, offset, atom_char_length);
                    offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length);
                } else {
                    offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQMINIMAL);
                    offset += duk__insert_u32(re_ctx, offset, qmin);
                    offset += duk__insert_u32(re_ctx, offset, qmax);
                    offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length);
                }
                DUK_UNREF(offset);  /* silence scan-build warning */
            } else {
                /*
                 *  Complex atom
                 *
                 *  The original code is used as a template, and removed at the end
                 *  (this differs from the handling of simple quantifiers).
                 *
                 *  NOTE: there is no current solution for empty atoms in complex
                 *  quantifiers.  This would need some sort of a 'progress' instruction.
                 *
                 *  XXX: impose limit on maximum result size, i.e. atom_code_len * atom_copies?
                 */
                duk_int32_t atom_code_length;
                duk_uint32_t atom_copies;
                duk_uint32_t tmp_qmin, tmp_qmax;
 
                /* pre-check how many atom copies we're willing to make (atom_copies not needed below) */
                atom_copies = (re_ctx->curr_token.qmax == DUK_RE_QUANTIFIER_INFINITE) ?
                              re_ctx->curr_token.qmin : re_ctx->curr_token.qmax;
                if (atom_copies > DUK_RE_MAX_ATOM_COPIES) {
                    DUK_ERROR_RANGE(re_ctx->thr, DUK_STR_QUANTIFIER_TOO_MANY_COPIES);
                }
 
                /* wipe the capture range made by the atom (if any) */
                DUK_ASSERT(atom_start_captures <= re_ctx->captures);
                if (atom_start_captures != re_ctx->captures) {
                    DUK_ASSERT(atom_start_captures < re_ctx->captures);
                    DUK_DDD(DUK_DDDPRINT("must wipe ]atom_start_captures,re_ctx->captures]: ]%ld,%ld]",
                                         (long) atom_start_captures, (long) re_ctx->captures));
 
                    /* insert (DUK_REOP_WIPERANGE, start, count) in reverse order so the order ends up right */
                    duk__insert_u32(re_ctx, atom_start_offset, (re_ctx->captures - atom_start_captures) * 2);
                    duk__insert_u32(re_ctx, atom_start_offset, (atom_start_captures + 1) * 2);
                    duk__insert_u32(re_ctx, atom_start_offset, DUK_REOP_WIPERANGE);
                } else {
                    DUK_DDD(DUK_DDDPRINT("no need to wipe captures: atom_start_captures == re_ctx->captures == %ld",
                                         (long) atom_start_captures));
                }
 
                atom_code_length = (duk_int32_t) DUK__RE_BUFLEN(re_ctx) - atom_start_offset;
 
                /* insert the required matches (qmin) by copying the atom */
                tmp_qmin = re_ctx->curr_token.qmin;
                tmp_qmax = re_ctx->curr_token.qmax;
                while (tmp_qmin > 0) {
                    duk__append_slice(re_ctx, atom_start_offset, atom_code_length);
                    tmp_qmin--;
                    if (tmp_qmax != DUK_RE_QUANTIFIER_INFINITE) {
                        tmp_qmax--;
                    }
                }
                DUK_ASSERT(tmp_qmin == 0);
 
                /* insert code for matching the remainder - infinite or finite */
                if (tmp_qmax == DUK_RE_QUANTIFIER_INFINITE) {
                    /* reuse last emitted atom for remaining 'infinite' quantifier */
 
                    if (re_ctx->curr_token.qmin == 0) {
                        /* Special case: original qmin was zero so there is nothing
                         * to repeat.  Emit an atom copy but jump over it here.
                         */
                        duk__append_u32(re_ctx, DUK_REOP_JUMP);
                        duk__append_jump_offset(re_ctx, atom_code_length);
                        duk__append_slice(re_ctx, atom_start_offset, atom_code_length);
                    }
                    if (re_ctx->curr_token.greedy) {
                        duk__append_u32(re_ctx, DUK_REOP_SPLIT2);   /* prefer jump */
                    } else {
                        duk__append_u32(re_ctx, DUK_REOP_SPLIT1);   /* prefer direct */
                    }
                    duk__append_jump_offset(re_ctx, -atom_code_length - 1);  /* -1 for opcode */
                } else {
                    /*
                     *  The remaining matches are emitted as sequence of SPLITs and atom
                     *  copies; the SPLITs skip the remaining copies and match the sequel.
                     *  This sequence needs to be emitted starting from the last copy
                     *  because the SPLITs are variable length due to the variable length
                     *  skip offset.  This causes a lot of memory copying now.
                     *
                     *  Example structure (greedy, match maximum # atoms):
                     *
                     *      SPLIT1 LSEQ
                     *      (atom)
                     *      SPLIT1 LSEQ    ; <- the byte length of this instruction is needed
                     *      (atom)         ; to encode the above SPLIT1 correctly
                     *      ...
                     *   LSEQ:
                     */
                    duk_uint32_t offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);
                    while (tmp_qmax > 0) {
                        duk__insert_slice(re_ctx, offset, atom_start_offset, atom_code_length);
                        if (re_ctx->curr_token.greedy) {
                            duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT1);   /* prefer direct */
                        } else {
                            duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT2);   /* prefer jump */
                        }
                        duk__insert_jump_offset(re_ctx,
                                                offset + 1,   /* +1 for opcode */
                                                (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1)));
                        tmp_qmax--;
                    }
                }
 
                /* remove the original 'template' atom */
                duk__remove_slice(re_ctx, atom_start_offset, atom_code_length);
            }
 
            /* 'taint' result as complex */
            res_charlen = -1;
            break;
        }
        case DUK_RETOK_ASSERT_START: {
            duk__append_u32(re_ctx, DUK_REOP_ASSERT_START);
            break;
        }
        case DUK_RETOK_ASSERT_END: {
            duk__append_u32(re_ctx, DUK_REOP_ASSERT_END);
            break;
        }
        case DUK_RETOK_ASSERT_WORD_BOUNDARY: {
            duk__append_u32(re_ctx, DUK_REOP_ASSERT_WORD_BOUNDARY);
            break;
        }
        case DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY: {
            duk__append_u32(re_ctx, DUK_REOP_ASSERT_NOT_WORD_BOUNDARY);
            break;
        }
        case DUK_RETOK_ASSERT_START_POS_LOOKAHEAD:
        case DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD: {
            duk_uint32_t offset;
            duk_uint32_t opcode = (re_ctx->curr_token.t == DUK_RETOK_ASSERT_START_POS_LOOKAHEAD) ?
                                  DUK_REOP_LOOKPOS : DUK_REOP_LOOKNEG;
 
            offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);
            duk__parse_disjunction(re_ctx, 0, &tmp_disj);
            duk__append_u32(re_ctx, DUK_REOP_MATCH);
 
            (void) duk__insert_u32(re_ctx, offset, opcode);
            (void) duk__insert_jump_offset(re_ctx,
                                           offset + 1,   /* +1 for opcode */
                                           (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1)));
 
            /* 'taint' result as complex -- this is conservative,
             * as lookaheads do not backtrack.
             */
            res_charlen = -1;
            break;
        }
        case DUK_RETOK_ATOM_PERIOD: {
            new_atom_char_length = 1;
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx, DUK_REOP_PERIOD);
            break;
        }
        case DUK_RETOK_ATOM_CHAR: {
            /* Note: successive characters could be joined into string matches
             * but this is not trivial (consider e.g. '/xyz+/); see docs for
             * more discussion.
             */
            duk_uint32_t ch;
 
            new_atom_char_length = 1;
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx, DUK_REOP_CHAR);
            ch = re_ctx->curr_token.num;
            if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) {
                ch = duk_unicode_re_canonicalize_char(re_ctx->thr, ch);
            }
            duk__append_u32(re_ctx, ch);
            break;
        }
        case DUK_RETOK_ATOM_DIGIT:
        case DUK_RETOK_ATOM_NOT_DIGIT: {
            new_atom_char_length = 1;
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx,
                            (re_ctx->curr_token.t == DUK_RETOK_ATOM_DIGIT) ?
                            DUK_REOP_RANGES : DUK_REOP_INVRANGES);
            duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_digit) / (2 * sizeof(duk_uint16_t)));
            duk__append_u16_list(re_ctx, duk_unicode_re_ranges_digit, sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t));
            break;
        }
        case DUK_RETOK_ATOM_WHITE:
        case DUK_RETOK_ATOM_NOT_WHITE: {
            new_atom_char_length = 1;
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx,
                            (re_ctx->curr_token.t == DUK_RETOK_ATOM_WHITE) ?
                            DUK_REOP_RANGES : DUK_REOP_INVRANGES);
            duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_white) / (2 * sizeof(duk_uint16_t)));
            duk__append_u16_list(re_ctx, duk_unicode_re_ranges_white, sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t));
            break;
        }
        case DUK_RETOK_ATOM_WORD_CHAR:
        case DUK_RETOK_ATOM_NOT_WORD_CHAR: {
            new_atom_char_length = 1;
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx,
                            (re_ctx->curr_token.t == DUK_RETOK_ATOM_WORD_CHAR) ?
                            DUK_REOP_RANGES : DUK_REOP_INVRANGES);
            duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_wordchar) / (2 * sizeof(duk_uint16_t)));
            duk__append_u16_list(re_ctx, duk_unicode_re_ranges_wordchar, sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t));
            break;
        }
        case DUK_RETOK_ATOM_BACKREFERENCE: {
            duk_uint32_t backref = (duk_uint32_t) re_ctx->curr_token.num;
            if (backref > re_ctx->highest_backref) {
                re_ctx->highest_backref = backref;
            }
            new_atom_char_length = -1;   /* mark as complex */
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx, DUK_REOP_BACKREFERENCE);
            duk__append_u32(re_ctx, backref);
            break;
        }
        case DUK_RETOK_ATOM_START_CAPTURE_GROUP: {
            duk_uint32_t cap;
 
            new_atom_char_length = -1;   /* mark as complex (capture handling) */
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            cap = ++re_ctx->captures;
            duk__append_u32(re_ctx, DUK_REOP_SAVE);
            duk__append_u32(re_ctx, cap * 2);
            duk__parse_disjunction(re_ctx, 0, &tmp_disj);  /* retval (sub-atom char length) unused, tainted as complex above */
            duk__append_u32(re_ctx, DUK_REOP_SAVE);
            duk__append_u32(re_ctx, cap * 2 + 1);
            break;
        }
        case DUK_RETOK_ATOM_START_NONCAPTURE_GROUP: {
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__parse_disjunction(re_ctx, 0, &tmp_disj);
            new_atom_char_length = tmp_disj.charlen;
            break;
        }
        case DUK_RETOK_ATOM_START_CHARCLASS:
        case DUK_RETOK_ATOM_START_CHARCLASS_INVERTED: {
            /*
             *  Range parsing is done with a special lexer function which calls
             *  us for every range parsed.  This is different from how rest of
             *  the parsing works, but avoids a heavy, arbitrary size intermediate
             *  value type to hold the ranges.
             *
             *  Another complication is the handling of character ranges when
             *  case insensitive matching is used (see docs for discussion).
             *  The range handler callback given to the lexer takes care of this
             *  as well.
             *
             *  Note that duplicate ranges are not eliminated when parsing character
             *  classes, so that canonicalization of
             *
             *    [0-9a-fA-Fx-{]
             *
             *  creates the result (note the duplicate ranges):
             *
             *    [0-9A-FA-FX-Z{-{]
             *
             *  where [x-{] is split as a result of canonicalization.  The duplicate
             *  ranges are not a semantics issue: they work correctly.
             */
 
            duk_uint32_t offset;
 
            DUK_DD(DUK_DDPRINT("character class"));
 
            /* insert ranges instruction, range count patched in later */
            new_atom_char_length = 1;
            new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
            duk__append_u32(re_ctx,
                            (re_ctx->curr_token.t == DUK_RETOK_ATOM_START_CHARCLASS) ?
                            DUK_REOP_RANGES : DUK_REOP_INVRANGES);
            offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);    /* patch in range count later */
 
            /* parse ranges until character class ends */
            re_ctx->nranges = 0;    /* note: ctx-wide temporary */
            duk_lexer_parse_re_ranges(&re_ctx->lex, duk__generate_ranges, (void *) re_ctx);
 
            /* insert range count */
            duk__insert_u32(re_ctx, offset, re_ctx->nranges);
            break;
        }
        case DUK_RETOK_ATOM_END_GROUP: {
            if (expect_eof) {
                DUK_ERROR_SYNTAX(re_ctx->thr, DUK_STR_UNEXPECTED_CLOSING_PAREN);
            }
            goto done;
        }
        case DUK_RETOK_EOF: {
            if (!expect_eof) {
                DUK_ERROR_SYNTAX(re_ctx->thr, DUK_STR_UNEXPECTED_END_OF_PATTERN);
            }
            goto done;
        }
        default: {
            DUK_ERROR_SYNTAX(re_ctx->thr, DUK_STR_UNEXPECTED_REGEXP_TOKEN);
        }
        }
 
        /* a complex (new) atom taints the result */
        if (new_atom_start_offset >= 0) {
            if (new_atom_char_length < 0) {
                res_charlen = -1;
            } else if (res_charlen >= 0) {
                /* only advance if not tainted */
                res_charlen += new_atom_char_length;
            }
        }
 
        /* record previous atom info in case next token is a quantifier */
        atom_start_offset = new_atom_start_offset;
        atom_char_length = new_atom_char_length;
        atom_start_captures = new_atom_start_captures;
    }
 
 done:
 
    /* finish up pending jump and split for last alternative */
    if (unpatched_disjunction_jump >= 0) {
        duk_uint32_t offset;
 
        DUK_ASSERT(unpatched_disjunction_split >= 0);
        offset = unpatched_disjunction_jump;
        offset += duk__insert_jump_offset(re_ctx,

Referenced by duk__parse_disjunction().

◆ duk__parse_do_stmt()

DUK_LOCAL_DECL void duk__parse_do_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_int_t	pc_label_site )

Definition at line 63387 of file duktape-1.8.0/src/duktape.c.

           {
        DUK_DDD(DUK_DDDPRINT("if does not have else part"));
 
        duk__patch_jump_here(comp_ctx, pc_jump_false);
    }
 
    DUK_DDD(DUK_DDDPRINT("end parsing if statement"));
}
 
DUK_LOCAL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
    duk_regconst_t rc_cond;
    duk_int_t pc_start;
 
    DUK_DDD(DUK_DDDPRINT("begin parsing do statement"));
 
    duk__advance(comp_ctx);  /* eat 'do' */
 
    pc_start = duk__get_current_pc(comp_ctx);

◆ duk__parse_for_stmt()

DUK_LOCAL_DECL void duk__parse_for_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_int_t	pc_label_site )

Definition at line 62786 of file duktape-1.8.0/src/duktape.c.

                                                                                                             {
    duk_reg_t reg_varbind;
    duk_regconst_t rc_varname;
 
    duk__advance(comp_ctx);  /* eat 'var' */
 
    for (;;) {
        /* rc_varname and reg_varbind are ignored here */
        duk__parse_var_decl(comp_ctx, res, 0 | expr_flags, &reg_varbind, &rc_varname);
 
        if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
            break;
        }
        duk__advance(comp_ctx);
    }
}
 
DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_int_t pc_v34_lhs;    /* start variant 3/4 left-hand-side code (L1 in doc/compiler.rst example) */
    duk_reg_t temp_reset;    /* knock back "next temp" to this whenever possible */
    duk_reg_t reg_temps;     /* preallocated temporaries (2) for variants 3 and 4 */
 
    DUK_DDD(DUK_DDDPRINT("start parsing a for/for-in statement"));
 
    /* Two temporaries are preallocated here for variants 3 and 4 which need
     * registers which are never clobbered by expressions in the loop
     * (concretely: for the enumerator object and the next enumerated value).
     * Variants 1 and 2 "release" these temps.
     */
 
    reg_temps = DUK__ALLOCTEMPS(comp_ctx, 2);
 
    temp_reset = DUK__GETTEMP(comp_ctx);
 
    /*
     *  For/for-in main variants are:
     *
     *    1. for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement
     *    2. for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement
     *    3. for (LeftHandSideExpression in Expression) Statement
     *    4. for (var VariableDeclarationNoIn in Expression) Statement
     *
     *  Parsing these without arbitrary lookahead or backtracking is relatively
     *  tricky but we manage to do so for now.
     *
     *  See doc/compiler.rst for a detailed discussion of control flow
     *  issues, evaluation order issues, etc.
     */
 
    duk__advance(comp_ctx);  /* eat 'for' */
    duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
 
    DUK_DDD(DUK_DDDPRINT("detecting for/for-in loop variant, pc=%ld", (long) duk__get_current_pc(comp_ctx)));
 
    /* a label site has been emitted by duk__parse_stmt() automatically
     * (it will also emit the ENDLABEL).
     */
 
    if (comp_ctx->curr_token.t == DUK_TOK_VAR) {
        /*
         *  Variant 2 or 4
         */
 
        duk_reg_t reg_varbind;       /* variable binding register if register-bound (otherwise < 0) */
        duk_regconst_t rc_varname;   /* variable name reg/const, if variable not register-bound */
 
        duk__advance(comp_ctx);  /* eat 'var' */
        duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, &reg_varbind, &rc_varname);
        DUK__SETTEMP(comp_ctx, temp_reset);
 
        if (comp_ctx->curr_token.t == DUK_TOK_IN) {
            /*
             *  Variant 4
             */
 
            DUK_DDD(DUK_DDDPRINT("detected for variant 4: for (var VariableDeclarationNoIn in Expression) Statement"));
            pc_v34_lhs = duk__get_current_pc(comp_ctx);  /* jump is inserted here */
            if (reg_varbind >= 0) {
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_LDREG,
                               (duk_regconst_t) reg_varbind,
                               (duk_regconst_t) (reg_temps + 0));
            } else {
                duk__emit_a_bc(comp_ctx,
                               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
                               (duk_regconst_t) (reg_temps + 0),
                               rc_varname);
            }
            goto parse_3_or_4;
        } else {
            /*
             *  Variant 2
             */
 
            DUK_DDD(DUK_DDDPRINT("detected for variant 2: for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement"));
            for (;;) {
                /* more initializers */
                if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
                    break;
                }
                DUK_DDD(DUK_DDDPRINT("variant 2 has another variable initializer"));
 
                duk__advance(comp_ctx);  /* eat comma */
                duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, &reg_varbind, &rc_varname);
            }
            goto parse_1_or_2;
        }
    } else {
        /*
         *  Variant 1 or 3
         */
 
        pc_v34_lhs = duk__get_current_pc(comp_ctx);  /* jump is inserted here (variant 3) */
 
        /* Note that duk__exprtop() here can clobber any reg above current temp_next,
         * so any loop variables (e.g. enumerator) must be "preallocated".
         */
 
        /* don't coerce yet to a plain value (variant 3 needs special handling) */
        duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_REJECT_IN | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/);  /* Expression */
        if (comp_ctx->curr_token.t == DUK_TOK_IN) {
            /*
             *  Variant 3
             */
 
            /* XXX: need to determine LHS type, and check that it is LHS compatible */
            DUK_DDD(DUK_DDDPRINT("detected for variant 3: for (LeftHandSideExpression in Expression) Statement"));
            if (duk__expr_is_empty(comp_ctx)) {
                goto syntax_error;  /* LeftHandSideExpression does not allow empty expression */
            }
 
            if (res->t == DUK_IVAL_VAR) {
                duk_reg_t reg_varbind;
                duk_regconst_t rc_varname;
 
                duk_dup(ctx, res->x1.valstack_idx);
                if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
                    duk__emit_a_bc(comp_ctx,
                                   DUK_OP_LDREG,
                                   (duk_regconst_t) reg_varbind,
                                   (duk_regconst_t) (reg_temps + 0));
                } else {
                    duk__emit_a_bc(comp_ctx,
                                   DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
                                   (duk_regconst_t) (reg_temps + 0),
                                   rc_varname);
                }
            } else if (res->t == DUK_IVAL_PROP) {
                /* Don't allow a constant for the object (even for a number etc), as
                 * it goes into the 'A' field of the opcode.
                 */
                duk_reg_t reg_obj;
                duk_regconst_t rc_key;
                reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
                rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
                duk__emit_a_b_c(comp_ctx,
                                DUK_OP_PUTPROP | DUK__EMIT_FLAG_A_IS_SOURCE,
                                (duk_regconst_t) reg_obj,
                                rc_key,
                                (duk_regconst_t) (reg_temps + 0));
            } else {
                duk__ivalue_toplain_ignore(comp_ctx, res);  /* just in case */
                duk__emit_extraop_only(comp_ctx,
                                       DUK_EXTRAOP_INVLHS);
            }
            goto parse_3_or_4;
        } else {
            /*
             *  Variant 1
             */
 
            DUK_DDD(DUK_DDDPRINT("detected for variant 1: for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement"));
            duk__ivalue_toplain_ignore(comp_ctx, res);
            goto parse_1_or_2;
        }
    }
 
 parse_1_or_2:
    /*
     *  Parse variant 1 or 2.  The first part expression (which differs
     *  in the variants) has already been parsed and its code emitted.
     *
     *  reg_temps + 0: unused
     *  reg_temps + 1: unused
     */
    {
        duk_regconst_t rc_cond;
        duk_int_t pc_l1, pc_l2, pc_l3, pc_l4;
        duk_int_t pc_jumpto_l3, pc_jumpto_l4;
        duk_bool_t expr_c_empty;
 
        DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 1 and 2"));
 
        /* "release" preallocated temps since we won't need them */
        temp_reset = reg_temps + 0;
        DUK__SETTEMP(comp_ctx, temp_reset);
 
        duk__advance_expect(comp_ctx, DUK_TOK_SEMICOLON);
 
        pc_l1 = duk__get_current_pc(comp_ctx);
        duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/);  /* Expression_opt */
        if (duk__expr_is_empty(comp_ctx)) {
            /* no need to coerce */
            pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx);  /* to body */
            pc_jumpto_l4 = -1;  /* omitted */
        } else {
            rc_cond = duk__ivalue_toregconst(comp_ctx, res);
            duk__emit_if_false_skip(comp_ctx, rc_cond);
            pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx);  /* to body */
            pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx);  /* to exit */
        }
        DUK__SETTEMP(comp_ctx, temp_reset);
 
        duk__advance_expect(comp_ctx, DUK_TOK_SEMICOLON);
 
        pc_l2 = duk__get_current_pc(comp_ctx);
        duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/);  /* Expression_opt */
        if (duk__expr_is_empty(comp_ctx)) {
            /* no need to coerce */
            expr_c_empty = 1;
            /* JUMP L1 omitted */
        } else {
            duk__ivalue_toplain_ignore(comp_ctx, res);
            expr_c_empty = 0;
            duk__emit_jump(comp_ctx, pc_l1);
        }
        DUK__SETTEMP(comp_ctx, temp_reset);
 
        duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
 
        pc_l3 = duk__get_current_pc(comp_ctx);
        duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
        if (expr_c_empty) {
            duk__emit_jump(comp_ctx, pc_l1);
        } else {
            duk__emit_jump(comp_ctx, pc_l2);
        }
        /* temp reset is not necessary after duk__parse_stmt(), which already does it */
 
        pc_l4 = duk__get_current_pc(comp_ctx);
 
        DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l3: %ld->%ld, jumpto_l4: %ld->%ld, "
                             "break: %ld->%ld, continue: %ld->%ld",
                         (long) pc_jumpto_l3, (long) pc_l3, (long) pc_jumpto_l4, (long) pc_l4,
                             (long) (pc_label_site + 1), (long) pc_l4, (long) (pc_label_site + 2), (long) pc_l2));
 
        duk__patch_jump(comp_ctx, pc_jumpto_l3, pc_l3);
        duk__patch_jump(comp_ctx, pc_jumpto_l4, pc_l4);
        duk__patch_jump(comp_ctx,
                        pc_label_site + 1,
                        pc_l4);                         /* break jump */
        duk__patch_jump(comp_ctx,
                        pc_label_site + 2,
                        expr_c_empty ? pc_l1 : pc_l2);  /* continue jump */
    }
    goto finished;
 
 parse_3_or_4:
    /*
     *  Parse variant 3 or 4.
     *
     *  For variant 3 (e.g. "for (A in C) D;") the code for A (except the
     *  final property/variable write) has already been emitted.  The first
     *  instruction of that code is at pc_v34_lhs; a JUMP needs to be inserted
     *  there to satisfy control flow needs.
     *
     *  For variant 4, if the variable declaration had an initializer
     *  (e.g. "for (var A = B in C) D;") the code for the assignment
     *  (B) has already been emitted.
     *
     *  Variables set before entering here:
     *
     *    pc_v34_lhs:    insert a "JUMP L2" here (see doc/compiler.rst example).
     *    reg_temps + 0: iteration target value (written to LHS)
     *    reg_temps + 1: enumerator object
     */
    {
        duk_int_t pc_l1, pc_l2, pc_l3, pc_l4, pc_l5;
        duk_int_t pc_jumpto_l2, pc_jumpto_l3, pc_jumpto_l4, pc_jumpto_l5;
        duk_reg_t reg_target;
 
        DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 3 and 4, pc_v34_lhs=%ld", (long) pc_v34_lhs));
 
        DUK__SETTEMP(comp_ctx, temp_reset);
 
        /* First we need to insert a jump in the middle of previously
         * emitted code to get the control flow right.  No jumps can
         * cross the position where the jump is inserted.  See doc/compiler.rst
         * for discussion on the intricacies of control flow and side effects
         * for variants 3 and 4.
         */
 
        duk__insert_jump_entry(comp_ctx, pc_v34_lhs);
        pc_jumpto_l2 = pc_v34_lhs;  /* inserted jump */
        pc_l1 = pc_v34_lhs + 1;     /* +1, right after inserted jump */
 
        /* The code for writing reg_temps + 0 to the left hand side has already
         * been emitted.
         */
 
        pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx);  /* -> loop body */
 
        duk__advance(comp_ctx);  /* eat 'in' */
 
        /* Parse enumeration target and initialize enumerator.  For 'null' and 'undefined',
         * INITENUM will creates a 'null' enumerator which works like an empty enumerator
         * (E5 Section 12.6.4, step 3).  Note that INITENUM requires the value to be in a
         * register (constant not allowed).
         */
 
        pc_l2 = duk__get_current_pc(comp_ctx);
        reg_target = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);  /* Expression */
        duk__emit_extraop_b_c(comp_ctx,
                              DUK_EXTRAOP_INITENUM | DUK__EMIT_FLAG_B_IS_TARGET,
                              (duk_regconst_t) (reg_temps + 1),
                              (duk_regconst_t) reg_target);
        pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx);
        DUK__SETTEMP(comp_ctx, temp_reset);
 
        duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
 
        pc_l3 = duk__get_current_pc(comp_ctx);
        duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
        /* temp reset is not necessary after duk__parse_stmt(), which already does it */
 
        /* NEXTENUM needs a jump slot right after the main opcode.
         * We need the code emitter to reserve the slot: if there's
         * target shuffling, the target shuffle opcodes must happen
         * after the jump slot (for NEXTENUM the shuffle opcodes are
         * not needed if the enum is finished).
         */
        pc_l4 = duk__get_current_pc(comp_ctx);
        duk__emit_extraop_b_c(comp_ctx,
                              DUK_EXTRAOP_NEXTENUM | DUK__EMIT_FLAG_B_IS_TARGET | DUK__EMIT_FLAG_RESERVE_JUMPSLOT,
                              (duk_regconst_t) (reg_temps + 0),
                              (duk_regconst_t) (reg_temps + 1));
        pc_jumpto_l5 = comp_ctx->emit_jumpslot_pc;  /* NEXTENUM jump slot: executed when enum finished */
        duk__emit_jump(comp_ctx, pc_l1);  /* jump to next loop, using reg_v34_iter as iterated value */
 
        pc_l5 = duk__get_current_pc(comp_ctx);
 
        /* XXX: since the enumerator may be a memory expensive object,
         * perhaps clear it explicitly here?  If so, break jump must
         * go through this clearing operation.
         */
 
        DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l2: %ld->%ld, jumpto_l3: %ld->%ld, "
                             "jumpto_l4: %ld->%ld, jumpto_l5: %ld->%ld, "
                             "break: %ld->%ld, continue: %ld->%ld",
                         (long) pc_jumpto_l2, (long) pc_l2, (long) pc_jumpto_l3, (long) pc_l3,
                         (long) pc_jumpto_l4, (long) pc_l4, (long) pc_jumpto_l5, (long) pc_l5,
                             (long) (pc_label_site + 1), (long) pc_l5, (long) (pc_label_site + 2), (long) pc_l4));

References duk_compiler_ctx::curr_token, duk__advance(), duk__parse_var_decl(), DUK_TOK_COMMA, and duk_token::t.

◆ duk__parse_func_body()

DUK_LOCAL_DECL void duk__parse_func_body	(	duk_compiler_ctx *	comp_ctx,
		duk_bool_t	expect_eof,
		duk_bool_t	implicit_return_value,
		duk_small_int_t	expect_token )

Definition at line 64849 of file duktape-1.8.0/src/duktape.c.

              :
 *
 *    - Global and eval code have an implicit return value generated
 *      by the last statement; function code does not
 *
 *    - Global code, eval code, and Function constructor body end in
 *      an EOF, other bodies in a closing brace ('}')
 *
 *  Upon entry, 'curr_tok' is ignored and the function will pull in the
 *  first token on its own.  Upon exit, 'curr_tok' is the terminating
 *  token (EOF or closing brace).
 */
 
DUK_LOCAL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token) {
    duk_compiler_func *func;
    duk_hthread *thr;
    duk_context *ctx;
    duk_reg_t reg_stmt_value = -1;
    duk_lexer_point lex_pt;
    duk_reg_t temp_first;
    duk_small_int_t compile_round = 1;
 
    DUK_ASSERT(comp_ctx != NULL);
 
    thr = comp_ctx->thr;
    ctx = (duk_context *) thr;
    DUK_ASSERT(thr != NULL);
 
    func = &comp_ctx->curr_func;
    DUK_ASSERT(func != NULL);
 
    DUK__RECURSION_INCREASE(comp_ctx, thr);
 
    duk_require_stack(ctx, DUK__FUNCTION_BODY_REQUIRE_SLOTS);
 
    /*
     *  Store lexer position for a later rewind
     */
 
    DUK_LEXER_GETPOINT(&comp_ctx->lex, &lex_pt);
 
    /*
     *  Program code (global and eval code) has an implicit return value
     *  from the last statement value (e.g. eval("1; 2+3;") returns 3).
     *  This is not the case with functions.  If implicit statement return
     *  value is requested, all statements are coerced to a register
     *  allocated here, and used in the implicit return statement below.
     */
 
    /* XXX: this is pointless here because pass 1 is throw-away */
    if (implicit_return_value) {
        reg_stmt_value = DUK__ALLOCTEMP(comp_ctx);
 
        /* If an implicit return value is needed by caller, it must be
         * initialized to 'undefined' because we don't know whether any
         * non-empty (where "empty" is a continuation type, and different
         * from an empty statement) statements will be executed.
         *
         * However, since 1st pass is a throwaway one, no need to emit
         * it here.
         */
#if 0
        duk__emit_extraop_bc(comp_ctx,
                             DUK_EXTRAOP_LDUNDEF,
                             0);
#endif
    }
 
    /*
     *  First pass.
     *
     *  Gather variable/function declarations needed for second pass.
     *  Code generated is dummy and discarded.
     */
 
    func->in_directive_prologue = 1;
    func->in_scanning = 1;
    func->may_direct_eval = 0;
    func->id_access_arguments = 0;
    func->id_access_slow = 0;
    func->reg_stmt_value = reg_stmt_value;
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    func->min_line = DUK_INT_MAX;
    func->max_line = 0;
#endif
 
    /* duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp literal" mode with current strictness */
    if (expect_token >= 0) {
        /* Eating a left curly; regexp mode is allowed by left curly
         * based on duk__token_lbp[] automatically.
         */
        DUK_ASSERT(expect_token == DUK_TOK_LCURLY);
        duk__update_lineinfo_currtoken(comp_ctx);
        duk__advance_expect(comp_ctx, expect_token);
    } else {
        /* Need to set curr_token.t because lexing regexp mode depends on current
         * token type.  Zero value causes "allow regexp" mode.
         */
        comp_ctx->curr_token.t = 0;
        duk__advance(comp_ctx);
    }
 
    DUK_DDD(DUK_DDDPRINT("begin 1st pass"));
    duk__parse_stmts(comp_ctx,
                     1,             /* allow source elements */
                     expect_eof);   /* expect EOF instead of } */
    DUK_DDD(DUK_DDDPRINT("end 1st pass"));
 
    /*
     *  Second (and possibly third) pass.
     *
     *  Generate actual code.  In most cases the need for shuffle
     *  registers is detected during pass 1, but in some corner cases
     *  we'll only detect it during pass 2 and a third pass is then
     *  needed (see GH-115).
     */
 
    for (;;) {
        duk_bool_t needs_shuffle_before = comp_ctx->curr_func.needs_shuffle;
        compile_round++;
 
        /*
         *  Rewind lexer.
         *
         *  duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp
         *  literal" mode with current strictness.
         *
         *  curr_token line number info should be initialized for pass 2 before
         *  generating prologue, to ensure prologue bytecode gets nice line numbers.
         */
 
        DUK_DDD(DUK_DDDPRINT("rewind lexer"));
        DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt);
        comp_ctx->curr_token.t = 0;  /* this is needed for regexp mode */
        comp_ctx->curr_token.start_line = 0;  /* needed for line number tracking (becomes prev_token.start_line) */
        duk__advance(comp_ctx);
 
        /*
         *  Reset function state and perform register allocation, which creates
         *  'varmap' for second pass.  Function prologue for variable declarations,
         *  binding value initializations etc is emitted as a by-product.
         *
         *  Strict mode restrictions for duplicate and invalid argument
         *  names are checked here now that we know whether the function
         *  is actually strict.  See: test-dev-strict-mode-boundary.js.
         *
         *  Inner functions are compiled during pass 1 and are not reset.
         */
 
        duk__reset_func_for_pass2(comp_ctx);
        func->in_directive_prologue = 1;
        func->in_scanning = 0;
 
        /* must be able to emit code, alloc consts, etc. */
 
        duk__init_varmap_and_prologue_for_pass2(comp_ctx,
                                                (implicit_return_value ? &reg_stmt_value : NULL));
        func->reg_stmt_value = reg_stmt_value;
 
        temp_first = DUK__GETTEMP(comp_ctx);
 
        func->temp_first = temp_first;
        func->temp_next = temp_first;
        func->stmt_next = 0;
        func->label_next = 0;
 
        /* XXX: init or assert catch depth etc -- all values */
        func->id_access_arguments = 0;
        func->id_access_slow = 0;
 
        /*
         *  Check function name validity now that we know strictness.
         *  This only applies to function declarations and expressions,
         *  not setter/getter name.
         *
         *  See: test-dev-strict-mode-boundary.js
         */
 
        if (func->is_function && !func->is_setget && func->h_name != NULL) {
            if (func->is_strict) {
                if (duk__hstring_is_eval_or_arguments(comp_ctx, func->h_name)) {
                    DUK_DDD(DUK_DDDPRINT("func name is 'eval' or 'arguments' in strict mode"));
                    goto error_funcname;
                }
                if (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(func->h_name)) {
                    DUK_DDD(DUK_DDDPRINT("func name is a reserved word in strict mode"));
                    goto error_funcname;
                }
            } else {
                if (DUK_HSTRING_HAS_RESERVED_WORD(func->h_name) &&
                    !DUK_HSTRING_HAS_STRICT_RESERVED_WORD(func->h_name)) {
                    DUK_DDD(DUK_DDDPRINT("func name is a reserved word in non-strict mode"));
                    goto error_funcname;
                }
            }
        }
 
        /*
         *  Second pass parsing.
         */
 
        if (implicit_return_value) {
            /* Default implicit return value. */
            duk__emit_extraop_bc(comp_ctx,
                                 DUK_EXTRAOP_LDUNDEF,
                                 0);
        }
 
        DUK_DDD(DUK_DDDPRINT("begin 2nd pass"));
        duk__parse_stmts(comp_ctx,
                         1,             /* allow source elements */
                         expect_eof);   /* expect EOF instead of } */
        DUK_DDD(DUK_DDDPRINT("end 2nd pass"));
 
        duk__update_lineinfo_currtoken(comp_ctx);
 
        if (needs_shuffle_before == comp_ctx->curr_func.needs_shuffle) {
            /* Shuffle decision not changed. */
            break;
        }
        if (compile_round >= 3) {
            /* Should never happen but avoid infinite loop just in case. */
            DUK_D(DUK_DPRINT("more than 3 compile passes needed, should never happen"));
            DUK_ERROR_INTERNAL_DEFMSG(thr);
        }
        DUK_D(DUK_DPRINT("need additional round to compile function, round now %d", (int) compile_round));
    }
 
    /*
     *  Emit a final RETURN.
     *
     *  It would be nice to avoid emitting an unnecessary "return" opcode
     *  if the current PC is not reachable.  However, this cannot be reliably
     *  detected; even if the previous instruction is an unconditional jump,
     *  there may be a previous jump which jumps to current PC (which is the
     *  case for iteration and conditional statements, for instance).
     */
 
    /* XXX: request a "last statement is terminal" from duk__parse_stmt() and duk__parse_stmts();
     * we could avoid the last RETURN if we could ensure there is no way to get here
     * (directly or via a jump)
     */
 
    DUK_ASSERT(comp_ctx->curr_func.catch_depth == 0);
    if (reg_stmt_value >= 0) {
        duk__emit_a_b(comp_ctx,
                      DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A,
                      (duk_regconst_t) DUK_BC_RETURN_FLAG_HAVE_RETVAL /*flags*/,
                      (duk_regconst_t) reg_stmt_value /*reg*/);
    } else {
        duk__emit_a_b(comp_ctx,
                      DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A,
                      (duk_regconst_t) 0 /*flags*/,
                      (duk_regconst_t) 0 /*reg(ignored)*/);
    }
 

◆ duk__parse_func_formals()

DUK_LOCAL_DECL void duk__parse_func_formals ( duk_compiler_ctx * comp_ctx )

Definition at line 65128 of file duktape-1.8.0/src/duktape.c.

                                    :
 *
 *    - function expression
 *    - function declaration
 *    - function statement (non-standard)
 *    - setter/getter
 *
 *  Adds the function to comp_ctx->curr_func function table and returns the
 *  function number.
 *
 *  On entry, curr_token points to:
 *
 *    - the token after 'function' for function expression/declaration/statement
 *    - the token after 'set' or 'get' for setter/getter
 */
 
/* Parse formals. */
DUK_LOCAL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t first = 1;
    duk_uarridx_t n;
 
    for (;;) {
        if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
            break;
        }
 
        if (first) {
            /* no comma */
            first = 0;
        } else {
            duk__advance_expect(comp_ctx, DUK_TOK_COMMA);
        }
 
        /* Note: when parsing a formal list in non-strict context, e.g.
         * "implements" is parsed as an identifier.  When the function is
         * later detected to be strict, the argument list must be rechecked
         * against a larger set of reserved words (that of strict mode).
         * This is handled by duk__parse_func_body().  Here we recognize
         * whatever tokens are considered reserved in current strictness
         * (which is not always enough).
         */

References duk_compiler_ctx::curr_token, duk__advance_expect(), DUK_ASSERT, DUK_ERROR_SYNTAX, DUK_TOK_COMMA, DUK_TOK_IDENTIFIER, DUK_TOK_RPAREN, duk_token::t, and duk_compiler_ctx::thr.

◆ duk__parse_func_like_fnum()

DUK_LOCAL_DECL duk_int_t duk__parse_func_like_fnum	(	duk_compiler_ctx *	comp_ctx,
		duk_bool_t	is_decl,
		duk_bool_t	is_setget )

Definition at line 65284 of file duktape-1.8.0/src/duktape.c.

                                                                                                                    {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_compiler_func old_func;
    duk_idx_t entry_top;
    duk_int_t fnum;
 
    /*
     *  On second pass, skip the function.
     */
 
    if (!comp_ctx->curr_func.in_scanning) {
        duk_lexer_point lex_pt;
 
        fnum = comp_ctx->curr_func.fnum_next++;
        duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 1));
        lex_pt.offset = duk_to_int(ctx, -1);
        duk_pop(ctx);
        duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 2));
        lex_pt.line = duk_to_int(ctx, -1);
        duk_pop(ctx);
 
        DUK_DDD(DUK_DDDPRINT("second pass of an inner func, skip the function, reparse closing brace; lex offset=%ld, line=%ld",
                             (long) lex_pt.offset, (long) lex_pt.line));
 
        DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt);
        comp_ctx->curr_token.t = 0;  /* this is needed for regexp mode */
        comp_ctx->curr_token.start_line = 0;  /* needed for line number tracking (becomes prev_token.start_line) */
        duk__advance(comp_ctx);
        duk__advance_expect(comp_ctx, DUK_TOK_RCURLY);
 
        return fnum;
    }
 
    /*
     *  On first pass, perform actual parsing.  Remember valstack top on entry
     *  to restore it later, and switch to using a new function in comp_ctx.
     */
 
    entry_top = duk_get_top(ctx);
    DUK_DDD(DUK_DDDPRINT("before func: entry_top=%ld, curr_tok.start_offset=%ld",
                         (long) entry_top, (long) comp_ctx->curr_token.start_offset));
 
    DUK_MEMCPY(&old_func, &comp_ctx->curr_func, sizeof(duk_compiler_func));
 
    DUK_MEMZERO(&comp_ctx->curr_func, sizeof(duk_compiler_func));
    duk__init_func_valstack_slots(comp_ctx);
    DUK_ASSERT(comp_ctx->curr_func.num_formals == 0);
 
    /* inherit initial strictness from parent */
    comp_ctx->curr_func.is_strict = old_func.is_strict;
 
    DUK_ASSERT(comp_ctx->curr_func.is_notail == 0);
    comp_ctx->curr_func.is_function = 1;
    DUK_ASSERT(comp_ctx->curr_func.is_eval == 0);
    DUK_ASSERT(comp_ctx->curr_func.is_global == 0);
    comp_ctx->curr_func.is_setget = is_setget;
    comp_ctx->curr_func.is_decl = is_decl;
 
    /*
     *  Parse inner function
     */
 
    duk__parse_func_like_raw(comp_ctx, is_decl, is_setget);  /* pushes function template */
 
    /* prev_token.start_offset points to the closing brace here; when skipping
     * we're going to reparse the closing brace to ensure semicolon insertion
     * etc work as expected.
     */
    DUK_DDD(DUK_DDDPRINT("after func: prev_tok.start_offset=%ld, curr_tok.start_offset=%ld",
                         (long) comp_ctx->prev_token.start_offset, (long) comp_ctx->curr_token.start_offset));
    DUK_ASSERT(comp_ctx->lex.input[comp_ctx->prev_token.start_offset] == (duk_uint8_t) DUK_ASC_RCURLY);
 
    /* XXX: append primitive */
    DUK_ASSERT(duk_get_length(ctx, old_func.funcs_idx) == (duk_size_t) (old_func.fnum_next * 3));
    fnum = old_func.fnum_next++;
 
    if (fnum > DUK__MAX_FUNCS) {
        DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_FUNC_LIMIT);
    }
 
    /* array writes autoincrement length */

◆ duk__parse_func_like_raw()

DUK_LOCAL_DECL void duk__parse_func_like_raw	(	duk_compiler_ctx *	comp_ctx,
		duk_bool_t	is_decl,
		duk_bool_t	is_setget )

Definition at line 65176 of file duktape-1.8.0/src/duktape.c.

                                             : %!O",
                             (duk_heaphdr *) comp_ctx->curr_token.str1));
 
        /* XXX: append primitive */
        duk_push_hstring(ctx, comp_ctx->curr_token.str1);
        n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx);
        duk_put_prop_index(ctx, comp_ctx->curr_func.argnames_idx, n);
 
        duk__advance(comp_ctx);  /* eat identifier */
    }
}
 
/* Parse a function-like expression, assuming that 'comp_ctx->curr_func' is
 * correctly set up.  Assumes that curr_token is just after 'function' (or
 * 'set'/'get' etc).
 */
DUK_LOCAL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
 
    DUK_ASSERT(comp_ctx->curr_func.num_formals == 0);
    DUK_ASSERT(comp_ctx->curr_func.is_function == 1);
    DUK_ASSERT(comp_ctx->curr_func.is_eval == 0);
    DUK_ASSERT(comp_ctx->curr_func.is_global == 0);
    DUK_ASSERT(comp_ctx->curr_func.is_setget == is_setget);
    DUK_ASSERT(comp_ctx->curr_func.is_decl == is_decl);
 
    duk__update_lineinfo_currtoken(comp_ctx);
 
    /*
     *  Function name (if any)
     *
     *  We don't check for prohibited names here, because we don't
     *  yet know whether the function will be strict.  Function body
     *  parsing handles this retroactively.
     *
     *  For function expressions and declarations function name must
     *  be an Identifer (excludes reserved words).  For setter/getter
     *  it is a PropertyName which allows reserved words and also
     *  strings and numbers (e.g. "{ get 1() { ... } }").
     */
 
    if (is_setget) {
        /* PropertyName -> IdentifierName | StringLiteral | NumericLiteral */
        if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER ||
            comp_ctx->curr_token.t == DUK_TOK_STRING) {
            duk_push_hstring(ctx, comp_ctx->curr_token.str1);       /* keep in valstack */
        } else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) {
            duk_push_number(ctx, comp_ctx->curr_token.num);
            duk_to_string(ctx, -1);
        } else {
            DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_GETSET_NAME);
        }
        comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1);  /* borrowed reference */
        DUK_ASSERT(comp_ctx->curr_func.h_name != NULL);
        duk__advance(comp_ctx);
    } else {
        /* Function name is an Identifier (not IdentifierName), but we get
         * the raw name (not recognizing keywords) here and perform the name
         * checks only after pass 1.
         */
        if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER) {
            duk_push_hstring(ctx, comp_ctx->curr_token.str1);       /* keep in valstack */
            comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1);  /* borrowed reference */
            DUK_ASSERT(comp_ctx->curr_func.h_name != NULL);
            duk__advance(comp_ctx);
        } else {
            /* valstack will be unbalanced, which is OK */
            DUK_ASSERT(!is_setget);
            if (is_decl) {
                DUK_ERROR_SYNTAX(thr, DUK_STR_FUNC_NAME_REQUIRED);
            }
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("function name: %!O",
                         (duk_heaphdr *) comp_ctx->curr_func.h_name));
 
    /*
     *  Formal argument list
     *
     *  We don't check for prohibited names or for duplicate argument
     *  names here, becase we don't yet know whether the function will
     *  be strict.  Function body parsing handles this retroactively.
     */
 
    duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
 
    duk__parse_func_formals(comp_ctx);
 
    DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RPAREN);
    duk__advance(comp_ctx);

◆ duk__parse_if_stmt()

DUK_LOCAL_DECL void duk__parse_if_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 63340 of file duktape-1.8.0/src/duktape.c.

             :
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_SWITCH);
}
 
DUK_LOCAL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_reg_t temp_reset;
    duk_regconst_t rc_cond;
    duk_int_t pc_jump_false;
 
    DUK_DDD(DUK_DDDPRINT("begin parsing if statement"));
 
    temp_reset = DUK__GETTEMP(comp_ctx);
 
    duk__advance(comp_ctx);  /* eat 'if' */
    duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
 
    rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
    duk__emit_if_true_skip(comp_ctx, rc_cond);
    pc_jump_false = duk__emit_jump_empty(comp_ctx);  /* jump to end or else part */
    DUK__SETTEMP(comp_ctx, temp_reset);
 
    duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
 
    duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
 
    /* The 'else' ambiguity is resolved by 'else' binding to the innermost
     * construct, so greedy matching is correct here.
     */
 
    if (comp_ctx->curr_token.t == DUK_TOK_ELSE) {
        duk_int_t pc_jump_end;
 
        DUK_DDD(DUK_DDDPRINT("if has else part"));

◆ duk__parse_regexp_flags()

DUK_LOCAL duk_uint32_t duk__parse_regexp_flags	(	duk_hthread *	thr,
		duk_hstring *	h )

Definition at line 78420 of file duktape-1.8.0/src/duktape.c.

                                                    : charlen=%ld",
                         (long) out_atom_info->charlen));
 
    re_ctx->recursion_depth--;
}
 
/*
 *  Flags parsing (see E5 Section 15.10.4.1).
 */
 
DUK_LOCAL duk_uint32_t duk__parse_regexp_flags(duk_hthread *thr, duk_hstring *h) {
    const duk_uint8_t *p;
    const duk_uint8_t *p_end;
    duk_uint32_t flags = 0;
 
    p = DUK_HSTRING_GET_DATA(h);
    p_end = p + DUK_HSTRING_GET_BYTELEN(h);
 
    /* Note: can be safely scanned as bytes (undecoded) */
 
    while (p < p_end) {
        duk_uint8_t c = *p++;
        switch ((int) c) {
        case (int) 'g': {
            if (flags & DUK_RE_FLAG_GLOBAL) {
                goto error;
            }
            flags |= DUK_RE_FLAG_GLOBAL;
            break;
        }
        case (int) 'i': {
            if (flags & DUK_RE_FLAG_IGNORE_CASE) {
                goto error;
            }
            flags |= DUK_RE_FLAG_IGNORE_CASE;
            break;
        }
        case (int) 'm': {
            if (flags & DUK_RE_FLAG_MULTILINE) {

◆ duk__parse_return_stmt()

DUK_LOCAL_DECL void duk__parse_return_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 63502 of file duktape-1.8.0/src/duktape.c.

                                                          : 2));
    } else {
        DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, "
                             "label_catch_depth=%ld, catch_depth=%ld "
                             "-> use slow variant (longjmp)",
                             (long) is_break, (long) label_id, (long) label_is_closest,
                             (long) label_catch_depth, (long) comp_ctx->curr_func.catch_depth));
 
        duk__emit_extraop_bc(comp_ctx,
                      is_break ? DUK_EXTRAOP_BREAK : DUK_EXTRAOP_CONTINUE,
                      (duk_regconst_t) label_id);
    }
}
 
DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_hthread *thr = comp_ctx->thr;
    duk_regconst_t rc_val;
    duk_small_uint_t ret_flags;
 
    duk__advance(comp_ctx);  /* eat 'return' */
 
    /* A 'return' statement is only allowed inside an actual function body,
     * not as part of eval or global code.
     */
    if (!comp_ctx->curr_func.is_function) {
        DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_RETURN);
    }
 
    ret_flags = 0;
 
    if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON ||  /* explicit semi follows */
        comp_ctx->curr_token.lineterm ||                /* automatic semi will be inserted */
        comp_ctx->curr_token.allow_auto_semi) {         /* automatic semi will be inserted */
        DUK_DDD(DUK_DDDPRINT("empty return value -> undefined"));
        rc_val = 0;
    } else {
        duk_int_t pc_before_expr;
        duk_int_t pc_after_expr;
 
        DUK_DDD(DUK_DDDPRINT("return with a value"));
 
        DUK_UNREF(pc_before_expr);
        DUK_UNREF(pc_after_expr);
 
        pc_before_expr = duk__get_current_pc(comp_ctx);
        rc_val = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
        pc_after_expr = duk__get_current_pc(comp_ctx);
 
        /* Tail call check: if last opcode emitted was CALL(I), and
         * the context allows it, change the CALL(I) to a tail call.
         * This doesn't guarantee that a tail call will be allowed at
         * runtime, so the RETURN must still be emitted.  (Duktape
         * 0.10.0 avoided this and simulated a RETURN if a tail call
         * couldn't be used at runtime; but this didn't work
         * correctly with a thread yield/resume, see
         * test-bug-tailcall-thread-yield-resume.js for discussion.)
         *
         * In addition to the last opcode being CALL, we also need to
         * be sure that 'rc_val' is the result register of the CALL(I).
         * For instance, for the expression 'return 0, (function ()
         * { return 1; }), 2' the last opcode emitted is CALL (no
         * bytecode is emitted for '2') but 'rc_val' indicates
         * constant '2'.  Similarly if '2' is replaced by a register
         * bound variable, no opcodes are emitted but tail call would
         * be incorrect.
         *
         * This is tricky and easy to get wrong.  It would be best to
         * track enough expression metadata to check that 'rc_val' came
         * from that last CALL instruction.  We don't have that metadata
         * now, so we check that 'rc_val' is a temporary register result
         * (not a constant or a register bound variable).  There should
         * be no way currently for 'rc_val' to be a temporary for an
         * expression following the CALL instruction without emitting
         * some opcodes following the CALL.  This proxy check is used
         * below.
         *
         * See: test-bug-comma-expr-gh131.js.
         *
         * The non-standard 'caller' property disables tail calls
         * because they pose some special cases which haven't been
         * fixed yet.
         */
 
#if defined(DUK_USE_TAILCALL)
        if (comp_ctx->curr_func.catch_depth == 0 &&   /* no catchers */
            pc_after_expr > pc_before_expr) {         /* at least one opcode emitted */
            duk_compiler_instr *instr;
            duk_small_uint_t op;
 
            instr = duk__get_instr_ptr(comp_ctx, pc_after_expr - 1);
            DUK_ASSERT(instr != NULL);
 
            op = (duk_small_uint_t) DUK_DEC_OP(instr->ins);
            if ((op == DUK_OP_CALL || op == DUK_OP_CALLI) &&
                DUK__ISTEMP(comp_ctx, rc_val) /* see above */) {
                DUK_DDD(DUK_DDDPRINT("return statement detected a tail call opportunity: "

◆ duk__parse_stmt()

DUK_LOCAL_DECL void duk__parse_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_bool_t	allow_source_elem )

Definition at line 63917 of file duktape-1.8.0/src/duktape.c.

                                                               : %ld", (long) label_id));
 
    duk__emit_extraop_bc(comp_ctx,
                         DUK_EXTRAOP_LABEL,
                         (duk_regconst_t) label_id);
    duk__emit_invalid(comp_ctx);
    duk__emit_invalid(comp_ctx);
 
    return label_id;
}
 
/* Parse a single statement.
 *
 * Creates a label site (with an empty label) automatically for iteration
 * statements.  Also "peels off" any label statements for explicit labels.
 */
DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t dir_prol_at_entry;    /* directive prologue status at entry */
    duk_reg_t temp_at_entry;
    duk_uarridx_t labels_len_at_entry;
    duk_int_t pc_at_entry;           /* assumed to also be PC of "LABEL" */
    duk_int_t stmt_id;
    duk_small_uint_t stmt_flags = 0;
    duk_int_t label_id = -1;
    duk_small_uint_t tok;
 
    DUK__RECURSION_INCREASE(comp_ctx, thr);
 
    temp_at_entry = DUK__GETTEMP(comp_ctx);
    pc_at_entry = duk__get_current_pc(comp_ctx);
    labels_len_at_entry = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.labelnames_idx);
    stmt_id = comp_ctx->curr_func.stmt_next++;
    dir_prol_at_entry = comp_ctx->curr_func.in_directive_prologue;
 
    DUK_UNREF(stmt_id);
 
    DUK_DDD(DUK_DDDPRINT("parsing a statement, stmt_id=%ld, temp_at_entry=%ld, labels_len_at_entry=%ld, "
                         "is_strict=%ld, in_directive_prologue=%ld, catch_depth=%ld",
                         (long) stmt_id, (long) temp_at_entry, (long) labels_len_at_entry,
                         (long) comp_ctx->curr_func.is_strict, (long) comp_ctx->curr_func.in_directive_prologue,
                         (long) comp_ctx->curr_func.catch_depth));
 
    /* The directive prologue flag is cleared by default so that it is
     * unset for any recursive statement parsing.  It is only "revived"
     * if a directive is detected.  (We could also make directives only
     * allowed if 'allow_source_elem' was true.)
     */
    comp_ctx->curr_func.in_directive_prologue = 0;
 
 retry_parse:
 
    DUK_DDD(DUK_DDDPRINT("try stmt parse, stmt_id=%ld, label_id=%ld, allow_source_elem=%ld, catch_depth=%ld",
                         (long) stmt_id, (long) label_id, (long) allow_source_elem,
                         (long) comp_ctx->curr_func.catch_depth));
 
    /*
     *  Detect iteration statements; if encountered, establish an
     *  empty label.
     */
 
    tok = comp_ctx->curr_token.t;
    if (tok == DUK_TOK_FOR || tok == DUK_TOK_DO || tok == DUK_TOK_WHILE ||
        tok == DUK_TOK_SWITCH) {
        DUK_DDD(DUK_DDDPRINT("iteration/switch statement -> add empty label"));
 
        label_id = duk__stmt_label_site(comp_ctx, label_id);
        duk__add_label(comp_ctx,
                       DUK_HTHREAD_STRING_EMPTY_STRING(thr),
                       pc_at_entry /*pc_label*/,
                       label_id);
    }
 
    /*
     *  Main switch for statement / source element type.
     */
 
    switch (comp_ctx->curr_token.t) {
    case DUK_TOK_FUNCTION: {
        /*
         *  Function declaration, function expression, or (non-standard)
         *  function statement.
         *
         *  The E5 specification only allows function declarations at
         *  the top level (in "source elements").  An ExpressionStatement
         *  is explicitly not allowed to begin with a "function" keyword
         *  (E5 Section 12.4).  Hence any non-error semantics for such
         *  non-top-level statements are non-standard.  Duktape semantics
         *  for function statements are modelled after V8, see
         *  test-dev-func-decl-outside-top.js.
         */
 
#if defined(DUK_USE_NONSTD_FUNC_STMT)
        /* Lenient: allow function declarations outside top level in
         * non-strict mode but reject them in strict mode.
         */
        if (allow_source_elem || !comp_ctx->curr_func.is_strict)
#else  /* DUK_USE_NONSTD_FUNC_STMT */
        /* Strict: never allow function declarations outside top level. */
        if (allow_source_elem)
#endif  /* DUK_USE_NONSTD_FUNC_STMT */
        {
            /* FunctionDeclaration: not strictly a statement but handled as such.
             *
             * O(depth^2) parse count for inner functions is handled by recording a
             * lexer offset on the first compilation pass, so that the function can
             * be efficiently skipped on the second pass.  This is encapsulated into
             * duk__parse_func_like_fnum().
             */
 
            duk_int_t fnum;
 
            DUK_DDD(DUK_DDDPRINT("function declaration statement"));
 
            duk__advance(comp_ctx);  /* eat 'function' */
            fnum = duk__parse_func_like_fnum(comp_ctx, 1 /*is_decl*/, 0 /*is_setget*/);
 
            if (comp_ctx->curr_func.in_scanning) {
                duk_uarridx_t n;
                duk_hstring *h_funcname;
 
                duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, fnum * 3);
                duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);  /* -> [ ... func name ] */
                h_funcname = duk_get_hstring(ctx, -1);
                DUK_ASSERT(h_funcname != NULL);
 
                DUK_DDD(DUK_DDDPRINT("register function declaration %!O in pass 1, fnum %ld",
                                     (duk_heaphdr *) h_funcname, (long) fnum));
                n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
                duk_push_hstring(ctx, h_funcname);
                duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n);
                duk_push_int(ctx, (duk_int_t) (DUK_DECL_TYPE_FUNC + (fnum << 8)));
                duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1);
 
                duk_pop_n(ctx, 2);
            }
 
            /* no statement value (unlike function expression) */
            stmt_flags = 0;
            break;
        } else {
            DUK_ERROR_SYNTAX(thr, DUK_STR_FUNC_STMT_NOT_ALLOWED);
        }
        break;
    }
    case DUK_TOK_LCURLY: {
        DUK_DDD(DUK_DDDPRINT("block statement"));
        duk__advance(comp_ctx);
        duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
        /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
        if (label_id >= 0) {
            duk__patch_jump_here(comp_ctx, pc_at_entry + 1);  /* break jump */
        }
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_CONST: {
        DUK_DDD(DUK_DDDPRINT("constant declaration statement"));
        duk__parse_var_stmt(comp_ctx, res, DUK__EXPR_FLAG_REQUIRE_INIT /*expr_flags*/);
        stmt_flags = DUK__HAS_TERM;
        break;
    }
    case DUK_TOK_VAR: {
        DUK_DDD(DUK_DDDPRINT("variable declaration statement"));
        duk__parse_var_stmt(comp_ctx, res, 0 /*expr_flags*/);
        stmt_flags = DUK__HAS_TERM;
        break;
    }
    case DUK_TOK_SEMICOLON: {
        /* empty statement with an explicit semicolon */
        DUK_DDD(DUK_DDDPRINT("empty statement"));
        stmt_flags = DUK__HAS_TERM;
        break;
    }
    case DUK_TOK_IF: {
        DUK_DDD(DUK_DDDPRINT("if statement"));
        duk__parse_if_stmt(comp_ctx, res);
        if (label_id >= 0) {
            duk__patch_jump_here(comp_ctx, pc_at_entry + 1);  /* break jump */
        }
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_DO: {
        /*
         *  Do-while statement is mostly trivial, but there is special
         *  handling for automatic semicolon handling (triggered by the
         *  DUK__ALLOW_AUTO_SEMI_ALWAYS) flag related to a bug filed at:
         *
         *    https://bugs.ecmascript.org/show_bug.cgi?id=8
         *
         *  See doc/compiler.rst for details.
         */
        DUK_DDD(DUK_DDDPRINT("do statement"));
        DUK_ASSERT(label_id >= 0);
        duk__update_label_flags(comp_ctx,
                                label_id,
                                DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
        duk__parse_do_stmt(comp_ctx, res, pc_at_entry);
        stmt_flags = DUK__HAS_TERM | DUK__ALLOW_AUTO_SEMI_ALWAYS;  /* DUK__ALLOW_AUTO_SEMI_ALWAYS workaround */
        break;
    }
    case DUK_TOK_WHILE: {
        DUK_DDD(DUK_DDDPRINT("while statement"));
        DUK_ASSERT(label_id >= 0);
        duk__update_label_flags(comp_ctx,
                                label_id,
                                DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
        duk__parse_while_stmt(comp_ctx, res, pc_at_entry);
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_FOR: {
        /*
         *  For/for-in statement is complicated to parse because
         *  determining the statement type (three-part for vs. a
         *  for-in) requires potential backtracking.
         *
         *  See the helper for the messy stuff.
         */
        DUK_DDD(DUK_DDDPRINT("for/for-in statement"));
        DUK_ASSERT(label_id >= 0);
        duk__update_label_flags(comp_ctx,
                                label_id,
                                DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
        duk__parse_for_stmt(comp_ctx, res, pc_at_entry);
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_CONTINUE:
    case DUK_TOK_BREAK: {
        DUK_DDD(DUK_DDDPRINT("break/continue statement"));
        duk__parse_break_or_continue_stmt(comp_ctx, res);
        stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
        break;
    }
    case DUK_TOK_RETURN: {
        DUK_DDD(DUK_DDDPRINT("return statement"));
        duk__parse_return_stmt(comp_ctx, res);
        stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
        break;
    }
    case DUK_TOK_WITH: {
        DUK_DDD(DUK_DDDPRINT("with statement"));
        comp_ctx->curr_func.with_depth++;
        duk__parse_with_stmt(comp_ctx, res);
        if (label_id >= 0) {
            duk__patch_jump_here(comp_ctx, pc_at_entry + 1);  /* break jump */
        }
        comp_ctx->curr_func.with_depth--;
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_SWITCH: {
        /*
         *  The switch statement is pretty messy to compile.
         *  See the helper for details.
         */
        DUK_DDD(DUK_DDDPRINT("switch statement"));
        DUK_ASSERT(label_id >= 0);
        duk__update_label_flags(comp_ctx,
                                label_id,
                                DUK_LABEL_FLAG_ALLOW_BREAK);  /* don't allow continue */
        duk__parse_switch_stmt(comp_ctx, res, pc_at_entry);
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_THROW: {
        DUK_DDD(DUK_DDDPRINT("throw statement"));
        duk__parse_throw_stmt(comp_ctx, res);
        stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
        break;
    }
    case DUK_TOK_TRY: {
        DUK_DDD(DUK_DDDPRINT("try statement"));
        duk__parse_try_stmt(comp_ctx, res);
        stmt_flags = 0;
        break;
    }
    case DUK_TOK_DEBUGGER: {
        duk__advance(comp_ctx);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
        DUK_DDD(DUK_DDDPRINT("debugger statement: debugging enabled, emit debugger opcode"));
        duk__emit_extraop_only(comp_ctx, DUK_EXTRAOP_DEBUGGER);
#else
        DUK_DDD(DUK_DDDPRINT("debugger statement: ignored"));
#endif
        stmt_flags = DUK__HAS_TERM;
        break;
    }
    default: {
        /*
         *  Else, must be one of:
         *    - ExpressionStatement, possibly a directive (String)
         *    - LabelledStatement (Identifier followed by ':')
         *
         *  Expressions beginning with 'function' keyword are covered by a case
         *  above (such expressions are not allowed in standard E5 anyway).
         *  Also expressions starting with '{' are interpreted as block
         *  statements.  See E5 Section 12.4.
         *
         *  Directive detection is tricky; see E5 Section 14.1 on directive
         *  prologue.  A directive is an expression statement with a single
         *  string literal and an explicit or automatic semicolon.  Escape
         *  characters are significant and no parens etc are allowed:
         *
         *    'use strict';          // valid 'use strict' directive
         *    'use\u0020strict';     // valid directive, not a 'use strict' directive
         *    ('use strict');        // not a valid directive
         *
         *  The expression is determined to consist of a single string literal
         *  based on duk__expr_nud() and duk__expr_led() call counts.  The string literal
         *  of a 'use strict' directive is determined to lack any escapes based
         *  num_escapes count from the lexer.  Note that other directives may be
         *  allowed to contain escapes, so a directive with escapes does not
         *  terminate a directive prologue.
         *
         *  We rely on the fact that the expression parser will not emit any
         *  code for a single token expression.  However, it will generate an
         *  intermediate value which we will then successfully ignore.
         *
         *  A similar approach is used for labels.
         */
 
        duk_bool_t single_token;
 
        DUK_DDD(DUK_DDDPRINT("expression statement"));
        duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
 
        single_token = (comp_ctx->curr_func.nud_count == 1 &&  /* one token */
                        comp_ctx->curr_func.led_count == 0);   /* no operators */
 
        if (single_token &&
            comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
            comp_ctx->curr_token.t == DUK_TOK_COLON) {
            /*
             *  Detected label
             */
 
            duk_hstring *h_lab;
 
            /* expected ival */
            DUK_ASSERT(res->t == DUK_IVAL_VAR);
            DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE);
            DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx)));
            h_lab = comp_ctx->prev_token.str1;
            DUK_ASSERT(h_lab != NULL);
 
            DUK_DDD(DUK_DDDPRINT("explicit label site for label '%!O'",
                                 (duk_heaphdr *) h_lab));
 
            duk__advance(comp_ctx);  /* eat colon */
 
            label_id = duk__stmt_label_site(comp_ctx, label_id);
 
            duk__add_label(comp_ctx,
                           h_lab,
                           pc_at_entry /*pc_label*/,
                           label_id);
 
            /* a statement following a label cannot be a source element
             * (a function declaration).
             */
            allow_source_elem = 0;
 
            DUK_DDD(DUK_DDDPRINT("label handled, retry statement parsing"));
            goto retry_parse;
        }
 
        stmt_flags = 0;
 
        if (dir_prol_at_entry &&                           /* still in prologue */
            single_token &&                                /* single string token */
            comp_ctx->prev_token.t == DUK_TOK_STRING) {
            /*
             *  Detected a directive
             */
            duk_hstring *h_dir;
 
            /* expected ival */
            DUK_ASSERT(res->t == DUK_IVAL_PLAIN);
            DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE);
            DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx)));
            h_dir = comp_ctx->prev_token.str1;
            DUK_ASSERT(h_dir != NULL);
 
            DUK_DDD(DUK_DDDPRINT("potential directive: %!O", h_dir));
 
            stmt_flags |= DUK__STILL_PROLOGUE;
 
            /* Note: escaped characters differentiate directives */
 
            if (comp_ctx->prev_token.num_escapes > 0) {
                DUK_DDD(DUK_DDDPRINT("directive contains escapes: valid directive "
                                     "but we ignore such directives"));
            } else {
                /*
                 * The length comparisons are present to handle
                 * strings like "use strict\u0000foo" as required.
                 */
 
                if (DUK_HSTRING_GET_BYTELEN(h_dir) == 10 &&
                    DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use strict", 10) == 0) {
#if defined(DUK_USE_STRICT_DECL)
                    DUK_DDD(DUK_DDDPRINT("use strict directive detected: strict flag %ld -> %ld",
                                         (long) comp_ctx->curr_func.is_strict, (long) 1));
                    comp_ctx->curr_func.is_strict = 1;
#else
                    DUK_DDD(DUK_DDDPRINT("use strict detected but strict declarations disabled, ignoring"));
#endif
                } else if (DUK_HSTRING_GET_BYTELEN(h_dir) == 14 &&
                           DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use duk notail", 14) == 0) {
                    DUK_DDD(DUK_DDDPRINT("use duk notail directive detected: notail flag %ld -> %ld",
                                         (long) comp_ctx->curr_func.is_notail, (long) 1));
                    comp_ctx->curr_func.is_notail = 1;
                } else {
                    DUK_DD(DUK_DDPRINT("unknown directive: '%!O', ignoring but not terminating "
                                       "directive prologue", (duk_hobject *) h_dir));
                }
            }
        } else {
            DUK_DDD(DUK_DDDPRINT("non-directive expression statement or no longer in prologue; "
                                 "prologue terminated if still active"));
                }
 
        stmt_flags |= DUK__HAS_VAL | DUK__HAS_TERM;
    }
    }  /* end switch (tok) */
 
    /*
     *  Statement value handling.
     *
     *  Global code and eval code has an implicit return value
     *  which comes from the last statement with a value
     *  (technically a non-"empty" continuation, which is
     *  different from an empty statement).
     *
     *  Since we don't know whether a later statement will
     *  override the value of the current statement, we need
     *  to coerce the statement value to a register allocated
     *  for implicit return values.  In other cases we need
     *  to coerce the statement value to a plain value to get
     *  any side effects out (consider e.g. "foo.bar;").
     */
 
    /* XXX: what about statements which leave a half-cooked value in 'res'
     * but have no stmt value?  Any such statements?
     */
 
    if (stmt_flags & DUK__HAS_VAL) {
        duk_reg_t reg_stmt_value = comp_ctx->curr_func.reg_stmt_value;
        if (reg_stmt_value >= 0) {
            duk__ivalue_toforcedreg(comp_ctx, res, reg_stmt_value);
        } else {
            duk__ivalue_toplain_ignore(comp_ctx, res);
        }
    } else {
        ;
    }
 
    /*
     *  Statement terminator check, including automatic semicolon
     *  handling.  After this step, 'curr_tok' should be the first
     *  token after a possible statement terminator.
     */
 
    if (stmt_flags & DUK__HAS_TERM) {
        if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON) {
            DUK_DDD(DUK_DDDPRINT("explicit semicolon terminates statement"));
            duk__advance(comp_ctx);
        } else {
            if (comp_ctx->curr_token.allow_auto_semi) {
                DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement"));
            } else if (stmt_flags & DUK__ALLOW_AUTO_SEMI_ALWAYS) {
                /* XXX: make this lenience dependent on flags or strictness? */
                DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement (allowed for compatibility "
                                     "even though no lineterm present before next token)"));
            } else {
                DUK_ERROR_SYNTAX(thr, DUK_STR_UNTERMINATED_STMT);
            }
        }
    } else {
        DUK_DDD(DUK_DDDPRINT("statement has no terminator"));
    }
 
    /*
     *  Directive prologue tracking.
     */
 
    if (stmt_flags & DUK__STILL_PROLOGUE) {
        DUK_DDD(DUK_DDDPRINT("setting in_directive_prologue"));
        comp_ctx->curr_func.in_directive_prologue = 1;
    }
 
    /*
     *  Cleanups (all statement parsing flows through here).
     *
     *  Pop label site and reset labels.  Reset 'next temp' to value at

◆ duk__parse_stmts()

DUK_LOCAL_DECL void duk__parse_stmts	(	duk_compiler_ctx *	comp_ctx,
		duk_bool_t	allow_source_elem,
		duk_bool_t	expect_eof )

Definition at line 64433 of file duktape-1.8.0/src/duktape.c.

                                                                                                                 {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_ivalue res_alloc;
    duk_ivalue *res = &res_alloc;
 
    /* Setup state.  Initial ivalue is 'undefined'. */
 
    duk_require_stack(ctx, DUK__PARSE_STATEMENTS_SLOTS);
 
    /* XXX: 'res' setup can be moved to function body level; in fact, two 'res'
     * intermediate values suffice for parsing of each function.  Nesting is needed
     * for nested functions (which may occur inside expressions).
     */
 
    DUK_MEMZERO(&res_alloc, sizeof(res_alloc));
    res->t = DUK_IVAL_PLAIN;
    res->x1.t = DUK_ISPEC_VALUE;
    res->x1.valstack_idx = duk_get_top(ctx);
    res->x2.valstack_idx = res->x1.valstack_idx + 1;
    duk_push_undefined(ctx);
    duk_push_undefined(ctx);
 
    /* Parse statements until a closing token (EOF or '}') is found. */
 
    for (;;) {
        /* Check whether statement list ends. */
 
        if (expect_eof) {
            if (comp_ctx->curr_token.t == DUK_TOK_EOF) {
                break;
            }
        } else {
            if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
                break;
            }
        }
 

Referenced by duk__parse_func_body().

◆ duk__parse_string()

DUK_LOCAL duk_ret_t duk__parse_string	(	duk_context *	ctx,
		const char *	str )

Definition at line 24995 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    /* XXX: there is a small risk here: because the ISO 8601 parser is
     * very loose, it may end up parsing some datetime values which
     * would be better parsed with a platform specific parser.
     */
 
    DUK_ASSERT(str != NULL);
    DUK_DDD(DUK_DDDPRINT("parse datetime from string '%s'", (const char *) str));
 
    if (duk__parse_string_iso8601_subset(ctx, str) != 0) {
        return 1;
    }

References duk__parse_string_iso8601_subset(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, and NULL.

◆ duk__parse_string_iso8601_subset()

DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset	(	duk_context *	ctx,
		const char *	str )

Definition at line 24800 of file duktape-1.8.0/src/duktape.c.

                                                                                         {
    duk_int_t parts[DUK__NUM_ISO8601_PARSER_PARTS];
    duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS];
    duk_double_t d;
    const duk_uint8_t *p;
    duk_small_uint_t part_idx = 0;
    duk_int_t accum = 0;
    duk_small_uint_t ndigits = 0;
    duk_bool_t neg_year = 0;
    duk_bool_t neg_tzoffset = 0;
    duk_uint_fast8_t ch;
    duk_small_uint_t i;
 
    /* During parsing, month and day are one-based; set defaults here. */
    DUK_MEMZERO(parts, sizeof(parts));
    DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] == 0);  /* don't care value, year is mandatory */
    parts[DUK_DATE_IDX_MONTH] = 1;
    parts[DUK_DATE_IDX_DAY] = 1;
 
    /* Special handling for year sign. */
    p = (const duk_uint8_t *) str;
    ch = p[0];
    if (ch == DUK_ASC_PLUS) {
        p++;
    } else if (ch == DUK_ASC_MINUS) {
        neg_year = 1;
        p++;
    }
 
    for (;;) {
        ch = *p++;
        DUK_DDD(DUK_DDDPRINT("parsing, part_idx=%ld, char=%ld ('%c')",
                             (long) part_idx, (long) ch,
                             (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : DUK_ASC_QUESTION)));
 
        if (ch >= DUK_ASC_0 && ch <= DUK_ASC_9) {
            if (ndigits >= 9) {
                DUK_DDD(DUK_DDDPRINT("too many digits -> reject"));
                goto reject;
            }
            if (part_idx == DUK__PI_MILLISECOND /*msec*/ && ndigits >= 3) {
                /* ignore millisecond fractions after 3 */
            } else {
                accum = accum * 10 + ((duk_int_t) ch) - ((duk_int_t) DUK_ASC_0) + 0x00;
                ndigits++;
            }
        } else {
            duk_uint_fast32_t match_val;
            duk_small_int_t sep_idx;
 
            if (ndigits <= 0) {
                goto reject;
            }
            if (part_idx == DUK__PI_MILLISECOND) {
                /* complete the millisecond field */
                while (ndigits < 3) {
                    accum *= 10;
                    ndigits++;
                }
            }
            parts[part_idx] = accum;
            DUK_DDD(DUK_DDDPRINT("wrote part %ld -> value %ld", (long) part_idx, (long) accum));
 
            accum = 0;
            ndigits = 0;
 
            for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t)); i++) {
                if (duk__parse_iso8601_seps[i] == ch) {
                    break;
                }
            }
            if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t))) {
                DUK_DDD(DUK_DDDPRINT("separator character doesn't match -> reject"));
                goto reject;
            }
 
            sep_idx = i;
            match_val = (1UL << part_idx) + (1UL << (sep_idx + 9));  /* match against rule part/sep bits */
 
            for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t)); i++) {
                duk_uint_fast32_t rule = duk__parse_iso8601_control[i];
                duk_small_uint_t nextpart;
                duk_small_uint_t cflags;
 
                DUK_DDD(DUK_DDDPRINT("part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, considering rule=0x%08lx",
                                     (long) part_idx, (long) sep_idx,
                                     (unsigned long) match_val, (unsigned long) rule));
 
                if ((rule & match_val) != match_val) {
                    continue;
                }
 
                DUK__UNPACK_RULE(rule, nextpart, cflags);
 
                DUK_DDD(DUK_DDDPRINT("rule match -> part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, "
                                     "rule=0x%08lx -> nextpart=%ld, cflags=0x%02lx",
                                     (long) part_idx, (long) sep_idx,
                                     (unsigned long) match_val, (unsigned long) rule,
                                     (long) nextpart, (unsigned long) cflags));
 
                if (cflags & DUK__CF_NEG) {
                    neg_tzoffset = 1;
                }
 
                if (cflags & DUK__CF_ACCEPT) {
                    goto accept;
                }
 
                if (cflags & DUK__CF_ACCEPT_NUL) {
                    DUK_ASSERT(*(p - 1) != (char) 0);
                    if (*p == DUK_ASC_NUL) {
                        goto accept;
                    }
                    goto reject;
                }
 
                part_idx = nextpart;
                break;
            }  /* rule match */
 
            if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t))) {
                DUK_DDD(DUK_DDDPRINT("no rule matches -> reject"));
                goto reject;
            }
 
            if (ch == 0) {
                /* This shouldn't be necessary, but check just in case
                 * to avoid any chance of overruns.
                 */
                DUK_DDD(DUK_DDDPRINT("NUL after rule matching (should not happen) -> reject"));
                goto reject;
            }
        }  /* if-digit-else-ctrl */
    }  /* char loop */
 
    /* We should never exit the loop above. */
    DUK_UNREACHABLE();
 
 reject:
    DUK_DDD(DUK_DDDPRINT("reject"));
    return 0;
 
 accept:
    DUK_DDD(DUK_DDDPRINT("accept"));
 
    /* Apply timezone offset to get the main parts in UTC */
    if (neg_year) {
        parts[DUK__PI_YEAR] = -parts[DUK__PI_YEAR];
    }
    if (neg_tzoffset) {
        parts[DUK__PI_HOUR] += parts[DUK__PI_TZHOUR];
        parts[DUK__PI_MINUTE] += parts[DUK__PI_TZMINUTE];
    } else {
        parts[DUK__PI_HOUR] -= parts[DUK__PI_TZHOUR];
        parts[DUK__PI_MINUTE] -= parts[DUK__PI_TZMINUTE];
    }
    parts[DUK__PI_MONTH] -= 1;  /* zero-based month */
    parts[DUK__PI_DAY] -= 1;  /* zero-based day */

Referenced by duk__parse_string().

◆ duk__parse_switch_stmt()

DUK_LOCAL_DECL void duk__parse_switch_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_int_t	pc_label_site )

Definition at line 63141 of file duktape-1.8.0/src/duktape.c.

         :
    DUK_DDD(DUK_DDDPRINT("end parsing a for/for-in statement"));
    return;
 
 syntax_error:
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_FOR);
}
 
DUK_LOCAL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
    duk_hthread *thr = comp_ctx->thr;
    duk_reg_t temp_at_loop;
    duk_regconst_t rc_switch;    /* reg/const for switch value */
    duk_regconst_t rc_case;      /* reg/const for case value */
    duk_reg_t reg_temp;          /* general temp register */
    duk_int_t pc_prevcase = -1;
    duk_int_t pc_prevstmt = -1;
    duk_int_t pc_default = -1;   /* -1 == not set, -2 == pending (next statement list) */
 
    /* Note: negative pc values are ignored when patching jumps, so no explicit checks needed */
 
    /*
     *  Switch is pretty complicated because of several conflicting concerns:
     *
     *    - Want to generate code without an intermediate representation,
     *      i.e., in one go
     *
     *    - Case selectors are expressions, not values, and may thus e.g. throw
     *      exceptions (which causes evaluation order concerns)
     *
     *    - Evaluation semantics of case selectors and default clause need to be
     *      carefully implemented to provide correct behavior even with case value
     *      side effects
     *
     *    - Fall through case and default clauses; avoiding dead JUMPs if case
     *      ends with an unconditional jump (a break or a continue)
     *
     *    - The same case value may occur multiple times, but evaluation rules
     *      only process the first match before switching to a "propagation" mode
     *      where case values are no longer evaluated
     *
     *  See E5 Section 12.11.  Also see doc/compiler.rst for compilation
     *  discussion.
     */
 
    duk__advance(comp_ctx);
    duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
    rc_switch = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
    duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
    duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
 
    DUK_DDD(DUK_DDDPRINT("switch value in register %ld", (long) rc_switch));
 
    temp_at_loop = DUK__GETTEMP(comp_ctx);
 
    for (;;) {
        duk_int_t num_stmts;
        duk_small_int_t tok;
 
        /* sufficient for keeping temp reg numbers in check */
        DUK__SETTEMP(comp_ctx, temp_at_loop);
 
        if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
            break;
        }
 
        /*
         *  Parse a case or default clause.
         */
 
        if (comp_ctx->curr_token.t == DUK_TOK_CASE) {
            /*
             *  Case clause.
             *
             *  Note: cannot use reg_case as a temp register (for SEQ target)
             *  because it may be a constant.
             */
 
            duk__patch_jump_here(comp_ctx, pc_prevcase);  /* chain jumps for case
                                                           * evaluation and checking
                                                           */
 
            duk__advance(comp_ctx);
            rc_case = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
            duk__advance_expect(comp_ctx, DUK_TOK_COLON);
 
            reg_temp = DUK__ALLOCTEMP(comp_ctx);
            duk__emit_a_b_c(comp_ctx,
                            DUK_OP_SEQ,
                            (duk_regconst_t) reg_temp,
                            rc_switch,
                            rc_case);
            duk__emit_if_true_skip(comp_ctx, (duk_regconst_t) reg_temp);
 
            /* jump to next case clause */
            pc_prevcase = duk__emit_jump_empty(comp_ctx);  /* no match, next case */
 
            /* statements go here (if any) on next loop */
        } else if (comp_ctx->curr_token.t == DUK_TOK_DEFAULT) {
            /*
             *  Default clause.
             */
 
            if (pc_default >= 0) {
                goto syntax_error;
            }
            duk__advance(comp_ctx);
            duk__advance_expect(comp_ctx, DUK_TOK_COLON);
 
            /* Fix for https://github.com/svaarala/duktape/issues/155:
             * If 'default' is first clause (detected by pc_prevcase < 0)
             * we need to ensure we stay in the matching chain.
             */
            if (pc_prevcase < 0) {
                DUK_DD(DUK_DDPRINT("default clause is first, emit prevcase jump"));
                pc_prevcase = duk__emit_jump_empty(comp_ctx);
            }
 
            /* default clause matches next statement list (if any) */
            pc_default = -2;
        } else {
            /* Code is not accepted before the first case/default clause */
            goto syntax_error;
        }
 
        /*
         *  Parse code after the clause.  Possible terminators are
         *  'case', 'default', and '}'.
         *
         *  Note that there may be no code at all, not even an empty statement,
         *  between case clauses.  This must be handled just like an empty statement
         *  (omitting seemingly pointless JUMPs), to avoid situations like
         *  test-bug-case-fallthrough.js.
         */
 
        num_stmts = 0;
        if (pc_default == -2) {
            pc_default = duk__get_current_pc(comp_ctx);
        }
 
        /* Note: this is correct even for default clause statements:
         * they participate in 'fall-through' behavior even if the
         * default clause is in the middle.
         */
        duk__patch_jump_here(comp_ctx, pc_prevstmt);  /* chain jumps for 'fall-through'
                                                       * after a case matches.
                                                       */
 
        for (;;) {
            tok = comp_ctx->curr_token.t;
            if (tok == DUK_TOK_CASE || tok == DUK_TOK_DEFAULT ||
                tok == DUK_TOK_RCURLY) {
                break;
            }
            num_stmts++;
            duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
        }
 
        /* fall-through jump to next code of next case (backpatched) */
        pc_prevstmt = duk__emit_jump_empty(comp_ctx);
 
        /* XXX: would be nice to omit this jump when the jump is not
         * reachable, at least in the obvious cases (such as the case
         * ending with a 'break'.
         *
         * Perhaps duk__parse_stmt() could provide some info on whether
         * the statement is a "dead end"?
         *
         * If implemented, just set pc_prevstmt to -1 when not needed.
         */
    }
 
    DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RCURLY);
    duk__advance(comp_ctx);
 
    /* default case control flow patchup; note that if pc_prevcase < 0
     * (i.e. no case clauses), control enters default case automatically.
     */
    if (pc_default >= 0) {
        /* default case exists: go there if no case matches */
        duk__patch_jump(comp_ctx, pc_prevcase, pc_default);
    } else {
        /* default case does not exist, or no statements present
         * after default case: finish case evaluation
         */
        duk__patch_jump_here(comp_ctx, pc_prevcase);
    }
 
    /* fall-through control flow patchup; note that pc_prevstmt may be
     * < 0 (i.e. no case clauses), in which case this is a no-op.

◆ duk__parse_throw_stmt()

DUK_LOCAL_DECL void duk__parse_throw_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 63602 of file duktape-1.8.0/src/duktape.c.

◆ duk__parse_try_stmt()

DUK_LOCAL_DECL void duk__parse_try_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 63619 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    duk_reg_t reg_val;
 
    duk__advance(comp_ctx);  /* eat 'throw' */
 
    /* Unlike break/continue, throw statement does not allow an empty value. */
 
    if (comp_ctx->curr_token.lineterm) {
        DUK_ERROR_SYNTAX(comp_ctx->thr, DUK_STR_INVALID_THROW);
    }
 
    reg_val = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
    duk__emit_extraop_bc(comp_ctx,
                         DUK_EXTRAOP_THROW,
                         (duk_regconst_t) reg_val);
}
 
DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_reg_t reg_catch;      /* reg_catch+0 and reg_catch+1 are reserved for TRYCATCH */
    duk_regconst_t rc_varname = 0;
    duk_small_uint_t trycatch_flags = 0;
    duk_int_t pc_ldconst = -1;
    duk_int_t pc_trycatch = -1;
    duk_int_t pc_catch = -1;
    duk_int_t pc_finally = -1;
 
    DUK_UNREF(res);
 
    /*
     *  See the following documentation for discussion:
     *
     *    doc/execution.rst: control flow details
     *
     *  Try, catch, and finally "parts" are Blocks, not Statements, so
     *  they must always be delimited by curly braces.  This is unlike e.g.
     *  the if statement, which accepts any Statement.  This eliminates any
     *  questions of matching parts of nested try statements.  The Block
     *  parsing is implemented inline here (instead of calling out).
     *
     *  Finally part has a 'let scoped' variable, which requires a few kinks
     *  here.
     */
 
    comp_ctx->curr_func.catch_depth++;
 
    duk__advance(comp_ctx);  /* eat 'try' */
 
    reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2);
 
    /* The target for this LDCONST may need output shuffling, but we assume
     * that 'pc_ldconst' will be the LDCONST that we can patch later.  This
     * should be the case because there's no input shuffling.  (If there's
     * no catch clause, this LDCONST will be replaced with a NOP.)
     */
    pc_ldconst = duk__get_current_pc(comp_ctx);
    duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, reg_catch, 0 /*patched later*/);
 
    pc_trycatch = duk__get_current_pc(comp_ctx);
    duk__emit_invalid(comp_ctx);  /* TRYCATCH, cannot emit now (not enough info) */
    duk__emit_invalid(comp_ctx);  /* jump for 'catch' case */
    duk__emit_invalid(comp_ctx);  /* jump for 'finally' case or end (if no finally) */
 
    /* try part */
    duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
    duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
    /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
    duk__emit_extraop_only(comp_ctx,
                           DUK_EXTRAOP_ENDTRY);
 
    if (comp_ctx->curr_token.t == DUK_TOK_CATCH) {
        /*
         *  The catch variable must be updated to reflect the new allocated
         *  register for the duration of the catch clause.  We need to store
         *  and restore the original value for the varmap entry (if any).
         */
 
        /*
         *  Note: currently register bindings must be fixed for the entire
         *  function.  So, even though the catch variable is in a register
         *  we know, we must use an explicit environment record and slow path
         *  accesses to read/write the catch binding to make closures created
         *  within the catch clause work correctly.  This restriction should
         *  be fixable (at least in common cases) later.
         *
         *  See: test-bug-catch-binding-2.js.
         *
         *  XXX: improve to get fast path access to most catch clauses.
         */
 
        duk_hstring *h_var;
        duk_int_t varmap_value;  /* for storing/restoring the varmap binding for catch variable */
 
        DUK_DDD(DUK_DDDPRINT("stack top at start of catch clause: %ld", (long) duk_get_top(ctx)));
 
        trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_CATCH;
 
        pc_catch = duk__get_current_pc(comp_ctx);
 
        duk__advance(comp_ctx);
        duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
 
        if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
            /* Identifier, i.e. don't allow reserved words */
            goto syntax_error;
        }
        h_var = comp_ctx->curr_token.str1;
        DUK_ASSERT(h_var != NULL);
 
        duk_push_hstring(ctx, h_var);  /* keep in on valstack, use borrowed ref below */
 
        if (comp_ctx->curr_func.is_strict &&
            ((h_var == DUK_HTHREAD_STRING_EVAL(thr)) ||
             (h_var == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)))) {
            DUK_DDD(DUK_DDDPRINT("catch identifier 'eval' or 'arguments' in strict mode -> SyntaxError"));
            goto syntax_error;
        }
 
        duk_dup_top(ctx);
        rc_varname = duk__getconst(comp_ctx);
        DUK_DDD(DUK_DDDPRINT("catch clause, rc_varname=0x%08lx (%ld)",
                             (unsigned long) rc_varname, (long) rc_varname));
 
        duk__advance(comp_ctx);
        duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
 
        duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
 
        DUK_DDD(DUK_DDDPRINT("varmap before modifying for catch clause: %!iT",
                             (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
 
        duk_dup_top(ctx);
        duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
        if (duk_is_undefined(ctx, -1)) {
            varmap_value = -2;
        } else if (duk_is_null(ctx, -1)) {
            varmap_value = -1;
        } else {
            DUK_ASSERT(duk_is_number(ctx, -1));
            varmap_value = duk_get_int(ctx, -1);
            DUK_ASSERT(varmap_value >= 0);
        }
        duk_pop(ctx);
 
#if 0
        /* It'd be nice to do something like this - but it doesn't
         * work for closures created inside the catch clause.
         */
        duk_dup_top(ctx);
        duk_push_int(ctx, (duk_int_t) (reg_catch + 0));
        duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
#endif
        duk_dup_top(ctx);
        duk_push_null(ctx);
        duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
 
        duk__emit_a_bc(comp_ctx,
                       DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
                       (duk_regconst_t) (reg_catch + 0) /*value*/,
                       rc_varname /*varname*/);
 
        DUK_DDD(DUK_DDDPRINT("varmap before parsing catch clause: %!iT",
                             (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
 
        duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
        /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
 
        if (varmap_value == -2) {
            /* not present */
            duk_del_prop(ctx, comp_ctx->curr_func.varmap_idx);
        } else {
            if (varmap_value == -1) {
                duk_push_null(ctx);
            } else {
                DUK_ASSERT(varmap_value >= 0);
                duk_push_int(ctx, varmap_value);
            }
            duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
        }
        /* varname is popped by above code */
 
        DUK_DDD(DUK_DDDPRINT("varmap after restore catch clause: %!iT",
                             (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
 
        duk__emit_extraop_only(comp_ctx,
                               DUK_EXTRAOP_ENDCATCH);
 
        /*
         *  XXX: for now, indicate that an expensive catch binding
         *  declarative environment is always needed.  If we don't
         *  need it, we don't need the const_varname either.
         */
 
        trycatch_flags |= DUK_BC_TRYCATCH_FLAG_CATCH_BINDING;
 
        DUK_DDD(DUK_DDDPRINT("stack top at end of catch clause: %ld", (long) duk_get_top(ctx)));
    }
 
    if (comp_ctx->curr_token.t == DUK_TOK_FINALLY) {
        trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY;
 
        pc_finally = duk__get_current_pc(comp_ctx);
 
        duk__advance(comp_ctx);
 
        duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
        duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
        /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
        duk__emit_extraop_b(comp_ctx,
                            DUK_EXTRAOP_ENDFIN,
                            reg_catch);  /* rethrow */
    }
 
    if (!(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) &&
        !(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY)) {
        /* must have catch and/or finally */
        goto syntax_error;
    }
 
    /* If there's no catch block, rc_varname will be 0 and duk__patch_trycatch()
     * will replace the LDCONST with a NOP.  For any actual constant (including
     * constant 0) the DUK__CONST_MARKER flag will be set in rc_varname.
     */
 
    duk__patch_trycatch(comp_ctx,
                        pc_ldconst,
                        pc_trycatch,
                        reg_catch,
                        rc_varname,
                        trycatch_flags);
 
    if (trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) {
        DUK_ASSERT(pc_catch >= 0);

References duk_compiler_ctx::curr_token, duk__advance(), DUK__BP_FOR_EXPR, duk__emit_extraop_bc(), duk__exprtop_toreg(), DUK_ERROR_SYNTAX, DUK_EXTRAOP_THROW, DUK_STR_INVALID_THROW, duk_token::lineterm, and duk_compiler_ctx::thr.

◆ duk__parse_var_decl()

DUK_LOCAL_DECL void duk__parse_var_decl	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	expr_flags,
		duk_reg_t *	out_reg_varbind,
		duk_regconst_t *	out_rc_varname )

Definition at line 62691 of file duktape-1.8.0/src/duktape.c.

                          :
 *
 *    If register bound:      out_reg_varbind >= 0, out_rc_varname == 0 (ignore)
 *    If not register bound:  out_reg_varbind < 0, out_rc_varname >= 0
 *
 * These allow the caller to use the variable for further assignment, e.g.
 * as is done in 'for-in' parsing.
 */
 
DUK_LOCAL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) {
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *h_varname;
    duk_reg_t reg_varbind;
    duk_regconst_t rc_varname;
 
    /* assume 'var' has been eaten */
 
    /* Note: Identifier rejects reserved words */
    if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
        goto syntax_error;
    }
    h_varname = comp_ctx->curr_token.str1;
 
    DUK_ASSERT(h_varname != NULL);
 
    /* strict mode restrictions (E5 Section 12.2.1) */
    if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
        goto syntax_error;
    }
 
    /* register declarations in first pass */
    if (comp_ctx->curr_func.in_scanning) {
        duk_uarridx_t n;
        DUK_DDD(DUK_DDDPRINT("register variable declaration %!O in pass 1",
                             (duk_heaphdr *) h_varname));
        n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
        duk_push_hstring(ctx, h_varname);
        duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n);
        duk_push_int(ctx, DUK_DECL_TYPE_VAR + (0 << 8));
        duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1);
    }
 
    duk_push_hstring(ctx, h_varname);  /* push before advancing to keep reachable */
 
    /* register binding lookup is based on varmap (even in first pass) */
    duk_dup_top(ctx);
    (void) duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname);
 
    duk__advance(comp_ctx);  /* eat identifier */
 
    if (comp_ctx->curr_token.t == DUK_TOK_EQUALSIGN) {
        duk__advance(comp_ctx);
 
        DUK_DDD(DUK_DDDPRINT("vardecl, assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
                             (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
 
        duk__exprtop(comp_ctx, res, DUK__BP_COMMA | expr_flags /*rbp_flags*/);  /* AssignmentExpression */
 
        if (reg_varbind >= 0) {
            duk__ivalue_toforcedreg(comp_ctx, res, reg_varbind);
        } else {
            duk_reg_t reg_val;
            reg_val = duk__ivalue_toreg(comp_ctx, res);
            duk__emit_a_bc(comp_ctx,
                           DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
                           (duk_regconst_t) reg_val,
                           rc_varname);
        }

References duk_compiler_ctx::curr_func, duk_compiler_ctx::curr_token, duk_compiler_func::decls_idx, duk__advance(), DUK__BP_COMMA, duk__emit_a_bc(), DUK__EMIT_FLAG_A_IS_SOURCE, duk__exprtop(), duk__hstring_is_eval_or_arguments_in_strict_mode(), duk__ivalue_toforcedreg(), duk__ivalue_toreg(), duk__lookup_lhs(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_DECL_TYPE_VAR, duk_dup_top(), duk_get_length(), DUK_OP_PUTVAR, duk_push_hstring(), duk_push_int(), duk_put_prop_index(), DUK_TOK_EQUALSIGN, DUK_TOK_IDENTIFIER, duk_compiler_func::in_scanning, NULL, duk_token::str1, duk_token::t, and duk_compiler_ctx::thr.

Referenced by duk__parse_for_stmt().

◆ duk__parse_var_stmt()

DUK_LOCAL_DECL void duk__parse_var_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_small_uint_t	expr_flags )

Definition at line 62769 of file duktape-1.8.0/src/duktape.c.

                                                      {
            /* Used for minimal 'const': initializer required. */
            goto syntax_error;
        }
    }
 
    duk_pop(ctx);  /* pop varname */
 
    *out_rc_varname = rc_varname;
    *out_reg_varbind = reg_varbind;
 
    return;
 
 syntax_error:
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_VAR_DECLARATION);
}

◆ duk__parse_while_stmt()

DUK_LOCAL_DECL void duk__parse_while_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res,
		duk_int_t	pc_label_site )

Definition at line 63414 of file duktape-1.8.0/src/duktape.c.

                                                                                                           {
    duk_reg_t temp_reset;
    duk_regconst_t rc_cond;
    duk_int_t pc_start;
    duk_int_t pc_jump_false;
 
    DUK_DDD(DUK_DDDPRINT("begin parsing while statement"));
 
    temp_reset = DUK__GETTEMP(comp_ctx);
 
    duk__advance(comp_ctx);  /* eat 'while' */
 
    duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
 
    pc_start = duk__get_current_pc(comp_ctx);

◆ duk__parse_with_stmt()

DUK_LOCAL_DECL void duk__parse_with_stmt	(	duk_compiler_ctx *	comp_ctx,
		duk_ivalue *	res )

Definition at line 63854 of file duktape-1.8.0/src/duktape.c.

                                                            {
        DUK_ASSERT(pc_finally >= 0);
        duk__patch_jump(comp_ctx, pc_trycatch + 2, pc_finally);
    } else {
        /* without finally, the second jump slot is used to jump to end of stmt */
        duk__patch_jump_here(comp_ctx, pc_trycatch + 2);
    }
 
    comp_ctx->curr_func.catch_depth--;
    return;
 
 syntax_error:
    DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_TRY);
}
 
DUK_LOCAL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
    duk_int_t pc_trycatch;
    duk_int_t pc_finished;
    duk_reg_t reg_catch;
    duk_small_uint_t trycatch_flags;
 
    if (comp_ctx->curr_func.is_strict) {
        DUK_ERROR_SYNTAX(comp_ctx->thr, DUK_STR_WITH_IN_STRICT_MODE);
    }
 
    comp_ctx->curr_func.catch_depth++;
 
    duk__advance(comp_ctx);  /* eat 'with' */
 
    reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2);
 
    duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
    duk__exprtop_toforcedreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/, reg_catch);
    duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
 
    pc_trycatch = duk__get_current_pc(comp_ctx);
    trycatch_flags = DUK_BC_TRYCATCH_FLAG_WITH_BINDING;

◆ duk__patch_jump()

DUK_LOCAL_DECL void duk__patch_jump	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	jump_pc,
		duk_int_t	target_pc )

Definition at line 59330 of file duktape-1.8.0/src/duktape.c.

                                                                                                             {
        goto fail_bc_limit;
    }
    return;
 
  fail_bc_limit:
    DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_BYTECODE_LIMIT);
}
 
/* Does not assume that jump_pc contains a DUK_OP_JUMP previously; this is intentional
 * to allow e.g. an INVALID opcode be overwritten with a JUMP (label management uses this).
 */
DUK_LOCAL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc) {
    duk_compiler_instr *instr;
    duk_int_t offset;
 
    /* allow negative PCs, behave as a no-op */
    if (jump_pc < 0) {

◆ duk__patch_jump_here()

DUK_LOCAL_DECL void duk__patch_jump_here	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	jump_pc )

Definition at line 59354 of file duktape-1.8.0/src/duktape.c.

◆ duk__patch_trycatch()

DUK_LOCAL_DECL void duk__patch_trycatch	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	ldconst_pc,
		duk_int_t	trycatch_pc,
		duk_regconst_t	reg_catch,
		duk_regconst_t	const_varname,
		duk_small_uint_t	flags )

Definition at line 59358 of file duktape-1.8.0/src/duktape.c.

                                           : jump_pc=%ld, target_pc=%ld, offset=%ld",
                         (long) jump_pc, (long) target_pc, (long) offset));
}
 
DUK_LOCAL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
    duk__patch_jump(comp_ctx, jump_pc, duk__get_current_pc(comp_ctx));
}
 
DUK_LOCAL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags) {
    duk_compiler_instr *instr;
 
    DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0);
 
    instr = duk__get_instr_ptr(comp_ctx, ldconst_pc);
    DUK_ASSERT(DUK_DEC_OP(instr->ins) == DUK_OP_LDCONST);
    DUK_ASSERT(instr != NULL);
    if (const_varname & DUK__CONST_MARKER) {
        /* Have a catch variable. */
        const_varname = const_varname & (~DUK__CONST_MARKER);
        if (reg_catch > DUK_BC_BC_MAX || const_varname > DUK_BC_BC_MAX) {
            /* Catch attempts to use out-of-range reg/const.  Without this
             * check Duktape 0.12.0 could generate invalid code which caused
             * an assert failure on execution.  This error is triggered e.g.
             * for functions with a lot of constants and a try-catch statement.
             * Shuffling or opcode semantics change is needed to fix the issue.
             * See: test-bug-trycatch-many-constants.js.
             */
            DUK_D(DUK_DPRINT("failed to patch trycatch: flags=%ld, reg_catch=%ld, const_varname=%ld (0x%08lx)",

◆ duk__pcall_prop_raw()

DUK_LOCAL duk_ret_t duk__pcall_prop_raw ( duk_context * ctx )

Definition at line 12545 of file duktape-1.8.0/src/duktape.c.

                                   {
        /* See comments in duk_pcall(). */
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
        return DUK_EXEC_ERROR;  /* unreachable */
    }
 
    call_flags = 0;  /* respect reclimit, not constructor */
 
    rc = duk_handle_call_protected(thr,           /* thread */
                                   nargs,         /* num_stack_args */
                                   call_flags);   /* call_flags */
 
    return rc;
}
 
DUK_LOCAL duk_ret_t duk__pcall_prop_raw(duk_context *ctx) {
    duk_idx_t obj_index;

References DUK_ERROR_API, DUK_EXEC_ERROR, and DUK_STR_INVALID_CALL_ARGS.

◆ duk__peephole_optimize_bytecode()

DUK_LOCAL void duk__peephole_optimize_bytecode ( duk_compiler_ctx * comp_ctx )

Definition at line 59423 of file duktape-1.8.0/src/duktape.c.

                                                             {
    duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_INVALID, 0);
}
 
/*
 *  Peephole optimizer for finished bytecode.
 *
 *  Does not remove opcodes; currently only straightens out unconditional
 *  jump chains which are generated by several control structures.
 */
 
DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx) {
    duk_compiler_instr *bc;
    duk_small_uint_t iter;
    duk_int_t i, n;
    duk_int_t count_opt;
 
    bc = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code);
#if defined(DUK_USE_BUFLEN16)
    /* No need to assert, buffer size maximum is 0xffff. */
#else
    DUK_ASSERT((duk_size_t) DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr) <= (duk_size_t) DUK_INT_MAX);  /* bytecode limits */
#endif
    n = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr));
 
    for (iter = 0; iter < DUK_COMPILER_PEEPHOLE_MAXITER; iter++) {
        count_opt = 0;
 
        for (i = 0; i < n; i++) {
            duk_instr_t ins;
            duk_int_t target_pc1;
            duk_int_t target_pc2;
 
            ins = bc[i].ins;
            if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
                continue;
            }
 
            target_pc1 = i + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;
            DUK_DDD(DUK_DDDPRINT("consider jump at pc %ld; target_pc=%ld", (long) i, (long) target_pc1));
            DUK_ASSERT(target_pc1 >= 0);
            DUK_ASSERT(target_pc1 < n);
 
            /* Note: if target_pc1 == i, we'll optimize a jump to itself.
             * This does not need to be checked for explicitly; the case
             * is rare and max iter breaks us out.
             */
 
            ins = bc[target_pc1].ins;
            if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
                continue;
            }
 

Referenced by duk__parse_func_body().

◆ duk__pnew_helper()

DUK_LOCAL duk_ret_t duk__pnew_helper ( duk_context * ctx )

Definition at line 12805 of file duktape-1.8.0/src/duktape.c.

◆ duk__pow_fixed()

DUK_LOCAL double duk__pow_fixed	(	double	x,
		double	y )

Definition at line 32666 of file duktape-1.8.0/src/duktape.c.

                              {
        /* +0.5 is handled by floor, this is on purpose */
        if (x < 0.0) {
            return -0.0;
        } else {
            return +0.0;
        }
    }
 
    return DUK_FLOOR(x + 0.5);
}
 
DUK_LOCAL double duk__pow_fixed(double x, double y) {
    /* The ANSI C pow() semantics differ from Ecmascript.
     *
     * E.g. when x==1 and y is +/- infinite, the Ecmascript required
     * result is NaN, while at least Linux pow() returns 1.
     */
 
    duk_small_int_t cx, cy, sx;
 
    DUK_UNREF(cx);
    DUK_UNREF(sx);
    cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
 
    if (cy == DUK_FP_NAN) {
        goto ret_nan;
    }
    if (DUK_FABS(x) == 1.0 && cy == DUK_FP_INFINITE) {
        goto ret_nan;
    }
#if defined(DUK_USE_POW_NETBSD_WORKAROUND)
    /* See test-bug-netbsd-math-pow.js: NetBSD 6.0 on x86 (at least) does not
     * correctly handle some cases where x=+/-0.  Specific fixes to these
     * here.
     */
    cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    if (cx == DUK_FP_ZERO && y < 0.0) {
        sx = (duk_small_int_t) DUK_SIGNBIT(x);
        if (sx == 0) {
            /* Math.pow(+0,y) should be Infinity when y<0.  NetBSD pow()
             * returns -Infinity instead when y is <0 and finite.  The
             * if-clause also catches y == -Infinity (which works even
             * without the fix).
             */
            return DUK_DOUBLE_INFINITY;
        } else {
            /* Math.pow(-0,y) where y<0 should be:
             *   - -Infinity if y<0 and an odd integer
             *   - Infinity otherwise
             * NetBSD pow() returns -Infinity for all finite y<0.  The
             * if-clause also catches y == -Infinity (which works even
             * without the fix).
             */
 
            /* fmod() return value has same sign as input (negative) so
             * the result here will be in the range ]-2,0], 1 indicates
             * odd.  If x is -Infinity, NaN is returned and the odd check

◆ duk__prep_codec_arg()

DUK_LOCAL const duk_uint8_t * duk__prep_codec_arg	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 12958 of file duktape-1.8.0/src/duktape.c.

◆ duk__protected_compact_object()

DUK_LOCAL int duk__protected_compact_object ( duk_context * ctx )

Definition at line 43125 of file duktape-1.8.0/src/duktape.c.

43132 : %ld finalizers called", (long) count));

◆ duk__proxy_check_prop()

DUK_LOCAL duk_bool_t duk__proxy_check_prop	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_small_uint_t	stridx_trap,
		duk_tval *	tv_key,
		duk_hobject **	out_target )

Definition at line 47815 of file duktape-1.8.0/src/duktape.c.

                                                               {
        if (duk_hobject_proxy_check(thr, obj, &h_target, &h_handler)) {
            DUK_ASSERT(h_target != NULL);
            obj = h_target;
        } else {
            break;
        }
    }
 
    DUK_ASSERT(obj != NULL);
    return obj;
}
#endif  /* DUK_USE_ES6_PROXY */
 
#if defined(DUK_USE_ES6_PROXY)
DUK_LOCAL duk_bool_t duk__proxy_check_prop(duk_hthread *thr, duk_hobject *obj, duk_small_uint_t stridx_trap, duk_tval *tv_key, duk_hobject **out_target) {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *h_handler;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(tv_key != NULL);
    DUK_ASSERT(out_target != NULL);
 
    if (!duk_hobject_proxy_check(thr, obj, out_target, &h_handler)) {
        return 0;
    }
    DUK_ASSERT(*out_target != NULL);
    DUK_ASSERT(h_handler != NULL);
 
    /* XXX: At the moment Duktape accesses internal keys like _Finalizer using a
     * normal property set/get which would allow a proxy handler to interfere with
     * such behavior and to get access to internal key strings.  This is not a problem
     * as such because internal key strings can be created in other ways too (e.g.
     * through buffers).  The best fix is to change Duktape internal lookups to
     * skip proxy behavior.  Until that, internal property accesses bypass the
     * proxy and are applied to the target (as if the handler did not exist).
     * This has some side effects, see test-bi-proxy-internal-keys.js.
     */
 
    if (DUK_TVAL_IS_STRING(tv_key)) {
        duk_hstring *h_key = (duk_hstring *) DUK_TVAL_GET_STRING(tv_key);
        DUK_ASSERT(h_key != NULL);
        if (DUK_HSTRING_HAS_INTERNAL(h_key)) {
            DUK_DDD(DUK_DDDPRINT("internal key, skip proxy handler and apply to target"));
            return 0;
        }
    }
 
    /* The handler is looked up with a normal property lookup; it may be an
     * accessor or the handler object itself may be a proxy object.  If the
     * handler is a proxy, we need to extend the valstack as we make a
     * recursive proxy check without a function call in between (in fact
     * there is no limit to the potential recursion here).
     *
     * (For sanity, proxy creation rejects another proxy object as either
     * the handler or the target at the moment so recursive proxy cases
     * are not realized now.)

References DUK_ASSERT, duk_hobject_proxy_check(), and NULL.

Referenced by duk_hobject_putprop().

◆ duk__push_arraybuffer_with_length()

DUK_LOCAL duk_hbufferobject * duk__push_arraybuffer_with_length	(	duk_context *	ctx,
		duk_uint_t	len )

Definition at line 21927 of file duktape-1.8.0/src/duktape.c.

                                                                                                 {
    duk_hbuffer *h_val;
    duk_hbufferobject *h_bufobj;

◆ duk__push_c_function_raw()

DUK_LOCAL_DECL duk_idx_t duk__push_c_function_raw	(	duk_context *	ctx,
		duk_c_function	func,
		duk_idx_t	nargs,
		duk_uint_t	flags )

Definition at line 18763 of file duktape-1.8.0/src/duktape.c.

                                                                     : 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
 
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
    DUK_HOBJECT_INCREF(thr, obj);
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
    thr->valstack_top++;
 
    /* default prototype (Note: 'obj' must be reachable) */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
 
    return ret;
}
 
DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hnativefunction *obj;
    duk_idx_t ret;
    duk_tval *tv_slot;
    duk_int16_t func_nargs;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
    if (func == NULL) {
        goto api_error;
    }
    if (nargs >= 0 && nargs < DUK_HNATIVEFUNCTION_NARGS_MAX) {
        func_nargs = (duk_int16_t) nargs;
    } else if (nargs == DUK_VARARGS) {
        func_nargs = DUK_HNATIVEFUNCTION_NARGS_VARARGS;
    } else {
        goto api_error;
    }
 
    obj = duk_hnativefunction_alloc(thr->heap, flags);
    if (!obj) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    obj->func = func;
    obj->nargs = func_nargs;
 
    DUK_DDD(DUK_DDDPRINT("created native function object with flags: 0x%08lx, nargs=%ld",

Referenced by duk_push_c_function_noconstruct_noexotic(), and duk_push_c_function_noexotic().

◆ duk__push_double()

DUK_LOCAL void duk__push_double	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 53755 of file duktape-1.8.0/src/duktape.c.

                            {
        *p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
    }
    duk_to_string(ctx, -1);
}
DUK_LOCAL void duk__push_stridx_or_string(duk_context *ctx, duk_bitdecoder_ctx *bd) {
    if (duk_bd_decode_flag(bd)) {
        duk__push_string(ctx, bd);

References DUK__STRING_CHAR_BITS, and duk_bd_decode().

◆ duk__push_hstring_readable_unicode()

DUK_LOCAL void duk__push_hstring_readable_unicode	(	duk_context *	ctx,
		duk_hstring *	h_input )

Definition at line 19685 of file duktape-1.8.0/src/duktape.c.

                                                                                          {
    duk_hthread *thr;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH * DUK__READABLE_STRING_MAXCHARS +
                    2 /*quotes*/ + 3 /*periods*/];
    duk_uint8_t *q;
    duk_ucodepoint_t cp;
    duk_small_uint_t nchars;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h_input != NULL);
    thr = (duk_hthread *) ctx;
 
    p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
    p = p_start;
    q = buf;
 
    nchars = 0;
    *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE;
    for (;;) {
        if (p >= p_end) {
            break;
        }
        if (nchars == DUK__READABLE_STRING_MAXCHARS) {
            *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
            *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
            *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
            break;
        }
        if (duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) {
            if (cp < 0x20 || cp == 0x7f || cp == DUK_ASC_SINGLEQUOTE || cp == DUK_ASC_BACKSLASH) {
                DUK_ASSERT(DUK_UNICODE_MAX_XUTF8_LENGTH >= 4);  /* estimate is valid */
                DUK_ASSERT((cp >> 4) <= 0x0f);

◆ duk__push_stash()

DUK_LOCAL void duk__push_stash ( duk_context * ctx )

Definition at line 18421 of file duktape-1.8.0/src/duktape.c.

                                {
        duk_push_hobject(ctx, (duk_hobject *) thr->heap->curr_thread);
    } else {
        duk_push_undefined(ctx);
    }
}
 
DUK_EXTERNAL void duk_push_global_object(duk_context *ctx) {

Referenced by duk_push_thread_stash().

◆ duk__push_stridx()

DUK_LOCAL void duk__push_stridx	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 53728 of file duktape-1.8.0/src/duktape.c.

                                           {
        duk_hobject *h;
        h = (duk_hobject *) DUK_LOSE_CONST(duk_rom_builtins_bidx[i]);
        DUK_ASSERT(h != NULL);
        thr->builtins[i] = h;
    }
 
#if defined(DUK_USE_ROM_GLOBAL_CLONE) || defined(DUK_USE_ROM_GLOBAL_INHERIT)

References duk_hthread::builtins, DUK_ASSERT, DUK_LOSE_CONST, and NULL.

◆ duk__push_stridx_or_string()

DUK_LOCAL void duk__push_stridx_or_string	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 53748 of file duktape-1.8.0/src/duktape.c.

53753 {

53754 duk_small_uint_t n;

◆ duk__push_string()

DUK_LOCAL void duk__push_string	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 53736 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_small_uint_t n;
 

◆ duk__push_this_get_timeval()

DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval	(	duk_context *	ctx,
		duk_small_uint_t	flags )

Definition at line 25543 of file duktape-1.8.0/src/duktape.c.

25545 {

◆ duk__push_this_get_timeval_tzoffset()

DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval_tzoffset	(	duk_context *	ctx,
		duk_small_uint_t	flags,
		duk_int_t *	out_tzoffset )

Definition at line 25501 of file duktape-1.8.0/src/duktape.c.

                                                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_double_t d;
    duk_int_t tzoffset = 0;
 
    duk_push_this(ctx);
    h = duk_get_hobject(ctx, -1);  /* XXX: getter with class check, useful in built-ins */
    if (h == NULL || DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_DATE) {
        DUK_ERROR_TYPE(thr, "expected Date");
    }
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
    d = duk_to_number(ctx, -1);
    duk_pop(ctx);
 
    if (DUK_ISNAN(d)) {
        if (flags & DUK_DATE_FLAG_NAN_TO_ZERO) {
            d = 0.0;
        }
        if (flags & DUK_DATE_FLAG_NAN_TO_RANGE_ERROR) {
            DUK_ERROR_RANGE(thr, "Invalid Date");
        }
    }

◆ duk__push_this_helper()

DUK_LOCAL void duk__push_this_helper	(	duk_context *	ctx,
		duk_small_uint_t	check_object_coercible )

Definition at line 18296 of file duktape-1.8.0/src/duktape.c.

                                                                {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_POINTER(tv_slot, val);
}
 
DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t check_object_coercible) {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
    thr = (duk_hthread *) ctx;
    DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
    DUK__CHECK_SPACE();
 
    DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(thr->valstack_top));  /* because of valstack init policy */
    tv_slot = thr->valstack_top++;
 
    if (DUK_UNLIKELY(thr->callstack_top == 0)) {
        if (check_object_coercible) {
            goto type_error;
        }
        /* 'undefined' already on stack top */
    } else {
        duk_tval *tv;
 

◆ duk__push_this_number_plain()

DUK_LOCAL duk_double_t duk__push_this_number_plain ( duk_context * ctx )

Definition at line 32892 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    DUK_UNREF(ctx);
    return DUK_RET_UNIMPLEMENTED_ERROR;
}
 
#endif  /* DUK_USE_MATH_BUILTIN */
#line 1 "duk_bi_number.c"
/*
 *  Number built-ins
 */
 
/* include removed: duk_internal.h */
 
DUK_LOCAL duk_double_t duk__push_this_number_plain(duk_context *ctx) {
    duk_hobject *h;
 
    /* Number built-in accepts a plain number or a Number object (whose
     * internal value is operated on).  Other types cause TypeError.
     */
 
    duk_push_this(ctx);
    if (duk_is_number(ctx, -1)) {
        DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));

◆ duk__push_this_obj_len_u32()

DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32 ( duk_context * ctx )

Definition at line 20266 of file duktape-1.8.0/src/duktape.c.

                                              : even Duktape code internally
 *  assumes that an Array instance will always have a 'length' property.
 *  Preventing deletion of the property is critical.
 */
 
/* include removed: duk_internal.h */
 
/* Perform an intermediate join when this many elements have been pushed

Referenced by duk_bi_array_constructor().

◆ duk__push_this_obj_len_u32_limited()

DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32_limited ( duk_context * ctx )

Definition at line 20277 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    duk_uint32_t len;
 
    (void) duk_push_this_coercible_to_object(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);

References duk_get_prop_stridx(), duk_push_this_coercible_to_object(), DUK_STRIDX_LENGTH, and duk_to_uint32().

◆ duk__push_tval_to_hstring_arr_idx()

DUK_LOCAL duk_uint32_t duk__push_tval_to_hstring_arr_idx	(	duk_context *	ctx,
		duk_tval *	tv,
		duk_hstring **	out_h )

Definition at line 47565 of file duktape-1.8.0/src/duktape.c.

                                   {
        /* Catches >0x100000000 and negative values. */
        return DUK__NO_ARRAY_INDEX;
    }
 
    /* If the value happens to be 0xFFFFFFFF, it's not a valid array index
     * but will then match DUK__NO_ARRAY_INDEX.
     */
    return (duk_uint32_t) t;
}
#endif  /* DUK_USE_FASTINT */
 
/* Push an arbitrary duk_tval to the stack, coerce it to string, and return
 * both a duk_hstring pointer and an array index (or DUK__NO_ARRAY_INDEX).
 */

Referenced by duk_hobject_putprop().

◆ duk__put_prop_shared()

DUK_LOCAL duk_bool_t duk__put_prop_shared	(	duk_context *	ctx,
		duk_idx_t	obj_idx,
		duk_idx_t	idx_key )

Definition at line 14478 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                             {
    duk_bool_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(stridx >= 0);
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
 
    rc = duk_get_prop_stridx(ctx, obj_index, stridx);
    if (out_has_prop) {
        *out_has_prop = rc;
    }
    rc = duk_to_boolean(ctx, -1);
    DUK_ASSERT(rc == 0 || rc == 1);
    duk_pop(ctx);
    return rc;
}
 
DUK_LOCAL duk_bool_t duk__put_prop_shared(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t idx_key) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;
    duk_tval *tv_val;
    duk_small_int_t throw_flag;
    duk_bool_t rc;
 
    /* Note: copying tv_obj and tv_key to locals to shield against a valstack
     * resize is not necessary for a property put right now (putprop protects
     * against it internally).
     */

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, duk_get_prop_stridx(), DUK_HEAP_NUM_STRINGS, duk_pop(), and duk_to_boolean().

◆ duk__putprop_fastpath_bufobj_tval()

DUK_LOCAL duk_bool_t duk__putprop_fastpath_bufobj_tval	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_tval *	tv_key,
		duk_tval *	tv_val )

Definition at line 49570 of file duktape-1.8.0/src/duktape.c.

                                                                                                          {
        data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
        duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size);
    } else {
        DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)"));
        duk_push_uint(ctx, 0);
    }
 
    return 1;
}
 
DUK_LOCAL duk_bool_t duk__putprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val) {
    duk_context *ctx;
    duk_uint32_t idx;
    duk_hbufferobject *h_bufobj;
    duk_uint_t byte_off;
    duk_small_uint_t elem_size;
    duk_uint8_t *data;
 
    ctx = (duk_context *) thr;
 
    if (!(DUK_HOBJECT_IS_BUFFEROBJECT(obj) &&
          DUK_TVAL_IS_NUMBER(tv_val))) {
        return 0;
    }
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));  /* caller ensures; rom objects are never bufferobjects now */
 
    h_bufobj = (duk_hbufferobject *) obj;
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_key)) {
        idx = duk__tval_fastint_to_arr_idx(tv_key);
    } else
#endif
    if (DUK_TVAL_IS_DOUBLE(tv_key)) {
        idx = duk__tval_number_to_arr_idx(tv_key);
    } else {
        return 0;
    }
 
    /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
     * is 0xffffffffUL.  We don't need to check for that explicitly
     * because 0xffffffffUL will never be inside bufferobject length.
     */
 
    /* Careful with wrapping (left shifting idx would be unsafe). */
    if (idx >= (h_bufobj->length >> h_bufobj->shift)) {
        return 0;
    }
    DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX);
 
    byte_off = idx << h_bufobj->shift;  /* no wrap assuming h_bufobj->length is valid */
    elem_size = 1 << h_bufobj->shift;

Referenced by duk_hobject_putprop().

◆ duk__putprop_shallow_fastpath_array_tval()

DUK_LOCAL duk_bool_t duk__putprop_shallow_fastpath_array_tval	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_tval *	tv_key,
		duk_tval *	tv_val,
		duk_propdesc *	temp_desc )

Definition at line 49453 of file duktape-1.8.0/src/duktape.c.

                                 {
        DUK_DDD(DUK_DDDPRINT("-> fast path successful"));
        return tv;
    }
 
    DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path"));
    return NULL;
}
 
DUK_LOCAL duk_bool_t duk__putprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val, duk_propdesc *temp_desc) {
    duk_tval *tv;
    duk_uint32_t idx;
    duk_uint32_t old_len, new_len;
 
    if (!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj) &&
          DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
          DUK_HOBJECT_HAS_EXTENSIBLE(obj))) {
        return 0;
    }
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));  /* caller ensures */
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_key)) {
        idx = duk__tval_fastint_to_arr_idx(tv_key);
    } else
#endif
    if (DUK_TVAL_IS_DOUBLE(tv_key)) {
        idx = duk__tval_number_to_arr_idx(tv_key);
    } else {
        DUK_DDD(DUK_DDDPRINT("key is not a number"));
        return 0;
    }
 
    /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
     * is 0xffffffffUL.  We don't need to check for that explicitly
     * because 0xffffffffUL will never be inside object 'a_size'.
     */
 
    if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) {  /* for resizing of array part, use slow path */
        return 0;
    }
    DUK_ASSERT(idx != 0xffffffffUL);
    DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX);
 
    old_len = duk__get_old_array_length(thr, obj, temp_desc);
 
    if (idx >= old_len) {
        DUK_DDD(DUK_DDDPRINT("write new array entry requires length update "
                             "(arr_idx=%ld, old_len=%ld)",
                             (long) idx, (long) old_len));
        if (!(temp_desc->flags & DUK_PROPDESC_FLAG_WRITABLE)) {
            DUK_ERROR_TYPE(thr, DUK_STR_NOT_WRITABLE);
            return 0;  /* not reachable */

Referenced by duk_hobject_putprop().

◆ duk__putvar_helper()

DUK_LOCAL void duk__putvar_helper	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_activation *	act,
		duk_hstring *	name,
		duk_tval *	val,
		duk_bool_t	strict )

Definition at line 72796 of file duktape-1.8.0/src/duktape.c.

                                           {
    duk__id_lookup_result ref;
    duk_tval tv_tmp_obj;
    duk_tval tv_tmp_key;
    duk_bool_t parents;
 
    DUK_DDD(DUK_DDDPRINT("putvar: thr=%p, env=%p, act=%p, name=%!O, val=%p, strict=%ld "
                         "(env -> %!dO, val -> %!T)",
                         (void *) thr, (void *) env, (void *) act,
                         (duk_heaphdr *) name, (void *) val, (long) strict,
                         (duk_heaphdr *) env, (duk_tval *) val));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(name != NULL);
    DUK_ASSERT(val != NULL);
    /* env and act may be NULL */
 
        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env);
        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
    DUK_ASSERT_REFCOUNT_NONZERO_TVAL(val);
 
    /*
     *  In strict mode E5 protects 'eval' and 'arguments' from being
     *  assigned to (or even declared anywhere).  Attempt to do so
     *  should result in a compile time SyntaxError.  See the internal
     *  design documentation for details.
     *
     *  Thus, we should never come here, run-time, for strict code,
     *  and name 'eval' or 'arguments'.
     */
 
    DUK_ASSERT(!strict ||
               (name != DUK_HTHREAD_STRING_EVAL(thr) &&
                name != DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)));
 
    /*
     *  Lookup variable and update in-place if found.
     */
 
    parents = 1;     /* follow parent chain */
 
    if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
        if (ref.value && (ref.attrs & DUK_PROPDESC_FLAG_WRITABLE)) {
            /* Update duk_tval in-place if pointer provided and the
             * property is writable.  If the property is not writable
             * (immutable binding), use duk_hobject_putprop() which
             * will respect mutability.
             */
            duk_tval *tv_val;
 
            DUK_ASSERT(ref.this_binding == NULL);  /* always for register bindings */
 
            tv_val = ref.value;
            DUK_ASSERT(tv_val != NULL);
            DUK_TVAL_SET_TVAL_UPDREF(thr, tv_val, val);  /* side effects */
 
            /* ref.value and ref.this_binding invalidated here */
        } else {
            DUK_ASSERT(ref.holder != NULL);
 
            DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder);
            DUK_TVAL_SET_STRING(&tv_tmp_key, name);
            (void) duk_hobject_putprop(thr, &tv_tmp_obj, &tv_tmp_key, val, strict);
 
            /* ref.value and ref.this_binding invalidated here */
        }
 
        return;
    }
 
    /*
     *  Not found: write to global object (non-strict) or ReferenceError
     *  (strict); see E5 Section 8.7.2, step 3.

References duk__id_lookup_result::attrs, duk__get_identifier_reference(), DUK_ASSERT, DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR, DUK_ASSERT_REFCOUNT_NONZERO_TVAL, DUK_DDD, DUK_DDDPRINT, duk_hobject_putprop(), DUK_HTHREAD_STRING_EVAL, DUK_HTHREAD_STRING_LC_ARGUMENTS, DUK_PROPDESC_FLAG_WRITABLE, DUK_TVAL_SET_OBJECT, DUK_TVAL_SET_STRING, DUK_TVAL_SET_TVAL_UPDREF, duk__id_lookup_result::holder, name, NULL, duk__id_lookup_result::this_binding, and duk__id_lookup_result::value.

◆ duk__queue_refzero()

DUK_LOCAL void duk__queue_refzero	(	duk_heap *	heap,
		duk_heaphdr *	hdr )

Definition at line 44098 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    /* tail insert: don't disturb head in case refzero is running */
 
    if (heap->refzero_list != NULL) {
        duk_heaphdr *hdr_prev;
 
        hdr_prev = heap->refzero_list_tail;
        DUK_ASSERT(hdr_prev != NULL);

References DUK_ASSERT, DUK_ASSERT_HEAPHDR_LINKS, DUK_HEAPHDR_GET_NEXT, DUK_HEAPHDR_SET_NEXT, DUK_HEAPHDR_SET_PREV, NULL, duk_heap::refzero_list, and duk_heap::refzero_list_tail.

◆ duk__realloc_props()

DUK_LOCAL void duk__realloc_props	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_uint32_t	new_e_size,
		duk_uint32_t	new_a_size,
		duk_uint32_t	new_h_size,
		duk_bool_t	abandon_array )

Definition at line 47910 of file duktape-1.8.0/src/duktape.c.

        : a non-checked variant would be nice but is a bit tricky to
 *  implement for the array abandonment process.  It's easy for
 *  everything else.
 *
 *  Note: because we need to potentially resize the valstack (as part
 *  of abandoning the array part), any tval pointers to the valstack
 *  will become invalid after this call.
 */
 
DUK_LOCAL
void duk__realloc_props(duk_hthread *thr,
                        duk_hobject *obj,
                        duk_uint32_t new_e_size,
                        duk_uint32_t new_a_size,
                        duk_uint32_t new_h_size,
                        duk_bool_t abandon_array) {
    duk_context *ctx = (duk_context *) thr;
#ifdef DUK_USE_MARK_AND_SWEEP
    duk_small_uint_t prev_mark_and_sweep_base_flags;
#endif
    duk_uint32_t new_alloc_size;
    duk_uint32_t new_e_size_adjusted;
    duk_uint8_t *new_p;
    duk_hstring **new_e_k;
    duk_propvalue *new_e_pv;
    duk_uint8_t *new_e_f;
    duk_tval *new_a;
    duk_uint32_t *new_h;
    duk_uint32_t new_e_next;
    duk_uint_fast32_t i;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(!abandon_array || new_a_size == 0);  /* if abandon_array, new_a_size must be 0 */
    DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL || (DUK_HOBJECT_GET_ESIZE(obj) == 0 && DUK_HOBJECT_GET_ASIZE(obj) == 0));
    DUK_ASSERT(new_h_size == 0 || new_h_size >= new_e_size);  /* required to guarantee success of rehashing,
                                                               * intentionally use unadjusted new_e_size
                                                               */
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /*
     *  Pre resize assertions.
     */
 
#ifdef DUK_USE_ASSERTIONS
    /* XXX: pre-checks (such as no duplicate keys) */
#endif
 
    /*
     *  For property layout 1, tweak e_size to ensure that the whole entry
     *  part (key + val + flags) is a suitable multiple for alignment
     *  (platform specific).
     *
     *  Property layout 2 does not require this tweaking and is preferred
     *  on low RAM platforms requiring alignment.
     */
 
#if defined(DUK_USE_HOBJECT_LAYOUT_2) || defined(DUK_USE_HOBJECT_LAYOUT_3)
    DUK_DDD(DUK_DDDPRINT("using layout 2 or 3, no need to pad e_size: %ld", (long) new_e_size));
    new_e_size_adjusted = new_e_size;
#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && (DUK_HOBJECT_ALIGN_TARGET == 1)
    DUK_DDD(DUK_DDDPRINT("using layout 1, but no need to pad e_size: %ld", (long) new_e_size));
    new_e_size_adjusted = new_e_size;
#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && ((DUK_HOBJECT_ALIGN_TARGET == 4) || (DUK_HOBJECT_ALIGN_TARGET == 8))
    new_e_size_adjusted = (new_e_size + DUK_HOBJECT_ALIGN_TARGET - 1) & (~(DUK_HOBJECT_ALIGN_TARGET - 1));
    DUK_DDD(DUK_DDDPRINT("using layout 1, and alignment target is %ld, adjusted e_size: %ld -> %ld",
                         (long) DUK_HOBJECT_ALIGN_TARGET, (long) new_e_size, (long) new_e_size_adjusted));
    DUK_ASSERT(new_e_size_adjusted >= new_e_size);
#else
#error invalid hobject layout defines
#endif
 
    /*
     *  Debug logging after adjustment.
     */
 
    DUK_DDD(DUK_DDDPRINT("attempt to resize hobject %p props (%ld -> %ld bytes), from {p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld} to "
                         "{e_size=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld",
                         (void *) obj,
                         (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
                                                           DUK_HOBJECT_GET_ASIZE(obj),
                                                           DUK_HOBJECT_GET_HSIZE(obj)),
                         (long) DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size),
                         (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj),
                         (long) DUK_HOBJECT_GET_ESIZE(obj),
                         (long) DUK_HOBJECT_GET_ENEXT(obj),
                         (long) DUK_HOBJECT_GET_ASIZE(obj),
                         (long) DUK_HOBJECT_GET_HSIZE(obj),
                         (long) new_e_size_adjusted,
                         (long) new_a_size,
                         (long) new_h_size,
                         (long) abandon_array,
                         (long) new_e_size));
 
    /*
     *  Property count check.  This is the only point where we ensure that
     *  we don't get more (allocated) property space that we can handle.
     *  There aren't hard limits as such, but some algorithms fail (e.g.
     *  finding next higher prime, selecting hash part size) if we get too
     *  close to the 4G property limit.
     *
     *  Since this works based on allocation size (not actually used size),
     *  the limit is a bit approximate but good enough in practice.
     */
 
    if (new_e_size_adjusted + new_a_size > DUK_HOBJECT_MAX_PROPERTIES) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    /*
     *  Compute new alloc size and alloc new area.
     *
     *  The new area is allocated as a dynamic buffer and placed into the
     *  valstack for reachability.  The actual buffer is then detached at
     *  the end.
     *
     *  Note: heap_mark_and_sweep_base_flags are altered here to ensure
     *  no-one touches this object while we're resizing and rehashing it.
     *  The flags must be reset on every exit path after it.  Finalizers
     *  and compaction is prevented currently for all objects while it
     *  would be enough to restrict it only for the current object.
     */
 
#ifdef DUK_USE_MARK_AND_SWEEP
    prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags;
    thr->heap->mark_and_sweep_base_flags |=
            DUK_MS_FLAG_NO_FINALIZERS |         /* avoid attempts to add/remove object keys */
            DUK_MS_FLAG_NO_OBJECT_COMPACTION;   /* avoid attempt to compact the current object */
#endif
 
    new_alloc_size = DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size);
    DUK_DDD(DUK_DDDPRINT("new hobject allocation size is %ld", (long) new_alloc_size));
    new_e_next = 0;
    new_e_k = NULL;
    if (new_alloc_size == 0) {
        /* for zero size, don't push anything on valstack */
        DUK_ASSERT(new_e_size_adjusted == 0);
        DUK_ASSERT(new_a_size == 0);
        DUK_ASSERT(new_h_size == 0);
        new_p = NULL;
    } else {
        /* This may trigger mark-and-sweep with arbitrary side effects,
         * including an attempted resize of the object we're resizing,
         * executing a finalizer which may add or remove properties of
         * the object we're resizing etc.
         */
 
#if 0  /* XXX: inject test */
        if (1) {
            goto alloc_failed;
        }
#endif
        new_p = (duk_uint8_t *) DUK_ALLOC(thr->heap, new_alloc_size);
        if (new_p == NULL) {
            /* NULL always indicates alloc failure because
             * new_alloc_size > 0.
             */
            goto alloc_failed;
        }
    }
 
    /* Set up pointers to the new property area: this is hidden behind a macro
     * because it is memory layout specific.
     */
    DUK_HOBJECT_P_SET_REALLOC_PTRS(new_p, new_e_k, new_e_pv, new_e_f, new_a, new_h,
                                   new_e_size_adjusted, new_a_size, new_h_size);
    DUK_UNREF(new_h);  /* happens when hash part dropped */
 
    /* if new_p == NULL, all of these pointers are NULL */
    DUK_ASSERT((new_p != NULL) ||
               (new_e_k == NULL && new_e_pv == NULL && new_e_f == NULL &&
                new_a == NULL && new_h == NULL));
 
    DUK_DDD(DUK_DDDPRINT("new alloc size %ld, new_e_k=%p, new_e_pv=%p, new_e_f=%p, new_a=%p, new_h=%p",
                         (long) new_alloc_size, (void *) new_e_k, (void *) new_e_pv, (void *) new_e_f,
                         (void *) new_a, (void *) new_h));
 
    /*
     *  Migrate array to start of entries if requested.
     *
     *  Note: from an enumeration perspective the order of entry keys matters.
     *  Array keys should appear wherever they appeared before the array abandon
     *  operation.
     */
 
    if (abandon_array) {
        /*
         *  Note: assuming new_a_size == 0, and that entry part contains
         *  no conflicting keys, refcounts do not need to be adjusted for
         *  the values, as they remain exactly the same.
         *
         *  The keys, however, need to be interned, incref'd, and be
         *  reachable for GC.  Any intern attempt may trigger a GC and
         *  claim any non-reachable strings, so every key must be reachable
         *  at all times.
         *
         *  A longjmp must not occur here, as the new_p allocation would
         *  be freed without these keys being decref'd, hence the messy
         *  decref handling if intern fails.
         */
        DUK_ASSERT(new_a_size == 0);
 
        for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
            duk_tval *tv1;
            duk_tval *tv2;
            duk_hstring *key;
 
            DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
 
            tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
            if (DUK_TVAL_IS_UNUSED(tv1)) {
                continue;
            }
 
            DUK_ASSERT(new_p != NULL && new_e_k != NULL &&
                       new_e_pv != NULL && new_e_f != NULL);
 
            /*
             *  Intern key via the valstack to ensure reachability behaves
             *  properly.  We must avoid longjmp's here so use non-checked
             *  primitives.
             *
             *  Note: duk_check_stack() potentially reallocs the valstack,
             *  invalidating any duk_tval pointers to valstack.  Callers
             *  must be careful.
             */
 
            /* never shrinks; auto-adds DUK_VALSTACK_INTERNAL_EXTRA, which is generous */
            if (!duk_check_stack(ctx, 1)) {
                goto abandon_error;
            }
            DUK_ASSERT_VALSTACK_SPACE(thr, 1);
            key = duk_heap_string_intern_u32(thr->heap, i);
            if (!key) {
                goto abandon_error;
            }
            duk_push_hstring(ctx, key);  /* keep key reachable for GC etc; guaranteed not to fail */
 
            /* key is now reachable in the valstack */
 
            DUK_HSTRING_INCREF(thr, key);   /* second incref for the entry reference */
            new_e_k[new_e_next] = key;
            tv2 = &new_e_pv[new_e_next].v;  /* array entries are all plain values */
            DUK_TVAL_SET_TVAL(tv2, tv1);
            new_e_f[new_e_next] = DUK_PROPDESC_FLAG_WRITABLE |
                                  DUK_PROPDESC_FLAG_ENUMERABLE |
                                  DUK_PROPDESC_FLAG_CONFIGURABLE;
            new_e_next++;
 
            /* Note: new_e_next matches pushed temp key count, and nothing can
             * fail above between the push and this point.
             */
        }
 
        DUK_DDD(DUK_DDDPRINT("abandon array: pop %ld key temps from valstack", (long) new_e_next));
        duk_pop_n(ctx, new_e_next);
    }
 
    /*
     *  Copy keys and values in the entry part (compacting them at the same time).
     */
 
    for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
        duk_hstring *key;
 
        DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
 
        key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
        if (!key) {
            continue;
        }
 
        DUK_ASSERT(new_p != NULL && new_e_k != NULL &&
                   new_e_pv != NULL && new_e_f != NULL);
 
        new_e_k[new_e_next] = key;
        new_e_pv[new_e_next] = DUK_HOBJECT_E_GET_VALUE(thr->heap, obj, i);
        new_e_f[new_e_next] = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i);
        new_e_next++;
    }
    /* the entries [new_e_next, new_e_size_adjusted[ are left uninitialized on purpose (ok, not gc reachable) */
 
    /*
     *  Copy array elements to new array part.
     */
 
    if (new_a_size > DUK_HOBJECT_GET_ASIZE(obj)) {
        /* copy existing entries as is */
        DUK_ASSERT(new_p != NULL && new_a != NULL);
        if (DUK_HOBJECT_GET_ASIZE(obj) > 0) {
            /* Avoid zero copy with an invalid pointer.  If obj->p is NULL,
             * the 'new_a' pointer will be invalid which is not allowed even
             * when copy size is zero.
             */
            DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
            DUK_ASSERT(DUK_HOBJECT_GET_ASIZE(obj) > 0);
            DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * DUK_HOBJECT_GET_ASIZE(obj));
        }
 
        /* fill new entries with -unused- (required, gc reachable) */
        for (i = DUK_HOBJECT_GET_ASIZE(obj); i < new_a_size; i++) {
            duk_tval *tv = &new_a[i];
            DUK_TVAL_SET_UNUSED(tv);
        }
    } else {
#ifdef DUK_USE_ASSERTIONS
        /* caller must have decref'd values above new_a_size (if that is necessary) */
        if (!abandon_array) {
            for (i = new_a_size; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
                duk_tval *tv;
                tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
 
                /* current assertion is quite strong: decref's and set to unused */
                DUK_ASSERT(DUK_TVAL_IS_UNUSED(tv));
            }
        }
#endif
        if (new_a_size > 0) {
            /* Avoid zero copy with an invalid pointer.  If obj->p is NULL,
             * the 'new_a' pointer will be invalid which is not allowed even
             * when copy size is zero.
             */
            DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
            DUK_ASSERT(new_a_size > 0);
            DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * new_a_size);
        }
    }
 
    /*
     *  Rebuild the hash part always from scratch (guaranteed to finish).
     *
     *  Any resize of hash part requires rehashing.  In addition, by rehashing
     *  get rid of any elements marked deleted (DUK__HASH_DELETED) which is critical
     *  to ensuring the hash part never fills up.
     */
 
#if defined(DUK_USE_HOBJECT_HASH_PART)
    if (DUK_UNLIKELY(new_h_size > 0)) {
        DUK_ASSERT(new_h != NULL);
 
        /* fill new_h with u32 0xff = UNUSED */
        DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
        DUK_ASSERT(new_h_size > 0);
        DUK_MEMSET(new_h, 0xff, sizeof(duk_uint32_t) * new_h_size);
 
        DUK_ASSERT(new_e_next <= new_h_size);  /* equality not actually possible */
        for (i = 0; i < new_e_next; i++) {
            duk_hstring *key = new_e_k[i];
            duk_uint32_t j, step;
 
            DUK_ASSERT(key != NULL);
            j = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size);
            step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key));
 
            for (;;) {
                DUK_ASSERT(new_h[j] != DUK__HASH_DELETED);  /* should never happen */
                if (new_h[j] == DUK__HASH_UNUSED) {
                    DUK_DDD(DUK_DDDPRINT("rebuild hit %ld -> %ld", (long) j, (long) i));
                    new_h[j] = i;
                    break;
                }
                DUK_DDD(DUK_DDDPRINT("rebuild miss %ld, step %ld", (long) j, (long) step));
                j = (j + step) % new_h_size;
 
                /* guaranteed to finish */
                DUK_ASSERT(j != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size));
            }
        }
    } else {
        DUK_DDD(DUK_DDDPRINT("no hash part, no rehash"));
    }
#endif  /* DUK_USE_HOBJECT_HASH_PART */
 
    /*
     *  Nice debug log.
     */
 
    DUK_DD(DUK_DDPRINT("resized hobject %p props (%ld -> %ld bytes), from {p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld} to "
                       "{p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld",
                       (void *) obj,
                       (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
                                                         DUK_HOBJECT_GET_ASIZE(obj),
                                                         DUK_HOBJECT_GET_HSIZE(obj)),
                       (long) new_alloc_size,
                       (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj),
                       (long) DUK_HOBJECT_GET_ESIZE(obj),
                       (long) DUK_HOBJECT_GET_ENEXT(obj),
                       (long) DUK_HOBJECT_GET_ASIZE(obj),
                       (long) DUK_HOBJECT_GET_HSIZE(obj),
                       (void *) new_p,
                       (long) new_e_size_adjusted,
                       (long) new_e_next,
                       (long) new_a_size,
                       (long) new_h_size,
                       (long) abandon_array,
                       (long) new_e_size));
 
    /*
     *  All done, switch properties ('p') allocation to new one.
     */
 
    DUK_FREE(thr->heap, DUK_HOBJECT_GET_PROPS(thr->heap, obj));  /* NULL obj->p is OK */
    DUK_HOBJECT_SET_PROPS(thr->heap, obj, new_p);
    DUK_HOBJECT_SET_ESIZE(obj, new_e_size_adjusted);
    DUK_HOBJECT_SET_ENEXT(obj, new_e_next);
    DUK_HOBJECT_SET_ASIZE(obj, new_a_size);
    DUK_HOBJECT_SET_HSIZE(obj, new_h_size);
 
    /* clear array part flag only after switching */
    if (abandon_array) {
        DUK_HOBJECT_CLEAR_ARRAY_PART(obj);
    }
 
    DUK_DDD(DUK_DDDPRINT("resize result: %!O", (duk_heaphdr *) obj));
 
#ifdef DUK_USE_MARK_AND_SWEEP
    thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
#endif
 
    /*
     *  Post resize assertions.
     */
 
#ifdef DUK_USE_ASSERTIONS
    /* XXX: post-checks (such as no duplicate keys) */
#endif
    return;
 
    /*
     *  Abandon array failed, need to decref keys already inserted
     *  into the beginning of new_e_k before unwinding valstack.
     */
 
 abandon_error:
 alloc_failed:
    DUK_D(DUK_DPRINT("object property table resize failed"));

References DUK__HASH_DELETED, DUK__HASH_INITIAL, DUK__HASH_PROBE_STEP, DUK__HASH_UNUSED, DUK__VALSTACK_SPACE, DUK_ALLOC, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, duk_check_stack(), DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_FREE, duk_heap_string_intern_u32(), DUK_HEAPHDR_HAS_READONLY, DUK_HOBJECT_A_GET_BASE, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_ALIGN_TARGET, DUK_HOBJECT_CLEAR_ARRAY_PART, DUK_HOBJECT_E_GET_FLAGS, DUK_HOBJECT_E_GET_KEY, DUK_HOBJECT_E_GET_VALUE, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_GET_ENEXT, DUK_HOBJECT_GET_ESIZE, DUK_HOBJECT_GET_HSIZE, DUK_HOBJECT_GET_PROPS, DUK_HOBJECT_MAX_PROPERTIES, DUK_HOBJECT_P_COMPUTE_SIZE, DUK_HOBJECT_P_SET_REALLOC_PTRS, DUK_HOBJECT_SET_ASIZE, DUK_HOBJECT_SET_ENEXT, DUK_HOBJECT_SET_ESIZE, DUK_HOBJECT_SET_HSIZE, DUK_HOBJECT_SET_PROPS, DUK_HSTRING_GET_HASH, DUK_HSTRING_INCREF, DUK_MEMCPY, DUK_MEMSET, DUK_MS_FLAG_NO_FINALIZERS, DUK_MS_FLAG_NO_OBJECT_COMPACTION, duk_pop_n(), DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, duk_push_hstring(), DUK_TVAL_IS_UNUSED, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_UNUSED, DUK_UNLIKELY, DUK_UNREF, duk_hthread::heap, duk_heap::mark_and_sweep_base_flags, NULL, and duk_propvalue::v.

◆ duk__recheck_strtab_size_probe()

DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe	(	duk_heap *	heap,
		duk_uint32_t	new_used )

Definition at line 45785 of file duktape-1.8.0/src/duktape.c.

                                  {
        new_size = DUK_STRTAB_HIGHEST_32BIT_PRIME;
    } else {
        new_size = duk_util_get_hash_prime(DUK_STRTAB_GROW_ST_SIZE(new_size));
        new_size = duk_util_get_hash_prime(new_size);
    }
    DUK_ASSERT(new_size > 0);
 
    /* rehash even if old and new sizes are the same to get rid of
     * DELETED entries.
    */
 
    ret = duk__resize_strtab_raw_probe(heap, new_size);
 
    return ret;
}
 
DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe(duk_heap *heap, duk_uint32_t new_used) {
    duk_uint32_t new_free;
    duk_uint32_t tmp1;
    duk_uint32_t tmp2;

References DUK_STRTAB_HIGHEST_32BIT_PRIME.

◆ duk__reconfig_valstack_ecma_catcher()

DUK_LOCAL void duk__reconfig_valstack_ecma_catcher	(	duk_hthread *	thr,
		duk_size_t	act_idx,
		duk_size_t	cat_idx )

Definition at line 66190 of file duktape-1.8.0/src/duktape.c.

                                                                                                             {
    duk_activation *act;
    duk_catcher *cat;
    duk_hcompiledfunction *h_func;
    duk_idx_t clamp_top;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(act_idx >= 0);  /* unsigned */
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + act_idx)));
    DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0);  /* unsigned */
 
    act = thr->callstack + act_idx;
    cat = thr->catchstack + cat_idx;
    h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
 

◆ duk__reconfig_valstack_ecma_return()

DUK_LOCAL void duk__reconfig_valstack_ecma_return	(	duk_hthread *	thr,
		duk_size_t	act_idx )

Definition at line 66154 of file duktape-1.8.0/src/duktape.c.

                            : should not ordinarily throw errors; if errors
 *  occur (e.g. due to out-of-memory) they bubble outwards rather than being
 *  handled recursively.
 */
 
#define DUK__LONGJMP_RESTART   0  /* state updated, restart bytecode execution */
#define DUK__LONGJMP_RETHROW   1  /* exit bytecode executor by rethrowing an error to caller */
 
#define DUK__RETHAND_RESTART   0  /* state updated, restart bytecode execution */
#define DUK__RETHAND_FINISHED  1  /* exit bytecode execution with return value */
 
/* XXX: optimize reconfig valstack operations so that resize, clamp, and setting
 * top are combined into one pass.
 */
 
/* Reconfigure value stack for return to an Ecmascript function at 'act_idx'. */
DUK_LOCAL void duk__reconfig_valstack_ecma_return(duk_hthread *thr, duk_size_t act_idx) {
    duk_activation *act;
    duk_hcompiledfunction *h_func;
    duk_idx_t clamp_top;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(act_idx >= 0);  /* unsigned */
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + act_idx)));
    DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0);  /* unsigned */
 
    /* Clamp so that values at 'clamp_top' and above are wiped and won't
     * retain reachable garbage.  Then extend to 'nregs' because we're
     * returning to an Ecmascript function.
     */
 
    act = thr->callstack + act_idx;
    h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);

References duk_hthread::callstack, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_HOBJECT_IS_COMPILEDFUNCTION, duk_activation::idx_retval, and NULL.

◆ duk__recursion_decrease()

DUK_LOCAL void duk__recursion_decrease ( duk_compiler_ctx * comp_ctx )

Definition at line 58104 of file duktape-1.8.0/src/duktape.c.

◆ duk__recursion_increase()

DUK_LOCAL void duk__recursion_increase ( duk_compiler_ctx * comp_ctx )

Definition at line 58095 of file duktape-1.8.0/src/duktape.c.

◆ duk__refcount_finalize_hobject()

DUK_LOCAL void duk__refcount_finalize_hobject	(	duk_hthread *	thr,
		duk_hobject *	h )

Definition at line 44138 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk_uint_fast32_t i;
 
    DUK_ASSERT(h);
    DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h) == DUK_HTYPE_OBJECT);
 
    /* XXX: better to get base and walk forwards? */
 
    for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
        duk_hstring *key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
        if (!key) {
            continue;
        }
        duk_heaphdr_decref(thr, (duk_heaphdr *) key);
        if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)) {
            duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, h, i));
            duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, h, i));
        } else {
            duk_tval_decref(thr, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i));
        }
    }
 
    for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
        duk_tval_decref(thr, DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i));
    }
 
    /* hash part is a 'weak reference' and does not contribute */
 
    duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h));
 
    if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
        duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
        duk_tval *tv, *tv_end;
        duk_hobject **funcs, **funcs_end;
 
        if (DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f) != NULL) {
            tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, f);
            tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, f);
            while (tv < tv_end) {
                duk_tval_decref(thr, tv);
                tv++;
            }
 
            funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, f);
            funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, f);
            while (funcs < funcs_end) {
                duk_heaphdr_decref(thr, (duk_heaphdr *) *funcs);
                funcs++;
            }
        } else {
            /* May happen in some out-of-memory corner cases. */
            DUK_D(DUK_DPRINT("duk_hcompiledfunction 'data' is NULL, skipping decref"));
        }
 
        duk_heaphdr_decref(thr, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f));
    } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        duk_hnativefunction *f = (duk_hnativefunction *) h;
        DUK_UNREF(f);
        /* nothing to finalize */
    } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
        duk_hbufferobject *b = (duk_hbufferobject *) h;
        if (b->buf) {
            duk_heaphdr_decref(thr, (duk_heaphdr *) b->buf);
        }
    } else if (DUK_HOBJECT_IS_THREAD(h)) {
        duk_hthread *t = (duk_hthread *) h;
        duk_tval *tv;
 
        tv = t->valstack;
        while (tv < t->valstack_top) {
            duk_tval_decref(thr, tv);
            tv++;
        }
 
        for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
            duk_activation *act = t->callstack + i;
            duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
            duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->var_env);
            duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->lex_env);
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY

◆ duk__refzero_free_pending()

DUK_LOCAL void duk__refzero_free_pending ( duk_hthread * thr )

Definition at line 44318 of file duktape-1.8.0/src/duktape.c.

                                                           {
    duk_heaphdr *h1, *h2;
    duk_heap *heap;
    duk_int_t count = 0;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    heap = thr->heap;
    DUK_ASSERT(heap != NULL);
 
    /*
     *  Detect recursive invocation
     */
 
    if (DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)) {
        DUK_DDD(DUK_DDDPRINT("refzero free running, skip run"));
        return;
    }
 
    /*
     *  Churn refzero_list until empty
     */
 
    DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap);
    while (heap->refzero_list) {
        duk_hobject *obj;
        duk_bool_t rescued = 0;
 
        /*
         *  Pick an object from the head (don't remove yet).
         */
 
        h1 = heap->refzero_list;
        obj = (duk_hobject *) h1;
        DUK_DD(DUK_DDPRINT("refzero processing %p: %!O", (void *) h1, (duk_heaphdr *) h1));
        DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, h1) == NULL);
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(h1) == DUK_HTYPE_OBJECT);  /* currently, always the case */
 
#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE)
        /* Torture option to shake out finalizer side effect issues:
         * make a bogus function call for every finalizable object,
         * essentially simulating the case where everything has a
         * finalizer.
         */
        DUK_DD(DUK_DDPRINT("refzero torture enabled, fake finalizer"));
        DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0);
        DUK_HEAPHDR_PREINC_REFCOUNT(h1);  /* bump refcount to prevent refzero during finalizer processing */
        duk__refcount_run_torture_finalizer(thr, obj);  /* must never longjmp */
        DUK_HEAPHDR_PREDEC_REFCOUNT(h1);  /* remove artificial bump */
        DUK_ASSERT_DISABLE(h1->h_refcount >= 0);  /* refcount is unsigned, so always true */
#endif
 
        /*
         *  Finalizer check.
         *
         *  Note: running a finalizer may have arbitrary side effects, e.g.
         *  queue more objects on refzero_list (tail), or even trigger a
         *  mark-and-sweep.
         *
         *  Note: quick reject check should match vast majority of
         *  objects and must be safe (not throw any errors, ever).
         */
 
        /* An object may have FINALIZED here if it was finalized by mark-and-sweep
         * on a previous run and refcount then decreased to zero.  We won't run the
         * finalizer again here.
         */
 
        /* A finalizer is looked up from the object and up its prototype chain
         * (which allows inherited finalizers).
         */
        if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
            DUK_DDD(DUK_DDDPRINT("object has a finalizer, run it"));
 
            DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0);
            DUK_HEAPHDR_PREINC_REFCOUNT(h1);  /* bump refcount to prevent refzero during finalizer processing */
 
            duk_hobject_run_finalizer(thr, obj);  /* must never longjmp */
            DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(h1));  /* duk_hobject_run_finalizer() sets */
 
            DUK_HEAPHDR_PREDEC_REFCOUNT(h1);  /* remove artificial bump */
            DUK_ASSERT_DISABLE(h1->h_refcount >= 0);  /* refcount is unsigned, so always true */
 
            if (DUK_HEAPHDR_GET_REFCOUNT(h1) != 0) {
                DUK_DDD(DUK_DDDPRINT("-> object refcount after finalization non-zero, object will be rescued"));
                rescued = 1;
            } else {
                DUK_DDD(DUK_DDDPRINT("-> object refcount still zero after finalization, object will be freed"));
            }
        }
 
        /* Refzero head is still the same.  This is the case even if finalizer
         * inserted more refzero objects; they are inserted to the tail.
         */
        DUK_ASSERT(h1 == heap->refzero_list);
 
        /*
         *  Remove the object from the refzero list.  This cannot be done
         *  before a possible finalizer has been executed; the finalizer
         *  may trigger a mark-and-sweep, and mark-and-sweep must be able
         *  to traverse a complete refzero_list.
         */
 
        h2 = DUK_HEAPHDR_GET_NEXT(heap, h1);
        if (h2) {
            DUK_HEAPHDR_SET_PREV(heap, h2, NULL);  /* not strictly necessary */
            heap->refzero_list = h2;
        } else {
            heap->refzero_list = NULL;
            heap->refzero_list_tail = NULL;
        }
 
        /*
         *  Rescue or free.
         */
 
        if (rescued) {
            /* yes -> move back to heap allocated */
            DUK_DD(DUK_DDPRINT("object rescued during refcount finalization: %p", (void *) h1));
            DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(h1));
            DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(h1));
            DUK_HEAPHDR_CLEAR_FINALIZED(h1);
            h2 = heap->heap_allocated;
            DUK_HEAPHDR_SET_PREV(heap, h1, NULL);
            if (h2) {
                DUK_HEAPHDR_SET_PREV(heap, h2, h1);
            }
            DUK_HEAPHDR_SET_NEXT(heap, h1, h2);
            DUK_ASSERT_HEAPHDR_LINKS(heap, h1);
            DUK_ASSERT_HEAPHDR_LINKS(heap, h2);
            heap->heap_allocated = h1;
        } else {
            /* no -> decref members, then free */
            duk__refcount_finalize_hobject(thr, obj);
            duk_heap_free_heaphdr_raw(heap, h1);
        }
 
        count++;
    }
    DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap);
 
    DUK_DDD(DUK_DDDPRINT("refzero processed %ld objects", (long) count));
 
    /*
     *  Once the whole refzero cascade has been freed, check for
     *  a voluntary mark-and-sweep.
     */
 
#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_VOLUNTARY_GC)
    /* 'count' is more or less comparable to normal trigger counter update

◆ duk__regexp_match_helper()

DUK_LOCAL void duk__regexp_match_helper	(	duk_hthread *	thr,
		duk_small_int_t	force_global )

Definition at line 79386 of file duktape-1.8.0/src/duktape.c.

               :
    DUK_ERROR_INTERNAL_DEFMSG(re_ctx->thr);
    return NULL;  /* never here */
}
 
/*
 *  Exposed matcher function which provides the semantics of RegExp.prototype.exec().
 *
 *  RegExp.prototype.test() has the same semantics as exec() but does not return the
 *  result object (which contains the matching string and capture groups).  Currently
 *  there is no separate test() helper, so a temporary result object is created and
 *  discarded if test() is needed.  This is intentional, to save code space.
 *
 *  Input stack:  [ ... re_obj input ]
 *  Output stack: [ ... result ]
 */
 
DUK_LOCAL void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_global) {
    duk_context *ctx = (duk_context *) thr;
    duk_re_matcher_ctx re_ctx;
    duk_hobject *h_regexp;
    duk_hstring *h_bytecode;
    duk_hstring *h_input;
    duk_uint8_t *p_buf;
    const duk_uint8_t *pc;
    const duk_uint8_t *sp;
    duk_small_int_t match = 0;
    duk_small_int_t global;
    duk_uint_fast32_t i;
    double d;
    duk_uint32_t char_offset;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
 
    DUK_DD(DUK_DDPRINT("regexp match: regexp=%!T, input=%!T",
                       (duk_tval *) duk_get_tval(ctx, -2),
                       (duk_tval *) duk_get_tval(ctx, -1)));
 
    /*
     *  Regexp instance check, bytecode check, input coercion.
     *
     *  See E5 Section 15.10.6.
     */
 
    /* TypeError if wrong; class check, see E5 Section 15.10.6 */
    h_regexp = duk_require_hobject_with_class(ctx, -2, DUK_HOBJECT_CLASS_REGEXP);
    DUK_ASSERT(h_regexp != NULL);
    DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_regexp) == DUK_HOBJECT_CLASS_REGEXP);
    DUK_UNREF(h_regexp);
 
    duk_to_string(ctx, -1);
    h_input = duk_get_hstring(ctx, -1);
    DUK_ASSERT(h_input != NULL);
 
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_BYTECODE);  /* [ ... re_obj input ] -> [ ... re_obj input bc ] */
    h_bytecode = duk_require_hstring(ctx, -1);  /* no regexp instance should exist without a non-configurable bytecode property */
    DUK_ASSERT(h_bytecode != NULL);
 
    /*
     *  Basic context initialization.
     *
     *  Some init values are read from the bytecode header
     *  whose format is (UTF-8 codepoints):
     *
     *    uint   flags
     *    uint   nsaved (even, 2n+2 where n = num captures)
     */
 
    /* [ ... re_obj input bc ] */
 
    DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
 
    re_ctx.thr = thr;
    re_ctx.input = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
    re_ctx.input_end = re_ctx.input + DUK_HSTRING_GET_BYTELEN(h_input);
    re_ctx.bytecode = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_bytecode);
    re_ctx.bytecode_end = re_ctx.bytecode + DUK_HSTRING_GET_BYTELEN(h_bytecode);
    re_ctx.saved = NULL;
    re_ctx.recursion_limit = DUK_USE_REGEXP_EXECUTOR_RECLIMIT;
    re_ctx.steps_limit = DUK_RE_EXECUTE_STEPS_LIMIT;
 
    /* read header */
    pc = re_ctx.bytecode;
    re_ctx.re_flags = duk__bc_get_u32(&re_ctx, &pc);
    re_ctx.nsaved = duk__bc_get_u32(&re_ctx, &pc);
    re_ctx.bytecode = pc;
 
    DUK_ASSERT(DUK_RE_FLAG_GLOBAL < 0x10000UL);  /* must fit into duk_small_int_t */
    global = (duk_small_int_t) (force_global | (re_ctx.re_flags & DUK_RE_FLAG_GLOBAL));
 
    DUK_ASSERT(re_ctx.nsaved >= 2);
    DUK_ASSERT((re_ctx.nsaved % 2) == 0);
 
    p_buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, sizeof(duk_uint8_t *) * re_ctx.nsaved);
    DUK_UNREF(p_buf);
    re_ctx.saved = (const duk_uint8_t **) duk_get_buffer(ctx, -1, NULL);
    DUK_ASSERT(re_ctx.saved != NULL);
 
    /* [ ... re_obj input bc saved_buf ] */
 
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    for (i = 0; i < re_ctx.nsaved; i++) {
        re_ctx.saved[i] = (duk_uint8_t *) NULL;
    }
#elif defined(DUK_USE_ZERO_BUFFER_DATA)
    /* buffer is automatically zeroed */
#else
    DUK_MEMZERO((void *) p_buf, sizeof(duk_uint8_t *) * re_ctx.nsaved);
#endif
 
    DUK_DDD(DUK_DDDPRINT("regexp ctx initialized, flags=0x%08lx, nsaved=%ld, recursion_limit=%ld, steps_limit=%ld",
                         (unsigned long) re_ctx.re_flags, (long) re_ctx.nsaved, (long) re_ctx.recursion_limit,
                         (long) re_ctx.steps_limit));
 
    /*
     *  Get starting character offset for match, and initialize 'sp' based on it.
     *
     *  Note: lastIndex is non-configurable so it must be present (we check the
     *  internal class of the object above, so we know it is).  User code can set
     *  its value to an arbitrary (garbage) value though; E5 requires that lastIndex
     *  be coerced to a number before using.  The code below works even if the
     *  property is missing: the value will then be coerced to zero.
     *
     *  Note: lastIndex may be outside Uint32 range even after ToInteger() coercion.
     *  For instance, ToInteger(+Infinity) = +Infinity.  We track the match offset
     *  as an integer, but pre-check it to be inside the 32-bit range before the loop.
     *  If not, the check in E5 Section 15.10.6.2, step 9.a applies.
     */
 
    /* XXX: lastIndex handling produces a lot of asm */
 
    /* [ ... re_obj input bc saved_buf ] */
 
    duk_get_prop_stridx(ctx, -4, DUK_STRIDX_LAST_INDEX);  /* -> [ ... re_obj input bc saved_buf lastIndex ] */
    (void) duk_to_int(ctx, -1);  /* ToInteger(lastIndex) */
    d = duk_get_number(ctx, -1);  /* integer, but may be +/- Infinite, +/- zero (not NaN, though) */
    duk_pop(ctx);
 
    if (global) {
        if (d < 0.0 || d > (double) DUK_HSTRING_GET_CHARLEN(h_input)) {
            /* match fail */
            char_offset = 0;   /* not really necessary */
            DUK_ASSERT(match == 0);
            goto match_over;
        }
        char_offset = (duk_uint32_t) d;
    } else {
        /* lastIndex must be ignored for non-global regexps, but get the
         * value for (theoretical) side effects.  No side effects can
         * really occur, because lastIndex is a normal property and is
         * always non-configurable for RegExp instances.
         */
        char_offset = (duk_uint32_t) 0;
    }
 
    sp = re_ctx.input + duk_heap_strcache_offset_char2byte(thr, h_input, char_offset);
 
    /*
     *  Match loop.
     *
     *  Try matching at different offsets until match found or input exhausted.
     */
 
    /* [ ... re_obj input bc saved_buf ] */
 
    DUK_ASSERT(match == 0);
 
    for (;;) {
        /* char offset in [0, h_input->clen] (both ends inclusive), checked before entry */
        DUK_ASSERT_DISABLE(char_offset >= 0);
        DUK_ASSERT(char_offset <= DUK_HSTRING_GET_CHARLEN(h_input));
 
        /* Note: ctx.steps is intentionally not reset, it applies to the entire unanchored match */
        DUK_ASSERT(re_ctx.recursion_depth == 0);
 
        DUK_DDD(DUK_DDDPRINT("attempt match at char offset %ld; %p [%p,%p]",
                             (long) char_offset, (const void *) sp,
                             (const void *) re_ctx.input, (const void *) re_ctx.input_end));
 
        /*
         *  Note:
         *
         *    - duk__match_regexp() is required not to longjmp() in ordinary "non-match"
         *      conditions; a longjmp() will terminate the entire matching process.
         *
         *    - Clearing saved[] is not necessary because backtracking does it
         *
         *    - Backtracking also rewinds ctx.recursion back to zero, unless an
         *      internal/limit error occurs (which causes a longjmp())
         *
         *    - If we supported anchored matches, we would break out here
         *      unconditionally; however, Ecmascript regexps don't have anchored
         *      matches.  It might make sense to implement a fast bail-out if
         *      the regexp begins with '^' and sp is not 0: currently we'll just
         *      run through the entire input string, trivially failing the match
         *      at every non-zero offset.
         */
 
        if (duk__match_regexp(&re_ctx, re_ctx.bytecode, sp) != NULL) {
            DUK_DDD(DUK_DDDPRINT("match at offset %ld", (long) char_offset));
            match = 1;
            break;
        }
 
        /* advance by one character (code point) and one char_offset */
        char_offset++;
        if (char_offset > DUK_HSTRING_GET_CHARLEN(h_input)) {
            /*
             *  Note:
             *
             *    - Intentionally attempt (empty) match at char_offset == k_input->clen
             *
             *    - Negative char_offsets have been eliminated and char_offset is duk_uint32_t
             *      -> no need or use for a negative check
             */
 
            DUK_DDD(DUK_DDDPRINT("no match after trying all sp offsets"));
            break;
        }
 
        /* avoid calling at end of input, will DUK_ERROR (above check suffices to avoid this) */
        (void) duk__utf8_advance(thr, &sp, re_ctx.input, re_ctx.input_end, (duk_uint_fast32_t) 1);
    }
 
 match_over:
 
    /*
     *  Matching complete, create result array or return a 'null'.  Update lastIndex
     *  if necessary.  See E5 Section 15.10.6.2.
     *
     *  Because lastIndex is a character (not byte) offset, we need the character
     *  length of the match which we conveniently get as a side effect of interning
     *  the matching substring (0th index of result array).
     *
     *  saved[0]         start pointer (~ byte offset) of current match
     *  saved[1]         end pointer (~ byte offset) of current match (exclusive)
     *  char_offset      start character offset of current match (-> .index of result)
     *  char_end_offset  end character offset (computed below)
     */
 
    /* [ ... re_obj input bc saved_buf ] */
 
    if (match) {
#ifdef DUK_USE_ASSERTIONS
        duk_hobject *h_res;
#endif
        duk_uint32_t char_end_offset = 0;
 
        DUK_DDD(DUK_DDDPRINT("regexp matches at char_offset %ld", (long) char_offset));
 
        DUK_ASSERT(re_ctx.nsaved >= 2);        /* must have start and end */
        DUK_ASSERT((re_ctx.nsaved % 2) == 0);  /* and even number */
 
        /* XXX: Array size is known before and (2 * re_ctx.nsaved) but not taken
         * advantage of now.  The array is not compacted either, as regexp match
         * objects are usually short lived.
         */
 
        duk_push_array(ctx);
 
#ifdef DUK_USE_ASSERTIONS
        h_res = duk_require_hobject(ctx, -1);
        DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_res));
        DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_ARRAY(h_res));
        DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_res) == DUK_HOBJECT_CLASS_ARRAY);
#endif
 
        /* [ ... re_obj input bc saved_buf res_obj ] */
 
        duk_push_u32(ctx, char_offset);
        duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INDEX);
 
        duk_dup(ctx, -4);
        duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INPUT);
 
        for (i = 0; i < re_ctx.nsaved; i += 2) {
            /* Captures which are undefined have NULL pointers and are returned
             * as 'undefined'.  The same is done when saved[] pointers are insane
             * (this should, of course, never happen in practice).
             */
            if (re_ctx.saved[i] && re_ctx.saved[i+1] && re_ctx.saved[i+1] >= re_ctx.saved[i]) {
                duk_hstring *h_saved;
 
                duk_push_lstring(ctx,
                                 (const char *) re_ctx.saved[i],
                                 (duk_size_t) (re_ctx.saved[i+1] - re_ctx.saved[i]));
                h_saved = duk_get_hstring(ctx, -1);
                DUK_ASSERT(h_saved != NULL);
 
                if (i == 0) {
                    /* Assumes that saved[0] and saved[1] are always
                     * set by regexp bytecode (if not, char_end_offset
                     * will be zero).  Also assumes clen reflects the
                     * correct char length.
                     */
                    char_end_offset = char_offset + DUK_HSTRING_GET_CHARLEN(h_saved);
                }
            } else {
                duk_push_undefined(ctx);
            }
 
            /* [ ... re_obj input bc saved_buf res_obj val ] */
            duk_put_prop_index(ctx, -2, i / 2);
        }
 
        /* [ ... re_obj input bc saved_buf res_obj ] */
 
        /* NB: 'length' property is automatically updated by the array setup loop */
 
        if (global) {
            /* global regexp: lastIndex updated on match */
            duk_push_u32(ctx, char_end_offset);
            duk_put_prop_stridx(ctx, -6, DUK_STRIDX_LAST_INDEX);
        } else {
            /* non-global regexp: lastIndex never updated on match */
            ;
        }
    } else {
        /*
         *  No match, E5 Section 15.10.6.2, step 9.a.i - 9.a.ii apply, regardless
         *  of 'global' flag of the RegExp.  In particular, if lastIndex is invalid
         *  initially, it is reset to zero.
         */
 
        DUK_DDD(DUK_DDDPRINT("regexp does not match"));
 
        duk_push_null(ctx);
 
        /* [ ... re_obj input bc saved_buf res_obj ] */
 
        duk_push_int(ctx, 0);

◆ duk__remove_matching_hstring_probe()

DUK_LOCAL void duk__remove_matching_hstring_probe	(	duk_heap *	heap,
		duk_hstring **	entries,
		duk_uint32_t	size,
		duk_hstring *	h )

Definition at line 45599 of file duktape-1.8.0/src/duktape.c.

                                                : %ld (step %ld, size %ld)",
                             (long) i, (long) step, (long) size));
        i = (i + step) % size;
 
        /* looping should never happen */
        DUK_ASSERT(i != DUK__HASH_INITIAL(strhash, size));
    }
    DUK_UNREACHABLE();
}
 
#if defined(DUK_USE_HEAPPTR16)
DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_hstring *h) {
#else
DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) {
#endif
    duk_uint32_t i;
    duk_uint32_t step;
    duk_uint32_t hash;
#if defined(DUK_USE_HEAPPTR16)
    duk_uint16_t null16 = heap->heapptr_null16;
    duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
#endif
 
    DUK_ASSERT(size > 0);
 
    hash = DUK_HSTRING_GET_HASH(h);
    i = DUK__HASH_INITIAL(hash, size);
    step = DUK__HASH_PROBE_STEP(hash);
    for (;;) {
#if defined(DUK_USE_HEAPPTR16)
        duk_uint16_t e16 = entries16[i];
#else
        duk_hstring *e = entries[i];
#endif
 
#if defined(DUK_USE_HEAPPTR16)
        if (e16 == null16) {
#else
        if (!e) {
#endif
            DUK_UNREACHABLE();
            break;
        }
#if defined(DUK_USE_HEAPPTR16)
        if (e16 == h16) {
#else
        if (e == h) {
#endif

◆ duk__remove_slice()

DUK_LOCAL void duk__remove_slice	(	duk_re_compiler_ctx *	re_ctx,
		duk_uint32_t	data_offset,
		duk_uint32_t	data_length )

Definition at line 77783 of file duktape-1.8.0/src/duktape.c.

77784 {

77785 /* Call sites don't need the result length so it's not accumulated. */

References duk__append_u32().

Referenced by duk__parse_disjunction().

◆ duk__require_bufobj_this()

DUK_LOCAL duk_hbufferobject * duk__require_bufobj_this ( duk_context * ctx )

Definition at line 21872 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_readfield(), duk_bi_buffer_slice_shared(), and duk_bi_typedarray_set().

◆ duk__require_bufobj_value()

DUK_LOCAL duk_hbufferobject * duk__require_bufobj_value	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 21879 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    return duk__getrequire_bufobj_this(ctx, 0);
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
/* Check that 'this' is a duk_hbufferobject and return a pointer to it
 * (NULL if not).
 */
DUK_LOCAL duk_hbufferobject *duk__require_bufobj_this(duk_context *ctx) {
    return duk__getrequire_bufobj_this(ctx, 1);
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
/* Check that value is a duk_hbufferobject and return a pointer to it. */
DUK_LOCAL duk_hbufferobject *duk__require_bufobj_value(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr;
    duk_tval *tv;
    duk_hbufferobject *h_obj;
 
    thr = (duk_hthread *) ctx;
 

References duk__getrequire_bufobj_this().

◆ duk__reset_func_for_pass2()

DUK_LOCAL_DECL void duk__reset_func_for_pass2 ( duk_compiler_ctx * comp_ctx )

Definition at line 58267 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_compiler_func *func = &comp_ctx->curr_func;
    duk_hthread *thr = comp_ctx->thr;
    duk_context *ctx = (duk_context *) thr;
 
    /* reset bytecode buffer but keep current size; pass 2 will
     * require same amount or more.

Referenced by duk__parse_func_body().

◆ duk__reset_labels_to_length()

DUK_LOCAL_DECL void duk__reset_labels_to_length	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	len )

Definition at line 60430 of file duktape-1.8.0/src/duktape.c.

                {
        DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_LABEL);
    }
 
    DUK_DDD(DUK_DDDPRINT("label match: %!O -> label_id %ld, catch_depth=%ld, pc_label=%ld",
                         (duk_heaphdr *) h_label, (long) li->label_id,
                         (long) li->catch_depth, (long) li->pc_label));
 

◆ duk__resize_strtab_probe()

DUK_LOCAL duk_bool_t duk__resize_strtab_probe ( duk_heap * heap )

Definition at line 45763 of file duktape-1.8.0/src/duktape.c.

             :
    DUK_FREE(heap, new_entries);
    return 1;  /* FAIL */
}
 
DUK_LOCAL duk_bool_t duk__resize_strtab_probe(duk_heap *heap) {
    duk_uint32_t new_size;
    duk_bool_t ret;
 

◆ duk__resize_strtab_raw_probe()

DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe	(	duk_heap *	heap,
		duk_uint32_t	new_size )

Definition at line 45652 of file duktape-1.8.0/src/duktape.c.

                                                   : %ld", (long) i));
#if defined(DUK_USE_HEAPPTR16)
            entries16[i] = heap->heapptr_deleted16;
#else
            entries[i] = DUK__DELETED_MARKER(heap);
#endif
            break;
        }
 
        DUK_DDD(DUK_DDDPRINT("free matching miss: %ld", (long) i));
        i = (i + step) % size;
 
        /* looping should never happen */
        DUK_ASSERT(i != DUK__HASH_INITIAL(hash, size));
    }
}
 
DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size) {
#if defined(DUK_USE_DEBUG)
    duk_uint32_t old_used = heap->st_used;
#endif
    duk_uint32_t old_size = heap->st_size;
#if defined(DUK_USE_HEAPPTR16)
    duk_uint16_t *old_entries = heap->strtable16;
    duk_uint16_t *new_entries = NULL;
#else
    duk_hstring **old_entries = heap->strtable;
    duk_hstring **new_entries = NULL;
#endif
    duk_uint32_t new_used = 0;
    duk_uint32_t i;
 
#if defined(DUK_USE_DEBUG)
    DUK_UNREF(old_used);  /* unused with some debug level combinations */
#endif
 
#ifdef DUK_USE_DDDPRINT
    DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
                         (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
                         (long) (((double) old_used) / ((double) old_size) * 100.0),
                         (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) duk__count_used_probe(heap),
                         (long) (((double) duk__count_used_probe(heap)) / ((double) new_size) * 100.0)));
#endif
 
    DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used_probe(heap));  /* required for rehash to succeed, equality not that useful */
    DUK_ASSERT(old_entries);
 
    /*
     *  The attempt to allocate may cause a GC.  Such a GC must not attempt to resize
     *  the stringtable (though it can be swept); finalizer execution and object
     *  compaction must also be postponed to avoid the pressure to add strings to the
     *  string table.  Call site must prevent these.
     */
 
#if defined(DUK_USE_MARK_AND_SWEEP)
    DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE);
    DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_FINALIZERS);
    DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_OBJECT_COMPACTION);
#endif
 
#if defined(DUK_USE_HEAPPTR16)
    new_entries = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * new_size);
#else
    new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size);
#endif
 
    if (!new_entries) {
        goto resize_error;
    }
 
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    for (i = 0; i < new_size; i++) {
#if defined(DUK_USE_HEAPPTR16)
        new_entries[i] = heap->heapptr_null16;
#else
        new_entries[i] = NULL;
#endif
    }
#else
#if defined(DUK_USE_HEAPPTR16)
    /* Relies on NULL encoding to zero. */
    DUK_MEMZERO(new_entries, sizeof(duk_uint16_t) * new_size);
#else
    DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size);
#endif
#endif
 
    /* Because new_size > duk__count_used_probe(heap), guaranteed to work */
    for (i = 0; i < old_size; i++) {
        duk_hstring *e;
 
#if defined(DUK_USE_HEAPPTR16)
        e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, old_entries[i]);
#else
        e = old_entries[i];
#endif
        if (e == NULL || e == DUK__DELETED_MARKER(heap)) {
            continue;
        }
        /* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */
        duk__insert_hstring_probe(heap, new_entries, new_size, &new_used, e);
    }
 
#ifdef DUK_USE_DDPRINT
    DUK_DD(DUK_DDPRINT("resized stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
                       (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
                       (long) (((double) old_used) / ((double) old_size) * 100.0),
                       (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) new_used,
                       (long) (((double) new_used) / ((double) new_size) * 100.0)));
#endif

◆ duk__resize_valstack()

DUK_LOCAL duk_bool_t duk__resize_valstack	(	duk_context *	ctx,
		duk_size_t	new_size )

Definition at line 15491 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_ptrdiff_t old_bottom_offset;
    duk_ptrdiff_t old_top_offset;
    duk_ptrdiff_t old_end_offset_post;
#ifdef DUK_USE_DEBUG
    duk_ptrdiff_t old_end_offset_pre;
    duk_tval *old_valstack_pre;
    duk_tval *old_valstack_post;
#endif
    duk_tval *new_valstack;
    duk_size_t new_alloc_size;
    duk_tval *p;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
    DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) <= new_size);  /* can't resize below 'top' */
    DUK_ASSERT(new_size <= thr->valstack_max);  /* valstack limit caller has check, prevents wrapping */
    DUK_ASSERT(new_size <= DUK_SIZE_MAX / sizeof(duk_tval));  /* specific assert for wrapping */
 
    /* get pointer offsets for tweaking below */
    old_bottom_offset = (((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack));
    old_top_offset = (((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack));
#ifdef DUK_USE_DEBUG
    old_end_offset_pre = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack));  /* not very useful, used for debugging */
    old_valstack_pre = thr->valstack;
#endif
 
    /* Allocate a new valstack.
     *
     * Note: cannot use a plain DUK_REALLOC() because a mark-and-sweep may
     * invalidate the original thr->valstack base pointer inside the realloc
     * process.  See doc/memory-management.rst.
     */
 
    new_alloc_size = sizeof(duk_tval) * new_size;
    new_valstack = (duk_tval *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_valstack_ptr, (void *) thr, new_alloc_size);
    if (!new_valstack) {
        /* Because new_size != 0, if condition doesn't need to be
         * (new_valstack != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("failed to resize valstack to %lu entries (%lu bytes)",
                         (unsigned long) new_size, (unsigned long) new_alloc_size));
        return 0;
    }
 
    /* Note: the realloc may have triggered a mark-and-sweep which may
     * have resized our valstack internally.  However, the mark-and-sweep
     * MUST NOT leave the stack bottom/top in a different state.  Particular
     * assumptions and facts:
     *
     *   - The thr->valstack pointer may be different after realloc,
     *     and the offset between thr->valstack_end <-> thr->valstack
     *     may have changed.
     *   - The offset between thr->valstack_bottom <-> thr->valstack
     *     and thr->valstack_top <-> thr->valstack MUST NOT have changed,
     *     because mark-and-sweep must adhere to a strict stack policy.
     *     In other words, logical bottom and top MUST NOT have changed.
     *   - All values above the top are unreachable but are initialized
     *     to UNDEFINED, up to the post-realloc valstack_end.
     *   - 'old_end_offset' must be computed after realloc to be correct.
     */
 
    DUK_ASSERT((((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack)) == old_bottom_offset);
    DUK_ASSERT((((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack)) == old_top_offset);
 
    /* success, fixup pointers */
    old_end_offset_post = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack));  /* must be computed after realloc */
#ifdef DUK_USE_DEBUG
    old_valstack_post = thr->valstack;
#endif
    thr->valstack = new_valstack;
    thr->valstack_end = new_valstack + new_size;
#if !defined(DUK_USE_PREFER_SIZE)
    thr->valstack_size = new_size;
#endif
    thr->valstack_bottom = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_bottom_offset);
    thr->valstack_top = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_top_offset);
 
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
    /* useful for debugging */
#ifdef DUK_USE_DEBUG
    if (old_end_offset_pre != old_end_offset_post) {
        DUK_D(DUK_DPRINT("valstack was resized during valstack_resize(), probably by mark-and-sweep; "
                         "end offset changed: %lu -> %lu",
                         (unsigned long) old_end_offset_pre,
                         (unsigned long) old_end_offset_post));
    }
    if (old_valstack_pre != old_valstack_post) {
        DUK_D(DUK_DPRINT("valstack pointer changed during valstack_resize(), probably by mark-and-sweep: %p -> %p",
                         (void *) old_valstack_pre,
                         (void *) old_valstack_post));
    }
#endif
 
    DUK_DD(DUK_DDPRINT("resized valstack to %lu elements (%lu bytes), bottom=%ld, top=%ld, "
                       "new pointers: start=%p end=%p bottom=%p top=%p",
                       (unsigned long) new_size, (unsigned long) new_alloc_size,
                       (long) (thr->valstack_bottom - thr->valstack),
                       (long) (thr->valstack_top - thr->valstack),
                       (void *) thr->valstack, (void *) thr->valstack_end,
                       (void *) thr->valstack_bottom, (void *) thr->valstack_top));
 
    /* Init newly allocated slots (only). */
    p = (duk_tval *) (void *) ((duk_uint8_t *) thr->valstack + old_end_offset_post);

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_D, DUK_DD, DUK_DDPRINT, DUK_DPRINT, duk_hthread_get_valstack_ptr(), DUK_REALLOC_INDIRECT, DUK_SIZE_MAX, duk_hthread::heap, NULL, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, duk_hthread::valstack_size, and duk_hthread::valstack_top.

◆ duk__resolve_offset_opt_length()

DUK_LOCAL void duk__resolve_offset_opt_length	(	duk_context *	ctx,
		duk_hbufferobject *	h_bufarg,
		duk_idx_t	idx_offset,
		duk_idx_t	idx_length,
		duk_uint_t *	out_offset,
		duk_uint_t *	out_length,
		duk_bool_t	throw_flag )

Definition at line 21951 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_hthread *thr;
    duk_int_t offset_signed;
    duk_int_t length_signed;
    duk_uint_t offset;
    duk_uint_t length;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    offset_signed = duk_to_int(ctx, idx_offset);
    if (offset_signed < 0) {
        goto fail_range;
    }
    offset = (duk_uint_t) offset_signed;
    if (offset > h_bufarg->length) {
        goto fail_range;
    }
    DUK_ASSERT_DISABLE(offset >= 0);  /* unsigned */
    DUK_ASSERT(offset <= h_bufarg->length);
 
    if (duk_is_undefined(ctx, idx_length)) {
        DUK_ASSERT(h_bufarg->length >= offset);
        length = h_bufarg->length - offset;  /* >= 0 */
    } else {
        length_signed = duk_to_int(ctx, idx_length);
        if (length_signed < 0) {
            goto fail_range;
        }
        length = (duk_uint_t) length_signed;
        DUK_ASSERT(h_bufarg->length >= offset);
        if (length > h_bufarg->length - offset) {
            /* Unlike for negative arguments, some call sites
             * want length to be clamped if it's positive.
             */

◆ duk__round_fixed()

DUK_LOCAL double duk__round_fixed ( double x )

Definition at line 32625 of file duktape-1.8.0/src/duktape.c.

                          {
        if (DUK_SIGNBIT(x) == 0 || DUK_SIGNBIT(y) == 0) {
            return +0.0;
        } else {
            return -0.0;
        }
    }
#ifdef DUK_USE_MATH_FMAX
    return DUK_FMAX(x, y);
#else
    return (x > y ? x : y);
#endif
}
 
DUK_LOCAL double duk__round_fixed(double x) {
    /* Numbers half-way between integers must be rounded towards +Infinity,
     * e.g. -3.5 must be rounded to -3 (not -4).  When rounded to zero, zero
     * sign must be set appropriately.  E5.1 Section 15.8.2.15.
     *
     * Note that ANSI C round() is "round to nearest integer, away from zero",
     * which is incorrect for negative values.  Here we make do with floor().
     */
 
    duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
    if (c == DUK_FP_NAN || c == DUK_FP_INFINITE || c == DUK_FP_ZERO) {
        return x;
    }
 
    /*
     *  x is finite and non-zero
     *
     *  -1.6 -> floor(-1.1) -> -2
     *  -1.5 -> floor(-1.0) -> -1  (towards +Inf)
     *  -1.4 -> floor(-0.9) -> -1
     *  -0.5 -> -0.0               (special case)
     *  -0.1 -> -0.0               (special case)
     *  +0.1 -> +0.0               (special case)

References DUK_SIGNBIT.

◆ duk__run_object_finalizers()

DUK_LOCAL void duk__run_object_finalizers	(	duk_heap *	heap,
		duk_small_uint_t	flags )

Definition at line 43050 of file duktape-1.8.0/src/duktape.c.

              {
        DUK_HEAPHDR_SET_NEXT(heap, prev, NULL);
    }
    DUK_ASSERT_HEAPHDR_LINKS(heap, prev);
 
#ifdef DUK_USE_DEBUG
    DUK_D(DUK_DPRINT("mark-and-sweep sweep objects (non-string): %ld freed, %ld kept, %ld rescued, %ld queued for finalization",
                     (long) count_free, (long) count_keep, (long) count_rescue, (long) count_finalize));
#endif
    *out_count_keep = count_keep;
}
 
/*
 *  Run (object) finalizers in the "to be finalized" work list.
 */
 
DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap, duk_small_uint_t flags) {
    duk_heaphdr *curr;
    duk_heaphdr *next;
#ifdef DUK_USE_DEBUG
    duk_size_t count = 0;
#endif
    duk_hthread *thr;
 
    DUK_DD(DUK_DDPRINT("duk__run_object_finalizers: %p", (void *) heap));
 
    thr = duk__get_temp_hthread(heap);
    DUK_ASSERT(thr != NULL);
 
    curr = heap->finalize_list;
    while (curr) {
        DUK_DDD(DUK_DDDPRINT("mark-and-sweep finalize: %p", (void *) curr));
 
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);  /* only objects have finalizers */
        DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));                /* flags have been already cleared */
        DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(curr));
        DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
        DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
        DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(curr));  /* No finalizers for ROM objects */
 
        /* Keep heap->finalize_list up-to-date during the list walk.
         * This has no functional impact, but does matter e.g. for
         * duk_push_heapptr() asserts when assertions are enabled.
         */
        heap->finalize_list = curr;
 
        if (DUK_LIKELY((flags & DUK_MS_FLAG_SKIP_FINALIZERS) == 0)) {
            /* Run the finalizer, duk_hobject_run_finalizer() sets FINALIZED.
             * Next mark-and-sweep will collect the object unless it has
             * become reachable (i.e. rescued).  FINALIZED prevents the
             * finalizer from being executed again before that.
             */
            duk_hobject_run_finalizer(thr, (duk_hobject *) curr);  /* must never longjmp */
            DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(curr));
 
            /* XXX: could clear FINALIZED already here; now cleared in
             * next mark-and-sweep.
             */
        } else {
            /* Used during heap destruction: don't actually run finalizers
             * because we're heading into forced finalization.  Instead,
             * queue finalizable objects back to the heap_allocated list.
             */
            DUK_D(DUK_DPRINT("skip finalizers flag set, queue object to heap_allocated without finalizing"));
            DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
        }
 

◆ duk__run_voluntary_gc()

DUK_LOCAL void duk__run_voluntary_gc ( duk_heap * heap )

Definition at line 43639 of file duktape-1.8.0/src/duktape.c.

                                             { \
        (heap)->mark_and_sweep_trigger_counter--; \
        if ((heap)->mark_and_sweep_trigger_counter <= 0) { \

References DUK_DD, DUK_DDPRINT, and DUK_HEAP_HAS_MARKANDSWEEP_RUNNING.

◆ duk__safe_call_adjust_valstack()

DUK_LOCAL void duk__safe_call_adjust_valstack	(	duk_hthread *	thr,
		duk_idx_t	idx_retbase,
		duk_idx_t	num_stack_rets,
		duk_idx_t	num_actual_rets )

Definition at line 55835 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                            {
    duk_context *ctx = (duk_context *) thr;
    duk_idx_t idx_rcbase;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(idx_retbase >= 0);
    DUK_ASSERT(num_stack_rets >= 0);
    DUK_ASSERT(num_actual_rets >= 0);
 
    idx_rcbase = duk_get_top(ctx) - num_actual_rets;  /* base of known return values */
 
    DUK_DDD(DUK_DDDPRINT("adjust valstack after func call: "
                         "num_stack_rets=%ld, num_actual_rets=%ld, stack_top=%ld, idx_retbase=%ld, idx_rcbase=%ld",
                         (long) num_stack_rets, (long) num_actual_rets, (long) duk_get_top(ctx),
                         (long) idx_retbase, (long) idx_rcbase));
 
    DUK_ASSERT(idx_rcbase >= 0);  /* caller must check */
 
    /* Ensure space for final configuration (idx_retbase + num_stack_rets)
     * and intermediate configurations.
     */
    duk_require_stack_top(ctx,
                          (idx_rcbase > idx_retbase ? idx_rcbase : idx_retbase) +
                          num_stack_rets);
 
    /* Chop extra retvals away / extend with undefined. */
    duk_set_top(ctx, idx_rcbase + num_stack_rets);
 
    if (idx_rcbase >= idx_retbase) {
        duk_idx_t count = idx_rcbase - idx_retbase;
        duk_idx_t i;
 
        DUK_DDD(DUK_DDDPRINT("elements at/after idx_retbase have enough to cover func retvals "
                             "(idx_retbase=%ld, idx_rcbase=%ld)", (long) idx_retbase, (long) idx_rcbase));
 
        /* nuke values at idx_retbase to get the first retval (initially
         * at idx_rcbase) to idx_retbase
         */
 
        DUK_ASSERT(count >= 0);
 
        for (i = 0; i < count; i++) {
            /* XXX: inefficient; block remove primitive */
            duk_remove(ctx, idx_retbase);
        }
    } else {
        duk_idx_t count = idx_retbase - idx_rcbase;
        duk_idx_t i;

◆ duk__safe_to_string_raw()

DUK_LOCAL duk_ret_t duk__safe_to_string_raw ( duk_context * ctx )

Definition at line 17057 of file duktape-1.8.0/src/duktape.c.

                                           : d=4.5, t=0.5 -> ret = (4 + 1) & 0xfe = 5 & 0xfe = 4
                                  */
    } else {
        /* Not halfway, round to nearest. */
        ret = (duk_uint8_t) (d + 0.5);
    }

◆ duk__scan_backwards()

DUK_LOCAL const duk_uint8_t * duk__scan_backwards	(	const duk_uint8_t *	p,
		const duk_uint8_t *	q,
		duk_uint_fast32_t	n )

Definition at line 44767 of file duktape-1.8.0/src/duktape.c.

                                                                                                                 {
    while (n > 0) {
        for (;;) {
            p++;
            if (p >= q) {
                return NULL;
            }
            if ((*p & 0xc0) != 0x80) {
                break;
            }
        }
        n--;
    }
    return p;

References NULL.

◆ duk__scan_forwards()

DUK_LOCAL const duk_uint8_t * duk__scan_forwards	(	const duk_uint8_t *	p,
		const duk_uint8_t *	q,
		duk_uint_fast32_t	n )

Definition at line 44751 of file duktape-1.8.0/src/duktape.c.

◆ duk__set_bufobj_buffer()

DUK_LOCAL void duk__set_bufobj_buffer	(	duk_context *	ctx,
		duk_hbufferobject *	h_bufobj,
		duk_hbuffer *	h_val )

Definition at line 21905 of file duktape-1.8.0/src/duktape.c.

                                {
        h_obj = (duk_hbufferobject *) DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h_obj != NULL);
        if (DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_obj)) {
            DUK_ASSERT_HBUFFEROBJECT_VALID(h_obj);
            return h_obj;
        }
    }
 
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_BUFFER);
    return NULL;  /* not reachable */
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
DUK_LOCAL void duk__set_bufobj_buffer(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_hbuffer *h_val) {
    duk_hthread *thr;
 

◆ duk__set_catcher_regs()

DUK_LOCAL void duk__set_catcher_regs	(	duk_hthread *	thr,
		duk_size_t	cat_idx,
		duk_tval *	tv_val_unstable,
		duk_small_uint_t	lj_type )

Definition at line 66225 of file duktape-1.8.0/src/duktape.c.

◆ duk__set_part_helper()

DUK_LOCAL duk_ret_t duk__set_part_helper	(	duk_context *	ctx,
		duk_small_uint_t	flags_and_maxnargs )

Definition at line 25714 of file duktape-1.8.0/src/duktape.c.

                                                                                       : parts[idx_part]);
    return 1;
}
 
/* Helper for component setter calls: check 'this' binding, get the
 * internal time value, split it into parts (either as UTC time or
 * local time), modify one or more components as specified, recompute
 * the time value, set it as the internal value.  Finally, push the
 * new time value as a return value to the value stack and return 1
 * (caller can then tail call us).
 */
DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flags_and_maxnargs) {
    duk_double_t d;
    duk_int_t parts[DUK_DATE_IDX_NUM_PARTS];
    duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS];
    duk_idx_t nargs;
    duk_small_uint_t maxnargs = (duk_small_uint_t) (flags_and_maxnargs >> DUK_DATE_FLAG_VALUE_SHIFT);  /* unpack args */
    duk_small_uint_t idx_first, idx;
    duk_small_uint_t i;
 
    nargs = duk_get_top(ctx);
    d = duk__push_this_get_timeval(ctx, flags_and_maxnargs);
    DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d));
 
    if (DUK_ISFINITE(d)) {
        duk_bi_date_timeval_to_parts(d, parts, dparts, flags_and_maxnargs);
    } else {
        /* NaN timevalue: we need to coerce the arguments, but
         * the resulting internal timestamp needs to remain NaN.
         * This works but is not pretty: parts and dparts will
         * be partially uninitialized, but we only write to them.
         */
    }
 
    /*
     *  Determining which datetime components to overwrite based on
     *  stack arguments is a bit complicated, but important to factor
     *  out from setters themselves for compactness.
     *
     *  If DUK_DATE_FLAG_TIMESETTER, maxnargs indicates setter type:
     *
     *   1 -> millisecond
     *   2 -> second, [millisecond]
     *   3 -> minute, [second], [millisecond]
     *   4 -> hour, [minute], [second], [millisecond]
     *
     *  Else:
     *
     *   1 -> date
     *   2 -> month, [date]
     *   3 -> year, [month], [date]
     *
     *  By comparing nargs and maxnargs (and flags) we know which
     *  components to override.  We rely on part index ordering.
     */
 
    if (flags_and_maxnargs & DUK_DATE_FLAG_TIMESETTER) {
        DUK_ASSERT(maxnargs >= 1 && maxnargs <= 4);
        idx_first = DUK_DATE_IDX_MILLISECOND - (maxnargs - 1);
    } else {
        DUK_ASSERT(maxnargs >= 1 && maxnargs <= 3);
        idx_first = DUK_DATE_IDX_DAY - (maxnargs - 1);
    }
    DUK_ASSERT_DISABLE(idx_first >= 0);  /* unsigned */
    DUK_ASSERT(idx_first < DUK_DATE_IDX_NUM_PARTS);
 
    for (i = 0; i < maxnargs; i++) {
        if ((duk_idx_t) i >= nargs) {
            /* no argument given -> leave components untouched */
            break;
        }
        idx = idx_first + i;
        DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
        DUK_ASSERT(idx < DUK_DATE_IDX_NUM_PARTS);
 
        if (idx == DUK_DATE_IDX_YEAR && (flags_and_maxnargs & DUK_DATE_FLAG_YEAR_FIXUP)) {
            duk__twodigit_year_fixup(ctx, (duk_idx_t) i);
        }
 
        dparts[idx] = duk_to_number(ctx, i);
 
        if (idx == DUK_DATE_IDX_DAY) {
            /* Day-of-month is one-based in the API, but zero-based
             * internally, so fix here.  Note that month is zero-based
             * both in the API and internally.
             */
            /* SCANBUILD: complains about use of uninitialized values.
             * The complaint is correct, but operating in undefined
             * values here is intentional in some cases and the caller

Referenced by duk_bi_date_prototype_set_time().

◆ duk__set_parts_from_args()

DUK_LOCAL void duk__set_parts_from_args	(	duk_context *	ctx,
		duk_double_t *	dparts,
		duk_idx_t	nargs )

Definition at line 25839 of file duktape-1.8.0/src/duktape.c.

                                  {
        return;
    }
    duk_dup(ctx, idx_val);
    duk_to_int(ctx, -1);
    d = duk_get_number(ctx, -1);  /* get as double to handle huge numbers correctly */
    if (d >= 0.0 && d <= 99.0) {
        d += 1900.0;
        duk_push_number(ctx, d);
        duk_replace(ctx, idx_val);
    }
    duk_pop(ctx);
}
 
/* Set datetime parts from stack arguments, defaulting any missing values.
 * Day-of-week is not set; it is not required when setting the time value.
 */
DUK_LOCAL void duk__set_parts_from_args(duk_context *ctx, duk_double_t *dparts, duk_idx_t nargs) {
    duk_double_t d;
    duk_small_uint_t i;
    duk_small_uint_t idx;
 
    /* Causes a ToNumber() coercion, but doesn't break coercion order since
     * year is coerced first anyway.
     */
    duk__twodigit_year_fixup(ctx, 0);
 
    /* There are at most 7 args, but we use 8 here so that also
     * DUK_DATE_IDX_WEEKDAY gets initialized (to zero) to avoid the potential
     * for any Valgrind gripes later.
     */
    for (i = 0; i < 8; i++) {
        /* Note: rely on index ordering */
        idx = DUK_DATE_IDX_YEAR + i;
        if ((duk_idx_t) i < nargs) {
            d = duk_to_number(ctx, (duk_idx_t) i);
            if (idx == DUK_DATE_IDX_DAY) {
                /* Convert day from one-based to zero-based (internal).  This may
                 * cause the day part to be negative, which is OK.
                 */
                d -= 1.0;

◆ duk__set_this_timeval_from_dparts()

DUK_LOCAL_DECL duk_ret_t duk__set_this_timeval_from_dparts	(	duk_context *	ctx,
		duk_double_t *	dparts,
		duk_small_uint_t	flags )

Definition at line 25551 of file duktape-1.8.0/src/duktape.c.

                      {
        *out_tzoffset = tzoffset;
    }
 
    /* [ ... this ] */
    return d;
}
 
DUK_LOCAL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags) {
    return duk__push_this_get_timeval_tzoffset(ctx, flags, NULL);
}
 

◆ duk__settemp_checkmax()

DUK_LOCAL_DECL void duk__settemp_checkmax	(	duk_compiler_ctx *	comp_ctx,
		duk_reg_t	temp_next )

Definition at line 59593 of file duktape-1.8.0/src/duktape.c.

                                                        {  /* == DUK__MAX_TEMPS is OK */
        DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_TEMP_LIMIT);
    }
 
    /* maintain highest 'used' temporary, needed to figure out nregs of function */

References DUK_ERROR_RANGE, DUK_STR_TEMP_LIMIT, and duk_compiler_ctx::thr.

◆ duk__sin()

DUK_LOCAL double duk__sin ( double x )

Definition at line 32762 of file duktape-1.8.0/src/duktape.c.

32764 {

◆ duk__slow_case_conversion()

DUK_LOCAL duk_codepoint_t duk__slow_case_conversion	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_codepoint_t	cp,
		duk_bitdecoder_ctx *	bd_ctx )

Definition at line 10739 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_small_int_t skip = 0;
    duk_small_int_t n;
    duk_small_int_t t;
    duk_small_int_t count;
    duk_codepoint_t tmp_cp;
    duk_codepoint_t start_i;
    duk_codepoint_t start_o;
 
    DUK_UNREF(thr);
    DUK_ASSERT(bd_ctx != NULL);
 
    DUK_DDD(DUK_DDDPRINT("slow case conversion for codepoint: %ld", (long) cp));
 
    /* range conversion with a "skip" */
    DUK_DDD(DUK_DDDPRINT("checking ranges"));
    for (;;) {
        skip++;
        n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6);
        if (n == 0x3f) {
            /* end marker */
            break;
        }
        DUK_DDD(DUK_DDDPRINT("skip=%ld, n=%ld", (long) skip, (long) n));
 
        while (n--) {
            start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
            start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
            count = (duk_small_int_t) duk_bd_decode(bd_ctx, 7);
            DUK_DDD(DUK_DDDPRINT("range: start_i=%ld, start_o=%ld, count=%ld, skip=%ld",
                                 (long) start_i, (long) start_o, (long) count, (long) skip));
 
            if (cp >= start_i) {
                tmp_cp = cp - start_i;  /* always >= 0 */
                if (tmp_cp < (duk_codepoint_t) count * (duk_codepoint_t) skip &&
                    (tmp_cp % (duk_codepoint_t) skip) == 0) {
                    DUK_DDD(DUK_DDDPRINT("range matches input codepoint"));
                    cp = start_o + tmp_cp;
                    goto single;
                }
            }
        }
    }
 
    /* 1:1 conversion */
    n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6);
    DUK_DDD(DUK_DDDPRINT("checking 1:1 conversions (count %ld)", (long) n));
    while (n--) {
        start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
        start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
        DUK_DDD(DUK_DDDPRINT("1:1 conversion %ld -> %ld", (long) start_i, (long) start_o));
        if (cp == start_i) {
            DUK_DDD(DUK_DDDPRINT("1:1 matches input codepoint"));
            cp = start_o;
            goto single;
        }
    }
 
    /* complex, multicharacter conversion */
    n = (duk_small_int_t) duk_bd_decode(bd_ctx, 7);
    DUK_DDD(DUK_DDDPRINT("checking 1:n conversions (count %ld)", (long) n));
    while (n--) {
        start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
        t = (duk_small_int_t) duk_bd_decode(bd_ctx, 2);
        DUK_DDD(DUK_DDDPRINT("1:n conversion %ld -> %ld chars", (long) start_i, (long) t));
        if (cp == start_i) {
            DUK_DDD(DUK_DDDPRINT("1:n matches input codepoint"));
            if (bw != NULL) {
                while (t--) {
                    tmp_cp = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
                    DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) tmp_cp);
                }
            }
            return -1;

References DUK_ASSERT, duk_bd_decode(), DUK_BW_WRITE_RAW_XUTF8, DUK_DDD, DUK_DDDPRINT, DUK_UNREF, and NULL.

◆ duk__sort_array_indices()

DUK_LOCAL void duk__sort_array_indices	(	duk_hthread *	thr,
		duk_hobject *	h_obj )

Definition at line 46437 of file duktape-1.8.0/src/duktape.c.

        ://en.wikipedia.org/wiki/Insertion_sort
 *
 *  (Compiles to about 160 bytes now as a stand-alone function.)
 */
 
DUK_LOCAL void duk__sort_array_indices(duk_hthread *thr, duk_hobject *h_obj) {
    duk_hstring **keys;
    duk_hstring **p_curr, **p_insert, **p_end;
    duk_hstring *h_curr;
    duk_uarridx_t val_highest, val_curr, val_insert;
 
    DUK_ASSERT(h_obj != NULL);
    DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(h_obj) >= 2);  /* control props */
    DUK_UNREF(thr);
 
    if (DUK_HOBJECT_GET_ENEXT(h_obj) <= 1 + DUK__ENUM_START_INDEX) {
        return;
    }
 
    keys = DUK_HOBJECT_E_GET_KEY_BASE(thr->heap, h_obj);
    p_end = keys + DUK_HOBJECT_GET_ENEXT(h_obj);
    keys += DUK__ENUM_START_INDEX;
 
    DUK_DDD(DUK_DDDPRINT("keys=%p, p_end=%p (after skipping enum props)",
                         (void *) keys, (void *) p_end));
 
#ifdef DUK_USE_DDDPRINT
    {
        duk_uint_fast32_t i;
        for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h_obj); i++) {
            DUK_DDD(DUK_DDDPRINT("initial: %ld %p -> %!O",
                                 (long) i,
                                 (void *) DUK_HOBJECT_E_GET_KEY_PTR(thr->heap, h_obj, i),
                                 (duk_heaphdr *) DUK_HOBJECT_E_GET_KEY(thr->heap, h_obj, i)));
        }
    }
#endif
 
    val_highest = DUK_HSTRING_GET_ARRIDX_SLOW(keys[0]);
    for (p_curr = keys + 1; p_curr < p_end; p_curr++) {
        DUK_ASSERT(*p_curr != NULL);
        val_curr = DUK_HSTRING_GET_ARRIDX_SLOW(*p_curr);
 
        if (val_curr >= val_highest) {
            DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> "
                                 "already in correct order, next",
                                 (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr));
            val_highest = val_curr;
            continue;
        }
 
        DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> "
                             "needs to be inserted",
                             (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr));
 
        /* Needs to be inserted; scan backwards, since we optimize
         * for the case where elements are nearly in order.
         */
 
        p_insert = p_curr - 1;
        for (;;) {
            val_insert = DUK_HSTRING_GET_ARRIDX_SLOW(*p_insert);
            if (val_insert < val_curr) {
                DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> insert after this",
                                     (void *) p_insert, (long) val_insert, (long) val_curr));
                p_insert++;
                break;
            }
            if (p_insert == keys) {
                DUK_DDD(DUK_DDDPRINT("p_insert=%p -> out of keys, insert to beginning", (void *) p_insert));
                break;
            }
            DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> search backwards",
                                 (void *) p_insert, (long) val_insert, (long) val_curr));
            p_insert--;
        }
 
        DUK_DDD(DUK_DDDPRINT("final p_insert=%p", (void *) p_insert));
 
        /*        .-- p_insert   .-- p_curr
         *        v              v
         *  | ... | insert | ... | curr
         */
 
        h_curr = *p_curr;
        DUK_DDD(DUK_DDDPRINT("memmove: dest=%p, src=%p, size=%ld, h_curr=%p",
                             (void *) (p_insert + 1), (void *) p_insert,
                             (long) (p_curr - p_insert), (void *) h_curr));
 
        DUK_MEMMOVE((void *) (p_insert + 1),
                    (const void *) p_insert,

References DUK__ENUM_START_INDEX, DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_HOBJECT_E_GET_KEY, DUK_HOBJECT_E_GET_KEY_BASE, DUK_HOBJECT_E_GET_KEY_PTR, DUK_HOBJECT_GET_ENEXT, DUK_HSTRING_GET_ARRIDX_SLOW, DUK_MEMMOVE, DUK_UNREF, duk_hthread::heap, and NULL.

◆ duk__sqrt()

DUK_LOCAL double duk__sqrt ( double x )

Definition at line 32765 of file duktape-1.8.0/src/duktape.c.

32767 {

◆ duk__stmt_label_site()

DUK_LOCAL_DECL duk_int_t duk__stmt_label_site	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	label_id )

Definition at line 63894 of file duktape-1.8.0/src/duktape.c.

◆ duk__sweep_heap()

DUK_LOCAL void duk__sweep_heap	(	duk_heap *	heap,
		duk_int_t	flags,
		duk_size_t *	out_count_keep )

Definition at line 42892 of file duktape-1.8.0/src/duktape.c.

                                                      : %ld freed, %ld kept",
                     (long) count_free, (long) count_keep));
#endif
    *out_count_keep = count_keep;
}
#endif  /* DUK_USE_STRTAB_PROBE */
 
/*
 *  Sweep heap
 */
 
DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep) {
    duk_heaphdr *prev;  /* last element that was left in the heap */
    duk_heaphdr *curr;
    duk_heaphdr *next;
#ifdef DUK_USE_DEBUG
    duk_size_t count_free = 0;
    duk_size_t count_finalize = 0;
    duk_size_t count_rescue = 0;
#endif
    duk_size_t count_keep = 0;
 
    DUK_UNREF(flags);
    DUK_DD(DUK_DDPRINT("duk__sweep_heap: %p", (void *) heap));
 
    prev = NULL;
    curr = heap->heap_allocated;
    heap->heap_allocated = NULL;
    while (curr) {
        /* Strings and ROM objects are never placed on the heap allocated list. */
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_STRING);
        DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(curr));
 
        next = DUK_HEAPHDR_GET_NEXT(heap, curr);
 
        if (DUK_HEAPHDR_HAS_REACHABLE(curr)) {
            /*
             *  Reachable object, keep
             */
 
            DUK_DDD(DUK_DDDPRINT("sweep, reachable: %p", (void *) curr));
 
            if (DUK_HEAPHDR_HAS_FINALIZABLE(curr)) {
                /*
                 *  If object has been marked finalizable, move it to the
                 *  "to be finalized" work list.  It will be collected on
                 *  the next mark-and-sweep if it is still unreachable
                 *  after running the finalizer.
                 */
 
                DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
                DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
                DUK_DDD(DUK_DDDPRINT("object has finalizer, move to finalization work list: %p", (void *) curr));
 
#ifdef DUK_USE_DOUBLE_LINKED_HEAP
                if (heap->finalize_list) {
                    DUK_HEAPHDR_SET_PREV(heap, heap->finalize_list, curr);
                }
                DUK_HEAPHDR_SET_PREV(heap, curr, NULL);
#endif
                DUK_HEAPHDR_SET_NEXT(heap, curr, heap->finalize_list);
                DUK_ASSERT_HEAPHDR_LINKS(heap, curr);
                heap->finalize_list = curr;
#ifdef DUK_USE_DEBUG
                count_finalize++;
#endif
            } else {
                /*
                 *  Object will be kept; queue object back to heap_allocated (to tail)
                 */
 
                if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
                    /*
                     *  Object's finalizer was executed on last round, and
                     *  object has been happily rescued.
                     */
 
                    DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
                    DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
                    DUK_DD(DUK_DDPRINT("object rescued during mark-and-sweep finalization: %p", (void *) curr));
#ifdef DUK_USE_DEBUG
                    count_rescue++;
#endif
                } else {
                    /*
                     *  Plain, boring reachable object.
                     */
                    DUK_DD(DUK_DDPRINT("keep object: %!iO", curr));
                    count_keep++;
                }
 
                if (!heap->heap_allocated) {
                    heap->heap_allocated = curr;
                }
                if (prev) {
                    DUK_HEAPHDR_SET_NEXT(heap, prev, curr);
                }
#ifdef DUK_USE_DOUBLE_LINKED_HEAP
                DUK_HEAPHDR_SET_PREV(heap, curr, prev);
#endif
                DUK_ASSERT_HEAPHDR_LINKS(heap, prev);
                DUK_ASSERT_HEAPHDR_LINKS(heap, curr);
                prev = curr;
            }
 
            DUK_HEAPHDR_CLEAR_REACHABLE(curr);
            DUK_HEAPHDR_CLEAR_FINALIZED(curr);
            DUK_HEAPHDR_CLEAR_FINALIZABLE(curr);
 
            DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));
            DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
            DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
 
            curr = next;
        } else {
            /*
             *  Unreachable object, free
             */
 
            DUK_DDD(DUK_DDDPRINT("sweep, not reachable: %p", (void *) curr));
 
#if defined(DUK_USE_REFERENCE_COUNTING)
            /* Non-zero refcounts should not happen because we refcount
             * finalize all unreachable objects which should cancel out
             * refcounts (even for cycles).
             */
            DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(curr) == 0);
#endif
            DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
 
            if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
                DUK_DDD(DUK_DDDPRINT("finalized object not rescued: %p", (void *) curr));
            }
 
            /* Note: object cannot be a finalizable unreachable object, as
             * they have been marked temporarily reachable for this round,
             * and are handled above.
             */
 
#ifdef DUK_USE_DEBUG
            count_free++;
#endif
 
            /* weak refs should be handled here, but no weak refs for
             * any non-string objects exist right now.
             */
 

◆ duk__sweep_stringtable_probe()

DUK_LOCAL void duk__sweep_stringtable_probe	(	duk_heap *	heap,
		duk_size_t *	out_count_keep )

Definition at line 42819 of file duktape-1.8.0/src/duktape.c.

                                                    {
#if defined(DUK_USE_HEAPPTR16)
                duk__sweep_string_chain16(heap, lst + j, &count_keep, &count_free);
#else
                duk__sweep_string_chain(heap, lst + j, &count_keep, &count_free);
#endif
            }
        }
    }
 
    DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept",
                     (long) count_free, (long) count_keep));
    *out_count_keep = count_keep;
}
#endif  /* DUK_USE_STRTAB_CHAIN */
 
#if defined(DUK_USE_STRTAB_PROBE)
DUK_LOCAL void duk__sweep_stringtable_probe(duk_heap *heap, duk_size_t *out_count_keep) {
    duk_hstring *h;
    duk_uint_fast32_t i;
#ifdef DUK_USE_DEBUG
    duk_size_t count_free = 0;
#endif
    duk_size_t count_keep = 0;
 
    DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap));
 
    for (i = 0; i < heap->st_size; i++) {
#if defined(DUK_USE_HEAPPTR16)
        h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
#else
        h = heap->strtable[i];
#endif
        if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
            continue;
        } else if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
            DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
            count_keep++;
            continue;
        }
 
#ifdef DUK_USE_DEBUG
        count_free++;
#endif
 
#if defined(DUK_USE_REFERENCE_COUNTING)
        /* Non-zero refcounts should not happen for unreachable strings,
         * because we refcount finalize all unreachable objects which
         * should have decreased unreachable string refcounts to zero
         * (even for cycles).
         */
        DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
#endif
 
        DUK_DDD(DUK_DDDPRINT("sweep string, not reachable: %p", (void *) h));
 
        /* deal with weak references first */
        duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
 
        /* remove the string (mark DELETED), could also call
         * duk_heap_string_remove() but that would be slow and
         * pointless because we already know the slot.
         */
#if defined(DUK_USE_HEAPPTR16)
        heap->strtable16[i] = heap->heapptr_deleted16;
#else
        heap->strtable[i] = DUK_STRTAB_DELETED_MARKER(heap);

◆ duk__tag_check()

DUK_LOCAL duk_bool_t duk__tag_check	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_uint_t	tag )

Definition at line 17591 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_is_buffer_data(), and duk_is_function().

◆ duk__tan()

DUK_LOCAL double duk__tan ( double x )

Definition at line 32768 of file duktape-1.8.0/src/duktape.c.

32770 {

◆ duk__timeclip()

DUK_LOCAL duk_double_t duk__timeclip ( duk_double_t x )

Definition at line 25078 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    return (x >= -DUK_DATE_MSEC_100M_DAYS && x <= DUK_DATE_MSEC_100M_DAYS);
}
 
DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_leeway_range(duk_double_t x) {
    return (x >= -DUK_DATE_MSEC_100M_DAYS_LEEWAY && x <= DUK_DATE_MSEC_100M_DAYS_LEEWAY);
}
 
DUK_INTERNAL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t x) {

◆ duk__to_int_uint_helper()

DUK_LOCAL duk_double_t duk__to_int_uint_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk__toint_coercer	coerce_func )

Definition at line 16925 of file duktape-1.8.0/src/duktape.c.

16942 {

◆ duk__to_new_array_length_checked()

DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked ( duk_hthread * thr )

Definition at line 50331 of file duktape-1.8.0/src/duktape.c.

                                 {
        res = (duk_uint32_t) DUK_TVAL_GET_FASTINT_U32(tv);
    } else {
        res = (duk_uint32_t) DUK_TVAL_GET_DOUBLE(tv);
    }
#else
    res = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv);
#endif  /* DUK_USE_FASTINT */
 
    return res;
}
 
DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked(duk_hthread *thr) {
    duk_context *ctx = (duk_context *) thr;
    duk_uint32_t res;

Referenced by duk_hobject_define_property_helper().

◆ duk__to_regexp_helper()

DUK_LOCAL void duk__to_regexp_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_bool_t	force_new )

Definition at line 35148 of file duktape-1.8.0/src/duktape.c.

          :
#ifdef DUK_USE_REGEXP_SUPPORT
    if (is_regexp) {
        duk_pop(ctx);
    }
#endif
 
    return 1;
}
 
/*
 *  Various
 */
 
#ifdef DUK_USE_REGEXP_SUPPORT
DUK_LOCAL void duk__to_regexp_helper(duk_context *ctx, duk_idx_t index, duk_bool_t force_new) {
    duk_hobject *h;
 
    /* Shared helper for match() steps 3-4, search() steps 3-4. */
 
    DUK_ASSERT(index >= 0);

References duk_pop().

◆ duk__to_string_helper()

DUK_LOCAL duk_ret_t duk__to_string_helper	(	duk_context *	ctx,
		duk_small_uint_t	flags )

Definition at line 25626 of file duktape-1.8.0/src/duktape.c.

                                                    {
        DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d",
                    (const char *) yearstr, (int) parts[DUK_DATE_IDX_MONTH], (int) parts[DUK_DATE_IDX_DAY]);
    } else {
        DUK_ASSERT(flags & DUK_DATE_FLAG_TOSTRING_TIME);
        DUK_SPRINTF((char *) out_buf, "%02d:%02d:%02d.%03d%s",
                    (int) parts[DUK_DATE_IDX_HOUR], (int) parts[DUK_DATE_IDX_MINUTE],
                    (int) parts[DUK_DATE_IDX_SECOND], (int) parts[DUK_DATE_IDX_MILLISECOND],
                    (const char *) tzstr);
    }
}
 
/* Helper for string conversion calls: check 'this' binding, get the
 * internal time value, and format date and/or time in a few formats.
 * Return value allows tail calls.
 */
DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t flags) {
    duk_double_t d;
    duk_int_t parts[DUK_DATE_IDX_NUM_PARTS];
    duk_int_t tzoffset;  /* seconds, doesn't fit into 16 bits */
    duk_bool_t rc;
    duk_uint8_t buf[DUK_BI_DATE_ISO8601_BUFSIZE];
 
    DUK_UNREF(rc);  /* unreferenced with some options */
 
    d = duk__push_this_get_timeval_tzoffset(ctx, flags, &tzoffset);
    if (DUK_ISNAN(d)) {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_INVALID_DATE);
        return 1;
    }
    DUK_ASSERT(DUK_ISFINITE(d));
 
    /* formatters always get one-based month/day-of-month */
    duk_bi_date_timeval_to_parts(d, parts, NULL, DUK_DATE_FLAG_ONEBASED);
    DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12);
    DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31);
 
    if (flags & DUK_DATE_FLAG_TOSTRING_LOCALE) {
        /* try locale specific formatter; if it refuses to format the
         * string, fall back to an ISO 8601 formatted value in local
         * time.
         */
#if defined(DUK_USE_DATE_FORMAT_STRING)
        /* Contract, either:
         * - Push string to value stack and return 1
         * - Don't push anything and return 0
         */
 
        rc = DUK_USE_DATE_FORMAT_STRING(ctx, parts, tzoffset, flags);

Referenced by duk_bi_date_prototype_to_json().

◆ duk__toint32_touint32_helper()

DUK_LOCAL duk_double_t duk__toint32_touint32_helper	(	duk_double_t	x,
		duk_bool_t	is_toint32 )

Definition at line 70386 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    /* XXX: fastint */
    duk_double_t d = duk_js_tonumber(thr, tv);  /* invalidates tv */
    return duk_js_tointeger_number(d);
}
 
/*
 *  ToInt32(), ToUint32(), ToUint16()  (E5 Sections 9.5, 9.6, 9.7)
 */
 
/* combined algorithm matching E5 Sections 9.5 and 9.6 */
DUK_LOCAL duk_double_t duk__toint32_touint32_helper(duk_double_t x, duk_bool_t is_toint32) {
    duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t s;
 
    if (c == DUK_FP_NAN || c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
        return 0.0;
    }
 
 
    /* x = sign(x) * floor(abs(x)), i.e. truncate towards zero, keep sign */
    s = (duk_small_int_t) DUK_SIGNBIT(x);
    x = DUK_FLOOR(DUK_FABS(x));
    if (s) {
        x = -x;
    }
 
    /* NOTE: fmod(x) result sign is same as sign of x, which
     * differs from what Javascript wants (see Section 9.6).
     */
 

◆ duk__tonumber_string_raw()

DUK_LOCAL duk_double_t duk__tonumber_string_raw ( duk_hthread * thr )

Definition at line 70245 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    duk_context *ctx = (duk_context *) thr;
    duk_small_uint_t s2n_flags;
    duk_double_t d;
 
    /* Quite lenient, e.g. allow empty as zero, but don't allow trailing
     * garbage.
     */
    s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |

References DUK_S2N_FLAG_ALLOW_EXP, and DUK_S2N_FLAG_TRIM_WHITE.

◆ duk__transform_callback_decode_uri()

DUK_LOCAL void duk__transform_callback_decode_uri	(	duk__transform_context *	tfm_ctx,
		const void *	udata,
		duk_codepoint_t	cp )

Definition at line 28011 of file duktape-1.8.0/src/duktape.c.

                              {
        t = (int) xutf8_buf[i];
        DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr,
                              &tfm_ctx->bw,
                              DUK_ASC_PERCENT,
                              (duk_uint8_t) duk_uc_nybbles[t >> 4],
                                      (duk_uint8_t) duk_uc_nybbles[t & 0x0f]);
    }
 
    return;
 
 uri_error:
    DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input");
}
 
DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) {
    const duk_uint8_t *reserved_table = (const duk_uint8_t *) udata;
    duk_small_uint_t utf8_blen;
    duk_codepoint_t min_cp;
    duk_small_int_t t;  /* must be signed */
    duk_small_uint_t i;
 
    /* Maximum write size: XUTF8 path writes max DUK_UNICODE_MAX_XUTF8_LENGTH,
     * percent escape path writes max two times CESU-8 encoded BMP length.
     */
    DUK_BW_ENSURE(tfm_ctx->thr,
                  &tfm_ctx->bw,
                  (DUK_UNICODE_MAX_XUTF8_LENGTH >= 2 * DUK_UNICODE_MAX_CESU8_BMP_LENGTH ?
                  DUK_UNICODE_MAX_XUTF8_LENGTH : DUK_UNICODE_MAX_CESU8_BMP_LENGTH));
 
    if (cp == (duk_codepoint_t) '%') {
        const duk_uint8_t *p = tfm_ctx->p;
        duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p);  /* bytes left */
 
        DUK_DDD(DUK_DDDPRINT("percent encoding, left=%ld", (long) left));
 
        if (left < 2) {
            goto uri_error;
        }
 
        t = duk__decode_hex_escape(p, 2);
        DUK_DDD(DUK_DDDPRINT("first byte: %ld", (long) t));
        if (t < 0) {
            goto uri_error;
        }
 
        if (t < 0x80) {
            if (DUK__CHECK_BITMASK(reserved_table, t)) {
                /* decode '%xx' to '%xx' if decoded char in reserved set */
                DUK_ASSERT(tfm_ctx->p - 1 >= tfm_ctx->p_start);
                DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr,
                                      &tfm_ctx->bw,
                                      DUK_ASC_PERCENT,
                                      p[0],
                                      p[1]);
            } else {
                DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) t);
            }
            tfm_ctx->p += 2;
            return;
        }
 
        /* Decode UTF-8 codepoint from a sequence of hex escapes.  The
         * first byte of the sequence has been decoded to 't'.
         *
         * Note that UTF-8 validation must be strict according to the
         * specification: E5.1 Section 15.1.3, decode algorithm step
         * 4.d.vii.8.  URIError from non-shortest encodings is also
         * specifically noted in the spec.
         */
 
        DUK_ASSERT(t >= 0x80);
        if (t < 0xc0) {
            /* continuation byte */
            goto uri_error;
        } else if (t < 0xe0) {
            /* 110x xxxx; 2 bytes */
            utf8_blen = 2;
            min_cp = 0x80L;
            cp = t & 0x1f;
        } else if (t < 0xf0) {
            /* 1110 xxxx; 3 bytes */
            utf8_blen = 3;
            min_cp = 0x800L;
            cp = t & 0x0f;
        } else if (t < 0xf8) {
            /* 1111 0xxx; 4 bytes */
            utf8_blen = 4;
            min_cp = 0x10000L;
            cp = t & 0x07;
        } else {
            /* extended utf-8 not allowed for URIs */
            goto uri_error;
        }
 
        if (left < utf8_blen * 3 - 1) {
            /* '%xx%xx...%xx', p points to char after first '%' */
            goto uri_error;
        }
 
        p += 3;
        for (i = 1; i < utf8_blen; i++) {
            /* p points to digit part ('%xy', p points to 'x') */
            t = duk__decode_hex_escape(p, 2);
            DUK_DDD(DUK_DDDPRINT("i=%ld utf8_blen=%ld cp=%ld t=0x%02lx",
                                 (long) i, (long) utf8_blen, (long) cp, (unsigned long) t));
            if (t < 0) {
                goto uri_error;
            }
            if ((t & 0xc0) != 0x80) {
                goto uri_error;
            }
            cp = (cp << 6) + (t & 0x3f);
            p += 3;
        }
        p--;  /* p overshoots */
        tfm_ctx->p = p;
 
        DUK_DDD(DUK_DDDPRINT("final cp=%ld, min_cp=%ld", (long) cp, (long) min_cp));
 
        if (cp < min_cp || cp > 0x10ffffL || (cp >= 0xd800L && cp <= 0xdfffL)) {
            goto uri_error;
        }
 
        /* The E5.1 algorithm checks whether or not a decoded codepoint
         * is below 0x80 and perhaps may be in the "reserved" set.
         * This seems pointless because the single byte UTF-8 case is
         * handled separately, and non-shortest encodings are rejected.
         * So, 'cp' cannot be below 0x80 here, and thus cannot be in
         * the reserved set.
         */
 
        /* utf-8 validation ensures these */
        DUK_ASSERT(cp >= 0x80L && cp <= 0x10ffffL);
 

Referenced by duk_bi_global_object_escape(), and duk_bi_global_object_unescape().

◆ duk__transform_callback_encode_uri()

DUK_LOCAL void duk__transform_callback_encode_uri	(	duk__transform_context *	tfm_ctx,
		const void *	udata,
		duk_codepoint_t	cp )

Definition at line 27949 of file duktape-1.8.0/src/duktape.c.

                                        {
        cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end);
        callback(tfm_ctx, udata, cp);
    }
 
    DUK_BW_COMPACT(thr, &tfm_ctx->bw);
 
    duk_to_string(ctx, -1);
    return 1;
}
 
DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) {
    duk_uint8_t xutf8_buf[DUK_UNICODE_MAX_XUTF8_LENGTH];
    duk_small_int_t len;
    duk_codepoint_t cp1, cp2;
    duk_small_int_t i, t;
    const duk_uint8_t *unescaped_table = (const duk_uint8_t *) udata;
 
    /* UTF-8 encoded bytes escaped as %xx%xx%xx... -> 3 * nbytes.
     * Codepoint range is restricted so this is a slightly too large
     * but doesn't matter.
     */
    DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 3 * DUK_UNICODE_MAX_XUTF8_LENGTH);
 
    if (cp < 0) {
        goto uri_error;
    } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(unescaped_table, cp)) {
        DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp);
        return;
    } else if (cp >= 0xdc00L && cp <= 0xdfffL) {
        goto uri_error;
    } else if (cp >= 0xd800L && cp <= 0xdbffL) {
        /* Needs lookahead */
        if (duk_unicode_decode_xutf8(tfm_ctx->thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end, (duk_ucodepoint_t *) &cp2) == 0) {
            goto uri_error;
        }
        if (!(cp2 >= 0xdc00L && cp2 <= 0xdfffL)) {
            goto uri_error;
        }
        cp1 = cp;
        cp = ((cp1 - 0xd800L) << 10) + (cp2 - 0xdc00L) + 0x10000L;
    } else if (cp > 0x10ffffL) {
        /* Although we can allow non-BMP characters (they'll decode
         * back into surrogate pairs), we don't allow extended UTF-8
         * characters; they would encode to URIs which won't decode
         * back because of strict UTF-8 checks in URI decoding.
         * (However, we could just as well allow them here.)
         */
        goto uri_error;
    } else {
        /* Non-BMP characters within valid UTF-8 range: encode as is.
         * They'll decode back into surrogate pairs if the escaped
         * output is decoded.
         */
        ;

◆ duk__transform_callback_escape()

DUK_LOCAL void duk__transform_callback_escape	(	duk__transform_context *	tfm_ctx,
		const void *	udata,
		duk_codepoint_t	cp )

Definition at line 28150 of file duktape-1.8.0/src/duktape.c.

               {
            DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp);
        }
    } else {
        DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp);
    }
    return;
 
 uri_error:
    DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input");
}
 
#ifdef DUK_USE_SECTION_B
DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) {
    DUK_UNREF(udata);
 
    DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 6);
 
    if (cp < 0) {
        goto esc_error;
    } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(duk__escape_unescaped_table, cp)) {
        DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp);
    } else if (cp < 0x100L) {
        DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr,
                              &tfm_ctx->bw,
                              (duk_uint8_t) DUK_ASC_PERCENT,
                              (duk_uint8_t) duk_uc_nybbles[cp >> 4],
                              (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]);
    } else if (cp < 0x10000L) {
        DUK_BW_WRITE_RAW_U8_6(tfm_ctx->thr,
                              &tfm_ctx->bw,
                              (duk_uint8_t) DUK_ASC_PERCENT,
                              (duk_uint8_t) DUK_ASC_LC_U,
                              (duk_uint8_t) duk_uc_nybbles[cp >> 12],

◆ duk__transform_callback_unescape()

DUK_LOCAL void duk__transform_callback_unescape	(	duk__transform_context *	tfm_ctx,
		const void *	udata,
		duk_codepoint_t	cp )

Definition at line 28189 of file duktape-1.8.0/src/duktape.c.

           {
        /* Characters outside BMP cannot be escape()'d.  We could
         * encode them as surrogate pairs (for codepoints inside
         * valid UTF-8 range, but not extended UTF-8).  Because
         * escape() and unescape() are legacy functions, we don't.
         */
        goto esc_error;
    }
 
    return;
 
 esc_error:
    DUK_ERROR_TYPE(tfm_ctx->thr, "invalid input");
}
 
DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) {
    duk_small_int_t t;
 
    DUK_UNREF(udata);
 

Referenced by duk_bi_global_object_print_helper().

◆ duk__transform_helper()

DUK_LOCAL int duk__transform_helper	(	duk_context *	ctx,
		duk__transform_callback	callback,
		const void *	udata )

Definition at line 27921 of file duktape-1.8.0/src/duktape.c.

                                                                                          {
    duk_small_int_t ch;
    duk_small_int_t t = 0;
 
    while (n > 0) {
        t = t * 16;
        ch = (duk_small_int_t) duk_hex_dectab[*p++];
        if (DUK_LIKELY(ch >= 0)) {
            t += ch;
        } else {
            return -1;
        }
        n--;
    }
    return t;
}
 
DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, const void *udata) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk__transform_context tfm_ctx_alloc;
    duk__transform_context *tfm_ctx = &tfm_ctx_alloc;
    duk_codepoint_t cp;
 
    tfm_ctx->thr = thr;
 
    tfm_ctx->h_str = duk_to_hstring(ctx, 0);
    DUK_ASSERT(tfm_ctx->h_str != NULL);

References duk_hex_dectab, and DUK_LIKELY.

Referenced by duk_bi_global_object_escape(), duk_bi_global_object_print_helper(), and duk_bi_global_object_unescape().

◆ duk__try_push_vsprintf()

DUK_LOCAL duk_int_t duk__try_push_vsprintf	(	duk_context *	ctx,
		void *	buf,
		duk_size_t	sz,
		const char *	fmt,
		va_list	ap )

Definition at line 18461 of file duktape-1.8.0/src/duktape.c.

                                                                                   {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_ASSERT_CTX_VALID(ctx);
    if (!target_ctx) {
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
        return;  /* not reached */
    }
    duk_push_hobject(ctx, (duk_hobject *) target_ctx);
    duk__push_stash(ctx);
}
 

◆ duk__tval_number_to_arr_idx()

DUK_LOCAL duk_uint32_t duk__tval_number_to_arr_idx ( duk_tval * tv )

Definition at line 47520 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_double_t dbl;
    duk_uint32_t idx;

Referenced by duk__getprop_shallow_fastpath_array_tval(), and duk_hobject_putprop().

◆ duk__twodigit_year_fixup()

DUK_LOCAL_DECL void duk__twodigit_year_fixup	(	duk_context *	ctx,
		duk_idx_t	idx_val )

Definition at line 25813 of file duktape-1.8.0/src/duktape.c.

                         {
        return duk__set_this_timeval_from_dparts(ctx, dparts, flags_and_maxnargs);
    } else {
        /* Internal timevalue is already NaN, so don't touch it. */
        duk_push_nan(ctx);
        return 1;
    }
}
 
/* Apply ToNumber() to specified index; if ToInteger(val) in [0,99], add
 * 1900 and replace value at idx_val.
 */
DUK_LOCAL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val) {
    duk_double_t d;
 
    /* XXX: idx_val would fit into 16 bits, but using duk_small_uint_t
     * might not generate better code due to casting.

◆ duk__unemit_1()

DUK_LOCAL_DECL void duk__unemit_1 ( duk_json_enc_ctx * js_ctx )

Definition at line 30173 of file duktape-1.8.0/src/duktape.c.

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

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

◆ duk__uni_decode_value()

DUK_LOCAL duk_uint32_t duk__uni_decode_value ( duk_bitdecoder_ctx * bd_ctx )

Definition at line 10331 of file duktape-1.8.0/src/duktape.c.

10348 {

10349 duk_uint32_t t;

◆ duk__uni_range_match()

DUK_LOCAL duk_small_int_t duk__uni_range_match	(	const duk_uint8_t *	unitab,
		duk_size_t	unilen,
		duk_codepoint_t	cp )

Definition at line 10351 of file duktape-1.8.0/src/duktape.c.

                    {
        return t;
    }
    t = (duk_uint32_t) duk_bd_decode(bd_ctx, 8);
    if (t <= 0xfdU) {
        return t + 0x0f;
    }
    if (t == 0xfeU) {
        t = (duk_uint32_t) duk_bd_decode(bd_ctx, 12);
        return t + 0x0fU + 0xfeU;
    } else {
        t = (duk_uint32_t) duk_bd_decode(bd_ctx, 24);
        return t + 0x0fU + 0xfeU + 0x1000UL;
    }
}
 
DUK_LOCAL duk_small_int_t duk__uni_range_match(const duk_uint8_t *unitab, duk_size_t unilen, duk_codepoint_t cp) {
    duk_bitdecoder_ctx bd_ctx;
    duk_codepoint_t prev_re;
 
    DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
    bd_ctx.data = (const duk_uint8_t *) unitab;
    bd_ctx.length = (duk_size_t) unilen;
 
    prev_re = 0;
    for (;;) {
        duk_codepoint_t r1, r2;
        r1 = (duk_codepoint_t) duk__uni_decode_value(&bd_ctx);
        if (r1 == 0) {
            break;
        }

◆ duk__update_label_flags()

DUK_LOCAL_DECL void duk__update_label_flags	(	duk_compiler_ctx *	comp_ctx,
		duk_int_t	label_id,
		duk_small_uint_t	flags )

Definition at line 60316 of file duktape-1.8.0/src/duktape.c.

                                          : flags=0x%08lx, id=%ld, name=%!O, catch_depth=%ld, pc_label=%ld",
                         (unsigned long) li->flags, (long) li->label_id, (duk_heaphdr *) li->h_label,
                         (long) li->catch_depth, (long) li->pc_label));
}
 
/* Update all labels with matching label_id. */
DUK_LOCAL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags) {
    duk_uint8_t *p;
    duk_labelinfo *li_start, *li;
 
    p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, comp_ctx->curr_func.h_labelinfos);
    li_start = (duk_labelinfo *) (void *) p;
    li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
 

◆ duk__update_lineinfo_currtoken()

DUK_LOCAL void duk__update_lineinfo_currtoken ( duk_compiler_ctx * comp_ctx )

Definition at line 58820 of file duktape-1.8.0/src/duktape.c.

                                                          {
        goto fail_bc_limit;
    }
#endif
#endif
 
    return;
 
  fail_bc_limit:
    DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_BYTECODE_LIMIT);
}
 
/* Update function min/max line from current token.  Needed to improve
 * function line range information for debugging, so that e.g. opening
 * curly brace is covered by line range even when no opcodes are emitted
 * for the line containing the brace.
 */
DUK_LOCAL void duk__update_lineinfo_currtoken(duk_compiler_ctx *comp_ctx) {

Referenced by duk__parse_func_body().

◆ duk__utf8_advance()

DUK_LOCAL const duk_uint8_t * duk__utf8_advance	(	duk_hthread *	thr,
		const duk_uint8_t **	ptr,
		const duk_uint8_t *	ptr_start,
		const duk_uint8_t *	ptr_end,
		duk_uint_fast32_t	count )

Definition at line 78800 of file duktape-1.8.0/src/duktape.c.

                                     {
                /* utf-8 continuation bytes have the form 10xx xxxx */
                break;
            }
        }
        count--;
    }
    *ptr = p;
    return p;
 
 fail:
    DUK_ERROR_INTERNAL_DEFMSG(thr);
    return NULL;  /* never here */
}
 
DUK_LOCAL const duk_uint8_t *duk__utf8_advance(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count) {
    const duk_uint8_t *p;
 
    p = *ptr;
    if (p < ptr_start || p >= ptr_end) {
        goto fail;
    }
 
    while (count > 0) {
        for (;;) {
            p++;
 
            /* Note: if encoding ends by hitting end of input, we don't check that

◆ duk__utf8_backtrack()

DUK_LOCAL const duk_uint8_t * duk__utf8_backtrack	(	duk_hthread *	thr,
		const duk_uint8_t **	ptr,
		const duk_uint8_t *	ptr_start,
		const duk_uint8_t *	ptr_end,
		duk_uint_fast32_t	count )

Definition at line 78770 of file duktape-1.8.0/src/duktape.c.

                                                                                           {
    return (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end);
}
 
DUK_LOCAL duk_int32_t duk__bc_get_i32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc) {
    duk_uint32_t t;
 
    /* signed integer encoding needed to work with UTF-8 */
    t = (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end);
    if (t & 1) {
        return -((duk_int32_t) (t >> 1));
    } else {
        return (duk_int32_t) (t >> 1);
    }
}
 
DUK_LOCAL const duk_uint8_t *duk__utf8_backtrack(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count) {
    const duk_uint8_t *p;
 
    /* Note: allow backtracking from p == ptr_end */
    p = *ptr;
    if (p < ptr_start || p > ptr_end) {
        goto fail;
    }
 
    while (count > 0) {
        for (;;) {
            p--;

References duk_re_matcher_ctx::bytecode, duk_re_matcher_ctx::bytecode_end, duk_unicode_decode_xutf8_checked(), and duk_re_matcher_ctx::thr.

◆ duk__vm_arith_add()

DUK_LOCAL void duk__vm_arith_add	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_small_uint_fast_t	idx_z )

Definition at line 65621 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    /*
     *  Ecmascript modulus ('%') does not match IEEE 754 "remainder"
     *  operation (implemented by remainder() in C99) but does seem
     *  to match ANSI C fmod().
     *
     *  Compare E5 Section 11.5.3 and "man fmod".
     */
 
    return (duk_double_t) DUK_FMOD((double) d1, (double) d2);
}
 
DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z) {
    /*
     *  Addition operator is different from other arithmetic
     *  operations in that it also provides string concatenation.
     *  Hence it is implemented separately.
     *
     *  There is a fast path for number addition.  Other cases go
     *  through potentially multiple coercions as described in the
     *  E5 specification.  It may be possible to reduce the number
     *  of coercions, but this must be done carefully to preserve
     *  the exact semantics.
     *
     *  E5 Section 11.6.1.
     *
     *  Custom types also have special behavior implemented here.
     */
 
    duk_context *ctx = (duk_context *) thr;
    duk_double_union du;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
    DUK_ASSERT(tv_y != NULL);  /* may be reg or const */
    DUK_ASSERT_DISABLE(idx_z >= 0);  /* unsigned */
    DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
 
    /*
     *  Fast paths
     */
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        duk_int64_t v1, v2, v3;
        duk_int32_t v3_hi;
        duk_tval *tv_z;
 
        /* Input values are signed 48-bit so we can detect overflow
         * reliably from high bits or just a comparison.
         */
 
        v1 = DUK_TVAL_GET_FASTINT(tv_x);
        v2 = DUK_TVAL_GET_FASTINT(tv_y);
        v3 = v1 + v2;
        v3_hi = (duk_int32_t) (v3 >> 32);
        if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) {
            tv_z = thr->valstack_bottom + idx_z;
            DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, v3);  /* side effects */
            return;
        } else {
            /* overflow, fall through */
            ;
        }
    }
#endif  /* DUK_USE_FASTINT */
 
    if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
        duk_tval *tv_z;
 
        du.d = DUK_TVAL_GET_NUMBER(tv_x) + DUK_TVAL_GET_NUMBER(tv_y);
        DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
        DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
 
        tv_z = thr->valstack_bottom + idx_z;
        DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, du.d);  /* side effects */
        return;
    }
 
    /*
     *  Slow path: potentially requires function calls for coercion
     */
 
    duk_push_tval(ctx, tv_x);
    duk_push_tval(ctx, tv_y);
    duk_to_primitive(ctx, -2, DUK_HINT_NONE);  /* side effects -> don't use tv_x, tv_y after */
    duk_to_primitive(ctx, -1, DUK_HINT_NONE);
 
    /* As a first approximation, buffer values are coerced to strings
     * for addition.  This means that adding two buffers currently
     * results in a string.
     */
    if (duk_check_type_mask(ctx, -2, DUK_TYPE_MASK_STRING | DUK_TYPE_MASK_BUFFER) ||
        duk_check_type_mask(ctx, -1, DUK_TYPE_MASK_STRING | DUK_TYPE_MASK_BUFFER)) {
        duk_to_string(ctx, -2);
        duk_to_string(ctx, -1);
        duk_concat(ctx, 2);  /* [... s1 s2] -> [... s1+s2] */
        duk_replace(ctx, (duk_idx_t) idx_z);  /* side effects */
    } else {
        duk_double_t d1, d2;

References DUK_FMOD.

◆ duk__vm_arith_binary_op()

DUK_LOCAL void duk__vm_arith_binary_op	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_idx_t	idx_z,
		duk_small_uint_fast_t	opcode )

Definition at line 65728 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                        {
    /*
     *  Arithmetic operations other than '+' have number-only semantics
     *  and are implemented here.  The separate switch-case here means a
     *  "double dispatch" of the arithmetic opcode, but saves code space.
     *
     *  E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3.
     */
 
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_z;
    duk_double_t d1, d2;
    duk_double_union du;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
    DUK_ASSERT(tv_y != NULL);  /* may be reg or const */
    DUK_ASSERT_DISABLE(idx_z >= 0);  /* unsigned */
    DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        duk_int64_t v1, v2, v3;
        duk_int32_t v3_hi;
 
        v1 = DUK_TVAL_GET_FASTINT(tv_x);
        v2 = DUK_TVAL_GET_FASTINT(tv_y);
 
        switch (opcode) {
        case DUK_OP_SUB: {
            v3 = v1 - v2;
            break;
        }
        case DUK_OP_MUL: {
            /* Must ensure result is 64-bit (no overflow); a
             * simple and sufficient fast path is to allow only
             * 32-bit inputs.  Avoid zero inputs to avoid
             * negative zero issues (-1 * 0 = -0, for instance).
             */
            if (v1 >= -0x80000000LL && v1 <= 0x7fffffffLL && v1 != 0 &&
                v2 >= -0x80000000LL && v2 <= 0x7fffffffLL && v2 != 0) {
                v3 = v1 * v2;
            } else {
                goto skip_fastint;
            }
            break;
        }
        case DUK_OP_DIV: {
            /* Don't allow a zero divisor.  Fast path check by
             * "verifying" with multiplication.  Also avoid zero
             * dividend to avoid negative zero issues (0 / -1 = -0
             * for instance).
             */
            if (v1 == 0 || v2 == 0) {
                goto skip_fastint;
            }
            v3 = v1 / v2;
            if (v3 * v2 != v1) {
                goto skip_fastint;
            }
            break;
        }
        case DUK_OP_MOD: {
            /* Don't allow a zero divisor.  Restrict both v1 and
             * v2 to positive values to avoid compiler specific
             * behavior.
             */
            if (v1 < 1 || v2 < 1) {
                goto skip_fastint;
            }
            v3 = v1 % v2;
            DUK_ASSERT(v3 >= 0);
            DUK_ASSERT(v3 < v2);
            DUK_ASSERT(v1 - (v1 / v2) * v2 == v3);
            break;
        }
        default: {
            DUK_UNREACHABLE();
            goto skip_fastint;
        }
        }
 
        v3_hi = (duk_int32_t) (v3 >> 32);
        if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) {
            tv_z = thr->valstack_bottom + idx_z;
            DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, v3);  /* side effects */
            return;
        }
        /* fall through if overflow etc */
    }
 skip_fastint:
#endif  /* DUK_USE_FASTINT */
 
    if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
        /* fast path */
        d1 = DUK_TVAL_GET_NUMBER(tv_x);
        d2 = DUK_TVAL_GET_NUMBER(tv_y);
    } else {
        duk_push_tval(ctx, tv_x);
        duk_push_tval(ctx, tv_y);
        d1 = duk_to_number(ctx, -2);  /* side effects */
        d2 = duk_to_number(ctx, -1);
        DUK_ASSERT(duk_is_number(ctx, -2));
        DUK_ASSERT(duk_is_number(ctx, -1));
        DUK_ASSERT_DOUBLE_IS_NORMALIZED(d1);
        DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2);
        duk_pop_2(ctx);
    }
 
    switch (opcode) {
    case DUK_OP_SUB: {
        du.d = d1 - d2;
        break;
    }
    case DUK_OP_MUL: {
        du.d = d1 * d2;
        break;
    }
    case DUK_OP_DIV: {
        du.d = d1 / d2;
        break;
    }
    case DUK_OP_MOD: {

◆ duk__vm_arith_unary_op()

DUK_LOCAL void duk__vm_arith_unary_op	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_idx_t	idx_x,
		duk_small_uint_fast_t	opcode )

Definition at line 65990 of file duktape-1.8.0/src/duktape.c.

                   :
    tv_z = thr->valstack_bottom + idx_z;
    DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, fi3);  /* side effects */
#else
    d3 = (duk_double_t) i3;
 
 result_set:
    DUK_ASSERT(!DUK_ISNAN(d3));            /* 'd3' is never NaN, so no need to normalize */
    DUK_ASSERT_DOUBLE_IS_NORMALIZED(d3);   /* always normalized */
 
    tv_z = thr->valstack_bottom + idx_z;
    DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, d3);  /* side effects */
#endif
}
 
/* In-place unary operation. */
DUK_LOCAL void duk__vm_arith_unary_op(duk_hthread *thr, duk_tval *tv_x, duk_idx_t idx_x, duk_small_uint_fast_t opcode) {
    /*
     *  Arithmetic operations other than '+' have number-only semantics
     *  and are implemented here.  The separate switch-case here means a
     *  "double dispatch" of the arithmetic opcode, but saves code space.
     *
     *  E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3.
     */
 
    duk_context *ctx = (duk_context *) thr;
    duk_double_t d1;
    duk_double_union du;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(opcode == DUK_EXTRAOP_UNM || opcode == DUK_EXTRAOP_UNP);
    DUK_ASSERT(tv_x != NULL);
    DUK_ASSERT(idx_x >= 0);
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x)) {
        duk_int64_t v1, v2;
 
        v1 = DUK_TVAL_GET_FASTINT(tv_x);
        if (opcode == DUK_EXTRAOP_UNM) {
            /* The smallest fastint is no longer 48-bit when
             * negated.  Positive zero becames negative zero
             * (cannot be represented) when negated.
             */
            if (DUK_LIKELY(v1 != DUK_FASTINT_MIN && v1 != 0)) {
                v2 = -v1;
                DUK_TVAL_SET_FASTINT(tv_x, v2);  /* no refcount changes */
                return;
            }
        } else {
            /* ToNumber() for a fastint is a no-op. */
            DUK_ASSERT(opcode == DUK_EXTRAOP_UNP);
            return;
        }
        /* fall through if overflow etc */
    }
#endif  /* DUK_USE_FASTINT */
 
    if (!DUK_TVAL_IS_NUMBER(tv_x)) {
        duk_to_number(ctx, idx_x);  /* side effects, perform in-place */
        tv_x = DUK_GET_TVAL_POSIDX(ctx, idx_x);
        DUK_ASSERT(tv_x != NULL);
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
    }
 
    d1 = DUK_TVAL_GET_NUMBER(tv_x);
    if (opcode == DUK_EXTRAOP_UNM) {
        du.d = -d1;
    } else {

◆ duk__vm_bitwise_binary_op()

DUK_LOCAL void duk__vm_bitwise_binary_op	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_small_uint_fast_t	idx_z,
		duk_small_uint_fast_t	opcode )

Definition at line 65870 of file duktape-1.8.0/src/duktape.c.

           : {
        DUK_UNREACHABLE();
        du.d = DUK_DOUBLE_NAN;  /* should not happen */
        break;
    }
    }
 
    /* important to use normalized NaN with 8-byte tagged types */
    DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
    DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
 
    tv_z = thr->valstack_bottom + idx_z;
    DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, du.d);  /* side effects */
}
 
DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z, duk_small_uint_fast_t opcode) {
    /*
     *  Binary bitwise operations use different coercions (ToInt32, ToUint32)
     *  depending on the operation.  We coerce the arguments first using
     *  ToInt32(), and then cast to an 32-bit value if necessary.  Note that
     *  such casts must be correct even if there is no native 32-bit type
     *  (e.g., duk_int32_t and duk_uint32_t are 64-bit).
     *
     *  E5 Sections 11.10, 11.7.1, 11.7.2, 11.7.3
     */
 
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_z;
    duk_int32_t i1, i2, i3;
    duk_uint32_t u1, u2, u3;
#if defined(DUK_USE_FASTINT)
    duk_int64_t fi3;
#else
    duk_double_t d3;
#endif
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
    DUK_ASSERT(tv_y != NULL);  /* may be reg or const */
    DUK_ASSERT_DISABLE(idx_z >= 0);  /* unsigned */
    DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x);
        i2 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_y);
    }
    else
#endif  /* DUK_USE_FASTINT */
    {
        duk_push_tval(ctx, tv_x);
        duk_push_tval(ctx, tv_y);
        i1 = duk_to_int32(ctx, -2);
        i2 = duk_to_int32(ctx, -1);
        duk_pop_2(ctx);
    }
 
    switch (opcode) {
    case DUK_OP_BAND: {
        i3 = i1 & i2;
        break;
    }
    case DUK_OP_BOR: {
        i3 = i1 | i2;
        break;
    }
    case DUK_OP_BXOR: {
        i3 = i1 ^ i2;
        break;
    }
    case DUK_OP_BASL: {
        /* Signed shift, named "arithmetic" (asl) because the result
         * is signed, e.g. 4294967295 << 1 -> -2.  Note that result
         * must be masked.
         */
 
        u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
        i3 = (duk_int32_t) (((duk_uint32_t) i1) << (u2 & 0x1fUL));  /* E5 Section 11.7.1, steps 7 and 8 */
        i3 = i3 & ((duk_int32_t) 0xffffffffUL);                     /* Note: left shift, should mask */
        break;
    }
    case DUK_OP_BASR: {
        /* signed shift */
 
        u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
        i3 = i1 >> (u2 & 0x1fUL);                      /* E5 Section 11.7.2, steps 7 and 8 */
        break;
    }
    case DUK_OP_BLSR: {
        /* unsigned shift */
 
        u1 = ((duk_uint32_t) i1) & 0xffffffffUL;
        u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
 
        /* special result value handling */
        u3 = u1 >> (u2 & 0x1fUL);     /* E5 Section 11.7.2, steps 7 and 8 */
#if defined(DUK_USE_FASTINT)
        fi3 = (duk_int64_t) u3;
        goto fastint_result_set;
#else
        d3 = (duk_double_t) u3;
        goto result_set;
#endif
    }
    default: {
        DUK_UNREACHABLE();
        i3 = 0;  /* should not happen */
        break;
    }
    }
 
#if defined(DUK_USE_FASTINT)
    /* Result is always fastint compatible. */
    /* XXX: Set 32-bit result (but must then handle signed and
     * unsigned results separately).

◆ duk__vm_bitwise_not()

DUK_LOCAL void duk__vm_bitwise_not	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_uint_fast_t	idx_z )

Definition at line 66062 of file duktape-1.8.0/src/duktape.c.

                                                                                            {
    /*
     *  E5 Section 11.4.8
     */
 
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_z;
    duk_int32_t i1, i2;
#if !defined(DUK_USE_FASTINT)
    duk_double_t d2;
#endif
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
    DUK_ASSERT_DISABLE(idx_z >= 0);
    DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x)) {
        i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x);
    }
    else
#endif  /* DUK_USE_FASTINT */
    {
        duk_push_tval(ctx, tv_x);
        i1 = duk_to_int32(ctx, -1);
        duk_pop(ctx);
    }

◆ duk__vm_logical_not()

DUK_LOCAL void duk__vm_logical_not	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_z )

Definition at line 66109 of file duktape-1.8.0/src/duktape.c.

                                                                                     {
    /*
     *  E5 Section 11.4.9
     */
 

◆ duk__year_from_day()

DUK_LOCAL duk_int_t duk__year_from_day	(	duk_int_t	day,
		duk_small_int_t *	out_day_within_year )

Definition at line 25119 of file duktape-1.8.0/src/duktape.c.

                                                       {
    /* Note: in integer arithmetic, (x / 4) is same as floor(x / 4) for non-negative
     * values, but is incorrect for negative ones.
     */
    return 365 * (year - 1970)
           + duk__div_floor(year - 1969, 4)
           - duk__div_floor(year - 1901, 100)
           + duk__div_floor(year - 1601, 400);
}
 
/* Given a day number, determine year and day-within-year. */
DUK_LOCAL duk_int_t duk__year_from_day(duk_int_t day, duk_small_int_t *out_day_within_year) {
    duk_int_t year;
    duk_int_t diff_days;
 
    /* estimate year upwards (towards positive infinity), then back down;
     * two iterations should be enough
     */
 
    if (day >= 0) {
        year = 1970 + day / 365;
    } else {
        year = 1970 + day / 366;
    }
 
    for (;;) {
        diff_days = duk__day_from_year(year) - day;

◆ duk_alloc()

DUK_EXTERNAL void * duk_alloc	(	duk_context *	ctx,
		duk_size_t	size )

Definition at line 14320 of file duktape-1.8.0/src/duktape.c.

                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    DUK_FREE_RAW(thr->heap, ptr);

References DUK_ASSERT_CTX_VALID, DUK_FREE_RAW, and duk_hthread::heap.

◆ duk_alloc_raw()

DUK_EXTERNAL void * duk_alloc_raw	(	duk_context *	ctx,
		duk_size_t	size )

Definition at line 14296 of file duktape-1.8.0/src/duktape.c.

                                                                                   {
    va_list ap;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    va_start(ap, fmt);

References DUK_ASSERT_CTX_VALID, and duk_log_va().

◆ duk_base64_decode()

DUK_EXTERNAL void duk_base64_decode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13353 of file duktape-1.8.0/src/duktape.c.

                               {
        goto type_error;
    }
    dstlen = (srclen + 2) / 3 * 4;
    dst = (duk_uint8_t *) duk_push_fixed_buffer(ctx, dstlen);
 
    duk__base64_encode_helper((const duk_uint8_t *) src, srclen, dst);
 
    ret = duk_to_string(ctx, -1);
    duk_replace(ctx, index);
    return ret;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_ENCODE_FAILED);
    return NULL;  /* never here */
}
 
DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    const duk_uint8_t *src;
    duk_size_t srclen;
    duk_size_t dstlen;
    duk_uint8_t *dst;
    duk_uint8_t *dst_final;
    duk_bool_t retval;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* XXX: optimize for buffer inputs: no need to coerce to a string
     * which causes an unnecessary interning.
     */
 
    index = duk_require_normalize_index(ctx, index);
    src = duk__prep_codec_arg(ctx, index, &srclen);
 
    /* Computation must not wrap, only srclen + 3 is at risk of
     * wrapping because after that the number gets smaller.
     * This limit works for 32-bit size_t:
     * 0x100000000 - 3 - 1 = 4294967292
     */
    if (srclen > 4294967292UL) {
        goto type_error;
    }

◆ duk_base64_encode()

DUK_EXTERNAL const char * duk_base64_encode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13313 of file duktape-1.8.0/src/duktape.c.

                        {
        /* Here we'd have the option of decoding unpadded base64
         * (e.g. "xxxxyy" instead of "xxxxyy==".  Currently not
         * accepted.
         */
        goto error;
    }
 
    *out_dst_final = dst;
    return 1;
 
 error:
    return 0;
}
#endif  /* DUK_USE_BASE64_FASTPATH */
 
DUK_EXTERNAL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    const duk_uint8_t *src;
    duk_size_t srclen;
    duk_size_t dstlen;
    duk_uint8_t *dst;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* XXX: optimize for string inputs: no need to coerce to a buffer
     * which makes a copy of the input.
     */
 
    index = duk_require_normalize_index(ctx, index);
    src = duk__prep_codec_arg(ctx, index, &srclen);
    /* Note: for srclen=0, src may be NULL */
 
    /* Computation must not wrap; this limit works for 32-bit size_t:
     * >>> srclen = 3221225469
     * >>> '%x' % ((srclen + 2) / 3 * 4)
     * 'fffffffc'

References error().

◆ duk_bd_decode()

DUK_INTERNAL_DECL duk_int32_t duk_bd_decode	(	duk_bitdecoder_ctx *	ctx,
		duk_small_int_t	bits )

Definition at line 86379 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
    duk_small_int_t shift;
    duk_uint32_t mask;
    duk_uint32_t tmp;
 
    /* Note: cannot read more than 24 bits without possibly shifting top bits out.
     * Fixable, but adds complexity.
     */
    DUK_ASSERT(bits >= 1 && bits <= 24);
 
    while (ctx->currbits < bits) {
#if 0
        DUK_DDD(DUK_DDDPRINT("decode_bits: shift more data (bits=%ld, currbits=%ld)",
                             (long) bits, (long) ctx->currbits));
#endif
        ctx->currval <<= 8;
        if (ctx->offset < ctx->length) {
            /* If ctx->offset >= ctx->length, we "shift zeroes in"
             * instead of croaking.
             */
            ctx->currval |= ctx->data[ctx->offset++];
        }
        ctx->currbits += 8;
    }
#if 0
    DUK_DDD(DUK_DDDPRINT("decode_bits: bits=%ld, currbits=%ld, currval=0x%08lx",
                         (long) bits, (long) ctx->currbits, (unsigned long) ctx->currval));

Referenced by duk__push_double(), duk__slow_case_conversion(), and duk_be_encode().

◆ duk_bd_decode_flag()

DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag ( duk_bitdecoder_ctx * ctx )

Definition at line 86424 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_be_encode().

◆ duk_bd_decode_flagged()

DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged	(	duk_bitdecoder_ctx *	ctx,
		duk_small_int_t	bits,
		duk_int32_t	def_value )

Definition at line 86432 of file duktape-1.8.0/src/duktape.c.

                                     : %ld bits -> 0x%08lx (%ld), currbits=%ld, currval=0x%08lx",
                         (long) bits, (unsigned long) tmp, (long) tmp, (long) ctx->currbits, (unsigned long) ctx->currval));
#endif
 
    return tmp;

◆ duk_be_encode()

DUK_INTERNAL_DECL void duk_be_encode	(	duk_bitencoder_ctx *	ctx,
		duk_uint32_t	data,
		duk_small_int_t	bits )

Definition at line 86446 of file duktape-1.8.0/src/duktape.c.

                                                                                                                     {
    if (duk_bd_decode_flag(ctx)) {
        return (duk_int32_t) duk_bd_decode(ctx, bits);
    } else {
        return def_value;
    }
}
#line 1 "duk_util_bitencoder.c"
/*
 *  Bitstream encoder.
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits) {
    duk_uint8_t tmp;
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(ctx->currbits < 8);
 
    /* This limitation would be fixable but adds unnecessary complexity. */

References duk_bd_decode(), and duk_bd_decode_flag().

Referenced by duk__bw_update_ptrs().

◆ duk_be_finish()

DUK_INTERNAL_DECL void duk_be_finish ( duk_bitencoder_ctx * ctx )

Definition at line 86471 of file duktape-1.8.0/src/duktape.c.

                               {
        if (ctx->offset < ctx->length) {
            tmp = (duk_uint8_t) ((ctx->currval >> (ctx->currbits - 8)) & 0xff);
            ctx->data[ctx->offset++] = tmp;
        } else {
            /* If buffer has been exhausted, truncate bitstream */
            ctx->truncated = 1;
        }

References duk_bitencoder_ctx::currbits, duk_bitencoder_ctx::currval, duk_bitencoder_ctx::data, duk_bitencoder_ctx::length, duk_bitencoder_ctx::offset, and duk_bitencoder_ctx::truncated.

◆ duk_bi_array_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor ( duk_context * ctx )

Definition at line 20293 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    /* Range limited to [0, 0x7fffffff] range, i.e. range that can be
     * represented with duk_int32_t.  Use this when the method doesn't
     * handle the full 32-bit unsigned range correctly.
     */
    duk_uint32_t ret = duk__push_this_obj_len_u32(ctx);
    if (DUK_UNLIKELY(ret >= 0x80000000UL)) {
        DUK_ERROR_RANGE((duk_hthread *) ctx, DUK_STR_ARRAY_LENGTH_OVER_2G);
    }
    return ret;
}
 
/*
 *  Constructor
 */
 
DUK_INTERNAL duk_ret_t duk_bi_array_constructor(duk_context *ctx) {
    duk_idx_t nargs;
    duk_double_t d;
    duk_uint32_t len;
    duk_idx_t i;
 
    nargs = duk_get_top(ctx);
    duk_push_array(ctx);
 
    if (nargs == 1 && duk_is_number(ctx, 0)) {
        /* XXX: expensive check (also shared elsewhere - so add a shared internal API call?) */
        d = duk_get_number(ctx, 0);
        len = duk_to_uint32(ctx, 0);
        if (((duk_double_t) len) != d) {
            return DUK_RET_RANGE_ERROR;
        }
 
        /* XXX: if 'len' is low, may want to ensure array part is kept:
         * the caller is likely to want a dense array.
         */
        duk_push_u32(ctx, len);

References duk__push_this_obj_len_u32(), DUK_ERROR_RANGE, DUK_STR_ARRAY_LENGTH_OVER_2G, and DUK_UNLIKELY.

◆ duk_bi_array_constructor_is_array()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor_is_array ( duk_context * ctx )

Definition at line 20336 of file duktape-1.8.0/src/duktape.c.

                                {
        duk_dup(ctx, i);
        duk_xdef_prop_index_wec(ctx, -2, (duk_uarridx_t) i);
    }

References duk_dup(), and duk_xdef_prop_index_wec.

◆ duk_bi_array_prototype_concat()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_concat ( duk_context * ctx )

Definition at line 20387 of file duktape-1.8.0/src/duktape.c.

                                 : func=%!iT, this=%!iT",
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
    duk_call_method(ctx, 0);
 
    return 1;
}
 
/*
 *  concat()
 */
 
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_concat(duk_context *ctx) {
    duk_idx_t i, n;
    duk_uarridx_t idx, idx_last;
    duk_uarridx_t j, len;
    duk_hobject *h;
 
    /* XXX: the insert here is a bit expensive if there are a lot of items.
     * It could also be special cased in the outermost for loop quite easily
     * (as the element is dup()'d anyway).
     */
 
    (void) duk_push_this_coercible_to_object(ctx);
    duk_insert(ctx, 0);
    n = duk_get_top(ctx);
    duk_push_array(ctx);  /* -> [ ToObject(this) item1 ... itemN arr ] */
 
    /* NOTE: The Array special behaviors are NOT invoked by duk_xdef_prop_index()
     * (which differs from the official algorithm).  If no error is thrown, this
     * doesn't matter as the length is updated at the end.  However, if an error
     * is thrown, the length will be unset.  That shouldn't matter because the
     * caller won't get a reference to the intermediate value.
     */
 
    idx = 0;
    idx_last = 0;
    for (i = 0; i < n; i++) {
        DUK_ASSERT_TOP(ctx, n + 1);
 
        /* [ ToObject(this) item1 ... itemN arr ] */
 
        duk_dup(ctx, i);
        h = duk_get_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_ARRAY);
        if (!h) {
            duk_xdef_prop_index_wec(ctx, -2, idx++);
            idx_last = idx;
            continue;
        }
 
        /* [ ToObject(this) item1 ... itemN arr item(i) ] */
 
        /* XXX: an array can have length higher than 32 bits; this is not handled
         * correctly now.
         */
        len = (duk_uarridx_t) duk_get_length(ctx, -1);
        for (j = 0; j < len; j++) {
            if (duk_get_prop_index(ctx, -1, j)) {
                /* [ ToObject(this) item1 ... itemN arr item(i) item(i)[j] ] */
                duk_xdef_prop_index_wec(ctx, -3, idx++);
                idx_last = idx;
            } else {
                idx++;
                duk_pop(ctx);
#if defined(DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER)
                /* According to E5.1 Section 15.4.4.4 nonexistent trailing
                 * elements do not affect 'length' of the result.  Test262
                 * and other engines disagree, so update idx_last here too.
                 */
                idx_last = idx;
#else
                /* Strict standard behavior, ignore trailing elements for
                 * result 'length'.

◆ duk_bi_array_prototype_indexof_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_indexof_shared ( duk_context * ctx )

Definition at line 21329 of file duktape-1.8.0/src/duktape.c.

                                                                               {
    duk_idx_t nargs;
    duk_int_t i, len;
    duk_int_t from_index;
    duk_small_int_t idx_step = duk_get_current_magic(ctx);  /* idx_step is +1 for indexOf, -1 for lastIndexOf */
 
    /* lastIndexOf() needs to be a vararg function because we must distinguish
     * between an undefined fromIndex and a "not given" fromIndex; indexOf() is
     * made vararg for symmetry although it doesn't strictly need to be.
     */
 
    nargs = duk_get_top(ctx);
    duk_set_top(ctx, 2);
 
    /* XXX: must be able to represent -len */
    len = (duk_int_t) duk__push_this_obj_len_u32_limited(ctx);
    if (len == 0) {
        goto not_found;
    }
 
    /* Index clamping is a bit tricky, we must ensure that we'll only iterate
     * through elements that exist and that the specific requirements from E5.1
     * Sections 15.4.4.14 and 15.4.4.15 are fulfilled; especially:
     *
     *   - indexOf: clamp to [-len,len], negative handling -> [0,len],
     *     if clamped result is len, for-loop bails out immediately
     *
     *   - lastIndexOf: clamp to [-len-1, len-1], negative handling -> [-1, len-1],
     *     if clamped result is -1, for-loop bails out immediately
     *
     * If fromIndex is not given, ToInteger(undefined) = 0, which is correct
     * for indexOf() but incorrect for lastIndexOf().  Hence special handling,
     * and why lastIndexOf() needs to be a vararg function.
     */
 
    if (nargs >= 2) {
        /* indexOf: clamp fromIndex to [-len, len]
         * (if fromIndex == len, for-loop terminates directly)
         *
         * lastIndexOf: clamp fromIndex to [-len - 1, len - 1]
         * (if clamped to -len-1 -> fromIndex becomes -1, terminates for-loop directly)
         */
        from_index = duk_to_int_clamped(ctx,
                                        1,
                                        (idx_step > 0 ? -len : -len - 1),
                                        (idx_step > 0 ? len : len - 1));
        if (from_index < 0) {
            /* for lastIndexOf, result may be -1 (mark immediate termination) */
            from_index = len + from_index;
        }
    } else {
        /* for indexOf, ToInteger(undefined) would be 0, i.e. correct, but
         * handle both indexOf and lastIndexOf specially here.
         */
        if (idx_step > 0) {
            from_index = 0;
        } else {
            from_index = len - 1;
        }
    }
 
    /* stack[0] = searchElement
     * stack[1] = fromIndex
     * stack[2] = object
     * stack[3] = length (not needed, but not popped above)
     */
 
    for (i = from_index; i >= 0 && i < len; i += idx_step) {

◆ duk_bi_array_prototype_iter_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_iter_shared ( duk_context * ctx )

Definition at line 21430 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    duk_uint32_t len;
    duk_uint32_t i;
    duk_uarridx_t k;
    duk_bool_t bval;
    duk_small_int_t iter_type = duk_get_current_magic(ctx);
    duk_uint32_t res_length = 0;
 
    /* each call this helper serves has nargs==2 */
    DUK_ASSERT_TOP(ctx, 2);
 
    len = duk__push_this_obj_len_u32(ctx);
    duk_require_callable(ctx, 0);
    /* if thisArg not supplied, behave as if undefined was supplied */
 
    if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) {
        duk_push_array(ctx);
    } else {
        duk_push_undefined(ctx);
    }
 
    /* stack[0] = callback
     * stack[1] = thisArg
     * stack[2] = object
     * stack[3] = ToUint32(length)  (unused, but avoid unnecessary pop)
     * stack[4] = result array (or undefined)
     */
 
    k = 0;  /* result index for filter() */
    for (i = 0; i < len; i++) {
        DUK_ASSERT_TOP(ctx, 5);
 
        if (!duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
#if defined(DUK_USE_NONSTD_ARRAY_MAP_TRAILER)
            /* Real world behavior for map(): trailing non-existent
             * elements don't invoke the user callback, but are still
             * counted towards result 'length'.
             */
            if (iter_type == DUK__ITER_MAP) {
                res_length = i + 1;
            }
#else
            /* Standard behavior for map(): trailing non-existent
             * elements don't invoke the user callback and are not
             * counted towards result 'length'.
             */
#endif
            duk_pop(ctx);
            continue;
        }
 
        /* The original value needs to be preserved for filter(), hence
         * this funny order.  We can't re-get the value because of side
         * effects.
         */
 
        duk_dup(ctx, 0);
        duk_dup(ctx, 1);
        duk_dup(ctx, -3);
        duk_push_u32(ctx, i);
        duk_dup(ctx, 2);  /* [ ... val callback thisArg val i obj ] */
        duk_call_method(ctx, 3); /* -> [ ... val retval ] */
 
        switch (iter_type) {
        case DUK__ITER_EVERY:
            bval = duk_to_boolean(ctx, -1);
            if (!bval) {
                /* stack top contains 'false' */
                return 1;
            }
            break;
        case DUK__ITER_SOME:
            bval = duk_to_boolean(ctx, -1);
            if (bval) {
                /* stack top contains 'true' */
                return 1;
            }
            break;
        case DUK__ITER_FOREACH:
            /* nop */
            break;
        case DUK__ITER_MAP:
            duk_dup(ctx, -1);
            duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) i);  /* retval to result[i] */
            res_length = i + 1;
            break;
        case DUK__ITER_FILTER:
            bval = duk_to_boolean(ctx, -1);
            if (bval) {
                duk_dup(ctx, -2);  /* orig value */
                duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) k);
                k++;
                res_length = k;
            }
            break;
        default:
            DUK_UNREACHABLE();
            break;
        }
        duk_pop_2(ctx);
 
        DUK_ASSERT_TOP(ctx, 5);
    }
 
    switch (iter_type) {
    case DUK__ITER_EVERY:
        duk_push_true(ctx);
        break;
    case DUK__ITER_SOME:
        duk_push_false(ctx);
        break;

◆ duk_bi_array_prototype_join_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_join_shared ( duk_context * ctx )

Definition at line 20479 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    duk_uint32_t len, count;
    duk_uint32_t idx;
    duk_small_int_t to_locale_string = duk_get_current_magic(ctx);
    duk_idx_t valstack_required;
 
    /* For join(), nargs is 1.  For toLocaleString(), nargs is 0 and
     * setting the top essentially pushes an undefined to the stack,
     * thus defaulting to a comma separator.
     */
    duk_set_top(ctx, 1);
    if (duk_is_undefined(ctx, 0)) {
        duk_pop(ctx);
        duk_push_hstring_stridx(ctx, DUK_STRIDX_COMMA);
    } else {
        duk_to_string(ctx, 0);
    }
 
    len = duk__push_this_obj_len_u32(ctx);
 
    /* [ sep ToObject(this) len ] */
 
    DUK_DDD(DUK_DDDPRINT("sep=%!T, this=%!T, len=%lu",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (unsigned long) len));
 
    /* The extra (+4) is tight. */
    valstack_required = (len >= DUK__ARRAY_MID_JOIN_LIMIT ?
                         DUK__ARRAY_MID_JOIN_LIMIT : len) + 4;
    duk_require_stack(ctx, valstack_required);
 
    duk_dup(ctx, 0);
 
    /* [ sep ToObject(this) len sep ] */
 
    count = 0;
    idx = 0;
    for (;;) {
        if (count >= DUK__ARRAY_MID_JOIN_LIMIT ||   /* intermediate join to avoid valstack overflow */
            idx >= len) { /* end of loop (careful with len==0) */
            /* [ sep ToObject(this) len sep str0 ... str(count-1) ] */
            DUK_DDD(DUK_DDDPRINT("mid/final join, count=%ld, idx=%ld, len=%ld",
                                 (long) count, (long) idx, (long) len));
            duk_join(ctx, (duk_idx_t) count);  /* -> [ sep ToObject(this) len str ] */
            duk_dup(ctx, 0);                   /* -> [ sep ToObject(this) len str sep ] */
            duk_insert(ctx, -2);               /* -> [ sep ToObject(this) len sep str ] */
            count = 1;
        }
        if (idx >= len) {
            /* if true, the stack already contains the final result */
            break;
        }
 
        duk_get_prop_index(ctx, 1, (duk_uarridx_t) idx);
        if (duk_is_null_or_undefined(ctx, -1)) {
            duk_pop(ctx);
            duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
        } else {
            if (to_locale_string) {
                duk_to_object(ctx, -1);

◆ duk_bi_array_prototype_pop()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_pop ( duk_context * ctx )

Definition at line 20562 of file duktape-1.8.0/src/duktape.c.

20579 {

20580 duk_uint32_t len;

◆ duk_bi_array_prototype_push()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_push ( duk_context * ctx )

Definition at line 20582 of file duktape-1.8.0/src/duktape.c.

                  {
        duk_push_int(ctx, 0);
        duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
        return 0;
    }
    idx = len - 1;
 
    duk_get_prop_index(ctx, 0, (duk_uarridx_t) idx);
    duk_del_prop_index(ctx, 0, (duk_uarridx_t) idx);
    duk_push_u32(ctx, idx);
    duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_push(duk_context *ctx) {
    /* Note: 'this' is not necessarily an Array object.  The push()
     * algorithm is supposed to work for other kinds of objects too,
     * so the algorithm has e.g. an explicit update for the 'length'
     * property which is normally "magical" in arrays.
     */
 
    duk_uint32_t len;
    duk_idx_t i, n;
 
    n = duk_get_top(ctx);
    len = duk__push_this_obj_len_u32(ctx);
 
    /* [ arg1 ... argN obj length ] */
 
    /* Technically Array.prototype.push() can create an Array with length
     * longer than 2^32-1, i.e. outside the 32-bit range.  The final length
     * is *not* wrapped to 32 bits in the specification.
     *
     * This implementation tracks length with a uint32 because it's much
     * more practical.
     *
     * See: test-bi-array-push-maxlen.js.
     */
 
    if (len + (duk_uint32_t) n < len) {

◆ duk_bi_array_prototype_reduce_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reduce_shared ( duk_context * ctx )

Definition at line 21563 of file duktape-1.8.0/src/duktape.c.

           :
        DUK_UNREACHABLE();
        break;
    }
 
    return 1;
}
 
/*
 *  reduce(), reduceRight()
 */
 
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx) {
    duk_idx_t nargs;
    duk_bool_t have_acc;
    duk_uint32_t i, len;
    duk_small_int_t idx_step = duk_get_current_magic(ctx);  /* idx_step is +1 for reduce, -1 for reduceRight */
 
    /* We're a varargs function because we need to detect whether
     * initialValue was given or not.
     */
    nargs = duk_get_top(ctx);
    DUK_DDD(DUK_DDDPRINT("nargs=%ld", (long) nargs));
 
    duk_set_top(ctx, 2);
    len = duk__push_this_obj_len_u32(ctx);
    if (!duk_is_callable(ctx, 0)) {
        goto type_error;
    }
 
    /* stack[0] = callback fn
     * stack[1] = initialValue
     * stack[2] = object (coerced this)
     * stack[3] = length (not needed, but not popped above)
     * stack[4] = accumulator
     */
 
    have_acc = 0;
    if (nargs >= 2) {
        duk_dup(ctx, 1);
        have_acc = 1;
    }
    DUK_DDD(DUK_DDDPRINT("have_acc=%ld, acc=%!T",
                         (long) have_acc, (duk_tval *) duk_get_tval(ctx, 3)));
 
    /* For len == 0, i is initialized to len - 1 which underflows.
     * The condition (i < len) will then exit the for-loop on the
     * first round which is correct.  Similarly, loop termination
     * happens by i underflowing.
     */
 
    for (i = (idx_step >= 0 ? 0 : len - 1);
         i < len;  /* i >= 0 would always be true */
         i += idx_step) {
        DUK_DDD(DUK_DDDPRINT("i=%ld, len=%ld, have_acc=%ld, top=%ld, acc=%!T",
                             (long) i, (long) len, (long) have_acc,
                             (long) duk_get_top(ctx),
                             (duk_tval *) duk_get_tval(ctx, 4)));
 
        DUK_ASSERT((have_acc && duk_get_top(ctx) == 5) ||
                   (!have_acc && duk_get_top(ctx) == 4));
 
        if (!duk_has_prop_index(ctx, 2, (duk_uarridx_t) i)) {
            continue;
        }
 
        if (!have_acc) {
            DUK_ASSERT_TOP(ctx, 4);
            duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
            have_acc = 1;
            DUK_ASSERT_TOP(ctx, 5);
        } else {
            DUK_ASSERT_TOP(ctx, 5);
            duk_dup(ctx, 0);
            duk_dup(ctx, 4);
            duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
            duk_push_u32(ctx, i);
            duk_dup(ctx, 2);
            DUK_DDD(DUK_DDDPRINT("calling reduce function: func=%!T, prev=%!T, curr=%!T, idx=%!T, obj=%!T",
                                 (duk_tval *) duk_get_tval(ctx, -5), (duk_tval *) duk_get_tval(ctx, -4),
                                 (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
                                 (duk_tval *) duk_get_tval(ctx, -1)));

◆ duk_bi_array_prototype_reverse()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reverse ( duk_context * ctx )

Definition at line 21112 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    duk_uint32_t len;
    duk_uint32_t middle;
    duk_uint32_t lower, upper;
    duk_bool_t have_lower, have_upper;
 
    len = duk__push_this_obj_len_u32(ctx);
    middle = len / 2;
 
    /* If len <= 1, middle will be 0 and for-loop bails out
     * immediately (0 < 0 -> false).
     */
 
    for (lower = 0; lower < middle; lower++) {
        DUK_ASSERT(len >= 2);
        DUK_ASSERT_TOP(ctx, 2);
 
        DUK_ASSERT(len >= lower + 1);
        upper = len - lower - 1;
 
        have_lower = duk_get_prop_index(ctx, -2, (duk_uarridx_t) lower);
        have_upper = duk_get_prop_index(ctx, -3, (duk_uarridx_t) upper);
 
        /* [ ToObject(this) ToUint32(length) lowerValue upperValue ] */
 
        if (have_upper) {
            duk_put_prop_index(ctx, -4, (duk_uarridx_t) lower);
        } else {
            duk_del_prop_index(ctx, -4, (duk_uarridx_t) lower);

◆ duk_bi_array_prototype_shift()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_shift ( duk_context * ctx )

Definition at line 21225 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_uint32_t len;
    duk_uint32_t i;
 
    len = duk__push_this_obj_len_u32(ctx);
    if (len == 0) {
        duk_push_int(ctx, 0);
        duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
        return 0;
    }
 
    duk_get_prop_index(ctx, 0, 0);
 
    /* stack[0] = object (this)
     * stack[1] = ToUint32(length)
     * stack[2] = elem at index 0 (retval)
     */
 
    for (i = 1; i < len; i++) {
        DUK_ASSERT_TOP(ctx, 3);

◆ duk_bi_array_prototype_slice()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_slice ( duk_context * ctx )

Definition at line 21163 of file duktape-1.8.0/src/duktape.c.

               {
            duk_del_prop_index(ctx, -3, (duk_uarridx_t) upper);
            duk_pop(ctx);
        }
 
        DUK_ASSERT_TOP(ctx, 2);
    }
 
    DUK_ASSERT_TOP(ctx, 2);
    duk_pop(ctx);  /* -> [ ToObject(this) ] */
    return 1;
}
 
/*
 *  slice()
 */
 
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx) {
    duk_uint32_t len;
    duk_int_t start, end;
    duk_int_t i;
    duk_uarridx_t idx;
    duk_uint32_t res_length = 0;
 
    /* XXX: len >= 0x80000000 won't work below because we need to be
     * able to represent -len.
     */
    len = duk__push_this_obj_len_u32_limited(ctx);
    duk_push_array(ctx);
 
    /* stack[0] = start
     * stack[1] = end
     * stack[2] = ToObject(this)
     * stack[3] = ToUint32(length)
     * stack[4] = result array
     */
 
    start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
    if (start < 0) {
        start = len + start;
    }
    /* XXX: could duk_is_undefined() provide defaulting undefined to 'len'
     * (the upper limit)?
     */
    if (duk_is_undefined(ctx, 1)) {
        end = len;
    } else {
        end = duk_to_int_clamped(ctx, 1, -((duk_int_t) len), (duk_int_t) len);
        if (end < 0) {
            end = len + end;
        }
    }
    DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len);
    DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len);
 
    idx = 0;
    for (i = start; i < end; i++) {

◆ duk_bi_array_prototype_sort()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_sort ( duk_context * ctx )

Definition at line 20912 of file duktape-1.8.0/src/duktape.c.

                                                 : %!T", (duk_tval *) duk_get_tval(ctx, 1)));
    duk__array_sort_swap(ctx, lo, r);
 
#if defined(DUK_USE_DDDPRINT)
    duk__debuglog_qsort_state(ctx, lo, hi, r);
#endif
 
    DUK_DDD(DUK_DDDPRINT("recurse: pivot=%ld, obj=%!T", (long) r, (duk_tval *) duk_get_tval(ctx, 1)));
    duk__array_qsort(ctx, lo, r - 1);
    duk__array_qsort(ctx, r + 1, hi);
}
 
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_sort(duk_context *ctx) {
    duk_uint32_t len;
 
    /* XXX: len >= 0x80000000 won't work below because a signed type
     * is needed by qsort.

◆ duk_bi_array_prototype_splice()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_splice ( duk_context * ctx )

Definition at line 20948 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    duk_idx_t nargs;
    duk_uint32_t len;
    duk_bool_t have_delcount;
    duk_int_t item_count;
    duk_int_t act_start;
    duk_int_t del_count;
    duk_int_t i, n;
 
    DUK_UNREF(have_delcount);
 
    nargs = duk_get_top(ctx);
    if (nargs < 2) {
        duk_set_top(ctx, 2);
        nargs = 2;
        have_delcount = 0;
    } else {
        have_delcount = 1;
    }
 
    /* XXX: len >= 0x80000000 won't work below because we need to be
     * able to represent -len.
     */
    len = duk__push_this_obj_len_u32_limited(ctx);
 
    act_start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
    if (act_start < 0) {
        act_start = len + act_start;
    }
    DUK_ASSERT(act_start >= 0 && act_start <= (duk_int_t) len);
 
#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
    if (have_delcount) {
#endif
        del_count = duk_to_int_clamped(ctx, 1, 0, len - act_start);
#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
    } else {
        /* E5.1 standard behavior when deleteCount is not given would be
         * to treat it just like if 'undefined' was given, which coerces
         * ultimately to 0.  Real world behavior is to splice to the end
         * of array, see test-bi-array-proto-splice-no-delcount.js.
         */
        del_count = len - act_start;
    }
#endif
 
    DUK_ASSERT(nargs >= 2);
    item_count = (duk_int_t) (nargs - 2);
 
    DUK_ASSERT(del_count >= 0 && del_count <= (duk_int_t) len - act_start);
    DUK_ASSERT(del_count + act_start <= (duk_int_t) len);
 
    /* For now, restrict result array into 32-bit length range. */
    if (((duk_double_t) len) - ((duk_double_t) del_count) + ((duk_double_t) item_count) > (duk_double_t) DUK_UINT32_MAX) {
        DUK_D(DUK_DPRINT("Array.prototype.splice() would go beyond 32-bit length, throw"));
        return DUK_RET_RANGE_ERROR;
    }
 
    duk_push_array(ctx);
 
    /* stack[0] = start
     * stack[1] = deleteCount
     * stack[2...nargs-1] = items
     * stack[nargs] = ToObject(this)               -3
     * stack[nargs+1] = ToUint32(length)           -2
     * stack[nargs+2] = result array               -1
     */
 
    DUK_ASSERT_TOP(ctx, nargs + 3);
 
    /* Step 9: copy elements-to-be-deleted into the result array */
 
    for (i = 0; i < del_count; i++) {
        if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (act_start + i))) {
            duk_xdef_prop_index_wec(ctx, -2, i);  /* throw flag irrelevant (false in std alg) */
        } else {
            duk_pop(ctx);
        }
    }
    duk_push_u32(ctx, (duk_uint32_t) del_count);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
 
    /* Steps 12 and 13: reorganize elements to make room for itemCount elements */
 
    if (item_count < del_count) {
        /*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 1
         * -> [ A B F G H ]          (conceptual intermediate step)
         * -> [ A B . F G H ]        (placeholder marked)
         *    [ A B C F G H ]        (actual result at this point, C will be replaced)
         */
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
 
        n = len - del_count;
        for (i = act_start; i < n; i++) {
            if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
                duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
            } else {
                duk_pop(ctx);
                duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
            }
        }
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
 
        /* loop iterator init and limit changed from standard algorithm */
        n = len - del_count + item_count;
        for (i = len - 1; i >= n; i--) {
            duk_del_prop_index(ctx, -3, (duk_uarridx_t) i);
        }
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
    } else if (item_count > del_count) {
        /*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 4
         * -> [ A B F G H ]          (conceptual intermediate step)
         * -> [ A B . . . . F G H ]  (placeholder marked)
         *    [ A B C D E F F G H ]  (actual result at this point)
         */
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
 
        /* loop iterator init and limit changed from standard algorithm */
        for (i = len - del_count - 1; i >= act_start; i--) {
            if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
                duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
            } else {
                duk_pop(ctx);
                duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
            }
        }
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
    } else {
        /*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 3
         * -> [ A B F G H ]          (conceptual intermediate step)
         * -> [ A B . . . F G H ]    (placeholder marked)
         *    [ A B C D E F G H ]    (actual result at this point)
         */
    }
    DUK_ASSERT_TOP(ctx, nargs + 3);
 
    /* Step 15: insert itemCount elements into the hole made above */

◆ duk_bi_array_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_to_string ( duk_context * ctx )

Definition at line 20348 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_hobject *h;
 
    h = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_ARRAY);
    duk_push_boolean(ctx, (h != NULL));
    return 1;
}
 
/*
 *  toString()
 */
 
DUK_INTERNAL duk_ret_t duk_bi_array_prototype_to_string(duk_context *ctx) {
    (void) duk_push_this_coercible_to_object(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_JOIN);
 
    /* [ ... this func ] */
    if (!duk_is_callable(ctx, -1)) {
        /* Fall back to the initial (original) Object.toString().  We don't
         * currently have pointers to the built-in functions, only the top
         * level global objects (like "Array") so this is now done in a bit
         * of a hacky manner.  It would be cleaner to push the (original)
         * function and use duk_call_method().
         */
 
        /* XXX: 'this' will be ToObject() coerced twice, which is incorrect
         * but should have no visible side effects.
         */
        DUK_DDD(DUK_DDDPRINT("this.join is not callable, fall back to (original) Object.toString"));

References duk_get_hobject_with_class(), DUK_HOBJECT_CLASS_ARRAY, duk_push_boolean(), and NULL.

◆ duk_bi_array_prototype_unshift()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_unshift ( duk_context * ctx )

Definition at line 21267 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    duk_idx_t nargs;
    duk_uint32_t len;
    duk_uint32_t i;
 
    nargs = duk_get_top(ctx);
    len = duk__push_this_obj_len_u32(ctx);
 
    /* stack[0...nargs-1] = unshift args (vararg)
     * stack[nargs] = ToObject(this)
     * stack[nargs+1] = ToUint32(length)
     */
 
    DUK_ASSERT_TOP(ctx, nargs + 2);
 
    /* Note: unshift() may operate on indices above unsigned 32-bit range
     * and the final length may be >= 2**32.  However, we restrict the
     * final result to 32-bit range for practicality.
     */
 
    if (len + (duk_uint32_t) nargs < len) {
        DUK_D(DUK_DPRINT("Array.prototype.unshift() would go beyond 32-bit length, throw"));
        return DUK_RET_RANGE_ERROR;
    }
 
    i = len;
    while (i > 0) {
        DUK_ASSERT_TOP(ctx, nargs + 2);
        i--;
        /* k+argCount-1; note that may be above 32-bit range */
 
        if (duk_get_prop_index(ctx, -2, (duk_uarridx_t) i)) {
            /* fromPresent = true */
            /* [ ... ToObject(this) ToUint32(length) val ] */
            duk_put_prop_index(ctx, -3, (duk_uarridx_t) (i + nargs));  /* -> [ ... ToObject(this) ToUint32(length) ] */
        } else {
            /* fromPresent = false */
            /* [ ... ToObject(this) ToUint32(length) val ] */
            duk_pop(ctx);
            duk_del_prop_index(ctx, -2, (duk_uarridx_t) (i + nargs));  /* -> [ ... ToObject(this) ToUint32(length) ] */

◆ duk_bi_arraybuffer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_constructor ( duk_context * ctx )

Definition at line 22399 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  ArrayBuffer, DataView, and TypedArray constructors
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_bufobj;
    duk_hbuffer *h_val;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /* XXX: function flag to make this automatic? */
    if (!duk_is_constructor_call(ctx)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    if (duk_is_buffer(ctx, 0)) {
        /* Custom behavior: plain buffer is used as internal buffer
         * without making a copy (matches Duktape.Buffer).
         */
 
        h_val = duk_get_hbuffer(ctx, 0);
        DUK_ASSERT(h_val != NULL);
 
        /* XXX: accept any duk_hbufferobject type as an input also? */
    } else {
        duk_int_t len;
        len = duk_to_int(ctx, 0);
        if (len < 0) {
            goto fail_length;
        }
        (void) duk_push_fixed_buffer(ctx, (duk_size_t) len);
        h_val = (duk_hbuffer *) duk_get_hbuffer(ctx, -1);
        DUK_ASSERT(h_val != NULL);
 
#if !defined(DUK_USE_ZERO_BUFFER_DATA)
        /* Khronos/ES6 requires zeroing even when DUK_USE_ZERO_BUFFER_DATA
         * is not set.
         */
        DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) h_val));
        DUK_MEMZERO((void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_val), (duk_size_t) len);
#endif

◆ duk_bi_arraybuffer_isview()

DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_isview ( duk_context * ctx )

Definition at line 22898 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */

◆ duk_bi_boolean_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_constructor ( duk_context * ctx )

Definition at line 21704 of file duktape-1.8.0/src/duktape.c.

                                                                          {
            duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
            DUK_ASSERT(duk_is_boolean(ctx, -1));
            goto type_ok;
        }
    }
 
    return DUK_RET_TYPE_ERROR;
 
 type_ok:
    if (coerce_tostring) {
        duk_to_string(ctx, -1);
    }
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_this;
 
    DUK_UNREF(thr);
 

References DUK_ASSERT, duk_get_prop_stridx(), duk_is_boolean(), and DUK_STRIDX_INT_VALUE.

◆ duk_bi_boolean_prototype_tostring_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_prototype_tostring_shared ( duk_context * ctx )

Definition at line 21668 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    duk_tval *tv;
    duk_hobject *h;
    duk_small_int_t coerce_tostring = duk_get_current_magic(ctx);
 
    /* XXX: there is room to use a shared helper here, many built-ins
     * check the 'this' type, and if it's an object, check its class,
     * then get its internal value, etc.
     */
 
    duk_push_this(ctx);
    tv = duk_get_tval(ctx, -1);
    DUK_ASSERT(tv != NULL);
 
    if (DUK_TVAL_IS_BOOLEAN(tv)) {
        goto type_ok;
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        h = DUK_TVAL_GET_OBJECT(tv);

References DUK_ASSERT, duk_get_current_magic(), duk_get_tval(), duk_push_this(), DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_BOOLEAN, DUK_TVAL_IS_OBJECT, and NULL.

◆ duk_bi_buffer_compare_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_compare_shared ( duk_context * ctx )

Definition at line 23090 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.prototype.equals()
 *  Node.js Buffer.prototype.compare()
 *  Node.js Buffer.compare()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx) {
    duk_hthread *thr;
    duk_small_uint_t magic;
    duk_hbufferobject *h_bufarg1;
    duk_hbufferobject *h_bufarg2;
    duk_small_int_t comp_res;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    magic = duk_get_current_magic(ctx);
    if (magic & 0x02) {
        /* Static call style. */
        h_bufarg1 = duk__require_bufobj_value(ctx, 0);
        h_bufarg2 = duk__require_bufobj_value(ctx, 1);
    } else {
        h_bufarg1 = duk__require_bufobj_this(ctx);
        h_bufarg2 = duk__require_bufobj_value(ctx, 0);
    }
    DUK_ASSERT(h_bufarg1 != NULL);
    DUK_ASSERT(h_bufarg2 != NULL);
 
    /* We want to compare the slice/view areas of the arguments.
     * If either slice/view is invalid (underlying buffer is shorter)
     * ensure equals() is false, but otherwise the only thing that
     * matters is to be memory safe.
     */
 
    if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg1) &&
        DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg2)) {
        comp_res = duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufarg1->buf) + h_bufarg1->offset,

◆ duk_bi_buffer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_constructor ( duk_context * ctx )

Definition at line 22215 of file duktape-1.8.0/src/duktape.c.

                                       :
        du.d = (duk_double_t) duk_to_number(ctx, -1);
        break;
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
    default:
        DUK_UNREACHABLE();
    }
 
    DUK_MEMCPY((void *) p, (const void *) du.uc, (size_t) elem_size);
}
 
/*
 *  Duktape.Buffer: constructor
 */
 
DUK_INTERNAL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx) {
    duk_hthread *thr;
    duk_size_t buf_size;
    duk_small_int_t buf_dynamic;
    duk_uint8_t *buf_data;
    const duk_uint8_t *src_data;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /*
     *  Constructor arguments are currently somewhat compatible with
     *  (keep it that way if possible):
     *
     *    http://nodejs.org/api/buffer.html
     *
     *  Note that the ToBuffer() coercion (duk_to_buffer()) does NOT match
     *  the constructor behavior.
     */
 
    buf_dynamic = duk_get_boolean(ctx, 1);  /* default to false */
 
    switch (duk_get_type(ctx, 0)) {
    case DUK_TYPE_NUMBER: {
        /* new buffer of specified size */
        buf_size = (duk_size_t) duk_to_int(ctx, 0);
        (void) duk_push_buffer(ctx, buf_size, buf_dynamic);
        break;
    }
    case DUK_TYPE_BUFFER: {
        /* return input buffer, converted to a Duktape.Buffer object
         * if called as a constructor (no change if called as a
         * function).
         */
        duk_set_top(ctx, 1);
        break;
    }
    case DUK_TYPE_STRING: {
        /* new buffer with string contents */
        src_data = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &buf_size);
        DUK_ASSERT(src_data != NULL);  /* even for zero-length string */
        buf_data = (duk_uint8_t *) duk_push_buffer(ctx, buf_size, buf_dynamic);
        DUK_MEMCPY((void *) buf_data, (const void *) src_data, (size_t) buf_size);
        break;
    }
    case DUK_TYPE_OBJECT: {
        /* For all duk_hbufferobjects, get the plain buffer inside
         * without making a copy.  This is compatible with Duktape 1.2
         * but means that a slice/view information is ignored and the
         * full underlying buffer is returned.
         *
         * If called as a constructor, a new Duktape.Buffer object
         * pointing to the same plain buffer is created below.
         */
        duk_hbufferobject *h_bufobj;
        h_bufobj = (duk_hbufferobject *) duk_get_hobject(ctx, 0);
        DUK_ASSERT(h_bufobj != NULL);
        if (!DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj)) {
            return DUK_RET_TYPE_ERROR;
        }
        if (h_bufobj->buf == NULL) {
            return DUK_RET_TYPE_ERROR;
        }
        duk_push_hbuffer(ctx, h_bufobj->buf);
        break;
    }
    case DUK_TYPE_NONE:
    default: {
        return DUK_RET_TYPE_ERROR;
    }
    }
    DUK_ASSERT(duk_is_buffer(ctx, -1));
 
    /* stack is unbalanced, but: [ <something> buf ] */
 
    if (duk_is_constructor_call(ctx)) {
        duk_hbufferobject *h_bufobj;
        duk_hbuffer *h_val;
 
        h_val = duk_get_hbuffer(ctx, -1);

◆ duk_bi_buffer_prototype_tostring_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_prototype_tostring_shared ( duk_context * ctx )

Definition at line 22978 of file duktape-1.8.0/src/duktape.c.

           :
    return DUK_RET_TYPE_ERROR;
}
#else  /* DUK_USE_BUFFEROBJECT_SUPPORT */
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Duktape.Buffer: toString(), valueOf()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv;
    duk_small_int_t to_string = duk_get_current_magic(ctx);
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    tv = duk_get_borrowed_this_tval(ctx);
    DUK_ASSERT(tv != NULL);
 
    if (DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h_buf;
        h_buf = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h_buf != NULL);
        duk_push_hbuffer(ctx, h_buf);
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h;
        duk_hbufferobject *h_bufobj;
 
        /* Accept any duk_hbufferobject, though we're only normally
         * called for Duktape.Buffer values.
         */
        h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        if (!DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
            DUK_DD(DUK_DDPRINT("toString/valueOf() called for a non-bufferobject object"));
            goto type_error;
        }
        h_bufobj = (duk_hbufferobject *) h;
        DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 

◆ duk_bi_buffer_readfield()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_readfield ( duk_context * ctx )

Definition at line 24056 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_hthread *thr;
    duk_small_int_t magic = (duk_small_int_t) duk_get_current_magic(ctx);
    duk_small_int_t magic_ftype;
    duk_small_int_t magic_bigendian;
    duk_small_int_t magic_signed;
    duk_small_int_t magic_typedarray;
    duk_small_int_t endswap;
    duk_hbufferobject *h_this;
    duk_bool_t no_assert;
    duk_int_t offset_signed;
    duk_uint_t offset;
    duk_uint_t buffer_length;
    duk_uint_t check_length;
    duk_uint8_t *buf;
    duk_double_union du;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    magic_ftype = magic & 0x0007;
    magic_bigendian = magic & 0x0008;
    magic_signed = magic & 0x0010;
    magic_typedarray = magic & 0x0020;
 
    h_this = duk__require_bufobj_this(ctx);
    DUK_ASSERT(h_this != NULL);
    buffer_length = h_this->length;
 
    /* [ offset noAssert                 ], when ftype != DUK__FLD_VARINT */
    /* [ offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */
    /* [ offset littleEndian             ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */
 
    /* Handle TypedArray vs. Node.js Buffer arg differences */
    if (magic_typedarray) {
        no_assert = 0;
#if defined(DUK_USE_INTEGER_LE)
        endswap = !duk_to_boolean(ctx, 1);  /* 1=little endian */
#else
        endswap = duk_to_boolean(ctx, 1);  /* 1=little endian */
#endif
    } else {
        no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 2 : 1);
#if defined(DUK_USE_INTEGER_LE)
        endswap = magic_bigendian;
#else
        endswap = !magic_bigendian;
#endif
    }
 
    /* Offset is coerced first to signed integer range and then to unsigned.
     * This ensures we can add a small byte length (1-8) to the offset in
     * bound checks and not wrap.
     */
    offset_signed = duk_to_int(ctx, 0);
    offset = (duk_uint_t) offset_signed;
    if (offset_signed < 0) {
        goto fail_bounds;
    }
 
    DUK_DDD(DUK_DDDPRINT("readfield, buffer_length=%ld, offset=%ld, no_assert=%d, "
                         "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, "
                         "endswap=%d",
                         (long) buffer_length, (long) offset, (int) no_assert,
                         (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3),
                         (int) (magic_signed >> 4), (int) endswap));
 
    /* Update 'buffer_length' to be the effective, safe limit which
     * takes into account the underlying buffer.  This value will be
     * potentially invalidated by any side effect.
     */
    check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length);
    DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld",
                         (long) buffer_length, (long) check_length));
 
    if (h_this->buf) {
        buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this);
    } else {
        /* Neutered.  We could go into the switch-case safely with
         * buf == NULL because check_length == 0.  To avoid scanbuild
         * warnings, fail directly instead.
         */
        DUK_ASSERT(check_length == 0);
        goto fail_neutered;
    }
    DUK_ASSERT(buf != NULL);
 
    switch (magic_ftype) {
    case DUK__FLD_8BIT: {
        duk_uint8_t tmp;
        if (offset + 1U > check_length) {
            goto fail_bounds;
        }
        tmp = buf[offset];
        if (magic_signed) {
            duk_push_int(ctx, (duk_int_t) ((duk_int8_t) tmp));
        } else {
            duk_push_uint(ctx, (duk_uint_t) tmp);
        }
        break;
    }
    case DUK__FLD_16BIT: {
        duk_uint16_t tmp;
        if (offset + 2U > check_length) {
            goto fail_bounds;
        }
        DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 2);
        tmp = du.us[0];
        if (endswap) {
            tmp = DUK_BSWAP16(tmp);
        }
        if (magic_signed) {
            duk_push_int(ctx, (duk_int_t) ((duk_int16_t) tmp));
        } else {
            duk_push_uint(ctx, (duk_uint_t) tmp);
        }
        break;
    }
    case DUK__FLD_32BIT: {
        duk_uint32_t tmp;
        if (offset + 4U > check_length) {
            goto fail_bounds;
        }
        DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4);
        tmp = du.ui[0];
        if (endswap) {
            tmp = DUK_BSWAP32(tmp);
        }
        if (magic_signed) {
            duk_push_int(ctx, (duk_int_t) ((duk_int32_t) tmp));
        } else {
            duk_push_uint(ctx, (duk_uint_t) tmp);
        }
        break;
    }
    case DUK__FLD_FLOAT: {
        duk_uint32_t tmp;
        if (offset + 4U > check_length) {
            goto fail_bounds;
        }
        DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4);
        if (endswap) {
            tmp = du.ui[0];
            tmp = DUK_BSWAP32(tmp);
            du.ui[0] = tmp;
        }
        duk_push_number(ctx, (duk_double_t) du.f[0]);
        break;
    }
    case DUK__FLD_DOUBLE: {
        if (offset + 8U > check_length) {
            goto fail_bounds;
        }
        DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 8);
        if (endswap) {
            DUK_DBLUNION_BSWAP64(&du);
        }
        duk_push_number(ctx, (duk_double_t) du.d);
        break;
    }
    case DUK__FLD_VARINT: {
        /* Node.js Buffer variable width integer field.  We don't really
         * care about speed here, so aim for shortest algorithm.
         */
        duk_int_t field_bytelen;
        duk_int_t i, i_step, i_end;
#if defined(DUK_USE_64BIT_OPS)
        duk_int64_t tmp;
        duk_small_uint_t shift_tmp;
#else
        duk_double_t tmp;
        duk_small_int_t highbyte;
#endif
        const duk_uint8_t *p;
 
        field_bytelen = duk_get_int(ctx, 1);  /* avoid side effects! */
        if (field_bytelen < 1 || field_bytelen > 6) {
            goto fail_field_length;
        }
        if (offset + (duk_uint_t) field_bytelen > check_length) {
            goto fail_bounds;
        }
        p = (const duk_uint8_t *) (buf + offset);
 
        /* Slow gathering of value using either 64-bit arithmetic
         * or IEEE doubles if 64-bit types not available.  Handling
         * of negative numbers is a bit non-obvious in both cases.
         */
 
        if (magic_bigendian) {
            /* Gather in big endian */
            i = 0;
            i_step = 1;
            i_end = field_bytelen;  /* one i_step over */
        } else {
            /* Gather in little endian */
            i = field_bytelen - 1;
            i_step = -1;
            i_end = -1;  /* one i_step over */
        }
 
#if defined(DUK_USE_64BIT_OPS)
        tmp = 0;
        do {
            DUK_ASSERT(i >= 0 && i < field_bytelen);
            tmp = (tmp << 8) + (duk_int64_t) p[i];
            i += i_step;
        } while (i != i_end);
 
        if (magic_signed) {
            /* Shift to sign extend. */
            shift_tmp = 64 - (field_bytelen * 8);
            tmp = (tmp << shift_tmp) >> shift_tmp;
        }
 
        duk_push_i64(ctx, tmp);
#else
        highbyte = p[i];
        if (magic_signed && (highbyte & 0x80) != 0) {
            /* 0xff => 255 - 256 = -1; 0x80 => 128 - 256 = -128 */
            tmp = (duk_double_t) (highbyte - 256);
        } else {
            tmp = (duk_double_t) highbyte;
        }
        for (;;) {
            i += i_step;
            if (i == i_end) {
                break;
            }
            DUK_ASSERT(i >= 0 && i < field_bytelen);
            tmp = (tmp * 256.0) + (duk_double_t) p[i];
        }
 
        duk_push_number(ctx, tmp);
#endif
        break;
    }
    default: {  /* should never happen but default here */
        goto fail_bounds;
    }

References duk_hbufferobject::buf, duk_double_union::d, DUK__FLD_16BIT, DUK__FLD_32BIT, DUK__FLD_8BIT, DUK__FLD_DOUBLE, DUK__FLD_FLOAT, DUK__FLD_VARINT, duk__require_bufobj_this(), DUK_ASSERT, DUK_BSWAP16, DUK_BSWAP32, DUK_DBLUNION_BSWAP64, DUK_DDD, DUK_DDDPRINT, duk_get_current_magic(), duk_get_int(), DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH, DUK_HBUFFEROBJECT_GET_SLICE_BASE, DUK_MEMCPY, duk_push_i64, duk_push_int(), duk_push_number(), duk_push_uint(), duk_to_boolean(), duk_to_int(), DUK_UNREF, duk_double_union::f, duk_hthread::heap, duk_hbufferobject::length, NULL, duk_double_union::uc, duk_double_union::ui, and duk_double_union::us.

◆ duk_bi_buffer_slice_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_slice_shared ( duk_context * ctx )

Definition at line 23703 of file duktape-1.8.0/src/duktape.c.

               :
 *
 *    - Copy/view behavior; Node.js .slice() and TypedArray .subarray() create
 *      views, ArrayBuffer .slice() creates a copy
 *
 *    - Resulting object has a different class and prototype depending on the
 *      call (or 'this' argument)
 *
 *    - TypedArray .subarray() arguments are element indices, not byte offsets
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx) {
    duk_hthread *thr;
    duk_small_int_t magic;
    duk_small_uint_t res_class_num;
    duk_hobject *res_proto;
    duk_hbufferobject *h_this;
    duk_hbufferobject *h_bufobj;
    duk_hbuffer *h_val;
    duk_int_t start_offset, end_offset;
    duk_uint_t slice_length;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /* [ start end ] */
 
    magic = duk_get_current_magic(ctx);
    h_this = duk__require_bufobj_this(ctx);
 
    /* Slice offsets are element (not byte) offsets, which only matters
     * for TypedArray views, Node.js Buffer and ArrayBuffer have shift
     * zero so byte and element offsets are the same.  Negative indices
     * are counted from end of slice, crossed indices are allowed (and
     * result in zero length result), and final values are clamped
     * against the current slice.  There's intentionally no check
     * against the underlying buffer here.
     */
 
    duk__clamp_startend_negidx_shifted(ctx, h_this, 0 /*idx_start*/, 1 /*idx_end*/, &start_offset, &end_offset);
    DUK_ASSERT(end_offset >= start_offset);
    slice_length = (duk_uint_t) (end_offset - start_offset);
 
    /* The resulting buffer object gets the same class and prototype as
     * the buffer in 'this', e.g. if the input is a Node.js Buffer the
     * result is a Node.js Buffer; if the input is a Float32Array, the
     * result is a Float32Array.
     *
     * For the class number this seems correct.  The internal prototype
     * is not so clear: if 'this' is a bufferobject with a non-standard
     * prototype object, that value gets copied over into the result
     * (instead of using the standard prototype for that object type).
     */
 
    res_class_num = DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) h_this);
    h_bufobj = duk_push_bufferobject_raw(ctx,
                                         DUK_HOBJECT_FLAG_EXTENSIBLE |
                                         DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                         DUK_HOBJECT_CLASS_AS_FLAGS(res_class_num),
                                         DUK_BIDX_OBJECT_PROTOTYPE);  /* replaced */
    DUK_ASSERT(h_bufobj != NULL);
    res_proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, (duk_hobject *) h_this);  /* may be NULL */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) h_bufobj, res_proto);
 
    DUK_ASSERT(h_bufobj->length == 0);
    h_bufobj->shift = h_this->shift;  /* inherit */
    h_bufobj->elem_type = h_this->elem_type;  /* inherit */
    h_bufobj->is_view = magic & 0x01;
    DUK_ASSERT(h_bufobj->is_view == 0 || h_bufobj->is_view == 1);
 
    h_val = h_this->buf;
    if (h_val == NULL) {
        return DUK_RET_TYPE_ERROR;
    }
 
    if (magic & 0x02) {
        /* non-zero: make copy */
        duk_uint8_t *p_copy;
        duk_size_t copy_length;
 
        p_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) slice_length);
        DUK_ASSERT(p_copy != NULL);
 
        /* Copy slice, respecting underlying buffer limits; remainder
         * is left as zero.
         */
        copy_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, slice_length);
        DUK_MEMCPY((void *) p_copy,
                   (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + start_offset),
                   copy_length);
 
        h_val = duk_get_hbuffer(ctx, -1);
        DUK_ASSERT(h_val != NULL);
 
        h_bufobj->buf = h_val;
        DUK_HBUFFER_INCREF(thr, h_val);
        h_bufobj->length = slice_length;
        DUK_ASSERT(h_bufobj->offset == 0);
 
        duk_pop(ctx);  /* reachable so pop OK */
    } else {
        h_bufobj->buf = h_val;
        DUK_HBUFFER_INCREF(thr, h_val);
        h_bufobj->length = slice_length;
        h_bufobj->offset = (duk_uint_t) (h_this->offset + start_offset);
 
        /* Copy the .buffer property, needed for TypedArray.prototype.subarray().

References duk_hbufferobject::buf, duk__clamp_startend_negidx_shifted(), duk__require_bufobj_this(), DUK_ASSERT, DUK_BIDX_OBJECT_PROTOTYPE, duk_get_current_magic(), duk_get_hbuffer(), duk_get_prop_stridx(), DUK_HBUFFER_INCREF, DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH, DUK_HBUFFEROBJECT_GET_SLICE_BASE, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_FLAG_BUFFEROBJECT, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_GET_CLASS_NUMBER, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_MEMCPY, duk_pop(), duk_pop_2(), DUK_PROPDESC_FLAGS_NONE, duk_push_bufferobject_raw(), duk_push_fixed_buffer, duk_push_this(), DUK_RET_TYPE_ERROR, DUK_STRIDX_LC_BUFFER, DUK_UNREF, duk_xdef_prop_stridx(), duk_hbufferobject::elem_type, duk_hthread::heap, duk_hbufferobject::is_view, duk_hbufferobject::length, NULL, duk_hbufferobject::offset, and duk_hbufferobject::shift.

◆ duk_bi_buffer_writefield()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_writefield ( duk_context * ctx )

Definition at line 24322 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
/* XXX: split into separate functions for each field type? */
DUK_INTERNAL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx) {
    duk_hthread *thr;
    duk_small_int_t magic = (duk_small_int_t) duk_get_current_magic(ctx);
    duk_small_int_t magic_ftype;
    duk_small_int_t magic_bigendian;
    duk_small_int_t magic_signed;
    duk_small_int_t magic_typedarray;
    duk_small_int_t endswap;
    duk_hbufferobject *h_this;
    duk_bool_t no_assert;
    duk_int_t offset_signed;
    duk_uint_t offset;
    duk_uint_t buffer_length;
    duk_uint_t check_length;
    duk_uint8_t *buf;
    duk_double_union du;
    duk_int_t nbytes = 0;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    magic_ftype = magic & 0x0007;
    magic_bigendian = magic & 0x0008;
    magic_signed = magic & 0x0010;
    magic_typedarray = magic & 0x0020;
    DUK_UNREF(magic_signed);
 
    h_this = duk__require_bufobj_this(ctx);
    DUK_ASSERT(h_this != NULL);
    buffer_length = h_this->length;
 
    /* [ value  offset noAssert                 ], when ftype != DUK__FLD_VARINT */
    /* [ value  offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */
    /* [ offset value  littleEndian             ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */
 
    /* Handle TypedArray vs. Node.js Buffer arg differences */
    if (magic_typedarray) {
        no_assert = 0;
#if defined(DUK_USE_INTEGER_LE)
        endswap = !duk_to_boolean(ctx, 2);  /* 1=little endian */
#else
        endswap = duk_to_boolean(ctx, 2);  /* 1=little endian */
#endif
        duk_swap(ctx, 0, 1);  /* offset/value order different from Node.js */
    } else {
        no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 3 : 2);
#if defined(DUK_USE_INTEGER_LE)
        endswap = magic_bigendian;
#else
        endswap = !magic_bigendian;
#endif
    }
 
    /* Offset is coerced first to signed integer range and then to unsigned.
     * This ensures we can add a small byte length (1-8) to the offset in
     * bound checks and not wrap.
     */
    offset_signed = duk_to_int(ctx, 1);
    offset = (duk_uint_t) offset_signed;
 
    /* We need 'nbytes' even for a failed offset; return value must be
     * (offset + nbytes) even when write fails due to invalid offset.
     */
    if (magic_ftype != DUK__FLD_VARINT) {
        DUK_ASSERT(magic_ftype >= 0 && magic_ftype < (duk_small_int_t) (sizeof(duk__buffer_nbytes_from_fldtype) / sizeof(duk_uint8_t)));
        nbytes = duk__buffer_nbytes_from_fldtype[magic_ftype];
    } else {
        nbytes = duk_get_int(ctx, 2);
        if (nbytes < 1 || nbytes > 6) {
            goto fail_field_length;
        }
    }
    DUK_ASSERT(nbytes >= 1 && nbytes <= 8);
 
    /* Now we can check offset validity. */
    if (offset_signed < 0) {
        goto fail_bounds;
    }
 
    DUK_DDD(DUK_DDDPRINT("writefield, value=%!T, buffer_length=%ld, offset=%ld, no_assert=%d, "
                         "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, "
                         "endswap=%d",
                         duk_get_tval(ctx, 0), (long) buffer_length, (long) offset, (int) no_assert,
                         (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3),
                         (int) (magic_signed >> 4), (int) endswap));
 
    /* Coerce value to a number before computing check_length, so that
     * the field type specific coercion below can't have side effects
     * that would invalidate check_length.
     */
    duk_to_number(ctx, 0);
 
    /* Update 'buffer_length' to be the effective, safe limit which
     * takes into account the underlying buffer.  This value will be
     * potentially invalidated by any side effect.
     */
    check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length);
    DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld",
                         (long) buffer_length, (long) check_length));
 
    if (h_this->buf) {
        buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this);
    } else {
        /* Neutered.  We could go into the switch-case safely with
         * buf == NULL because check_length == 0.  To avoid scanbuild
         * warnings, fail directly instead.
         */
        DUK_ASSERT(check_length == 0);
        goto fail_neutered;
    }
    DUK_ASSERT(buf != NULL);
 
    switch (magic_ftype) {
    case DUK__FLD_8BIT: {
        if (offset + 1U > check_length) {
            goto fail_bounds;
        }
        /* sign doesn't matter when writing */
        buf[offset] = (duk_uint8_t) duk_to_uint32(ctx, 0);
        break;
    }
    case DUK__FLD_16BIT: {
        duk_uint16_t tmp;
        if (offset + 2U > check_length) {
            goto fail_bounds;
        }
        tmp = (duk_uint16_t) duk_to_uint32(ctx, 0);
        if (endswap) {
            tmp = DUK_BSWAP16(tmp);
        }
        du.us[0] = tmp;
        /* sign doesn't matter when writing */
        DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 2);
        break;
    }
    case DUK__FLD_32BIT: {
        duk_uint32_t tmp;
        if (offset + 4U > check_length) {
            goto fail_bounds;
        }
        tmp = (duk_uint32_t) duk_to_uint32(ctx, 0);
        if (endswap) {
            tmp = DUK_BSWAP32(tmp);
        }
        du.ui[0] = tmp;
        /* sign doesn't matter when writing */
        DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4);
        break;
    }
    case DUK__FLD_FLOAT: {
        duk_uint32_t tmp;
        if (offset + 4U > check_length) {
            goto fail_bounds;
        }
        du.f[0] = (duk_float_t) duk_to_number(ctx, 0);
        if (endswap) {
            tmp = du.ui[0];
            tmp = DUK_BSWAP32(tmp);
            du.ui[0] = tmp;
        }
        /* sign doesn't matter when writing */
        DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4);
        break;
    }
    case DUK__FLD_DOUBLE: {
        if (offset + 8U > check_length) {
            goto fail_bounds;
        }
        du.d = (duk_double_t) duk_to_number(ctx, 0);
        if (endswap) {
            DUK_DBLUNION_BSWAP64(&du);
        }
        /* sign doesn't matter when writing */
        DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 8);
        break;
    }
    case DUK__FLD_VARINT: {
        /* Node.js Buffer variable width integer field.  We don't really
         * care about speed here, so aim for shortest algorithm.
         */
        duk_int_t field_bytelen;
        duk_int_t i, i_step, i_end;
#if defined(DUK_USE_64BIT_OPS)
        duk_int64_t tmp;
#else
        duk_double_t tmp;
#endif
        duk_uint8_t *p;
 
        field_bytelen = (duk_int_t) nbytes;
        if (offset + (duk_uint_t) field_bytelen > check_length) {
            goto fail_bounds;
        }
 
        /* Slow writing of value using either 64-bit arithmetic
         * or IEEE doubles if 64-bit types not available.  There's
         * no special sign handling when writing varints.
         */
 
        if (magic_bigendian) {
            /* Write in big endian */
            i = field_bytelen;  /* one i_step added at top of loop */
            i_step = -1;
            i_end = 0;
        } else {
            /* Write in little endian */
            i = -1;  /* one i_step added at top of loop */
            i_step = 1;
            i_end = field_bytelen - 1;
        }
 
        /* XXX: The duk_to_number() cast followed by integer coercion
         * is platform specific so NaN, +/- Infinity, and out-of-bounds
         * values result in platform specific output now.
         * See: test-bi-nodejs-buffer-proto-varint-special.js
         */
 
#if defined(DUK_USE_64BIT_OPS)
        tmp = (duk_int64_t) duk_to_number(ctx, 0);
        p = (duk_uint8_t *) (buf + offset);
        do {
            i += i_step;
            DUK_ASSERT(i >= 0 && i < field_bytelen);
            p[i] = (duk_uint8_t) (tmp & 0xff);
            tmp = tmp >> 8;  /* unnecessary shift for last byte */
        } while (i != i_end);
#else
        tmp = duk_to_number(ctx, 0);
        p = (duk_uint8_t *) (buf + offset);
        do {
            i += i_step;
            tmp = DUK_FLOOR(tmp);
            DUK_ASSERT(i >= 0 && i < field_bytelen);
            p[i] = (duk_uint8_t) (DUK_FMOD(tmp, 256.0));
            tmp = tmp / 256.0;  /* unnecessary div for last byte */
        } while (i != i_end);
#endif
        break;
    }
    default: {  /* should never happen but default here */
        goto fail_bounds;
    }
    }
 
    /* Node.js Buffer: return offset + #bytes written (i.e. next
     * write offset).
     */
    if (magic_typedarray) {
        /* For TypedArrays 'undefined' return value is specified
         * by ES6 (matches V8).
         */
        return 0;
    }
    duk_push_uint(ctx, offset + nbytes);
    return 1;
 
 fail_neutered:

◆ duk_bi_dataview_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_dataview_constructor ( duk_context * ctx )

Definition at line 22831 of file duktape-1.8.0/src/duktape.c.

               :
    return DUK_RET_RANGE_ERROR;
}
#else  /* DUK_USE_BUFFEROBJECT_SUPPORT */
DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx) {
    duk_hbufferobject *h_bufarg;
    duk_hbufferobject *h_bufobj;
    duk_hbuffer *h_val;
    duk_uint_t offset;
    duk_uint_t length;
 
    /* XXX: function flag to make this automatic? */
    if (!duk_is_constructor_call(ctx)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    h_bufarg = duk__require_bufobj_value(ctx, 0);
    DUK_ASSERT(h_bufarg != NULL);
 
    duk__resolve_offset_opt_length(ctx, h_bufarg, 1, 2, &offset, &length, 1 /*throw_flag*/);
    DUK_ASSERT(offset <= h_bufarg->length);
    DUK_ASSERT(offset + length <= h_bufarg->length);
 
    h_bufobj = duk_push_bufferobject_raw(ctx,
                                         DUK_HOBJECT_FLAG_EXTENSIBLE |
                                         DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                         DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATAVIEW),
                                         DUK_BIDX_DATAVIEW_PROTOTYPE);
 
    h_val = h_bufarg->buf;
    if (h_val == NULL) {
        return DUK_RET_TYPE_ERROR;
    }
    h_bufobj->buf = h_val;
    DUK_HBUFFER_INCREF(thr, h_val);
    h_bufobj->offset = h_bufarg->offset + offset;
    h_bufobj->length = length;
    DUK_ASSERT(h_bufobj->shift == 0);
    DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8);
    h_bufobj->is_view = 1;
 
    /* The DataView .buffer property is ordinarily set to the argument

◆ duk_bi_date_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor ( duk_context * ctx )

Definition at line 26045 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_small_int_t magicidx = (duk_small_uint_t) duk_get_current_magic(ctx);
    DUK_ASSERT(magicidx >= 0 && magicidx < (duk_small_int_t) (sizeof(duk__date_magics) / sizeof(duk_uint16_t)));
    return (duk_small_uint_t) duk__date_magics[magicidx];
}
 
/*
 *  Constructor calls
 */
 
DUK_INTERNAL duk_ret_t duk_bi_date_constructor(duk_context *ctx) {
    duk_idx_t nargs = duk_get_top(ctx);
    duk_bool_t is_cons = duk_is_constructor_call(ctx);
    duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS];
    duk_double_t d;
 
    DUK_DDD(DUK_DDDPRINT("Date constructor, nargs=%ld, is_cons=%ld", (long) nargs, (long) is_cons));
 
    duk_push_object_helper(ctx,
                           DUK_HOBJECT_FLAG_EXTENSIBLE |
                           DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATE),
                           DUK_BIDX_DATE_PROTOTYPE);
 
    /* Unlike most built-ins, the internal [[PrimitiveValue]] of a Date
     * is mutable.
     */
 
    if (nargs == 0 || !is_cons) {
        d = duk__timeclip(DUK_USE_DATE_GET_NOW(ctx));
        duk_push_number(ctx, d);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W);
        if (!is_cons) {
            /* called as a normal function: return new Date().toString() */
            duk_to_string(ctx, -1);
        }
        return 1;
    } else if (nargs == 1) {
        duk_to_primitive(ctx, 0, DUK_HINT_NONE);
        if (duk_is_string(ctx, 0)) {

◆ duk_bi_date_constructor_now()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_now ( duk_context * ctx )

Definition at line 26115 of file duktape-1.8.0/src/duktape.c.

26122 {

References duk_push_nan().

◆ duk_bi_date_constructor_parse()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_parse ( duk_context * ctx )

Definition at line 26092 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_date_constructor_utc()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_utc ( duk_context * ctx )

Definition at line 26096 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    return duk__parse_string(ctx, duk_to_string(ctx, 0));
}
 
DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx) {

◆ duk_bi_date_format_timeval()

DUK_INTERNAL_DECL void duk_bi_date_format_timeval	(	duk_double_t	timeval,
		duk_uint8_t *	out_buf )

Definition at line 25886 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_date_get_local_tzoffset_gmtime()

DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_gmtime ( duk_double_t d )

Definition at line 26390 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    time_t t;
 
    DUK_UNREF(ctx);
    t = time(NULL);
    return ((duk_double_t) t) * 1000.0;
}
#endif  /* DUK_USE_DATE_NOW_TIME */
 
#if defined(DUK_USE_DATE_TZO_GMTIME) || defined(DUK_USE_DATE_TZO_GMTIME_R)
/* Get local time offset (in seconds) for a certain (UTC) instant 'd'. */
DUK_INTERNAL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d) {
    time_t t, t1, t2;
    duk_int_t parts[DUK_DATE_IDX_NUM_PARTS];
    duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS];
    struct tm tms[2];
#ifdef DUK_USE_DATE_TZO_GMTIME
    struct tm *tm_ptr;
#endif
 
    /* For NaN/inf, the return value doesn't matter. */
    if (!DUK_ISFINITE(d)) {
        return 0;
    }
 
    /* If not within Ecmascript range, some integer time calculations
     * won't work correctly (and some asserts will fail), so bail out
     * if so.  This fixes test-bug-date-insane-setyear.js.  There is
     * a +/- 24h leeway in this range check to avoid a test262 corner
     * case documented in test-bug-date-timeval-edges.js.
     */
    if (!duk_bi_date_timeval_in_leeway_range(d)) {
        DUK_DD(DUK_DDPRINT("timeval not within valid range, skip tzoffset computation to avoid integer overflows"));
        return 0;
    }
 
    /*
     *  This is a bit tricky to implement portably.  The result depends
     *  on the timestamp (specifically, DST depends on the timestamp).
     *  If e.g. UNIX APIs are used, they'll have portability issues with
     *  very small and very large years.
     *
     *  Current approach:
     *
     *  - Stay within portable UNIX limits by using equivalent year mapping.
     *    Avoid year 1970 and 2038 as some conversions start to fail, at
     *    least on some platforms.  Avoiding 1970 means that there are
     *    currently DST discrepancies for 1970.
     *
     *  - Create a UTC and local time breakdowns from 't'.  Then create
     *    a time_t using gmtime() and localtime() and compute the time
     *    difference between the two.
     *
     *  Equivalent year mapping (E5 Section 15.9.1.8):
     *
     *    If the host environment provides functionality for determining
     *    daylight saving time, the implementation of ECMAScript is free
     *    to map the year in question to an equivalent year (same
     *    leap-year-ness and same starting week day for the year) for which
     *    the host environment provides daylight saving time information.
     *    The only restriction is that all equivalent years should produce
     *    the same result.
     *
     *  This approach is quite reasonable but not entirely correct, e.g.
     *  the specification also states (E5 Section 15.9.1.8):
     *
     *    The implementation of ECMAScript should not try to determine
     *    whether the exact time was subject to daylight saving time, but
     *    just whether daylight saving time would have been in effect if
     *    the _current daylight saving time algorithm_ had been used at the
     *    time.  This avoids complications such as taking into account the
     *    years that the locale observed daylight saving time year round.
     *
     *  Since we rely on the platform APIs for conversions between local
     *  time and UTC, we can't guarantee the above.  Rather, if the platform
     *  has historical DST rules they will be applied.  This seems to be the
     *  general preferred direction in Ecmascript standardization (or at least
     *  implementations) anyway, and even the equivalent year mapping should
     *  be disabled if the platform is known to handle DST properly for the
     *  full Ecmascript range.
     *
     *  The following has useful discussion and links:
     *
     *    https://bugzilla.mozilla.org/show_bug.cgi?id=351066
     */
 
    duk_bi_date_timeval_to_parts(d, parts, dparts, DUK_DATE_FLAG_EQUIVYEAR /*flags*/);
    DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= 1970 && parts[DUK_DATE_IDX_YEAR] <= 2038);
 
    d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/);
    DUK_ASSERT(d >= 0 && d < 2147483648.0 * 1000.0);  /* unsigned 31-bit range */
    t = (time_t) (d / 1000.0);
    DUK_DDD(DUK_DDDPRINT("timeval: %lf -> time_t %ld", (double) d, (long) t));
 
    DUK_MEMZERO((void *) tms, sizeof(struct tm) * 2);
 
#if defined(DUK_USE_DATE_TZO_GMTIME_R)
    (void) gmtime_r(&t, &tms[0]);
    (void) localtime_r(&t, &tms[1]);
#elif defined(DUK_USE_DATE_TZO_GMTIME)
    tm_ptr = gmtime(&t);
    DUK_MEMCPY((void *) &tms[0], tm_ptr, sizeof(struct tm));
    tm_ptr = localtime(&t);
    DUK_MEMCPY((void *) &tms[1], tm_ptr, sizeof(struct tm));
#else
#error internal error
#endif
    DUK_DDD(DUK_DDDPRINT("gmtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
                         "wday:%ld,yday:%ld,isdst:%ld}",
                         (long) tms[0].tm_sec, (long) tms[0].tm_min, (long) tms[0].tm_hour,
                         (long) tms[0].tm_mday, (long) tms[0].tm_mon, (long) tms[0].tm_year,
                         (long) tms[0].tm_wday, (long) tms[0].tm_yday, (long) tms[0].tm_isdst));
    DUK_DDD(DUK_DDDPRINT("localtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
                         "wday:%ld,yday:%ld,isdst:%ld}",
                         (long) tms[1].tm_sec, (long) tms[1].tm_min, (long) tms[1].tm_hour,
                         (long) tms[1].tm_mday, (long) tms[1].tm_mon, (long) tms[1].tm_year,
                         (long) tms[1].tm_wday, (long) tms[1].tm_yday, (long) tms[1].tm_isdst));
 
    /* tm_isdst is both an input and an output to mktime(), use 0 to
     * avoid DST handling in mktime():
     * - https://github.com/svaarala/duktape/issues/406
     * - http://stackoverflow.com/questions/8558919/mktime-and-tm-isdst
     */
    tms[0].tm_isdst = 0;
    tms[1].tm_isdst = 0;
    t1 = mktime(&tms[0]);  /* UTC */
    t2 = mktime(&tms[1]);  /* local */
    if (t1 == (time_t) -1 || t2 == (time_t) -1) {
        /* This check used to be for (t < 0) but on some platforms
         * time_t is unsigned and apparently the proper way to detect
         * an mktime() error return is the cast above.  See e.g.:
         * http://pubs.opengroup.org/onlinepubs/009695299/functions/mktime.html
         */
        goto error;
    }
    DUK_DDD(DUK_DDDPRINT("t1=%ld (utc), t2=%ld (local)", (long) t1, (long) t2));
 

◆ duk_bi_date_get_now_time()

DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_time ( duk_context * ctx )

Definition at line 26379 of file duktape-1.8.0/src/duktape.c.

                                      {
        DUK_ERROR_INTERNAL_DEFMSG(thr);
    }
 

◆ duk_bi_date_get_timeval_from_dparts()

DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_timeval_from_dparts	(	duk_double_t *	dparts,
		duk_small_uint_t	flags )

Definition at line 25363 of file duktape-1.8.0/src/duktape.c.

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

Referenced by duk__format_parts_iso8601().

◆ duk_bi_date_is_leap_year()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_is_leap_year ( duk_int_t year )

Definition at line 25053 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_date_prototype_get_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_shared ( duk_context * ctx )

Definition at line 26240 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_date_prototype_get_timezone_offset()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_timezone_offset ( duk_context * ctx )

Definition at line 26245 of file duktape-1.8.0/src/duktape.c.

         :
 *
 *    - Date.prototype.getDate(): 'date' means day-of-month, and is
 *      zero-based in internal calculations but public API expects it to
 *      be one-based.
 *
 *    - Date.prototype.getTime() and Date.prototype.valueOf() have identical
 *      behavior.  They have separate function objects, but share the same C
 *      function (duk_bi_date_prototype_value_of).
 */
 
DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_shared(duk_context *ctx) {
    duk_small_uint_t flags_and_idx = duk__date_get_indirect_magic(ctx);
    return duk__get_part_helper(ctx, flags_and_idx);
}
 
DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ctx) {
    /*
     *  Return (t - LocalTime(t)) in minutes:
     *
     *    t - LocalTime(t) = t - (t + LocalTZA + DaylightSavingTA(t))
     *                     = -(LocalTZA + DaylightSavingTA(t))
     *
     *  where DaylightSavingTA() is checked for time 't'.
     *
     *  Note that the sign of the result is opposite to common usage,
     *  e.g. for EE(S)T which normally is +2h or +3h from UTC, this
     *  function returns -120 or -180.
     *

References duk__date_get_indirect_magic(), and duk__get_part_helper().

◆ duk_bi_date_prototype_set_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_shared ( duk_context * ctx )

Definition at line 26325 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_date_prototype_set_time()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_time ( duk_context * ctx )

Definition at line 26330 of file duktape-1.8.0/src/duktape.c.

                                                     : special year check
 *      is omitted.  NaN / Infinity will just flow through and ultimately
 *      result in a NaN internal time value.
 *
 *    - Date.prototype.setYear() does not have optional arguments for
 *      setting month and day-in-month (like setFullYear()), but we indicate
 *      'maxnargs' to be 3 to get the year written to the correct component
 *      index in duk__set_part_helper().  The function has nargs == 1, so only
 *      the year will be set regardless of actual argument count.
 */

References duk__date_get_indirect_magic(), and duk__set_part_helper().

◆ duk_bi_date_prototype_to_json()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_to_json ( duk_context * ctx )

Definition at line 26174 of file duktape-1.8.0/src/duktape.c.

                                                                               {
    duk_small_uint_t flags = duk__date_get_indirect_magic(ctx);
    return duk__to_string_helper(ctx, flags);
}
 
DUK_INTERNAL duk_ret_t duk_bi_date_prototype_value_of(duk_context *ctx) {
    /* This native function is also used for Date.prototype.getTime()
     * as their behavior is identical.
     */
 
    duk_double_t d = duk__push_this_get_timeval(ctx, 0 /*flags*/);  /* -> [ this ] */
    DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d));
    duk_push_number(ctx, d);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_date_prototype_to_json(duk_context *ctx) {
    /* Note: toJSON() is a generic function which works even if 'this'
     * is not a Date.  The sole argument is ignored.
     */
 
    duk_push_this(ctx);
    duk_to_object(ctx, -1);

References duk__date_get_indirect_magic(), and duk__to_string_helper().

◆ duk_bi_date_prototype_tostring_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_tostring_shared ( duk_context * ctx )

Definition at line 26158 of file duktape-1.8.0/src/duktape.c.

26160 :

26161 *

◆ duk_bi_date_prototype_value_of()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_value_of ( duk_context * ctx )

Definition at line 26163 of file duktape-1.8.0/src/duktape.c.

                                    : E5.1 specification does not require a
 *      specific format, but result should be human readable.  The
 *      specification suggests using ISO 8601 format with a space (instead
 *      of 'T') separator if a more human readable format is not available.
 *
 *    - Date.prototype.toISOString(): unlike other conversion functions,
 *      toISOString() requires a RangeError for invalid date values.

◆ duk_bi_date_timeval_in_leeway_range()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_leeway_range ( duk_double_t x )

Definition at line 25070 of file duktape-1.8.0/src/duktape.c.

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

◆ duk_bi_date_timeval_in_valid_range()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_valid_range ( duk_double_t x )

Definition at line 25066 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__div_floor().

◆ duk_bi_date_timeval_to_parts()

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

Definition at line 25218 of file duktape-1.8.0/src/duktape.c.

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

References duk__days_in_month.

◆ duk_bi_date_year_in_valid_range()

DUK_INTERNAL_DECL duk_bool_t duk_bi_date_year_in_valid_range ( duk_double_t year )

Definition at line 25074 of file duktape-1.8.0/src/duktape.c.

                           {
        return 1;
    }

◆ duk_bi_duktape_object_act()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_act ( duk_context * ctx )

Definition at line 26884 of file duktape-1.8.0/src/duktape.c.

     :
    /* set values into ret array */
    /* XXX: primitive to make array from valstack slice */
    n = duk_get_top(ctx);
    for (i = 2; i < n; i++) {
        duk_dup(ctx, i);
        duk_put_prop_index(ctx, 1, i - 2);
    }
    duk_dup(ctx, 1);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_uint_fast32_t pc;
    duk_uint_fast32_t line;
    duk_int_t level;
 
    /* -1             = top callstack entry, callstack[callstack_top - 1]
     * -callstack_top = bottom callstack entry, callstack[0]
     */
    level = duk_to_int(ctx, 0);
    if (level >= 0 || -level > (duk_int_t) thr->callstack_top) {
        return 0;
    }
    DUK_ASSERT(level >= -((duk_int_t) thr->callstack_top) && level <= -1);
    act = thr->callstack + thr->callstack_top + level;
 
    duk_push_object(ctx);
 
    duk_push_tval(ctx, &act->tv_func);
 
    /* Relevant PC is just before current one because PC is
     * post-incremented.  This should match what error augment
     * code does.
     */
    pc = duk_hthread_get_act_prev_pc(thr, act);
    duk_push_uint(ctx, (duk_uint_t) pc);
 
#if defined(DUK_USE_PC2LINE)
    line = duk_hobject_pc2line_query(ctx, -2, pc);
#else
    line = 0;

◆ duk_bi_duktape_object_compact()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_compact ( duk_context * ctx )

Definition at line 27067 of file duktape-1.8.0/src/duktape.c.

                                                    {
        duk_bi_json_parse_helper(ctx,
                                 1 /*idx_value*/,
                                 2 /*idx_replacer*/,

◆ duk_bi_duktape_object_dec()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_dec ( duk_context * ctx )

Definition at line 27021 of file duktape-1.8.0/src/duktape.c.

                                                    {
        duk_bi_json_stringify_helper(ctx,
                                     1 /*idx_value*/,
                                     2 /*idx_replacer*/,
                                     3 /*idx_space*/,
                                     DUK_JSON_FLAG_EXT_COMPATIBLE |
                                     DUK_JSON_FLAG_ASCII_ONLY /*flags*/);
#endif
    } else {
        return DUK_RET_TYPE_ERROR;
    }
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_duktape_object_dec(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_str;
 
    DUK_UNREF(thr);
 
    /* Vararg function: must be careful to check/require arguments.
     * The JSON helpers accept invalid indices and treat them like
     * non-existent optional parameters.
     */
 
    h_str = duk_require_hstring(ctx, 0);
    duk_require_valid_index(ctx, 1);
 
    if (h_str == DUK_HTHREAD_STRING_HEX(thr)) {
        duk_set_top(ctx, 2);
        duk_hex_decode(ctx, 1);
        DUK_ASSERT_TOP(ctx, 2);
    } else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) {
        duk_set_top(ctx, 2);
        duk_base64_decode(ctx, 1);
        DUK_ASSERT_TOP(ctx, 2);
#ifdef DUK_USE_JX
    } else if (h_str == DUK_HTHREAD_STRING_JX(thr)) {

◆ duk_bi_duktape_object_enc()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_enc ( duk_context * ctx )

Definition at line 26974 of file duktape-1.8.0/src/duktape.c.

           {
        /* Get. */
        DUK_ASSERT(duk_get_top(ctx) == 1);
        duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_FINALIZER);
        return 1;
    }
}
 
DUK_INTERNAL duk_ret_t duk_bi_duktape_object_enc(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_str;
 
    DUK_UNREF(thr);
 
    /* Vararg function: must be careful to check/require arguments.
     * The JSON helpers accept invalid indices and treat them like
     * non-existent optional parameters.
     */
 
    h_str = duk_require_hstring(ctx, 0);
    duk_require_valid_index(ctx, 1);
 
    if (h_str == DUK_HTHREAD_STRING_HEX(thr)) {
        duk_set_top(ctx, 2);
        duk_hex_encode(ctx, 1);
        DUK_ASSERT_TOP(ctx, 2);
    } else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) {
        duk_set_top(ctx, 2);
        duk_base64_encode(ctx, 1);
        DUK_ASSERT_TOP(ctx, 2);
#ifdef DUK_USE_JX
    } else if (h_str == DUK_HTHREAD_STRING_JX(thr)) {
        duk_bi_json_stringify_helper(ctx,
                                     1 /*idx_value*/,
                                     2 /*idx_replacer*/,
                                     3 /*idx_space*/,
                                     DUK_JSON_FLAG_EXT_CUSTOM |

◆ duk_bi_duktape_object_fin()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_fin ( duk_context * ctx )

Definition at line 26954 of file duktape-1.8.0/src/duktape.c.

26971 {

26972 (void) duk_require_hobject(ctx, 0);

◆ duk_bi_duktape_object_gc()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_gc ( duk_context * ctx )

Definition at line 26934 of file duktape-1.8.0/src/duktape.c.

26951 {

26952#ifdef DUK_USE_MARK_AND_SWEEP

◆ duk_bi_duktape_object_info()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_info ( duk_context * ctx )

Definition at line 26770 of file duktape-1.8.0/src/duktape.c.

                          : it might seem that vararg multipurpose functions
 *  like fin(), enc(), and dec() are not very size optimal, but using a single
 *  user-visible Ecmascript function saves a lot of run-time footprint; each
 *  Function instance takes >100 bytes.  Using a shared native helper and a
 *  'magic' value won't save much if there are multiple Function instances
 *  anyway.
 */
 
/* include removed: duk_internal.h */
 
/* Raw helper to extract internal information / statistics about a value.
 * The return values are version specific and must not expose anything
 * that would lead to security issues (e.g. exposing compiled function
 * 'data' buffer might be an issue).  Currently only counts and sizes and
 * such are given so there should not be a security impact.
 */
DUK_INTERNAL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_heaphdr *h;
    duk_int_t i, n;
 
    DUK_UNREF(thr);
 
    /* result array */
    duk_push_array(ctx);  /* -> [ val arr ] */
 
    /* type tag (public) */
    duk_push_int(ctx, duk_get_type(ctx, 0));
 
    /* address */
    tv = duk_get_tval(ctx, 0);
    DUK_ASSERT(tv != NULL);  /* because arg count is 1 */
    if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
        h = DUK_TVAL_GET_HEAPHDR(tv);
        duk_push_pointer(ctx, (void *) h);
    } else {
        /* internal type tag */
        duk_push_int(ctx, (duk_int_t) DUK_TVAL_GET_TAG(tv));
        goto done;
    }
    DUK_ASSERT(h != NULL);
 
    /* refcount */
#ifdef DUK_USE_REFERENCE_COUNTING
    duk_push_size_t(ctx, DUK_HEAPHDR_GET_REFCOUNT(h));
#else
    duk_push_undefined(ctx);
#endif
 
    /* heaphdr size and additional allocation size, followed by
     * type specific stuff (with varying value count)
     */
    switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
    case DUK_HTYPE_STRING: {
        duk_hstring *h_str = (duk_hstring *) h;
        duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hstring) + DUK_HSTRING_GET_BYTELEN(h_str) + 1));
        break;
    }
    case DUK_HTYPE_OBJECT: {
        duk_hobject *h_obj = (duk_hobject *) h;
        duk_small_uint_t hdr_size;
        if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
            hdr_size = (duk_small_uint_t) sizeof(duk_hcompiledfunction);
        } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h_obj)) {
            hdr_size = (duk_small_uint_t) sizeof(duk_hnativefunction);
        } else if (DUK_HOBJECT_IS_THREAD(h_obj)) {
            hdr_size = (duk_small_uint_t) sizeof(duk_hthread);
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
        } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
            hdr_size = (duk_small_uint_t) sizeof(duk_hbufferobject);
#endif
        } else {
            hdr_size = (duk_small_uint_t) sizeof(duk_hobject);
        }
        duk_push_uint(ctx, (duk_uint_t) hdr_size);
        duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_P_ALLOC_SIZE(h_obj));
        duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ESIZE(h_obj));
        /* Note: e_next indicates the number of gc-reachable entries
         * in the entry part, and also indicates the index where the
         * next new property would be inserted.  It does *not* indicate
         * the number of non-NULL keys present in the object.  That
         * value could be counted separately but requires a pass through
         * the key list.
         */
        duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ENEXT(h_obj));
        duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ASIZE(h_obj));
        duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_HSIZE(h_obj));
        if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
            duk_hbuffer *h_data = (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, (duk_hcompiledfunction *) h_obj);
            if (h_data) {
                duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_data));
            } else {
                duk_push_uint(ctx, 0);
            }
        }
        break;
    }
    case DUK_HTYPE_BUFFER: {
        duk_hbuffer *h_buf = (duk_hbuffer *) h;
        if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) {
            if (DUK_HBUFFER_HAS_EXTERNAL(h_buf)) {
                duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_external)));
            } else {
                /* When alloc_size == 0 the second allocation may not
                 * actually exist.
                 */
                duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_dynamic)));
            }
            duk_push_uint(ctx, (duk_uint_t) (DUK_HBUFFER_GET_SIZE(h_buf)));
        } else {
            duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1));

References DUK_ASSERT, duk_get_tval(), duk_get_type(), DUK_HBUFFER_GET_SIZE, DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_HCOMPILEDFUNCTION_GET_DATA, DUK_HEAPHDR_GET_REFCOUNT, DUK_HEAPHDR_GET_TYPE, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_GET_ENEXT, DUK_HOBJECT_GET_ESIZE, DUK_HOBJECT_GET_HSIZE, DUK_HOBJECT_IS_BUFFEROBJECT, DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_HOBJECT_IS_THREAD, DUK_HOBJECT_P_ALLOC_SIZE, DUK_HSTRING_GET_BYTELEN, DUK_HTYPE_BUFFER, DUK_HTYPE_OBJECT, DUK_HTYPE_STRING, duk_push_array(), duk_push_int(), duk_push_pointer(), duk_push_size_t, duk_push_uint(), duk_push_undefined(), DUK_TVAL_GET_HEAPHDR, DUK_TVAL_GET_TAG, DUK_TVAL_IS_HEAP_ALLOCATED, DUK_UNREF, duk_hthread::heap, and NULL.

◆ duk_bi_error_constructor_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_constructor_shared ( duk_context * ctx )

Definition at line 27079 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    DUK_ASSERT_TOP(ctx, 1);
    duk_compact(ctx, 0);
    return 1;  /* return the argument object */
}
#line 1 "duk_bi_error.c"
/*
 *  Error built-ins
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx) {
    /* Behavior for constructor and non-constructor call is
     * the same except for augmenting the created error.  When
     * called as a constructor, the caller (duk_new()) will handle
     * augmentation; when called as normal function, we need to do
     * it here.
     */
 
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_int_t bidx_prototype = duk_get_current_magic(ctx);
 
    /* same for both error and each subclass like TypeError */
    duk_uint_t flags_and_class = DUK_HOBJECT_FLAG_EXTENSIBLE |
                                 DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR);
 
    DUK_UNREF(thr);
 
    duk_push_object_helper(ctx, flags_and_class, bidx_prototype);
 
    /* If message is undefined, the own property 'message' is not set at
     * all to save property space.  An empty message is inherited anyway.
     */
    if (!duk_is_undefined(ctx, 0)) {

References DUK_ASSERT_TOP, and duk_compact().

◆ duk_bi_error_prototype_filename_getter()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_filename_getter ( duk_context * ctx )

Definition at line 27374 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_error_prototype_filename_setter()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_filename_setter ( duk_context * ctx )

Definition at line 27449 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_error_prototype_linenumber_getter()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_getter ( duk_context * ctx )

Definition at line 27378 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_error_prototype_linenumber_setter()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_setter ( duk_context * ctx )

Definition at line 27453 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_error_prototype_stack_getter()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_stack_getter ( duk_context * ctx )

Definition at line 27370 of file duktape-1.8.0/src/duktape.c.

27371 {

27372 return 0;

◆ duk_bi_error_prototype_stack_setter()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_stack_setter ( duk_context * ctx )

Definition at line 27445 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_error_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_to_string ( duk_context * ctx )

Definition at line 27120 of file duktape-1.8.0/src/duktape.c.

                                       {
        duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/);
    }
#endif
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx) {
    /* XXX: optimize with more direct internal access */
 
    duk_push_this(ctx);
    (void) duk_require_hobject_or_lfunc_coerce(ctx, -1);
 
    /* [ ... this ] */
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
    if (duk_is_undefined(ctx, -1)) {
        duk_pop(ctx);
        duk_push_string(ctx, "Error");
    } else {
        duk_to_string(ctx, -1);
    }
 
    /* [ ... this name ] */
 
    /* XXX: Are steps 6 and 7 in E5 Section 15.11.4.4 duplicated by
     * accident or are they actually needed?  The first ToString()
     * could conceivably return 'undefined'.
     */
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE);
    if (duk_is_undefined(ctx, -1)) {
        duk_pop(ctx);
        duk_push_string(ctx, "");
    } else {
        duk_to_string(ctx, -1);
    }
 

◆ duk_bi_function_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_constructor ( duk_context * ctx )

Definition at line 27463 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    return duk__error_setter_helper(ctx, DUK_STRIDX_FILE_NAME);
}
 
DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_setter(duk_context *ctx) {
    return duk__error_setter_helper(ctx, DUK_STRIDX_LINE_NUMBER);
}
#line 1 "duk_bi_function.c"
/*
 *  Function built-ins
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL duk_ret_t duk_bi_function_constructor(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_sourcecode;
    duk_idx_t nargs;
    duk_idx_t i;
    duk_small_uint_t comp_flags;
    duk_hcompiledfunction *func;
    duk_hobject *outer_lex_env;
    duk_hobject *outer_var_env;
 
    /* normal and constructor calls have identical semantics */
 
    nargs = duk_get_top(ctx);
    for (i = 0; i < nargs; i++) {
        duk_to_string(ctx, i);
    }
 
    if (nargs == 0) {
        duk_push_string(ctx, "");
        duk_push_string(ctx, "");
    } else if (nargs == 1) {
        /* XXX: cover this with the generic >1 case? */
        duk_push_string(ctx, "");
    } else {
        duk_insert(ctx, 0);   /* [ arg1 ... argN-1 body] -> [body arg1 ... argN-1] */
        duk_push_string(ctx, ",");
        duk_insert(ctx, 1);
        duk_join(ctx, nargs - 1);
    }
 
    /* [ body formals ], formals is comma separated list that needs to be parsed */
 
    DUK_ASSERT_TOP(ctx, 2);
 
    /* XXX: this placeholder is not always correct, but use for now.
     * It will fail in corner cases; see test-dev-func-cons-args.js.
     */
    duk_push_string(ctx, "function(");
    duk_dup(ctx, 1);
    duk_push_string(ctx, "){");
    duk_dup(ctx, 0);
    duk_push_string(ctx, "}");
    duk_concat(ctx, 5);
 
    /* [ body formals source ] */
 
    DUK_ASSERT_TOP(ctx, 3);
 
    /* strictness is not inherited, intentional */
    comp_flags = DUK_JS_COMPILE_FLAG_FUNCEXPR;
 
    duk_push_hstring_stridx(ctx, DUK_STRIDX_COMPILE);  /* XXX: copy from caller? */  /* XXX: ignored now */
    h_sourcecode = duk_require_hstring(ctx, -2);
    duk_js_compile(thr,
                   (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode),
                   (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode),
                   comp_flags);
    func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
    DUK_ASSERT(func != NULL);

◆ duk_bi_function_prototype()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype ( duk_context * ctx )

Definition at line 27540 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_function_prototype_apply()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_apply ( duk_context * ctx )

Definition at line 27613 of file duktape-1.8.0/src/duktape.c.

                                               {
            duk_push_sprintf(ctx, "function %s() {\"bound\"}", (const char *) func_name);
        } else {
            goto type_error;
        }
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_push_lightfunc_tostring(ctx, tv);
    } else {
        goto type_error;
    }
 
    return 1;
 
 type_error:
    return DUK_RET_TYPE_ERROR;
}
 
DUK_INTERNAL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx) {
    duk_idx_t len;
    duk_idx_t i;
 
    DUK_ASSERT_TOP(ctx, 2);  /* not a vararg function */
 
    duk_push_this(ctx);
    if (!duk_is_callable(ctx, -1)) {
        DUK_DDD(DUK_DDDPRINT("func is not callable"));
        goto type_error;
    }
    duk_insert(ctx, 0);
    DUK_ASSERT_TOP(ctx, 3);
 
    DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argArray=%!iT",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (duk_tval *) duk_get_tval(ctx, 2)));
 
    /* [ func thisArg argArray ] */
 
    if (duk_is_null_or_undefined(ctx, 2)) {
        DUK_DDD(DUK_DDDPRINT("argArray is null/undefined, no args"));
        len = 0;
    } else if (!duk_is_object(ctx, 2)) {
        goto type_error;
    } else {
        DUK_DDD(DUK_DDDPRINT("argArray is an object"));
 
        /* XXX: make this an internal helper */
        duk_get_prop_stridx(ctx, 2, DUK_STRIDX_LENGTH);
        len = (duk_idx_t) duk_to_uint32(ctx, -1);  /* ToUint32() coercion required */
        duk_pop(ctx);
 
        duk_require_stack(ctx, len);
 
        DUK_DDD(DUK_DDDPRINT("argArray length is %ld", (long) len));
        for (i = 0; i < len; i++) {
            duk_get_prop_index(ctx, 2, i);

◆ duk_bi_function_prototype_bind()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_bind ( duk_context * ctx )

Definition at line 27707 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    duk_hobject *h_bound;
    duk_hobject *h_target;
    duk_idx_t nargs;
    duk_idx_t i;
 
    /* vararg function, careful arg handling (e.g. thisArg may not be present) */
    nargs = duk_get_top(ctx);  /* = 1 + arg count */
    if (nargs == 0) {
        duk_push_undefined(ctx);
        nargs++;
    }
    DUK_ASSERT(nargs >= 1);
 
    duk_push_this(ctx);
    if (!duk_is_callable(ctx, -1)) {
        DUK_DDD(DUK_DDDPRINT("func is not callable"));
        goto type_error;
    }
 
    /* [ thisArg arg1 ... argN func ]  (thisArg+args == nargs total) */
    DUK_ASSERT_TOP(ctx, nargs + 1);
 
    /* create bound function object */
    duk_push_object_helper(ctx,
                           DUK_HOBJECT_FLAG_EXTENSIBLE |
                           DUK_HOBJECT_FLAG_BOUND |
                           DUK_HOBJECT_FLAG_CONSTRUCTABLE |
                           DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION),
                           DUK_BIDX_FUNCTION_PROTOTYPE);
    h_bound = duk_get_hobject(ctx, -1);
    DUK_ASSERT(h_bound != NULL);
 
    /* [ thisArg arg1 ... argN func boundFunc ] */
    duk_dup(ctx, -2);  /* func */
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
 
    duk_dup(ctx, 0);   /* thisArg */
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);
 
    duk_push_array(ctx);
 
    /* [ thisArg arg1 ... argN func boundFunc argArray ] */
 
    for (i = 0; i < nargs - 1; i++) {
        duk_dup(ctx, 1 + i);
        duk_put_prop_index(ctx, -2, i);
    }
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_ARGS, DUK_PROPDESC_FLAGS_NONE);
 
    /* [ thisArg arg1 ... argN func boundFunc ] */
 
    /* bound function 'length' property is interesting */
    h_target = duk_get_hobject(ctx, -2);
    if (h_target == NULL ||  /* lightfunc */
        DUK_HOBJECT_GET_CLASS_NUMBER(h_target) == DUK_HOBJECT_CLASS_FUNCTION) {
        /* For lightfuncs, simply read the virtual property. */
        duk_int_t tmp;
        duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH);
        tmp = duk_to_int(ctx, -1) - (nargs - 1);  /* step 15.a */
        duk_pop(ctx);
        duk_push_int(ctx, (tmp < 0 ? 0 : tmp));
    } else {
        duk_push_int(ctx, 0);
    }
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);  /* attrs in E5 Section 15.3.5.1 */
 
    /* caller and arguments must use the same thrower, [[ThrowTypeError]] */
    duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
    duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE);
 
    /* these non-standard properties are copied for convenience */
    /* XXX: 'copy properties' API call? */
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_WC);
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC);
 
    /* The 'strict' flag is copied to get the special [[Get]] of E5.1

◆ duk_bi_function_prototype_call()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_call ( duk_context * ctx )

Definition at line 27670 of file duktape-1.8.0/src/duktape.c.

           :
    return DUK_RET_TYPE_ERROR;
}
 
DUK_INTERNAL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx) {
    duk_idx_t nargs;
 
    /* Step 1 is not necessary because duk_call_method() will take
     * care of it.
     */
 
    /* vararg function, thisArg needs special handling */
    nargs = duk_get_top(ctx);  /* = 1 + arg count */
    if (nargs == 0) {
        duk_push_undefined(ctx);
        nargs++;
    }

◆ duk_bi_function_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_to_string ( duk_context * ctx )

Definition at line 27546 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    /* ignore arguments, return undefined (E5 Section 15.3.4) */
    DUK_UNREF(ctx);
    return 0;
}
 
DUK_INTERNAL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx) {
    duk_tval *tv;
 
    /*
     *  E5 Section 15.3.4.2 places few requirements on the output of
     *  this function:
     *
     *    - The result is an implementation dependent representation
     *      of the function; in particular
     *
     *    - The result must follow the syntax of a FunctionDeclaration.
     *      In particular, the function must have a name (even in the
     *      case of an anonymous function or a function with an empty
     *      name).
     *
     *    - Note in particular that the output does NOT need to compile
     *      into anything useful.
     */
 
 
    /* XXX: faster internal way to get this */
    duk_push_this(ctx);
    tv = duk_get_tval(ctx, -1);
    DUK_ASSERT(tv != NULL);
 
    if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv);
        const char *func_name;
 
        /* Function name: missing/undefined is mapped to empty string,
         * otherwise coerce to string.
         */
        /* XXX: currently no handling for non-allowed identifier characters,
         * e.g. a '{' in the function name.
         */
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
        if (duk_is_undefined(ctx, -1)) {
            func_name = "";
        } else {
            func_name = duk_to_string(ctx, -1);
            DUK_ASSERT(func_name != NULL);
        }
 
        /* Indicate function type in the function body using a dummy
         * directive.
         */
        if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj)) {
            duk_push_sprintf(ctx, "function %s() {\"ecmascript\"}", (const char *) func_name);
        } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) {

◆ duk_bi_global_object_decode_uri()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri ( duk_context * ctx )

Definition at line 28489 of file duktape-1.8.0/src/duktape.c.

28490 {

28491 duk_double_t d = duk_to_number(ctx, 0);

References DUK_ISNAN, duk_push_boolean(), and duk_to_number().

◆ duk_bi_global_object_decode_uri_component()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri_component ( duk_context * ctx )

Definition at line 28493 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_global_object_encode_uri()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_encode_uri ( duk_context * ctx )

Definition at line 28497 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_global_object_encode_uri_component()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_encode_uri_component ( duk_context * ctx )

Definition at line 28501 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_global_object_escape()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_escape ( duk_context * ctx )

Definition at line 28506 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (const void *) duk__decode_uri_reserved_table);
}

References duk__decode_uri_reserved_table, duk__transform_callback_decode_uri(), and duk__transform_helper().

◆ duk_bi_global_object_eval()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_eval ( duk_context * ctx )

Definition at line 28224 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    duk_activation *act_caller;
    duk_activation *act_eval;
    duk_activation *act;
    duk_hcompiledfunction *func;
    duk_hobject *outer_lex_env;
    duk_hobject *outer_var_env;
    duk_bool_t this_to_global = 1;
    duk_small_uint_t comp_flags;
    duk_int_t level = -2;
 
    DUK_ASSERT(duk_get_top(ctx) == 1 || duk_get_top(ctx) == 2);  /* 2 when called by debugger */
    DUK_ASSERT(thr->callstack_top >= 1);  /* at least this function exists */
    DUK_ASSERT(((thr->callstack + thr->callstack_top - 1)->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0 || /* indirect eval */
               (thr->callstack_top >= 2));  /* if direct eval, calling activation must exist */
 
    /*
     *  callstack_top - 1 --> this function
     *  callstack_top - 2 --> caller (may not exist)
     *
     *  If called directly from C, callstack_top might be 1.  If calling
     *  activation doesn't exist, call must be indirect.
     */
 
    h = duk_get_hstring(ctx, 0);
    if (!h) {
        return 1;  /* return arg as-is */
    }
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    /* NOTE: level is used only by the debugger and should never be present
     * for an Ecmascript eval().
     */
    DUK_ASSERT(level == -2);  /* by default, use caller's environment */
    if (duk_get_top(ctx) >= 2 && duk_is_number(ctx, 1)) {
        level = duk_get_int(ctx, 1);
    }
    DUK_ASSERT(level <= -2);  /* This is guaranteed by debugger code. */
#endif
 
    /* [ source ] */
 
    comp_flags = DUK_JS_COMPILE_FLAG_EVAL;
    act_eval = thr->callstack + thr->callstack_top - 1;    /* this function */
    if (thr->callstack_top >= (duk_size_t) -level) {
        /* Have a calling activation, check for direct eval (otherwise
         * assume indirect eval.
         */
        act_caller = thr->callstack + thr->callstack_top + level;  /* caller */
        if ((act_caller->flags & DUK_ACT_FLAG_STRICT) &&
            (act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL)) {
            /* Only direct eval inherits strictness from calling code
             * (E5.1 Section 10.1.1).
             */
            comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
        }
    } else {
        DUK_ASSERT((act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0);
    }
    act_caller = NULL;  /* avoid dereference after potential callstack realloc */
    act_eval = NULL;
 
    duk_push_hstring_stridx(ctx, DUK_STRIDX_INPUT);  /* XXX: copy from caller? */
    duk_js_compile(thr,
                   (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h),
                   (duk_size_t) DUK_HSTRING_GET_BYTELEN(h),
                   comp_flags);
    func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) func));
 
    /* [ source template ] */
 
    /* E5 Section 10.4.2 */
    DUK_ASSERT(thr->callstack_top >= 1);
    act = thr->callstack + thr->callstack_top - 1;  /* this function */
    if (act->flags & DUK_ACT_FLAG_DIRECT_EVAL) {
        DUK_ASSERT(thr->callstack_top >= 2);
        act = thr->callstack + thr->callstack_top + level;  /* caller */
        if (act->lex_env == NULL) {
            DUK_ASSERT(act->var_env == NULL);
            DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
 
            /* this may have side effects, so re-lookup act */
            duk_js_init_activation_environment_records_delayed(thr, act);
            act = thr->callstack + thr->callstack_top + level;
        }
        DUK_ASSERT(act->lex_env != NULL);
        DUK_ASSERT(act->var_env != NULL);
 
        this_to_global = 0;
 
        if (DUK_HOBJECT_HAS_STRICT((duk_hobject *) func)) {
            duk_hobject *new_env;
            duk_hobject *act_lex_env;
 
            DUK_DDD(DUK_DDDPRINT("direct eval call to a strict function -> "
                                 "var_env and lex_env to a fresh env, "
                                 "this_binding to caller's this_binding"));
 
            act_lex_env = act->lex_env;
            act = NULL;  /* invalidated */
 
            (void) duk_push_object_helper_proto(ctx,
                                                DUK_HOBJECT_FLAG_EXTENSIBLE |
                                                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
                                                act_lex_env);
            new_env = duk_require_hobject(ctx, -1);
            DUK_ASSERT(new_env != NULL);
            DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO",
                                 (duk_heaphdr *) new_env));
 
            outer_lex_env = new_env;
            outer_var_env = new_env;
 
            duk_insert(ctx, 0);  /* stash to bottom of value stack to keep new_env reachable for duration of eval */
 
            /* compiler's responsibility */
            DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV((duk_hobject *) func));
        } else {
            DUK_DDD(DUK_DDDPRINT("direct eval call to a non-strict function -> "
                                 "var_env and lex_env to caller's envs, "
                                 "this_binding to caller's this_binding"));
 
            outer_lex_env = act->lex_env;
            outer_var_env = act->var_env;
 
            /* compiler's responsibility */
            DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) func));
        }
    } else {
        DUK_DDD(DUK_DDDPRINT("indirect eval call -> var_env and lex_env to "
                             "global object, this_binding to global object"));
 
        this_to_global = 1;
        outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
        outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
    }
    act = NULL;
 
    /* Eval code doesn't need an automatic .prototype object. */
    duk_js_push_closure(thr, func, outer_var_env, outer_lex_env, 0 /*add_auto_proto*/);
 
    /* [ source template closure ] */
 
    if (this_to_global) {
        DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL);
        duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL);
    } else {
        duk_tval *tv;
        DUK_ASSERT(thr->callstack_top >= 2);
        act = thr->callstack + thr->callstack_top + level;  /* caller */
        tv = thr->valstack + act->idx_bottom - 1;  /* this is just beneath bottom */

◆ duk_bi_global_object_is_finite()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_is_finite ( duk_context * ctx )

Definition at line 28479 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_global_object_is_nan()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_is_nan ( duk_context * ctx )

Definition at line 28473 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_global_object_parse_float()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_float ( duk_context * ctx )

Definition at line 28444 of file duktape-1.8.0/src/duktape.c.

                         {
            s2n_flags &= ~DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
        }
    } else {
        radix = 10;
    }
 
    duk_dup(ctx, 0);
    duk_numconv_parse(ctx, radix, s2n_flags);
    return 1;
 
 ret_nan:
    duk_push_nan(ctx);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_float(duk_context *ctx) {
    duk_small_uint_t s2n_flags;
    duk_int32_t radix;
 
    DUK_ASSERT_TOP(ctx, 1);
    duk_to_string(ctx, 0);
 

◆ duk_bi_global_object_parse_int()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_int ( duk_context * ctx )

Definition at line 28401 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    duk_int32_t radix;
    duk_small_uint_t s2n_flags;
 
    DUK_ASSERT_TOP(ctx, 2);
    duk_to_string(ctx, 0);
 
    radix = duk_to_int32(ctx, 1);
 
    s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
                DUK_S2N_FLAG_ALLOW_GARBAGE |
                DUK_S2N_FLAG_ALLOW_PLUS |
                DUK_S2N_FLAG_ALLOW_MINUS |
                DUK_S2N_FLAG_ALLOW_LEADING_ZERO |
                DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
 
    /* Specification stripPrefix maps to DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT.
     *
     * Don't autodetect octals (from leading zeroes), require user code to
     * provide an explicit radix 8 for parsing octal.  See write-up from Mozilla:
     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt#ECMAScript_5_Removes_Octal_Interpretation
     */
 
    if (radix != 0) {
        if (radix < 2 || radix > 36) {

◆ duk_bi_global_object_print_helper()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_print_helper ( duk_context * ctx )

Definition at line 28526 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    return duk__transform_helper(ctx, duk__transform_callback_unescape, (const void *) NULL);
}
#else  /* DUK_USE_SECTION_B */
DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
 
DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_SECTION_B */
 
#if defined(DUK_USE_BROWSER_LIKE) && (defined(DUK_USE_FILE_IO) || defined(DUK_USE_DEBUGGER_SUPPORT))
DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_int_t magic;
    duk_idx_t nargs;
    const duk_uint8_t *buf;
    duk_size_t sz_buf;
    const char nl = (const char) DUK_ASC_LF;
#ifndef DUK_USE_PREFER_SIZE
    duk_uint8_t buf_stack[256];
#endif
#ifdef DUK_USE_FILE_IO
    duk_file *f_out;
#endif
 
    DUK_UNREF(thr);
 
    magic = duk_get_current_magic(ctx);
    DUK_UNREF(magic);
 
    nargs = duk_get_top(ctx);
 
    /* If argument count is 1 and first argument is a buffer, write the buffer
     * as raw data into the file without a newline; this allows exact control
     * over stdout/stderr without an additional entrypoint (useful for now).
     *
     * Otherwise current print/alert semantics are to ToString() coerce
     * arguments, join them with a single space, and append a newline.
     */
 
    if (nargs == 1 && duk_is_buffer(ctx, 0)) {
        buf = (const duk_uint8_t *) duk_get_buffer(ctx, 0, &sz_buf);
        DUK_ASSERT(buf != NULL);
    } else if (nargs > 0) {
#ifdef DUK_USE_PREFER_SIZE
        /* Compact but lots of churn. */
        duk_push_hstring_stridx(thr, DUK_STRIDX_SPACE);
        duk_insert(ctx, 0);
        duk_join(ctx, nargs);
        duk_push_string(thr, "\n");
        duk_concat(ctx, 2);
        buf = (const duk_uint8_t *) duk_get_lstring(ctx, -1, &sz_buf);
        DUK_ASSERT(buf != NULL);
#else  /* DUK_USE_PREFER_SIZE */
        /* Higher footprint, less churn. */
        duk_idx_t i;
        duk_size_t sz_str;
        const duk_uint8_t *p_str;
        duk_uint8_t *p;
 
        sz_buf = (duk_size_t) nargs;  /* spaces (nargs - 1) + newline */
        for (i = 0; i < nargs; i++) {
            (void) duk_to_lstring(ctx, i, &sz_str);
            sz_buf += sz_str;
        }
 
        if (sz_buf <= sizeof(buf_stack)) {
            p = (duk_uint8_t *) buf_stack;
        } else {
            p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, sz_buf);
            DUK_ASSERT(p != NULL);
        }
 
        buf = (const duk_uint8_t *) p;
        for (i = 0; i < nargs; i++) {
            p_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &sz_str);
            DUK_ASSERT(p_str != NULL);
            DUK_MEMCPY((void *) p, (const void *) p_str, sz_str);
            p += sz_str;
            *p++ = (duk_uint8_t) (i == nargs - 1 ? DUK_ASC_LF : DUK_ASC_SPACE);
        }
        DUK_ASSERT((const duk_uint8_t *) p == buf + sz_buf);
#endif  /* DUK_USE_PREFER_SIZE */
    } else {
        buf = (const duk_uint8_t *) &nl;
        sz_buf = 1;
    }
 
    /* 'buf' contains the string to write, 'sz_buf' contains the length
     * (which may be zero).
     */
    DUK_ASSERT(buf != NULL);
 
    if (sz_buf == 0) {
        return 0;

References duk__transform_callback_unescape(), duk__transform_helper(), and NULL.

◆ duk_bi_global_object_require()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_require ( duk_context * ctx )

Definition at line 28828 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    const char *str_req_id;  /* requested identifier */
    const char *str_mod_id;  /* require.id of current module */
    duk_int_t pcall_rc;
 
    /* NOTE: we try to minimize code size by avoiding unnecessary pops,
     * so the stack looks a bit cluttered in this function.  DUK_ASSERT_TOP()
     * assertions are used to ensure stack configuration is correct at each
     * step.
     */
 
    /*
     *  Resolve module identifier into canonical absolute form.
     */
 
    str_req_id = duk_require_string(ctx, DUK__IDX_REQUESTED_ID);
    duk_push_current_function(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ID);
    str_mod_id = duk_get_string(ctx, DUK__IDX_REQUIRE_ID);  /* ignore non-strings */
    DUK_DDD(DUK_DDDPRINT("resolve module id: requested=%!T, currentmodule=%!T",
                         duk_get_tval(ctx, DUK__IDX_REQUESTED_ID),
                         duk_get_tval(ctx, DUK__IDX_REQUIRE_ID)));
    duk__bi_global_resolve_module_id(ctx, str_req_id, str_mod_id);
    str_req_id = NULL;
    str_mod_id = NULL;
    DUK_DDD(DUK_DDDPRINT("resolved module id: requested=%!T, currentmodule=%!T, result=%!T, lastcomp=%!T",
                         duk_get_tval(ctx, DUK__IDX_REQUESTED_ID),
                         duk_get_tval(ctx, DUK__IDX_REQUIRE_ID),
                         duk_get_tval(ctx, DUK__IDX_RESOLVED_ID),
                         duk_get_tval(ctx, DUK__IDX_LASTCOMP)));
 
    /* [ requested_id require require.id resolved_id last_comp ] */
    DUK_ASSERT_TOP(ctx, DUK__IDX_LASTCOMP + 1);
 
    /*
     *  Cached module check.
     *
     *  If module has been loaded or its loading has already begun without
     *  finishing, return the same cached value ('exports').  The value is
     *  registered when module load starts so that circular references can
     *  be supported to some extent.
     */
 
    duk_push_hobject_bidx(ctx, DUK_BIDX_DUKTAPE);
    duk_get_prop_stridx(ctx, DUK__IDX_DUKTAPE, DUK_STRIDX_MOD_LOADED);  /* Duktape.modLoaded */
    (void) duk_require_hobject(ctx, DUK__IDX_MODLOADED);
    DUK_ASSERT_TOP(ctx, DUK__IDX_MODLOADED + 1);
 
    duk_dup(ctx, DUK__IDX_RESOLVED_ID);
    if (duk_get_prop(ctx, DUK__IDX_MODLOADED)) {
        /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded Duktape.modLoaded[id] ] */
        DUK_DD(DUK_DDPRINT("module already loaded: %!T",
                           duk_get_tval(ctx, DUK__IDX_RESOLVED_ID)));
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_EXPORTS);  /* return module.exports */
        return 1;
    }
    DUK_ASSERT_TOP(ctx, DUK__IDX_UNDEFINED + 1);
 
    /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined ] */
 
    /*
     *  Module not loaded (and loading not started previously).
     *
     *  Create a new require() function with 'id' set to resolved ID
     *  of module being loaded.  Also create 'exports' and 'module'
     *  tables but don't register exports to the loaded table yet.
     *  We don't want to do that unless the user module search callbacks
     *  succeeds in finding the module.
     */
 
    DUK_D(DUK_DPRINT("loading module %!T, resolution base %!T, requested ID %!T -> resolved ID %!T, last component %!T",
                         duk_get_tval(ctx, DUK__IDX_RESOLVED_ID),
                         duk_get_tval(ctx, DUK__IDX_REQUIRE_ID),
                         duk_get_tval(ctx, DUK__IDX_REQUESTED_ID),
                         duk_get_tval(ctx, DUK__IDX_RESOLVED_ID),
                         duk_get_tval(ctx, DUK__IDX_LASTCOMP)));
 
    /* Fresh require: require.id is left configurable (but not writable)
     * so that is not easy to accidentally tweak it, but it can still be
     * done with Object.defineProperty().
     *
     * XXX: require.id could also be just made non-configurable, as there
     * is no practical reason to touch it.
     */
    duk_push_c_function(ctx, duk_bi_global_object_require, 1 /*nargs*/);
    duk_push_hstring_stridx(ctx, DUK_STRIDX_REQUIRE);
    duk_xdef_prop_stridx(ctx, DUK__IDX_FRESH_REQUIRE, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
    duk_dup(ctx, DUK__IDX_RESOLVED_ID);
    duk_xdef_prop_stridx(ctx, DUK__IDX_FRESH_REQUIRE, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_C);  /* a fresh require() with require.id = resolved target module id */
 
    /* Module table:
     * - module.exports: initial exports table (may be replaced by user)
     * - module.id is non-writable and non-configurable, as the CommonJS
     *   spec suggests this if possible
     * - module.filename: not set, defaults to resolved ID if not explicitly
     *   set by modSearch() (note capitalization, not .fileName, matches Node.js)
     * - module.name: not set, defaults to last component of resolved ID if
     *   not explicitly set by modSearch()
     */
    duk_push_object(ctx);  /* exports */
    duk_push_object(ctx);  /* module */
    duk_dup(ctx, DUK__IDX_EXPORTS);
    duk_xdef_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_EXPORTS, DUK_PROPDESC_FLAGS_WC);  /* module.exports = exports */
    duk_dup(ctx, DUK__IDX_RESOLVED_ID);  /* resolved id: require(id) must return this same module */
    duk_xdef_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_NONE);  /* module.id = resolved_id */
    duk_compact(ctx, DUK__IDX_MODULE);  /* module table remains registered to modLoaded, minimize its size */
    DUK_ASSERT_TOP(ctx, DUK__IDX_MODULE + 1);
 
    DUK_DD(DUK_DDPRINT("module table created: %!T", duk_get_tval(ctx, DUK__IDX_MODULE)));
 
    /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module ] */
 
    /* Register the module table early to modLoaded[] so that we can
     * support circular references even in modSearch().  If an error
     * is thrown, we'll delete the reference.
     */
    duk_dup(ctx, DUK__IDX_RESOLVED_ID);
    duk_dup(ctx, DUK__IDX_MODULE);
    duk_put_prop(ctx, DUK__IDX_MODLOADED);  /* Duktape.modLoaded[resolved_id] = module */
 
    /*
     *  Call user provided module search function and build the wrapped
     *  module source code (if necessary).  The module search function
     *  can be used to implement pure Ecmacsript, pure C, and mixed
     *  Ecmascript/C modules.
     *
     *  The module search function can operate on the exports table directly
     *  (e.g. DLL code can register values to it).  It can also return a
     *  string which is interpreted as module source code (if a non-string
     *  is returned the module is assumed to be a pure C one).  If a module
     *  cannot be found, an error must be thrown by the user callback.
     *
     *  Because Duktape.modLoaded[] already contains the module being
     *  loaded, circular references for C modules should also work
     *  (although expected to be quite rare).
     */
 
    duk_push_string(ctx, "(function(require,exports,module){");
 
    /* Duktape.modSearch(resolved_id, fresh_require, exports, module). */
    duk_get_prop_stridx(ctx, DUK__IDX_DUKTAPE, DUK_STRIDX_MOD_SEARCH);  /* Duktape.modSearch */
    duk_dup(ctx, DUK__IDX_RESOLVED_ID);
    duk_dup(ctx, DUK__IDX_FRESH_REQUIRE);
    duk_dup(ctx, DUK__IDX_EXPORTS);
    duk_dup(ctx, DUK__IDX_MODULE);  /* [ ... Duktape.modSearch resolved_id last_comp fresh_require exports module ] */
    pcall_rc = duk_pcall(ctx, 4 /*nargs*/);  /* -> [ ... source ] */
    DUK_ASSERT_TOP(ctx, DUK__IDX_MODULE + 3);
 
    if (pcall_rc != DUK_EXEC_SUCCESS) {
        /* Delete entry in Duktape.modLoaded[] and rethrow. */
        goto delete_rethrow;
    }
 
    /* If user callback did not return source code, module loading
     * is finished (user callback initialized exports table directly).
     */
    if (!duk_is_string(ctx, -1)) {
        /* User callback did not return source code, so module loading
         * is finished: just update modLoaded with final module.exports
         * and we're done.
         */
        goto return_exports;
    }
 
    /* Finish the wrapped module source.  Force module.filename as the
     * function .fileName so it gets set for functions defined within a
     * module.  This also ensures loggers created within the module get
     * the module ID (or overridden filename) as their default logger name.
     * (Note capitalization: .filename matches Node.js while .fileName is
     * used elsewhere in Duktape.)
     */
    duk_push_string(ctx, "\n})");  /* Newline allows module last line to contain a // comment. */
    duk_concat(ctx, 3);
    if (!duk_get_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_FILENAME)) {
        /* module.filename for .fileName, default to resolved ID if
         * not present.
         */
        duk_pop(ctx);
        duk_dup(ctx, DUK__IDX_RESOLVED_ID);
    }
    duk_eval_raw(ctx, NULL, 0, DUK_COMPILE_EVAL);
 
    /* Module has now evaluated to a wrapped module function.  Force its
     * .name to match module.name (defaults to last component of resolved
     * ID) so that it is shown in stack traces too.  Note that we must not
     * introduce an actual name binding into the function scope (which is
     * usually the case with a named function) because it would affect the
     * scope seen by the module and shadow accesses to globals of the same name.
     * This is now done by compiling the function as anonymous and then forcing
     * its .name without setting a "has name binding" flag.
     */
 
    duk_push_hstring_stridx(ctx, DUK_STRIDX_NAME);
    if (!duk_get_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_NAME)) {
        /* module.name for .name, default to last component if
         * not present.
         */
        duk_pop(ctx);
        duk_dup(ctx, DUK__IDX_LASTCOMP);
    }
    duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_FORCE);
 
    /*
     *  Call the wrapped module function.
     *
     *  Use a protected call so that we can update Duktape.modLoaded[resolved_id]
     *  even if the module throws an error.
     */
 
    /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module mod_func ] */
    DUK_ASSERT_TOP(ctx, DUK__IDX_MODULE + 2);
 
    duk_dup(ctx, DUK__IDX_EXPORTS);  /* exports (this binding) */
    duk_dup(ctx, DUK__IDX_FRESH_REQUIRE);  /* fresh require (argument) */
    duk_get_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_EXPORTS);  /* relookup exports from module.exports in case it was changed by modSearch */
    duk_dup(ctx, DUK__IDX_MODULE);  /* module (argument) */
    DUK_ASSERT_TOP(ctx, DUK__IDX_MODULE + 6);
 
    /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module mod_func exports fresh_require exports module ] */
 
    pcall_rc = duk_pcall_method(ctx, 3 /*nargs*/);
    if (pcall_rc != DUK_EXEC_SUCCESS) {
        /* Module loading failed.  Node.js will forget the module
         * registration so that another require() will try to load
         * the module again.  Mimic that behavior.
         */
        goto delete_rethrow;
    }

◆ duk_bi_global_object_unescape()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_unescape ( duk_context * ctx )

Definition at line 28510 of file duktape-1.8.0/src/duktape.c.

                                                                                   {
    return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (const void *) duk__decode_uri_component_reserved_table);
}

References duk__decode_uri_component_reserved_table, duk__transform_callback_decode_uri(), and duk__transform_helper().

◆ duk_bi_json_object_parse()

DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_parse ( duk_context * ctx )

Definition at line 32213 of file duktape-1.8.0/src/duktape.c.

                                            : value=%!T, replacer=%!T, space=%!T, "
                         "flags=0x%08lx, result=%!T, stack_top=%ld",
                         (duk_tval *) duk_get_tval(ctx, idx_value),
                         (duk_tval *) duk_get_tval(ctx, idx_replacer),
                         (duk_tval *) duk_get_tval(ctx, idx_space),
                         (unsigned long) flags,

◆ duk_bi_json_object_stringify()

DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_stringify ( duk_context * ctx )

Definition at line 32221 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_json_parse_helper()

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

Definition at line 31773 of file duktape-1.8.0/src/duktape.c.

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

◆ duk_bi_json_stringify_helper()

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

Definition at line 31876 of file duktape-1.8.0/src/duktape.c.

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

◆ duk_bi_logger_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_constructor ( duk_context * ctx )

Definition at line 32253 of file duktape-1.8.0/src/duktape.c.

                                                       {
    (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C,
    (duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G,
    (duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F,
    (duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N,
    (duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R,
    (duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L
};
 
/* Constructor */
DUK_INTERNAL duk_ret_t duk_bi_logger_constructor(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t nargs;
 
    /* Calling as a non-constructor is not meaningful. */
    if (!duk_is_constructor_call(ctx)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    nargs = duk_get_top(ctx);
    duk_set_top(ctx, 1);
 
    duk_push_this(ctx);
 
    /* [ name this ] */
 
    if (nargs == 0) {
        /* Automatic defaulting of logger name from caller.  This would
         * work poorly with tail calls, but constructor calls are currently
         * never tail calls, so tail calls are not an issue now.
         */
 
        if (thr->callstack_top >= 2) {
            duk_activation *act_caller = thr->callstack + thr->callstack_top - 2;
            duk_hobject *func_caller;
 
            func_caller = DUK_ACT_GET_FUNC(act_caller);
            if (func_caller) {
                /* Stripping the filename might be a good idea
                 * ("/foo/bar/quux.js" -> logger name "quux"),
                 * but now used verbatim.
                 */
                duk_push_hobject(ctx, func_caller);
                duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
                duk_replace(ctx, 0);
            }

References DUK_ASC_UC_B, DUK_ASC_UC_C, DUK_ASC_UC_D, DUK_ASC_UC_E, DUK_ASC_UC_F, DUK_ASC_UC_G, DUK_ASC_UC_I, DUK_ASC_UC_L, DUK_ASC_UC_N, DUK_ASC_UC_R, DUK_ASC_UC_T, and DUK_ASC_UC_W.

◆ duk_bi_logger_prototype_fmt()

DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_fmt ( duk_context * ctx )

Definition at line 32310 of file duktape-1.8.0/src/duktape.c.

                               {
        duk_dup(ctx, 0);
        duk_put_prop_stridx(ctx, 1, DUK_STRIDX_LC_N);
    } else {
        /* don't set 'n' at all, inherited value is used as name */
    }
 
    duk_compact(ctx, 1);
 
    return 0;  /* keep default instance */
}
 
/* Default function to format objects.  Tries to use toLogString() but falls
 * back to toString().  Any errors are propagated out without catching.

References duk_dup(), duk_put_prop_stridx(), and DUK_STRIDX_LC_N.

◆ duk_bi_logger_prototype_log_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_log_shared ( duk_context * ctx )

Definition at line 32358 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_double_t now;
    duk_small_int_t entry_lev = duk_get_current_magic(ctx);
    duk_small_int_t logger_lev;
    duk_int_t nargs;
    duk_int_t i;
    duk_size_t tot_len;
    const duk_uint8_t *arg_str;
    duk_size_t arg_len;
    duk_uint8_t *buf, *p;
    const duk_uint8_t *q;
    duk_uint8_t date_buf[DUK_BI_DATE_ISO8601_BUFSIZE];
    duk_size_t date_len;
    duk_small_int_t rc;
 
    DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5);
    DUK_UNREF(thr);
 
    /* XXX: sanitize to printable (and maybe ASCII) */
    /* XXX: better multiline */
 
    /*
     *  Logger arguments are:
     *
     *    magic: log level (0-5)
     *    this: logger
     *    stack: plain log args
     *
     *  We want to minimize memory churn so a two-pass approach
     *  is used: first pass formats arguments and computes final
     *  string length, second pass copies strings either into a
     *  pre-allocated and reused buffer (short messages) or into a
     *  newly allocated fixed buffer.  If the backend function plays
     *  nice, it won't coerce the buffer to a string (and thus
     *  intern it).
     */
 
    nargs = duk_get_top(ctx);
 
    /* [ arg1 ... argN this ] */
 
    /*
     *  Log level check
     */
 
    duk_push_this(ctx);
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_L);
    logger_lev = (duk_small_int_t) duk_get_int(ctx, -1);
    if (entry_lev < logger_lev) {
        return 0;
    }
    /* log level could be popped but that's not necessary */
 
    now = DUK_USE_DATE_GET_NOW(ctx);
    duk_bi_date_format_timeval(now, date_buf);
    date_len = DUK_STRLEN((const char *) date_buf);
 
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LC_N);
    duk_to_string(ctx, -1);
    DUK_ASSERT(duk_is_string(ctx, -1));
 
    /* [ arg1 ... argN this loggerLevel loggerName ] */
 
    /*
     *  Pass 1
     */
 
    /* Line format: <time> <entryLev> <loggerName>: <msg> */
 
    tot_len = 0;
    tot_len += 3 +  /* separators: space, space, colon */
               3 +  /* level string */
               date_len +  /* time */
               duk_get_length(ctx, -1);  /* loggerName */
 
    for (i = 0; i < nargs; i++) {
        /* When formatting an argument to a string, errors may happen from multiple
         * causes.  In general we want to catch obvious errors like a toLogString()
         * throwing an error, but we don't currently try to catch every possible
         * error.  In particular, internal errors (like out of memory or stack) are
         * not caught.  Also, we expect Error toString() to not throw an error.
         */
        if (duk_is_object(ctx, i)) {
            /* duk_pcall_prop() may itself throw an error, but we're content
             * in catching the obvious errors (like toLogString() throwing an
             * error).
             */
            duk_push_hstring_stridx(ctx, DUK_STRIDX_FMT);
            duk_dup(ctx, i);
            /* [ arg1 ... argN this loggerLevel loggerName 'fmt' arg ] */
            /* call: this.fmt(arg) */
            rc = duk_pcall_prop(ctx, -5 /*obj_index*/, 1 /*nargs*/);
            if (rc) {
                /* Keep the error as the result (coercing it might fail below,
                 * but we don't catch that now).
                 */
                ;
            }
            duk_replace(ctx, i);
        }
        (void) duk_to_lstring(ctx, i, &arg_len);
        tot_len++;  /* sep (even before first one) */
        tot_len += arg_len;
    }
 
    /*
     *  Pass 2
     */
 
    /* XXX: There used to be a shared log buffer here, but it was removed
     * when dynamic buffer spare was removed.  The problem with using
     * bufwriter is that, without the spare, the buffer gets passed on
     * as an argument to the raw() call so it'd need to be resized
     * (reallocated) anyway.  If raw() call convention is changed, this
     * could be made more efficient.
     */
 
    buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len);
    DUK_ASSERT(buf != NULL);
    p = buf;
 
    DUK_MEMCPY((void *) p, (const void *) date_buf, (size_t) date_len);
    p += date_len;
    *p++ = (duk_uint8_t) DUK_ASC_SPACE;
 
    q = duk__log_level_strings + (entry_lev * 3);
    DUK_MEMCPY((void *) p, (const void *) q, (size_t) 3);
    p += 3;
 
    *p++ = (duk_uint8_t) DUK_ASC_SPACE;
 
    arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len);
    DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len);
    p += arg_len;
 
    *p++ = (duk_uint8_t) DUK_ASC_COLON;
 
    for (i = 0; i < nargs; i++) {
        *p++ = (duk_uint8_t) DUK_ASC_SPACE;
 
        arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len);
        DUK_ASSERT(arg_str != NULL);
        DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len);
        p += arg_len;
    }
    DUK_ASSERT(buf + tot_len == p);
 
    /* [ arg1 ... argN this loggerLevel loggerName buffer ] */
 
#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_LOGGING)
    /* Do debugger forwarding before raw() because the raw() function
     * doesn't get the log level right now.
     */
    if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
        const char *log_buf;
        duk_size_t sz_buf;
        log_buf = (const char *) duk_get_buffer(ctx, -1, &sz_buf);
        DUK_ASSERT(log_buf != NULL);
        duk_debug_write_notify(thr, DUK_DBG_CMD_LOG);

◆ duk_bi_logger_prototype_raw()

DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_raw ( duk_context * ctx )

Definition at line 32334 of file duktape-1.8.0/src/duktape.c.

32351 {

◆ duk_bi_math_object_max()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_max ( duk_context * ctx )

Definition at line 32842 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_math_object_min()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_min ( duk_context * ctx )

Definition at line 32846 of file duktape-1.8.0/src/duktape.c.

32848 {

◆ duk_bi_math_object_onearg_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_onearg_shared ( duk_context * ctx )

Definition at line 32820 of file duktape-1.8.0/src/duktape.c.

                                                         {
#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
    duk__atan2,

◆ duk_bi_math_object_random()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_random ( duk_context * ctx )

Definition at line 32850 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_math_object_twoarg_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_twoarg_shared ( duk_context * ctx )

Definition at line 32831 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_small_int_t fun_idx = duk_get_current_magic(ctx);
    duk__one_arg_func fun;
 

◆ duk_bi_nodejs_buffer_byte_length()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_byte_length ( duk_context * ctx )

Definition at line 23891 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.byteLength()

◆ duk_bi_nodejs_buffer_concat()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_concat ( duk_context * ctx )

Definition at line 23917 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.concat()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx) {
    duk_hthread *thr;
    duk_hobject *h_arg;
    duk_int_t total_length = 0;
    duk_hbufferobject *h_bufobj;
    duk_hbufferobject *h_bufres;
    duk_hbuffer *h_val;
    duk_uint_t i, n;
    duk_uint8_t *p;
    duk_size_t space_left;
    duk_size_t copy_size;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /* Node.js accepts only actual Arrays. */
    h_arg = duk_require_hobject(ctx, 0);
    if (DUK_HOBJECT_GET_CLASS_NUMBER(h_arg) != DUK_HOBJECT_CLASS_ARRAY) {
        return DUK_RET_TYPE_ERROR;
    }
 
    /* Compute result length and validate argument buffers. */
    n = (duk_uint_t) duk_get_length(ctx, 0);
    for (i = 0; i < n; i++) {
        /* Neutered checks not necessary here: neutered buffers have
         * zero 'length' so we'll effectively skip them.
         */
        DUK_ASSERT_TOP(ctx, 2);  /* [ array totalLength ] */
        duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);  /* -> [ array totalLength buf ] */
        h_bufobj = duk__require_bufobj_value(ctx, 2);
        DUK_ASSERT(h_bufobj != NULL);
        total_length += h_bufobj->length;
        duk_pop(ctx);
    }
    if (n == 1) {
        /* For the case n==1 Node.js doesn't seem to type check
         * the sole member but we do it before returning it.
         * For this case only the original buffer object is
         * returned (not a copy).
         */
        duk_get_prop_index(ctx, 0, 0);
        return 1;
    }
 
    /* User totalLength overrides a computed length, but we'll check
     * every copy in the copy loop.  Note that duk_to_uint() can
     * technically have arbitrary side effects so we need to recheck
     * the buffers in the copy loop.
     */
    if (!duk_is_undefined(ctx, 1) && n > 0) {
        /* For n == 0, Node.js ignores totalLength argument and
         * returns a zero length buffer.
         */
        total_length = duk_to_int(ctx, 1);
    }
    if (total_length < 0) {
        return DUK_RET_RANGE_ERROR;
    }
 
    h_bufres = duk_push_bufferobject_raw(ctx,
                                         DUK_HOBJECT_FLAG_EXTENSIBLE |
                                         DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                         DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER),
                                         DUK_BIDX_NODEJS_BUFFER_PROTOTYPE);
    DUK_ASSERT(h_bufres != NULL);
 
    p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, total_length);
    DUK_ASSERT(p != NULL);
    space_left = total_length;
 
    for (i = 0; i < n; i++) {
        DUK_ASSERT_TOP(ctx, 4);  /* [ array totalLength bufres buf ] */
 
        duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);
        h_bufobj = duk__require_bufobj_value(ctx, 4);
        DUK_ASSERT(h_bufobj != NULL);
 
        copy_size = h_bufobj->length;
        if (copy_size > space_left) {
            copy_size = space_left;
        }
 
        if (h_bufobj->buf != NULL &&
            DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) {
            DUK_MEMCPY((void *) p,
                       (const void *) DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj),
                       copy_size);
        } else {
            /* Just skip, leaving zeroes in the result. */
            ;

◆ duk_bi_nodejs_buffer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_constructor ( duk_context * ctx )

Definition at line 22318 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    /* Internal class is Object: Object.prototype.toString.call(new Buffer(0))
     * prints "[object Object]".
     */
    duk_int_t len;
    duk_int_t i;
    duk_hbuffer *h_buf;
    duk_hbufferobject *h_bufobj;
    duk_size_t buf_size;
 
    switch (duk_get_type(ctx, 0)) {
    case DUK_TYPE_BUFFER: {
        /* Custom behavior: plain buffer is used as internal buffer
         * without making a copy (matches Duktape.Buffer).
         */
        duk_set_top(ctx, 1);  /* -> [ buffer ] */
        break;
    }
    case DUK_TYPE_NUMBER: {
        len = duk_to_int_clamped(ctx, 0, 0, DUK_INT_MAX);
        (void) duk_push_fixed_buffer(ctx, (duk_size_t) len);
        break;
    }
    case DUK_TYPE_OBJECT: {
        duk_uint8_t *buf;
 
        (void) duk_get_prop_string(ctx, 0, "length");
        len = duk_to_int_clamped(ctx, -1, 0, DUK_INT_MAX);
        duk_pop(ctx);
        buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
        for (i = 0; i < len; i++) {
            /* XXX: fast path for array arguments? */
            duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);
            buf[i] = (duk_uint8_t) (duk_to_uint32(ctx, -1) & 0xffU);
            duk_pop(ctx);
        }
        break;
    }
    case DUK_TYPE_STRING: {
        /* ignore encoding for now */
        duk_dup(ctx, 0);
        (void) duk_to_buffer(ctx, -1, &buf_size);
        break;
    }
    default:
        return DUK_RET_TYPE_ERROR;
    }
 
    DUK_ASSERT(duk_is_buffer(ctx, -1));
    h_buf = duk_get_hbuffer(ctx, -1);
    DUK_ASSERT(h_buf != NULL);
 

◆ duk_bi_nodejs_buffer_copy()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_copy ( duk_context * ctx )

Definition at line 23278 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.prototype.copy()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_this;
    duk_hbufferobject *h_bufarg;
    duk_int_t source_length;
    duk_int_t target_length;
    duk_int_t target_start, source_start, source_end;
    duk_uint_t target_ustart, source_ustart, source_uend;
    duk_uint_t copy_size = 0;
 
    /* [ targetBuffer targetStart sourceStart sourceEnd ] */
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_this = duk__require_bufobj_this(ctx);
    h_bufarg = duk__require_bufobj_value(ctx, 0);
    DUK_ASSERT(h_this != NULL);
    DUK_ASSERT(h_bufarg != NULL);
    source_length = (duk_int_t) h_this->length;
    target_length = (duk_int_t) h_bufarg->length;
 
    target_start = duk_to_int(ctx, 1);
    source_start = duk_to_int(ctx, 2);
    if (duk_is_undefined(ctx, 3)) {
        source_end = source_length;
    } else {
        source_end = duk_to_int(ctx, 3);
    }
 
    DUK_DDD(DUK_DDDPRINT("checking copy args: target_start=%ld, target_length=%ld, "
                         "source_start=%ld, source_end=%ld, source_length=%ld",
                         (long) target_start, (long) h_bufarg->length,
                         (long) source_start, (long) source_end, (long) source_length));
 
    /* This behavior mostly mimics Node.js now. */
 
    if (source_start < 0 || source_end < 0 || target_start < 0) {
        /* Negative offsets cause a RangeError. */
        goto fail_bounds;
    }
    source_ustart = (duk_uint_t) source_start;
    source_uend = (duk_uint_t) source_end;
    target_ustart = (duk_uint_t) target_start;
    if (source_ustart >= source_uend ||  /* crossed offsets or zero size */
        source_ustart >= (duk_uint_t) source_length ||  /* source out-of-bounds (but positive) */
        target_ustart >= (duk_uint_t) target_length) {  /* target out-of-bounds (but positive) */
        goto silent_ignore;
    }
    if (source_uend >= (duk_uint_t) source_length) {
        /* Source end clamped silently to available length. */
        source_uend = source_length;
    }
    copy_size = source_uend - source_ustart;
    if (target_ustart + copy_size > (duk_uint_t) target_length) {
        /* Clamp to target's end if too long.
         *
         * NOTE: there's no overflow possibility in the comparison;
         * both target_ustart and copy_size are >= 0 and based on
         * values in duk_int_t range.  Adding them as duk_uint_t
         * values is then guaranteed not to overflow.
         */
        DUK_ASSERT(target_ustart + copy_size >= target_ustart);  /* no overflow */
        DUK_ASSERT(target_ustart + copy_size >= copy_size);  /* no overflow */
        copy_size = (duk_uint_t) target_length - target_ustart;
    }
 
    DUK_DDD(DUK_DDDPRINT("making copy: target_ustart=%lu source_ustart=%lu copy_size=%lu",
                         (unsigned long) target_ustart, (unsigned long) source_ustart,
                         (unsigned long) copy_size));
 
    DUK_ASSERT(copy_size >= 1);
    DUK_ASSERT(source_ustart <= (duk_uint_t) source_length);
    DUK_ASSERT(source_ustart + copy_size <= (duk_uint_t) source_length);
    DUK_ASSERT(target_ustart <= (duk_uint_t) target_length);
    DUK_ASSERT(target_ustart + copy_size <= (duk_uint_t) target_length);
 
    /* Ensure copy is covered by underlying buffers. */
    DUK_ASSERT(h_bufarg->buf != NULL);  /* length check */
    DUK_ASSERT(h_this->buf != NULL);    /* length check */
    if (DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufarg, target_ustart + copy_size) &&
        DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, source_ustart + copy_size)) {
        /* Must use memmove() because copy area may overlap (source and target
         * buffer may be the same, or from different slices.
         */
        DUK_MEMMOVE((void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg) + target_ustart),

◆ duk_bi_nodejs_buffer_fill()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_fill ( duk_context * ctx )

Definition at line 23150 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.prototype.fill()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_this;
    const duk_uint8_t *fill_str_ptr;
    duk_size_t fill_str_len;
    duk_uint8_t fill_value;
    duk_int_t fill_offset;
    duk_int_t fill_end;
    duk_size_t fill_length;
    duk_uint8_t *p;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_this = duk__require_bufobj_this(ctx);
    DUK_ASSERT(h_this != NULL);
    if (h_this->buf == NULL) {
        return DUK_RET_TYPE_ERROR;
    }
 
    /* [ value offset end ] */
 
    if (duk_is_string(ctx, 0)) {
        fill_str_ptr = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &fill_str_len);
        DUK_ASSERT(fill_str_ptr != NULL);
    } else {
        fill_value = (duk_uint8_t) duk_to_uint32(ctx, 0);
        fill_str_ptr = (const duk_uint8_t *) &fill_value;
        fill_str_len = 1;
    }
 
    /* Fill offset handling is more lenient than in Node.js. */
 
    duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &fill_offset, &fill_end);
 
    DUK_DDD(DUK_DDDPRINT("fill: fill_value=%02x, fill_offset=%ld, fill_end=%ld, view length=%ld",
                         (unsigned int) fill_value, (long) fill_offset, (long) fill_end, (long) h_this->length));
 
    DUK_ASSERT(fill_end - fill_offset >= 0);
    DUK_ASSERT(h_this->buf != NULL);
 
    p = (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + fill_offset);
    fill_length = (duk_size_t) (fill_end - fill_offset);
    if (fill_str_len == 1) {
        /* Handle single character fills as memset() even when
         * the fill data comes from a one-char argument.
         */
        DUK_MEMSET((void *) p, (int) fill_str_ptr[0], (size_t) fill_length);

◆ duk_bi_nodejs_buffer_is_buffer()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_buffer ( duk_context * ctx )

Definition at line 23850 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.isBuffer()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv;
    duk_hobject *h;
    duk_hobject *h_proto;
    duk_bool_t ret = 0;
 
    thr = (duk_hthread *) ctx;
 
    DUK_ASSERT(duk_get_top(ctx) >= 1);  /* nargs */
    tv = duk_get_tval(ctx, 0);
    DUK_ASSERT(tv != NULL);

◆ duk_bi_nodejs_buffer_is_encoding()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_encoding ( duk_context * ctx )

Definition at line 23828 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}

◆ duk_bi_nodejs_buffer_tojson()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tojson ( duk_context * ctx )

Definition at line 23039 of file duktape-1.8.0/src/duktape.c.

           :
    return DUK_RET_TYPE_ERROR;
}
#else  /* DUK_USE_BUFFEROBJECT_SUPPORT */
DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.prototype: toJSON()
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_this;
    duk_uint8_t *buf;
    duk_uint_t i;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
    h_this = duk__require_bufobj_this(ctx);
    DUK_ASSERT(h_this != NULL);
 
    if (h_this->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_this)) {
        /* Serialize uncovered backing buffer as a null; doesn't
         * really matter as long we're memory safe.
         */
        duk_push_null(ctx);
        return 1;
    }
 
    duk_push_object(ctx);

◆ duk_bi_nodejs_buffer_tostring()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tostring ( duk_context * ctx )

Definition at line 22921 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer: toString([encoding], [start], [end])
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_this;
    duk_int_t start_offset, end_offset;
    duk_uint8_t *buf_slice;
    duk_size_t slice_length;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_this = duk__get_bufobj_this(ctx);
    if (h_this == NULL) {
        /* XXX: happens e.g. when evaluating: String(Buffer.prototype). */
        duk_push_string(ctx, "[object Object]");
        return 1;
    }
    DUK_ASSERT_HBUFFEROBJECT_VALID(h_this);
 
    /* ignore encoding for now */
 
    duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &start_offset, &end_offset);
 
    slice_length = (duk_size_t) (end_offset - start_offset);
    buf_slice = (duk_uint8_t *) duk_push_fixed_buffer(ctx, slice_length);
    DUK_ASSERT(buf_slice != NULL);
 
    if (h_this->buf == NULL) {
        goto type_error;

◆ duk_bi_nodejs_buffer_write()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_write ( duk_context * ctx )

Definition at line 23227 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
/*
 *  Node.js Buffer.prototype.write(string, [offset], [length], [encoding])
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_this;
    duk_uint_t offset;
    duk_uint_t length;
    const duk_uint8_t *str_data;
    duk_size_t str_len;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_this = duk__require_bufobj_this(ctx);
    DUK_ASSERT(h_this != NULL);
 
    /* Argument must be a string, e.g. a buffer is not allowed. */
    str_data = (const duk_uint8_t *) duk_require_lstring(ctx, 0, &str_len);
 
    duk__resolve_offset_opt_length(ctx, h_this, 1, 2, &offset, &length, 0 /*throw_flag*/);
    DUK_ASSERT(offset <= h_this->length);
    DUK_ASSERT(offset + length <= h_this->length);
 
    /* XXX: encoding is ignored now. */

◆ duk_bi_number_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_constructor ( duk_context * ctx )

Definition at line 32920 of file duktape-1.8.0/src/duktape.c.

                                                                       {
        DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
        DUK_ERROR_TYPE((duk_hthread *) ctx, "number expected");
    }
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
    DUK_ASSERT(duk_is_number(ctx, -1));
    DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T",
                         (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
    duk_remove(ctx, -2);
 
 done:
    return duk_get_number(ctx, -1);
}
 
DUK_INTERNAL duk_ret_t duk_bi_number_constructor(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t nargs;
    duk_hobject *h_this;
 
    DUK_UNREF(thr);
 
    /*
     *  The Number constructor uses ToNumber(arg) for number coercion
     *  (coercing an undefined argument to NaN).  However, if the
     *  argument is not given at all, +0 must be used instead.  To do
     *  this, a vararg function is used.
     */
 
    nargs = duk_get_top(ctx);
    if (nargs == 0) {
        duk_push_int(ctx, 0);
    }
    duk_to_number(ctx, 0);
    duk_set_top(ctx, 1);
    DUK_ASSERT_TOP(ctx, 1);
 
    if (!duk_is_constructor_call(ctx)) {
        return 1;
    }
 
    /*
     *  E5 Section 15.7.2.1 requires that the constructed object
     *  must have the original Number.prototype as its internal
     *  prototype.  However, since Number.prototype is non-writable
     *  and non-configurable, this doesn't have to be enforced here:
     *  The default object (bound to 'this') is OK, though we have
     *  to change its class.
     *
     *  Internal value set to ToNumber(arg) or +0; if no arg given,
     *  ToNumber(undefined) = NaN, so special treatment is needed

◆ duk_bi_number_prototype_to_exponential()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_exponential ( duk_context * ctx )

Definition at line 33046 of file duktape-1.8.0/src/duktape.c.

              :
    DUK_ASSERT_TOP(ctx, 2);
    duk_to_string(ctx, -1);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx) {
    duk_bool_t frac_undefined;
    duk_small_int_t frac_digits;
    duk_double_t d;
    duk_small_int_t c;
    duk_small_uint_t n2s_flags;
 
    d = duk__push_this_number_plain(ctx);
 
    frac_undefined = duk_is_undefined(ctx, 0);
    duk_to_int(ctx, 0);  /* for side effects */
 
    c = (duk_small_int_t) DUK_FPCLASSIFY(d);
    if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
        goto use_to_string;
    }

◆ duk_bi_number_prototype_to_fixed()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_fixed ( duk_context * ctx )

Definition at line 33013 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    /* XXX: just use toString() for now; permitted although not recommended.
     * nargs==1, so radix is passed to toString().
     */
    return duk_bi_number_prototype_to_string(ctx);
}
 
/*
 *  toFixed(), toExponential(), toPrecision()
 */
 
/* XXX: shared helper for toFixed(), toExponential(), toPrecision()? */
 
DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx) {
    duk_small_int_t frac_digits;
    duk_double_t d;
    duk_small_int_t c;
    duk_small_uint_t n2s_flags;
 
    frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20);
    d = duk__push_this_number_plain(ctx);
 
    c = (duk_small_int_t) DUK_FPCLASSIFY(d);
    if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
        goto use_to_string;
    }
 
    if (d >= 1.0e21 || d <= -1.0e21) {

◆ duk_bi_number_prototype_to_locale_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_locale_string ( duk_context * ctx )

Definition at line 33000 of file duktape-1.8.0/src/duktape.c.

                                  {
        radix = 10;
    } else {
        radix = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 2, 36);
    }

◆ duk_bi_number_prototype_to_precision()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_precision ( duk_context * ctx )

Definition at line 33080 of file duktape-1.8.0/src/duktape.c.

                                   : DUK_N2S_FLAG_FIXED_FORMAT);
 
    duk_numconv_stringify(ctx,
                          10 /*radix*/,
                          frac_digits + 1 /*leading digit + fractions*/,
                          n2s_flags /*flags*/);
    return 1;
 
 use_to_string:
    DUK_ASSERT_TOP(ctx, 2);
    duk_to_string(ctx, -1);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx) {
    /* The specification has quite awkward order of coercion and
     * checks for toPrecision().  The operations below are a bit
     * reordered, within constraints of observable side effects.
     */
 
    duk_double_t d;
    duk_small_int_t prec;
    duk_small_int_t c;
    duk_small_uint_t n2s_flags;
 
    DUK_ASSERT_TOP(ctx, 1);
 
    d = duk__push_this_number_plain(ctx);
    if (duk_is_undefined(ctx, 0)) {
        goto use_to_string;
    }
    DUK_ASSERT_TOP(ctx, 2);
 
    duk_to_int(ctx, 0);  /* for side effects */
 
    c = (duk_small_int_t) DUK_FPCLASSIFY(d);
    if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
        goto use_to_string;
    }
 
    prec = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 1, 21);
 
    n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |

◆ duk_bi_number_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_string ( duk_context * ctx )

Definition at line 32979 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    (void) duk__push_this_number_plain(ctx);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx) {
    duk_small_int_t radix;
    duk_small_uint_t n2s_flags;

◆ duk_bi_number_prototype_value_of()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_value_of ( duk_context * ctx )

Definition at line 32974 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_object_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor ( duk_context * ctx )

Definition at line 33133 of file duktape-1.8.0/src/duktape.c.

              :
    /* Used when precision is undefined; also used for NaN (-> "NaN"),
     * and +/- infinity (-> "Infinity", "-Infinity").
     */
 
    DUK_ASSERT_TOP(ctx, 2);
    duk_to_string(ctx, -1);
    return 1;
}
#line 1 "duk_bi_object.c"
/*
 *  Object built-ins
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor(duk_context *ctx) {
    if (!duk_is_constructor_call(ctx) &&
        !duk_is_null_or_undefined(ctx, 0)) {
        duk_to_object(ctx, 0);
        return 1;
    }
 
    if (duk_is_object(ctx, 0)) {
        return 1;
    }
 
    /* Pointer and buffer primitive values are treated like other
     * primitives values which have a fully fledged object counterpart:
     * promote to an object value.  Lightfuncs are coerced with
     * ToObject() even they could also be returned as is.

◆ duk_bi_object_constructor_create()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_create ( duk_context * ctx )

Definition at line 33284 of file duktape-1.8.0/src/duktape.c.

     :
    duk_set_top(ctx, 1);
    return ret_success;
 
 fail_nonextensible:
 fail_loop:
    return DUK_RET_TYPE_ERROR;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx) {
    /* XXX: no need for indirect call */
    return duk_hobject_object_get_own_property_descriptor(ctx);
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx) {
    duk_tval *tv;
    duk_hobject *proto = NULL;
 
    DUK_ASSERT_TOP(ctx, 2);
 
    tv = duk_get_tval(ctx, 0);
    DUK_ASSERT(tv != NULL);
    if (DUK_TVAL_IS_NULL(tv)) {
        ;
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        proto = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(proto != NULL);
    } else {
        return DUK_RET_TYPE_ERROR;
    }
 
    (void) duk_push_object_helper_proto(ctx,
                                        DUK_HOBJECT_FLAG_EXTENSIBLE |
                                        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                        proto);
 
    if (!duk_is_undefined(ctx, 1)) {

◆ duk_bi_object_constructor_define_properties()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_properties ( duk_context * ctx )

Definition at line 33395 of file duktape-1.8.0/src/duktape.c.

                                                                                     {
    duk_small_uint_t pass;
    duk_uint_t defprop_flags;
    duk_hobject *obj;
    duk_idx_t idx_value;
    duk_hobject *get;
    duk_hobject *set;
 
    /* Lightfunc handling by ToObject() coercion. */
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);  /* target */
    DUK_ASSERT(obj != NULL);
 
    duk_to_object(ctx, 1);        /* properties object */
 
    DUK_DDD(DUK_DDDPRINT("target=%!iT, properties=%!iT",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1)));
 
    /*
     *  Two pass approach to processing the property descriptors.
     *  On first pass validate and normalize all descriptors before
     *  any changes are made to the target object.  On second pass
     *  make the actual modifications to the target object.
     *
     *  Right now we'll just use the same normalize/validate helper
     *  on both passes, ignoring its outputs on the first pass.
     */
 
    for (pass = 0; pass < 2; pass++) {
        duk_set_top(ctx, 2);  /* -> [ hobject props ] */
        duk_enum(ctx, 1, DUK_ENUM_OWN_PROPERTIES_ONLY /*enum_flags*/);
 
        for (;;) {
            duk_hstring *key;
 
            /* [ hobject props enum(props) ] */
 
            duk_set_top(ctx, 3);
 
            if (!duk_next(ctx, 2, 1 /*get_value*/)) {
                break;
            }
 
            DUK_DDD(DUK_DDDPRINT("-> key=%!iT, desc=%!iT",
                                 (duk_tval *) duk_get_tval(ctx, -2),
                                 (duk_tval *) duk_get_tval(ctx, -1)));
 
            /* [ hobject props enum(props) key desc ] */
 
            duk_hobject_prepare_property_descriptor(ctx,
                                                    4 /*idx_desc*/,
                                                    &defprop_flags,
                                                    &idx_value,
                                                    &get,
                                                    &set);
 
            /* [ hobject props enum(props) key desc value? getter? setter? ] */
 
            if (pass == 0) {
                continue;
            }
 
            key = duk_get_hstring(ctx, 3);
            DUK_ASSERT(key != NULL);
 

◆ duk_bi_object_constructor_define_property()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_property ( duk_context * ctx )

Definition at line 33325 of file duktape-1.8.0/src/duktape.c.

                                                                                   {
    duk_hobject *obj;
    duk_hstring *key;
    duk_hobject *get;
    duk_hobject *set;
    duk_idx_t idx_value;
    duk_uint_t defprop_flags;
 
    DUK_ASSERT(ctx != NULL);
 
    DUK_DDD(DUK_DDDPRINT("Object.defineProperty(): ctx=%p obj=%!T key=%!T desc=%!T",
                         (void *) ctx,
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (duk_tval *) duk_get_tval(ctx, 2)));
 
    /* [ obj key desc ] */
 
    /* Lightfuncs are currently supported by coercing to a temporary
     * Function object; changes will be allowed (the coerced value is
     * extensible) but will be lost.
     */
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    (void) duk_to_string(ctx, 1);
    key = duk_require_hstring(ctx, 1);
    (void) duk_require_hobject(ctx, 2);
 
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(duk_get_hobject(ctx, 2) != NULL);
 
    /*
     *  Validate and convert argument property descriptor (an Ecmascript
     *  object) into a set of defprop_flags and possibly property value,
     *  getter, and/or setter values on the value stack.
     *
     *  Lightfunc set/get values are coerced to full Functions.
     */
 
    duk_hobject_prepare_property_descriptor(ctx,
                                            2 /*idx_desc*/,
                                            &defprop_flags,
                                            &idx_value,
                                            &get,
                                            &set);
 
    /*
     *  Use Object.defineProperty() helper for the actual operation.
     */
 
    duk_hobject_define_property_helper(ctx,
                                       defprop_flags,

◆ duk_bi_object_constructor_get_own_property_descriptor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor ( duk_context * ctx )

Definition at line 33279 of file duktape-1.8.0/src/duktape.c.

                             {
            goto fail_loop;
        }

◆ duk_bi_object_constructor_is_extensible()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_extensible ( duk_context * ctx )

Definition at line 33537 of file duktape-1.8.0/src/duktape.c.

                                                                                           {
    duk_hobject *h;
    duk_bool_t is_frozen;
    duk_bool_t rc;
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    if (!h) {
        duk_push_true(ctx);  /* frozen and sealed */
    } else {
        is_frozen = duk_get_current_magic(ctx);

References duk_get_current_magic(), duk_hobject_object_is_sealed_frozen_helper(), duk_push_boolean(), duk_push_true(), and duk_require_hobject_or_lfunc().

◆ duk_bi_object_constructor_is_sealed_frozen_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared ( duk_context * ctx )

Definition at line 33521 of file duktape-1.8.0/src/duktape.c.

            {
        /* Lightfunc, always success. */
        return 1;
    }
    DUK_ASSERT(h != NULL);
 
    DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
 
    /* A non-extensible object cannot gain any more properties,
     * so this is a good time to compact.
     */
    duk_hobject_compact_props(thr, h);
 
    return 1;

◆ duk_bi_object_constructor_keys_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_keys_shared ( duk_context * ctx )

Definition at line 33552 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_hobject *h;
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    if (!h) {
        duk_push_false(ctx);
    } else {
        duk_push_boolean(ctx, DUK_HOBJECT_HAS_EXTENSIBLE(h));
    }
    return 1;
}
 
/* Shared helper for Object.getOwnPropertyNames() and Object.keys().
 * Magic: 0=getOwnPropertyNames, 1=Object.keys.
 */
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
#if defined(DUK_USE_ES6_PROXY)
    duk_hobject *h_proxy_target;
    duk_hobject *h_proxy_handler;
    duk_hobject *h_trap_result;
    duk_uarridx_t i, len, idx;
#endif
    duk_small_uint_t enum_flags;
 
    DUK_ASSERT_TOP(ctx, 1);
    DUK_UNREF(thr);
 
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    DUK_ASSERT(obj != NULL);
    DUK_UNREF(obj);
 
#if defined(DUK_USE_ES6_PROXY)
    if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
                                            obj,
                                            &h_proxy_target,
                                            &h_proxy_handler))) {
        goto skip_proxy;
    }
 
    duk_push_hobject(ctx, h_proxy_handler);
    if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_OWN_KEYS)) {
        /* Careful with reachability here: don't pop 'obj' before pushing
         * proxy target.
         */
        DUK_DDD(DUK_DDDPRINT("no ownKeys trap, get keys of target instead"));
        duk_pop_2(ctx);
        duk_push_hobject(ctx, h_proxy_target);
        duk_replace(ctx, 0);
        DUK_ASSERT_TOP(ctx, 1);
        goto skip_proxy;
    }
 
    /* [ obj handler trap ] */
    duk_insert(ctx, -2);
    duk_push_hobject(ctx, h_proxy_target);  /* -> [ obj trap handler target ] */
    duk_call_method(ctx, 1 /*nargs*/);      /* -> [ obj trap_result ] */
    h_trap_result = duk_require_hobject(ctx, -1);
    DUK_UNREF(h_trap_result);
 
    len = (duk_uarridx_t) duk_get_length(ctx, -1);
    idx = 0;
    duk_push_array(ctx);
    for (i = 0; i < len; i++) {
        /* [ obj trap_result res_arr ] */
        if (duk_get_prop_index(ctx, -2, i) && duk_is_string(ctx, -1)) {
            /* XXX: for Object.keys() we should check enumerability of key */
            /* [ obj trap_result res_arr propname ] */
            duk_put_prop_index(ctx, -2, idx);
            idx++;
        } else {
            duk_pop(ctx);
        }
    }
 
    /* XXX: missing trap result validation for non-configurable target keys
     * (must be present), for non-extensible target all target keys must be
     * present and no extra keys can be present.
     * http://www.ecma-international.org/ecma-262/6.0/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
     */
 
    /* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result)
     * should be filtered so that only enumerable keys remain.  Enumerability
     * should be checked with [[GetOwnProperty]] on the original object
     * (i.e., the proxy in this case).  If the proxy has a getOwnPropertyDescriptor
     * trap, it should be triggered for every property.  If the proxy doesn't have
     * the trap, enumerability should be checked against the target object instead.
     * We don't do any of this now, so Object.keys() and Object.getOwnPropertyNames()
     * return the same result now for proxy traps.  We still do clean up the trap
     * result, so that Object.keys() and Object.getOwnPropertyNames() will return a
     * clean array of strings without gaps.
     */
    return 1;
 
 skip_proxy:

◆ duk_bi_object_constructor_prevent_extensions()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_prevent_extensions ( duk_context * ctx )

Definition at line 33500 of file duktape-1.8.0/src/duktape.c.

            {
        /* Lightfunc, always success. */
        return 1;
    }
 
    is_freeze = (duk_bool_t) duk_get_current_magic(ctx);
    duk_hobject_object_seal_freeze_helper(thr, h, is_freeze);
 
    /* Sealed and frozen objects cannot gain any more properties,
     * so this is a good time to compact them.
     */
    duk_hobject_compact_props(thr, h);
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;

◆ duk_bi_object_constructor_seal_freeze_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_seal_freeze_shared ( duk_context * ctx )

Definition at line 33478 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_bool_t is_freeze;

◆ duk_bi_object_getprototype_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_getprototype_shared ( duk_context * ctx )

Definition at line 33171 of file duktape-1.8.0/src/duktape.c.

                                                              {
        duk_to_object(ctx, 0);
        return 1;
    }
 
    duk_push_object_helper(ctx,
                           DUK_HOBJECT_FLAG_EXTENSIBLE |
                           DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                           DUK_BIDX_OBJECT_PROTOTYPE);
    return 1;
}
 
/* Shared helper to implement Object.getPrototypeOf and the ES6
 * Object.prototype.__proto__ getter.
 *
 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
 */
DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_hobject *proto;
 
    DUK_UNREF(thr);
 
    /* magic: 0=getter call, 1=Object.getPrototypeOf */
    if (duk_get_current_magic(ctx) == 0) {
        duk_push_this_coercible_to_object(ctx);
        duk_insert(ctx, 0);
    }
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    /* h is NULL for lightfunc */
 
    /* XXX: should the API call handle this directly, i.e. attempt

References duk_to_object().

◆ duk_bi_object_prototype_has_own_property()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_has_own_property ( duk_context * ctx )

Definition at line 33697 of file duktape-1.8.0/src/duktape.c.

33699 {

◆ duk_bi_object_prototype_is_prototype_of()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_is_prototype_of ( duk_context * ctx )

Definition at line 33674 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    DUK_ASSERT_TOP(ctx, 0);
    (void) duk_push_this_coercible_to_object(ctx);
    duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_STRING);
    if (!duk_is_callable(ctx, 1)) {
        return DUK_RET_TYPE_ERROR;
    }
    duk_dup(ctx, 0);  /* -> [ O toString O ] */
    duk_call_method(ctx, 0);  /* XXX: call method tail call? */
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx) {
    (void) duk_push_this_coercible_to_object(ctx);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_v;
    duk_hobject *h_obj;
 

References DUK_ASSERT_TOP, duk_call_method(), duk_dup(), duk_get_prop_stridx(), duk_is_callable, duk_push_this_coercible_to_object(), DUK_RET_TYPE_ERROR, and DUK_STRIDX_TO_STRING.

◆ duk_bi_object_prototype_property_is_enumerable()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_property_is_enumerable ( duk_context * ctx )

Definition at line 33701 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_object_prototype_to_locale_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_locale_string ( duk_context * ctx )

Definition at line 33657 of file duktape-1.8.0/src/duktape.c.

           {
        /* Object.getOwnPropertyNames */
        enum_flags = DUK_ENUM_INCLUDE_NONENUMERABLE |
                     DUK_ENUM_OWN_PROPERTIES_ONLY |
                     DUK_ENUM_NO_PROXY_BEHAVIOR;
    }
 
    return duk_hobject_get_enumerated_keys(ctx, enum_flags);
}
 

◆ duk_bi_object_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_string ( duk_context * ctx )

Definition at line 33651 of file duktape-1.8.0/src/duktape.c.

33654 {

33655 /* Object.keys */

◆ duk_bi_object_prototype_value_of()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_value_of ( duk_context * ctx )

Definition at line 33669 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_object_setprototype_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_setprototype_shared ( duk_context * ctx )

Definition at line 33212 of file duktape-1.8.0/src/duktape.c.

           {
        proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
        if (proto) {
            duk_push_hobject(ctx, proto);
        } else {
            duk_push_null(ctx);
        }
    }
    return 1;
}
 
/* Shared helper to implement ES6 Object.setPrototypeOf and
 * Object.prototype.__proto__ setter.
 *
 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.setprototypeof
 */
DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_obj;
    duk_hobject *h_new_proto;
    duk_hobject *h_curr;
    duk_ret_t ret_success = 1;  /* retval for success path */
 
    /* Preliminaries for __proto__ and setPrototypeOf (E6 19.1.2.18 steps 1-4);
     * magic: 0=setter call, 1=Object.setPrototypeOf
     */
    if (duk_get_current_magic(ctx) == 0) {
        duk_push_this_check_object_coercible(ctx);
        duk_insert(ctx, 0);
        if (!duk_check_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT)) {
            return 0;
        }
 
        /* __proto__ setter returns 'undefined' on success unlike the
         * setPrototypeOf() call which returns the target object.
         */
        ret_success = 0;
    } else {
        duk_require_object_coercible(ctx, 0);
        duk_require_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT);
    }
 
    h_new_proto = duk_get_hobject(ctx, 1);
    /* h_new_proto may be NULL */
    if (duk_is_lightfunc(ctx, 0)) {
        if (h_new_proto == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]) {
            goto skip;
        }
        goto fail_nonextensible;
    }
    h_obj = duk_get_hobject(ctx, 0);
    if (!h_obj) {
        goto skip;
    }
    DUK_ASSERT(h_obj != NULL);
 
    /* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */
    /* TODO: implement Proxy object support here */
 
    if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) {
        goto skip;
    }
    if (!DUK_HOBJECT_HAS_EXTENSIBLE(h_obj)) {
        goto fail_nonextensible;
    }

◆ duk_bi_pointer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_constructor ( duk_context * ctx )

Definition at line 33715 of file duktape-1.8.0/src/duktape.c.

                                                                                        {
    return duk_hobject_object_ownprop_helper(ctx, DUK_PROPDESC_FLAG_ENUMERABLE /*required_desc_flags*/);
}
#line 1 "duk_bi_pointer.c"
/*
 *  Pointer built-ins
 */
 
/* include removed: duk_internal.h */
 
/*
 *  Constructor
 */
 
DUK_INTERNAL duk_ret_t duk_bi_pointer_constructor(duk_context *ctx) {
    /* XXX: this behavior is quite useless now; it would be nice to be able
     * to create pointer values from e.g. numbers or strings.  Numbers are
     * problematic on 64-bit platforms though.  Hex encoded strings?
     */
    if (duk_get_top(ctx) == 0) {
        duk_push_pointer(ctx, NULL);
    } else {
        duk_to_pointer(ctx, 0);
    }

◆ duk_bi_pointer_prototype_tostring_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_prototype_tostring_shared ( duk_context * ctx )

Definition at line 33747 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    duk_tval *tv;
    duk_small_int_t to_string = duk_get_current_magic(ctx);
 
    duk_push_this(ctx);
    tv = duk_require_tval(ctx, -1);
    DUK_ASSERT(tv != NULL);
 
    if (DUK_TVAL_IS_POINTER(tv)) {
        /* nop */
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
 
        /* Must be a "pointer object", i.e. class "Pointer" */

◆ duk_bi_proxy_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor ( duk_context * ctx )

Definition at line 33787 of file duktape-1.8.0/src/duktape.c.

                   {
        duk_to_string(ctx, -1);
    }
    return 1;
 
 type_error:
    return DUK_RET_TYPE_ERROR;
}
#line 1 "duk_bi_proxy.c"
/*
 *  Proxy built-in (ES6)
 */
 
/* include removed: duk_internal.h */
 
#if defined(DUK_USE_ES6_PROXY)
DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) {
    duk_hobject *h_target;
    duk_hobject *h_handler;
 
    if (!duk_is_constructor_call(ctx)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    /* Reject a proxy object as the target because it would need
     * special handler in property lookups.  (ES6 has no such restriction)
     */
    h_target = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    DUK_ASSERT(h_target != NULL);
    if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_target)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    /* Reject a proxy object as the handler because it would cause
     * potentially unbounded recursion.  (ES6 has no such restriction)
     */
    h_handler = duk_require_hobject_or_lfunc_coerce(ctx, 1);
    DUK_ASSERT(h_handler != NULL);
    if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_handler)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    /* XXX: the returned value is exotic in ES6, but we use a
     * simple object here with no prototype.  Without a prototype,
     * [[DefaultValue]] coercion fails which is abit confusing.
     * No callable check/handling in the current Proxy subset.
     */
    (void) duk_push_object_helper_proto(ctx,
                                        DUK_HOBJECT_FLAG_EXTENSIBLE |
                                        DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ |
                                        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                        NULL);

References duk_to_string().

◆ duk_bi_regexp_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_constructor ( duk_context * ctx )

Definition at line 33866 of file duktape-1.8.0/src/duktape.c.

                                                      {
    duk_hobject *h;
 
    duk_push_this(ctx);
    h = duk_require_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_REGEXP);
    DUK_ASSERT(h != NULL);
    DUK_UNREF(h);
    duk_insert(ctx, 0);  /* prepend regexp to valstack 0 index */
}
 
/* XXX: much to improve (code size) */
DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_pattern;
 
    DUK_ASSERT_TOP(ctx, 2);
    h_pattern = duk_get_hobject(ctx, 0);
 
    if (!duk_is_constructor_call(ctx) &&
        h_pattern != NULL &&
        DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP &&
        duk_is_undefined(ctx, 1)) {
        /* Called as a function, pattern has [[Class]] "RegExp" and
         * flags is undefined -> return object as is.
         */
        duk_dup(ctx, 0);
        return 1;
    }
 
    /* Else functionality is identical for function call and constructor
     * call.
     */
 
    if (h_pattern != NULL &&
        DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP) {
        if (duk_is_undefined(ctx, 1)) {
            duk_bool_t flag_g, flag_i, flag_m;
            duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
            flag_g = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
            flag_i = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_IGNORE_CASE, NULL);
            flag_m = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_MULTILINE, NULL);
 
            duk_push_sprintf(ctx, "%s%s%s",
                             (const char *) (flag_g ? "g" : ""),
                             (const char *) (flag_i ? "i" : ""),
                             (const char *) (flag_m ? "m" : ""));
 
            /* [ ... pattern flags ] */
        } else {
            return DUK_RET_TYPE_ERROR;
        }
    } else {
        if (duk_is_undefined(ctx, 0)) {
            duk_push_string(ctx, "");
        } else {
            duk_dup(ctx, 0);
            duk_to_string(ctx, -1);
        }
        if (duk_is_undefined(ctx, 1)) {
            duk_push_string(ctx, "");
        } else {
            duk_dup(ctx, 1);
            duk_to_string(ctx, -1);
        }
 
        /* [ ... pattern flags ] */

References DUK_ASSERT, DUK_HOBJECT_CLASS_REGEXP, duk_insert(), duk_push_this(), duk_require_hobject_with_class(), DUK_UNREF, and NULL.

◆ duk_bi_regexp_prototype_exec()

DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_exec ( duk_context * ctx )

Definition at line 33939 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_regexp_prototype_test()

DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_test ( duk_context * ctx )

Definition at line 33951 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk__get_this_regexp(ctx);
 
    /* [ regexp input ] */
 
    duk_regexp_match((duk_hthread *) ctx);
 
    /* [ result ] */

◆ duk_bi_regexp_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_to_string ( duk_context * ctx )

Definition at line 33966 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk__get_this_regexp(ctx);
 
    /* [ regexp input ] */
 
    /* result object is created and discarded; wasteful but saves code space */
    duk_regexp_match((duk_hthread *) ctx);
 
    /* [ result ] */
 
    duk_push_boolean(ctx, (duk_is_null(ctx, -1) ? 0 : 1));
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) {
    duk_hstring *h_bc;
    duk_small_int_t re_flags;
 
#if 0
    /* A little tricky string approach to provide the flags string.
     * This depends on the specific flag values in duk_regexp.h,
     * which needs to be asserted for.  In practice this doesn't
     * produce more compact code than the easier approach in use.
     */
 
    const char *flag_strings = "gim\0gi\0gm\0g\0";
    duk_uint8_t flag_offsets[8] = {
        (duk_uint8_t) 3,   /* flags: ""    */
        (duk_uint8_t) 10,  /* flags: "g"   */
        (duk_uint8_t) 5,   /* flags: "i"   */
        (duk_uint8_t) 4,   /* flags: "gi"  */
        (duk_uint8_t) 2,   /* flags: "m"   */
        (duk_uint8_t) 7,   /* flags: "gm"  */
        (duk_uint8_t) 1,   /* flags: "im"  */
        (duk_uint8_t) 0,   /* flags: "gim" */
    };
    DUK_ASSERT(DUK_RE_FLAG_GLOBAL == 1);
    DUK_ASSERT(DUK_RE_FLAG_IGNORE_CASE == 2);
    DUK_ASSERT(DUK_RE_FLAG_MULTILINE == 4);
#endif
 
    duk__get_this_regexp(ctx);
 
    /* [ regexp ] */
 
    duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
    duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_BYTECODE);
    h_bc = duk_get_hstring(ctx, -1);
    DUK_ASSERT(h_bc != NULL);
    DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1);
    DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
    DUK_ASSERT(DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);
    re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
 
    /* [ regexp source bytecode ] */
 
#if 1
    /* This is a cleaner approach and also produces smaller code than
     * the other alternative.  Use duk_require_string() for format
     * safety (although the source property should always exist).
     */
    duk_push_sprintf(ctx, "/%s/%s%s%s",
                     (const char *) duk_require_string(ctx, -2),  /* require to be safe */

◆ duk_bi_string_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor ( duk_context * ctx )

Definition at line 34076 of file duktape-1.8.0/src/duktape.c.

                                                                   {
    /* String constructor needs to distinguish between an argument not given at all
     * vs. given as 'undefined'.  We're a vararg function to handle this properly.
     */
 
    if (duk_get_top(ctx) == 0) {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
    } else {
        duk_to_string(ctx, 0);
    }
    DUK_ASSERT(duk_is_string(ctx, 0));

References DUK_ASSERT, duk_get_top(), duk_is_string(), duk_push_hstring_stridx(), duk_set_top(), DUK_STRIDX_EMPTY_STRING, and duk_to_string().

◆ duk_bi_string_constructor_from_char_code()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor_from_char_code ( duk_context * ctx )

Definition at line 34105 of file duktape-1.8.0/src/duktape.c.

                                      {
        duk_push_object_helper(ctx,
                               DUK_HOBJECT_FLAG_EXTENSIBLE |
                               DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ |
                               DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING),
                               DUK_BIDX_STRING_PROTOTYPE);
 
        /* String object internal value is immutable */
        duk_dup(ctx, 0);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
    }
    /* Note: unbalanced stack on purpose */
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
    duk_idx_t i, n;
    duk_ucodepoint_t cp;
 
    /* XXX: It would be nice to build the string directly but ToUint16()
     * coercion is needed so a generic helper would not be very
     * helpful (perhaps coerce the value stack first here and then
     * build a string from a duk_tval number sequence in one go?).
     */
 
    n = duk_get_top(ctx);
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(thr, bw, n);  /* initial estimate for ASCII only codepoints */
 
    for (i = 0; i < n; i++) {
        /* XXX: could improve bufwriter handling to write multiple codepoints
         * with one ensure call but the relative benefit would be quite small.
         */
 
#if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT)
        /* ToUint16() coercion is mandatory in the E5.1 specification, but

References DUK_BIDX_STRING_PROTOTYPE, duk_dup(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_STRING, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_PROPDESC_FLAGS_NONE, duk_push_object_helper(), DUK_STRIDX_INT_VALUE, and duk_xdef_prop_stridx().

◆ duk_bi_string_prototype_caseconv_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_caseconv_shared ( duk_context * ctx )

Definition at line 34357 of file duktape-1.8.0/src/duktape.c.

                             {
        end_pos = start_pos;
    }
 
    DUK_ASSERT(end_pos >= start_pos);

◆ duk_bi_string_prototype_char_at()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_at ( duk_context * ctx )

Definition at line 34189 of file duktape-1.8.0/src/duktape.c.

           {
        goto type_error;
    }
 
    /* never here, but fall through */
 
 type_error:

◆ duk_bi_string_prototype_char_code_at()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_code_at ( duk_context * ctx )

Definition at line 34200 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    duk_int_t pos;
 
    /* XXX: faster implementation */
 
    (void) duk_push_this_coercible_to_string(ctx);
    pos = duk_to_int(ctx, 0);
    duk_substring(ctx, -1, pos, pos + 1);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_int_t pos;
    duk_hstring *h;
    duk_bool_t clamped;
 
    /* XXX: faster implementation */
 
    DUK_DDD(DUK_DDDPRINT("arg=%!T", (duk_tval *) duk_get_tval(ctx, 0)));

◆ duk_bi_string_prototype_concat()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_concat ( duk_context * ctx )

Definition at line 35298 of file duktape-1.8.0/src/duktape.c.

                      {
        duk_push_null(ctx);
    }

◆ duk_bi_string_prototype_indexof_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_indexof_shared ( duk_context * ctx )

Definition at line 34370 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_int_t uppercase = duk_get_current_magic(ctx);
 
    (void) duk_push_this_coercible_to_string(ctx);
    duk_unicode_case_convert_string(thr, (duk_bool_t) uppercase);
    return 1;
}
 
/*
 *  indexOf() and lastIndexOf()
 */
 
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_this;
    duk_hstring *h_search;
    duk_int_t clen_this;
    duk_int_t cpos;
    duk_int_t bpos;
    const duk_uint8_t *p_start, *p_end, *p;
    const duk_uint8_t *q_start;
    duk_int_t q_blen;
    duk_uint8_t firstbyte;
    duk_uint8_t t;
    duk_small_int_t is_lastindexof = duk_get_current_magic(ctx);  /* 0=indexOf, 1=lastIndexOf */
 
    h_this = duk_push_this_coercible_to_string(ctx);
    DUK_ASSERT(h_this != NULL);
    clen_this = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h_this);
 
    h_search = duk_to_hstring(ctx, 0);
    DUK_ASSERT(h_search != NULL);
    q_start = DUK_HSTRING_GET_DATA(h_search);
    q_blen = (duk_int_t) DUK_HSTRING_GET_BYTELEN(h_search);
 
    duk_to_number(ctx, 1);
    if (duk_is_nan(ctx, 1) && is_lastindexof) {
        /* indexOf: NaN should cause pos to be zero.
         * lastIndexOf: NaN should cause pos to be +Infinity
         * (and later be clamped to len).
         */
        cpos = clen_this;
    } else {
        cpos = duk_to_int_clamped(ctx, 1, 0, clen_this);
    }
 
    /* Empty searchstring always matches; cpos must be clamped here.
     * (If q_blen were < 0 due to clamped coercion, it would also be
     * caught here.)
     */
    if (q_blen <= 0) {
        duk_push_int(ctx, cpos);
        return 1;
    }
    DUK_ASSERT(q_blen > 0);
 
    bpos = (duk_int_t) duk_heap_strcache_offset_char2byte(thr, h_this, (duk_uint32_t) cpos);
 
    p_start = DUK_HSTRING_GET_DATA(h_this);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_this);
    p = p_start + bpos;
 
    /* This loop is optimized for size.  For speed, there should be
     * two separate loops, and we should ensure that memcmp() can be
     * used without an extra "will searchstring fit" check.  Doing
     * the preconditioning for 'p' and 'p_end' is easy but cpos
     * must be updated if 'p' is wound back (backward scanning).
     */
 
    firstbyte = q_start[0];  /* leading byte of match string */
    while (p <= p_end && p >= p_start) {
        t = *p;
 
        /* For Ecmascript strings, this check can only match for
         * initial UTF-8 bytes (not continuation bytes).  For other
         * strings all bets are off.
         */
 
        if ((t == firstbyte) && ((duk_size_t) (p_end - p) >= (duk_size_t) q_blen)) {
            DUK_ASSERT(q_blen > 0);  /* no issues with memcmp() zero size, even if broken */
            if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
                duk_push_int(ctx, cpos);
                return 1;
            }
        }
 
        /* track cpos while scanning */
        if (is_lastindexof) {
            /* when going backwards, we decrement cpos 'early';
             * 'p' may point to a continuation byte of the char
             * at offset 'cpos', but that's OK because we'll
             * backtrack all the way to the initial byte.

References duk_get_current_magic(), duk_push_this_coercible_to_string(), and duk_unicode_case_convert_string().

◆ duk_bi_string_prototype_locale_compare()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_locale_compare ( duk_context * ctx )

Definition at line 35314 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    /* duk_concat() coerces arguments with ToString() in correct order */
    (void) duk_push_this_coercible_to_string(ctx);
    duk_insert(ctx, 0);  /* this is relatively expensive */
    duk_concat(ctx, duk_get_top(ctx));
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx) {
    DUK_ASSERT_TOP(ctx, 0);
    (void) duk_push_this_coercible_to_string(ctx);
    duk_trim(ctx, 0);
    DUK_ASSERT_TOP(ctx, 1);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx) {
    duk_hstring *h1;
    duk_hstring *h2;
    duk_size_t h1_len, h2_len, prefix_len;
    duk_small_int_t ret = 0;
    duk_small_int_t rc;
 
    /* The current implementation of localeCompare() is simply a codepoint
     * by codepoint comparison, implemented with a simple string compare
     * because UTF-8 should preserve codepoint ordering (assuming valid
     * shortest UTF-8 encoding).
     *
     * The specification requires that the return value must be related
     * to the sort order: e.g. negative means that 'this' comes before
     * 'that' in sort order.  We assume an ascending sort order.
     */
 
    /* XXX: could share code with duk_js_ops.c, duk_js_compare_helper */
 
    h1 = duk_push_this_coercible_to_string(ctx);
    DUK_ASSERT(h1 != NULL);
 
    h2 = duk_to_hstring(ctx, 0);
    DUK_ASSERT(h2 != NULL);
 
    h1_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1);
    h2_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2);
    prefix_len = (h1_len <= h2_len ? h1_len : h2_len);
 
    /* Zero size compare not an issue with DUK_MEMCMP. */
    rc = (duk_small_int_t) DUK_MEMCMP((const void *) DUK_HSTRING_GET_DATA(h1),
                                      (const void *) DUK_HSTRING_GET_DATA(h2),
                                      (size_t) prefix_len);
 
    if (rc < 0) {
        ret = -1;
        goto done;
    } else if (rc > 0) {
        ret = 1;
        goto done;

References duk_concat(), duk_get_top(), duk_insert(), and duk_push_this_coercible_to_string().

◆ duk_bi_string_prototype_match()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_match ( duk_context * ctx )

Definition at line 35220 of file duktape-1.8.0/src/duktape.c.

                                 {
        duk_push_int(ctx, -1);
        return 1;
    }
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
    DUK_ASSERT(duk_is_number(ctx, -1));
    return 1;
}
#else  /* DUK_USE_REGEXP_SUPPORT */
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_REGEXP_SUPPORT */
 
#ifdef DUK_USE_REGEXP_SUPPORT
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_bool_t global;
    duk_int_t prev_last_index;
    duk_int_t this_index;
    duk_int_t arr_idx;
 
    DUK_ASSERT_TOP(ctx, 1);
    (void) duk_push_this_coercible_to_string(ctx);
    duk__to_regexp_helper(ctx, 0 /*index*/, 0 /*force_new*/);
    global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
    DUK_ASSERT_TOP(ctx, 2);
 
    /* stack[0] = regexp
     * stack[1] = string
     */
 
    if (!global) {
        duk_regexp_match(thr);  /* -> [ res_obj ] */
        return 1;  /* return 'res_obj' */
    }
 
    /* Global case is more complex. */
 
    /* [ regexp string ] */
 
    duk_push_int(ctx, 0);
    duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
    duk_push_array(ctx);
 
    /* [ regexp string res_arr ] */
 
    prev_last_index = 0;
    arr_idx = 0;
 
    for (;;) {
        DUK_ASSERT_TOP(ctx, 3);
 
        duk_dup(ctx, 0);
        duk_dup(ctx, 1);
        duk_regexp_match(thr);  /* -> [ ... regexp string ] -> [ ... res_obj ] */
 
        if (!duk_is_object(ctx, -1)) {
            duk_pop(ctx);
            break;
        }
 
        duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
        DUK_ASSERT(duk_is_number(ctx, -1));
        this_index = duk_get_int(ctx, -1);
        duk_pop(ctx);
 
        if (this_index == prev_last_index) {
            this_index++;

References duk_push_int().

◆ duk_bi_string_prototype_replace()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_replace ( duk_context * ctx )

Definition at line 34483 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_input;
    duk_hstring *h_match;
    duk_hstring *h_search;
    duk_hobject *h_re;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
#ifdef DUK_USE_REGEXP_SUPPORT
    duk_bool_t is_regexp;
    duk_bool_t is_global;
#endif
    duk_bool_t is_repl_func;
    duk_uint32_t match_start_coff, match_start_boff;
#ifdef DUK_USE_REGEXP_SUPPORT
    duk_int_t match_caps;
#endif
    duk_uint32_t prev_match_end_boff;
    const duk_uint8_t *r_start, *r_end, *r;   /* repl string scan */
    duk_size_t tmp_sz;
 
    DUK_ASSERT_TOP(ctx, 2);
    h_input = duk_push_this_coercible_to_string(ctx);
    DUK_ASSERT(h_input != NULL);
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input));  /* input size is good output starting point */
 
    DUK_ASSERT_TOP(ctx, 4);
 
    /* stack[0] = search value
     * stack[1] = replace value
     * stack[2] = input string
     * stack[3] = result buffer
     */
 
    h_re = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP);
    if (h_re) {
#ifdef DUK_USE_REGEXP_SUPPORT
        is_regexp = 1;
        is_global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
 
        if (is_global) {
            /* start match from beginning */
            duk_push_int(ctx, 0);
            duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
        }
#else  /* DUK_USE_REGEXP_SUPPORT */
        return DUK_RET_UNSUPPORTED_ERROR;
#endif  /* DUK_USE_REGEXP_SUPPORT */
    } else {
        duk_to_string(ctx, 0);
#ifdef DUK_USE_REGEXP_SUPPORT
        is_regexp = 0;
        is_global = 0;
#endif
    }
 
    if (duk_is_function(ctx, 1)) {
        is_repl_func = 1;
        r_start = NULL;
        r_end = NULL;
    } else {
        duk_hstring *h_repl;
 
        is_repl_func = 0;
        h_repl = duk_to_hstring(ctx, 1);
        DUK_ASSERT(h_repl != NULL);
        r_start = DUK_HSTRING_GET_DATA(h_repl);
        r_end = r_start + DUK_HSTRING_GET_BYTELEN(h_repl);
    }
 
    prev_match_end_boff = 0;
 
    for (;;) {
        /*
         *  If matching with a regexp:
         *    - non-global RegExp: lastIndex not touched on a match, zeroed
         *      on a non-match
         *    - global RegExp: on match, lastIndex will be updated by regexp
         *      executor to point to next char after the matching part (so that
         *      characters in the matching part are not matched again)
         *
         *  If matching with a string:
         *    - always non-global match, find first occurrence
         *
         *  We need:
         *    - The character offset of start-of-match for the replacer function
         *    - The byte offsets for start-of-match and end-of-match to implement
         *      the replacement values $&, $`, and $', and to copy non-matching
         *      input string portions (including header and trailer) verbatim.
         *
         *  NOTE: the E5.1 specification is a bit vague how the RegExp should
         *  behave in the replacement process; e.g. is matching done first for
         *  all matches (in the global RegExp case) before any replacer calls
         *  are made?  See: test-bi-string-proto-replace.js for discussion.
         */
 
        DUK_ASSERT_TOP(ctx, 4);
 
#ifdef DUK_USE_REGEXP_SUPPORT
        if (is_regexp) {
            duk_dup(ctx, 0);
            duk_dup(ctx, 2);
            duk_regexp_match(thr);  /* [ ... regexp input ] -> [ res_obj ] */
            if (!duk_is_object(ctx, -1)) {
                duk_pop(ctx);
                break;
            }
 
            duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
            DUK_ASSERT(duk_is_number(ctx, -1));
            match_start_coff = duk_get_int(ctx, -1);
            duk_pop(ctx);
 
            duk_get_prop_index(ctx, -1, 0);
            DUK_ASSERT(duk_is_string(ctx, -1));
            h_match = duk_get_hstring(ctx, -1);
            DUK_ASSERT(h_match != NULL);
            duk_pop(ctx);  /* h_match is borrowed, remains reachable through match_obj */
 
            if (DUK_HSTRING_GET_BYTELEN(h_match) == 0) {
                /* This should be equivalent to match() algorithm step 8.f.iii.2:
                 * detect an empty match and allow it, but don't allow it twice.
                 */
                duk_uint32_t last_index;
 
                duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
                last_index = (duk_uint32_t) duk_get_uint(ctx, -1);
                DUK_DDD(DUK_DDDPRINT("empty match, bump lastIndex: %ld -> %ld",
                                     (long) last_index, (long) (last_index + 1)));
                duk_pop(ctx);
                duk_push_int(ctx, last_index + 1);
                duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
            }
 
            DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_INT_MAX);  /* string limits */
            match_caps = (duk_int_t) duk_get_length(ctx, -1);
        } else {
#else  /* DUK_USE_REGEXP_SUPPORT */
        {  /* unconditionally */
#endif  /* DUK_USE_REGEXP_SUPPORT */
            const duk_uint8_t *p_start, *p_end, *p;   /* input string scan */
            const duk_uint8_t *q_start;               /* match string */
            duk_size_t q_blen;
 
#ifdef DUK_USE_REGEXP_SUPPORT
            DUK_ASSERT(!is_global);  /* single match always */
#endif
 
            p_start = DUK_HSTRING_GET_DATA(h_input);
            p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
            p = p_start;
 
            h_search = duk_get_hstring(ctx, 0);
            DUK_ASSERT(h_search != NULL);
            q_start = DUK_HSTRING_GET_DATA(h_search);
            q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_search);
 
            p_end -= q_blen;  /* ensure full memcmp() fits in while */
 
            match_start_coff = 0;
 
            while (p <= p_end) {
                DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
                if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
                    duk_dup(ctx, 0);
                    h_match = duk_get_hstring(ctx, -1);
                    DUK_ASSERT(h_match != NULL);
#ifdef DUK_USE_REGEXP_SUPPORT
                    match_caps = 0;
#endif
                    goto found;
                }
 
                /* track utf-8 non-continuation bytes */
                if ((p[0] & 0xc0) != 0x80) {
                    match_start_coff++;
                }
                p++;
            }
 
            /* not found */
            break;
        }
     found:
 
        /* stack[0] = search value
         * stack[1] = replace value
         * stack[2] = input string
         * stack[3] = result buffer
         * stack[4] = regexp match OR match string
         */
 
        match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
 
        tmp_sz = (duk_size_t) (match_start_boff - prev_match_end_boff);
        DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz);
 
        prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match);
 
        if (is_repl_func) {
            duk_idx_t idx_args;
            duk_hstring *h_repl;
 
            /* regexp res_obj is at index 4 */
 
            duk_dup(ctx, 1);
            idx_args = duk_get_top(ctx);
 
#ifdef DUK_USE_REGEXP_SUPPORT
            if (is_regexp) {
                duk_int_t idx;
                duk_require_stack(ctx, match_caps + 2);
                for (idx = 0; idx < match_caps; idx++) {
                    /* match followed by capture(s) */
                    duk_get_prop_index(ctx, 4, idx);
                }
            } else {
#else  /* DUK_USE_REGEXP_SUPPORT */
            {  /* unconditionally */
#endif  /* DUK_USE_REGEXP_SUPPORT */
                /* match == search string, by definition */
                duk_dup(ctx, 0);
            }
            duk_push_int(ctx, match_start_coff);
            duk_dup(ctx, 2);
 
            /* [ ... replacer match [captures] match_char_offset input ] */
 
            duk_call(ctx, duk_get_top(ctx) - idx_args);
            h_repl = duk_to_hstring(ctx, -1);  /* -> [ ... repl_value ] */
            DUK_ASSERT(h_repl != NULL);
 
            DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_repl);
 
            duk_pop(ctx);  /* repl_value */
        } else {
            r = r_start;
 
            while (r < r_end) {
                duk_int_t ch1;
                duk_int_t ch2;
#ifdef DUK_USE_REGEXP_SUPPORT
                duk_int_t ch3;
#endif
                duk_size_t left;
 
                ch1 = *r++;
                if (ch1 != DUK_ASC_DOLLAR) {
                    goto repl_write;
                }
                left = r_end - r;
 
                if (left <= 0) {
                    goto repl_write;
                }
 
                ch2 = r[0];
                switch ((int) ch2) {
                case DUK_ASC_DOLLAR: {
                    ch1 = (1 << 8) + DUK_ASC_DOLLAR;
                    goto repl_write;
                }
                case DUK_ASC_AMP: {
                    DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_match);
                    r++;
                    continue;
                }
                case DUK_ASC_GRAVE: {
                    tmp_sz = (duk_size_t) match_start_boff;
                    DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input), tmp_sz);
                    r++;
                    continue;
                }
                case DUK_ASC_SINGLEQUOTE: {
                    duk_uint32_t match_end_boff;
 
                    /* Use match charlen instead of bytelen, just in case the input and
                     * match codepoint encodings would have different lengths.
                     */
                    match_end_boff = duk_heap_strcache_offset_char2byte(thr,
                                                                        h_input,
                                                                        match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match));
 
                    tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff);
                    DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + match_end_boff, tmp_sz);
                    r++;
                    continue;
                }
                default: {
#ifdef DUK_USE_REGEXP_SUPPORT
                    duk_int_t capnum, captmp, capadv;
                    /* XXX: optional check, match_caps is zero if no regexp,
                     * so dollar will be interpreted literally anyway.
                     */
 
                    if (!is_regexp) {
                        goto repl_write;
                    }
 
                    if (!(ch2 >= DUK_ASC_0 && ch2 <= DUK_ASC_9)) {
                        goto repl_write;
                    }
                    capnum = ch2 - DUK_ASC_0;
                    capadv = 1;
 
                    if (left >= 2) {
                        ch3 = r[1];
                        if (ch3 >= DUK_ASC_0 && ch3 <= DUK_ASC_9) {
                            captmp = capnum * 10 + (ch3 - DUK_ASC_0);
                            if (captmp < match_caps) {
                                capnum = captmp;
                                capadv = 2;
                            }
                        }
                    }
 
                    if (capnum > 0 && capnum < match_caps) {
                        DUK_ASSERT(is_regexp != 0);  /* match_caps == 0 without regexps */
 
                        /* regexp res_obj is at offset 4 */
                        duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum);
                        if (duk_is_string(ctx, -1)) {
                            duk_hstring *h_tmp_str;
 
                            h_tmp_str = duk_get_hstring(ctx, -1);
                            DUK_ASSERT(h_tmp_str != NULL);
 
                            DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_tmp_str);
                        } else {
                            /* undefined -> skip (replaced with empty) */
                        }
                        duk_pop(ctx);
                        r += capadv;
                        continue;
                    } else {
                        goto repl_write;
                    }
#else  /* DUK_USE_REGEXP_SUPPORT */
                    goto repl_write;  /* unconditionally */
#endif  /* DUK_USE_REGEXP_SUPPORT */
                }  /* default case */
                }  /* switch (ch2) */
 
             repl_write:
                /* ch1 = (r_increment << 8) + byte */
 
                DUK_BW_WRITE_ENSURE_U8(thr, bw, (duk_uint8_t) (ch1 & 0xff));
                r += ch1 >> 8;
            }  /* while repl */
        }  /* if (is_repl_func) */
 
        duk_pop(ctx);  /* pop regexp res_obj or match string */
 
#ifdef DUK_USE_REGEXP_SUPPORT

◆ duk_bi_string_prototype_search()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_search ( duk_context * ctx )

Definition at line 35174 of file duktape-1.8.0/src/duktape.c.

            {
        goto do_new;
    }
    return;
 
 do_new:
    duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
    duk_dup(ctx, index);
    duk_new(ctx, 1);  /* [ ... RegExp val ] -> [ ... res ] */
    duk_replace(ctx, index);
}
#endif  /* DUK_USE_REGEXP_SUPPORT */
 
#ifdef DUK_USE_REGEXP_SUPPORT
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    /* Easiest way to implement the search required by the specification
     * is to do a RegExp test() with lastIndex forced to zero.  To avoid
     * side effects on the argument, "clone" the RegExp if a RegExp was
     * given as input.
     *
     * The global flag of the RegExp should be ignored; setting lastIndex
     * to zero (which happens when "cloning" the RegExp) should have an
     * equivalent effect.
     */
 
    DUK_ASSERT_TOP(ctx, 1);
    (void) duk_push_this_coercible_to_string(ctx);  /* at index 1 */
    duk__to_regexp_helper(ctx, 0 /*index*/, 1 /*force_new*/);
 
    /* stack[0] = regexp
     * stack[1] = string
     */
 

◆ duk_bi_string_prototype_slice()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_slice ( duk_context * ctx )

Definition at line 34317 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_SECTION_B */
 
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx) {
    duk_hstring *h;
    duk_int_t start_pos, end_pos;
    duk_int_t len;
 
    h = duk_push_this_coercible_to_string(ctx);
    DUK_ASSERT(h != NULL);
    len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
 
    /* [ start end str ] */
 
    start_pos = duk_to_int_clamped(ctx, 0, -len, len);
    if (start_pos < 0) {
        start_pos = len + start_pos;
    }
    if (duk_is_undefined(ctx, 1)) {
        end_pos = len;
    } else {

◆ duk_bi_string_prototype_split()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_split ( duk_context * ctx )

Definition at line 34865 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_input;
    duk_hstring *h_sep;
    duk_uint32_t limit;
    duk_uint32_t arr_idx;
#ifdef DUK_USE_REGEXP_SUPPORT
    duk_bool_t is_regexp;
#endif
    duk_bool_t matched;  /* set to 1 if any match exists (needed for empty input special case) */
    duk_uint32_t prev_match_end_coff, prev_match_end_boff;
    duk_uint32_t match_start_boff, match_start_coff;
    duk_uint32_t match_end_boff, match_end_coff;
 
    DUK_UNREF(thr);
 
    h_input = duk_push_this_coercible_to_string(ctx);
    DUK_ASSERT(h_input != NULL);
 
    duk_push_array(ctx);
 
    if (duk_is_undefined(ctx, 1)) {
        limit = 0xffffffffUL;
    } else {
        limit = duk_to_uint32(ctx, 1);
    }
 
    if (limit == 0) {
        return 1;
    }
 
    /* If the separator is a RegExp, make a "clone" of it.  The specification
     * algorithm calls [[Match]] directly for specific indices; we emulate this
     * by tweaking lastIndex and using a "force global" variant of duk_regexp_match()
     * which will use global-style matching even when the RegExp itself is non-global.
     */
 
    if (duk_is_undefined(ctx, 0)) {
        /* The spec algorithm first does "R = ToString(separator)" before checking
         * whether separator is undefined.  Since this is side effect free, we can
         * skip the ToString() here.
         */
        duk_dup(ctx, 2);
        duk_put_prop_index(ctx, 3, 0);
        return 1;
    } else if (duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP) != NULL) {
#ifdef DUK_USE_REGEXP_SUPPORT
        duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
        duk_dup(ctx, 0);
        duk_new(ctx, 1);  /* [ ... RegExp val ] -> [ ... res ] */
        duk_replace(ctx, 0);
        /* lastIndex is initialized to zero by new RegExp() */
        is_regexp = 1;
#else
        return DUK_RET_UNSUPPORTED_ERROR;
#endif
    } else {
        duk_to_string(ctx, 0);
#ifdef DUK_USE_REGEXP_SUPPORT
        is_regexp = 0;
#endif
    }
 
    /* stack[0] = separator (string or regexp)
     * stack[1] = limit
     * stack[2] = input string
     * stack[3] = result array
     */
 
    prev_match_end_boff = 0;
    prev_match_end_coff = 0;
    arr_idx = 0;
    matched = 0;
 
    for (;;) {
        /*
         *  The specification uses RegExp [[Match]] to attempt match at specific
         *  offsets.  We don't have such a primitive, so we use an actual RegExp
         *  and tweak lastIndex.  Since the RegExp may be non-global, we use a
         *  special variant which forces global-like behavior for matching.
         */
 
        DUK_ASSERT_TOP(ctx, 4);
 
#ifdef DUK_USE_REGEXP_SUPPORT
        if (is_regexp) {
            duk_dup(ctx, 0);
            duk_dup(ctx, 2);
            duk_regexp_match_force_global(thr);  /* [ ... regexp input ] -> [ res_obj ] */
            if (!duk_is_object(ctx, -1)) {
                duk_pop(ctx);
                break;
            }
            matched = 1;
 
            duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
            DUK_ASSERT(duk_is_number(ctx, -1));
            match_start_coff = duk_get_int(ctx, -1);
            match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
            duk_pop(ctx);
 
            if (match_start_coff == DUK_HSTRING_GET_CHARLEN(h_input)) {
                /* don't allow an empty match at the end of the string */
                duk_pop(ctx);
                break;
            }
 
            duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
            DUK_ASSERT(duk_is_number(ctx, -1));
            match_end_coff = duk_get_int(ctx, -1);
            match_end_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_end_coff);
            duk_pop(ctx);
 
            /* empty match -> bump and continue */
            if (prev_match_end_boff == match_end_boff) {
                duk_push_int(ctx, match_end_coff + 1);
                duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
                duk_pop(ctx);
                continue;
            }
        } else {
#else  /* DUK_USE_REGEXP_SUPPORT */
        {  /* unconditionally */
#endif  /* DUK_USE_REGEXP_SUPPORT */
            const duk_uint8_t *p_start, *p_end, *p;   /* input string scan */
            const duk_uint8_t *q_start;               /* match string */
            duk_size_t q_blen, q_clen;
 
            p_start = DUK_HSTRING_GET_DATA(h_input);
            p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
            p = p_start + prev_match_end_boff;
 
            h_sep = duk_get_hstring(ctx, 0);
            DUK_ASSERT(h_sep != NULL);
            q_start = DUK_HSTRING_GET_DATA(h_sep);
            q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sep);
            q_clen = (duk_size_t) DUK_HSTRING_GET_CHARLEN(h_sep);
 
            p_end -= q_blen;  /* ensure full memcmp() fits in while */
 
            match_start_coff = prev_match_end_coff;
 
            if (q_blen == 0) {
                /* Handle empty separator case: it will always match, and always
                 * triggers the check in step 13.c.iii initially.  Note that we
                 * must skip to either end of string or start of first codepoint,
                 * skipping over any continuation bytes!
                 *
                 * Don't allow an empty string to match at the end of the input.
                 */
 
                matched = 1;  /* empty separator can always match */
 
                match_start_coff++;
                p++;
                while (p < p_end) {
                    if ((p[0] & 0xc0) != 0x80) {
                        goto found;
                    }
                    p++;
                }
                goto not_found;
            }
 
            DUK_ASSERT(q_blen > 0 && q_clen > 0);
            while (p <= p_end) {
                DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
                DUK_ASSERT(q_blen > 0);  /* no issues with empty memcmp() */
                if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
                    /* never an empty match, so step 13.c.iii can't be triggered */
                    goto found;
                }
 
                /* track utf-8 non-continuation bytes */
                if ((p[0] & 0xc0) != 0x80) {
                    match_start_coff++;
                }
                p++;
            }
 
         not_found:
            /* not found */
            break;
 
         found:
            matched = 1;
            match_start_boff = (duk_uint32_t) (p - p_start);
            match_end_coff = (duk_uint32_t) (match_start_coff + q_clen);  /* constrained by string length */
            match_end_boff = (duk_uint32_t) (match_start_boff + q_blen);  /* ditto */
 
            /* empty match (may happen with empty separator) -> bump and continue */
            if (prev_match_end_boff == match_end_boff) {
                prev_match_end_boff++;
                prev_match_end_coff++;
                continue;
            }
        }  /* if (is_regexp) */
 
        /* stack[0] = separator (string or regexp)
         * stack[1] = limit
         * stack[2] = input string
         * stack[3] = result array
         * stack[4] = regexp res_obj (if is_regexp)
         */
 
        DUK_DDD(DUK_DDDPRINT("split; match_start b=%ld,c=%ld, match_end b=%ld,c=%ld, prev_end b=%ld,c=%ld",
                             (long) match_start_boff, (long) match_start_coff,
                             (long) match_end_boff, (long) match_end_coff,
                             (long) prev_match_end_boff, (long) prev_match_end_coff));
 
        duk_push_lstring(ctx,
                         (const char *) (DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff),
                         (duk_size_t) (match_start_boff - prev_match_end_boff));
        duk_put_prop_index(ctx, 3, arr_idx);
        arr_idx++;
        if (arr_idx >= limit) {
            goto hit_limit;
        }
 
#ifdef DUK_USE_REGEXP_SUPPORT
        if (is_regexp) {
            duk_size_t i, len;
 
            len = duk_get_length(ctx, 4);
            for (i = 1; i < len; i++) {
                DUK_ASSERT(i <= DUK_UARRIDX_MAX);  /* cannot have >4G captures */
                duk_get_prop_index(ctx, 4, (duk_uarridx_t) i);
                duk_put_prop_index(ctx, 3, arr_idx);
                arr_idx++;
                if (arr_idx >= limit) {
                    goto hit_limit;
                }
            }
 
            duk_pop(ctx);
            /* lastIndex already set up for next match */
        } else {
#else  /* DUK_USE_REGEXP_SUPPORT */
        {  /* unconditionally */
#endif  /* DUK_USE_REGEXP_SUPPORT */
            /* no action */
        }
 
        prev_match_end_boff = match_end_boff;
        prev_match_end_coff = match_end_coff;
        continue;
    }  /* for */
 
    /* Combined step 11 (empty string special case) and 14-15. */
 
    DUK_DDD(DUK_DDDPRINT("split trailer; prev_end b=%ld,c=%ld",
                         (long) prev_match_end_boff, (long) prev_match_end_coff));
 
    if (DUK_HSTRING_GET_CHARLEN(h_input) > 0 || !matched) {
        /* Add trailer if:
         *   a) non-empty input
         *   b) empty input and no (zero size) match found (step 11)
         */
 
        duk_push_lstring(ctx,

◆ duk_bi_string_prototype_substr()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substr ( duk_context * ctx )

Definition at line 34268 of file duktape-1.8.0/src/duktape.c.

                             {
        duk_int_t tmp = start_pos;
        start_pos = end_pos;
        end_pos = tmp;
    }
 
    DUK_ASSERT(end_pos >= start_pos);
 
    duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
    return 1;
}
 
#ifdef DUK_USE_SECTION_B
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) {
    duk_hstring *h;
    duk_int_t start_pos, end_pos;
    duk_int_t len;
 
    /* Unlike non-obsolete String calls, substr() algorithm in E5.1
     * specification will happily coerce undefined and null to strings
     * ("undefined" and "null").
     */
    duk_push_this(ctx);
    h = duk_to_hstring(ctx, -1);
    DUK_ASSERT(h != NULL);
    len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
 
    /* [ start length str ] */
 
    /* The implementation for computing of start_pos and end_pos differs
     * from the standard algorithm, but is intended to result in the exactly
     * same behavior.  This is not always obvious.
     */
 
    /* combines steps 2 and 5; -len ensures max() not needed for step 5 */
    start_pos = duk_to_int_clamped(ctx, 0, -len, len);
    if (start_pos < 0) {
        start_pos = len + start_pos;

◆ duk_bi_string_prototype_substring()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substring ( duk_context * ctx )

Definition at line 34235 of file duktape-1.8.0/src/duktape.c.

                 {
        duk_push_number(ctx, DUK_DOUBLE_NAN);
        return 1;
    }
 
    duk_push_u32(ctx, (duk_uint32_t) duk_hstring_char_code_at_raw(thr, h, pos));
    return 1;
}
 
/*
 *  substring(), substr(), slice()
 */
 
/* XXX: any chance of merging these three similar but still slightly
 * different algorithms so that footprint would be reduced?
 */
 
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx) {
    duk_hstring *h;
    duk_int_t start_pos, end_pos;
    duk_int_t len;
 
    h = duk_push_this_coercible_to_string(ctx);
    DUK_ASSERT(h != NULL);
    len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
 
    /* [ start end str ] */
 
    start_pos = duk_to_int_clamped(ctx, 0, 0, len);
    if (duk_is_undefined(ctx, 1)) {
        end_pos = len;

References DUK_DOUBLE_NAN, and duk_push_number().

◆ duk_bi_string_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_to_string ( duk_context * ctx )

Definition at line 34152 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_tval *tv;
 
    duk_push_this(ctx);
    tv = duk_require_tval(ctx, -1);
    DUK_ASSERT(tv != NULL);
 
    if (DUK_TVAL_IS_STRING(tv)) {
        /* return as is */
        return 1;
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
 
        /* Must be a "string object", i.e. class "String" */

◆ duk_bi_string_prototype_trim()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_trim ( duk_context * ctx )

Definition at line 35306 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}

◆ duk_bi_thread_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_constructor ( duk_context * ctx )

Definition at line 35382 of file duktape-1.8.0/src/duktape.c.

     :
    duk_push_int(ctx, (duk_int_t) ret);
    return 1;
}
#line 1 "duk_bi_thread.c"
/*
 *  Thread builtins
 */
 
/* include removed: duk_internal.h */
 
/*
 *  Constructor
 */
 
DUK_INTERNAL duk_ret_t duk_bi_thread_constructor(duk_context *ctx) {
    duk_hthread *new_thr;
    duk_hobject *func;
 
    /* XXX: need a duk_require_func_or_lfunc_coerce() */
    if (!duk_is_callable(ctx, 0)) {

◆ duk_bi_thread_current()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_current ( duk_context * ctx )

Definition at line 35673 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_thread_resume()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_resume ( duk_context * ctx )

Definition at line 35421 of file duktape-1.8.0/src/duktape.c.

                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hthread *thr_resume;
    duk_tval *tv;
    duk_hobject *func;
    duk_hobject *caller_func;
    duk_small_int_t is_error;
 
    DUK_DDD(DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (duk_tval *) duk_get_tval(ctx, 2)));
 
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
    DUK_ASSERT(thr->heap->curr_thread == thr);
 
    thr_resume = duk_require_hthread(ctx, 0);
    is_error = (duk_small_int_t) duk_to_boolean(ctx, 2);
    duk_set_top(ctx, 2);
 
    /* [ thread value ] */
 
    /*
     *  Thread state and calling context checks
     */
 
    if (thr->callstack_top < 2) {
        DUK_DD(DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)"));
        goto state_error;
    }
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
    DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
 
    caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
    if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
        DUK_DD(DUK_DDPRINT("resume state invalid: caller must be Ecmascript code"));
        goto state_error;
    }
 
    /* Note: there is no requirement that: 'thr->callstack_preventcount == 1'
     * like for yield.
     */
 
    if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE &&
        thr_resume->state != DUK_HTHREAD_STATE_YIELDED) {
        DUK_DD(DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED"));
        goto state_error;
    }
 
    DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE ||
               thr_resume->state == DUK_HTHREAD_STATE_YIELDED);
 
    /* Further state-dependent pre-checks */
 
    if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
        /* no pre-checks now, assume a previous yield() has left things in
         * tip-top shape (longjmp handler will assert for these).
         */
    } else {
        DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE);
 
        if ((thr_resume->callstack_top != 0) ||
            (thr_resume->valstack_top - thr_resume->valstack != 1)) {
            goto state_invalid_initial;
        }
        tv = &thr_resume->valstack_top[-1];
        DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top);
        if (!DUK_TVAL_IS_OBJECT(tv)) {
            goto state_invalid_initial;
        }
        func = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(func != NULL);
        if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
            /* Note: cannot be a bound function either right now,
             * this would be easy to relax though.
             */
            goto state_invalid_initial;
        }
 
    }
 
    /*
     *  The error object has been augmented with a traceback and other
     *  info from its creation point -- usually another thread.  The
     *  error handler is called here right before throwing, but it also
     *  runs in the resumer's thread.  It might be nice to get a traceback
     *  from the resumee but this is not the case now.
     */
 
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
    if (is_error) {
        DUK_ASSERT_TOP(ctx, 2);  /* value (error) is at stack top */
        duk_err_augment_error_throw(thr);  /* in resumer's context */
    }
#endif
 
#ifdef DUK_USE_DEBUG
    if (is_error) {
        DUK_DDD(DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0),
                             (duk_tval *) duk_get_tval(ctx, 1)));
    } else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
        DUK_DDD(DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0),
                             (duk_tval *) duk_get_tval(ctx, 1)));
    } else {
        DUK_DDD(DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0),
                             (duk_tval *) duk_get_tval(ctx, 1)));
    }
#endif
 
    thr->heap->lj.type = DUK_LJ_TYPE_RESUME;
 
    /* lj value2: thread */
    DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
    DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value2, &thr->valstack_bottom[0]);  /* side effects */
 
    /* lj value1: value */
    DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top);

◆ duk_bi_thread_yield()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_yield ( duk_context * ctx )

Definition at line 35575 of file duktape-1.8.0/src/duktape.c.

                                                             {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *caller_func;
    duk_small_int_t is_error;
 
    DUK_DDD(DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1)));
 
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
    DUK_ASSERT(thr->heap->curr_thread == thr);
 
    is_error = (duk_small_int_t) duk_to_boolean(ctx, 1);
    duk_set_top(ctx, 1);
 
    /* [ value ] */
 
    /*
     *  Thread state and calling context checks
     */
 
    if (!thr->resumer) {
        DUK_DD(DUK_DDPRINT("yield state invalid: current thread must have a resumer"));
        goto state_error;
    }
    DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
 
    if (thr->callstack_top < 2) {
        DUK_DD(DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)"));
        goto state_error;
    }
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
    DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
 
    caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
    if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
        DUK_DD(DUK_DDPRINT("yield state invalid: caller must be Ecmascript code"));
        goto state_error;
    }
 
    DUK_ASSERT(thr->callstack_preventcount >= 1);  /* should never be zero, because we (Duktape.Thread.yield) are on the stack */
    if (thr->callstack_preventcount != 1) {
        /* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */
        DUK_DD(DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %ld)",
                           (long) thr->callstack_preventcount));
        goto state_error;
    }
 
    /*
     *  The error object has been augmented with a traceback and other
     *  info from its creation point -- usually the current thread.
     *  The error handler, however, is called right before throwing
     *  and runs in the yielder's thread.
     */
 
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
    if (is_error) {
        DUK_ASSERT_TOP(ctx, 1);  /* value (error) is at stack top */
        duk_err_augment_error_throw(thr);  /* in yielder's context */
    }
#endif
 
#ifdef DUK_USE_DEBUG
    if (is_error) {
        DUK_DDD(DUK_DDDPRINT("YIELD ERROR: value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0)));
    } else {
        DUK_DDD(DUK_DDDPRINT("YIELD NORMAL: value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0)));
    }
#endif
 
    /*
     *  Process yield
     *
     *  After longjmp(), processing continues in bytecode executor longjmp
     *  handler, which will e.g. update thr->resumer to NULL.
     */
 

◆ duk_bi_type_error_thrower()

DUK_INTERNAL_DECL duk_ret_t duk_bi_type_error_thrower ( duk_context * ctx )

Definition at line 35684 of file duktape-1.8.0/src/duktape.c.

            :
    DUK_ERROR_TYPE(thr, "invalid state");
    return 0;  /* never here */

◆ duk_bi_typedarray_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_constructor ( duk_context * ctx )

Definition at line 22470 of file duktape-1.8.0/src/duktape.c.

            :
    return DUK_RET_RANGE_ERROR;
}
#else  /* DUK_USE_BUFFEROBJECT_SUPPORT */
DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx) {
    DUK_UNREF(ctx);
    return DUK_RET_UNSUPPORTED_ERROR;
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
 
/* Format of magic, bits:
 *   0...1: elem size shift (0-3)
 *   2...5: elem type (DUK_HBUFFEROBJECT_ELEM_xxx)
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv;
    duk_hobject *h_obj;
    duk_hbufferobject *h_bufobj = NULL;
    duk_hbufferobject *h_bufarr = NULL;
    duk_hbufferobject *h_bufarg = NULL;
    duk_hbuffer *h_val;
    duk_small_uint_t magic;
    duk_small_uint_t shift;
    duk_small_uint_t elem_type;
    duk_small_uint_t elem_size;
    duk_small_uint_t class_num;
    duk_small_uint_t proto_bidx;
    duk_uint_t align_mask;
    duk_uint_t elem_length;
    duk_int_t elem_length_signed;
    duk_uint_t byte_length;
    duk_small_uint_t copy_mode;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /* XXX: function flag to make this automatic? */
    if (!duk_is_constructor_call(ctx)) {
        return DUK_RET_TYPE_ERROR;
    }
 
    /* We could fit built-in index into magic but that'd make the magic
     * number dependent on built-in numbering (genbuiltins.py doesn't
     * handle that yet).  So map both class and prototype from the
     * element type.
     */
    magic = duk_get_current_magic(ctx);
    shift = magic & 0x03;               /* bits 0...1: shift */
    elem_type = (magic >> 2) & 0x0f;    /* bits 2...5: type */
    elem_size = 1 << shift;
    align_mask = elem_size - 1;
    DUK_ASSERT(elem_type < sizeof(duk__buffer_proto_from_elemtype) / sizeof(duk_uint8_t));
    proto_bidx = duk__buffer_proto_from_elemtype[elem_type];
    DUK_ASSERT(proto_bidx < DUK_NUM_BUILTINS);
    DUK_ASSERT(elem_type < sizeof(duk__buffer_class_from_elemtype) / sizeof(duk_uint8_t));
    class_num = duk__buffer_class_from_elemtype[elem_type];
 
    DUK_DD(DUK_DDPRINT("typedarray constructor, magic=%d, shift=%d, elem_type=%d, "
                       "elem_size=%d, proto_bidx=%d, class_num=%d",
                       (int) magic, (int) shift, (int) elem_type, (int) elem_size,
                       (int) proto_bidx, (int) class_num));
 
    /* Argument variants.  When the argument is an ArrayBuffer a view to
     * the same buffer is created; otherwise a new ArrayBuffer is always
     * created.
     */
 
    tv = duk_get_tval(ctx, 0);
    DUK_ASSERT(tv != NULL);  /* arg count */
    if (DUK_TVAL_IS_OBJECT(tv)) {
        h_obj = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h_obj != NULL);
 
        if (DUK_HOBJECT_GET_CLASS_NUMBER(h_obj) == DUK_HOBJECT_CLASS_ARRAYBUFFER) {
            /* ArrayBuffer: unlike any other argument variant, create
             * a view into the existing buffer.
             */
 
            duk_int_t byte_offset_signed;
            duk_uint_t byte_offset;
 
            h_bufarg = (duk_hbufferobject *) h_obj;
 
            byte_offset_signed = duk_to_int(ctx, 1);
            if (byte_offset_signed < 0) {
                goto fail_arguments;
            }
            byte_offset = (duk_uint_t) byte_offset_signed;
            if (byte_offset > h_bufarg->length ||
                (byte_offset & align_mask) != 0) {
                /* Must be >= 0 and multiple of element size. */
                goto fail_arguments;
            }
            if (duk_is_undefined(ctx, 2)) {
                DUK_ASSERT(h_bufarg->length >= byte_offset);
                byte_length = h_bufarg->length - byte_offset;
                if ((byte_length & align_mask) != 0) {
                    /* Must be element size multiple from
                     * start offset to end of buffer.
                     */
                    goto fail_arguments;
                }
                elem_length = (byte_length >> shift);
            } else {
                elem_length_signed = duk_to_int(ctx, 2);
                if (elem_length_signed < 0) {
                    goto fail_arguments;
                }
                elem_length = (duk_uint_t) elem_length_signed;
                byte_length = elem_length << shift;
                if ((byte_length >> shift) != elem_length) {
                    /* Byte length would overflow. */
                    /* XXX: easier check with less code? */
                    goto fail_arguments;
                }
                DUK_ASSERT(h_bufarg->length >= byte_offset);
                if (byte_length > h_bufarg->length - byte_offset) {
                    /* Not enough data. */
                    goto fail_arguments;
                }
            }
            DUK_UNREF(elem_length);
            DUK_ASSERT_DISABLE(byte_offset >= 0);
            DUK_ASSERT(byte_offset <= h_bufarg->length);
            DUK_ASSERT_DISABLE(byte_length >= 0);
            DUK_ASSERT(byte_offset + byte_length <= h_bufarg->length);
            DUK_ASSERT((elem_length << shift) == byte_length);
 
            h_bufobj = duk_push_bufferobject_raw(ctx,
                                                 DUK_HOBJECT_FLAG_EXTENSIBLE |
                                                 DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                                 DUK_HOBJECT_CLASS_AS_FLAGS(class_num),
                                                 proto_bidx);
            h_val = h_bufarg->buf;
            if (h_val == NULL) {
                return DUK_RET_TYPE_ERROR;
            }
            h_bufobj->buf = h_val;
            DUK_HBUFFER_INCREF(thr, h_val);
            h_bufobj->offset = h_bufarg->offset + byte_offset;
            h_bufobj->length = byte_length;
            h_bufobj->shift = (duk_uint8_t) shift;
            h_bufobj->elem_type = (duk_uint8_t) elem_type;
            h_bufobj->is_view = 1;
            DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
            /* Set .buffer to the argument ArrayBuffer. */
            duk_dup(ctx, 0);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE);
            duk_compact(ctx, -1);
            return 1;
        } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
            /* TypedArray (or other non-ArrayBuffer duk_hbufferobject).
             * Conceptually same behavior as for an Array-like argument,
             * with a few fast paths.
             */
 
            h_bufarg = (duk_hbufferobject *) h_obj;
            DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg);
            elem_length_signed = (duk_int_t) (h_bufarg->length >> h_bufarg->shift);
            if (h_bufarg->buf == NULL) {
                return DUK_RET_TYPE_ERROR;
            }
 
            /* Select copy mode.  Must take into account element
             * compatibility and validity of the underlying source
             * buffer.
             */
 
            DUK_DDD(DUK_DDDPRINT("selecting copy mode for bufobj arg, "
                                 "src byte_length=%ld, src shift=%d, "
                                 "src/dst elem_length=%ld; "
                                 "dst shift=%d -> dst byte_length=%ld",
                                 (long) h_bufarg->length, (int) h_bufarg->shift,
                                 (long) elem_length_signed, (int) shift,
                                 (long) (elem_length_signed << shift)));
 
            copy_mode = 2;  /* default is explicit index read/write copy */
            DUK_ASSERT(elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t));
            if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) {
                if ((duk__buffer_elemtype_copy_compatible[elem_type] & (1 << h_bufarg->elem_type)) != 0) {
                    DUK_DDD(DUK_DDDPRINT("source/target are copy compatible, memcpy"));
                    DUK_ASSERT(shift == h_bufarg->shift);  /* byte sizes will match */
                    copy_mode = 0;
                } else {
                    DUK_DDD(DUK_DDDPRINT("source/target not copy compatible but valid, fast copy"));
                    copy_mode = 1;
                }
            }
        } else {
            /* Array or Array-like */
            elem_length_signed = (duk_int_t) duk_get_length(ctx, 0);
            copy_mode = 2;
        }
    } else if (DUK_TVAL_IS_BUFFER(tv)) {
        /* Accept plain buffer values like array initializers
         * (new in Duktape 1.4.0).
         */
        duk_hbuffer *h_srcbuf;
        h_srcbuf = DUK_TVAL_GET_BUFFER(tv);
        elem_length_signed = (duk_int_t) DUK_HBUFFER_GET_SIZE(h_srcbuf);
        copy_mode = 2;  /* XXX: could add fast path for u8 compatible views */
    } else {
        /* Non-object argument is simply int coerced, matches
         * V8 behavior (except for "null", which we coerce to
         * 0 but V8 TypeErrors).
         */
        elem_length_signed = duk_to_int(ctx, 0);
        copy_mode = 3;
    }
    if (elem_length_signed < 0) {
        goto fail_arguments;
    }
    elem_length = (duk_uint_t) elem_length_signed;
    byte_length = (duk_uint_t) (elem_length << shift);
    if ((byte_length >> shift) != elem_length) {
        /* Byte length would overflow. */
        /* XXX: easier check with less code? */
        goto fail_arguments;
    }
 
    DUK_DDD(DUK_DDDPRINT("elem_length=%ld, byte_length=%ld",
                         (long) elem_length, (long) byte_length));
 
    /* ArrayBuffer argument is handled specially above; the rest of the
     * argument variants are handled by shared code below.
     */
 
    /* Push a new ArrayBuffer (becomes view .buffer) */
    h_bufarr = duk__push_arraybuffer_with_length(ctx, byte_length);
    DUK_ASSERT(h_bufarr != NULL);
    h_val = h_bufarr->buf;
    DUK_ASSERT(h_val != NULL);
 
    /* Push the resulting view object and attach the ArrayBuffer. */
    h_bufobj = duk_push_bufferobject_raw(ctx,
                                         DUK_HOBJECT_FLAG_EXTENSIBLE |
                                         DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                         DUK_HOBJECT_CLASS_AS_FLAGS(class_num),
                                         proto_bidx);
 
    h_bufobj->buf = h_val;
    DUK_HBUFFER_INCREF(thr, h_val);
    DUK_ASSERT(h_bufobj->offset == 0);
    h_bufobj->length = byte_length;
    h_bufobj->shift = (duk_uint8_t) shift;
    h_bufobj->elem_type = (duk_uint8_t) elem_type;
    h_bufobj->is_view = 1;
    DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
    /* Set .buffer */
    duk_dup(ctx, -2);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE);
    duk_compact(ctx, -1);
 
    /* Copy values, the copy method depends on the arguments.
     *
     * Copy mode decision may depend on the validity of the underlying
     * buffer of the source argument; there must be no harmful side effects
     * from there to here for copy_mode to still be valid.
     */
    DUK_DDD(DUK_DDDPRINT("copy mode: %d", (int) copy_mode));
    switch (copy_mode) {
    case 0: {
        /* Use byte copy. */
 
        duk_uint8_t *p_src;
        duk_uint8_t *p_dst;
 
        DUK_ASSERT(h_bufobj != NULL);
        DUK_ASSERT(h_bufobj->buf != NULL);
        DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj));
        DUK_ASSERT(h_bufarg != NULL);
        DUK_ASSERT(h_bufarg->buf != NULL);
        DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg));
 
        p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj);
        p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg);
 
        DUK_DDD(DUK_DDDPRINT("using memcpy: p_src=%p, p_dst=%p, byte_length=%ld",
                             (void *) p_src, (void *) p_dst, (long) byte_length));
 
        DUK_MEMCPY((void *) p_dst, (const void *) p_src, (size_t) byte_length);
        break;
    }
    case 1: {
        /* Copy values through direct validated reads and writes. */
 
        duk_small_uint_t src_elem_size;
        duk_small_uint_t dst_elem_size;
        duk_uint8_t *p_src;
        duk_uint8_t *p_src_end;
        duk_uint8_t *p_dst;
 
        DUK_ASSERT(h_bufobj != NULL);
        DUK_ASSERT(h_bufobj->buf != NULL);
        DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj));
        DUK_ASSERT(h_bufarg != NULL);
        DUK_ASSERT(h_bufarg->buf != NULL);
        DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg));
 
        src_elem_size = 1 << h_bufarg->shift;
        dst_elem_size = elem_size;
 
        p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg);
        p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj);
        p_src_end = p_src + h_bufarg->length;
 
        DUK_DDD(DUK_DDDPRINT("using fast copy: p_src=%p, p_src_end=%p, p_dst=%p, "
                             "src_elem_size=%d, dst_elem_size=%d",
                             (void *) p_src, (void *) p_src_end, (void *) p_dst,
                             (int) src_elem_size, (int) dst_elem_size));
 
        while (p_src != p_src_end) {
            DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: "
                                 "p_src=%p, p_src_end=%p, p_dst=%p",
                                 (void *) p_src, (void *) p_src_end, (void *) p_dst));
            /* A validated read() is always a number, so it's write coercion
             * is always side effect free an won't invalidate pointers etc.
             */
            duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size);
            duk_hbufferobject_validated_write(ctx, h_bufobj, p_dst, dst_elem_size);
            duk_pop(ctx);
            p_src += src_elem_size;
            p_dst += dst_elem_size;
        }
        break;
    }
    case 2: {
        /* Copy values by index reads and writes.  Let virtual
         * property handling take care of coercion.
         */
        duk_uint_t i;
 
        DUK_DDD(DUK_DDDPRINT("using slow copy"));
 
        for (i = 0; i < elem_length; i++) {
            duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);
            duk_put_prop_index(ctx, -2, (duk_uarridx_t) i);
        }
        break;
    }
    default:
    case 3: {
        /* No copy, leave zero bytes in the buffer.  There's no
         * ambiguity with Float32/Float64 because zero bytes also
         * represent 0.0.
         */
#if !defined(DUK_USE_ZERO_BUFFER_DATA)

◆ duk_bi_typedarray_set()

DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_set ( duk_context * ctx )

Definition at line 23425 of file duktape-1.8.0/src/duktape.c.

                                                       :
 *
 *    - Source and target separate buffers or non-overlapping.
 *
 *    - Source and target have a compatible type so that a plain byte copy
 *      is possible.  Note that while e.g. uint8 and int8 are compatible
 *      (coercion one way or another doesn't change the byte representation),
 *      e.g. int8 and uint8clamped are NOT compatible when writing int8
 *      values into uint8clamped typedarray (-1 would clamp to 0 for instance).
 *
 *  See test-bi-typedarray-proto-set.js.
 */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL duk_ret_t duk_bi_typedarray_set(duk_context *ctx) {
    duk_hthread *thr;
    duk_hbufferobject *h_this;
    duk_hobject *h_obj;
    duk_uarridx_t i, n;
    duk_int_t offset_signed;
    duk_uint_t offset_elems;
    duk_uint_t offset_bytes;
 
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_this = duk__require_bufobj_this(ctx);
    DUK_ASSERT(h_this != NULL);
    DUK_ASSERT_HBUFFEROBJECT_VALID(h_this);
 
    if (h_this->buf == NULL) {
        DUK_DDD(DUK_DDDPRINT("source neutered, skip copy"));
        return 0;
    }
 
    h_obj = duk_require_hobject(ctx, 0);
    DUK_ASSERT(h_obj != NULL);
 
    /* XXX: V8 throws a TypeError for negative values.  Would it
     * be more useful to interpret negative offsets here from the
     * end of the buffer too?
     */
    offset_signed = duk_to_int(ctx, 1);
    if (offset_signed < 0) {
        return DUK_RET_TYPE_ERROR;
    }
    offset_elems = (duk_uint_t) offset_signed;
    offset_bytes = offset_elems << h_this->shift;
    if ((offset_bytes >> h_this->shift) != offset_elems) {
        /* Byte length would overflow. */
        /* XXX: easier check with less code? */
        return DUK_RET_RANGE_ERROR;
    }
    if (offset_bytes > h_this->length) {
        /* Equality may be OK but >length not.  Checking
         * this explicitly avoids some overflow cases
         * below.
         */
        return DUK_RET_RANGE_ERROR;
    }
    DUK_ASSERT(offset_bytes <= h_this->length);
 
    /* Fast path: source is a TypedArray (or any bufferobject). */
 
    if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
        duk_hbufferobject *h_bufarg;
        duk_uint16_t comp_mask;
        duk_small_int_t no_overlap = 0;
        duk_uint_t src_length;
        duk_uint_t dst_length;
        duk_uint_t dst_length_elems;
        duk_uint8_t *p_src_base;
        duk_uint8_t *p_src_end;
        duk_uint8_t *p_src;
        duk_uint8_t *p_dst_base;
        duk_uint8_t *p_dst;
        duk_small_uint_t src_elem_size;
        duk_small_uint_t dst_elem_size;
 
        h_bufarg = (duk_hbufferobject *) h_obj;
        DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg);
 
        if (h_bufarg->buf == NULL) {
            DUK_DDD(DUK_DDDPRINT("target neutered, skip copy"));
            return 0;
        }
 
        /* Nominal size check. */
        src_length = h_bufarg->length;  /* bytes in source */
        dst_length_elems = (src_length >> h_bufarg->shift);  /* elems in source and dest */
        dst_length = dst_length_elems << h_this->shift;  /* bytes in dest */
        if ((dst_length >> h_this->shift) != dst_length_elems) {
            /* Byte length would overflow. */
            /* XXX: easier check with less code? */
            return DUK_RET_RANGE_ERROR;
        }
        DUK_DDD(DUK_DDDPRINT("nominal size check: src_length=%ld, dst_length=%ld",
                             (long) src_length, (long) dst_length));
        DUK_ASSERT(offset_bytes <= h_this->length);
        if (dst_length > h_this->length - offset_bytes) {
            /* Overflow not an issue because subtraction is used on the right
             * side and guaranteed to be >= 0.
             */
            DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length"));
            return DUK_RET_RANGE_ERROR;
        }
        if (!DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, offset_bytes + dst_length)) {
            DUK_DDD(DUK_DDDPRINT("copy not covered by underlying target buffer, ignore"));
            return 0;
        }
 
        p_src_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg);
        p_dst_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + offset_bytes;
 
        /* Check actual underlying buffers for validity and that they
         * cover the copy.  No side effects are allowed after the check
         * so that the validity status doesn't change.
         */
        if (!DUK_HBUFFEROBJECT_VALID_SLICE(h_this) ||
            !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) {
            /* The condition could be more narrow and check for the
             * copy area only, but there's no need for fine grained
             * behavior when the underlying buffer is misconfigured.
             */
            DUK_DDD(DUK_DDDPRINT("source and/or target not covered by underlying buffer, skip copy"));
            return 0;
        }
 
        /* We want to do a straight memory copy if possible: this is
         * an important operation because .set() is the TypedArray
         * way to copy chunks of memory.  However, because set()
         * conceptually works in terms of elements, not all views are
         * compatible with direct byte copying.
         *
         * If we do manage a direct copy, the "overlap issue" handled
         * below can just be solved using memmove() because the source
         * and destination element sizes are necessarily equal.
         */
 
        DUK_ASSERT(h_this->elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t));
        comp_mask = duk__buffer_elemtype_copy_compatible[h_this->elem_type];
        if (comp_mask & (1 << h_bufarg->elem_type)) {
            DUK_ASSERT(src_length == dst_length);
 
            DUK_DDD(DUK_DDDPRINT("fast path: able to use memmove() because views are compatible"));
            DUK_MEMMOVE((void *) p_dst_base, (const void *) p_src_base, (size_t) dst_length);
            return 0;
        }
        DUK_DDD(DUK_DDDPRINT("fast path: views are not compatible with a byte copy, copy by item"));
 
        /* We want to avoid making a copy to process set() but that's
         * not always possible: the source and the target may overlap
         * and because element sizes are different, the overlap cannot
         * always be handled with a memmove() or choosing the copy
         * direction in a certain way.  For example, if source type is
         * uint8 and target type is uint32, the target area may exceed
         * the source area from both ends!
         *
         * Note that because external buffers may point to the same
         * memory areas, we must ultimately make this check using
         * pointers.
         *
         * NOTE: careful with side effects: any side effect may cause
         * a buffer resize (or external buffer pointer/length update)!
         */
 
        DUK_DDD(DUK_DDDPRINT("overlap check: p_src_base=%p, src_length=%ld, "
                             "p_dst_base=%p, dst_length=%ld",
                             (void *) p_src_base, (long) src_length,
                             (void *) p_dst_base, (long) dst_length));
 
        if (p_src_base >= p_dst_base + dst_length ||  /* source starts after dest ends */
            p_src_base + src_length <= p_dst_base) {   /* source ends before dest starts */
            no_overlap = 1;
        }
 
        if (!no_overlap) {
            /* There's overlap: the desired end result is that
             * conceptually a copy is made to avoid "trampling"
             * of source data by destination writes.  We make
             * an actual temporary copy to handle this case.
             */
            duk_uint8_t *p_src_copy;
 
            DUK_DDD(DUK_DDDPRINT("there is overlap, make a copy of the source"));
            p_src_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, src_length);
            DUK_ASSERT(p_src_copy != NULL);
            DUK_MEMCPY((void *) p_src_copy, (const void *) p_src_base, (size_t) src_length);
 
            p_src_base = p_src_copy;  /* use p_src_base from now on */
        }
        /* Value stack intentionally mixed size here. */
 
        DUK_DDD(DUK_DDDPRINT("after overlap check: p_src_base=%p, src_length=%ld, "
                             "p_dst_base=%p, dst_length=%ld, valstack top=%ld",
                             (void *) p_src_base, (long) src_length,
                             (void *) p_dst_base, (long) dst_length,
                             (long) duk_get_top(ctx)));
 
        /* Ready to make the copy.  We must proceed element by element
         * and must avoid any side effects that might cause the buffer
         * validity check above to become invalid.
         *
         * Although we work through the value stack here, only plain
         * numbers are handled which should be side effect safe.
         */
 
        src_elem_size = 1 << h_bufarg->shift;
        dst_elem_size = 1 << h_this->shift;
        p_src = p_src_base;
        p_dst = p_dst_base;
        p_src_end = p_src_base + src_length;
 
        while (p_src != p_src_end) {
            DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: "
                                 "p_src=%p, p_src_end=%p, p_dst=%p",
                                 (void *) p_src, (void *) p_src_end, (void *) p_dst));
            /* A validated read() is always a number, so it's write coercion
             * is always side effect free an won't invalidate pointers etc.
             */
            duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size);
            duk_hbufferobject_validated_write(ctx, h_this, p_dst, dst_elem_size);
            duk_pop(ctx);
            p_src += src_elem_size;
            p_dst += dst_elem_size;
        }
 
        return 0;
    } else {
        /* Slow path: quite slow, but we save space by using the property code
         * to write coerce target values.  We don't need to worry about overlap
         * here because the source is not a TypedArray.
         *
         * We could use the bufferobject write coercion helper but since the
         * property read may have arbitrary side effects, full validity checks
         * would be needed for every element anyway.
         */
 
        n = (duk_uarridx_t) duk_get_length(ctx, 0);
        DUK_ASSERT(offset_bytes <= h_this->length);
        if ((n << h_this->shift) > h_this->length - offset_bytes) {
            /* Overflow not an issue because subtraction is used on the right
             * side and guaranteed to be >= 0.
             */
            DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length"));
            return DUK_RET_RANGE_ERROR;
        }
 
        /* There's no need to check for buffer validity status for the

References duk_hbufferobject::buf, duk__buffer_elemtype_copy_compatible, duk__require_bufobj_this(), DUK_ASSERT, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_ASSERT_TOP, DUK_DDD, DUK_DDDPRINT, duk_get_length(), duk_get_prop_index(), duk_get_top(), DUK_HBUFFEROBJECT_GET_SLICE_BASE, duk_hbufferobject_push_validated_read(), DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL, DUK_HBUFFEROBJECT_VALID_SLICE, duk_hbufferobject_validated_write(), DUK_HOBJECT_IS_BUFFEROBJECT, DUK_MEMCPY, DUK_MEMMOVE, duk_pop(), duk_push_fixed_buffer, duk_push_this(), duk_put_prop_index(), duk_require_hobject(), DUK_RET_RANGE_ERROR, DUK_RET_TYPE_ERROR, duk_to_int(), DUK_UNREF, duk_hbufferobject::elem_type, duk_hthread::heap, duk_hbufferobject::length, NULL, and duk_hbufferobject::shift.

◆ duk_bw_compact()

DUK_INTERNAL_DECL void duk_bw_compact	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx )

Definition at line 86572 of file duktape-1.8.0/src/duktape.c.

◆ duk_bw_init()

DUK_INTERNAL_DECL void duk_bw_init	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx,
		duk_hbuffer_dynamic *	h_buf )

Definition at line 86508 of file duktape-1.8.0/src/duktape.c.

                                                                                                                               {
    duk_uint8_t *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw_ctx != NULL);
    DUK_UNREF(thr);
 

References duk_bufwriter_ctx::buf, DUK_ASSERT, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR, DUK_UNREF, duk_hthread::heap, and NULL.

◆ duk_bw_init_pushbuf()

DUK_INTERNAL_DECL void duk_bw_init_pushbuf	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx,
		duk_size_t	buf_size )

Definition at line 86519 of file duktape-1.8.0/src/duktape.c.

                                                                                                       {
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw_ctx != NULL);
    DUK_ASSERT(h_buf != NULL);

◆ duk_bw_insert_ensure_area()

DUK_INTERNAL_DECL duk_uint8_t * duk_bw_insert_ensure_area	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	off,
		duk_size_t	len )

Definition at line 86719 of file duktape-1.8.0/src/duktape.c.

◆ duk_bw_insert_ensure_bytes()

DUK_INTERNAL_DECL void duk_bw_insert_ensure_bytes	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	dst_off,
		const duk_uint8_t *	buf,
		duk_size_t	len )

Definition at line 86637 of file duktape-1.8.0/src/duktape.c.

◆ duk_bw_insert_ensure_slice()

DUK_INTERNAL_DECL void duk_bw_insert_ensure_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	dst_off,
		duk_size_t	src_off,
		duk_size_t	len )

Definition at line 86685 of file duktape-1.8.0/src/duktape.c.

◆ duk_bw_insert_raw_area()

DUK_INTERNAL_DECL duk_uint8_t * duk_bw_insert_raw_area	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	off,
		duk_size_t	len )

Definition at line 86701 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                              {
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);
    DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_UNREF(thr);
 
    /* Don't support "straddled" source now. */
    DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);
 
    DUK_BW_ENSURE(thr, bw, len);
    duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len);
}
 

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_insert_raw_slice(), DUK_UNREF, and NULL.

◆ duk_bw_insert_raw_bytes()

DUK_INTERNAL_DECL void duk_bw_insert_raw_bytes	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	dst_off,
		const duk_uint8_t *	buf,
		duk_size_t	len )

Definition at line 86613 of file duktape-1.8.0/src/duktape.c.

                                                                                                                         {
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);
    DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_UNREF(thr);
 
    DUK_BW_ENSURE(thr, bw, len);
    duk_bw_write_raw_slice(thr, bw, src_off, len);
}
 
DUK_INTERNAL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) {
    duk_uint8_t *p_base;
    duk_size_t buf_sz, move_sz;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);

◆ duk_bw_insert_raw_slice()

DUK_INTERNAL_DECL void duk_bw_insert_raw_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	dst_off,
		duk_size_t	src_off,
		duk_size_t	len )

Definition at line 86648 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                  {
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);
    DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(buf != NULL);
    DUK_UNREF(thr);
 
    DUK_BW_ENSURE(thr, bw, len);
    duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len);
}
 
DUK_INTERNAL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) {
    duk_uint8_t *p_base;
    duk_size_t buf_sz, move_sz;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);
    DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_UNREF(thr);
 
    p_base = bw->p_base;
 
    /* Don't support "straddled" source now. */
    DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);
 
    if (dst_off <= src_off) {
        /* Target is before source.  Source offset is expressed as

Referenced by duk_bw_insert_raw_area().

◆ duk_bw_remove_raw_slice()

DUK_INTERNAL_DECL void duk_bw_remove_raw_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	off,
		duk_size_t	len )

Definition at line 86729 of file duktape-1.8.0/src/duktape.c.

                                                                                                                             {
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);
    DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_UNREF(thr);
 
    DUK_BW_ENSURE(thr, bw, len);
    return duk_bw_insert_raw_area(thr, bw, off, len);
}
 
DUK_INTERNAL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
    duk_size_t move_sz;
 
    duk_uint8_t *p_base;
    duk_uint8_t *p_src;
    duk_uint8_t *p_dst;

◆ duk_bw_resize()

DUK_INTERNAL_DECL duk_uint8_t * duk_bw_resize	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx,
		duk_size_t	sz )

Definition at line 86534 of file duktape-1.8.0/src/duktape.c.

                                                                                                        {
    duk_context *ctx;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw_ctx != NULL);
    ctx = (duk_context *) thr;
 
    (void) duk_push_dynamic_buffer(ctx, buf_size);
    bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
    duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size);
}
 
/* Resize target buffer for requested size.  Called by the macro only when the
 * fast path test (= there is space) fails.
 */
DUK_INTERNAL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) {
    duk_size_t curr_off;
    duk_size_t add_sz;
    duk_size_t new_sz;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw_ctx != NULL);
 
    /* We could do this operation without caller updating bw_ctx->ptr,
     * but by writing it back here we can share code better.
     */
 
    curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
    add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD;
    new_sz = curr_off + sz + add_sz;
    if (new_sz < curr_off) {
        /* overflow */
        DUK_ERROR_RANGE(thr, DUK_STR_BUFFER_TOO_LONG);
        return NULL;  /* not reachable */

◆ duk_bw_write_ensure_slice()

DUK_INTERNAL_DECL void duk_bw_write_ensure_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	src_off,
		duk_size_t	len )

Definition at line 86601 of file duktape-1.8.0/src/duktape.c.

                                                                                                                      {
    duk_uint8_t *p_base;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw != NULL);
    DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
    DUK_UNREF(thr);
 
    p_base = bw->p_base;

References DUK_ASSERT, DUK_BW_GET_SIZE, DUK_MEMCPY, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

◆ duk_bw_write_raw_slice()

DUK_INTERNAL_DECL void duk_bw_write_raw_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	src_off,
		duk_size_t	len )

Definition at line 86584 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_size_t len;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(bw_ctx != NULL);
    DUK_UNREF(thr);
 
    len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
    duk_hbuffer_resize(thr, bw_ctx->buf, len);
    duk__bw_update_ptrs(thr, bw_ctx, len, len);
}

◆ duk_call()

DUK_EXTERNAL void duk_call	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12414 of file duktape-1.8.0/src/duktape.c.

                              : %!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    /* [... key arg1 ... argN func] */
 
    duk_replace(ctx, -nargs - 2);
 
    /* [... func arg1 ... argN] */
 
    duk_dup(ctx, normalized_obj_index);
    duk_insert(ctx, -nargs - 1);
 
    /* [... func this arg1 ... argN] */
}
 
DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;
    duk_idx_t idx_func;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    idx_func = duk_get_top(ctx) - nargs - 1;

◆ duk_call_method()

DUK_EXTERNAL void duk_call_method	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12441 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;

Referenced by duk_bi_object_prototype_is_prototype_of(), duk_hobject_putprop(), and duk_to_defaultvalue().

◆ duk_call_prop()

DUK_EXTERNAL void duk_call_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_idx_t	nargs )

Definition at line 12462 of file duktape-1.8.0/src/duktape.c.

                                   {
        /* note that we can't reliably pop anything here */
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    }
 
    call_flags = 0;  /* not protected, respect reclimit, not constructor */
 
    duk_handle_call_unprotected(thr,           /* thread */
                                nargs,         /* num_stack_args */
                                call_flags);   /* call_flags */
}
 
DUK_EXTERNAL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs) {
    /*

◆ duk_char_code_at()

DUK_EXTERNAL duk_codepoint_t duk_char_code_at	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	char_offset )

Definition at line 20106 of file duktape-1.8.0/src/duktape.c.

                              : p_start=%p, p_end=%p, q_start=%p, q_end=%p",
                         (const void *) p_start, (const void *) p_end,
                         (const void *) q_start, (const void *) q_end));
 
    if (q_start == p_start && q_end == p_end) {
        DUK_DDD(DUK_DDDPRINT("nothing was trimmed: avoid interning (hashing etc)"));
        return;
    }
 
    duk_push_lstring(ctx, (const char *) q_start, (duk_size_t) (q_end - q_start));
    duk_replace(ctx, index);
}
 
DUK_EXTERNAL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset) {
    duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_check_stack()

DUK_EXTERNAL duk_bool_t duk_check_stack	(	duk_context *	ctx,
		duk_idx_t	extra )

Definition at line 15721 of file duktape-1.8.0/src/duktape.c.

                        {
            DUK_ERROR_ALLOC_DEFMSG(thr);
        } else {
            return 0;
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("valstack resize successful"));
    return 1;
}
 
DUK_EXTERNAL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t min_new_size;
 

Referenced by duk__realloc_props().

◆ duk_check_stack_top()

DUK_EXTERNAL duk_bool_t duk_check_stack_top	(	duk_context *	ctx,
		duk_idx_t	top )

Definition at line 15765 of file duktape-1.8.0/src/duktape.c.

                                 {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        extra = 0;
    }
 
    min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
    (void) duk_valstack_resize_raw(ctx,
                                   min_new_size,  /* min_new_size */
                                   0 /* no shrink */ |   /* flags */
                                   0 /* no compact */ |
                                   DUK_VSRESIZE_FLAG_THROW);
}
 
DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top) {
    duk_hthread *thr;
    duk_size_t min_new_size;
 

◆ duk_check_type()

DUK_EXTERNAL duk_bool_t duk_check_type	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	type )

Definition at line 17676 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ duk_check_type_mask()

DUK_EXTERNAL duk_bool_t duk_check_type_mask	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_uint_t	mask )

Definition at line 17720 of file duktape-1.8.0/src/duktape.c.

                        :
        return DUK_TYPE_MASK_POINTER;
    case DUK_TAG_LIGHTFUNC:
        return DUK_TYPE_MASK_LIGHTFUNC;
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default:
        /* Note: number has no explicit tag (in 8-byte representation) */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        return DUK_TYPE_MASK_NUMBER;
    }

Referenced by duk_to_boolean().

◆ duk_compact()

DUK_EXTERNAL void duk_compact	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14834 of file duktape-1.8.0/src/duktape.c.

                  :
    DUK_ERROR_TYPE(thr, DUK_STR_INVALID_DESCRIPTOR);
    return;
 
 fail_not_callable:
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_CALLABLE);
    return;
}
 
/*
 *  Object related

Referenced by duk_bi_error_constructor_shared().

◆ duk_compile_raw()

DUK_EXTERNAL duk_int_t duk_compile_raw	(	duk_context *	ctx,
		const char *	src_buffer,
		duk_size_t	src_length,
		duk_uint_t	flags )

Definition at line 13733 of file duktape-1.8.0/src/duktape.c.

                                                                                                                          {
    duk__compile_raw_args comp_args_alloc;
    duk__compile_raw_args *comp_args = &comp_args_alloc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) {
        /* String length is computed here to avoid multiple evaluation
         * of a macro argument in the calling side.
         */
        src_length = DUK_STRLEN(src_buffer);
    }
 
    comp_args->src_buffer = (const duk_uint8_t *) src_buffer;
    comp_args->src_length = src_length;
    comp_args->flags = flags;
    duk_push_pointer(ctx, (void *) comp_args);
 
    /* [ ... source? filename? &comp_args ] (depends on flags) */
 
    if (flags & DUK_COMPILE_SAFE) {
        duk_int_t rc;
        duk_int_t nargs;
        duk_int_t nrets = 1;
 
        /* Arguments can be: [ source? filename? &comp_args] so that
         * nargs is 1 to 3.  Call site encodes the correct nargs count

◆ duk_concat()

DUK_EXTERNAL void duk_concat	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 19902 of file duktape-1.8.0/src/duktape.c.

           {
        duk_replace(ctx, -((duk_idx_t) count) - 1);  /* overwrite str1 */
        duk_pop_n(ctx, count-1);
    }

Referenced by duk_bi_string_prototype_locale_compare(), and duk_push_string_funcptr().

◆ duk_config_buffer()

DUK_EXTERNAL void duk_config_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		void *	ptr,
		duk_size_t	len )

Definition at line 11631 of file duktape-1.8.0/src/duktape.c.

                  {
        *out_size = sz;
    }
    DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(thr->heap, h);
    DUK_HBUFFER_DYNAMIC_SET_SIZE(h, 0);
 
    return ptr;
}
 

◆ duk_copy()

DUK_EXTERNAL void duk_copy	(	duk_context *	ctx,
		duk_idx_t	from_index,
		duk_idx_t	to_index )

Definition at line 15938 of file duktape-1.8.0/src/duktape.c.

◆ duk_create_activation_environment_record()

DUK_INTERNAL_DECL duk_hobject * duk_create_activation_environment_record	(	duk_hthread *	thr,
		duk_hobject *	func,
		duk_size_t	idx_bottom )

Definition at line 71971 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *env;
    duk_hobject *parent;
    duk_tval *tv;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(func != NULL);
 
    tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr));
    if (tv) {
        DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
        DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv)));
        parent = DUK_TVAL_GET_OBJECT(tv);
    } else {
        parent = thr->builtins[DUK_BIDX_GLOBAL_ENV];
    }
 
    (void) duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
                                  -1);  /* no prototype, updated below */

Referenced by duk_handle_ecma_call_setup().

◆ duk_create_heap()

DUK_EXTERNAL duk_context * duk_create_heap	(	duk_alloc_function	alloc_func,
		duk_realloc_function	realloc_func,
		duk_free_function	free_func,
		void *	heap_udata,
		duk_fatal_function	fatal_handler )

Definition at line 14058 of file duktape-1.8.0/src/duktape.c.

                                 {
    duk_ljstate lj;
    duk_bool_t handling_error;
    duk_hthread *curr_thread;
    duk_int_t call_recursion_depth;
};
 
DUK_EXTERNAL
duk_context *duk_create_heap(duk_alloc_function alloc_func,
                             duk_realloc_function realloc_func,
                             duk_free_function free_func,
                             void *heap_udata,
                             duk_fatal_function fatal_handler) {
    duk_heap *heap = NULL;
    duk_context *ctx;
 
    /* Assume that either all memory funcs are NULL or non-NULL, mixed
     * cases will now be unsafe.
     */
 
    /* XXX: just assert non-NULL values here and make caller arguments
     * do the defaulting to the default implementations (smaller code)?
     */
 
    if (!alloc_func) {
        DUK_ASSERT(realloc_func == NULL);
        DUK_ASSERT(free_func == NULL);
#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS)
        alloc_func = duk_default_alloc_function;
        realloc_func = duk_default_realloc_function;
        free_func = duk_default_free_function;
#else
        DUK_D(DUK_DPRINT("no allocation functions given and no default providers"));
        return NULL;
#endif
    } else {
        DUK_ASSERT(realloc_func != NULL);
        DUK_ASSERT(free_func != NULL);
    }
 
    if (!fatal_handler) {

◆ duk_debugger_attach_custom()

DUK_EXTERNAL void duk_debugger_attach_custom	(	duk_context *	ctx,
		duk_debug_read_function	read_cb,
		duk_debug_write_function	write_cb,
		duk_debug_peek_function	peek_cb,
		duk_debug_read_flush_function	read_flush_cb,
		duk_debug_write_flush_function	write_flush_cb,
		duk_debug_request_function	request_cb,
		duk_debug_detached_function	detached_cb,
		void *	udata )

Definition at line 13986 of file duktape-1.8.0/src/duktape.c.

                                                  {
        DUK_HEAP_SET_PAUSED(thr->heap);
 
        /* Pause on the next opcode executed.  This is always safe to do even
         * inside the debugger message loop: the interrupt counter will be reset
         * to its proper value when the message loop exits.
         */
        thr->interrupt_init = 1;
        thr->interrupt_counter = 0;
    }
}
 
#else  /* DUK_USE_DEBUGGER_SUPPORT */
 
DUK_EXTERNAL void duk_debugger_attach_custom(duk_context *ctx,
                                             duk_debug_read_function read_cb,
                                             duk_debug_write_function write_cb,

◆ duk_debugger_cooperate()

DUK_EXTERNAL void duk_debugger_cooperate ( duk_context * ctx )

Definition at line 14012 of file duktape-1.8.0/src/duktape.c.

◆ duk_debugger_detach()

DUK_EXTERNAL void duk_debugger_detach ( duk_context * ctx )

Definition at line 14007 of file duktape-1.8.0/src/duktape.c.

◆ duk_debugger_notify()

DUK_EXTERNAL duk_bool_t duk_debugger_notify	(	duk_context *	ctx,
		duk_idx_t	nvalues )

Definition at line 14018 of file duktape-1.8.0/src/duktape.c.

                                                        {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ERROR_API((duk_hthread *) ctx, "no debugger support");
}
 
DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) {
    /* nop */
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(ctx);

◆ duk_debugger_pause()

DUK_EXTERNAL void duk_debugger_pause ( duk_context * ctx )

Definition at line 14034 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_idx_t top;
 
    DUK_ASSERT_CTX_VALID(ctx);

References DUK_ASSERT_CTX_VALID, DUK_ERROR_API, duk_get_top(), and duk_pop_n().

◆ duk_decode_string()

DUK_EXTERNAL void duk_decode_string	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_decode_char_function	callback,
		void *	udata )

Definition at line 19918 of file duktape-1.8.0/src/duktape.c.

                                                                {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__concat_and_join_helper(ctx, count, 0 /*is_join*/);
}
 
DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__concat_and_join_helper(ctx, count, 1 /*is_join*/);
}
 
/* XXX: could map/decode be unified with duk_unicode_support.c code?
 * Case conversion needs also the character surroundings though.
 */
 
DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_input;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_codepoint_t cp;
 

References duk__concat_and_join_helper(), and DUK_ASSERT_CTX_VALID.

◆ duk_def_prop()

DUK_EXTERNAL void duk_def_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uint_t	flags )

Definition at line 14742 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj = duk_require_hobject(ctx, obj_index);
    duk_hobject *thrower = thr->builtins[DUK_BIDX_TYPE_ERROR_THROWER];
    duk_hobject_define_accessor_internal(thr, obj, DUK_HTHREAD_GET_STRING(thr, stridx), thrower, thrower, desc_flags);
}
 
/* Object.defineProperty() equivalent C binding. */
DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t idx_base;
    duk_hobject *obj;
    duk_hstring *key;
    duk_idx_t idx_value;
    duk_hobject *get;
    duk_hobject *set;
    duk_uint_t is_data_desc;
    duk_uint_t is_acc_desc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_require_hobject(ctx, obj_index);
 
    is_data_desc = flags & (DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
    is_acc_desc = flags & (DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
    if (is_data_desc && is_acc_desc) {
        /* "Have" flags must not be conflicting so that they would
         * apply to both a plain property and an accessor at the same
         * time.
         */
        goto fail_invalid_desc;
    }
 
    idx_base = duk_get_top_index(ctx);
    if (flags & DUK_DEFPROP_HAVE_SETTER) {
        duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED |
                                             DUK_TYPE_MASK_OBJECT |
                                             DUK_TYPE_MASK_LIGHTFUNC);
        set = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
        if (set != NULL && !DUK_HOBJECT_IS_CALLABLE(set)) {
            goto fail_not_callable;
        }
        idx_base--;
    } else {
        set = NULL;
    }
    if (flags & DUK_DEFPROP_HAVE_GETTER) {
        duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED |
                                             DUK_TYPE_MASK_OBJECT |
                                             DUK_TYPE_MASK_LIGHTFUNC);
        get = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
        if (get != NULL && !DUK_HOBJECT_IS_CALLABLE(get)) {
            goto fail_not_callable;
        }
        idx_base--;
    } else {
        get = NULL;
    }
    if (flags & DUK_DEFPROP_HAVE_VALUE) {
        idx_value = idx_base;
        idx_base--;
    } else {
        idx_value = (duk_idx_t) -1;
    }
    key = duk_require_hstring(ctx, idx_base);
 
    duk_require_valid_index(ctx, idx_base);
 
    duk_hobject_define_property_helper(ctx,
                                       flags /*defprop_flags*/,
                                       obj,
                                       key,
                                       idx_value,
                                       get,
                                       set);

◆ duk_default_alloc_function()

DUK_INTERNAL_DECL void * duk_default_alloc_function	(	void *	udata,
		duk_size_t	size )

Definition at line 11550 of file duktape-1.8.0/src/duktape.c.

◆ duk_default_fatal_handler()

DUK_INTERNAL void duk_default_fatal_handler	(	duk_context *	ctx,
		duk_errcode_t	code,
		const char *	msg )

Definition at line 9876 of file duktape-1.8.0/src/duktape.c.

                                                        {
    DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_UNSUPPORTED_ERROR, NULL);
}
DUK_INTERNAL void duk_err_internal(duk_hthread *thr) {
    DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_INTERNAL_ERROR, NULL);
}
DUK_INTERNAL void duk_err_alloc(duk_hthread *thr) {
    DUK_ERROR_RAW(thr, NULL, thr, DUK_ERR_ALLOC_ERROR, NULL);
}
#endif

◆ duk_default_free_function()

DUK_INTERNAL_DECL void duk_default_free_function	(	void *	udata,
		void *	ptr )

Definition at line 11568 of file duktape-1.8.0/src/duktape.c.

11571 : %lu -> %p",

11572 (unsigned long) size, (void *) res));

◆ duk_default_panic_handler()

DUK_INTERNAL void duk_default_panic_handler	(	duk_errcode_t	code,
		const char *	msg )

Definition at line 9894 of file duktape-1.8.0/src/duktape.c.

                                      : %s\n", (long) code, (const char *) (msg ? msg : "null"));
    DUK_FFLUSH(DUK_STDERR);
#else
    /* omit print */
#endif
    DUK_D(DUK_DPRINT("default fatal handler called, code %ld -> calling DUK_PANIC()", (long) code));
    DUK_PANIC(code, msg);
    DUK_UNREACHABLE();
}
 
/*
 *  Default panic handler
 */
 
#if !defined(DUK_USE_PANIC_HANDLER)
DUK_INTERNAL void duk_default_panic_handler(duk_errcode_t code, const char *msg) {
#if defined(DUK_USE_FILE_IO)
    DUK_FPRINTF(DUK_STDERR, "PANIC %ld: %s ("
#if defined(DUK_USE_PANIC_ABORT)
                "calling abort"
#elif defined(DUK_USE_PANIC_EXIT)
                "calling exit"
#elif defined(DUK_USE_PANIC_SEGFAULT)
                "segfaulting on purpose"
#else
#error no DUK_USE_PANIC_xxx macro defined
#endif
                ")\n", (long) code, (const char *) (msg ? msg : "null"));
    DUK_FFLUSH(DUK_STDERR);
#else
    /* omit print */
    DUK_UNREF(code);

◆ duk_default_realloc_function()

DUK_INTERNAL_DECL void * duk_default_realloc_function	(	void *	udata,
		void *	ptr,
		duk_size_t	newsize )

Definition at line 11559 of file duktape-1.8.0/src/duktape.c.

◆ duk_del_prop()

DUK_EXTERNAL duk_bool_t duk_del_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14547 of file duktape-1.8.0/src/duktape.c.

                                                                                                         {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(stridx >= 0);
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    DUK_UNREF(thr);
 
    obj_idx = duk_require_normalize_index(ctx, obj_idx);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
    return duk__put_prop_shared(ctx, obj_idx, -1);
}
 
DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;
    duk_small_int_t throw_flag;
    duk_bool_t rc;

Referenced by duk_del_prop_stridx().

◆ duk_del_prop_index()

DUK_EXTERNAL duk_bool_t duk_del_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14580 of file duktape-1.8.0/src/duktape.c.

◆ duk_del_prop_stridx()

DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx )

Definition at line 14588 of file duktape-1.8.0/src/duktape.c.

                                                                                                    {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(key != NULL);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    duk_push_string(ctx, key);
    return duk_del_prop(ctx, obj_index);
}
 
DUK_EXTERNAL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
    DUK_ASSERT_CTX_VALID(ctx);
 

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_del_prop(), duk_push_string(), duk_require_normalize_index(), and NULL.

◆ duk_del_prop_string()

DUK_EXTERNAL duk_bool_t duk_del_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14571 of file duktape-1.8.0/src/duktape.c.

◆ duk_del_var()

DUK_EXTERNAL duk_bool_t duk_del_var ( duk_context * ctx )

Definition at line 20199 of file duktape-1.8.0/src/duktape.c.

             {
        duk_js_putvar_activation(thr, act, h_varname, tv_val, throw_flag);  /* -> [ ... varname val this ] */
    } else {
        /* Outside any activation -> put to global. */
        DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL);
        duk_js_putvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, tv_val, throw_flag);

References duk_js_putvar_activation().

◆ duk_destroy_heap()

DUK_EXTERNAL void duk_destroy_heap ( duk_context * ctx )

Definition at line 14109 of file duktape-1.8.0/src/duktape.c.

               {
        return NULL;
    }
    ctx = (duk_context *) heap->heap_thread;

◆ duk_dump_function()

DUK_EXTERNAL void duk_dump_function ( duk_context * ctx )

Definition at line 12285 of file duktape-1.8.0/src/duktape.c.

                                             : %!iT", duk_get_tval(ctx, -1)));
    DUK_ASSERT_TOP(ctx, idx_base + 1);
    return p;
 
 format_error:
    return NULL;
}
 
DUK_EXTERNAL void duk_dump_function(duk_context *ctx) {
    duk_hthread *thr;
    duk_hcompiledfunction *func;
    duk_bufwriter_ctx bw_ctx_alloc;
    duk_bufwriter_ctx *bw_ctx = &bw_ctx_alloc;
    duk_uint8_t *p;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
 
    /* Bound functions don't have all properties so we'd either need to
     * lookup the non-bound target function or reject bound functions.
     * For now, bound functions are rejected.
     */
    func = duk_require_hcompiledfunction(ctx, -1);
    DUK_ASSERT(func != NULL);

◆ duk_dup()

DUK_EXTERNAL void duk_dup	(	duk_context *	ctx,
		duk_idx_t	from_index )

Definition at line 15837 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_swap(ctx, index, -1);
}

Referenced by duk__ispec_toregconst_raw(), duk_bi_array_constructor_is_array(), duk_bi_logger_prototype_fmt(), duk_bi_object_prototype_is_prototype_of(), duk_bi_string_constructor_from_char_code(), duk_hobject_define_property_helper(), duk_hobject_putprop(), duk_lexer_parse_js_input_element(), and duk_to_defaultvalue().

◆ duk_dup_top()

DUK_EXTERNAL void duk_dup_top ( duk_context * ctx )

Definition at line 15854 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    duk_hthread *thr;
    duk_tval *tv_from;
    duk_tval *tv_to;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
 
    tv_from = duk_require_tval(ctx, from_index);
    tv_to = thr->valstack_top++;
    DUK_ASSERT(tv_from != NULL);
    DUK_ASSERT(tv_to != NULL);
    DUK_TVAL_SET_TVAL(tv_to, tv_from);
    DUK_TVAL_INCREF(thr, tv_to);  /* no side effects */
}
 
DUK_EXTERNAL void duk_dup_top(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv_from;

References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_INCREF, DUK_TVAL_SET_TVAL, NULL, and duk_hthread::valstack_top.

Referenced by duk__format_parts_iso8601(), duk__init_varmap_and_prologue_for_pass2(), and duk__parse_var_decl().

◆ duk_enum()

DUK_EXTERNAL void duk_enum	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uint_t	enum_flags )

Definition at line 14849 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);

References DUK_ASSERT_CTX_VALID.

◆ duk_equals()

DUK_EXTERNAL duk_bool_t duk_equals	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 19543 of file duktape-1.8.0/src/duktape.c.

◆ duk_err_alloc()

DUK_INTERNAL void duk_err_alloc	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber,
		const char *	message )

Definition at line 9839 of file duktape-1.8.0/src/duktape.c.

                                                                                                                 {
    DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_API_ERROR, message);
}

References DUK_ERR_API_ERROR, and DUK_ERROR_RAW.

◆ duk_err_api()

DUK_INTERNAL void duk_err_api	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber,
		const char *	message )

Definition at line 9822 of file duktape-1.8.0/src/duktape.c.

9823 {

9824 DUK_ERROR_RAW_FMT3(thr, filename, linenumber, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)",

DUK_ERROR_RAW_FMT3

#define DUK_ERROR_RAW_FMT3(thr, file, line, err, fmt, arg1, arg2, arg3)

Definition duktape-1.8.0/src/duktape.c:7687

References DUK_ERR_TYPE_ERROR, and DUK_ERROR_RAW_FMT3.

◆ duk_err_api_index()

DUK_INTERNAL void duk_err_api_index	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber,
		duk_idx_t	index )

Definition at line 9819 of file duktape-1.8.0/src/duktape.c.

◆ duk_err_augment_error_create()

DUK_INTERNAL_DECL void duk_err_augment_error_create	(	duk_hthread *	thr,
		duk_hthread *	thr_callstack,
		const char *	filename,
		duk_int_t	line,
		duk_bool_t	noblame_fileline )

Definition at line 40347 of file duktape-1.8.0/src/duktape.c.

       : thread containing the error value
 *  thr_callstack: thread which should be used for generating callstack etc.
 *  c_filename: C __FILE__ related to the error
 *  c_line: C __LINE__ related to the error
 *  noblame_fileline: if true, don't fileName/line as error source, otherwise use traceback
 *                    (needed because user code filename/line are reported but internal ones
 *                    are not)
 *
 *  XXX: rename noblame_fileline to flags field; combine it to some existing
 *  field (there are only a few call sites so this may not be worth it).
 */
 
#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
DUK_INTERNAL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *obj;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr_callstack != NULL);
    DUK_ASSERT(ctx != NULL);
 
    /* [ ... error ] */
 
    /*
     *  Criteria for augmenting:
     *
     *   - augmentation enabled in build (naturally)
     *   - error value internal prototype chain contains the built-in
     *     Error prototype object (i.e. 'val instanceof Error')
     *
     *  Additional criteria for built-in augmenting:
     *
     *   - error value is an extensible object
     */
 
    obj = duk_get_hobject(ctx, -1);
    if (!obj) {
        DUK_DDD(DUK_DDDPRINT("value is not an object, skip both built-in and user augment"));
        return;
    }
    if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE], 1 /*ignore_loop*/)) {
        /* If the value has a prototype loop, it's critical not to
         * throw here.  Instead, assume the value is not to be
         * augmented.

References duk_hthread::builtins, duk__err_augment_builtin_create(), DUK_ASSERT, DUK_BIDX_ERROR_PROTOTYPE, DUK_DDD, DUK_DDDPRINT, duk_get_hobject(), DUK_HOBJECT_HAS_EXTENSIBLE, duk_hobject_prototype_chain_contains(), and NULL.

◆ duk_err_augment_error_throw()

DUK_INTERNAL_DECL void duk_err_augment_error_throw ( duk_hthread * thr )

Definition at line 40404 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_create_and_throw().

◆ duk_err_create_and_throw()

DUK_INTERNAL void duk_err_create_and_throw	(	duk_hthread *	thr,
		duk_errcode_t	code,
		const char *	msg,
		const char *	filename,
		duk_int_t	line )

Definition at line 40613 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                        {
#else
DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) {
#endif
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t double_error = thr->heap->handling_error;
 
#ifdef DUK_USE_VERBOSE_ERRORS
    DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld, msg=%s, filename=%s, line=%ld",
                       (long) code, (const char *) msg,
                       (const char *) filename, (long) line));
#else
    DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld", (long) code));
#endif
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
 
    thr->heap->handling_error = 1;
 
    if (!double_error) {
        /* Allow headroom for calls during error handling (see GH-191).
         * We allow space for 10 additional recursions, with one extra
         * for, e.g. a print() call at the deepest level.
         */
        DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX);
        thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11;
    }
 
    DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11);  /* just making sure */
 
    /* Sync so that augmentation sees up-to-date activations, NULL
     * thr->ptr_curr_pc so that it's not used if side effects occur
     * in augmentation or longjmp handling.
     */
    duk_hthread_sync_and_null_currpc(thr);
 
    /*
     *  Create and push an error object onto the top of stack.
     *  If a "double error" occurs, use a fixed error instance
     *  to avoid further trouble.
     */
 
    /* XXX: if attempt to push beyond allocated valstack, this double fault
     * handling fails miserably.  We should really write the double error
     * directly to thr->heap->lj.value1 and avoid valstack use entirely.
     */
 
    if (double_error) {
        if (thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
            DUK_D(DUK_DPRINT("double fault detected -> push built-in fixed 'double error' instance"));
            duk_push_hobject_bidx(ctx, DUK_BIDX_DOUBLE_ERROR);
        } else {
            DUK_D(DUK_DPRINT("double fault detected; there is no built-in fixed 'double error' instance "
                             "-> push the error code as a number"));
            duk_push_int(ctx, (duk_int_t) code);
        }
    } else {
        /* Error object is augmented at its creation here. */
        duk_require_stack(ctx, 1);
        /* XXX: unnecessary '%s' formatting here, but cannot use
         * 'msg' as a format string directly.
         */
#ifdef DUK_USE_VERBOSE_ERRORS
        duk_push_error_object_raw(ctx,
                                  code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
                                  filename,
                                  line,
                                  "%s",
                                  (const char *) msg);
#else
        duk_push_error_object_raw(ctx,
                                  code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
                                  NULL,
                                  0,
                                  NULL);
#endif
    }
 
    /*
     *  Augment error (throw time), unless alloc/double error
     */
 
    if (double_error || code == DUK_ERR_ALLOC_ERROR) {
        DUK_D(DUK_DPRINT("alloc or double error: skip throw augmenting to avoid further trouble"));
    } else {
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
        DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT (before throw augment)",
                             (duk_tval *) duk_get_tval(ctx, -1)));
        duk_err_augment_error_throw(thr);
#endif

References duk_hthread::builtins, duk_hthread::callstack_max, DUK_ASSERT, DUK_BIDX_DOUBLE_ERROR, DUK_CALLSTACK_DEFAULT_MAX, DUK_CALLSTACK_GROW_STEP, DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, DUK_ERR_ALLOC_ERROR, duk_err_augment_error_throw(), duk_err_create_and_throw(), DUK_ERRCODE_FLAG_NOBLAME_FILELINE, duk_get_tval(), duk_hthread_sync_and_null_currpc(), DUK_INTERNAL, duk_push_error_object_raw(), duk_push_hobject_bidx(), duk_push_int(), duk_require_stack(), duk_heap::handling_error, duk_hthread::heap, and NULL.

Referenced by duk_err_create_and_throw(), duk_err_handle_error(), and duk_err_require_type_index().

◆ duk_err_handle_error()

DUK_INTERNAL void duk_err_handle_error	(	duk_hthread *	thr,
		const char *	filename,
		duk_uint_t	line_and_code,
		const char *	msg )

Definition at line 9788 of file duktape-1.8.0/src/duktape.c.

References DUK__ERRFMT_BUFSIZE, duk_err_create_and_throw(), and DUK_VSNPRINTF.

◆ duk_err_handle_error_fmt()

DUK_INTERNAL void duk_err_handle_error_fmt	(	duk_hthread *	thr,
		const char *	filename,
		duk_uint_t	line_and_code,
		const char *	fmt,
			... )

Definition at line 9778 of file duktape-1.8.0/src/duktape.c.

◆ duk_err_internal()

DUK_INTERNAL void duk_err_internal	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber,
		const char *	message )

Definition at line 9836 of file duktape-1.8.0/src/duktape.c.

                                                                                                                   {
    DUK_ERROR_RAW_FMT1(thr, filename, linenumber, DUK_ERR_API_ERROR, "invalid stack index %ld", (long) (index));
}

References DUK_ERR_API_ERROR, DUK_ERROR_RAW_FMT1, and index.

◆ duk_err_internal_defmsg()

DUK_INTERNAL void duk_err_internal_defmsg	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber )

Definition at line 9833 of file duktape-1.8.0/src/duktape.c.

                                                                                                                   {
    DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_RANGE_ERROR, message);
}

References DUK_ERR_RANGE_ERROR, and DUK_ERROR_RAW.

◆ duk_err_longjmp()

DUK_INTERNAL void duk_err_longjmp ( duk_hthread * thr )

Definition at line 40418 of file duktape-1.8.0/src/duktape.c.

                                                                {
#if defined(DUK_USE_ERRTHROW)
    duk__err_augment_user(thr, DUK_STRIDX_ERR_THROW);
#endif  /* DUK_USE_ERRTHROW */
}
#endif  /* DUK_USE_AUGMENT_ERROR_THROW */
#line 1 "duk_error_longjmp.c"
/*
 *  Do a longjmp call, calling the fatal error handler if no
 *  catchpoint exists.
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) {
    DUK_ASSERT(thr != NULL);
 
    DUK_DD(DUK_DDPRINT("longjmp error: type=%d iserror=%d value1=%!T value2=%!T",
                       (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
                       &thr->heap->lj.value1, &thr->heap->lj.value2));
 
#if !defined(DUK_USE_CPP_EXCEPTIONS)
    /* If we don't have a jmpbuf_ptr, there is little we can do
     * except panic.  The caller's expectation is that we never
     * return.
     *
     * With C++ exceptions we now just propagate an uncaught error
     * instead of invoking the fatal error handler.  Because there's
     * a dummy jmpbuf for C++ exceptions now, this could be changed.
     */
    if (!thr->heap->lj.jmpbuf_ptr) {
 
        DUK_D(DUK_DPRINT("uncaught error: type=%d iserror=%d value1=%!T value2=%!T",
                         (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
                         &thr->heap->lj.value1, &thr->heap->lj.value2));

References duk__err_augment_user(), and DUK_STRIDX_ERR_THROW.

◆ duk_err_range()

DUK_INTERNAL void duk_err_range	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber,
		const char *	message )

Definition at line 9816 of file duktape-1.8.0/src/duktape.c.

◆ duk_err_require_type_index()

DUK_INTERNAL void duk_err_require_type_index	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber,
		duk_idx_t	index,
		const char *	expect_name )

Definition at line 9811 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_err_create_and_throw(thr, code);
}
 

References duk_err_create_and_throw().

◆ duk_err_setup_heap_ljstate()

DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate	(	duk_hthread *	thr,
		duk_small_int_t	lj_type )

Definition at line 40530 of file duktape-1.8.0/src/duktape.c.

                                    :
    case DUK_ERR_INTERNAL_ERROR:
    case DUK_ERR_ALLOC_ERROR:
    case DUK_ERR_ASSERTION_ERROR:
    case DUK_ERR_API_ERROR:
    case DUK_ERR_ERROR:
    default:
        return thr->builtins[DUK_BIDX_ERROR_PROTOTYPE];
    }
}
 
/*
 *  Exposed helper for setting up heap longjmp state.
 */
 
DUK_INTERNAL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type) {
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    /* If something is thrown with the debugger attached and nobody will
     * catch it, execution is paused before the longjmp, turning over
     * control to the debug client.  This allows local state to be examined
     * before the stack is unwound.  Errors are not intercepted when debug
     * message loop is active (e.g. for Eval).
     */
 
    /* XXX: Allow customizing the pause and notify behavior at runtime
     * using debugger runtime flags.  For now the behavior is fixed using
     * config options.
     */
#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
    if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) &&
        !thr->heap->dbg_processing &&
        lj_type == DUK_LJ_TYPE_THROW) {
        duk_context *ctx = (duk_context *) thr;
        duk_bool_t fatal;
        duk_hobject *h_obj;
 
        /* Don't intercept a DoubleError, we may have caused the initial double
         * fault and attempting to intercept it will cause us to be called
         * recursively and exhaust the C stack.
         */
        h_obj = duk_get_hobject(ctx, -1);
        if (h_obj == thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
            DUK_D(DUK_DPRINT("built-in DoubleError instance thrown, not intercepting"));
            goto skip_throw_intercept;
        }
 
        DUK_D(DUK_DPRINT("throw with debugger attached, report to client"));
 
        fatal = !duk__have_active_catcher(thr);
 
#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY)
        /* Report it to the debug client */
        duk_debug_send_throw(thr, fatal);
#endif
 
#if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
        if (fatal) {

◆ duk_err_unimplemented_defmsg()

DUK_INTERNAL void duk_err_unimplemented_defmsg	(	duk_hthread *	thr,
		const char *	filename,
		duk_int_t	linenumber )

Definition at line 9825 of file duktape-1.8.0/src/duktape.c.

◆ duk_error_prototype_from_code()

DUK_INTERNAL_DECL duk_hobject * duk_error_prototype_from_code	(	duk_hthread *	thr,
		duk_errcode_t	err_code )

Definition at line 40499 of file duktape-1.8.0/src/duktape.c.

                        {
        for (i = 0; i < thr->catchstack_top; i++) {
            duk_catcher *cat = thr->catchstack + i;
            if (DUK_CAT_HAS_CATCH_ENABLED(cat)) {
                return 1;  /* all we need to know */
            }
        }
        thr = thr->resumer;
    }
    return 0;
}
#endif  /* DUK_USE_DEBUGGER_SUPPORT && (DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) */
 
/*
 *  Get prototype object for an integer error code.
 */
 
DUK_INTERNAL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t code) {
    switch (code) {
    case DUK_ERR_EVAL_ERROR:
        return thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE];
    case DUK_ERR_RANGE_ERROR:
        return thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE];
    case DUK_ERR_REFERENCE_ERROR:
        return thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE];
    case DUK_ERR_SYNTAX_ERROR:

References duk_hthread::catchstack, duk_hthread::catchstack_top, DUK_CAT_HAS_CATCH_ENABLED, and duk_hthread::resumer.

◆ duk_error_raw()

DUK_EXTERNAL void duk_error_raw	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	filename,
		duk_int_t	line,
		const char *	fmt,
			... )

Definition at line 19508 of file duktape-1.8.0/src/duktape.c.

◆ duk_error_stash()

DUK_EXTERNAL void duk_error_stash	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	fmt,
			... )

Definition at line 19520 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                      {
    va_list ap;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    va_start(ap, fmt);
    duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    duk_throw(ctx);
}
 
#if !defined(DUK_USE_VARIADIC_MACROS)

◆ duk_error_throw_from_negative_rc()

DUK_INTERNAL void duk_error_throw_from_negative_rc	(	duk_hthread *	thr,
		duk_ret_t	rc )

Definition at line 40726 of file duktape-1.8.0/src/duktape.c.

                                                : %!iT, %!iT (after throw augment)",
                         (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2));
 
    duk_err_longjmp(thr);
    DUK_UNREACHABLE();
}
 
/*
 *  Helper for C function call negative return values.
 */
 
DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc) {
    duk_context *ctx = (duk_context *) thr;
    const char *msg;
    duk_errcode_t code;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(rc < 0);
 
    /* XXX: this generates quite large code - perhaps select the error
     * class based on the code and then just use the error 'name'?
     */
    /* XXX: shared strings */
 
    code = -rc;
 
    switch (rc) {
    case DUK_RET_UNIMPLEMENTED_ERROR:  msg = "unimplemented"; break;
    case DUK_RET_UNSUPPORTED_ERROR:    msg = "unsupported"; break;
    case DUK_RET_INTERNAL_ERROR:       msg = "internal"; break;
    case DUK_RET_ALLOC_ERROR:          msg = "alloc"; break;
    case DUK_RET_ASSERTION_ERROR:      msg = "assertion"; break;
    case DUK_RET_API_ERROR:            msg = "api"; break;
    case DUK_RET_UNCAUGHT_ERROR:       msg = "uncaught"; break;
    case DUK_RET_ERROR:                msg = "error"; break;
    case DUK_RET_EVAL_ERROR:           msg = "eval"; break;
    case DUK_RET_RANGE_ERROR:          msg = "range"; break;
    case DUK_RET_REFERENCE_ERROR:      msg = "reference"; break;
    case DUK_RET_SYNTAX_ERROR:         msg = "syntax"; break;

◆ duk_error_va_raw()

DUK_EXTERNAL void duk_error_va_raw	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	filename,
		duk_int_t	line,
		const char *	fmt,
		va_list	ap )

Definition at line 19501 of file duktape-1.8.0/src/duktape.c.

◆ duk_eval_raw()

DUK_EXTERNAL duk_int_t duk_eval_raw	(	duk_context *	ctx,
		const char *	src_buffer,
		duk_size_t	src_length,
		duk_uint_t	flags )

Definition at line 13597 of file duktape-1.8.0/src/duktape.c.

                             {
    duk_size_t src_length;  /* should be first on 64-bit platforms */
    const duk_uint8_t *src_buffer;
    duk_uint_t flags;
};
 
/* Eval is just a wrapper now. */
DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) {
    duk_uint_t comp_flags;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: strictness is *not* inherited from the current Duktape/C.
     * This would be confusing because the current strictness state
     * depends on whether we're running inside a Duktape/C activation
     * (= strict mode) or outside of any activation (= non-strict mode).
     * See tests/api/test-eval-strictness.c for more discussion.
     */
 
    /* [ ... source? filename? ] (depends on flags) */
 
    comp_flags = flags;
    comp_flags |= DUK_COMPILE_EVAL;
    rc = duk_compile_raw(ctx, src_buffer, src_length, comp_flags);  /* may be safe, or non-safe depending on flags */
 
    /* [ ... closure/error ] */
 
    if (rc != DUK_EXEC_SUCCESS) {
        rc = DUK_EXEC_ERROR;
        goto got_rc;
    }
 
    duk_push_global_object(ctx);  /* explicit 'this' binding, see GH-164 */

◆ duk_fatal()

DUK_EXTERNAL void duk_fatal	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	err_msg )

Definition at line 19481 of file duktape-1.8.0/src/duktape.c.

                                           : %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
    duk_err_augment_error_throw(thr);
#endif
    DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (after throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
 
    /* thr->heap->lj.jmpbuf_ptr is checked by duk_err_longjmp() so we don't
     * need to check that here.  If the value is NULL, a panic occurs because
     * we can't return.
     */
 
    duk_err_longjmp(thr);
    DUK_UNREACHABLE();
}
 
DUK_EXTERNAL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg) {
    duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_free()

DUK_EXTERNAL void duk_free	(	duk_context *	ctx,
		void *	ptr )

Definition at line 14328 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return DUK_REALLOC_RAW(thr->heap, ptr, size);

References DUK_ASSERT_CTX_VALID, DUK_REALLOC_RAW, and duk_hthread::heap.

◆ duk_free_hbuffer_inner()

DUK_INTERNAL_DECL void duk_free_hbuffer_inner	(	duk_heap *	heap,
		duk_hbuffer *	h )

Definition at line 41068 of file duktape-1.8.0/src/duktape.c.

                                         {
        duk_hthread *t = (duk_hthread *) h;
        DUK_FREE(heap, t->valstack);
        DUK_FREE(heap, t->callstack);
        DUK_FREE(heap, t->catchstack);
        /* Don't free h->resumer because it exists in the heap.
         * Callstack entries also contain function pointers which
         * are not freed for the same reason.
         */
 

◆ duk_free_hobject_inner()

DUK_INTERNAL_DECL void duk_free_hobject_inner	(	duk_heap *	heap,
		duk_hobject *	h )

Definition at line 41037 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(h != NULL);
 
    DUK_FREE(heap, DUK_HOBJECT_GET_PROPS(heap, h));
 
    if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
        duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
        DUK_UNREF(f);
        /* Currently nothing to free; 'data' is a heap object */
    } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        duk_hnativefunction *f = (duk_hnativefunction *) h;
        DUK_UNREF(f);

References DUK_ASSERT, DUK_FREE, DUK_HOBJECT_GET_PROPS, DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_UNREF, and NULL.

◆ duk_free_hstring_inner()

DUK_INTERNAL_DECL void duk_free_hstring_inner	(	duk_heap *	heap,
		duk_hstring *	h )

Definition at line 41079 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(h != NULL);
 
    if (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h)) {
        duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h;
        DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g)));
        DUK_FREE(heap, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g));
    }

◆ duk_free_raw()

DUK_EXTERNAL void duk_free_raw	(	duk_context *	ctx,
		void *	ptr )

Definition at line 14304 of file duktape-1.8.0/src/duktape.c.

◆ duk_gc()

DUK_EXTERNAL void duk_gc	(	duk_context *	ctx,
		duk_uint_t	flags )

Definition at line 14370 of file duktape-1.8.0/src/duktape.c.

                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(out_funcs != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
 
    heap = thr->heap;
    out_funcs->alloc_func = heap->alloc_func;
    out_funcs->realloc_func = heap->realloc_func;
    out_funcs->free_func = heap->free_func;
    out_funcs->udata = heap->heap_udata;
}
 
DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags) {
#ifdef DUK_USE_MARK_AND_SWEEP
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
 
    DUK_UNREF(flags);

References duk_heap::alloc_func, duk_memory_functions::alloc_func, DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_heap::free_func, duk_memory_functions::free_func, duk_hthread::heap, duk_heap::heap_udata, NULL, duk_heap::realloc_func, duk_memory_functions::realloc_func, and duk_memory_functions::udata.

◆ duk_get_boolean()

DUK_EXTERNAL duk_bool_t duk_get_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16100 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_NULL(tv)) {
        return;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "null", DUK_STR_NOT_NULL);

◆ duk_get_borrowed_this_tval()

DUK_INTERNAL_DECL duk_tval * duk_get_borrowed_this_tval ( duk_context * ctx )

Definition at line 18371 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_hstring *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 1 /*check_object_coercible*/);
    duk_to_string(ctx, -1);

◆ duk_get_buffer()

DUK_EXTERNAL void * duk_get_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16332 of file duktape-1.8.0/src/duktape.c.

16334 {

Referenced by duk__base64_encode_helper().

◆ duk_get_buffer_data()

DUK_EXTERNAL void * duk_get_buffer_data	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16394 of file duktape-1.8.0/src/duktape.c.

16395 {

16396 *out_size = (duk_size_t) h_bufobj->length;

References duk_hbufferobject::length.

◆ duk_get_c_function()

DUK_EXTERNAL duk_c_function duk_get_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16513 of file duktape-1.8.0/src/duktape.c.

                                                                                             {
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && !DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        h = NULL;
    }
    return (duk_hnativefunction *) h;
}
 
DUK_INTERNAL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (!(h != NULL && DUK_HOBJECT_IS_NATIVEFUNCTION(h))) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "nativefunction", DUK_STR_NOT_NATIVEFUNCTION);
    }
    return (duk_hnativefunction *) h;
}
 
DUK_EXTERNAL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
    duk_hobject *h;
    duk_hnativefunction *f;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_TAG_OBJECT, index, and NULL.

◆ duk_get_context()

DUK_EXTERNAL duk_context * duk_get_context	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16558 of file duktape-1.8.0/src/duktape.c.

◆ duk_get_current_magic()

DUK_EXTERNAL duk_int_t duk_get_current_magic ( duk_context * ctx )

Definition at line 12880 of file duktape-1.8.0/src/duktape.c.

                     {
        /* Strict by default. */
        return 1;
    }
    return ((act->flags & DUK_ACT_FLAG_STRICT) != 0 ? 1 : 0);
}
 
/*
 *  Duktape/C function magic
 */
 
DUK_EXTERNAL duk_int_t duk_get_current_magic(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_hobject *func;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
 
    act = duk_hthread_get_current_activation(thr);

Referenced by duk_bi_boolean_prototype_tostring_shared(), duk_bi_buffer_readfield(), duk_bi_buffer_slice_shared(), duk_bi_object_constructor_is_extensible(), and duk_bi_string_prototype_indexof_shared().

◆ duk_get_error_code()

DUK_EXTERNAL duk_errcode_t duk_get_error_code	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17953 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_HAS_DYNAMIC(h) && DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0);
    }
    return 0;
}
 
DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_uint_t sanity;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h = duk_get_hobject(ctx, index);
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        if (!h) {
            return DUK_ERR_NONE;
        }
        if (h == thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE]) {
            return DUK_ERR_EVAL_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE]) {
            return DUK_ERR_RANGE_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE]) {
            return DUK_ERR_REFERENCE_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE]) {

◆ duk_get_finalizer()

DUK_EXTERNAL void duk_get_finalizer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14993 of file duktape-1.8.0/src/duktape.c.

◆ duk_get_global_string()

DUK_EXTERNAL duk_bool_t duk_get_global_string	(	duk_context *	ctx,
		const char *	key )

Definition at line 14903 of file duktape-1.8.0/src/duktape.c.

                     {
        while (ent->key != NULL) {
            duk_push_number(ctx, ent->value);
            duk_put_prop_string(ctx, obj_index, ent->key);
            ent++;
        }
    }
}
 
/*

◆ duk_get_hbuffer()

DUK_INTERNAL_DECL duk_hbuffer * duk_get_hbuffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16449 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ duk_get_hcompiledfunction()

DUK_INTERNAL_DECL duk_hcompiledfunction * duk_get_hcompiledfunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16479 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && !DUK_HOBJECT_IS_THREAD(h)) {
        h = NULL;
    }
    return (duk_hthread *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_THREAD, DUK_TAG_OBJECT, index, and NULL.

◆ duk_get_heapptr()

DUK_EXTERNAL void * duk_get_heapptr	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16570 of file duktape-1.8.0/src/duktape.c.

                                      {
        DUK_ERROR_REQUIRE_TYPE_INDEX((duk_hthread *) ctx, index, "function", DUK_STR_NOT_FUNCTION);
    }
}
 
DUK_EXTERNAL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_context *) duk_get_hthread(ctx, index);
}
 
DUK_EXTERNAL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_context *) duk_require_hthread(ctx, index);

References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_FUNCTION, and index.

◆ duk_get_hnativefunction()

DUK_INTERNAL_DECL duk_hnativefunction * duk_get_hnativefunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16496 of file duktape-1.8.0/src/duktape.c.

                                                                                                 {
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && !DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
        h = NULL;
    }
    return (duk_hcompiledfunction *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_TAG_OBJECT, index, and NULL.

◆ duk_get_hobject()

DUK_INTERNAL_DECL duk_hobject * duk_get_hobject	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16436 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__compact_object_list(), duk__error_getter_helper(), and duk_err_augment_error_create().

◆ duk_get_hobject_or_lfunc_coerce()

DUK_INTERNAL_DECL duk_hobject * duk_get_hobject_or_lfunc_coerce	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16618 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
}
#endif
 
/* Useful for internal call sites where we either expect an object (function)
 * or a lightfunc.  Accepts an object (returned as is) or a lightfunc (coerced
 * to an object).  Return value is NULL if value is neither an object nor a
 * lightfunc.

Referenced by duk_hobject_prepare_property_descriptor(), and duk_js_instanceof().

◆ duk_get_hobject_with_class()

DUK_INTERNAL_DECL duk_hobject * duk_get_hobject_with_class	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_uint_t	classnum )

Definition at line 16676 of file duktape-1.8.0/src/duktape.c.

                                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    if (DUK_TVAL_IS_OBJECT(tv)) {
        return DUK_TVAL_GET_OBJECT(tv);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_to_object(ctx, index);
        return duk_require_hobject(ctx, index);
    }

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_require_hobject(), duk_require_tval(), DUK_STR_NOT_OBJECT, duk_to_object(), DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_LIGHTFUNC, DUK_TVAL_IS_OBJECT, and index.

Referenced by duk_bi_array_prototype_to_string().

◆ duk_get_hstring()

DUK_INTERNAL_DECL duk_hstring * duk_get_hstring	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16423 of file duktape-1.8.0/src/duktape.c.

16424 {

16425 duk_tval *tv;

Referenced by duk__create_escaped_source(), duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), and duk_lexer_parse_js_input_element().

◆ duk_get_hthread()

DUK_INTERNAL_DECL duk_hthread * duk_get_hthread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16462 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    return (duk_hbuffer *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER);
}

◆ duk_get_int()

DUK_EXTERNAL duk_int_t duk_get_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16175 of file duktape-1.8.0/src/duktape.c.

                                      {
        duk_double_union ret;
        ret.d = DUK_TVAL_GET_NUMBER(tv);
 

Referenced by duk_bi_buffer_readfield().

◆ duk_get_length()

DUK_EXTERNAL duk_size_t duk_get_length	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16710 of file duktape-1.8.0/src/duktape.c.

                                                                     {
        duk_hstring *h_class;
        h_class = DUK_HTHREAD_GET_STRING(thr, DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(classnum));
        DUK_UNREF(h_class);
 
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, (const char *) DUK_HSTRING_GET_DATA(h_class), DUK_STR_UNEXPECTED_TYPE);
    }
    return h;
}
 
DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return 0;
    }
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
    case DUK_TAG_BOOLEAN:
    case DUK_TAG_POINTER:
        return 0;
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
        return (duk_size_t) DUK_HSTRING_GET_CHARLEN(h);
    }
    case DUK_TAG_OBJECT: {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        return (duk_size_t) duk_hobject_get_length((duk_hthread *) ctx, h);
    }
    case DUK_TAG_BUFFER: {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (duk_size_t) DUK_HBUFFER_GET_SIZE(h);
    }

Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__parse_var_decl(), and duk_bi_typedarray_set().

◆ duk_get_lstring()

DUK_EXTERNAL const char * duk_get_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 16199 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/);
}
 
DUK_EXTERNAL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index) {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/);
}
 
DUK_EXTERNAL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
    const char *ret;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* default: NULL, length 0 */
    ret = NULL;
    if (out_len) {
        *out_len = 0;

◆ duk_get_magic()

DUK_EXTERNAL duk_int_t duk_get_magic	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 12908 of file duktape-1.8.0/src/duktape.c.

                   {
            duk_tval *tv = &act->tv_func;
            duk_small_uint_t lf_flags;
            lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
            return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
        }
        DUK_ASSERT(func != NULL);
 
        if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
            duk_hnativefunction *nf = (duk_hnativefunction *) func;
            return (duk_int_t) nf->magic;
        }
    }
    return 0;
}
 
DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);

◆ duk_get_memory_functions()

DUK_EXTERNAL void duk_get_memory_functions	(	duk_context *	ctx,
		duk_memory_functions *	out_funcs )

Definition at line 14354 of file duktape-1.8.0/src/duktape.c.

◆ duk_get_number()

DUK_EXTERNAL duk_double_t duk_get_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16131 of file duktape-1.8.0/src/duktape.c.

                                                                               {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
        duk_bool_t ret = DUK_TVAL_GET_BOOLEAN(tv);
        DUK_ASSERT(ret == 0 || ret == 1);
        return ret;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "boolean", DUK_STR_NOT_BOOLEAN);
    return 0;  /* not reachable */
}
 
DUK_EXTERNAL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index) {
    duk_double_union ret;
    duk_tval *tv;

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_BOOLEAN, DUK_TVAL_GET_BOOLEAN, DUK_TVAL_IS_BOOLEAN, and index.

◆ duk_get_pointer()

DUK_EXTERNAL void * duk_get_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16256 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_get_lstring(ctx, index, NULL);
}
 
DUK_EXTERNAL const char *duk_require_string(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_get_prop()

DUK_EXTERNAL duk_bool_t duk_get_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14408 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;
    duk_bool_t rc;

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk_get_prop_stridx().

◆ duk_get_prop_index()

DUK_EXTERNAL duk_bool_t duk_get_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14440 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), and duk_bi_typedarray_set().

◆ duk_get_prop_stridx()

DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx )

Definition at line 14448 of file duktape-1.8.0/src/duktape.c.

                                                                                                    {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(key != NULL);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    duk_push_string(ctx, key);
    return duk_get_prop(ctx, obj_index);
}
 
DUK_EXTERNAL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
    DUK_ASSERT_CTX_VALID(ctx);
 

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_prop(), duk_push_string(), duk_require_normalize_index(), and NULL.

Referenced by duk__error_getter_helper(), duk__finalize_helper(), duk__push_this_obj_len_u32_limited(), duk__put_prop_shared(), duk_bi_boolean_constructor(), duk_bi_buffer_slice_shared(), duk_bi_object_prototype_is_prototype_of(), duk_hobject_prepare_property_descriptor(), duk_js_instanceof(), and duk_to_defaultvalue().

◆ duk_get_prop_stridx_boolean()

DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_boolean	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx,
		duk_bool_t *	out_has_prop )

Definition at line 14461 of file duktape-1.8.0/src/duktape.c.

                                                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(stridx >= 0);
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    DUK_UNREF(thr);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
    return duk_get_prop(ctx, obj_index);
}

◆ duk_get_prop_string()

DUK_EXTERNAL duk_bool_t duk_get_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14431 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_put_global_string().

◆ duk_get_prototype()

DUK_EXTERNAL void duk_get_prototype	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14938 of file duktape-1.8.0/src/duktape.c.

14955 {

14956 duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_get_string()

DUK_EXTERNAL const char * duk_get_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16244 of file duktape-1.8.0/src/duktape.c.

                                                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);

References DUK_ASSERT_CTX_VALID.

Referenced by duk__error_getter_helper().

◆ duk_get_top()

DUK_EXTERNAL duk_idx_t duk_get_top ( duk_context * ctx )

Definition at line 15335 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API_INDEX, DUK_INVALID_INDEX, duk_normalize_index(), and index.

Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__math_minmax(), duk_bi_string_constructor(), duk_bi_string_prototype_locale_compare(), duk_bi_typedarray_set(), duk_debugger_pause(), and duk_handle_call_protected().

◆ duk_get_top_index()

DUK_EXTERNAL duk_idx_t duk_get_top_index ( duk_context * ctx )

Definition at line 15438 of file duktape-1.8.0/src/duktape.c.

           {
            tv--;
            DUK_TVAL_SET_UNDEFINED(tv);
        } while (tv != tv_end);
        thr->valstack_top = tv_end;
#endif  /* DUK_USE_REFERENCE_COUNTING */
    }
}

Referenced by duk__error_getter_helper(), and duk_hobject_prepare_property_descriptor().

◆ duk_get_tval()

DUK_INTERNAL_DECL duk_tval * duk_get_tval	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15252 of file duktape-1.8.0/src/duktape.c.

                   {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        DUK_ASSERT(index != DUK_INVALID_INDEX);
        uindex = (duk_uidx_t) index;
    }
 
    /* DUK_INVALID_INDEX won't be accepted as a valid index. */
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
 
    if (DUK_LIKELY(uindex < vs_size)) {
        return (duk_idx_t) uindex;
    }
    DUK_ERROR_API_INDEX(thr, index);
    return 0;  /* unreachable */
}
 
DUK_INTERNAL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t uindex;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);

References index.

Referenced by duk__concat_and_join_helper(), duk__get_buffer_helper(), duk__init_varmap_and_prologue_for_pass2(), duk__ispec_toregconst_raw(), duk_bi_boolean_prototype_tostring_shared(), duk_bi_duktape_object_info(), duk_err_create_and_throw(), duk_get_number(), duk_handle_ecma_call_setup(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_putprop(), duk_is_c_function(), duk_require_heapptr(), and duk_require_null().

◆ duk_get_type()

DUK_EXTERNAL duk_int_t duk_get_type	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17613 of file duktape-1.8.0/src/duktape.c.

                                                                                                              {
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_get_hobject(ctx, index);
    if (obj) {
        return (DUK_HEAPHDR_CHECK_FLAG_BITS((duk_heaphdr *) obj, flag_mask) ? 1 : 0);
    }
    return 0;
}
 
DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return DUK_TYPE_NONE;
    }
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
        return DUK_TYPE_UNDEFINED;
    case DUK_TAG_NULL:
        return DUK_TYPE_NULL;
    case DUK_TAG_BOOLEAN:
        return DUK_TYPE_BOOLEAN;
    case DUK_TAG_STRING:
        return DUK_TYPE_STRING;
    case DUK_TAG_OBJECT:
        return DUK_TYPE_OBJECT;

Referenced by duk__error_getter_helper(), duk_bi_duktape_object_info(), and duk_get_type_mask().

◆ duk_get_type_mask()

DUK_EXTERNAL duk_uint_t duk_get_type_mask	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17682 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_int_t type_tag;
 
    type_tag = duk_get_type(ctx, index);
    DUK_ASSERT(type_tag >= DUK_TYPE_MIN && type_tag <= DUK_TYPE_MAX);
    DUK_ASSERT(DUK_TYPE_MIN == 0 && sizeof(duk__type_names) / sizeof(const char *) == DUK_TYPE_MAX + 1);
 
    return duk__type_names[type_tag];
}
#endif
 
DUK_EXTERNAL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_get_type(ctx, index) == type) ? 1 : 0;
}
 
DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return DUK_TYPE_MASK_NONE;
    }
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
        return DUK_TYPE_MASK_UNDEFINED;
    case DUK_TAG_NULL:
        return DUK_TYPE_MASK_NULL;
    case DUK_TAG_BOOLEAN:
        return DUK_TYPE_MASK_BOOLEAN;
    case DUK_TAG_STRING:
        return DUK_TYPE_MASK_STRING;
    case DUK_TAG_OBJECT:
        return DUK_TYPE_MASK_OBJECT;

References DUK_ASSERT, duk_get_type(), DUK_TYPE_MAX, DUK_TYPE_MIN, and index.

◆ duk_get_uint()

DUK_EXTERNAL duk_uint_t duk_get_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16181 of file duktape-1.8.0/src/duktape.c.

◆ duk_get_var()

DUK_EXTERNAL void duk_get_var ( duk_context * ctx )

Definition at line 20132 of file duktape-1.8.0/src/duktape.c.

                                                   {
        return 0;
    }
 
    DUK_ASSERT(char_offset <= DUK_UINT_MAX);  /* guaranteed by string limits */
    cp = duk_hstring_char_code_at_raw(thr, h, (duk_uint_t) char_offset);
    return (duk_codepoint_t) cp;
}
#line 1 "duk_api_var.c"
/*
 *  Variable access
 */
 
/* include removed: duk_internal.h */
 
DUK_EXTERNAL void duk_get_var(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_hstring *h_varname;
    duk_small_int_t throw_flag = 1;  /* always throw ReferenceError for unresolvable */
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h_varname = duk_require_hstring(ctx, -1);  /* XXX: tostring? */
    DUK_ASSERT(h_varname != NULL);
 
    act = duk_hthread_get_current_activation(thr);
    if (act) {
        (void) duk_js_getvar_activation(thr, act, h_varname, throw_flag);  /* -> [ ... varname val this ] */
    } else {

◆ duk_handle_call_protected()

DUK_INTERNAL_DECL duk_int_t duk_handle_call_protected	(	duk_hthread *	thr,
		duk_idx_t	num_stack_args,
		duk_small_uint_t	call_flags )

Definition at line 55950 of file duktape-1.8.0/src/duktape.c.

                      :
 *
 *    [ retval ]         (DUK_EXEC_SUCCESS)
 *    [ errobj ]         (DUK_EXEC_ERROR (normal error), protected call)
 *
 *  Even when executing a protected call an error may be thrown in rare cases
 *  such as an insane num_stack_args argument.  If there is no catchpoint for
 *  such errors, the fatal error handler is called.
 *
 *  The error handling path should be error free, even for out-of-memory
 *  errors, to ensure safe sandboxing.  (As of Duktape 1.4.0 this is not
 *  yet the case, see XXX notes below.)
 */
 
DUK_INTERNAL duk_int_t duk_handle_call_protected(duk_hthread *thr,
                                                 duk_idx_t num_stack_args,
                                                 duk_small_uint_t call_flags) {
    duk_context *ctx;
    duk_size_t entry_valstack_bottom_index;
    duk_size_t entry_valstack_end;
    duk_size_t entry_callstack_top;
    duk_size_t entry_catchstack_top;
    duk_int_t entry_call_recursion_depth;
    duk_hthread *entry_curr_thread;
    duk_uint_fast8_t entry_thread_state;
    duk_instr_t **entry_ptr_curr_pc;
    duk_jmpbuf *old_jmpbuf_ptr = NULL;
    duk_jmpbuf our_jmpbuf;
    duk_idx_t idx_func;  /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
 
    /* XXX: Multiple tv_func lookups are now avoided by making a local
     * copy of tv_func.  Another approach would be to compute an offset
     * for tv_func from valstack bottom and recomputing the tv_func
     * pointer quickly as valstack + offset instead of calling duk_get_tval().
     */
 
    ctx = (duk_context *) thr;
    DUK_UNREF(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(num_stack_args >= 0);
    /* XXX: currently NULL allocations are not supported; remove if later allowed */
    DUK_ASSERT(thr->valstack != NULL);
    DUK_ASSERT(thr->callstack != NULL);
    DUK_ASSERT(thr->catchstack != NULL);
 
    /* Argument validation and func/args offset. */
    idx_func = duk__get_idx_func(thr, num_stack_args);
 
    /* Preliminaries, required by setjmp() handler.  Must be careful not
     * to throw an unintended error here.
     */
 
    entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
#if defined(DUK_USE_PREFER_SIZE)
    entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack);
#else
    DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
    entry_valstack_end = thr->valstack_size;
#endif
    entry_callstack_top = thr->callstack_top;
    entry_catchstack_top = thr->catchstack_top;
    entry_call_recursion_depth = thr->heap->call_recursion_depth;
    entry_curr_thread = thr->heap->curr_thread;  /* Note: may be NULL if first call */
    entry_thread_state = thr->state;
    entry_ptr_curr_pc = thr->ptr_curr_pc;  /* may be NULL */
 
    DUK_DD(DUK_DDPRINT("duk_handle_call_protected: thr=%p, num_stack_args=%ld, "
                       "call_flags=0x%08lx (ignorerec=%ld, constructor=%ld), "
                       "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, "
                       "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
                       "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
                       (void *) thr,
                       (long) num_stack_args,
                       (unsigned long) call_flags,
                       (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0),
                       (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0),
                       (long) duk_get_top(ctx),
                       (long) idx_func,
                       (long) (idx_func + 2),
                       (long) thr->heap->call_recursion_depth,
                       (long) thr->heap->call_recursion_limit,
                       (long) entry_valstack_bottom_index,
                       (long) entry_callstack_top,
                       (long) entry_catchstack_top,
                       (long) entry_call_recursion_depth,
                       (void *) entry_curr_thread,
                       (long) entry_thread_state));
 
    old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
    thr->heap->lj.jmpbuf_ptr = &our_jmpbuf;
 
#if defined(DUK_USE_CPP_EXCEPTIONS)
    try {
#else
    DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == &our_jmpbuf);
    if (DUK_SETJMP(our_jmpbuf.jb) == 0) {
#endif
        /* Call handling and success path.  Success path exit cleans
         * up almost all state.
         */
        duk__handle_call_inner(thr, num_stack_args, call_flags, idx_func);
 
        /* Success path handles */
        DUK_ASSERT(thr->heap->call_recursion_depth == entry_call_recursion_depth);
        DUK_ASSERT(thr->ptr_curr_pc == entry_ptr_curr_pc);
 
        /* Longjmp state is kept clean in success path */
        DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
        DUK_ASSERT(thr->heap->lj.iserror == 0);
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
 
        thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
 
        return DUK_EXEC_SUCCESS;
#if defined(DUK_USE_CPP_EXCEPTIONS)
    } catch (duk_internal_exception &exc) {
#else
    } else {
#endif
        /* Error; error value is in heap->lj.value1. */
 
#if defined(DUK_USE_CPP_EXCEPTIONS)
        DUK_UNREF(exc);
#endif
 
        duk__handle_call_error(thr,
                               entry_valstack_bottom_index,
                               entry_valstack_end,
                               entry_catchstack_top,
                               entry_callstack_top,
                               entry_call_recursion_depth,
                               entry_curr_thread,
                               entry_thread_state,
                               entry_ptr_curr_pc,
                               idx_func,
                               old_jmpbuf_ptr);
 
        /* Longjmp state is cleaned up by error handling */
        DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
        DUK_ASSERT(thr->heap->lj.iserror == 0);
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
        return DUK_EXEC_ERROR;
    }
#if defined(DUK_USE_CPP_EXCEPTIONS)
    catch (std::exception &exc) {
        const char *what = exc.what();
        if (!what) {
            what = "unknown";
        }
        DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)"));
        try {
            DUK_ERROR_FMT1(thr, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what);
        } catch (duk_internal_exception exc) {
            DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception"));
            DUK_UNREF(exc);
            duk__handle_call_error(thr,
                                   entry_valstack_bottom_index,
                                   entry_valstack_end,
                                   entry_catchstack_top,
                                   entry_callstack_top,
                                   entry_call_recursion_depth,
                                   entry_curr_thread,
                                   entry_thread_state,
                                   entry_ptr_curr_pc,
                                   idx_func,
                                   old_jmpbuf_ptr);
            return DUK_EXEC_ERROR;
        }
    } catch (...) {
        DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)"));
        try {
            DUK_ERROR_API(thr, "caught invalid c++ exception (perhaps thrown by user code)");
        } catch (duk_internal_exception exc) {
            DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception"));

References duk_heap::call_recursion_depth, duk_heap::call_recursion_limit, duk_hthread::callstack, duk_hthread::callstack_top, duk_hthread::catchstack, duk_hthread::catchstack_top, duk_heap::curr_thread, duk__get_idx_func(), duk__handle_call_error(), duk__handle_call_inner(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_CALL_FLAG_CONSTRUCTOR_CALL, DUK_CALL_FLAG_IGNORE_RECLIMIT, DUK_D, DUK_DD, DUK_DDPRINT, DUK_DPRINT, DUK_ERR_API_ERROR, DUK_ERROR_API, DUK_ERROR_FMT1, DUK_EXEC_ERROR, DUK_EXEC_SUCCESS, duk_get_top(), DUK_LJ_TYPE_UNKNOWN, DUK_SETJMP, DUK_TVAL_IS_UNDEFINED, DUK_UNREF, duk_hthread::heap, duk_ljstate::iserror, duk_jmpbuf::jb, duk_ljstate::jmpbuf_ptr, duk_heap::lj, NULL, duk_hthread::ptr_curr_pc, duk_hthread::state, duk_ljstate::type, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, duk_hthread::valstack_size, duk_ljstate::value1, and duk_ljstate::value2.

◆ duk_handle_call_unprotected()

DUK_INTERNAL_DECL void duk_handle_call_unprotected	(	duk_hthread *	thr,
		duk_idx_t	num_stack_args,
		duk_small_uint_t	call_flags )

Definition at line 56131 of file duktape-1.8.0/src/duktape.c.

◆ duk_handle_ecma_call_setup()

DUK_INTERNAL_DECL duk_bool_t duk_handle_ecma_call_setup	(	duk_hthread *	thr,
		duk_idx_t	num_stack_args,
		duk_small_uint_t	call_flags )

Definition at line 57276 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk_context *ctx = (duk_context *) thr;
    duk_size_t entry_valstack_bottom_index;
    duk_idx_t idx_func;     /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
    duk_idx_t idx_args;     /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */
    duk_idx_t nargs;        /* # argument registers target function wants (< 0 => never for ecma calls) */
    duk_idx_t nregs;        /* # total registers target function wants on entry (< 0 => never for ecma calls) */
    duk_hobject *func;      /* 'func' on stack (borrowed reference) */
    duk_tval *tv_func;      /* duk_tval ptr for 'func' on stack (borrowed reference) */
    duk_activation *act;
    duk_hobject *env;
    duk_bool_t use_tailcall;
    duk_instr_t **entry_ptr_curr_pc;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(!((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 && (call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0));
 
    /* XXX: assume these? */
    DUK_ASSERT(thr->valstack != NULL);
    DUK_ASSERT(thr->callstack != NULL);
    DUK_ASSERT(thr->catchstack != NULL);
 
    /* no need to handle thread state book-keeping here */
    DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ||
               (thr->state == DUK_HTHREAD_STATE_RUNNING &&
                thr->heap->curr_thread == thr));
 
    /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc.  Then NULL
     * thr->ptr_curr_pc so that it's not accidentally used with an incorrect
     * activation when side effects occur.  If we end up not making the
     * call we must restore the value.
     */
    entry_ptr_curr_pc = thr->ptr_curr_pc;
    duk_hthread_sync_and_null_currpc(thr);
 
    /* if a tail call:
     *   - an Ecmascript activation must be on top of the callstack
     *   - there cannot be any active catchstack entries
     */
#if defined(DUK_USE_ASSERTIONS)
    if (call_flags & DUK_CALL_FLAG_IS_TAILCALL) {
        duk_size_t our_callstack_index;
        duk_size_t i;
 
        DUK_ASSERT(thr->callstack_top >= 1);
        our_callstack_index = thr->callstack_top - 1;
        DUK_ASSERT_DISABLE(our_callstack_index >= 0);
        DUK_ASSERT(our_callstack_index < thr->callstack_size);
        DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index) != NULL);
        DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index)));
 
        /* No entry in the catchstack which would actually catch a
         * throw can refer to the callstack entry being reused.
         * There *can* be catchstack entries referring to the current
         * callstack entry as long as they don't catch (e.g. label sites).
         */
 
        for (i = 0; i < thr->catchstack_top; i++) {
            DUK_ASSERT(thr->catchstack[i].callstack_index < our_callstack_index ||  /* refer to callstack entries below current */
                       DUK_CAT_GET_TYPE(thr->catchstack + i) == DUK_CAT_TYPE_LABEL); /* or a non-catching entry */
        }
    }
#endif  /* DUK_USE_ASSERTIONS */
 
    entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
    /* XXX: rework */
    idx_func = duk_normalize_index(thr, -num_stack_args - 2);
    idx_args = idx_func + 2;
 
    DUK_DD(DUK_DDPRINT("handle_ecma_call_setup: thr=%p, "
                       "num_stack_args=%ld, call_flags=0x%08lx (resume=%ld, tailcall=%ld), "
                       "idx_func=%ld, idx_args=%ld, entry_valstack_bottom_index=%ld",
                       (void *) thr,
                       (long) num_stack_args,
                       (unsigned long) call_flags,
                       (long) ((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ? 1 : 0),
                       (long) ((call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0 ? 1 : 0),
                       (long) idx_func,
                       (long) idx_args,
                       (long) entry_valstack_bottom_index));
 
    if (DUK_UNLIKELY(idx_func < 0 || idx_args < 0)) {
        /* XXX: assert? compiler is responsible for this never happening */
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    }
 
    /*
     *  Check the function type, handle bound function chains, and prepare
     *  parameters for the rest of the call handling.  Also figure out the
     *  effective 'this' binding, which replaces the current value at
     *  idx_func + 1.
     *
     *  If the target function is a 'bound' one, follow the chain of 'bound'
     *  functions until a non-bound function is found.  During this process,
     *  bound arguments are 'prepended' to existing ones, and the "this"
     *  binding is overridden.  See E5 Section 15.3.4.5.1.
     *
     *  If the final target function cannot be handled by an ecma-to-ecma
     *  call, return to the caller with a return value indicating this case.
     *  The bound chain is resolved and the caller can resume with a plain
     *  function call.
     */
 
    func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags);
    if (func == NULL || !DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
        DUK_DDD(DUK_DDDPRINT("final target is a lightfunc/nativefunc, cannot do ecma-to-ecma call"));
        thr->ptr_curr_pc = entry_ptr_curr_pc;
        return 0;
    }
    /* XXX: tv_func is not actually needed */
 
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(func));
 
    duk__coerce_effective_this_binding(thr, func, idx_func + 1);
    DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T",
                         duk_get_tval(ctx, idx_func + 1)));
 
    nargs = ((duk_hcompiledfunction *) func)->nargs;
    nregs = ((duk_hcompiledfunction *) func)->nregs;
    DUK_ASSERT(nregs >= nargs);
 
    /* [ ... func this arg1 ... argN ] */
 
    /*
     *  Preliminary activation record and valstack manipulation.
     *  The concrete actions depend on whether the we're dealing
     *  with a tail call (reuse an existing activation), a resume,
     *  or a normal call.
     *
     *  The basic actions, in varying order, are:
     *
     *    - Check stack size for call handling
     *    - Grow call stack if necessary (non-tail-calls)
     *    - Update current activation (idx_retval) if necessary
     *      (non-tail, non-resume calls)
     *    - Move start of args (idx_args) to valstack bottom
     *      (tail calls)
     *
     *  Don't touch valstack_bottom or valstack_top yet so that Duktape API
     *  calls work normally.
     */
 
    /* XXX: some overlapping code; cleanup */
    use_tailcall = call_flags & DUK_CALL_FLAG_IS_TAILCALL;
#if !defined(DUK_USE_TAILCALL)
    DUK_ASSERT(use_tailcall == 0);  /* compiler ensures this */
#endif
    if (use_tailcall) {
        /* tailcall cannot be flagged to resume calls, and a
         * previous frame must exist
         */
        DUK_ASSERT(thr->callstack_top >= 1);
        DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) == 0);
 
        act = thr->callstack + thr->callstack_top - 1;
        if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
            /* See: test-bug-tailcall-preventyield-assert.c. */
            DUK_DDD(DUK_DDDPRINT("tail call prevented by current activation having DUK_ACT_FLAG_PREVENTYIELD"));
            use_tailcall = 0;
        } else if (DUK_HOBJECT_HAS_NOTAIL(func)) {
            DUK_D(DUK_DPRINT("tail call prevented by function having a notail flag"));
            use_tailcall = 0;
        }
    }
 
    if (use_tailcall) {
        duk_tval *tv1, *tv2;
        duk_size_t cs_index;
        duk_int_t i_stk;  /* must be signed for loop structure */
        duk_idx_t i_arg;
 
        /*
         *  Tailcall handling
         *
         *  Although the callstack entry is reused, we need to explicitly unwind
         *  the current activation (or simulate an unwind).  In particular, the
         *  current activation must be closed, otherwise something like
         *  test-bug-reduce-judofyr.js results.  Also catchstack needs be unwound
         *  because there may be non-error-catching label entries in valid tail calls.
         */
 
        DUK_DDD(DUK_DDDPRINT("is tail call, reusing activation at callstack top, at index %ld",
                             (long) (thr->callstack_top - 1)));
 
        /* 'act' already set above */
 
        DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
        DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(func));
        DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
        DUK_ASSERT((act->flags & DUK_ACT_FLAG_PREVENT_YIELD) == 0);
 
        /* Unwind catchstack entries referring to the callstack entry we're reusing */
        cs_index = thr->callstack_top - 1;
        DUK_ASSERT(thr->catchstack_top <= DUK_INT_MAX);  /* catchstack limits */
        for (i_stk = (duk_int_t) (thr->catchstack_top - 1); i_stk >= 0; i_stk--) {
            duk_catcher *cat = thr->catchstack + i_stk;
            if (cat->callstack_index != cs_index) {
                /* 'i' is the first entry we'll keep */
                break;
            }
        }
        duk_hthread_catchstack_unwind(thr, i_stk + 1);
 
        /* Unwind the topmost callstack entry before reusing it */
        DUK_ASSERT(thr->callstack_top > 0);
        duk_hthread_callstack_unwind(thr, thr->callstack_top - 1);
 
        /* Then reuse the unwound activation; callstack was not shrunk so there is always space */
        thr->callstack_top++;
        DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
        act = thr->callstack + thr->callstack_top - 1;
 
        /* Start filling in the activation */
        act->func = func;  /* don't want an intermediate exposed state with func == NULL */
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
        act->prev_caller = NULL;
#endif
        DUK_ASSERT(func != NULL);
        DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
        /* don't want an intermediate exposed state with invalid pc */
        act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
        act->prev_line = 0;
#endif
        DUK_TVAL_SET_OBJECT(&act->tv_func, func);  /* borrowed, no refcount */
#if defined(DUK_USE_REFERENCE_COUNTING)
        DUK_HOBJECT_INCREF(thr, func);
        act = thr->callstack + thr->callstack_top - 1;  /* side effects (currently none though) */
#endif
 
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
#if defined(DUK_USE_TAILCALL)
#error incorrect options: tail calls enabled with function caller property
#endif
        /* XXX: this doesn't actually work properly for tail calls, so
         * tail calls are disabled when DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
         * is in use.
         */
        duk__update_func_caller_prop(thr, func);
        act = thr->callstack + thr->callstack_top - 1;
#endif
 
        act->flags = (DUK_HOBJECT_HAS_STRICT(func) ?
                      DUK_ACT_FLAG_STRICT | DUK_ACT_FLAG_TAILCALLED :
                      DUK_ACT_FLAG_TAILCALLED);
 
        DUK_ASSERT(DUK_ACT_GET_FUNC(act) == func);      /* already updated */
        DUK_ASSERT(act->var_env == NULL);   /* already NULLed (by unwind) */
        DUK_ASSERT(act->lex_env == NULL);   /* already NULLed (by unwind) */
        act->idx_bottom = entry_valstack_bottom_index;  /* tail call -> reuse current "frame" */
        DUK_ASSERT(nregs >= 0);
#if 0  /* topmost activation idx_retval is considered garbage, no need to init */
        act->idx_retval = 0;
#endif
 
        /*
         *  Manipulate valstack so that args are on the current bottom and the
         *  previous caller's 'this' binding (which is the value preceding the
         *  current bottom) is replaced with the new 'this' binding:
         *
         *       [ ... this_old | (crud) func this_new arg1 ... argN ]
         *  -->  [ ... this_new | arg1 ... argN ]
         *
         *  For tail calling to work properly, the valstack bottom must not grow
         *  here; otherwise crud would accumulate on the valstack.
         */
 
        tv1 = thr->valstack_bottom - 1;
        tv2 = thr->valstack_bottom + idx_func + 1;
        DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);  /* tv1 is -below- valstack_bottom */
        DUK_ASSERT(tv2 >= thr->valstack_bottom && tv2 < thr->valstack_top);
        DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2);  /* side effects */
 
        for (i_arg = 0; i_arg < idx_args; i_arg++) {
            /* XXX: block removal API primitive */
            /* Note: 'func' is popped from valstack here, but it is
             * already reachable from the activation.
             */
            duk_remove(ctx, 0);
        }
        idx_func = 0; DUK_UNREF(idx_func);  /* really 'not applicable' anymore, should not be referenced after this */
        idx_args = 0;
 
        /* [ ... this_new | arg1 ... argN ] */
    } else {
        DUK_DDD(DUK_DDDPRINT("not a tail call, pushing a new activation to callstack, to index %ld",
                             (long) (thr->callstack_top)));
 
        duk_hthread_callstack_grow(thr);
 
        if (call_flags & DUK_CALL_FLAG_IS_RESUME) {
            DUK_DDD(DUK_DDDPRINT("is resume -> no update to current activation (may not even exist)"));
        } else {
            DUK_DDD(DUK_DDDPRINT("update to current activation idx_retval"));
            DUK_ASSERT(thr->callstack_top < thr->callstack_size);
            DUK_ASSERT(thr->callstack_top >= 1);
            act = thr->callstack + thr->callstack_top - 1;
            DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL);
            DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(act)));
            act->idx_retval = entry_valstack_bottom_index + idx_func;
        }
 
        DUK_ASSERT(thr->callstack_top < thr->callstack_size);
        act = thr->callstack + thr->callstack_top;
        thr->callstack_top++;
        DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
 
        DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
        DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(func));
        DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
 
        act->flags = (DUK_HOBJECT_HAS_STRICT(func) ?
                      DUK_ACT_FLAG_STRICT :
                      0);
        act->func = func;
        act->var_env = NULL;
        act->lex_env = NULL;
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
        act->prev_caller = NULL;
#endif
        DUK_ASSERT(func != NULL);
        DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
        act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
        act->prev_line = 0;
#endif
        act->idx_bottom = entry_valstack_bottom_index + idx_args;
        DUK_ASSERT(nregs >= 0);
#if 0  /* topmost activation idx_retval is considered garbage, no need to init */
        act->idx_retval = 0;
#endif
        DUK_TVAL_SET_OBJECT(&act->tv_func, func);  /* borrowed, no refcount */
 
        DUK_HOBJECT_INCREF(thr, func);  /* act->func */
 
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
        duk__update_func_caller_prop(thr, func);
        act = thr->callstack + thr->callstack_top - 1;
#endif
    }
 
    /* [ ... func this arg1 ... argN ]  (not tail call)
     * [ this | arg1 ... argN ]         (tail call)
     *
     * idx_args updated to match
     */
 
    /*
     *  Environment record creation and 'arguments' object creation.
     *  Named function expression name binding is handled by the
     *  compiler; the compiled function's parent env will contain
     *  the (immutable) binding already.
     *
     *  Delayed creation (on demand) is handled in duk_js_var.c.
     */
 
    /* XXX: unify handling with native call. */
 
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));  /* bound function chain has already been resolved */
 
    if (!DUK_HOBJECT_HAS_NEWENV(func)) {
        /* use existing env (e.g. for non-strict eval); cannot have
         * an own 'arguments' object (but can refer to the existing one)
         */
 
        duk__handle_oldenv_for_call(thr, func, act);
        /* No need to re-lookup 'act' at present: no side effects. */
 
        DUK_ASSERT(act->lex_env != NULL);
        DUK_ASSERT(act->var_env != NULL);
        goto env_done;
    }
 
    DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
 
    if (!DUK_HOBJECT_HAS_CREATEARGS(func)) {
        /* no need to create environment record now; leave as NULL */
        DUK_ASSERT(act->lex_env == NULL);
        DUK_ASSERT(act->var_env == NULL);
        goto env_done;
    }
 
    /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */
    env = duk_create_activation_environment_record(thr, func, act->idx_bottom);
    DUK_ASSERT(env != NULL);
 
    /* [ ... arg1 ... argN envobj ] */
 
    /* original input stack before nargs/nregs handling must be
     * intact for 'arguments' object
     */
    DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func));
    duk__handle_createargs_for_call(thr, func, env, num_stack_args);
 
    /* [ ... arg1 ... argN envobj ] */
 
    act = thr->callstack + thr->callstack_top - 1;
    act->lex_env = env;
    act->var_env = env;
    DUK_HOBJECT_INCREF(thr, act->lex_env);
    DUK_HOBJECT_INCREF(thr, act->var_env);
    duk_pop(ctx);
 
 env_done:
    /* [ ... arg1 ... argN ] */
 
    /*
     *  Setup value stack: clamp to 'nargs', fill up to 'nregs'
     */
 
    duk__adjust_valstack_and_top(thr,
                                 num_stack_args,
                                 idx_args,
                                 nregs,
                                 nargs,
                                 func);
 

References duk_hthread::callstack, duk_catcher::callstack_index, duk_hthread::callstack_size, duk_hthread::callstack_top, duk_hthread::catchstack, duk_hthread::catchstack_top, duk_activation::curr_pc, duk_heap::curr_thread, duk__adjust_valstack_and_top(), duk__coerce_effective_this_binding(), duk__handle_createargs_for_call(), duk__handle_oldenv_for_call(), duk__nonbound_func_lookup(), DUK_ACT_FLAG_PREVENT_YIELD, DUK_ACT_FLAG_STRICT, DUK_ACT_FLAG_TAILCALLED, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CALL_FLAG_IS_RESUME, DUK_CALL_FLAG_IS_TAILCALL, DUK_CAT_GET_TYPE, DUK_CAT_TYPE_LABEL, duk_create_activation_environment_record(), DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, DUK_ERROR_API, duk_get_tval(), DUK_HCOMPILEDFUNCTION_GET_CODE_BASE, DUK_HOBJECT_HAS_BOUND, DUK_HOBJECT_HAS_COMPILEDFUNCTION, DUK_HOBJECT_HAS_CREATEARGS, DUK_HOBJECT_HAS_NATIVEFUNCTION, DUK_HOBJECT_HAS_NEWENV, DUK_HOBJECT_HAS_NOTAIL, DUK_HOBJECT_HAS_STRICT, DUK_HOBJECT_INCREF, DUK_HOBJECT_IS_COMPILEDFUNCTION, duk_hthread_callstack_grow(), duk_hthread_callstack_unwind(), duk_hthread_catchstack_unwind(), DUK_HTHREAD_STATE_RUNNING, duk_hthread_sync_and_null_currpc(), DUK_INT_MAX, duk_normalize_index(), duk_pop(), duk_remove(), DUK_STR_INVALID_CALL_ARGS, DUK_TVAL_SET_OBJECT, DUK_TVAL_SET_TVAL_UPDREF, DUK_UNLIKELY, DUK_UNREF, duk_activation::flags, duk_activation::func, duk_hthread::heap, duk_activation::idx_bottom, duk_activation::idx_retval, duk_activation::lex_env, NULL, duk_hthread::ptr_curr_pc, duk_hthread::state, duk_activation::tv_func, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, duk_hthread::valstack_top, and duk_activation::var_env.

◆ duk_handle_safe_call()

DUK_INTERNAL_DECL duk_int_t duk_handle_safe_call	(	duk_hthread *	thr,
		duk_safe_call_function	func,
		duk_idx_t	num_stack_args,
		duk_idx_t	num_stack_res )

Definition at line 56858 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_context *ctx = (duk_context *) thr;
    duk_size_t entry_valstack_bottom_index;
    duk_size_t entry_callstack_top;
    duk_size_t entry_catchstack_top;
    duk_int_t entry_call_recursion_depth;
    duk_hthread *entry_curr_thread;
    duk_uint_fast8_t entry_thread_state;
    duk_instr_t **entry_ptr_curr_pc;
    duk_jmpbuf *old_jmpbuf_ptr = NULL;
    duk_jmpbuf our_jmpbuf;
    duk_idx_t idx_retbase;
    duk_int_t retval;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
 
    /* Note: careful with indices like '-x'; if 'x' is zero, it refers to bottom */
    entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
    entry_callstack_top = thr->callstack_top;
    entry_catchstack_top = thr->catchstack_top;
    entry_call_recursion_depth = thr->heap->call_recursion_depth;
    entry_curr_thread = thr->heap->curr_thread;  /* Note: may be NULL if first call */
    entry_thread_state = thr->state;
    entry_ptr_curr_pc = thr->ptr_curr_pc;  /* may be NULL */
    idx_retbase = duk_get_top(ctx) - num_stack_args;  /* Note: not a valid stack index if num_stack_args == 0 */
 
    /* Note: cannot portably debug print a function pointer, hence 'func' not printed! */
    DUK_DD(DUK_DDPRINT("duk_handle_safe_call: thr=%p, num_stack_args=%ld, num_stack_rets=%ld, "
                       "valstack_top=%ld, idx_retbase=%ld, rec_depth=%ld/%ld, "
                       "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
                       "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
                       (void *) thr,
                       (long) num_stack_args,
                       (long) num_stack_rets,
                       (long) duk_get_top(ctx),
                       (long) idx_retbase,
                       (long) thr->heap->call_recursion_depth,
                       (long) thr->heap->call_recursion_limit,
                       (long) entry_valstack_bottom_index,
                       (long) entry_callstack_top,
                       (long) entry_catchstack_top,
                       (long) entry_call_recursion_depth,
                       (void *) entry_curr_thread,
                       (long) entry_thread_state));
 
    if (idx_retbase < 0) {
        /* Since stack indices are not reliable, we can't do anything useful
         * here.  Invoke the existing setjmp catcher, or if it doesn't exist,
         * call the fatal error handler.
         */
 
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    }
 
    /* setjmp catchpoint setup */
 
    old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
    thr->heap->lj.jmpbuf_ptr = &our_jmpbuf;
 
#if defined(DUK_USE_CPP_EXCEPTIONS)
    try {
#else
    DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == &our_jmpbuf);
    if (DUK_SETJMP(our_jmpbuf.jb) == 0) {
        /* Success path. */
#endif
        DUK_DDD(DUK_DDDPRINT("safe_call setjmp catchpoint setup complete"));
 
        duk__handle_safe_call_inner(thr,
                                    func,
                                    idx_retbase,
                                    num_stack_rets,
                                    entry_valstack_bottom_index,
                                    entry_callstack_top,
                                    entry_catchstack_top);
 
        /* Longjmp state is kept clean in success path */
        DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
        DUK_ASSERT(thr->heap->lj.iserror == 0);
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
 
        /* Note: either pointer may be NULL (at entry), so don't assert */
        thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
 
        retval = DUK_EXEC_SUCCESS;
#if defined(DUK_USE_CPP_EXCEPTIONS)
    } catch (duk_internal_exception &exc) {
        DUK_UNREF(exc);
#else
    } else {
        /* Error path. */
#endif
        duk__handle_safe_call_error(thr,
                                    idx_retbase,
                                    num_stack_rets,
                                    entry_valstack_bottom_index,
                                    entry_callstack_top,
                                    entry_catchstack_top,
                                    old_jmpbuf_ptr);
 
        /* Longjmp state is cleaned up by error handling */
        DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
        DUK_ASSERT(thr->heap->lj.iserror == 0);
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
 
        retval = DUK_EXEC_ERROR;
    }
#if defined(DUK_USE_CPP_EXCEPTIONS)
    catch (std::exception &exc) {
        const char *what = exc.what();
        if (!what) {
            what = "unknown";
        }
        DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)"));
        try {
            DUK_ERROR_FMT1(thr, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what);
        } catch (duk_internal_exception exc) {
            DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception"));
            DUK_UNREF(exc);
            duk__handle_safe_call_error(thr,
                                        idx_retbase,
                                        num_stack_rets,
                                        entry_valstack_bottom_index,
                                        entry_callstack_top,
                                        entry_catchstack_top,
                                        old_jmpbuf_ptr);
            retval = DUK_EXEC_ERROR;
        }
    } catch (...) {
        DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)"));
        try {
            DUK_ERROR_API(thr, "caught invalid c++ exception (perhaps thrown by user code)");
        } catch (duk_internal_exception exc) {
            DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception"));
            DUK_UNREF(exc);
            duk__handle_safe_call_error(thr,
                                        idx_retbase,
                                        num_stack_rets,
                                        entry_valstack_bottom_index,
                                        entry_callstack_top,
                                        entry_catchstack_top,
                                        old_jmpbuf_ptr);

◆ duk_has_prop()

DUK_EXTERNAL duk_bool_t duk_has_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14601 of file duktape-1.8.0/src/duktape.c.

                                                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(stridx >= 0);
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    DUK_UNREF(thr);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
    return duk_del_prop(ctx, obj_index);
}
 
DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk_has_prop_stridx().

◆ duk_has_prop_index()

DUK_EXTERNAL duk_bool_t duk_has_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14632 of file duktape-1.8.0/src/duktape.c.

◆ duk_has_prop_stridx()

DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx )

Definition at line 14640 of file duktape-1.8.0/src/duktape.c.

                                                                                                    {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(key != NULL);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    duk_push_string(ctx, key);
    return duk_has_prop(ctx, obj_index);
}
 
DUK_EXTERNAL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
    DUK_ASSERT_CTX_VALID(ctx);
 

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_has_prop(), duk_push_string(), duk_require_normalize_index(), and NULL.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ duk_has_prop_string()

DUK_EXTERNAL duk_bool_t duk_has_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14623 of file duktape-1.8.0/src/duktape.c.

◆ duk_has_var()

DUK_EXTERNAL duk_bool_t duk_has_var ( duk_context * ctx )

Definition at line 20206 of file duktape-1.8.0/src/duktape.c.

◆ duk_hbuffer_alloc()

DUK_INTERNAL_DECL duk_hbuffer * duk_hbuffer_alloc	(	duk_heap *	heap,
		duk_size_t	size,
		duk_small_uint_t	flags,
		void **	out_bufdata )

Definition at line 40782 of file duktape-1.8.0/src/duktape.c.

                                                                                                                         {
    duk_hbuffer *res = NULL;
    duk_size_t header_size;
    duk_size_t alloc_size;
 
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(out_bufdata != NULL);
 
    DUK_DDD(DUK_DDDPRINT("allocate hbuffer"));
 
    /* Size sanity check.  Should not be necessary because caller is
     * required to check this, but we don't want to cause a segfault
     * if the size wraps either in duk_size_t computation or when
     * storing the size in a 16-bit field.
     */
    if (size > DUK_HBUFFER_MAX_BYTELEN) {
        DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size));
        return NULL;  /* no need to write 'out_bufdata' */
    }
 
    if (flags & DUK_BUF_FLAG_EXTERNAL) {
        header_size = sizeof(duk_hbuffer_external);
        alloc_size = sizeof(duk_hbuffer_external);
    } else if (flags & DUK_BUF_FLAG_DYNAMIC) {
        header_size = sizeof(duk_hbuffer_dynamic);
        alloc_size = sizeof(duk_hbuffer_dynamic);
    } else {
        header_size = sizeof(duk_hbuffer_fixed);
        alloc_size = sizeof(duk_hbuffer_fixed) + size;
        DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed));  /* no wrapping */
    }
 
    res = (duk_hbuffer *) DUK_ALLOC(heap, alloc_size);
    if (!res) {
        goto error;
    }
 
    /* zero everything unless requested not to do so */
#if defined(DUK_USE_ZERO_BUFFER_DATA)
    DUK_MEMZERO((void *) res,
                (flags & DUK_BUF_FLAG_NOZERO) ? header_size : alloc_size);
#else
    DUK_MEMZERO((void *) res, header_size);
#endif
 
    if (flags & DUK_BUF_FLAG_EXTERNAL) {
        duk_hbuffer_external *h;
        h = (duk_hbuffer_external *) res;
        DUK_UNREF(h);
        *out_bufdata = NULL;
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
#if defined(DUK_USE_HEAPPTR16)
/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
#else
        DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, h, NULL);
#endif
#endif
        DUK_ASSERT(DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, h) == NULL);
    } else if (flags & DUK_BUF_FLAG_DYNAMIC) {
        duk_hbuffer_dynamic *h = (duk_hbuffer_dynamic *) res;
        void *ptr;
 
        if (size > 0) {
            DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL));  /* alloc external with size zero */
            DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer"));
#ifdef DUK_USE_ZERO_BUFFER_DATA
            ptr = DUK_ALLOC_ZEROED(heap, size);
#else
            ptr = DUK_ALLOC(heap, size);
#endif
            if (!ptr) {
                /* Because size > 0, NULL check is correct */
                goto error;
            }
            *out_bufdata = ptr;
 
            DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, ptr);
        } else {
            *out_bufdata = NULL;
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
#if defined(DUK_USE_HEAPPTR16)
/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
#else
            DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, NULL);
#endif
#endif
            DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, h) == NULL);
        }
    } else {
        *out_bufdata = (void *) ((duk_hbuffer_fixed *) res + 1);
    }
 
    DUK_HBUFFER_SET_SIZE(res, size);
 
    DUK_HEAPHDR_SET_TYPE(&res->hdr, DUK_HTYPE_BUFFER);
    if (flags & DUK_BUF_FLAG_DYNAMIC) {
        DUK_HBUFFER_SET_DYNAMIC(res);

◆ duk_hbuffer_get_dynalloc_ptr()

DUK_INTERNAL_DECL void * duk_hbuffer_get_dynalloc_ptr	(	duk_heap *	heap,
		void *	ud )

Definition at line 40899 of file duktape-1.8.0/src/duktape.c.

           {
        DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL));
    }
        DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr);
 

Referenced by duk_hbuffer_resize().

◆ duk_hbuffer_reset()

DUK_INTERNAL_DECL void duk_hbuffer_reset	(	duk_hthread *	thr,
		duk_hbuffer_dynamic *	buf )

Definition at line 40979 of file duktape-1.8.0/src/duktape.c.

                                  {
            DUK_ASSERT(new_size - prev_size > 0);
#ifdef DUK_USE_ZERO_BUFFER_DATA
            DUK_MEMZERO((void *) ((char *) res + prev_size),
                        (duk_size_t) (new_size - prev_size));
#endif
        }
 

References DUK_ASSERT, and DUK_MEMZERO.

◆ duk_hbuffer_resize()

DUK_INTERNAL_DECL void duk_hbuffer_resize	(	duk_hthread *	thr,
		duk_hbuffer_dynamic *	buf,
		duk_size_t	new_size )

Definition at line 40922 of file duktape-1.8.0/src/duktape.c.

                                                                                                      {
    void *res;
    duk_size_t prev_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(buf != NULL);
    DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
    DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf));
 
    /*
     *  Maximum size check
     */
 
    if (new_size > DUK_HBUFFER_MAX_BYTELEN) {
        DUK_ERROR_RANGE(thr, "buffer too long");
    }
 
    /*
     *  Note: use indirect realloc variant just in case mark-and-sweep
     *  (finalizers) might resize this same buffer during garbage
     *  collection.
     */
 
    res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_size);
    if (res != NULL || new_size == 0) {
        /* 'res' may be NULL if new allocation size is 0. */
 
        DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld -> %p:%ld",
                             (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf),
                             (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf),
                             (void *) res,
                             (long) new_size));
 
        /*
         *  The entire allocated buffer area, regardless of actual used
         *  size, is kept zeroed in resizes for simplicity.  If the buffer
         *  is grown, zero the new part.
         */
 

References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_RANGE, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR, DUK_HBUFFER_DYNAMIC_GET_SIZE, duk_hbuffer_get_dynalloc_ptr(), DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_HBUFFER_MAX_BYTELEN, DUK_REALLOC_INDIRECT, duk_hthread::heap, and NULL.

Referenced by duk__appendbuffer().

◆ duk_hbufferobject_alloc()

DUK_INTERNAL duk_hbufferobject * duk_hbufferobject_alloc	(	duk_heap *	heap,
		duk_uint_t	hobject_flags )

Definition at line 46299 of file duktape-1.8.0/src/duktape.c.

              {
        return NULL;
    }
    DUK_MEMZERO(res, sizeof(duk_hnativefunction));
 
    duk__init_object_parts(heap, &res->obj, hobject_flags);
 
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    res->func = NULL;
#endif
 
    return res;
}
 
DUK_INTERNAL duk_hbufferobject *duk_hbufferobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) {

References NULL.

◆ duk_hbufferobject_clamp_bytelength()

DUK_INTERNAL_DECL duk_uint_t duk_hbufferobject_clamp_bytelength	(	duk_hbufferobject *	h_bufobj,
		duk_uint_t	len )

Definition at line 40991 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(buf != NULL);
    DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
    DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf));
 
    duk_hbuffer_resize(thr, buf, 0);
}
/* include removed: duk_internal.h */
#line 2 "duk_hbufferobject_misc.c"
 

◆ duk_hbufferobject_push_validated_read()

DUK_INTERNAL_DECL void duk_hbufferobject_push_validated_read	(	duk_context *	ctx,
		duk_hbufferobject *	h_bufobj,
		duk_uint8_t *	p,
		duk_small_uint_t	elem_size )

Definition at line 22121 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                   {
    duk_double_union du;
 
    DUK_MEMCPY((void *) du.uc, (const void *) p, (size_t) elem_size);
 
    switch (h_bufobj->elem_type) {
    case DUK_HBUFFEROBJECT_ELEM_UINT8:
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
    case DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED:
#endif
        duk_push_uint(ctx, (duk_uint_t) du.uc[0]);
        break;
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
    /* These are not needed when only Duktape.Buffer is supported. */
    case DUK_HBUFFEROBJECT_ELEM_INT8:
        duk_push_int(ctx, (duk_int_t) (duk_int8_t) du.uc[0]);
        break;
    case DUK_HBUFFEROBJECT_ELEM_UINT16:
        duk_push_uint(ctx, (duk_uint_t) du.us[0]);
        break;
    case DUK_HBUFFEROBJECT_ELEM_INT16:
        duk_push_int(ctx, (duk_int_t) (duk_int16_t) du.us[0]);
        break;

Referenced by duk__get_own_propdesc_raw(), and duk_bi_typedarray_set().

◆ duk_hbufferobject_validated_write()

DUK_INTERNAL_DECL void duk_hbufferobject_validated_write	(	duk_context *	ctx,
		duk_hbufferobject *	h_bufobj,
		duk_uint8_t *	p,
		duk_small_uint_t	elem_size )

Definition at line 22162 of file duktape-1.8.0/src/duktape.c.

                                     :
        duk_push_int(ctx, (duk_int_t) (duk_int32_t) du.ui[0]);
        break;
    case DUK_HBUFFEROBJECT_ELEM_FLOAT32:
        duk_push_number(ctx, (duk_double_t) du.f[0]);
        break;
    case DUK_HBUFFEROBJECT_ELEM_FLOAT64:
        duk_push_number(ctx, (duk_double_t) du.d);
        break;
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
    default:
        DUK_UNREACHABLE();
    }
}
 
DUK_INTERNAL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size) {
    duk_double_union du;
 
    /* NOTE! Caller must ensure that any side effects from the
     * coercions below are safe.  If that cannot be guaranteed
     * (which is normally the case), caller must coerce the
     * argument using duk_to_number() before any pointer
     * validations; the result of duk_to_number() always coerces
     * without side effects here.
     */
 
    switch (h_bufobj->elem_type) {
    case DUK_HBUFFEROBJECT_ELEM_UINT8:
        du.uc[0] = (duk_uint8_t) duk_to_uint32(ctx, -1);
        break;
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
    /* These are not needed when only Duktape.Buffer is supported. */
    case DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED:
        du.uc[0] = (duk_uint8_t) duk_to_uint8clamped(ctx, -1);
        break;
    case DUK_HBUFFEROBJECT_ELEM_INT8:
        du.uc[0] = (duk_uint8_t) duk_to_int32(ctx, -1);
        break;
    case DUK_HBUFFEROBJECT_ELEM_UINT16:
        du.us[0] = (duk_uint16_t) duk_to_uint32(ctx, -1);
        break;
    case DUK_HBUFFEROBJECT_ELEM_INT16:
        du.us[0] = (duk_uint16_t) duk_to_int32(ctx, -1);
        break;
    case DUK_HBUFFEROBJECT_ELEM_UINT32:
        du.ui[0] = (duk_uint32_t) duk_to_uint32(ctx, -1);

Referenced by duk_bi_typedarray_set(), and duk_hobject_putprop().

◆ duk_hcompiledfunction_alloc()

DUK_INTERNAL_DECL duk_hcompiledfunction * duk_hcompiledfunction_alloc	(	duk_heap *	heap,
		duk_uint_t	hobject_flags )

Definition at line 46257 of file duktape-1.8.0/src/duktape.c.

              {
        return NULL;
    }
    DUK_MEMZERO(res, sizeof(duk_hobject));
 
    duk__init_object_parts(heap, res, hobject_flags);
 
    return res;
}
 
DUK_INTERNAL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
    duk_hcompiledfunction *res;
 
    res = (duk_hcompiledfunction *) DUK_ALLOC(heap, sizeof(duk_hcompiledfunction));
    if (!res) {
        return NULL;

◆ duk_heap_alloc()

DUK_INTERNAL_DECL duk_heap * duk_heap_alloc	(	duk_alloc_function	alloc_func,
		duk_realloc_function	realloc_func,
		duk_free_function	free_func,
		void *	heap_udata,
		duk_fatal_function	fatal_func )

Definition at line 41739 of file duktape-1.8.0/src/duktape.c.

                                        : big"));
#else
    DUK_D(DUK_DPRINT("integer endianness: ???"));
#endif
#if defined(DUK_USE_DOUBLE_LE)
    DUK_D(DUK_DPRINT("IEEE double endianness: little"));
#elif defined(DUK_USE_DOUBLE_ME)
    DUK_D(DUK_DPRINT("IEEE double endianness: mixed"));
#elif defined(DUK_USE_DOUBLE_BE)
    DUK_D(DUK_DPRINT("IEEE double endianness: big"));
#else
    DUK_D(DUK_DPRINT("IEEE double endianness: ???"));
#endif
}
#endif  /* DUK_USE_DEBUG */
 
DUK_INTERNAL
duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
                         duk_realloc_function realloc_func,
                         duk_free_function free_func,
                         void *heap_udata,
                         duk_fatal_function fatal_func) {
    duk_heap *res = NULL;
 
    /* Silence a few global unused warnings here. */
    DUK_UNREF(duk_str_unsupported);
 
    DUK_D(DUK_DPRINT("allocate heap"));
 
    /*
     *  Debug dump type sizes
     */
 
#if defined(DUK_USE_DEBUG)
    duk__dump_misc_options();
    duk__dump_type_sizes();
    duk__dump_type_limits();
#endif
 
    /*
     *  If selftests enabled, run them as early as possible
     */
#if defined(DUK_USE_SELF_TESTS)
    DUK_D(DUK_DPRINT("running self tests"));
    duk_selftest_run_tests();
    DUK_D(DUK_DPRINT("self tests passed"));
#endif
 
    /*
     *  Computed values (e.g. INFINITY)
     */
 
#if defined(DUK_USE_COMPUTED_NAN)
    do {
        /* Workaround for some exotic platforms where NAN is missing
         * and the expression (0.0 / 0.0) does NOT result in a NaN.
         * Such platforms use the global 'duk_computed_nan' which must
         * be initialized at runtime.  Use 'volatile' to ensure that
         * the compiler will actually do the computation and not try
         * to do constant folding which might result in the original
         * problem.
         */
        volatile double dbl1 = 0.0;
        volatile double dbl2 = 0.0;
        duk_computed_nan = dbl1 / dbl2;
    } while (0);
#endif
 
#if defined(DUK_USE_COMPUTED_INFINITY)
    do {
        /* Similar workaround for INFINITY. */
        volatile double dbl1 = 1.0;
        volatile double dbl2 = 0.0;
        duk_computed_infinity = dbl1 / dbl2;
    } while (0);
#endif
 
    /*
     *  Allocate heap struct
     *
     *  Use a raw call, all macros expect the heap to be initialized
     */
 
    res = (duk_heap *) alloc_func(heap_udata, sizeof(duk_heap));
    if (!res) {
        goto error;
    }
 
    /*
     *  Zero the struct, and start initializing roughly in order
     */
 
    DUK_MEMZERO(res, sizeof(*res));
 
    /* explicit NULL inits */
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    res->heap_udata = NULL;
    res->heap_allocated = NULL;
#if defined(DUK_USE_REFERENCE_COUNTING)
    res->refzero_list = NULL;
    res->refzero_list_tail = NULL;
#endif
#if defined(DUK_USE_MARK_AND_SWEEP)
    res->finalize_list = NULL;
#endif
    res->heap_thread = NULL;
    res->curr_thread = NULL;
    res->heap_object = NULL;
#if defined(DUK_USE_STRTAB_CHAIN)
    /* nothing to NULL */
#elif defined(DUK_USE_STRTAB_PROBE)
#if defined(DUK_USE_HEAPPTR16)
    res->strtable16 = (duk_uint16_t *) NULL;
#else
    res->strtable = (duk_hstring **) NULL;
#endif
#endif
#if defined(DUK_USE_ROM_STRINGS)
    /* no res->strs[] */
#else  /* DUK_USE_ROM_STRINGS */
#if defined(DUK_USE_HEAPPTR16)
    /* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */
#else
    {
        duk_small_uint_t i;
            for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
            res->strs[i] = NULL;
            }
    }
#endif
#endif  /* DUK_USE_ROM_STRINGS */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    res->dbg_read_cb = NULL;
    res->dbg_write_cb = NULL;
    res->dbg_peek_cb = NULL;
    res->dbg_read_flush_cb = NULL;
    res->dbg_write_flush_cb = NULL;
    res->dbg_request_cb = NULL;
    res->dbg_udata = NULL;
    res->dbg_step_thread = NULL;
#endif
#endif  /* DUK_USE_EXPLICIT_NULL_INIT */
 
    res->alloc_func = alloc_func;
    res->realloc_func = realloc_func;
    res->free_func = free_func;
    res->heap_udata = heap_udata;
    res->fatal_func = fatal_func;
 
#if defined(DUK_USE_HEAPPTR16)
    /* XXX: zero assumption */
    res->heapptr_null16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) NULL);
    res->heapptr_deleted16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) DUK_STRTAB_DELETED_MARKER(res));
#endif
 
    /* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */
 
    res->call_recursion_depth = 0;
    res->call_recursion_limit = DUK_USE_NATIVE_CALL_RECLIMIT;
 
    /* XXX: use the pointer as a seed for now: mix in time at least */
 
    /* The casts through duk_intr_pt is to avoid the following GCC warning:
     *
     *   warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
     *
     * This still generates a /Wp64 warning on VS2010 when compiling for x86.
     */
#if defined(DUK_USE_ROM_STRINGS)
    /* XXX: make a common DUK_USE_ option, and allow custom fixed seed? */
    DUK_D(DUK_DPRINT("using rom strings, force heap hash_seed to fixed value 0x%08lx", (long) DUK__FIXED_HASH_SEED));
    res->hash_seed = (duk_uint32_t) DUK__FIXED_HASH_SEED;
#else  /* DUK_USE_ROM_STRINGS */
    res->hash_seed = (duk_uint32_t) (duk_intptr_t) res;
#if !defined(DUK_USE_STRHASH_DENSE)
    res->hash_seed ^= 5381;  /* Bernstein hash init value is normally 5381; XOR it in in case pointer low bits are 0 */
#endif
#endif  /* DUK_USE_ROM_STRINGS */
    res->rnd_state = (duk_uint32_t) (duk_intptr_t) res;
 
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    res->lj.jmpbuf_ptr = NULL;
#endif
    DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN);  /* zero */
 
    DUK_TVAL_SET_UNDEFINED(&res->lj.value1);
    DUK_TVAL_SET_UNDEFINED(&res->lj.value2);
 
#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME)
#error initial heap stringtable size is defined incorrectly
#endif
 
    /*
     *  Init stringtable: fixed variant
     */
 
#if defined(DUK_USE_STRTAB_CHAIN)
    DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE);
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    {
        duk_small_uint_t i;
            for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
#if defined(DUK_USE_HEAPPTR16)
            res->strtable[i].u.str16 = res->heapptr_null16;
#else
            res->strtable[i].u.str = NULL;
#endif
            }
    }
#endif  /* DUK_USE_EXPLICIT_NULL_INIT */
#endif  /* DUK_USE_STRTAB_CHAIN */
 
    /*
     *  Init stringtable: probe variant
     */
 
#if defined(DUK_USE_STRTAB_PROBE)
#if defined(DUK_USE_HEAPPTR16)
    res->strtable16 = (duk_uint16_t *) alloc_func(heap_udata, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
    if (!res->strtable16) {
        goto error;
    }
#else  /* DUK_USE_HEAPPTR16 */
    res->strtable = (duk_hstring **) alloc_func(heap_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
    if (!res->strtable) {
        goto error;
    }
#endif  /* DUK_USE_HEAPPTR16 */
    res->st_size = DUK_STRTAB_INITIAL_SIZE;
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    {
        duk_small_uint_t i;
        DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE);
            for (i = 0; i < DUK_STRTAB_INITIAL_SIZE; i++) {
#if defined(DUK_USE_HEAPPTR16)
            res->strtable16[i] = res->heapptr_null16;
#else
            res->strtable[i] = NULL;
#endif
            }
    }
#else  /* DUK_USE_EXPLICIT_NULL_INIT */
#if defined(DUK_USE_HEAPPTR16)
    DUK_MEMZERO(res->strtable16, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
#else
    DUK_MEMZERO(res->strtable, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
#endif
#endif  /* DUK_USE_EXPLICIT_NULL_INIT */
#endif  /* DUK_USE_STRTAB_PROBE */
 
    /*
     *  Init stringcache
     */
 
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
    {
        duk_small_uint_t i;
        for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
            res->strcache[i].h = NULL;
        }
    }
#endif
 
    /* XXX: error handling is incomplete.  It would be cleanest if
     * there was a setjmp catchpoint, so that all init code could
     * freely throw errors.  If that were the case, the return code
     * passing here could be removed.
     */
 
    /*
     *  Init built-in strings
     */
 
    DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS"));
    if (!duk__init_heap_strings(res)) {
        goto error;
    }
 
    /*
     *  Init the heap thread
     */
 
    DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD"));
    if (!duk__init_heap_thread(res)) {
        goto error;
    }
 
    DUK_ASSERT(res->heap_thread != NULL);
    res->rnd_state ^= (duk_uint32_t) DUK_USE_DATE_GET_NOW((duk_context *) res->heap_thread);
 
    /*
     *  Init the heap object
     */
 
    DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT"));
    DUK_ASSERT(res->heap_thread != NULL);
    res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE |
                                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT));
    if (!res->heap_object) {
        goto error;
    }
    DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object);
 
    /*
     *  All done
     */
 

◆ duk_heap_force_strtab_resize()

DUK_INTERNAL_DECL void duk_heap_force_strtab_resize ( duk_heap * heap )

Definition at line 46058 of file duktape-1.8.0/src/duktape.c.

                                                               {
    duk_small_uint_t prev_mark_and_sweep_base_flags;
    /* Force a resize so that DELETED entries are eliminated.

◆ duk_heap_free()

DUK_INTERNAL_DECL void duk_heap_free ( duk_heap * heap )

Definition at line 41280 of file duktape-1.8.0/src/duktape.c.

                                  {
            DUK_D(DUK_DPRINT("no more finalizable objects, forced finalization finished"));
            break;
        }
        if (count_finalized >= curr_limit) {
            DUK_D(DUK_DPRINT("finalizer count above limit, potentially runaway finalizer; skip remaining finalizers"));
            break;
        }
    }
 
    DUK_ASSERT(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap));
    DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap);
}
 
DUK_INTERNAL void duk_heap_free(duk_heap *heap) {
    DUK_D(DUK_DPRINT("free heap: %p", (void *) heap));
 
#if defined(DUK_USE_DEBUG)
    duk_heap_dump_strtab(heap);
#endif
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    /* Detach a debugger if attached (can be called multiple times)
     * safely.
     */
    /* XXX: Add a flag to reject an attempt to re-attach?  Otherwise
     * the detached callback may immediately reattach.
     */
    duk_debug_do_detach(heap);
#endif
 
    /* Execute finalizers before freeing the heap, even for reachable
     * objects, and regardless of whether or not mark-and-sweep is
     * enabled.  This gives finalizers the chance to free any native
     * resources like file handles, allocations made outside Duktape,
     * etc.  This is quite tricky to get right, so that all finalizer
     * guarantees are honored.
     *
     * XXX: this perhaps requires an execution time limit.
     */
    DUK_D(DUK_DPRINT("execute finalizers before freeing heap"));
#if defined(DUK_USE_MARK_AND_SWEEP)
    /* Run mark-and-sweep a few times just in case (unreachable object
     * finalizers run already here).  The last round must rescue objects
     * from the previous round without running any more finalizers.  This
     * ensures rescued objects get their FINALIZED flag cleared so that
     * their finalizer is called once more in forced finalization to
     * satisfy finalizer guarantees.  However, we don't want to run any
     * more finalizer because that'd required one more loop, and so on.
     */
    DUK_D(DUK_DPRINT("forced gc #1 in heap destruction"));
    duk_heap_mark_and_sweep(heap, 0);
    DUK_D(DUK_DPRINT("forced gc #2 in heap destruction"));
    duk_heap_mark_and_sweep(heap, 0);
    DUK_D(DUK_DPRINT("forced gc #3 in heap destruction (don't run finalizers)"));
    duk_heap_mark_and_sweep(heap, DUK_MS_FLAG_SKIP_FINALIZERS);  /* skip finalizers; queue finalizable objects to heap_allocated */
#endif
 
    DUK_HEAP_SET_FINALIZER_NORESCUE(heap);  /* rescue no longer supported */
    duk__free_run_finalizers(heap);
 
    /* Note: heap->heap_thread, heap->curr_thread, and heap->heap_object
     * are on the heap allocated list.
     */
 
    DUK_D(DUK_DPRINT("freeing heap objects of heap: %p", (void *) heap));
    duk__free_allocated(heap);

◆ duk_heap_free_heaphdr_raw()

DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw	(	duk_heap *	heap,
		duk_heaphdr *	hdr )

Definition at line 41095 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(h != NULL);
 
    DUK_UNREF(heap);
    DUK_UNREF(h);
 
#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_FREE)
    if (DUK_HSTRING_HAS_EXTDATA(h)) {
        DUK_DDD(DUK_DDDPRINT("free extstr: hstring %!O, extdata: %p",
                             h, DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h)));
        DUK_USE_EXTSTR_FREE(heap->heap_udata, (const void *) DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h));
    }
#endif
}
 
DUK_INTERNAL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr) {
    DUK_ASSERT(heap);
    DUK_ASSERT(hdr);
 
    DUK_DDD(DUK_DDDPRINT("free heaphdr %p, htype %ld", (void *) hdr, (long) DUK_HEAPHDR_GET_TYPE(hdr)));

References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_HSTRING_HAS_EXTDATA, DUK_UNREF, duk_heap::heap_udata, and NULL.

Referenced by duk__free_markandsweep_finalize_list(), duk__free_refzero_list(), and duk__free_run_finalizers().

◆ duk_heap_free_strtab()

DUK_INTERNAL void duk_heap_free_strtab ( duk_heap * heap )

Definition at line 46144 of file duktape-1.8.0/src/duktape.c.

                           {
                duk_free_hstring_inner(heap, h);
                DUK_FREE(heap, h);
            }
        }
        e->listlen = 0;
    }
}
#endif  /* DUK_USE_STRTAB_CHAIN */
 
#if defined(DUK_USE_STRTAB_PROBE)
DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
    duk_uint_fast32_t i;
    duk_hstring *h;
 
#if defined(DUK_USE_HEAPPTR16)
    if (heap->strtable16) {
#else
    if (heap->strtable) {
#endif
        for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
#if defined(DUK_USE_HEAPPTR16)
            h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
#else
            h = heap->strtable[i];
#endif
            if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
                continue;
            }
            DUK_ASSERT(h != NULL);
 

◆ duk_heap_hashstring()

DUK_INTERNAL_DECL duk_uint32_t duk_heap_hashstring	(	duk_heap *	heap,
		const duk_uint8_t *	str,
		duk_size_t	len )

Definition at line 42142 of file duktape-1.8.0/src/duktape.c.

                                                                                                      {
    duk_uint32_t hash;
    duk_size_t step;
    duk_size_t off;
 
    /* Slightly modified "Bernstein hash" from:
     *
     *     http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
     *
     * Modifications: string skipping and reverse direction similar to
     * Lua 5.1.5, and different hash initializer.
     *
     * The reverse direction ensures last byte it always included in the
     * hash which is a good default as changing parts of the string are
     * more often in the suffix than in the prefix.

◆ duk_heap_insert_into_heap_allocated()

DUK_INTERNAL_DECL void duk_heap_insert_into_heap_allocated	(	duk_heap *	heap,
		duk_heaphdr *	hdr )

Definition at line 44033 of file duktape-1.8.0/src/duktape.c.

           {
        heap->heap_allocated = DUK_HEAPHDR_GET_NEXT(heap, hdr);
    }
    if (DUK_HEAPHDR_GET_NEXT(heap, hdr)) {
        DUK_HEAPHDR_SET_PREV(heap, DUK_HEAPHDR_GET_NEXT(heap, hdr), DUK_HEAPHDR_GET_PREV(heap, hdr));
    } else {
        ;
    }
 
    /* The prev/next pointers of the removed duk_heaphdr are left as garbage.
     * It's up to the caller to ensure they're written before inserting the
     * object back.

◆ duk_heap_mark_and_sweep()

DUK_INTERNAL_DECL duk_bool_t duk_heap_mark_and_sweep	(	duk_heap *	heap,
		duk_small_uint_t	flags )

Definition at line 43340 of file duktape-1.8.0/src/duktape.c.

                                                                                        {
    duk_hthread *thr;
    duk_size_t count_keep_obj;
    duk_size_t count_keep_str;
#ifdef DUK_USE_VOLUNTARY_GC
    duk_size_t tmp;
#endif
 
    if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_D(DUK_DPRINT("refuse to do a recursive mark-and-sweep"));
        return 0;
    }
 
    /* XXX: thread selection for mark-and-sweep is currently a hack.
     * If we don't have a thread, the entire mark-and-sweep is now
     * skipped (although we could just skip finalizations).
     */
 
    /* If thr != NULL, the thr may still be in the middle of
     * initialization.
     * XXX: Improve the thread viability test.
     */
    thr = duk__get_temp_hthread(heap);
    if (thr == NULL) {
        DUK_D(DUK_DPRINT("gc skipped because we don't have a temp thread"));
 
        /* reset voluntary gc trigger count */
#ifdef DUK_USE_VOLUNTARY_GC
        heap->mark_and_sweep_trigger_counter = DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP;
#endif
        return 0;  /* OK */
    }
 
    /* If debugger is paused, garbage collection is disabled by default. */
    /* XXX: will need a force flag if garbage collection is triggered
     * explicitly during paused state.
     */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    if (DUK_HEAP_IS_PAUSED(heap)) {
        /* Checking this here rather that in memory alloc primitives
         * reduces checking code there but means a failed allocation
         * will go through a few retries before giving up.  That's
         * fine because this only happens during debugging.
         */
        DUK_D(DUK_DPRINT("gc skipped because debugger is paused"));
        return 0;
    }
#endif
 
    DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) starting, requested flags: 0x%08lx, effective flags: 0x%08lx",
                     (unsigned long) flags, (unsigned long) (flags | heap->mark_and_sweep_base_flags)));
 
    flags |= heap->mark_and_sweep_base_flags;
 
    /*
     *  Assertions before
     */
 
#ifdef DUK_USE_ASSERTIONS
    DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap));
    DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap));
    DUK_ASSERT(heap->mark_and_sweep_recursion_depth == 0);
    duk__assert_heaphdr_flags(heap);
#ifdef DUK_USE_REFERENCE_COUNTING
    /* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount
     * finalizer may trigger a mark-and-sweep.
     */
    duk__assert_valid_refcounts(heap);
#endif  /* DUK_USE_REFERENCE_COUNTING */
#endif  /* DUK_USE_ASSERTIONS */
 
    /*
     *  Begin
     */
 
    DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap);
 
    /*
     *  Mark roots, hoping that recursion limit is not normally hit.
     *  If recursion limit is hit, run additional reachability rounds
     *  starting from "temproots" until marking is complete.
     *
     *  Marking happens in two phases: first we mark actual reachability
     *  roots (and run "temproots" to complete the process).  Then we
     *  check which objects are unreachable and are finalizable; such
     *  objects are marked as FINALIZABLE and marked as reachability
     *  (and "temproots" is run again to complete the process).
     *
     *  The heap finalize_list must also be marked as a reachability root.
     *  There may be objects on the list from a previous round if the
     *  previous run had finalizer skip flag.
     */
 
    duk__mark_roots_heap(heap);               /* main reachability roots */
#ifdef DUK_USE_REFERENCE_COUNTING
    duk__mark_refzero_list(heap);             /* refzero_list treated as reachability roots */
#endif
    duk__mark_temproots_by_heap_scan(heap);   /* temproots */
 
    duk__mark_finalizable(heap);              /* mark finalizable as reachability roots */
    duk__mark_finalize_list(heap);            /* mark finalizer work list as reachability roots */
    duk__mark_temproots_by_heap_scan(heap);   /* temproots */
 
    /*
     *  Sweep garbage and remove marking flags, and move objects with
     *  finalizers to the finalizer work list.
     *
     *  Objects to be swept need to get their refcounts finalized before
     *  they are swept.  In other words, their target object refcounts
     *  need to be decreased.  This has to be done before freeing any
     *  objects to avoid decref'ing dangling pointers (which may happen
     *  even without bugs, e.g. with reference loops)
     *
     *  Because strings don't point to other heap objects, similar
     *  finalization is not necessary for strings.
     */
 
    /* XXX: more emergency behavior, e.g. find smaller hash sizes etc */
 
#ifdef DUK_USE_REFERENCE_COUNTING
    duk__finalize_refcounts(heap);
#endif
    duk__sweep_heap(heap, flags, &count_keep_obj);
#if defined(DUK_USE_STRTAB_CHAIN)
    duk__sweep_stringtable_chain(heap, &count_keep_str);
#elif defined(DUK_USE_STRTAB_PROBE)
    duk__sweep_stringtable_probe(heap, &count_keep_str);
#else
#error internal error, invalid strtab options
#endif
#ifdef DUK_USE_REFERENCE_COUNTING
    duk__clear_refzero_list_flags(heap);
#endif
    duk__clear_finalize_list_flags(heap);
 
    /*
     *  Object compaction (emergency only).
     *
     *  Object compaction is a separate step after sweeping, as there is
     *  more free memory for it to work with.  Also, currently compaction
     *  may insert new objects into the heap allocated list and the string
     *  table which we don't want to do during a sweep (the reachability
     *  flags of such objects would be incorrect).  The objects inserted
     *  are currently:
     *
     *    - a temporary duk_hbuffer for a new properties allocation
     *    - if array part is abandoned, string keys are interned
     *
     *  The object insertions go to the front of the list, so they do not
     *  cause an infinite loop (they are not compacted).
     */
 
    if ((flags & DUK_MS_FLAG_EMERGENCY) &&
        !(flags & DUK_MS_FLAG_NO_OBJECT_COMPACTION)) {
        duk__compact_objects(heap);
    }
 
    /*
     *  String table resize check.
     *
     *  Note: this may silently (and safely) fail if GC is caused by an
     *  allocation call in stringtable resize_hash().  Resize_hash()
     *  will prevent a recursive call to itself by setting the
     *  DUK_MS_FLAG_NO_STRINGTABLE_RESIZE in heap->mark_and_sweep_base_flags.
     */
 
    /* XXX: stringtable emergency compaction? */
 
    /* XXX: remove this feature entirely? it would only matter for
     * emergency GC.  Disable for lowest memory builds.
     */
#if defined(DUK_USE_MS_STRINGTABLE_RESIZE)
    if (!(flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE)) {
        DUK_DD(DUK_DDPRINT("resize stringtable: %p", (void *) heap));
        duk_heap_force_strtab_resize(heap);
    } else {
        DUK_D(DUK_DPRINT("stringtable resize skipped because DUK_MS_FLAG_NO_STRINGTABLE_RESIZE is set"));
    }
#endif
 
    /*
     *  Finalize objects in the finalization work list.  Finalized
     *  objects are queued back to heap_allocated with FINALIZED set.
     *
     *  Since finalizers may cause arbitrary side effects, they are
     *  prevented during string table and object property allocation
     *  resizing using the DUK_MS_FLAG_NO_FINALIZERS flag in
     *  heap->mark_and_sweep_base_flags.  In this case the objects
     *  remain in the finalization work list after mark-and-sweep
     *  exits and they may be finalized on the next pass.
     *
     *  Finalization currently happens inside "MARKANDSWEEP_RUNNING"
     *  protection (no mark-and-sweep may be triggered by the
     *  finalizers).  As a side effect:
     *
     *    1) an out-of-memory error inside a finalizer will not
     *       cause a mark-and-sweep and may cause the finalizer
     *       to fail unnecessarily
     *
     *    2) any temporary objects whose refcount decreases to zero
     *       during finalization will not be put into refzero_list;
     *       they can only be collected by another mark-and-sweep
     *
     *  This is not optimal, but since the sweep for this phase has
     *  already happened, this is probably good enough for now.
     */
 
#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE)
    /* Cannot simulate individual finalizers because finalize_list only
     * contains objects with actual finalizers.  But simulate side effects
     * from finalization by doing a bogus function call and resizing the
     * stacks.
     */
    if (flags & DUK_MS_FLAG_NO_FINALIZERS) {
        DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, DUK_MS_FLAG_NO_FINALIZERS is set"));
    } else if (!(thr->valstack != NULL && thr->callstack != NULL && thr->catchstack != NULL)) {
        DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, thread not yet viable"));
    } else {
        DUK_D(DUK_DPRINT("run mark-and-sweep torture finalizer"));
        duk__markandsweep_torture_finalizer(thr);
    }
#endif  /* DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE */
 
    if (flags & DUK_MS_FLAG_NO_FINALIZERS) {
        DUK_D(DUK_DPRINT("finalizer run skipped because DUK_MS_FLAG_NO_FINALIZERS is set"));
    } else {
        duk__run_object_finalizers(heap, flags);
    }
 
    /*
     *  Finish
     */
 
    DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap);
 
    /*
     *  Assertions after
     */
 
#ifdef DUK_USE_ASSERTIONS
    DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap));
    DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap));
    DUK_ASSERT(heap->mark_and_sweep_recursion_depth == 0);
    duk__assert_heaphdr_flags(heap);
#ifdef DUK_USE_REFERENCE_COUNTING
    /* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount
     * finalizer may trigger a mark-and-sweep.
     */
    duk__assert_valid_refcounts(heap);
#endif  /* DUK_USE_REFERENCE_COUNTING */
#endif  /* DUK_USE_ASSERTIONS */
 
    /*

◆ duk_heap_mem_alloc()

DUK_INTERNAL_DECL void * duk_heap_mem_alloc	(	duk_heap *	heap,
		duk_size_t	size )

Definition at line 43661 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    void *res;
    duk_bool_t rc;
    duk_small_int_t i;
 
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT_DISABLE(size >= 0);
 
    /*
     *  Voluntary periodic GC (if enabled)
     */
 
    DUK__VOLUNTARY_PERIODIC_GC(heap);
 
    /*
     *  First attempt
     */
 
#ifdef DUK_USE_GC_TORTURE
    /* simulate alloc failure on every alloc (except when mark-and-sweep is running) */
    if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first alloc attempt fails"));
        res = NULL;
        DUK_UNREF(res);
        goto skip_attempt;
    }
#endif
    res = heap->alloc_func(heap->heap_udata, size);
    if (res || size == 0) {
        /* for zero size allocations NULL is allowed */
        return res;
    }
#ifdef DUK_USE_GC_TORTURE
 skip_attempt:
#endif
 
    DUK_D(DUK_DPRINT("first alloc attempt failed, attempt to gc and retry"));
 
    /*
     *  Avoid a GC if GC is already running.  This can happen at a late
     *  stage in a GC when we try to e.g. resize the stringtable
     *  or compact objects.
     */
 
    if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed, gc in progress (gc skipped), alloc size %ld", (long) size));
        return NULL;
    }
 
    /*
     *  Retry with several GC attempts.  Initial attempts are made without
     *  emergency mode; later attempts use emergency mode which minimizes
     *  memory allocations forcibly.
     */
 
    for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
        duk_small_uint_t flags;
 
        flags = 0;
        if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {

◆ duk_heap_mem_alloc_zeroed()

DUK_INTERNAL_DECL void * duk_heap_mem_alloc_zeroed	(	duk_heap *	heap,
		duk_size_t	size )

Definition at line 43751 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT_DISABLE(size >= 0);
 

◆ duk_heap_mem_free()

DUK_INTERNAL_DECL void duk_heap_mem_free	(	duk_heap *	heap,
		void *	ptr )

Definition at line 43971 of file duktape-1.8.0/src/duktape.c.

                                                                                                                  {
    return heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
}
#endif  /* DUK_USE_MARK_AND_SWEEP */
 
/*
 *  Free memory
 */
 
#ifdef DUK_USE_MARK_AND_SWEEP
DUK_INTERNAL void duk_heap_mem_free(duk_heap *heap, void *ptr) {

◆ duk_heap_mem_realloc()

DUK_INTERNAL_DECL void * duk_heap_mem_realloc	(	duk_heap *	heap,
		void *	ptr,
		duk_size_t	newsize )

Definition at line 43770 of file duktape-1.8.0/src/duktape.c.

             {
        /* assume memset with zero size is OK */
        DUK_MEMZERO(res, size);
    }
    return res;
}
 
/*
 *  Reallocate memory with garbage collection
 */
 
#ifdef DUK_USE_MARK_AND_SWEEP
DUK_INTERNAL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize) {
    void *res;
    duk_bool_t rc;
    duk_small_int_t i;
 
    DUK_ASSERT(heap != NULL);
    /* ptr may be NULL */
    DUK_ASSERT_DISABLE(newsize >= 0);
 
    /*
     *  Voluntary periodic GC (if enabled)
     */
 
    DUK__VOLUNTARY_PERIODIC_GC(heap);
 
    /*
     *  First attempt
     */
 
#ifdef DUK_USE_GC_TORTURE
    /* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
    if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first realloc attempt fails"));
        res = NULL;
        DUK_UNREF(res);
        goto skip_attempt;
    }
#endif
    res = heap->realloc_func(heap->heap_udata, ptr, newsize);
    if (res || newsize == 0) {
        /* for zero size allocations NULL is allowed */
        return res;
    }
#ifdef DUK_USE_GC_TORTURE
 skip_attempt:
#endif
 
    DUK_D(DUK_DPRINT("first realloc attempt failed, attempt to gc and retry"));
 
    /*
     *  Avoid a GC if GC is already running.  See duk_heap_mem_alloc().
     */
 
    if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
        return NULL;
    }
 
    /*
     *  Retry with several GC attempts.  Initial attempts are made without
     *  emergency mode; later attempts use emergency mode which minimizes
     *  memory allocations forcibly.
     */
 
    for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
        duk_small_uint_t flags;
 
        flags = 0;
        if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {

◆ duk_heap_mem_realloc_indirect()

DUK_INTERNAL_DECL void * duk_heap_mem_realloc_indirect	(	duk_heap *	heap,
		duk_mem_getptr	cb,
		void *	ud,
		duk_size_t	newsize )

Definition at line 43864 of file duktape-1.8.0/src/duktape.c.

                                                                                       {
    DUK_ASSERT(heap != NULL);
    /* ptr may be NULL */
    DUK_ASSERT_DISABLE(newsize >= 0);
 
    return heap->realloc_func(heap->heap_udata, ptr, newsize);
}
#endif  /* DUK_USE_MARK_AND_SWEEP */
 
/*
 *  Reallocate memory with garbage collection, using a callback to provide
 *  the current allocated pointer.  This variant is used when a mark-and-sweep
 *  (e.g. finalizers) might change the original pointer.
 */
 
#ifdef DUK_USE_MARK_AND_SWEEP
DUK_INTERNAL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize) {
    void *res;
    duk_bool_t rc;
    duk_small_int_t i;
 
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT_DISABLE(newsize >= 0);
 
    /*
     *  Voluntary periodic GC (if enabled)
     */
 
    DUK__VOLUNTARY_PERIODIC_GC(heap);
 
    /*
     *  First attempt
     */
 
#ifdef DUK_USE_GC_TORTURE
    /* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
    if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first indirect realloc attempt fails"));
        res = NULL;
        DUK_UNREF(res);
        goto skip_attempt;
    }
#endif
    res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
    if (res || newsize == 0) {
        /* for zero size allocations NULL is allowed */
        return res;
    }
#ifdef DUK_USE_GC_TORTURE
 skip_attempt:
#endif
 
    DUK_D(DUK_DPRINT("first indirect realloc attempt failed, attempt to gc and retry"));
 
    /*
     *  Avoid a GC if GC is already running.  See duk_heap_mem_alloc().
     */
 
    if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
        DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
        return NULL;
    }
 
    /*
     *  Retry with several GC attempts.  Initial attempts are made without
     *  emergency mode; later attempts use emergency mode which minimizes
     *  memory allocations forcibly.
     */
 
    for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
        duk_small_uint_t flags;
 
#ifdef DUK_USE_ASSERTIONS
        void *ptr_pre;  /* ptr before mark-and-sweep */
        void *ptr_post;
#endif
 
#ifdef DUK_USE_ASSERTIONS
        ptr_pre = cb(heap, ud);
#endif
        flags = 0;
        if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
            flags |= DUK_MS_FLAG_EMERGENCY;
        }
 
        rc = duk_heap_mark_and_sweep(heap, flags);
        DUK_UNREF(rc);
#ifdef DUK_USE_ASSERTIONS
        ptr_post = cb(heap, ud);
        if (ptr_pre != ptr_post) {
            /* useful for debugging */
            DUK_DD(DUK_DDPRINT("note: base pointer changed by mark-and-sweep: %p -> %p",
                               (void *) ptr_pre, (void *) ptr_post));
        }

References DUK_ASSERT, DUK_ASSERT_DISABLE, duk_heap::heap_udata, NULL, and duk_heap::realloc_func.

◆ duk_heap_remove_any_from_heap_allocated()

DUK_INTERNAL_DECL void duk_heap_remove_any_from_heap_allocated	(	duk_heap *	heap,
		duk_heaphdr *	hdr )

Definition at line 44012 of file duktape-1.8.0/src/duktape.c.

44029 {

44030 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(hdr) != DUK_HTYPE_STRING);

◆ duk_heap_strcache_offset_char2byte()

DUK_INTERNAL_DECL duk_uint_fast32_t duk_heap_strcache_offset_char2byte	(	duk_hthread *	thr,
		duk_hstring *	h,
		duk_uint_fast32_t	char_offset )

Definition at line 44795 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                   {
    duk_heap *heap;
    duk_strcache *sce;
    duk_uint_fast32_t byte_offset;
    duk_small_int_t i;
    duk_bool_t use_cache;
    duk_uint_fast32_t dist_start, dist_end, dist_sce;
    const duk_uint8_t *p_start;
    const duk_uint8_t *p_end;
    const duk_uint8_t *p_found;
 
    if (char_offset > DUK_HSTRING_GET_CHARLEN(h)) {
        goto error;
    }
 
    /*
     *  For ASCII strings, the answer is simple.
     */
 
    if (DUK_HSTRING_IS_ASCII(h)) {
        /* clen == blen -> pure ascii */
        return char_offset;
    }
 
    /*
     *  For non-ASCII strings, we need to scan forwards or backwards
     *  from some starting point.  The starting point may be the start
     *  or end of the string, or some cached midpoint in the string
     *  cache.
     *
     *  For "short" strings we simply scan without checking or updating
     *  the cache.  For longer strings we check and update the cache as
     *  necessary, inserting a new cache entry if none exists.
     */
 
    DUK_DDD(DUK_DDDPRINT("non-ascii string %p, char_offset=%ld, clen=%ld, blen=%ld",
                         (void *) h, (long) char_offset,
                         (long) DUK_HSTRING_GET_CHARLEN(h),
                         (long) DUK_HSTRING_GET_BYTELEN(h)));
 
    heap = thr->heap;
    sce = NULL;
    use_cache = (DUK_HSTRING_GET_CHARLEN(h) > DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT);
 
    if (use_cache) {
#ifdef DUK_USE_DDDPRINT
        DUK_DDD(DUK_DDDPRINT("stringcache before char2byte (using cache):"));
        for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
            duk_strcache *c = heap->strcache + i;
            DUK_DDD(DUK_DDDPRINT("  [%ld] -> h=%p, cidx=%ld, bidx=%ld",
                                 (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx));
        }
#endif
 
        for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
            duk_strcache *c = heap->strcache + i;
 
            if (c->h == h) {
                sce = c;
                break;
            }
        }
    }
 
    /*
     *  Scan from shortest distance:
     *    - start of string
     *    - end of string
     *    - cache entry (if exists)
     */
 
    DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h) >= char_offset);
    dist_start = char_offset;
    dist_end = DUK_HSTRING_GET_CHARLEN(h) - char_offset;
    dist_sce = 0; DUK_UNREF(dist_sce);  /* initialize for debug prints, needed if sce==NULL */
 
    p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
    p_end = (const duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h));
    p_found = NULL;
 
    if (sce) {
        if (char_offset >= sce->cidx) {
            dist_sce = char_offset - sce->cidx;
            if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
                DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
                                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
                                     "scan forwards from sce",
                                     (long) use_cache, (void *) (sce ? sce->h : NULL),
                                     (sce ? (long) sce->cidx : (long) -1),
                                     (sce ? (long) sce->bidx : (long) -1),
                                     (long) dist_start, (long) dist_end, (long) dist_sce));
 
                p_found = duk__scan_forwards(p_start + sce->bidx,
                                             p_end,
                                             dist_sce);
                goto scan_done;
            }
        } else {
            dist_sce = sce->cidx - char_offset;
            if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
                DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
                                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
                                     "scan backwards from sce",
                                     (long) use_cache, (void *) (sce ? sce->h : NULL),
                                     (sce ? (long) sce->cidx : (long) -1),
                                     (sce ? (long) sce->bidx : (long) -1),
                                     (long) dist_start, (long) dist_end, (long) dist_sce));
 
                p_found = duk__scan_backwards(p_start + sce->bidx,
                                              p_start,
                                              dist_sce);
                goto scan_done;
            }
        }
    }
 
    /* no sce, or sce scan not best */
 
    if (dist_start <= dist_end) {
        DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
                             "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
                             "scan forwards from string start",
                             (long) use_cache, (void *) (sce ? sce->h : NULL),
                             (sce ? (long) sce->cidx : (long) -1),
                             (sce ? (long) sce->bidx : (long) -1),
                             (long) dist_start, (long) dist_end, (long) dist_sce));
 
        p_found = duk__scan_forwards(p_start,
                                     p_end,
                                     dist_start);
    } else {
        DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
                             "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
                             "scan backwards from string end",
                             (long) use_cache, (void *) (sce ? sce->h : NULL),
                             (sce ? (long) sce->cidx : (long) -1),
                             (sce ? (long) sce->bidx : (long) -1),
                             (long) dist_start, (long) dist_end, (long) dist_sce));
 
        p_found = duk__scan_backwards(p_end,
                                      p_start,
                                      dist_end);
    }
 
 scan_done:
 
    if (!p_found) {
        /* Scan error: this shouldn't normally happen; it could happen if
         * string is not valid UTF-8 data, and clen/blen are not consistent
         * with the scanning algorithm.
         */
        goto error;
    }
 
    DUK_ASSERT(p_found >= p_start);
    DUK_ASSERT(p_found <= p_end);  /* may be equal */
    byte_offset = (duk_uint32_t) (p_found - p_start);
 
    DUK_DDD(DUK_DDDPRINT("-> string %p, cidx %ld -> bidx %ld",
                         (void *) h, (long) char_offset, (long) byte_offset));
 
    /*
     *  Update cache entry (allocating if necessary), and move the
     *  cache entry to the first place (in an "LRU" policy).
     */
 
    if (use_cache) {
        /* update entry, allocating if necessary */
        if (!sce) {
            sce = heap->strcache + DUK_HEAP_STRCACHE_SIZE - 1;  /* take last entry */
            sce->h = h;
        }
        DUK_ASSERT(sce != NULL);
        sce->bidx = (duk_uint32_t) (p_found - p_start);
        sce->cidx = (duk_uint32_t) char_offset;
 
        /* LRU: move our entry to first */
        if (sce > &heap->strcache[0]) {
            /*
             *   A                  C
             *   B                  A
             *   C <- sce    ==>    B
             *   D                  D
             */
            duk_strcache tmp;
 
            tmp = *sce;
            DUK_MEMMOVE((void *) (&heap->strcache[1]),
                        (const void *) (&heap->strcache[0]),
                        (size_t) (((char *) sce) - ((char *) &heap->strcache[0])));
            heap->strcache[0] = tmp;
 
            /* 'sce' points to the wrong entry here, but is no longer used */

Referenced by duk_hstring_char_code_at_raw().

◆ duk_heap_strcache_string_remove()

DUK_INTERNAL_DECL void duk_heap_strcache_string_remove	(	duk_heap *	heap,
		duk_hstring *	h )

Definition at line 44726 of file duktape-1.8.0/src/duktape.c.

References DUK_DD, DUK_DDPRINT, DUK_HEAP_STRCACHE_SIZE, duk_strcache::h, NULL, and duk_heap::strcache.

◆ duk_heap_string_intern()

DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern	(	duk_heap *	heap,
		const duk_uint8_t *	str,
		duk_uint32_t	blen )

Definition at line 45985 of file duktape-1.8.0/src/duktape.c.

                                                                                                            {
    duk_uint32_t strhash;  /* dummy */
    return duk__do_lookup(heap, str, blen, &strhash);
}

◆ duk_heap_string_intern_checked()

DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern_checked	(	duk_hthread *	thr,
		const duk_uint8_t *	str,
		duk_uint32_t	len )

Definition at line 46001 of file duktape-1.8.0/src/duktape.c.

                                                                                                            {
    duk_hstring *res;
    duk_uint32_t strhash;
 
    /* caller is responsible for ensuring this */
    DUK_ASSERT(blen <= DUK_HSTRING_MAX_BYTELEN);

References duk__do_intern(), duk__do_lookup(), DUK_ASSERT, and DUK_HSTRING_MAX_BYTELEN.

◆ duk_heap_string_intern_u32()

DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern_u32	(	duk_heap *	heap,
		duk_uint32_t	val )

Definition at line 46019 of file duktape-1.8.0/src/duktape.c.

              {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    return res;
}
 

Referenced by duk__realloc_props().

◆ duk_heap_string_intern_u32_checked()

DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern_u32_checked	(	duk_hthread *	thr,
		duk_uint32_t	val )

Definition at line 46027 of file duktape-1.8.0/src/duktape.c.

                                                                                       {
    char buf[DUK_STRTAB_U32_MAX_STRLEN+1];
    DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val);
    buf[sizeof(buf) - 1] = (char) 0;
    DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX);  /* formatted result limited */
    return duk_heap_string_lookup(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf));
}

References DUK_ASSERT, DUK_SNPRINTF, DUK_STRLEN, DUK_STRTAB_U32_MAX_STRLEN, and DUK_UINT32_MAX.

◆ duk_heap_string_remove()

DUK_INTERNAL_DECL void duk_heap_string_remove	(	duk_heap *	heap,
		duk_hstring *	h )

Definition at line 46037 of file duktape-1.8.0/src/duktape.c.

                                                                                                 {
    duk_hstring *res = duk_heap_string_intern_u32(thr->heap, val);
    if (!res) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    return res;
}
 
/* find and remove string from stringtable; caller must free the string itself */
#if defined(DUK_USE_REFERENCE_COUNTING)
DUK_INTERNAL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h) {

◆ duk_heaphdr_decref()

DUK_INTERNAL_DECL void duk_heaphdr_decref	(	duk_hthread *	thr,
		duk_heaphdr *	h )

Definition at line 44662 of file duktape-1.8.0/src/duktape.c.

                                                               {
    if (h == NULL) {
        return;
    }
    DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
    DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
 
    DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
#endif
 

◆ duk_heaphdr_decref_allownull()

DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull	(	duk_hthread *	thr,
		duk_heaphdr *	h )

Definition at line 44680 of file duktape-1.8.0/src/duktape.c.

                                     {
        return;
    }
#endif
    if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
        return;
    }
    duk_heaphdr_refzero(thr, h);
}
 
DUK_INTERNAL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h) {
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);

◆ duk_heaphdr_refcount_finalize()

DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize	(	duk_hthread *	thr,
		duk_heaphdr *	hdr )

Definition at line 44236 of file duktape-1.8.0/src/duktape.c.

                                                                    {
            duk_catcher *cat = t->catchstack + i;
        }
#endif
 
        for (i = 0; i < DUK_NUM_BUILTINS; i++) {
            duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->builtins[i]);
        }
 
        duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->resumer);
    }
}

◆ duk_heaphdr_refzero()

DUK_INTERNAL_DECL void duk_heaphdr_refzero	(	duk_hthread *	thr,
		duk_heaphdr *	h )

Definition at line 44494 of file duktape-1.8.0/src/duktape.c.

                                                                        {
    duk_heap *heap;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(h != NULL);
 
    heap = thr->heap;
    DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h));
 
    /*
     *  Refzero handling is skipped entirely if (1) mark-and-sweep is
     *  running or (2) execution is paused in the debugger.  The objects
     *  are left in the heap, and will be freed by mark-and-sweep or
     *  eventual heap destruction.
     *
     *  This is necessary during mark-and-sweep because refcounts are also
     *  updated during the sweep phase (otherwise objects referenced by a
     *  swept object would have incorrect refcounts) which then calls here.
     *  This could be avoided by using separate decref macros in
     *  mark-and-sweep; however, mark-and-sweep also calls finalizers which
     *  would use the ordinary decref macros anyway and still call this
     *  function.
     *
     *  This check must be enabled also when mark-and-sweep support has been
     *  disabled: the flag is also used in heap destruction when running
     *  finalizers for remaining objects, and the flag prevents objects from
     *  being moved around in heap linked lists.
     */
 
    /* XXX: ideally this would be just one flag (maybe a derived one) so
     * that a single bit test is sufficient to check the condition.
     */
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    if (DUK_UNLIKELY(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap) || DUK_HEAP_IS_PAUSED(heap))) {
#else
    if (DUK_UNLIKELY(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap))) {
#endif
        DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h));
        return;
    }
 
    switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
    case DUK_HTYPE_STRING:
        /*
         *  Strings have no internal references but do have "weak"
         *  references in the string cache.  Also note that strings
         *  are not on the heap_allocated list like other heap
         *  elements.
         */
 
        duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
        duk_heap_string_remove(heap, (duk_hstring *) h);
        duk_heap_free_heaphdr_raw(heap, h);
        break;
 
    case DUK_HTYPE_OBJECT:
        /*
         *  Objects have internal references.  Must finalize through
         *  the "refzero" work list.
         */
 
        duk_heap_remove_any_from_heap_allocated(heap, h);
        duk__queue_refzero(heap, h);
        duk__refzero_free_pending(thr);
        break;

◆ duk_hex_decode()

DUK_EXTERNAL void duk_hex_decode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13453 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
    const duk_uint8_t *inp;
    duk_size_t len;
    duk_size_t i;
    duk_int_t t;
    duk_uint8_t *buf;
#if defined(DUK_USE_HEX_FASTPATH)
    duk_int_t chk;
    duk_uint8_t *p;
    duk_size_t len_safe;
#endif
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    inp = duk__prep_codec_arg(ctx, index, &len);
    DUK_ASSERT(inp != NULL || len == 0);
 
    if (len & 0x01) {
        goto type_error;
    }
 
    /* Fixed buffer, no zeroing because we'll fill all the data. */
    buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len / 2, DUK_BUF_FLAG_NOZERO /*flags*/);
    DUK_ASSERT(buf != NULL);
 
#if defined(DUK_USE_HEX_FASTPATH)
    p = buf;
    len_safe = len & ~0x07U;
    for (i = 0; i < len_safe; i += 8) {
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
        chk = t;
        p[0] = (duk_uint8_t) t;
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 2]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 3]]);
        chk |= t;
        p[1] = (duk_uint8_t) t;
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 4]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 5]]);
        chk |= t;
        p[2] = (duk_uint8_t) t;
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 6]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 7]]);
        chk |= t;
        p[3] = (duk_uint8_t) t;
        p += 4;
 
        /* Check if any lookup above had a negative result. */
        if (DUK_UNLIKELY(chk < 0)) {
            goto type_error;
        }
    }
    for (; i < len; i += 2) {
        t = (((duk_int_t) duk_hex_dectab[inp[i]]) << 4) |
            ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
        if (DUK_UNLIKELY(t < 0)) {
            goto type_error;
        }
        *p++ = (duk_uint8_t) t;
    }
#else  /* DUK_USE_HEX_FASTPATH */
    for (i = 0; i < len; i += 2) {
        /* For invalid characters the value -1 gets extended to
         * at least 16 bits.  If either nybble is invalid, the

◆ duk_hex_encode()

DUK_EXTERNAL const char * duk_hex_encode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13397 of file duktape-1.8.0/src/duktape.c.

                 {
        goto type_error;
    }
 
    /* XXX: convert to fixed buffer? */
    (void) duk_resize_buffer(ctx, -1, (duk_size_t) (dst_final - dst));
    duk_replace(ctx, index);
    return;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_DECODE_FAILED);
}
 
DUK_EXTERNAL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index) {
    const duk_uint8_t *inp;
    duk_size_t len;
    duk_size_t i;
    duk_uint8_t *buf;
    const char *ret;
#if defined(DUK_USE_HEX_FASTPATH)
    duk_size_t len_safe;
    duk_uint16_t *p16;
#endif
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    inp = duk__prep_codec_arg(ctx, index, &len);
    DUK_ASSERT(inp != NULL || len == 0);
 
    /* Fixed buffer, no zeroing because we'll fill all the data. */
    buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len * 2, DUK_BUF_FLAG_NOZERO /*flags*/);
    DUK_ASSERT(buf != NULL);
 
#if defined(DUK_USE_HEX_FASTPATH)
    DUK_ASSERT((((duk_size_t) buf) & 0x01U) == 0);   /* pointer is aligned, guaranteed for fixed buffer */
    p16 = (duk_uint16_t *) (void *) buf;
    len_safe = len & ~0x03U;
    for (i = 0; i < len_safe; i += 4) {
        p16[0] = duk_hex_enctab[inp[i]];
        p16[1] = duk_hex_enctab[inp[i + 1]];
        p16[2] = duk_hex_enctab[inp[i + 2]];
        p16[3] = duk_hex_enctab[inp[i + 3]];
        p16 += 4;
    }
    for (; i < len; i++) {
        *p16++ = duk_hex_enctab[inp[i]];
    }
#else  /* DUK_USE_HEX_FASTPATH */
    for (i = 0; i < len; i++) {
        duk_small_uint_t t;

◆ duk_hnativefunction_alloc()

DUK_INTERNAL_DECL duk_hnativefunction * duk_hnativefunction_alloc	(	duk_heap *	heap,
		duk_uint_t	hobject_flags )

Definition at line 46281 of file duktape-1.8.0/src/duktape.c.

◆ duk_hobject_alloc()

DUK_INTERNAL_DECL duk_hobject * duk_hobject_alloc	(	duk_heap *	heap,
		duk_uint_t	hobject_flags )

Definition at line 46236 of file duktape-1.8.0/src/duktape.c.

                                                : empty objects consume a minimum
     *  amount of memory.  Further, an initial allocation might fail and cause
     *  'obj' to "leak" (require a mark-and-sweep) since it is not reachable yet.
     */
}
 
/*
 *  Allocate an duk_hobject.
 *
 *  The allocated object has no allocation for properties; the caller may
 *  want to force a resize if a desired size is known.
 *
 *  The allocated object has zero reference count and is not reachable.
 *  The caller MUST make the object reachable and increase its reference
 *  count before invoking any operation that might require memory allocation.
 */
 
DUK_INTERNAL duk_hobject *duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
    duk_hobject *res;
 

◆ duk_hobject_compact_props()

DUK_INTERNAL_DECL void duk_hobject_compact_props	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 48465 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk_uint32_t e_size;       /* currently used -> new size */
    duk_uint32_t a_size;       /* currently required */
    duk_uint32_t a_used;       /* actually used */
    duk_uint32_t h_size;
    duk_bool_t abandon_array;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
 
#if defined(DUK_USE_ROM_OBJECTS)
    if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj)) {
        DUK_DD(DUK_DDPRINT("ignore attempt to compact a rom object"));
        return;
    }
#endif
 
    e_size = duk__count_used_e_keys(thr, obj);
    duk__compute_a_stats(thr, obj, &a_used, &a_size);
 
    DUK_DD(DUK_DDPRINT("compacting hobject, used e keys %ld, used a keys %ld, min a size %ld, "
                       "resized array density would be: %ld/%ld = %lf",
                       (long) e_size, (long) a_used, (long) a_size,
                       (long) a_used, (long) a_size,
                       (double) a_used / (double) a_size));
 
    if (duk__abandon_array_density_check(a_used, a_size)) {
        DUK_DD(DUK_DDPRINT("decided to abandon array during compaction, a_used=%ld, a_size=%ld",
                           (long) a_used, (long) a_size));
        abandon_array = 1;
        e_size += a_used;
        a_size = 0;
    } else {
        DUK_DD(DUK_DDPRINT("decided to keep array during compaction"));
        abandon_array = 0;

Referenced by duk__compact_object_list().

◆ duk_hobject_define_accessor_internal()

DUK_INTERNAL_DECL void duk_hobject_define_accessor_internal	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_hobject *	getter,
		duk_hobject *	setter,
		duk_small_uint_t	propflags )

Definition at line 52113 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                                                   {
    duk_context *ctx = (duk_context *) thr;
    duk_int_t e_idx;
    duk_int_t h_idx;
 
    DUK_DDD(DUK_DDDPRINT("define new accessor (internal): thr=%p, obj=%!O, key=%!O, "
                         "getter=%!O, setter=%!O, flags=0x%02lx",
                         (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key,
                         (duk_heaphdr *) getter, (duk_heaphdr *) setter,
                         (unsigned long) propflags));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT((propflags & ~DUK_PROPDESC_FLAGS_MASK) == 0);
    /* setter and/or getter may be NULL */
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));
 

◆ duk_hobject_define_property_helper()

DUK_INTERNAL_DECL void duk_hobject_define_property_helper	(	duk_context *	ctx,
		duk_uint_t	defprop_flags,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_idx_t	idx_value,
		duk_hobject *	get,
		duk_hobject *	set )

Definition at line 52429 of file duktape-1.8.0/src/duktape.c.

        : Ecmascript compliant [[DefineOwnProperty]](P, Desc, Throw) is not
 *  implemented directly, but Object.defineProperty() serves its purpose.
 *  We don't need the [[DefineOwnProperty]] internally and we don't have a
 *  property descriptor with 'missing values' so it's easier to avoid it
 *  entirely.
 *
 *  Note: this is only called for actual objects, not primitive values.
 *  This must support virtual properties for full objects (e.g. Strings)
 *  but not for plain values (e.g. strings).  Lightfuncs, even though
 *  primitive in a sense, are treated like objects and accepted as target
 *  values.
 */
 
/* XXX: this is a major target for size optimization */
DUK_INTERNAL
void duk_hobject_define_property_helper(duk_context *ctx,
                                        duk_uint_t defprop_flags,
                                        duk_hobject *obj,
                                        duk_hstring *key,
                                        duk_idx_t idx_value,
                                        duk_hobject *get,
                                        duk_hobject *set) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uint32_t arr_idx;
    duk_tval tv;
    duk_bool_t has_enumerable;
    duk_bool_t has_configurable;
    duk_bool_t has_writable;
    duk_bool_t has_value;
    duk_bool_t has_get;
    duk_bool_t has_set;
    duk_bool_t is_enumerable;
    duk_bool_t is_configurable;
    duk_bool_t is_writable;
    duk_bool_t throw_flag;
    duk_bool_t force_flag;
    duk_small_uint_t new_flags;
    duk_propdesc curr;
    duk_uint32_t arridx_new_array_length;  /* != 0 => post-update for array 'length' (used when key is an array index) */
    duk_uint32_t arrlen_old_len;
    duk_uint32_t arrlen_new_len;
    duk_bool_t pending_write_protect;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    /* idx_value may be < 0 (no value), set and get may be NULL */
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /* All the flags fit in 16 bits, so will fit into duk_bool_t. */
 
    has_writable = (defprop_flags & DUK_DEFPROP_HAVE_WRITABLE);
    has_enumerable = (defprop_flags & DUK_DEFPROP_HAVE_ENUMERABLE);
    has_configurable = (defprop_flags & DUK_DEFPROP_HAVE_CONFIGURABLE);
    has_value = (defprop_flags & DUK_DEFPROP_HAVE_VALUE);
    has_get = (defprop_flags & DUK_DEFPROP_HAVE_GETTER);
    has_set = (defprop_flags & DUK_DEFPROP_HAVE_SETTER);
    is_writable = (defprop_flags & DUK_DEFPROP_WRITABLE);
    is_enumerable = (defprop_flags & DUK_DEFPROP_ENUMERABLE);
    is_configurable = (defprop_flags & DUK_DEFPROP_CONFIGURABLE);
    throw_flag = 1;   /* Object.defineProperty() calls [[DefineOwnProperty]] with Throw=true */
    force_flag = (defprop_flags & DUK_DEFPROP_FORCE);
 
    arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
 
    arridx_new_array_length = 0;
    pending_write_protect = 0;
    arrlen_old_len = 0;
    arrlen_new_len = 0;
 
    DUK_DDD(DUK_DDDPRINT("has_enumerable=%ld is_enumerable=%ld "
                         "has_configurable=%ld is_configurable=%ld "
                         "has_writable=%ld is_writable=%ld "
                         "has_value=%ld value=%!T "
                         "has_get=%ld get=%p=%!O "
                         "has_set=%ld set=%p=%!O "
                         "arr_idx=%ld",
                         (long) has_enumerable, (long) is_enumerable,
                         (long) has_configurable, (long) is_configurable,
                         (long) has_writable, (long) is_writable,
                         (long) has_value, (duk_tval *) (idx_value >= 0 ? duk_get_tval(ctx, idx_value) : NULL),
                         (long) has_get, (void *) get, (duk_heaphdr *) get,
                         (long) has_set, (void *) set, (duk_heaphdr *) set,
                         (long) arr_idx));
 
    /*
     *  Array exotic behaviors can be implemented at this point.  The local variables
     *  are essentially a 'value copy' of the input descriptor (Desc), which is modified
     *  by the Array [[DefineOwnProperty]] (E5 Section 15.4.5.1).
     */
 
    if (!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) {
        goto skip_array_exotic;
    }
 
    if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
        /* E5 Section 15.4.5.1, step 3, steps a - i are implemented here, j - n at the end */
        if (!has_value) {
            DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', but no value in descriptor -> normal behavior"));
            goto skip_array_exotic;
        }
 
        DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', value present in descriptor -> exotic behavior"));
 
        /*
         *  Get old and new length
         */
 
        /* Note: reuse 'curr' as a temp propdesc */
        arrlen_old_len = duk__get_old_array_length(thr, obj, &curr);
 
        duk_dup(ctx, idx_value);
        arrlen_new_len = duk__to_new_array_length_checked(thr);
        duk_push_u32(ctx, arrlen_new_len);
        duk_replace(ctx, idx_value);  /* step 3.e: replace 'Desc.[[Value]]' */
 
        DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) arrlen_old_len, (long) arrlen_new_len));
 
        if (arrlen_new_len >= arrlen_old_len) {
            /* standard behavior, step 3.f.i */
            DUK_DDD(DUK_DDDPRINT("new length is same or higher as previous => standard behavior"));
            goto skip_array_exotic;
        }
        DUK_DDD(DUK_DDDPRINT("new length is smaller than previous => exotic post behavior"));
 
        /* XXX: consolidated algorithm step 15.f -> redundant? */
        if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && !force_flag) {
            /* Note: 'curr' refers to 'length' propdesc */
            goto fail_not_writable_array_length;
        }
 
        /* steps 3.h and 3.i */
        if (has_writable && !is_writable) {
            DUK_DDD(DUK_DDDPRINT("desc writable is false, force it back to true, and flag pending write protect"));
            is_writable = 1;
            pending_write_protect = 1;
        }
 
        /* remaining actual steps are carried out if standard DefineOwnProperty succeeds */
    } else if (arr_idx != DUK__NO_ARRAY_INDEX) {
        /* XXX: any chance of unifying this with the 'length' key handling? */
 
        /* E5 Section 15.4.5.1, step 4 */
        duk_uint32_t old_len;
 
        /* Note: use 'curr' as a temp propdesc */
        old_len = duk__get_old_array_length(thr, obj, &curr);
 
        if (arr_idx >= old_len) {
            DUK_DDD(DUK_DDDPRINT("defineProperty requires array length update "
                                 "(arr_idx=%ld, old_len=%ld)",
                                 (long) arr_idx, (long) old_len));
 
            if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
                /* Note: 'curr' refers to 'length' propdesc */
                goto fail_not_writable_array_length;
            }
 
            /* actual update happens once write has been completed without
             * error below.
             */
            DUK_ASSERT(arr_idx != 0xffffffffUL);
            arridx_new_array_length = arr_idx + 1;
        } else {
            DUK_DDD(DUK_DDDPRINT("defineProperty does not require length update "
                                 "(arr_idx=%ld, old_len=%ld) -> standard behavior",
                                 (long) arr_idx, (long) old_len));
        }
    }
 skip_array_exotic:
 
    /* XXX: There is currently no support for writing buffer object
     * indexed elements here.  Attempt to do so will succeed and
     * write a concrete property into the buffer object.  This should
     * be fixed at some point but because buffers are a custom feature
     * anyway, this is relatively unimportant.
     */
 
    /*
     *  Actual Object.defineProperty() default algorithm.
     */
 
    /*
     *  First check whether property exists; if not, simple case.  This covers
     *  steps 1-4.
     */
 
    if (!duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE)) {
        DUK_DDD(DUK_DDDPRINT("property does not exist"));
 
        if (!DUK_HOBJECT_HAS_EXTENSIBLE(obj) && !force_flag) {
            goto fail_not_extensible;
        }
 
        /* XXX: share final setting code for value and flags?  difficult because
         * refcount code is different.  Share entry allocation?  But can't allocate
         * until array index checked.
         */
 
        /* steps 4.a and 4.b are tricky */
        if (has_set || has_get) {
            duk_int_t e_idx;
 
            DUK_DDD(DUK_DDDPRINT("create new accessor property"));
 
            DUK_ASSERT(has_set || set == NULL);
            DUK_ASSERT(has_get || get == NULL);
            DUK_ASSERT(!has_value);
            DUK_ASSERT(!has_writable);
 
            new_flags = DUK_PROPDESC_FLAG_ACCESSOR;  /* defaults, E5 Section 8.6.1, Table 7 */
            if (has_enumerable && is_enumerable) {
                new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
            }
            if (has_configurable && is_configurable) {
                new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
            }
 
            if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
                DUK_DDD(DUK_DDDPRINT("accessor cannot go to array part, abandon array"));
                duk__abandon_array_checked(thr, obj);
            }
 
            /* write to entry part */
            e_idx = duk__alloc_entry_checked(thr, obj, key);
            DUK_ASSERT(e_idx >= 0);
 
            DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, e_idx, get);
            DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, e_idx, set);
            DUK_HOBJECT_INCREF_ALLOWNULL(thr, get);
            DUK_HOBJECT_INCREF_ALLOWNULL(thr, set);
 
            DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags);
            goto success_exotics;
        } else {
            duk_int_t e_idx;
            duk_tval *tv2;
 
            DUK_DDD(DUK_DDDPRINT("create new data property"));
 
            DUK_ASSERT(!has_set);
            DUK_ASSERT(!has_get);
 
            new_flags = 0;  /* defaults, E5 Section 8.6.1, Table 7 */
            if (has_writable && is_writable) {
                new_flags |= DUK_PROPDESC_FLAG_WRITABLE;
            }
            if (has_enumerable && is_enumerable) {
                new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
            }
            if (has_configurable && is_configurable) {
                new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
            }
            if (has_value) {
                duk_tval *tv_tmp = duk_require_tval(ctx, idx_value);
                DUK_TVAL_SET_TVAL(&tv, tv_tmp);
            } else {
                DUK_TVAL_SET_UNDEFINED(&tv);  /* default value */
            }
 
            if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
                if (new_flags == DUK_PROPDESC_FLAGS_WEC) {
#if 0
                    DUK_DDD(DUK_DDDPRINT("new data property attributes match array defaults, attempt to write to array part"));
                    /* may become sparse...*/
#endif
                    /* XXX: handling for array part missing now; this doesn't affect
                     * compliance but causes array entry writes using defineProperty()
                     * to always abandon array part.
                     */
                }
                DUK_DDD(DUK_DDDPRINT("new data property cannot go to array part, abandon array"));
                duk__abandon_array_checked(thr, obj);
                /* fall through */
            }
 
            /* write to entry part */
            e_idx = duk__alloc_entry_checked(thr, obj, key);
            DUK_ASSERT(e_idx >= 0);
            tv2 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
            DUK_TVAL_SET_TVAL(tv2, &tv);
            DUK_TVAL_INCREF(thr, tv2);
 
            DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags);
            goto success_exotics;
        }
        DUK_UNREACHABLE();
    }
 
    /* we currently assume virtual properties are not configurable (as none of them are) */
    DUK_ASSERT((curr.e_idx >= 0 || curr.a_idx >= 0) || !(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE));
 
    /* [obj key desc value get set curr_value] */
 
    /*
     *  Property already exists.  Steps 5-6 detect whether any changes need
     *  to be made.
     */
 
    if (has_enumerable) {
        if (is_enumerable) {
            if (!(curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE)) {
                goto need_check;
            }
        } else {
            if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) {
                goto need_check;
            }
        }
    }
    if (has_configurable) {
        if (is_configurable) {
            if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
                goto need_check;
            }
        } else {
            if (curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) {
                goto need_check;
            }
        }
    }
    if (has_value) {
        duk_tval *tmp1;
        duk_tval *tmp2;
 
        /* attempt to change from accessor to data property */
        if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            goto need_check;
        }
 
        tmp1 = duk_require_tval(ctx, -1);         /* curr value */
        tmp2 = duk_require_tval(ctx, idx_value);  /* new value */
        if (!duk_js_samevalue(tmp1, tmp2)) {
            goto need_check;
        }
    }
    if (has_writable) {
        /* attempt to change from accessor to data property */
        if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            goto need_check;
        }
 
        if (is_writable) {
            if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
                goto need_check;
            }
        } else {
            if (curr.flags & DUK_PROPDESC_FLAG_WRITABLE) {
                goto need_check;
            }
        }
    }
    if (has_set) {
        if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            if (set != curr.set) {
                goto need_check;
            }
        } else {
            goto need_check;
        }
    }
    if (has_get) {
        if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            if (get != curr.get) {
                goto need_check;
            }
        } else {
            goto need_check;
        }
    }
 
    /* property exists, either 'desc' is empty, or all values
     * match (SameValue)
     */
    goto success_no_exotics;
 
 need_check:
 
    /*
     *  Some change(s) need to be made.  Steps 7-11.
     */
 
    /* shared checks for all descriptor types */
    if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
        if (has_configurable && is_configurable) {
            goto fail_not_configurable;
        }
        if (has_enumerable) {
            if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) {
                if (!is_enumerable) {
                    goto fail_not_configurable;
                }
            } else {
                if (is_enumerable) {
                    goto fail_not_configurable;
                }
            }
        }
    }
 
    /* Reject attempt to change virtual properties: not part of the
     * standard algorithm, applies currently to e.g. virtual index
     * properties of buffer objects (which are virtual but writable).
     * (Cannot "force" modification of a virtual property.)
     */
    if (curr.flags & DUK_PROPDESC_FLAG_VIRTUAL) {
        goto fail_virtual;
    }
 
    /* Reject attempt to change a read-only object. */
#if defined(DUK_USE_ROM_OBJECTS)
    if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj)) {
        DUK_DD(DUK_DDPRINT("attempt to define property on read-only target object"));
        goto fail_not_configurable;
    }
#endif
 
    /* descriptor type specific checks */
    if (has_set || has_get) {
        /* IsAccessorDescriptor(desc) == true */
        DUK_ASSERT(!has_writable);
        DUK_ASSERT(!has_value);
 
        if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            /* curr and desc are accessors */
            if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
                if (has_set && set != curr.set) {
                    goto fail_not_configurable;
                }
                if (has_get && get != curr.get) {
                    goto fail_not_configurable;
                }
            }
        } else {
            duk_bool_t rc;
            duk_tval *tv1;
            duk_tval tv_tmp;
 
            /* curr is data, desc is accessor */
            if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
                goto fail_not_configurable;
            }
 
            DUK_DDD(DUK_DDDPRINT("convert property to accessor property"));
            if (curr.a_idx >= 0) {
                DUK_DDD(DUK_DDDPRINT("property to convert is stored in an array entry, abandon array and re-lookup"));
                duk__abandon_array_checked(thr, obj);
                duk_pop(ctx);  /* remove old value */
                rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
                DUK_UNREF(rc);
                DUK_ASSERT(rc != 0);
                DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
            }
 
            DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
 
            /* Avoid side effects that might disturb curr.e_idx until
             * we're done editing the slot.
             */
            tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
            DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
            DUK_TVAL_SET_UNDEFINED(tv1);
 
            DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL);
            DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL);
            DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
            DUK_HOBJECT_E_SLOT_SET_ACCESSOR(thr->heap, obj, curr.e_idx);
 
            DUK_DDD(DUK_DDDPRINT("flags after data->accessor conversion: 0x%02lx",
                                 (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx)));
 
            DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
 
            /* re-lookup to update curr.flags
             * XXX: would be faster to update directly
             */
            duk_pop(ctx);  /* remove old value */
            rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
            DUK_UNREF(rc);
            DUK_ASSERT(rc != 0);
        }
    } else if (has_value || has_writable) {
        /* IsDataDescriptor(desc) == true */
        DUK_ASSERT(!has_set);
        DUK_ASSERT(!has_get);
 
        if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            duk_bool_t rc;
            duk_hobject *h_get;
            duk_hobject *h_set;
 
            /* curr is accessor, desc is data */
            if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
                goto fail_not_configurable;
            }
 
            /* curr is accessor -> cannot be in array part */
            DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
 
            DUK_DDD(DUK_DDDPRINT("convert property to data property"));
 
            /* Avoid side effects that might disturb curr.e_idx until
             * we're done editing the slot.
             */
            DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
            h_get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx);
            DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL);
            h_set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx);
            DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL);
 
            DUK_TVAL_SET_UNDEFINED(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx));
            DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
            DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(thr->heap, obj, curr.e_idx);
 
            DUK_DDD(DUK_DDDPRINT("flags after accessor->data conversion: 0x%02lx",
                                 (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx)));
 
            DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_get);  /* side effects */
            DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_set);  /* side effects */
 
            /* re-lookup to update curr.flags
             * XXX: would be faster to update directly
             */
            duk_pop(ctx);  /* remove old value */
            rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
            DUK_UNREF(rc);
            DUK_ASSERT(rc != 0);
        } else {
            /* curr and desc are data */
            if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
                if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_writable && is_writable) {
                    goto fail_not_configurable;
                }
                /* Note: changing from writable to non-writable is OK */
                if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_value) {
                    duk_tval *tmp1 = duk_require_tval(ctx, -1);         /* curr value */
                    duk_tval *tmp2 = duk_require_tval(ctx, idx_value);  /* new value */
                    if (!duk_js_samevalue(tmp1, tmp2)) {
                        goto fail_not_configurable;
                    }
                }
            }
        }
    } else {
        /* IsGenericDescriptor(desc) == true; this means in practice that 'desc'
         * only has [[Enumerable]] or [[Configurable]] flag updates, which are
         * allowed at this point.
         */
 
        DUK_ASSERT(!has_value && !has_writable && !has_get && !has_set);
    }
 
    /*
     *  Start doing property attributes updates.  Steps 12-13.
     *
     *  Start by computing new attribute flags without writing yet.
     *  Property type conversion is done above if necessary.
     */
 
    new_flags = curr.flags;
 
    if (has_enumerable) {
        if (is_enumerable) {
            new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
        } else {
            new_flags &= ~DUK_PROPDESC_FLAG_ENUMERABLE;
        }
    }
    if (has_configurable) {
        if (is_configurable) {
            new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
        } else {
            new_flags &= ~DUK_PROPDESC_FLAG_CONFIGURABLE;
        }
    }
    if (has_writable) {
        if (is_writable) {
            new_flags |= DUK_PROPDESC_FLAG_WRITABLE;
        } else {
            new_flags &= ~DUK_PROPDESC_FLAG_WRITABLE;
        }
    }
 
    /* XXX: write protect after flag? -> any chance of handling it here? */
 
    DUK_DDD(DUK_DDDPRINT("new flags that we want to write: 0x%02lx",
                         (unsigned long) new_flags));
 
    /*
     *  Check whether we need to abandon an array part (if it exists)
     */
 
    if (curr.a_idx >= 0) {
        duk_bool_t rc;
 
        DUK_ASSERT(curr.e_idx < 0);
 
        if (new_flags == DUK_PROPDESC_FLAGS_WEC) {
            duk_tval *tv1, *tv2;
 
            DUK_DDD(DUK_DDDPRINT("array index, new property attributes match array defaults, update in-place"));
 
            DUK_ASSERT(curr.flags == DUK_PROPDESC_FLAGS_WEC);  /* must have been, since in array part */
            DUK_ASSERT(!has_set);
            DUK_ASSERT(!has_get);
 
            tv2 = duk_require_tval(ctx, idx_value);
            tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, curr.a_idx);
            DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2);  /* side effects */
            goto success_exotics;
        }
 
        DUK_DDD(DUK_DDDPRINT("array index, new property attributes do not match array defaults, abandon array and re-lookup"));
        duk__abandon_array_checked(thr, obj);
        duk_pop(ctx);  /* remove old value */
        rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
        DUK_UNREF(rc);
        DUK_ASSERT(rc != 0);
        DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
    }
 
    DUK_DDD(DUK_DDDPRINT("updating existing property in entry part"));
 
    /* array case is handled comprehensively above */
    DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
 
    DUK_DDD(DUK_DDDPRINT("update existing property attributes"));
    DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, curr.e_idx, new_flags);
 
    if (has_set) {
        duk_hobject *tmp;
 
        DUK_DDD(DUK_DDDPRINT("update existing property setter"));
        DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
 
        tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx);
        DUK_UNREF(tmp);
        DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, set);
        DUK_HOBJECT_INCREF_ALLOWNULL(thr, set);
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);  /* side effects */
    }
    if (has_get) {
        duk_hobject *tmp;
 
        DUK_DDD(DUK_DDDPRINT("update existing property getter"));
        DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
 
        tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx);
        DUK_UNREF(tmp);
        DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, get);
        DUK_HOBJECT_INCREF_ALLOWNULL(thr, get);
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);  /* side effects */
    }
    if (has_value) {
        duk_tval *tv1, *tv2;
 
        DUK_DDD(DUK_DDDPRINT("update existing property value"));
        DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
 
        tv2 = duk_require_tval(ctx, idx_value);
        tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
        DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2);  /* side effects */
    }
 
    /*
     *  Standard algorithm succeeded without errors, check for exotic post-behaviors.
     *
     *  Arguments exotic behavior in E5 Section 10.6 occurs after the standard
     *  [[DefineOwnProperty]] has completed successfully.
     *
     *  Array exotic behavior in E5 Section 15.4.5.1 is implemented partly
     *  prior to the default [[DefineOwnProperty]], but:
     *    - for an array index key (e.g. "10") the final 'length' update occurs here
     *    - for 'length' key the element deletion and 'length' update occurs here
     */
 
 success_exotics:
 
    /* [obj key desc value get set curr_value] */
 
    if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) {
        if (arridx_new_array_length > 0) {
            duk_tval *tmp;
            duk_bool_t rc;
 
            /*
             *  Note: zero works as a "no update" marker because the new length
             *  can never be zero after a new property is written.
             */
 
            /* E5 Section 15.4.5.1, steps 4.e.i - 4.e.ii */
 
            DUK_DDD(DUK_DDDPRINT("defineProperty successful, pending array length update to: %ld",
                                 (long) arridx_new_array_length));
 
            /* Note: reuse 'curr' */
            rc = duk__get_own_propdesc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &curr, 0 /*flags*/);  /* don't push value */
            DUK_UNREF(rc);
            DUK_ASSERT(rc != 0);
            DUK_ASSERT(curr.e_idx >= 0);
 
            tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp));
            /* no need for decref/incref because value is a number */
            DUK_TVAL_SET_FASTINT_U32(tmp, arridx_new_array_length);
        }
        if (key == DUK_HTHREAD_STRING_LENGTH(thr) && arrlen_new_len < arrlen_old_len) {
            /*
             *  E5 Section 15.4.5.1, steps 3.k - 3.n.  The order at the end combines
             *  the error case 3.l.iii and the success case 3.m-3.n.
             *
             *  Note: 'length' is always in entries part, so no array abandon issues for
             *  'writable' update.
             */
 
            /* XXX: investigate whether write protect can be handled above, if we
             * just update length here while ignoring its protected status
             */
 
            duk_tval *tmp;
            duk_uint32_t result_len;
            duk_bool_t rc;
 
            DUK_DDD(DUK_DDDPRINT("defineProperty successful, key is 'length', exotic array behavior, "
                                 "doing array element deletion and length update"));
 
            rc = duk__handle_put_array_length_smaller(thr, obj, arrlen_old_len, arrlen_new_len, force_flag, &result_len);
 
            /* update length (curr points to length, and we assume it's still valid) */
            DUK_ASSERT(result_len >= arrlen_new_len && result_len <= arrlen_old_len);
 
            DUK_ASSERT(curr.e_idx >= 0);
            DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
            tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp));
            /* no decref needed for a number */
            DUK_TVAL_SET_FASTINT_U32(tmp, result_len);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp));
 
            if (pending_write_protect) {
                DUK_DDD(DUK_DDDPRINT("setting array length non-writable (pending writability update)"));
                DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
            }
 
            /*
             *  XXX: shrink array allocation or entries compaction here?
             */
 
            if (!rc) {
                goto fail_array_length_partial;
            }
        }
    } else if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) {
        duk_hobject *map;
        duk_hobject *varenv;
 
        DUK_ASSERT(arridx_new_array_length == 0);
        DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj));  /* traits are separate; in particular, arguments not an array */
 
        map = NULL;
        varenv = NULL;
        if (!duk__lookup_arguments_map(thr, obj, key, &curr, &map, &varenv)) {
            goto success_no_exotics;
        }
        DUK_ASSERT(map != NULL);
        DUK_ASSERT(varenv != NULL);
 
        /* [obj key desc value get set curr_value varname] */
 
        if (has_set || has_get) {
            /* = IsAccessorDescriptor(Desc) */
            DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map' "
                                 "changed to an accessor, delete arguments binding"));
 
            (void) duk_hobject_delprop_raw(thr, map, key, 0);  /* ignore result */
        } else {
            /* Note: this order matters (final value before deleting map entry must be done) */
            DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
                                 "check for value update / binding deletion"));
 
            if (has_value) {
                duk_hstring *varname;
 
                DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
                                     "update bound value (variable/argument)"));
 
                varname = duk_require_hstring(ctx, -1);
                DUK_ASSERT(varname != NULL);
 
                DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; "
                                     "key=%!O, varname=%!O, value=%!T",
                                     (duk_heaphdr *) key,
                                     (duk_heaphdr *) varname,
                                     (duk_tval *) duk_require_tval(ctx, idx_value)));
 
                /* strict flag for putvar comes from our caller (currently: fixed) */
                duk_js_putvar_envrec(thr, varenv, varname, duk_require_tval(ctx, idx_value), throw_flag);
            }
            if (has_writable && !is_writable) {
                DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
                                     "changed to non-writable, delete arguments binding"));
 
                (void) duk_hobject_delprop_raw(thr, map, key, 0);  /* ignore result */
            }
        }
 
        /* 'varname' is in stack in this else branch, leaving an unbalanced stack below,
         * but this doesn't matter now.
         */
    }
 
 success_no_exotics:
    return;
 
 fail_virtual:
    DUK_ERROR_TYPE(thr, DUK_STR_PROPERTY_IS_VIRTUAL);
    return;

References duk_propdesc::a_idx, duk__abandon_array_checked(), duk__alloc_entry_checked(), duk__get_old_array_length(), duk__get_own_propdesc_raw(), duk__handle_put_array_length_smaller(), duk__lookup_arguments_map(), DUK__NO_ARRAY_INDEX, duk__to_new_array_length_checked(), DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DEFPROP_CONFIGURABLE, DUK_DEFPROP_ENUMERABLE, DUK_DEFPROP_FORCE, DUK_DEFPROP_HAVE_CONFIGURABLE, DUK_DEFPROP_HAVE_ENUMERABLE, DUK_DEFPROP_HAVE_GETTER, DUK_DEFPROP_HAVE_SETTER, DUK_DEFPROP_HAVE_VALUE, DUK_DEFPROP_HAVE_WRITABLE, DUK_DEFPROP_WRITABLE, duk_dup(), DUK_ERROR_TYPE, duk_get_tval(), DUK_GETDESC_FLAG_PUSH_VALUE, DUK_HEAPHDR_HAS_READONLY, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_DECREF_ALLOWNULL, duk_hobject_delprop_raw(), DUK_HOBJECT_E_GET_FLAGS, DUK_HOBJECT_E_GET_VALUE_GETTER, DUK_HOBJECT_E_GET_VALUE_SETTER, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, DUK_HOBJECT_E_SET_FLAGS, DUK_HOBJECT_E_SET_VALUE_GETTER, DUK_HOBJECT_E_SET_VALUE_SETTER, DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR, DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE, DUK_HOBJECT_E_SLOT_IS_ACCESSOR, DUK_HOBJECT_E_SLOT_SET_ACCESSOR, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_HOBJECT_HAS_EXTENSIBLE, DUK_HOBJECT_INCREF_ALLOWNULL, DUK_HSTRING_GET_ARRIDX_SLOW, DUK_HTHREAD_STRING_LENGTH, duk_js_putvar_envrec(), duk_js_samevalue, duk_pop(), DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_VIRTUAL, DUK_PROPDESC_FLAG_WRITABLE, DUK_PROPDESC_FLAGS_WEC, duk_push_u32, duk_replace(), duk_require_hstring(), duk_require_tval(), DUK_STR_ARRAY_LENGTH_NOT_WRITABLE, DUK_STR_PROPERTY_IS_VIRTUAL, DUK_TVAL_DECREF, DUK_TVAL_INCREF, DUK_TVAL_IS_NUMBER, DUK_TVAL_SET_FASTINT_U32, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_TVAL_UPDREF, DUK_TVAL_SET_UNDEFINED, DUK_UNREACHABLE, DUK_UNREF, duk_propdesc::e_idx, duk_propdesc::flags, duk_propdesc::get, duk_hthread::heap, NULL, and duk_propdesc::set.

◆ duk_hobject_define_property_internal()

DUK_INTERNAL_DECL void duk_hobject_define_property_internal	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_small_uint_t	flags )

Definition at line 51940 of file duktape-1.8.0/src/duktape.c.

                    :
 *    - virtual properties (error if write attempted)
 *    - getter/setter properties (error if write attempted)
 *    - non-default (!= WEC) attributes for array entries (error if attempted)
 *    - array abandoning: if array part exists, it is always extended
 *    - array 'length' updating
 *
 *  Stack: [... in_val] -> []
 *
 *  Used for e.g. built-in initialization and environment record
 *  operations.
 */
 
DUK_INTERNAL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) {
    duk_context *ctx = (duk_context *) thr;
    duk_propdesc desc;
    duk_uint32_t arr_idx;
    duk_int_t e_idx;
    duk_tval *tv1 = NULL;
    duk_tval *tv2 = NULL;
    duk_small_uint_t propflags = flags & DUK_PROPDESC_FLAGS_MASK;  /* mask out flags not actually stored */
 
    DUK_DDD(DUK_DDDPRINT("define new property (internal): thr=%p, obj=%!O, key=%!O, flags=0x%02lx, val=%!T",
                         (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key,
                         (unsigned long) flags, (duk_tval *) duk_get_tval(ctx, -1)));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
    DUK_ASSERT(duk_is_valid_index(ctx, -1));  /* contains value */
 
    arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
 
    if (duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
        if (desc.e_idx >= 0) {
            if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
                DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> skip as requested"));
                goto pop_exit;
            }
            DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> update value and attributes"));
            if (DUK_UNLIKELY(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx))) {
                DUK_D(DUK_DPRINT("existing property is an accessor, not supported"));
                goto error_internal;
            }
 
            DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, propflags);
            tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
        } else if (desc.a_idx >= 0) {
            if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
                DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> skip as requested"));
                goto pop_exit;
            }
            DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> update value (assert attributes)"));
            if (propflags != DUK_PROPDESC_FLAGS_WEC) {
                DUK_D(DUK_DPRINT("existing property in array part, but propflags not WEC (0x%02lx)",
                                 (unsigned long) propflags));
                goto error_internal;
            }
 
            tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx);
        } else {
            if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
                DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> skip as requested"));
                goto pop_exit;
            }
            DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> failure"));
            goto error_virtual;
        }
 
        goto write_value;
    }
 
    if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
        if (arr_idx != DUK__NO_ARRAY_INDEX) {
            DUK_DDD(DUK_DDDPRINT("property does not exist, object has array part -> possibly extend array part and write value (assert attributes)"));
            DUK_ASSERT(propflags == DUK_PROPDESC_FLAGS_WEC);
 
            /* always grow the array, no sparse / abandon support here */
            if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
                duk__grow_props_for_array_item(thr, obj, arr_idx);
            }
 
            DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj));
            tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
            goto write_value;
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("property does not exist, object belongs in entry part -> allocate new entry and write value and attributes"));
    e_idx = duk__alloc_entry_checked(thr, obj, key);  /* increases key refcount */
    DUK_ASSERT(e_idx >= 0);
    DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, propflags);
    tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
    /* new entry: previous value is garbage; set to undefined to share write_value */
    DUK_TVAL_SET_UNDEFINED(tv1);
    goto write_value;
 
 write_value:
    /* tv1 points to value storage */
 
    tv2 = duk_require_tval(ctx, -1);  /* late lookup, avoid side effects */
    DUK_DDD(DUK_DDDPRINT("writing/updating value: %!T -> %!T",

References duk_propdesc::a_idx, duk__alloc_entry_checked(), duk__get_own_propdesc_raw(), duk__grow_props_for_array_item(), DUK__NO_ARRAY_INDEX, DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, duk_get_tval(), DUK_HEAPHDR_HAS_READONLY, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, DUK_HOBJECT_E_SET_FLAGS, DUK_HOBJECT_E_SLOT_IS_ACCESSOR, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HSTRING_GET_ARRIDX_SLOW, duk_is_valid_index(), duk_pop(), DUK_PROPDESC_FLAG_NO_OVERWRITE, DUK_PROPDESC_FLAGS_MASK, DUK_PROPDESC_FLAGS_WEC, duk_require_tval(), DUK_TVAL_SET_TVAL_UPDREF, DUK_TVAL_SET_UNDEFINED, DUK_UNLIKELY, duk_propdesc::e_idx, duk_hthread::heap, and NULL.

Referenced by duk__declvar_helper().

◆ duk_hobject_define_property_internal_arridx()

DUK_INTERNAL_DECL void duk_hobject_define_property_internal_arridx	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_uarridx_t	arr_idx,
		duk_small_uint_t	flags )

Definition at line 52056 of file duktape-1.8.0/src/duktape.c.

               :
    DUK_ERROR_INTERNAL_DEFMSG(thr);
    return;
 
 error_virtual:
    DUK_ERROR_TYPE(thr, DUK_STR_REDEFINE_VIRT_PROP);
    return;
}
 
/*
 *  Fast path for defining array indexed values without interning the key.
 *  This is used by e.g. code for Array prototype and traceback creation so
 *  must avoid interning.
 */
 
DUK_INTERNAL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, duk_hobject *obj, duk_uarridx_t arr_idx, duk_small_uint_t flags) {
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *key;
    duk_tval *tv1, *tv2;
 
    DUK_DDD(DUK_DDDPRINT("define new property (internal) arr_idx fast path: thr=%p, obj=%!O, "
                         "arr_idx=%ld, flags=0x%02lx, val=%!T",
                         (void *) thr, obj, (long) arr_idx, (unsigned long) flags,
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));
 
    if (DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
        arr_idx != DUK__NO_ARRAY_INDEX &&
        flags == DUK_PROPDESC_FLAGS_WEC) {
        DUK_ASSERT((flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) == 0);  /* covered by comparison */
 
        DUK_DDD(DUK_DDDPRINT("define property to array part (property may or may not exist yet)"));
 
        /* always grow the array, no sparse / abandon support here */
        if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
            duk__grow_props_for_array_item(thr, obj, arr_idx);
        }
 
        DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj));
        tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
        tv2 = duk_require_tval(ctx, -1);
 

◆ duk_hobject_delprop()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop	(	duk_hthread *	thr,
		duk_tval *	tv_obj,
		duk_tval *	tv_key,
		duk_bool_t	throw_flag )

Definition at line 51732 of file duktape-1.8.0/src/duktape.c.

                      :
    DUK_DDD(DUK_DDDPRINT("delete failed: property found, not configurable"));
 
    if (throw_flag) {
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_CONFIGURABLE);
    }
    return 0;
}
 
/*
 *  DELPROP: Ecmascript property deletion.
 */
 
DUK_INTERNAL duk_bool_t duk_hobject_delprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_bool_t throw_flag) {
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *key = NULL;
#if defined(DUK_USE_ES6_PROXY)
    duk_propdesc desc;
#endif
    duk_int_t entry_top;
    duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX;
    duk_bool_t rc;
 
    DUK_DDD(DUK_DDDPRINT("delprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
                         (void *) thr, (void *) tv_obj, (void *) tv_key,
                         (duk_tval *) tv_obj, (duk_tval *) tv_key));
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(tv_obj != NULL);
    DUK_ASSERT(tv_key != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /* Storing the entry top is cheaper here to ensure stack is correct at exit,
     * as there are several paths out.
     */
    entry_top = duk_get_top(ctx);
 
    if (DUK_TVAL_IS_UNDEFINED(tv_obj) ||
        DUK_TVAL_IS_NULL(tv_obj)) {
        DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject"));
        goto fail_invalid_base_uncond;
    }
 
    duk_push_tval(ctx, tv_obj);
    duk_push_tval(ctx, tv_key);
 
    tv_obj = DUK_GET_TVAL_NEGIDX(ctx, -2);
    if (DUK_TVAL_IS_OBJECT(tv_obj)) {
        duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_obj);
        DUK_ASSERT(obj != NULL);
 
#if defined(DUK_USE_ES6_PROXY)
        if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
            duk_hobject *h_target;
            duk_bool_t tmp_bool;
 
            /* Note: proxy handling must happen before key is string coerced. */
 
            if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_DELETE_PROPERTY, tv_key, &h_target)) {
                /* -> [ ... obj key trap handler ] */
                DUK_DDD(DUK_DDDPRINT("-> proxy object 'deleteProperty' for key %!T", (duk_tval *) tv_key));
                duk_push_hobject(ctx, h_target);  /* target */
                duk_dup(ctx, -4);  /* P */
                duk_call_method(ctx, 2 /*nargs*/);
                tmp_bool = duk_to_boolean(ctx, -1);
                duk_pop(ctx);
                if (!tmp_bool) {
                    goto fail_proxy_rejected;  /* retval indicates delete failed */
                }
 
                /* Target object must be checked for a conflicting
                 * non-configurable property.
                 */
                tv_key = DUK_GET_TVAL_NEGIDX(ctx, -1);
                arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
                DUK_ASSERT(key != NULL);
 
                if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
                    int desc_reject;
 
                    DUK_DDD(DUK_DDDPRINT("proxy 'deleteProperty': target has matching property %!O, check for "
                                         "conflicting property; desc.flags=0x%08lx, "
                                         "desc.get=%p, desc.set=%p",
                                         (duk_heaphdr *) key, (unsigned long) desc.flags,
                                         (void *) desc.get, (void *) desc.set));
 
                    desc_reject = !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE);
                    if (desc_reject) {
                        /* unconditional */
                        DUK_ERROR_TYPE(thr, DUK_STR_PROXY_REJECTED);
                    }
                }
                rc = 1;  /* success */
                goto done_rc;
            }
 
            obj = h_target;  /* resume delete to target */
        }
#endif  /* DUK_USE_ES6_PROXY */
 
        duk_to_string(ctx, -1);
        key = duk_get_hstring(ctx, -1);
        DUK_ASSERT(key != NULL);
 
        rc = duk_hobject_delprop_raw(thr, obj, key, throw_flag ? DUK_DELPROP_FLAG_THROW : 0);
        goto done_rc;
    } else if (DUK_TVAL_IS_STRING(tv_obj)) {
        /* XXX: unnecessary string coercion for array indices,
         * intentional to keep small.
         */
        duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
        DUK_ASSERT(h != NULL);
 
        duk_to_string(ctx, -1);
        key = duk_get_hstring(ctx, -1);
        DUK_ASSERT(key != NULL);
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            goto fail_not_configurable;
        }
 
        arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
 
        if (arr_idx != DUK__NO_ARRAY_INDEX &&
            arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
            goto fail_not_configurable;
        }
    } else if (DUK_TVAL_IS_BUFFER(tv_obj)) {
        /* XXX: unnecessary string coercion for array indices,
         * intentional to keep small; some overlap with string
         * handling.
         */
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
        DUK_ASSERT(h != NULL);
 
        duk_to_string(ctx, -1);
        key = duk_get_hstring(ctx, -1);
        DUK_ASSERT(key != NULL);
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            goto fail_not_configurable;
        }
 
        arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
 
        if (arr_idx != DUK__NO_ARRAY_INDEX &&
            arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
            goto fail_not_configurable;
        }
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) {
        /* Lightfunc virtual properties are non-configurable, so
         * reject if match any of them.
         */
 
        duk_to_string(ctx, -1);
        key = duk_get_hstring(ctx, -1);
        DUK_ASSERT(key != NULL);
 
        if (duk__key_is_lightfunc_ownprop(thr, key)) {
            goto fail_not_configurable;
        }
    }
 
    /* non-object base, no offending virtual property */
    rc = 1;
    goto done_rc;
 
 done_rc:
    duk_set_top(ctx, entry_top);
    return rc;
 
 fail_invalid_base_uncond:
    /* Note: unconditional throw */
    DUK_ASSERT(duk_get_top(ctx) == entry_top);
#if defined(DUK_USE_PARANOID_ERRORS)
    DUK_ERROR_TYPE(thr, DUK_STR_INVALID_BASE);
#else
    DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot delete property %s of %s",
                   duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj));
#endif
    return 0;

◆ duk_hobject_delprop_raw()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop_raw	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_small_uint_t	flags )

Definition at line 51564 of file duktape-1.8.0/src/duktape.c.

              :
    DUK_DDD(DUK_DDDPRINT("result: error, internal"));
    if (throw_flag) {
        DUK_ERROR_INTERNAL_DEFMSG(thr);
    }
    duk_pop(ctx);  /* remove key */
    return 0;
}
 
/*
 *  Ecmascript compliant [[Delete]](P, Throw).
 */
 
DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) {
    duk_propdesc desc;
    duk_tval *tv;
    duk_uint32_t arr_idx;
    duk_bool_t throw_flag;
    duk_bool_t force_flag;
 
    throw_flag = (flags & DUK_DELPROP_FLAG_THROW);
    force_flag = (flags & DUK_DELPROP_FLAG_FORCE);
 
    DUK_DDD(DUK_DDDPRINT("delprop_raw: thr=%p, obj=%p, key=%p, throw=%ld, force=%ld (obj -> %!O, key -> %!O)",
                         (void *) thr, (void *) obj, (void *) key, (long) throw_flag, (long) force_flag,
                         (duk_heaphdr *) obj, (duk_heaphdr *) key));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
 
    /* 0 = don't push current value */
    if (!duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
        DUK_DDD(DUK_DDDPRINT("property not found, succeed always"));
        goto success;
    }
 
#if defined(DUK_USE_ROM_OBJECTS)
    if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj)) {
        DUK_DD(DUK_DDPRINT("attempt to delprop on read-only target object"));
        goto fail_not_configurable;
    }
#endif
 
    if ((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) == 0 && !force_flag) {
        goto fail_not_configurable;
    }
    if (desc.a_idx < 0 && desc.e_idx < 0) {
        /* Currently there are no deletable virtual properties, but
         * with force_flag we might attempt to delete one.
         */
        goto fail_virtual;
    }
 
    if (desc.a_idx >= 0) {
        DUK_ASSERT(desc.e_idx < 0);
 
        tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx);
        DUK_TVAL_SET_UNUSED_UPDREF(thr, tv);  /* side effects */
        goto success;
    } else {
        duk_hobject *h_get = NULL;
        duk_hobject *h_set = NULL;
        duk_tval tv_tmp;
 
        DUK_ASSERT(desc.a_idx < 0);
 
        /* Set property slot to an empty state.  Careful not to invoke
         * any side effects while using desc.e_idx so that it doesn't
         * get invalidated by a finalizer mutating our object.
         */
 
        /* remove hash entry (no decref) */
#if defined(DUK_USE_HOBJECT_HASH_PART)
        if (desc.h_idx >= 0) {
            duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj);
 
            DUK_DDD(DUK_DDDPRINT("removing hash entry at h_idx %ld", (long) desc.h_idx));
            DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) > 0);
            DUK_ASSERT((duk_uint32_t) desc.h_idx < DUK_HOBJECT_GET_HSIZE(obj));
            h_base[desc.h_idx] = DUK__HASH_DELETED;
        } else {
            DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) == 0);
        }
#else
        DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) == 0);
#endif
 
        /* remove value */
        DUK_DDD(DUK_DDDPRINT("before removing value, e_idx %ld, key %p, key at slot %p",
                             (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)));
        DUK_DDD(DUK_DDDPRINT("removing value at e_idx %ld", (long) desc.e_idx));
        DUK_MEMSET((void *) &tv_tmp, 0, sizeof(tv_tmp));
        DUK_TVAL_SET_UNDEFINED(&tv_tmp);
        if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx)) {
            h_get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, desc.e_idx);
            h_set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, desc.e_idx);
            DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, desc.e_idx, NULL);
            DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, desc.e_idx, NULL);
        } else {
            tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
            DUK_TVAL_SET_TVAL(&tv_tmp, tv);
            DUK_TVAL_SET_UNDEFINED(tv);
        }
#if 0
        /* Not strictly necessary because if key == NULL, flag MUST be ignored. */
        DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, 0);
#endif
 
        /* remove key */
        DUK_DDD(DUK_DDDPRINT("before removing key, e_idx %ld, key %p, key at slot %p",
                             (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)));
        DUK_DDD(DUK_DDDPRINT("removing key at e_idx %ld", (long) desc.e_idx));
        DUK_ASSERT(key == DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx));
        DUK_HOBJECT_E_SET_KEY(thr->heap, obj, desc.e_idx, NULL);
 
        /* Do decrefs only with safe pointers to avoid side effects
         * disturbing e_idx.
         */
        DUK_TVAL_DECREF(thr, &tv_tmp);
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_get);
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_set);
        DUK_HSTRING_DECREF(thr, key);
        goto success;
    }
 
    DUK_UNREACHABLE();
 
 success:
    /*
     *  Argument exotic [[Delete]] behavior (E5 Section 10.6) is
     *  a post-check, keeping arguments internal 'map' in sync with
     *  any successful deletes (note that property does not need to
     *  exist for delete to 'succeed').
     *
     *  Delete key from 'map'.  Since 'map' only contains array index
     *  keys, we can use arr_idx for a fast skip.
     */
 
    DUK_DDD(DUK_DDDPRINT("delete successful, check for arguments exotic behavior"));
 
    if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) {
        /* Note: only numbered indices are relevant, so arr_idx fast reject
         * is good (this is valid unless there are more than 4**32-1 arguments).
         */
 
        DUK_DDD(DUK_DDDPRINT("delete successful, arguments exotic behavior needed"));
 
        /* Note: we can reuse 'desc' here */
        (void) duk__check_arguments_map_for_delete(thr, obj, key, &desc);
    }
 
    DUK_DDD(DUK_DDDPRINT("delete successful"));
    return 1;

Referenced by duk__delvar_helper(), and duk_hobject_define_property_helper().

◆ duk_hobject_enumerator_create()

DUK_INTERNAL_DECL void duk_hobject_enumerator_create	(	duk_context *	ctx,
		duk_small_uint_t	enum_flags )

Definition at line 46550 of file duktape-1.8.0/src/duktape.c.

                                                                                               {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *enum_target;
    duk_hobject *curr;
    duk_hobject *res;
#if defined(DUK_USE_ES6_PROXY)
    duk_hobject *h_proxy_target;
    duk_hobject *h_proxy_handler;
    duk_hobject *h_trap_result;
#endif
    duk_uint_fast32_t i, len;  /* used for array, stack, and entry indices */
 
    DUK_ASSERT(ctx != NULL);
 
    DUK_DDD(DUK_DDDPRINT("create enumerator, stack top: %ld", (long) duk_get_top(ctx)));
 
    enum_target = duk_require_hobject(ctx, -1);
    DUK_ASSERT(enum_target != NULL);
 
    duk_push_object_internal(ctx);
    res = duk_require_hobject(ctx, -1);
 
    DUK_DDD(DUK_DDDPRINT("created internal object"));
 
    /* [enum_target res] */
 
    /* Target must be stored so that we can recheck whether or not
     * keys still exist when we enumerate.  This is not done if the
     * enumeration result comes from a proxy trap as there is no
     * real object to check against.
     */
    duk_push_hobject(ctx, enum_target);
    duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET);
 
    /* Initialize index so that we skip internal control keys. */
    duk_push_int(ctx, DUK__ENUM_START_INDEX);
    duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT);
 
    /*
     *  Proxy object handling
     */
 
#if defined(DUK_USE_ES6_PROXY)
    if (DUK_LIKELY((enum_flags & DUK_ENUM_NO_PROXY_BEHAVIOR) != 0)) {
        goto skip_proxy;
    }
    if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
                                            enum_target,
                                            &h_proxy_target,
                                            &h_proxy_handler))) {
        goto skip_proxy;
    }
 
    DUK_DDD(DUK_DDDPRINT("proxy enumeration"));
    duk_push_hobject(ctx, h_proxy_handler);
    if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ENUMERATE)) {
        /* No need to replace the 'enum_target' value in stack, only the
         * enum_target reference.  This also ensures that the original
         * enum target is reachable, which keeps the proxy and the proxy
         * target reachable.  We do need to replace the internal _Target.
         */
        DUK_DDD(DUK_DDDPRINT("no enumerate trap, enumerate proxy target instead"));
        DUK_DDD(DUK_DDDPRINT("h_proxy_target=%!O", (duk_heaphdr *) h_proxy_target));
        enum_target = h_proxy_target;
 
        duk_push_hobject(ctx, enum_target);  /* -> [ ... enum_target res handler undefined target ] */
        duk_put_prop_stridx(ctx, -4, DUK_STRIDX_INT_TARGET);
 
        duk_pop_2(ctx);  /* -> [ ... enum_target res ] */
        goto skip_proxy;
    }
 
    /* [ ... enum_target res handler trap ] */
    duk_insert(ctx, -2);
    duk_push_hobject(ctx, h_proxy_target);    /* -> [ ... enum_target res trap handler target ] */
    duk_call_method(ctx, 1 /*nargs*/);        /* -> [ ... enum_target res trap_result ] */
    h_trap_result = duk_require_hobject(ctx, -1);
    DUK_UNREF(h_trap_result);
 
    /* Copy trap result keys into the enumerator object. */
    len = (duk_uint_fast32_t) duk_get_length(ctx, -1);
    for (i = 0; i < len; i++) {
        /* XXX: not sure what the correct semantic details are here,
         * e.g. handling of missing values (gaps), handling of non-array
         * trap results, etc.
         *
         * For keys, we simply skip non-string keys which seems to be
         * consistent with how e.g. Object.keys() will process proxy trap
         * results (ES6, Section 19.1.2.14).
         */
        if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) {
            /* [ ... enum_target res trap_result val ] */
            duk_push_true(ctx);
            /* [ ... enum_target res trap_result val true ] */
            duk_put_prop(ctx, -4);
        } else {
            duk_pop(ctx);
        }
    }
    /* [ ... enum_target res trap_result ] */
    duk_pop(ctx);
    duk_remove(ctx, -2);
 
    /* [ ... res ] */
 
    /* The internal _Target property is kept pointing to the original
     * enumeration target (the proxy object), so that the enumerator
     * 'next' operation can read property values if so requested.  The
     * fact that the _Target is a proxy disables key existence check
     * during enumeration.
     */
    DUK_DDD(DUK_DDDPRINT("proxy enumeration, final res: %!O", (duk_heaphdr *) res));
    goto compact_and_return;
 
 skip_proxy:
#endif  /* DUK_USE_ES6_PROXY */
 
    curr = enum_target;
    while (curr) {
        /*
         *  Virtual properties.
         *
         *  String and buffer indices are virtual and always enumerable,
         *  'length' is virtual and non-enumerable.  Array and arguments
         *  object props have special behavior but are concrete.
         */
 
        if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr) ||
            DUK_HOBJECT_IS_BUFFEROBJECT(curr)) {
            /* String and buffer enumeration behavior is identical now,
             * so use shared handler.
             */
            if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)) {
                duk_hstring *h_val;
                h_val = duk_hobject_get_internal_value_string(thr->heap, curr);
                DUK_ASSERT(h_val != NULL);  /* string objects must not created without internal value */
                len = (duk_uint_fast32_t) DUK_HSTRING_GET_CHARLEN(h_val);
            } else {
                duk_hbufferobject *h_bufobj;
                DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT(curr));
                h_bufobj = (duk_hbufferobject *) curr;
                if (h_bufobj == NULL) {
                    /* Neutered buffer, zero length seems
                     * like good behavior here.
                     */
                    len = 0;
                } else {
                    /* There's intentionally no check for
                     * current underlying buffer length.
                     */
                    len = (duk_uint_fast32_t) (h_bufobj->length >> h_bufobj->shift);
                }
            }
 
            for (i = 0; i < len; i++) {
                duk_hstring *k;
 
                k = duk_heap_string_intern_u32_checked(thr, i);
                DUK_ASSERT(k);
                duk_push_hstring(ctx, k);
                duk_push_true(ctx);
 
                /* [enum_target res key true] */
                duk_put_prop(ctx, -3);
 
                /* [enum_target res] */
            }
 
            /* 'length' and other virtual properties are not
             * enumerable, but are included if non-enumerable
             * properties are requested.
             */
 
            if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
                duk_uint_fast32_t n;
 
                if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) {
                    n = sizeof(duk__bufferobject_virtual_props) / sizeof(duk_uint16_t);
                } else {
                    DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr));
                    DUK_ASSERT(duk__bufferobject_virtual_props[0] == DUK_STRIDX_LENGTH);
                    n = 1;  /* only 'length' */
                }
 
                for (i = 0; i < n; i++) {
                    duk_push_hstring_stridx(ctx, duk__bufferobject_virtual_props[i]);
                    duk_push_true(ctx);
                    duk_put_prop(ctx, -3);
                }
 
            }
        } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) {
            if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
                duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
                duk_push_true(ctx);
                duk_put_prop(ctx, -3);
            }
        }
 
        /*
         *  Array part
         *
         *  Note: ordering between array and entry part must match 'abandon array'
         *  behavior in duk_hobject_props.c: key order after an array is abandoned
         *  must be the same.
         */
 
        for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(curr); i++) {
            duk_hstring *k;
            duk_tval *tv;
 
            tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, curr, i);
            if (DUK_TVAL_IS_UNUSED(tv)) {
                continue;
            }
            k = duk_heap_string_intern_u32_checked(thr, i);
            DUK_ASSERT(k);
 
            duk_push_hstring(ctx, k);
            duk_push_true(ctx);
 
            /* [enum_target res key true] */
            duk_put_prop(ctx, -3);
 
            /* [enum_target res] */
        }
 
        /*
         *  Entries part
         */
 
        for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(curr); i++) {
            duk_hstring *k;
 
            k = DUK_HOBJECT_E_GET_KEY(thr->heap, curr, i);
            if (!k) {
                continue;
            }
            if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(thr->heap, curr, i) &&
                !(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) {
                continue;
            }
            if (DUK_HSTRING_HAS_INTERNAL(k) &&
                !(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) {
                continue;
            }
            if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) &&
                (DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) {
                continue;
            }
 
            DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, curr, i) ||
                       !DUK_TVAL_IS_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(thr->heap, curr, i)->v));
 
            duk_push_hstring(ctx, k);
            duk_push_true(ctx);
 
            /* [enum_target res key true] */
            duk_put_prop(ctx, -3);
 
            /* [enum_target res] */
        }
 
        if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) {
            break;
        }
 
        curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
    }
 
    /* [enum_target res] */
 
    duk_remove(ctx, -2);
 
    /* [res] */
 
    if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) ==
                      (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) {
        /*
         *  Some E5/E5.1 algorithms require that array indices are iterated
         *  in a strictly ascending order.  This is the case for e.g.
         *  Array.prototype.forEach() and JSON.stringify() PropertyList
         *  handling.
         *
         *  To ensure this property for arrays with an array part (and
         *  arbitrary objects too, since e.g. forEach() can be applied
         *  to an array), the caller can request that we sort the keys
         *  here.
         */
 
        /* XXX: avoid this at least when enum_target is an Array, it has an
         * array part, and no ancestor properties were included?  Not worth

◆ duk_hobject_enumerator_next()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_enumerator_next	(	duk_context *	ctx,
		duk_bool_t	get_value )

Definition at line 46868 of file duktape-1.8.0/src/duktape.c.

                   :
#endif
    /* compact; no need to seal because object is internal */
    duk_hobject_compact_props(thr, res);
 
    DUK_DDD(DUK_DDDPRINT("created enumerator object: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
}
 
/*
 *  Returns non-zero if a key and/or value was enumerated, and:
 *
 *   [enum] -> [key]        (get_value == 0)
 *   [enum] -> [key value]  (get_value == 1)
 *
 *  Returns zero without pushing anything on the stack otherwise.
 */
DUK_INTERNAL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *e;
    duk_hobject *enum_target;
    duk_hstring *res = NULL;
    duk_uint_fast32_t idx;
    duk_bool_t check_existence;
 
    DUK_ASSERT(ctx != NULL);
 
    /* [... enum] */
 
    e = duk_require_hobject(ctx, -1);
 
    /* XXX use get tval ptr, more efficient */
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_NEXT);
    idx = (duk_uint_fast32_t) duk_require_uint(ctx, -1);
    duk_pop(ctx);
    DUK_DDD(DUK_DDDPRINT("enumeration: index is: %ld", (long) idx));
 
    /* Enumeration keys are checked against the enumeration target (to see
     * that they still exist).  In the proxy enumeration case _Target will
     * be the proxy, and checking key existence against the proxy is not
     * required (or sensible, as the keys may be fully virtual).
     */
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);
    enum_target = duk_require_hobject(ctx, -1);
    DUK_ASSERT(enum_target != NULL);
#if defined(DUK_USE_ES6_PROXY)
    check_existence = (!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(enum_target));
#else
    check_existence = 1;
#endif
    duk_pop(ctx);  /* still reachable */
 
    DUK_DDD(DUK_DDDPRINT("getting next enum value, enum_target=%!iO, enumerator=%!iT",
                         (duk_heaphdr *) enum_target, (duk_tval *) duk_get_tval(ctx, -1)));
 
    /* no array part */
    for (;;) {
        duk_hstring *k;
 
        if (idx >= DUK_HOBJECT_GET_ENEXT(e)) {
            DUK_DDD(DUK_DDDPRINT("enumeration: ran out of elements"));
            break;
        }
 
        /* we know these because enum objects are internally created */
        k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, idx);
        DUK_ASSERT(k != NULL);
        DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, e, idx));
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(&DUK_HOBJECT_E_GET_VALUE(thr->heap, e, idx).v));
 
        idx++;
 
        /* recheck that the property still exists */
        if (check_existence && !duk_hobject_hasprop_raw(thr, enum_target, k)) {
            DUK_DDD(DUK_DDDPRINT("property deleted during enumeration, skip"));
            continue;
        }
 
        DUK_DDD(DUK_DDDPRINT("enumeration: found element, key: %!O", (duk_heaphdr *) k));
        res = k;
        break;
    }
 
    DUK_DDD(DUK_DDDPRINT("enumeration: updating next index to %ld", (long) idx));
 
    duk_push_u32(ctx, (duk_uint32_t) idx);
    duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT);
 
    /* [... enum] */
 

◆ duk_hobject_find_existing_array_entry_tval_ptr()

DUK_INTERNAL_DECL duk_tval * duk_hobject_find_existing_array_entry_tval_ptr	(	duk_heap *	heap,
		duk_hobject *	obj,
		duk_uarridx_t	i )

Definition at line 48649 of file duktape-1.8.0/src/duktape.c.

                                                                         {
        *out_attrs = DUK_HOBJECT_E_GET_FLAGS(heap, obj, e_idx);
        return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx);
    } else {
        *out_attrs = 0;
        return NULL;
    }
}

◆ duk_hobject_find_existing_entry()

DUK_INTERNAL_DECL void duk_hobject_find_existing_entry	(	duk_heap *	heap,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_int_t *	e_idx,
		duk_int_t *	h_idx )

Definition at line 48528 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                          {
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(e_idx != NULL);
    DUK_ASSERT(h_idx != NULL);
    DUK_UNREF(heap);
 
    if (DUK_LIKELY(DUK_HOBJECT_GET_HSIZE(obj) == 0))
    {
        /* Linear scan: more likely because most objects are small.
         * This is an important fast path.
         *
         * XXX: this might be worth inlining for property lookups.
         */
        duk_uint_fast32_t i;
        duk_uint_fast32_t n;
        duk_hstring **h_keys_base;
        DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using linear scan for lookup"));
 
        h_keys_base = DUK_HOBJECT_E_GET_KEY_BASE(heap, obj);
        n = DUK_HOBJECT_GET_ENEXT(obj);
        for (i = 0; i < n; i++) {
            if (h_keys_base[i] == key) {
                *e_idx = i;
                *h_idx = -1;
                return;
            }
        }
    }
#if defined(DUK_USE_HOBJECT_HASH_PART)
    else
    {
        /* hash lookup */
        duk_uint32_t n;
        duk_uint32_t i, step;
        duk_uint32_t *h_base;
 
        DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using hash part for lookup"));
 
        h_base = DUK_HOBJECT_H_GET_BASE(heap, obj);
        n = DUK_HOBJECT_GET_HSIZE(obj);
        i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n);
        step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key));
 
        for (;;) {
            duk_uint32_t t;
 
            DUK_ASSERT_DISABLE(i >= 0);  /* unsigned */
            DUK_ASSERT(i < DUK_HOBJECT_GET_HSIZE(obj));
            t = h_base[i];
            DUK_ASSERT(t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED ||
                       (t < DUK_HOBJECT_GET_ESIZE(obj)));  /* t >= 0 always true, unsigned */
 
            if (t == DUK__HASH_UNUSED) {
                break;
            } else if (t == DUK__HASH_DELETED) {
                DUK_DDD(DUK_DDDPRINT("lookup miss (deleted) i=%ld, t=%ld",
                                     (long) i, (long) t));
            } else {
                DUK_ASSERT(t < DUK_HOBJECT_GET_ESIZE(obj));
                if (DUK_HOBJECT_E_GET_KEY(heap, obj, t) == key) {
                    DUK_DDD(DUK_DDDPRINT("lookup hit i=%ld, t=%ld -> key %p",
                                         (long) i, (long) t, (void *) key));
                    *e_idx = t;
                    *h_idx = i;

Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), and duk_hobject_find_existing_entry_tval_ptr_and_attrs().

◆ duk_hobject_find_existing_entry_tval_ptr()

DUK_INTERNAL_DECL duk_tval * duk_hobject_find_existing_entry_tval_ptr	(	duk_heap *	heap,
		duk_hobject *	obj,
		duk_hstring *	key )

Definition at line 48612 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__declvar_helper(), duk__err_augment_user(), and duk__getid_open_decl_env_regs().

◆ duk_hobject_find_existing_entry_tval_ptr_and_attrs()

DUK_INTERNAL_DECL duk_tval * duk_hobject_find_existing_entry_tval_ptr_and_attrs	(	duk_heap *	heap,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_int_t *	out_attrs )

Definition at line 48629 of file duktape-1.8.0/src/duktape.c.

                                                                                                                    {
    duk_int_t e_idx;
    duk_int_t h_idx;
 
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_UNREF(heap);
 
    duk_hobject_find_existing_entry(heap, obj, key, &e_idx, &h_idx);
    if (e_idx >= 0 && !DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)) {
        return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx);
    } else {
        return NULL;
    }
}
 
/* For internal use: get non-accessor entry value and attributes */
DUK_INTERNAL duk_tval *duk_hobject_find_existing_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *out_attrs) {

References DUK_ASSERT, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, DUK_HOBJECT_E_SLOT_IS_ACCESSOR, duk_hobject_find_existing_entry(), DUK_UNREF, and NULL.

◆ duk_hobject_get_enumerated_keys()

DUK_INTERNAL_DECL duk_ret_t duk_hobject_get_enumerated_keys	(	duk_context *	ctx,
		duk_small_uint_t	enum_flags )

Definition at line 46964 of file duktape-1.8.0/src/duktape.c.

               {
            duk_remove(ctx, -2);   /* -> [... key] */
        }
        return 1;
    } else {
        duk_pop(ctx);  /* -> [...] */
        return 0;
    }
}
 
/*
 *  Get enumerated keys in an Ecmascript array.  Matches Object.keys() behavior
 *  described in E5 Section 15.2.3.14.
 */
 
DUK_INTERNAL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_small_uint_t enum_flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *e;
    duk_uint_fast32_t i;
    duk_uint_fast32_t idx;
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(duk_get_hobject(ctx, -1) != NULL);
    DUK_UNREF(thr);
 
    /* Create a temporary enumerator to get the (non-duplicated) key list;
     * the enumerator state is initialized without being needed, but that
     * has little impact.
     */
 
    duk_hobject_enumerator_create(ctx, enum_flags);
    duk_push_array(ctx);
 
    /* [enum_target enum res] */
 
    e = duk_require_hobject(ctx, -2);
    DUK_ASSERT(e != NULL);
 
    idx = 0;
    for (i = DUK__ENUM_START_INDEX; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(e); i++) {
        duk_hstring *k;

◆ duk_hobject_get_internal_value()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_get_internal_value	(	duk_heap *	heap,
		duk_hobject *	obj,
		duk_tval *	tv )

Definition at line 48752 of file duktape-1.8.0/src/duktape.c.

48769 {

◆ duk_hobject_get_internal_value_string()

DUK_INTERNAL_DECL duk_hstring * duk_hobject_get_internal_value_string	(	duk_heap *	heap,
		duk_hobject *	obj )

Definition at line 48771 of file duktape-1.8.0/src/duktape.c.

                    {
        DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx));
        DUK_TVAL_SET_TVAL(tv_out, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx));
        return 1;
    }
    DUK_TVAL_SET_UNDEFINED(tv_out);
    return 0;
}
 
DUK_INTERNAL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj) {
    duk_tval tv;
 

Referenced by duk__get_own_propdesc_raw().

◆ duk_hobject_get_length()

DUK_INTERNAL_DECL duk_uint32_t duk_hobject_get_length	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 52173 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    duk_context *ctx = (duk_context *) thr;
    duk_push_hobject(ctx, obj);
    duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
    duk_push_u32(ctx, length);
    (void) duk_hobject_putprop(thr,
                               DUK_GET_TVAL_NEGIDX(ctx, -3),
                               DUK_GET_TVAL_NEGIDX(ctx, -2),
                               DUK_GET_TVAL_NEGIDX(ctx, -1),
                               0);
    duk_pop_n(ctx, 3);
}
 
DUK_INTERNAL void duk_hobject_set_length_zero(duk_hthread *thr, duk_hobject *obj) {
    duk_hobject_set_length(thr, obj, 0);

References DUK_GET_TVAL_NEGIDX, duk_hobject_putprop(), duk_pop_n(), duk_push_hobject(), duk_push_hstring_stridx(), duk_push_u32, and DUK_STRIDX_LENGTH.

◆ duk_hobject_get_own_propdesc()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_get_own_propdesc	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key,
		duk_propdesc *	out_desc,
		duk_small_uint_t	flags )

Definition at line 49294 of file duktape-1.8.0/src/duktape.c.

                                                                         {
            DUK_DDD(DUK_DDDPRINT("-> arguments exotic behavior overrides result: %!T -> %!T",
                                 (duk_tval *) duk_get_tval(ctx, -2),
                                 (duk_tval *) duk_get_tval(ctx, -1)));

◆ duk_hobject_getprop()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_getprop	(	duk_hthread *	thr,
		duk_tval *	tv_obj,
		duk_tval *	tv_key )

Definition at line 49633 of file duktape-1.8.0/src/duktape.c.

                                                                                                          {
        data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
        duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size);
    } else {
        DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)"));
    }
 
    duk_pop(ctx);
    return 1;
}
 
/*
 *  GETPROP: Ecmascript property read.
 */
 
DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key) {
    duk_context *ctx = (duk_context *) thr;
    duk_tval tv_obj_copy;
    duk_tval tv_key_copy;
    duk_hobject *curr = NULL;
    duk_hstring *key = NULL;
    duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX;
    duk_propdesc desc;
    duk_uint_t sanity;
 
    DUK_DDD(DUK_DDDPRINT("getprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
                         (void *) thr, (void *) tv_obj, (void *) tv_key,
                         (duk_tval *) tv_obj, (duk_tval *) tv_key));
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(tv_obj != NULL);
    DUK_ASSERT(tv_key != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /*
     *  Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of
     *  them being invalidated by a valstack resize.
     *
     *  XXX: this is now an overkill for many fast paths.  Rework this
     *  to be faster (although switching to a valstack discipline might
     *  be a better solution overall).
     */
 
    DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj);
    DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
    tv_obj = &tv_obj_copy;
    tv_key = &tv_key_copy;
 
    /*
     *  Coercion and fast path processing
     */
 
    switch (DUK_TVAL_GET_TAG(tv_obj)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL: {
        /* Note: unconditional throw */
        DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject"));
#if defined(DUK_USE_PARANOID_ERRORS)
        DUK_ERROR_TYPE(thr, DUK_STR_INVALID_BASE);
#else
        DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot read property %s of %s",
                       duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj));
#endif
        return 0;
    }
 
    case DUK_TAG_BOOLEAN: {
        DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype"));
        curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE];
        break;
    }
 
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
        duk_int_t pop_count;
 
#if defined(DUK_USE_FASTINT)
        if (DUK_TVAL_IS_FASTINT(tv_key)) {
            arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
            DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
            pop_count = 0;
        } else
#endif
        if (DUK_TVAL_IS_NUMBER(tv_key)) {
            arr_idx = duk__tval_number_to_arr_idx(tv_key);
            DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path number; arr_idx %ld", (long) arr_idx));
            pop_count = 0;
        } else {
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
            DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after "
                                 "coercion key is %!T, arr_idx %ld",
                                 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
            pop_count = 1;
        }
 
        if (arr_idx != DUK__NO_ARRAY_INDEX &&
            arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
            duk_pop_n(ctx, pop_count);
            duk_push_hstring(ctx, h);
            duk_substring(ctx, -1, arr_idx, arr_idx + 1);  /* [str] -> [substr] */
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is an index inside string length "
                                 "after coercion -> return char)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        }
 
        if (pop_count == 0) {
            /* This is a pretty awkward control flow, but we need to recheck the
             * key coercion here.
             */
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
            DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after "
                                 "coercion key is %!T, arr_idx %ld",
                                 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
        }
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            duk_pop(ctx);  /* [key] -> [] */
            duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h));  /* [] -> [res] */
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is 'length' after coercion -> "
                                 "return string length)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        }
        DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype"));
        curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE];
        goto lookup;  /* avoid double coercion */
    }
 
    case DUK_TAG_OBJECT: {
        duk_tval *tmp;
 
        curr = DUK_TVAL_GET_OBJECT(tv_obj);
        DUK_ASSERT(curr != NULL);
 
        tmp = duk__getprop_shallow_fastpath_array_tval(thr, curr, tv_key);
        if (tmp) {
            duk_push_tval(ctx, tmp);
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is object, key is a number, array part "
                                 "fast path)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        }
 
        if (duk__getprop_fastpath_bufobj_tval(thr, curr, tv_key) != 0) {
            /* Read value pushed on stack. */
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is bufobj, key is a number, bufferobject "
                                 "fast path)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        }
 
#if defined(DUK_USE_ES6_PROXY)
        if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(curr))) {
            duk_hobject *h_target;
 
            if (duk__proxy_check_prop(thr, curr, DUK_STRIDX_GET, tv_key, &h_target)) {
                /* -> [ ... trap handler ] */
                DUK_DDD(DUK_DDDPRINT("-> proxy object 'get' for key %!T", (duk_tval *) tv_key));
                duk_push_hobject(ctx, h_target);  /* target */
                duk_push_tval(ctx, tv_key);       /* P */
                duk_push_tval(ctx, tv_obj);       /* Receiver: Proxy object */
                duk_call_method(ctx, 3 /*nargs*/);
 
                /* Target object must be checked for a conflicting
                 * non-configurable property.
                 */
                arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
                DUK_ASSERT(key != NULL);
 
                if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
                    duk_tval *tv_hook = duk_require_tval(ctx, -3);  /* value from hook */
                    duk_tval *tv_targ = duk_require_tval(ctx, -1);  /* value from target */
                    duk_bool_t datadesc_reject;
                    duk_bool_t accdesc_reject;
 
                    DUK_DDD(DUK_DDDPRINT("proxy 'get': target has matching property %!O, check for "
                                         "conflicting property; tv_hook=%!T, tv_targ=%!T, desc.flags=0x%08lx, "
                                         "desc.get=%p, desc.set=%p",
                                         (duk_heaphdr *) key, (duk_tval *) tv_hook, (duk_tval *) tv_targ,
                                         (unsigned long) desc.flags,
                                         (void *) desc.get, (void *) desc.set));
 
                    datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
                                      !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
                                      !(desc.flags & DUK_PROPDESC_FLAG_WRITABLE) &&
                                      !duk_js_samevalue(tv_hook, tv_targ);
                    accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
                                     !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
                                     (desc.get == NULL) &&
                                     !DUK_TVAL_IS_UNDEFINED(tv_hook);
                    if (datadesc_reject || accdesc_reject) {
                        DUK_ERROR_TYPE(thr, DUK_STR_PROXY_REJECTED);
                    }
 
                    duk_pop_2(ctx);
                } else {
                    duk_pop(ctx);
                }
                return 1;  /* return value */
            }
 
            curr = h_target;  /* resume lookup from target */
            DUK_TVAL_SET_OBJECT(tv_obj, curr);
        }
#endif  /* DUK_USE_ES6_PROXY */
 
        if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(curr)) {
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
 
            if (duk__check_arguments_map_for_get(thr, curr, key, &desc)) {
                DUK_DDD(DUK_DDDPRINT("-> %!T (base is object with arguments exotic behavior, "
                                     "key matches magically bound property -> skip standard "
                                     "Get with replacement value)",
                                     (duk_tval *) duk_get_tval(ctx, -1)));
 
                /* no need for 'caller' post-check, because 'key' must be an array index */
 
                duk_remove(ctx, -2);  /* [key result] -> [result] */
                return 1;
            }
 
            goto lookup;  /* avoid double coercion */
        }
        break;
    }
 
    /* Buffer has virtual properties similar to string, but indexed values
     * are numbers, not 1-byte buffers/strings which would perform badly.
     */
    case DUK_TAG_BUFFER: {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
        duk_int_t pop_count;
 
        /*
         *  Because buffer values are often looped over, a number fast path
         *  is important.
         */
 
#if defined(DUK_USE_FASTINT)
        if (DUK_TVAL_IS_FASTINT(tv_key)) {
            arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
            pop_count = 0;
        }
        else
#endif
        if (DUK_TVAL_IS_NUMBER(tv_key)) {
            arr_idx = duk__tval_number_to_arr_idx(tv_key);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx));
            pop_count = 0;
        } else {
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
                                 "coercion key is %!T, arr_idx %ld",
                                 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
            pop_count = 1;
        }
 
        if (arr_idx != DUK__NO_ARRAY_INDEX &&
            arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
            duk_pop_n(ctx, pop_count);
            duk_push_uint(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h))[arr_idx]);
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is an index inside buffer length "
                                 "after coercion -> return byte as number)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        }
 
        if (pop_count == 0) {
            /* This is a pretty awkward control flow, but we need to recheck the
             * key coercion here.
             */
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
                                 "coercion key is %!T, arr_idx %ld",
                                 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
        }
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
            key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) {
            duk_pop(ctx);  /* [key] -> [] */
            duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h));  /* [] -> [res] */
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'length' or 'byteLength' "
                                 "after coercion -> return buffer length)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) {
            duk_pop(ctx);  /* [key] -> [] */
            duk_push_uint(ctx, 0);  /* [] -> [res] */
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'byteOffset' after coercion -> "
                                 "return 0 for consistency with Buffer objects)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) {
            duk_pop(ctx);  /* [key] -> [] */
            duk_push_uint(ctx, 1);  /* [] -> [res] */
 
            DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'BYTES_PER_ELEMENT' after coercion -> "
                                 "return 1 for consistency with Buffer objects)",
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            return 1;
        }
 
        DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype"));
        curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE];
        goto lookup;  /* avoid double coercion */
    }
 
    case DUK_TAG_POINTER: {
        DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype"));
        curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE];
        break;
    }
 
    case DUK_TAG_LIGHTFUNC: {
        duk_int_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_obj);
 
        /* Must coerce key: if key is an object, it may coerce to e.g. 'length'. */
        arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            duk_int_t lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
            duk_pop(ctx);
            duk_push_int(ctx, lf_len);
            return 1;
        } else if (key == DUK_HTHREAD_STRING_NAME(thr)) {
            duk_pop(ctx);
            duk_push_lightfunc_name(ctx, tv_obj);
            return 1;
        }
 
        DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype"));
        curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
        goto lookup;  /* avoid double coercion */
    }
 
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {
        /* number */
        DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype"));
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_obj));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj));
        curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE];
        break;
    }
    }
 
    /* key coercion (unless already coerced above) */
    DUK_ASSERT(key == NULL);
    arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
    DUK_ASSERT(key != NULL);
 
    /*
     *  Property lookup
     */
 
 lookup:
    /* [key] (coerced) */
    DUK_ASSERT(curr != NULL);
    DUK_ASSERT(key != NULL);
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        if (!duk__get_own_propdesc_raw(thr, curr, key, arr_idx, &desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
            goto next_in_chain;
        }
 
        if (desc.get != NULL) {
            /* accessor with defined getter */
            DUK_ASSERT((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0);
 
            duk_pop(ctx);                     /* [key undefined] -> [key] */
            duk_push_hobject(ctx, desc.get);
            duk_push_tval(ctx, tv_obj);       /* note: original, uncoerced base */
#ifdef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
            duk_dup(ctx, -3);
            duk_call_method(ctx, 1);          /* [key getter this key] -> [key retval] */
#else
            duk_call_method(ctx, 0);          /* [key getter this] -> [key retval] */
#endif
        } else {
            /* [key value] or [key undefined] */
 
            /* data property or accessor without getter */
            DUK_ASSERT(((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0) ||
                       (desc.get == NULL));
 
            /* if accessor without getter, return value is undefined */
            DUK_ASSERT(((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0) ||
                       duk_is_undefined(ctx, -1));
 
            /* Note: for an accessor without getter, falling through to
             * check for "caller" exotic behavior is unnecessary as
             * "undefined" will never activate the behavior.  But it does
             * no harm, so we'll do it anyway.
             */
        }
 
        goto found;  /* [key result] */
 
     next_in_chain:
        /* XXX: option to pretend property doesn't exist if sanity limit is
         * hit might be useful.
         */
        if (sanity-- == 0) {
            DUK_ERROR_RANGE(thr, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
        }
        curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
    } while (curr);
 
    /*
     *  Not found
     */
 
    duk_to_undefined(ctx, -1);  /* [key] -> [undefined] (default value) */
 
    DUK_DDD(DUK_DDDPRINT("-> %!T (not found)", (duk_tval *) duk_get_tval(ctx, -1)));
    return 0;
 
    /*
     *  Found; post-processing (Function and arguments objects)
     */
 
 found:
    /* [key result] */
 
#if !defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
    /* Special behavior for 'caller' property of (non-bound) function objects
     * and non-strict Arguments objects: if 'caller' -value- (!) is a strict
     * mode function, throw a TypeError (E5 Sections 15.3.5.4, 10.6).
     * Quite interestingly, a non-strict function with no formal arguments
     * will get an arguments object -without- special 'caller' behavior!
     *
     * The E5.1 spec is a bit ambiguous if this special behavior applies when
     * a bound function is the base value (not the 'caller' value): Section
     * 15.3.4.5 (describing bind()) states that [[Get]] for bound functions
     * matches that of Section 15.3.5.4 ([[Get]] for Function instances).
     * However, Section 13.3.5.4 has "NOTE: Function objects created using
     * Function.prototype.bind use the default [[Get]] internal method."
     * The current implementation assumes this means that bound functions
     * should not have the special [[Get]] behavior.
     *
     * The E5.1 spec is also a bit unclear if the TypeError throwing is
     * applied if the 'caller' value is a strict bound function.  The
     * current implementation will throw even for both strict non-bound
     * and strict bound functions.
     *
     * See test-dev-strict-func-as-caller-prop-value.js for quite extensive
     * tests.
     *
     * This exotic behavior is disabled when the non-standard 'caller' property
     * is enabled, as it conflicts with the free use of 'caller'.
     */
    if (key == DUK_HTHREAD_STRING_CALLER(thr) &&
        DUK_TVAL_IS_OBJECT(tv_obj)) {
        duk_hobject *orig = DUK_TVAL_GET_OBJECT(tv_obj);
        DUK_ASSERT(orig != NULL);
 
        if (DUK_HOBJECT_IS_NONBOUND_FUNCTION(orig) ||
            DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(orig)) {
            duk_hobject *h;
 
            /* XXX: The TypeError is currently not applied to bound
             * functions because the 'strict' flag is not copied by
             * bind().  This may or may not be correct, the specification
             * only refers to the value being a "strict mode Function
             * object" which is ambiguous.
             */
            DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(orig));

Referenced by duk__getvar_helper().

◆ duk_hobject_hasprop()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop	(	duk_hthread *	thr,
		duk_tval *	tv_obj,
		duk_tval *	tv_key )

Definition at line 50129 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    duk_context *ctx = (duk_context *) thr;
    duk_tval tv_key_copy;
    duk_hobject *obj;
    duk_hstring *key;
    duk_uint32_t arr_idx;
    duk_bool_t rc;
    duk_propdesc desc;
 
    DUK_DDD(DUK_DDDPRINT("hasprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
                         (void *) thr, (void *) tv_obj, (void *) tv_key,
                         (duk_tval *) tv_obj, (duk_tval *) tv_key));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(tv_obj != NULL);
    DUK_ASSERT(tv_key != NULL);
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
    tv_key = &tv_key_copy;
 
    /*
     *  The 'in' operator requires an object as its right hand side,
     *  throwing a TypeError unconditionally if this is not the case.
     *
     *  However, lightfuncs need to behave like fully fledged objects
     *  here to be maximally transparent, so we need to handle them
     *  here.
     */
 
    /* XXX: Refactor key coercion so that it's only called once.  It can't
     * be trivially lifted here because the object must be type checked
     * first.
     */
 
    if (DUK_TVAL_IS_OBJECT(tv_obj)) {
        obj = DUK_TVAL_GET_OBJECT(tv_obj);
        DUK_ASSERT(obj != NULL);
 
        arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) {
        arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
        if (duk__key_is_lightfunc_ownprop(thr, key)) {
            /* FOUND */
            rc = 1;
            goto pop_and_return;
        }
 
        /* If not found, resume existence check from Function.prototype.
         * We can just substitute the value in this case; nothing will
         * need the original base value (as would be the case with e.g.
         * setters/getters.
         */
        obj = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
    } else {
        /* Note: unconditional throw */
        DUK_DDD(DUK_DDDPRINT("base object is not an object -> reject"));
        DUK_ERROR_TYPE(thr, DUK_STR_INVALID_BASE);
    }
 
    /* XXX: fast path for arrays? */
 
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_UNREF(arr_idx);
 
#if defined(DUK_USE_ES6_PROXY)
    if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
        duk_hobject *h_target;
        duk_bool_t tmp_bool;
 
        /* XXX: the key in 'key in obj' is string coerced before we're called
         * (which is the required behavior in E5/E5.1/E6) so the key is a string
         * here already.
         */
 
        if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_HAS, tv_key, &h_target)) {
            /* [ ... key trap handler ] */
            DUK_DDD(DUK_DDDPRINT("-> proxy object 'has' for key %!T", (duk_tval *) tv_key));
            duk_push_hobject(ctx, h_target);  /* target */
            duk_push_tval(ctx, tv_key);       /* P */
            duk_call_method(ctx, 2 /*nargs*/);
            tmp_bool = duk_to_boolean(ctx, -1);
            if (!tmp_bool) {
                /* Target object must be checked for a conflicting
                 * non-configurable property.
                 */
 
                if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
                    DUK_DDD(DUK_DDDPRINT("proxy 'has': target has matching property %!O, check for "
                                         "conflicting property; desc.flags=0x%08lx, "
                                         "desc.get=%p, desc.set=%p",
                                         (duk_heaphdr *) key, (unsigned long) desc.flags,
                                         (void *) desc.get, (void *) desc.set));
                    /* XXX: Extensibility check for target uses IsExtensible().  If we
                     * implemented the isExtensible trap and didn't reject proxies as
                     * proxy targets, it should be respected here.
                     */
                    if (!((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&  /* property is configurable and */
                          DUK_HOBJECT_HAS_EXTENSIBLE(h_target))) {          /* ... target is extensible */
                        DUK_ERROR_TYPE(thr, DUK_STR_PROXY_REJECTED);
                    }
                }
            }
 

◆ duk_hobject_hasprop_raw()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop_raw	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hstring *	key )

Definition at line 50265 of file duktape-1.8.0/src/duktape.c.

               :
    duk_pop(ctx);  /* [ key ] -> [] */
    return rc;
}
 
/*
 *  HASPROP variant used internally.
 *
 *  This primitive must never throw an error, callers rely on this.
 *  In particular, don't throw an error for prototype loops; instead,
 *  pretend like the property doesn't exist if a prototype sanity limit
 *  is reached.

◆ duk_hobject_object_get_own_property_descriptor()

DUK_INTERNAL_DECL duk_ret_t duk_hobject_object_get_own_property_descriptor ( duk_context * ctx )

Definition at line 52195 of file duktape-1.8.0/src/duktape.c.

                                              {
        return (duk_uint32_t) val;
    }
    return 0;
}
 
/*
 *  Object.getOwnPropertyDescriptor()  (E5 Sections 15.2.3.3, 8.10.4)
 *
 *  This is an actual function call.
 */
 
DUK_INTERNAL duk_ret_t duk_hobject_object_get_own_property_descriptor(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    duk_hstring *key;
    duk_propdesc pd;
    duk_bool_t rc;
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
 
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    (void) duk_to_string(ctx, 1);
    key = duk_require_hstring(ctx, 1);
 
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    rc = duk_hobject_get_own_propdesc(thr, obj, key, &pd, DUK_GETDESC_FLAG_PUSH_VALUE);
    if (!rc) {
        duk_push_undefined(ctx);
 
        /* [obj key undefined] */
        return 1;
    }
 
    duk_push_object(ctx);
 
    /* [obj key value desc] */
 
    if (DUK_PROPDESC_IS_ACCESSOR(&pd)) {
        /* If a setter/getter is missing (undefined), the descriptor must
         * still have the property present with the value 'undefined'.
         */
        if (pd.get) {
            duk_push_hobject(ctx, pd.get);
        } else {
            duk_push_undefined(ctx);
        }
        duk_put_prop_stridx(ctx, -2, DUK_STRIDX_GET);
        if (pd.set) {
            duk_push_hobject(ctx, pd.set);
        } else {
            duk_push_undefined(ctx);
        }

◆ duk_hobject_object_is_sealed_frozen_helper()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_is_sealed_frozen_helper	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_bool_t	is_frozen )

Definition at line 53352 of file duktape-1.8.0/src/duktape.c.

                                                                                                                             {
    duk_uint_fast32_t i;
 
    DUK_ASSERT(obj != NULL);
    DUK_UNREF(thr);
 
    /* Note: no allocation pressure, no need to check refcounts etc */
 
    /* must not be extensible */
    if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {
        return 0;
    }
 
    /* all virtual properties are non-configurable and non-writable */
 
    /* entry part must not contain any configurable properties, or
     * writable properties (if is_frozen).
     */
    for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
        duk_small_uint_t flags;
 
        if (!DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i)) {
            continue;
        }
 
        /* avoid multiple computations of flags address; bypasses macros */
        flags = (duk_small_uint_t) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i);
 
        if (flags & DUK_PROPDESC_FLAG_CONFIGURABLE) {
            return 0;
        }
        if (is_frozen &&
            !(flags & DUK_PROPDESC_FLAG_ACCESSOR) &&

Referenced by duk_bi_object_constructor_is_extensible().

◆ duk_hobject_object_ownprop_helper()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_ownprop_helper	(	duk_context *	ctx,
		duk_small_uint_t	required_desc_flags )

Definition at line 53256 of file duktape-1.8.0/src/duktape.c.

                    :
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_EXTENSIBLE);
    return;
 
 fail_not_configurable:
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_CONFIGURABLE);
    return;
 
 fail_array_length_partial:
    DUK_ERROR_TYPE(thr, DUK_STR_ARRAY_LENGTH_WRITE_FAILED);
    return;
}
 
/*
 *  Object.prototype.hasOwnProperty() and Object.prototype.propertyIsEnumerable().
 */
 
DUK_INTERNAL duk_bool_t duk_hobject_object_ownprop_helper(duk_context *ctx, duk_small_uint_t required_desc_flags) {
    duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_hobject_object_seal_freeze_helper()

DUK_INTERNAL_DECL void duk_hobject_object_seal_freeze_helper	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_bool_t	is_freeze )

Definition at line 53291 of file duktape-1.8.0/src/duktape.c.

                                                                                                                  {
    duk_uint_fast32_t i;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(obj != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
#if defined(DUK_USE_ROM_OBJECTS)
    if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj)) {
        DUK_DD(DUK_DDPRINT("attempt to seal/freeze a readonly object, reject"));
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_CONFIGURABLE);
    }
#endif
 
    /*
     *  Abandon array part because all properties must become non-configurable.
     *  Note that this is now done regardless of whether this is always the case
     *  (skips check, but performance problem if caller would do this many times
     *  for the same object; not likely).
     */
 
    duk__abandon_array_checked(thr, obj);
    DUK_ASSERT(DUK_HOBJECT_GET_ASIZE(obj) == 0);
 
    for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
        duk_uint8_t *fp;
 
        /* since duk__abandon_array_checked() causes a resize, there should be no gaps in keys */
        DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != NULL);
 

◆ duk_hobject_pc2line_pack()

DUK_INTERNAL_DECL void duk_hobject_pc2line_pack	(	duk_hthread *	thr,
		duk_compiler_instr *	instrs,
		duk_uint_fast32_t	length )

Definition at line 47186 of file duktape-1.8.0/src/duktape.c.

                                                                                                                   {
    duk_context *ctx = (duk_context *) thr;
    duk_hbuffer_dynamic *h_buf;
    duk_bitencoder_ctx be_ctx_alloc;
    duk_bitencoder_ctx *be_ctx = &be_ctx_alloc;
    duk_uint32_t *hdr;
    duk_size_t new_size;
    duk_uint_fast32_t num_header_entries;
    duk_uint_fast32_t curr_offset;
    duk_int_fast32_t curr_line, next_line, diff_line;
    duk_uint_fast32_t curr_pc;
    duk_uint_fast32_t hdr_index;
 
    DUK_ASSERT(length <= DUK_COMPILER_MAX_BYTECODE_LENGTH);
 
    /* XXX: add proper spare handling to dynamic buffer, to minimize
     * reallocs; currently there is no spare at all.
     */
 
    num_header_entries = (length + DUK_PC2LINE_SKIP - 1) / DUK_PC2LINE_SKIP;
    curr_offset = (duk_uint_fast32_t) (sizeof(duk_uint32_t) + num_header_entries * sizeof(duk_uint32_t) * 2);
 
    duk_push_dynamic_buffer(ctx, (duk_size_t) curr_offset);
    h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
    DUK_ASSERT(h_buf != NULL);
    DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf) && !DUK_HBUFFER_HAS_EXTERNAL(h_buf));
 
    hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
    DUK_ASSERT(hdr != NULL);
    hdr[0] = (duk_uint32_t) length;  /* valid pc range is [0, length[ */
 
    curr_pc = 0U;
    while (curr_pc < length) {
        new_size = (duk_size_t) (curr_offset + DUK_PC2LINE_MAX_DIFF_LENGTH);
        duk_hbuffer_resize(thr, h_buf, new_size);
 
        hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
        DUK_ASSERT(hdr != NULL);
        DUK_ASSERT(curr_pc < length);
        hdr_index = 1 + (curr_pc / DUK_PC2LINE_SKIP) * 2;
        curr_line = (duk_int_fast32_t) instrs[curr_pc].line;
        hdr[hdr_index + 0] = (duk_uint32_t) curr_line;
        hdr[hdr_index + 1] = (duk_uint32_t) curr_offset;
 
#if 0
        DUK_DDD(DUK_DDDPRINT("hdr[%ld]: pc=%ld line=%ld offset=%ld",
                             (long) (curr_pc / DUK_PC2LINE_SKIP),
                             (long) curr_pc,
                             (long) hdr[hdr_index + 0],
                             (long) hdr[hdr_index + 1]));
#endif
 
        DUK_MEMZERO(be_ctx, sizeof(*be_ctx));
        be_ctx->data = ((duk_uint8_t *) hdr) + curr_offset;
        be_ctx->length = (duk_size_t) DUK_PC2LINE_MAX_DIFF_LENGTH;
 
        for (;;) {
            curr_pc++;
            if ( ((curr_pc % DUK_PC2LINE_SKIP) == 0) ||  /* end of diff run */
                 (curr_pc >= length) ) {                 /* end of bytecode */
                break;
            }
            DUK_ASSERT(curr_pc < length);
            next_line = (duk_int32_t) instrs[curr_pc].line;
            diff_line = next_line - curr_line;
 
#if 0
            DUK_DDD(DUK_DDDPRINT("curr_line=%ld, next_line=%ld -> diff_line=%ld",
                                 (long) curr_line, (long) next_line, (long) diff_line));
#endif
 
            if (diff_line == 0) {
                /* 0 */
                duk_be_encode(be_ctx, 0, 1);
            } else if (diff_line >= 1 && diff_line <= 4) {
                /* 1 0 <2 bits> */
                duk_be_encode(be_ctx, (0x02 << 2) + (diff_line - 1), 4);
            } else if (diff_line >= -0x80 && diff_line <= 0x7f) {
                /* 1 1 0 <8 bits> */
                DUK_ASSERT(diff_line + 0x80 >= 0 && diff_line + 0x80 <= 0xff);
                duk_be_encode(be_ctx, (0x06 << 8) + (diff_line + 0x80), 11);
            } else {
                /* 1 1 1 <32 bits>
                 * Encode in two parts to avoid bitencode 24-bit limitation
                 */
                duk_be_encode(be_ctx, (0x07 << 16) + ((next_line >> 16) & 0xffffU), 19);
                duk_be_encode(be_ctx, next_line & 0xffffU, 16);
            }
 
            curr_line = next_line;
        }
 

◆ duk_hobject_pc2line_query()

DUK_INTERNAL_DECL duk_uint_fast32_t duk_hobject_pc2line_query	(	duk_context *	ctx,
		duk_idx_t	idx_func,
		duk_uint_fast32_t	pc )

Definition at line 47398 of file duktape-1.8.0/src/duktape.c.

               {
            /* 0: no change */
        }
 
        n--;
    }
 
    DUK_DDD(DUK_DDDPRINT("pc2line lookup result: pc %ld -> line %ld", (long) pc, (long) curr_line));
    return curr_line;
 
 error:
    DUK_D(DUK_DPRINT("pc2line conversion failed for pc=%ld", (long) pc));
    return 0;
}
 
DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc) {
    duk_hbuffer_fixed *pc2line;
    duk_uint_fast32_t line;
 
    /* XXX: now that pc2line is used by the debugger quite heavily in

Referenced by duk__error_getter_helper().

◆ duk_hobject_prepare_property_descriptor()

DUK_INTERNAL_DECL void duk_hobject_prepare_property_descriptor	(	duk_context *	ctx,
		duk_idx_t	idx_in,
		duk_uint_t *	out_defprop_flags,
		duk_idx_t *	out_idx_value,
		duk_hobject **	out_getter,
		duk_hobject **	out_setter )

Definition at line 52276 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t idx_value = -1;
    duk_hobject *getter = NULL;
    duk_hobject *setter = NULL;
    duk_bool_t is_data_desc = 0;
    duk_bool_t is_acc_desc = 0;
    duk_uint_t defprop_flags = 0;
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(out_defprop_flags != NULL);
    DUK_ASSERT(out_idx_value != NULL);
    DUK_ASSERT(out_getter != NULL);
    DUK_ASSERT(out_setter != NULL);
 
    /* Must be an object, otherwise TypeError (E5.1 Section 8.10.5, step 1). */
    idx_in = duk_require_normalize_index(ctx, idx_in);
    (void) duk_require_hobject(ctx, idx_in);
 
    /* The coercion order must match the ToPropertyDescriptor() algorithm
     * so that side effects in coercion happen in the correct order.
     * (This order also happens to be compatible with duk_def_prop(),
     * although it doesn't matter in practice.)
     */
 
    if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_VALUE)) {
        is_data_desc = 1;
        defprop_flags |= DUK_DEFPROP_HAVE_VALUE;
        idx_value = duk_get_top_index(ctx);
        /* Leave 'value' on stack */
    } else {
        duk_pop(ctx);
    }
 
    if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_WRITABLE)) {
        is_data_desc = 1;
        if (duk_to_boolean(ctx, -1)) {
            defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE;
        } else {
            defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE;
        }
    }
    duk_pop(ctx);
 
    if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_GET)) {
        duk_tval *tv = duk_require_tval(ctx, -1);
        duk_hobject *h_get;
 
        if (DUK_TVAL_IS_UNDEFINED(tv)) {
            /* undefined is accepted */
            DUK_ASSERT(getter == NULL);
        } else {
            /* NOTE: lightfuncs are coerced to full functions because
             * lightfuncs don't fit into a property value slot.  This
             * has some side effects, see test-dev-lightfunc-accessor.js.
             */
            h_get = duk_get_hobject_or_lfunc_coerce(ctx, -1);
            if (h_get == NULL || !DUK_HOBJECT_IS_CALLABLE(h_get)) {
                goto type_error;
            }
            getter = h_get;
        }
        is_acc_desc = 1;
        defprop_flags |= DUK_DEFPROP_HAVE_GETTER;
        /* Leave 'getter' on stack */
    } else {
        duk_pop(ctx);
    }
 
    if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_SET)) {
        duk_tval *tv = duk_require_tval(ctx, -1);
        duk_hobject *h_set;
 
        if (DUK_TVAL_IS_UNDEFINED(tv)) {
            /* undefined is accepted */
            DUK_ASSERT(setter == NULL);
        }  else {
            /* NOTE: lightfuncs are coerced to full functions because
             * lightfuncs don't fit into a property value slot.  This
             * has some side effects, see test-dev-lightfunc-accessor.js.
             */
            h_set = duk_get_hobject_or_lfunc_coerce(ctx, -1);
            if (h_set == NULL || !DUK_HOBJECT_IS_CALLABLE(h_set)) {
                goto type_error;
            }
            setter = h_set;
        }
        is_acc_desc = 1;
        defprop_flags |= DUK_DEFPROP_HAVE_SETTER;
        /* Leave 'setter' on stack */
    } else {
        duk_pop(ctx);
    }
 
    if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_ENUMERABLE)) {
        if (duk_to_boolean(ctx, -1)) {
            defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE | DUK_DEFPROP_ENUMERABLE;
        } else {
            defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE;
        }
    }
    duk_pop(ctx);
 
    if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_CONFIGURABLE)) {
        if (duk_to_boolean(ctx, -1)) {
            defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE;
        } else {
            defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE;
        }
    }

References DUK_ASSERT, DUK_DEFPROP_CONFIGURABLE, DUK_DEFPROP_ENUMERABLE, DUK_DEFPROP_HAVE_CONFIGURABLE, DUK_DEFPROP_HAVE_ENUMERABLE, DUK_DEFPROP_HAVE_GETTER, DUK_DEFPROP_HAVE_SETTER, DUK_DEFPROP_HAVE_VALUE, DUK_DEFPROP_HAVE_WRITABLE, DUK_DEFPROP_WRITABLE, DUK_ERROR_TYPE, duk_get_hobject_or_lfunc_coerce(), duk_get_prop_stridx(), duk_get_top_index(), DUK_HOBJECT_IS_CALLABLE, duk_pop(), duk_require_hobject(), duk_require_normalize_index(), duk_require_tval(), DUK_STR_INVALID_DESCRIPTOR, DUK_STRIDX_CONFIGURABLE, DUK_STRIDX_ENUMERABLE, DUK_STRIDX_GET, DUK_STRIDX_SET, DUK_STRIDX_VALUE, DUK_STRIDX_WRITABLE, duk_to_boolean(), DUK_TVAL_IS_UNDEFINED, and NULL.

◆ duk_hobject_prototype_chain_contains()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_prototype_chain_contains	(	duk_hthread *	thr,
		duk_hobject *	h,
		duk_hobject *	p,
		duk_bool_t	ignore_loop )

Definition at line 47125 of file duktape-1.8.0/src/duktape.c.

                                                                                      : %!T",
                         (void *) obj, (duk_tval *) duk_get_tval(ctx, -1)));
    }
    duk_pop_2(ctx);  /* -> [...] */
 
    DUK_ASSERT_TOP(ctx, entry_top);
}
#line 1 "duk_hobject_misc.c"
/*
 *  Misc support functions
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, duk_hobject *h, duk_hobject *p, duk_bool_t ignore_loop) {
    duk_uint_t sanity;
 
    DUK_ASSERT(thr != NULL);
 
    /* False if the object is NULL or the prototype 'p' is NULL.
     * In particular, false if both are NULL (don't compare equal).
     */
    if (h == NULL || p == NULL) {
        return 0;
    }
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;

Referenced by duk_err_augment_error_create().

◆ duk_hobject_proxy_check()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_proxy_check	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_hobject **	out_target,
		duk_hobject **	out_handler )

Definition at line 47740 of file duktape-1.8.0/src/duktape.c.

                                                                              :
     *
     *    arr_idx > limit'' * ((old_size + 7) / 8)
     */
 
    return (arr_idx > DUK_HOBJECT_A_FAST_RESIZE_LIMIT * ((old_size + 7) >> 3));
}
 
/*
 *  Proxy helpers
 */
 
#if defined(DUK_USE_ES6_PROXY)
DUK_INTERNAL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *obj, duk_hobject **out_target, duk_hobject **out_handler) {
    duk_tval *tv_target;
    duk_tval *tv_handler;
    duk_hobject *h_target;
    duk_hobject *h_handler;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(out_target != NULL);
    DUK_ASSERT(out_handler != NULL);
 
    /* Caller doesn't need to check exotic proxy behavior (but does so for
     * some fast paths).
     */
    if (DUK_LIKELY(!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
        return 0;
    }
 
    tv_handler = duk_hobject_find_existing_entry_tval_ptr(thr->heap, obj, DUK_HTHREAD_STRING_INT_HANDLER(thr));
    if (!tv_handler) {
        DUK_ERROR_TYPE(thr, DUK_STR_PROXY_REVOKED);
        return 0;
    }
    DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_handler));
    h_handler = DUK_TVAL_GET_OBJECT(tv_handler);

Referenced by duk__proxy_check_prop().

◆ duk_hobject_putprop()

DUK_INTERNAL_DECL duk_bool_t duk_hobject_putprop	(	duk_hthread *	thr,
		duk_tval *	tv_obj,
		duk_tval *	tv_key,
		duk_tval *	tv_val,
		duk_bool_t	throw_flag )

Definition at line 50655 of file duktape-1.8.0/src/duktape.c.

                          :
 *
 *      - Preprocessing before and postprocessing after an actual property
 *        write.  For example, array index write requires pre-checking the
 *        array 'length' property for access control, and may require an
 *        array 'length' update after the actual write has succeeded (but
 *        not if it fails).
 *
 *      - Deletion of multiple entries, as a result of array 'length' write.
 *
 *    * Input values are taken as pointers which may point to the valstack.
 *      If valstack is resized because of the put (this may happen at least
 *      when the array part is abandoned), the pointers can be invalidated.
 *      (We currently make a copy of all of the input values to avoid issues.)
 */
 
DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_tval *tv_val, duk_bool_t throw_flag) {
    duk_context *ctx = (duk_context *) thr;
    duk_tval tv_obj_copy;
    duk_tval tv_key_copy;
    duk_tval tv_val_copy;
    duk_hobject *orig = NULL;  /* NULL if tv_obj is primitive */
    duk_hobject *curr;
    duk_hstring *key = NULL;
    duk_propdesc desc;
    duk_tval *tv;
    duk_uint32_t arr_idx;
    duk_bool_t rc;
    duk_int_t e_idx;
    duk_uint_t sanity;
    duk_uint32_t new_array_length = 0;  /* 0 = no update */
 
    DUK_DDD(DUK_DDDPRINT("putprop: thr=%p, obj=%p, key=%p, val=%p, throw=%ld "
                         "(obj -> %!T, key -> %!T, val -> %!T)",
                         (void *) thr, (void *) tv_obj, (void *) tv_key, (void *) tv_val,
                         (long) throw_flag, (duk_tval *) tv_obj, (duk_tval *) tv_key, (duk_tval *) tv_val));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(tv_obj != NULL);
    DUK_ASSERT(tv_key != NULL);
    DUK_ASSERT(tv_val != NULL);
 
    DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
 
    /*
     *  Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of
     *  them being invalidated by a valstack resize.
     *
     *  XXX: this is an overkill for some paths, so optimize this later
     *  (or maybe switch to a stack arguments model entirely).
     */
 
    DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj);
    DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
    DUK_TVAL_SET_TVAL(&tv_val_copy, tv_val);
    tv_obj = &tv_obj_copy;
    tv_key = &tv_key_copy;
    tv_val = &tv_val_copy;
 
    /*
     *  Coercion and fast path processing.
     */
 
    switch (DUK_TVAL_GET_TAG(tv_obj)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL: {
        /* Note: unconditional throw */
        DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject (object=%!iT)",
                             (duk_tval *) tv_obj));
#if defined(DUK_USE_PARANOID_ERRORS)
        DUK_ERROR_TYPE(thr, DUK_STR_INVALID_BASE);
#else
        DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot write property %s of %s",
                       duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj));
#endif
        return 0;
    }
 
    case DUK_TAG_BOOLEAN: {
        DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype"));
        curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE];
        break;
    }
 
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
 
        /*
         *  Note: currently no fast path for array index writes.
         *  They won't be possible anyway as strings are immutable.
         */
 
        DUK_ASSERT(key == NULL);
        arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
        DUK_ASSERT(key != NULL);
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
            goto fail_not_writable;
        }
 
        if (arr_idx != DUK__NO_ARRAY_INDEX &&
            arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
            goto fail_not_writable;
        }
 
        DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype"));
        curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE];
        goto lookup;  /* avoid double coercion */
    }
 
    case DUK_TAG_OBJECT: {
        orig = DUK_TVAL_GET_OBJECT(tv_obj);
        DUK_ASSERT(orig != NULL);
 
#if defined(DUK_USE_ROM_OBJECTS)
        /* With this check in place fast paths won't need read-only
         * object checks.  This is technically incorrect if there are
         * setters that cause no writes to ROM objects, but current
         * built-ins don't have such setters.
         */
        if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) orig)) {
            DUK_DD(DUK_DDPRINT("attempt to putprop on read-only target object"));
            goto fail_not_writable_no_pop;  /* Must avoid duk_pop() in exit path */
        }
#endif
 
        /* The fast path for array property put is not fully compliant:
         * If one places conflicting number-indexed properties into
         * Array.prototype (for example, a non-writable Array.prototype[7])
         * the fast path will incorrectly ignore them.
         *
         * This fast path could be made compliant by falling through
         * to the slow path if the previous value was UNUSED.  This would
         * also remove the need to check for extensibility.  Right now a
         * non-extensible array is slower than an extensible one as far
         * as writes are concerned.
         *
         * The fast path behavior is documented in more detail here:
         * tests/ecmascript/test-misc-array-fast-write.js
         */
 
        if (duk__putprop_shallow_fastpath_array_tval(thr, orig, tv_key, tv_val, &desc) != 0) {
            DUK_DDD(DUK_DDDPRINT("array fast path success"));
            return 1;
        }
 
        if (duk__putprop_fastpath_bufobj_tval(thr, orig, tv_key, tv_val) != 0) {
            DUK_DDD(DUK_DDDPRINT("base is bufobj, key is a number, bufferobject fast path"));
            return 1;
        }
 
#if defined(DUK_USE_ES6_PROXY)
        if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(orig))) {
            duk_hobject *h_target;
            duk_bool_t tmp_bool;
 
            if (duk__proxy_check_prop(thr, orig, DUK_STRIDX_SET, tv_key, &h_target)) {
                /* -> [ ... trap handler ] */
                DUK_DDD(DUK_DDDPRINT("-> proxy object 'set' for key %!T", (duk_tval *) tv_key));
                duk_push_hobject(ctx, h_target);  /* target */
                duk_push_tval(ctx, tv_key);       /* P */
                duk_push_tval(ctx, tv_val);       /* V */
                duk_push_tval(ctx, tv_obj);       /* Receiver: Proxy object */
                duk_call_method(ctx, 4 /*nargs*/);
                tmp_bool = duk_to_boolean(ctx, -1);
                duk_pop(ctx);
                if (!tmp_bool) {
                    goto fail_proxy_rejected;
                }
 
                /* Target object must be checked for a conflicting
                 * non-configurable property.
                 */
                arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
                DUK_ASSERT(key != NULL);
 
                if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
                    duk_tval *tv_targ = duk_require_tval(ctx, -1);
                    duk_bool_t datadesc_reject;
                    duk_bool_t accdesc_reject;
 
                    DUK_DDD(DUK_DDDPRINT("proxy 'set': target has matching property %!O, check for "
                                         "conflicting property; tv_val=%!T, tv_targ=%!T, desc.flags=0x%08lx, "
                                         "desc.get=%p, desc.set=%p",
                                         (duk_heaphdr *) key, (duk_tval *) tv_val, (duk_tval *) tv_targ,
                                         (unsigned long) desc.flags,
                                         (void *) desc.get, (void *) desc.set));
 
                    datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
                                      !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
                                      !(desc.flags & DUK_PROPDESC_FLAG_WRITABLE) &&
                                      !duk_js_samevalue(tv_val, tv_targ);
                    accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
                                     !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
                                     (desc.set == NULL);
                    if (datadesc_reject || accdesc_reject) {
                        DUK_ERROR_TYPE(thr, DUK_STR_PROXY_REJECTED);
                    }
 
                    duk_pop_2(ctx);
                } else {
                    duk_pop(ctx);
                }
                return 1;  /* success */
            }
 
            orig = h_target;  /* resume write to target */
            DUK_TVAL_SET_OBJECT(tv_obj, orig);
        }
#endif  /* DUK_USE_ES6_PROXY */
 
        curr = orig;
        break;
    }
 
    case DUK_TAG_BUFFER: {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
        duk_int_t pop_count = 0;
 
        /*
         *  Because buffer values may be looped over and read/written
         *  from, an array index fast path is important.
         */
 
#if defined(DUK_USE_FASTINT)
        if (DUK_TVAL_IS_FASTINT(tv_key)) {
            arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
            pop_count = 0;
        } else
#endif
        if (DUK_TVAL_IS_NUMBER(tv_key)) {
            arr_idx = duk__tval_number_to_arr_idx(tv_key);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx));
            pop_count = 0;
        } else {
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
                                 "coercion key is %!T, arr_idx %ld",
                                 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
            pop_count = 1;
        }
 
        if (arr_idx != DUK__NO_ARRAY_INDEX &&
            arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
            duk_uint8_t *data;
            DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx));
            data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);
 
            /* XXX: duk_to_int() ensures we'll get 8 lowest bits as
             * as input is within duk_int_t range (capped outside it).
             */
#if defined(DUK_USE_FASTINT)
            /* Buffer writes are often integers. */
            if (DUK_TVAL_IS_FASTINT(tv_val)) {
                data[arr_idx] = (duk_uint8_t) DUK_TVAL_GET_FASTINT_U32(tv_val);
            }
            else
#endif
            {
                duk_push_tval(ctx, tv_val);
                data[arr_idx] = (duk_uint8_t) duk_to_uint32(ctx, -1);
                pop_count++;
            }
 
            duk_pop_n(ctx, pop_count);
            DUK_DDD(DUK_DDDPRINT("result: success (buffer data write)"));
            return 1;
        }
 
        if (pop_count == 0) {
            /* This is a pretty awkward control flow, but we need to recheck the
             * key coercion here.
             */
            arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
            DUK_ASSERT(key != NULL);
            DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
                                 "coercion key is %!T, arr_idx %ld",
                                 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
        }
 
        if (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
            key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr) ||
            key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr) ||
            key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) {
            goto fail_not_writable;
        }
 
        DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype"));
        curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE];
        goto lookup;  /* avoid double coercion */
    }
 
    case DUK_TAG_POINTER: {
        DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype"));
        curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE];
        break;
    }
 
    case DUK_TAG_LIGHTFUNC: {
        /* All lightfunc own properties are non-writable and the lightfunc
         * is considered non-extensible.  However, the write may be captured
         * by an inherited setter which means we can't stop the lookup here.
         */
 
        arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
 
        if (duk__key_is_lightfunc_ownprop(thr, key)) {
            goto fail_not_writable;
        }
 
        DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype"));
        curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
        goto lookup;  /* avoid double coercion */
    }
 
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {
        /* number */
        DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype"));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj));
        curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE];
        break;
    }
    }
 
    DUK_ASSERT(key == NULL);
    arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
    DUK_ASSERT(key != NULL);
 
 lookup:
 
    /*
     *  Check whether the property already exists in the prototype chain.
     *  Note that the actual write goes into the original base object
     *  (except if an accessor property captures the write).
     */
 
    /* [key] */
 
    DUK_ASSERT(curr != NULL);
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        if (!duk__get_own_propdesc_raw(thr, curr, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
            goto next_in_chain;
        }
 
        if (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
            /*
             *  Found existing accessor property (own or inherited).
             *  Call setter with 'this' set to orig, and value as the only argument.
             *  Setter calls are OK even for ROM objects.
             *
             *  Note: no exotic arguments object behavior, because [[Put]] never
             *  calls [[DefineOwnProperty]] (E5 Section 8.12.5, step 5.b).
             */
 
            duk_hobject *setter;
 
            DUK_DD(DUK_DDPRINT("put to an own or inherited accessor, calling setter"));
 
            setter = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, curr, desc.e_idx);
            if (!setter) {
                goto fail_no_setter;
            }
            duk_push_hobject(ctx, setter);
            duk_push_tval(ctx, tv_obj);  /* note: original, uncoerced base */
            duk_push_tval(ctx, tv_val);  /* [key setter this val] */
#ifdef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
            duk_dup(ctx, -4);
            duk_call_method(ctx, 2);     /* [key setter this val key] -> [key retval] */
#else
            duk_call_method(ctx, 1);     /* [key setter this val] -> [key retval] */
#endif
            duk_pop(ctx);                /* ignore retval -> [key] */
            goto success_no_arguments_exotic;
        }
 
        if (orig == NULL) {
            /*
             *  Found existing own or inherited plain property, but original
             *  base is a primitive value.
             */
            DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object"));
            goto fail_base_primitive;
        }
 
        if (curr != orig) {
            /*
             *  Found existing inherited plain property.
             *  Do an access control check, and if OK, write
             *  new property to 'orig'.
             */
            if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) {
                DUK_DD(DUK_DDPRINT("found existing inherited plain property, but original object is not extensible"));
                goto fail_not_extensible;
            }
            if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
                DUK_DD(DUK_DDPRINT("found existing inherited plain property, original object is extensible, but inherited property is not writable"));
                goto fail_not_writable;
            }
            DUK_DD(DUK_DDPRINT("put to new property, object extensible, inherited property found and is writable"));
            goto create_new;
        } else {
            /*
             *  Found existing own (non-inherited) plain property.
             *  Do an access control check and update in place.
             */
 
            if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
                DUK_DD(DUK_DDPRINT("found existing own (non-inherited) plain property, but property is not writable"));
                goto fail_not_writable;
            }
            if (desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) {
                DUK_DD(DUK_DDPRINT("found existing own (non-inherited) virtual property, property is writable"));
                if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) {
                    duk_hbufferobject *h_bufobj;
                    duk_uint_t byte_off;
                    duk_small_uint_t elem_size;
 
                    h_bufobj = (duk_hbufferobject *) curr;
                    DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
                    DUK_DD(DUK_DDPRINT("writable virtual property is in buffer object"));
 
                    /* Careful with wrapping: arr_idx upshift may easily wrap, whereas
                     * length downshift won't.
                     */
                    if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) {
                        duk_uint8_t *data;
                        DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx));
 
                        DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);  /* index/length check guarantees */
                        byte_off = arr_idx << h_bufobj->shift;       /* no wrap assuming h_bufobj->length is valid */
                        elem_size = 1 << h_bufobj->shift;
 
                        /* Coerce to number before validating pointers etc so that the
                         * number coercions in duk_hbufferobject_validated_write() are
                         * guaranteed to be side effect free and not invalidate the
                         * pointer checks we do here.
                         */
                        duk_push_tval(ctx, tv_val);
                        duk_to_number(ctx, -1);
 
                        if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) {
                            data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
                            duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size);
                        } else {
                            DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)"));
                        }
                        duk_pop(ctx);
                        goto success_no_arguments_exotic;
                    }
                }
 
                goto fail_internal;  /* should not happen */
            }
            DUK_DD(DUK_DDPRINT("put to existing own plain property, property is writable"));
            goto update_old;
        }
        DUK_UNREACHABLE();
 
     next_in_chain:
        /* XXX: option to pretend property doesn't exist if sanity limit is
         * hit might be useful.
         */
        if (sanity-- == 0) {
            DUK_ERROR_RANGE(thr, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
        }
        curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
    } while (curr);
 
    /*
     *  Property not found in prototype chain.
     */
 
    DUK_DDD(DUK_DDDPRINT("property not found in prototype chain"));
 
    if (orig == NULL) {
        DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object"));
        goto fail_base_primitive;
    }
 
    if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) {
        DUK_DD(DUK_DDPRINT("put to a new property (not found in prototype chain), but original object not extensible"));
        goto fail_not_extensible;
    }
 
    goto create_new;
 
 update_old:
 
    /*
     *  Update an existing property of the base object.
     */
 
    /* [key] */
 
    DUK_DDD(DUK_DDDPRINT("update an existing property of the original object"));
 
    DUK_ASSERT(orig != NULL);
#if defined(DUK_USE_ROM_OBJECTS)
    /* This should not happen because DUK_TAG_OBJECT case checks
     * for this already, but check just in case.
     */
    if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) orig)) {
        goto fail_not_writable;
    }
#endif
 
    /* Although there are writable virtual properties (e.g. plain buffer
     * and buffer object number indices), they are handled before we come
     * here.
     */
    DUK_ASSERT((desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) == 0);
    DUK_ASSERT(desc.a_idx >= 0 || desc.e_idx >= 0);
 
    if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
        key == DUK_HTHREAD_STRING_LENGTH(thr)) {
        /*
         *  Write to 'length' of an array is a very complex case
         *  handled in a helper which updates both the array elements
         *  and writes the new 'length'.  The write may result in an
         *  unconditional RangeError or a partial write (indicated
         *  by a return code).
         *
         *  Note: the helper has an unnecessary writability check
         *  for 'length', we already know it is writable.
         */
 
        DUK_DDD(DUK_DDDPRINT("writing existing 'length' property to array exotic, invoke complex helper"));
 
        /* XXX: the helper currently assumes stack top contains new
         * 'length' value and the whole calling convention is not very
         * compatible with what we need.
         */
 
        duk_push_tval(ctx, tv_val);  /* [key val] */
        rc = duk__handle_put_array_length(thr, orig);
        duk_pop(ctx);  /* [key val] -> [key] */
        if (!rc) {
            goto fail_array_length_partial;
        }
 
        /* key is 'length', cannot match argument exotic behavior */
        goto success_no_arguments_exotic;
    }
 
    if (desc.e_idx >= 0) {
        tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
        DUK_DDD(DUK_DDDPRINT("previous entry value: %!iT", (duk_tval *) tv));
        DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val);  /* side effects */
        /* don't touch property attributes or hash part */
        DUK_DD(DUK_DDPRINT("put to an existing entry at index %ld -> new value %!iT",
                           (long) desc.e_idx, (duk_tval *) tv));
    } else {
        /* Note: array entries are always writable, so the writability check
         * above is pointless for them.  The check could be avoided with some
         * refactoring but is probably not worth it.
         */
 
        DUK_ASSERT(desc.a_idx >= 0);
        tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, desc.a_idx);
        DUK_DDD(DUK_DDDPRINT("previous array value: %!iT", (duk_tval *) tv));
        DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val);  /* side effects */
        DUK_DD(DUK_DDPRINT("put to an existing array entry at index %ld -> new value %!iT",
                           (long) desc.a_idx, (duk_tval *) tv));
    }
 
    /* Regardless of whether property is found in entry or array part,
     * it may have arguments exotic behavior (array indices may reside
     * in entry part for abandoned / non-existent array parts).
     */
    goto success_with_arguments_exotic;
 
 create_new:
 
    /*
     *  Create a new property in the original object.
     *
     *  Exotic properties need to be reconsidered here from a write
     *  perspective (not just property attributes perspective).
     *  However, the property does not exist in the object already,
     *  so this limits the kind of exotic properties that apply.
     */
 
    /* [key] */
 
    DUK_DDD(DUK_DDDPRINT("create new property to original object"));
 
    DUK_ASSERT(orig != NULL);
 
#if defined(DUK_USE_ROM_OBJECTS)
    /* This should not happen because DUK_TAG_OBJECT case checks
     * for this already, but check just in case.
     */
    if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) orig)) {
        goto fail_not_writable;
    }
#endif
 
    /* Not possible because array object 'length' is present
     * from its creation and cannot be deleted, and is thus
     * caught as an existing property above.
     */
    DUK_ASSERT(!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
                 key == DUK_HTHREAD_STRING_LENGTH(thr)));
 
    if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
        arr_idx != DUK__NO_ARRAY_INDEX) {
        /* automatic length update */
        duk_uint32_t old_len;
 
        old_len = duk__get_old_array_length(thr, orig, &desc);
 
        if (arr_idx >= old_len) {
            DUK_DDD(DUK_DDDPRINT("write new array entry requires length update "
                                 "(arr_idx=%ld, old_len=%ld)",
                                 (long) arr_idx, (long) old_len));
 
            if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
                DUK_DD(DUK_DDPRINT("attempt to extend array, but array 'length' is not writable"));
                goto fail_not_writable;
            }
 
            /* Note: actual update happens once write has been completed
             * without error below.  The write should always succeed
             * from a specification viewpoint, but we may e.g. run out
             * of memory.  It's safer in this order.
             */
 
            DUK_ASSERT(arr_idx != 0xffffffffUL);
            new_array_length = arr_idx + 1;  /* flag for later write */
        } else {
            DUK_DDD(DUK_DDDPRINT("write new array entry does not require length update "
                                 "(arr_idx=%ld, old_len=%ld)",
                                 (long) arr_idx, (long) old_len));
        }
    }
 
 /* write_to_array_part: */
 
    /*
     *  Write to array part?
     *
     *  Note: array abandonding requires a property resize which uses
     *  'rechecks' valstack for temporaries and may cause any existing
     *  valstack pointers to be invalidated.  To protect against this,
     *  tv_obj, tv_key, and tv_val are copies of the original inputs.
     */
 
    if (arr_idx != DUK__NO_ARRAY_INDEX &&
        DUK_HOBJECT_HAS_ARRAY_PART(orig)) {
        if (arr_idx < DUK_HOBJECT_GET_ASIZE(orig)) {
            goto no_array_growth;
        }
 
        /*
         *  Array needs to grow, but we don't want it becoming too sparse.
         *  If it were to become sparse, abandon array part, moving all
         *  array entries into the entries part (for good).
         *
         *  Since we don't keep track of actual density (used vs. size) of
         *  the array part, we need to estimate somehow.  The check is made
         *  in two parts:
         *
         *    - Check whether the resize need is small compared to the
         *      current size (relatively); if so, resize without further
         *      checking (essentially we assume that the original part is
         *      "dense" so that the result would be dense enough).
         *
         *    - Otherwise, compute the resize using an actual density
         *      measurement based on counting the used array entries.
         */
 
        DUK_DDD(DUK_DDDPRINT("write to new array requires array resize, decide whether to do a "
                             "fast resize without abandon check (arr_idx=%ld, old_size=%ld)",
                             (long) arr_idx, (long) DUK_HOBJECT_GET_ASIZE(orig)));
 
        if (duk__abandon_array_slow_check_required(arr_idx, DUK_HOBJECT_GET_ASIZE(orig))) {
            duk_uint32_t old_used;
            duk_uint32_t old_size;
 
            DUK_DDD(DUK_DDDPRINT("=> fast check is NOT OK, do slow check for array abandon"));
 
            duk__compute_a_stats(thr, orig, &old_used, &old_size);
 
            DUK_DDD(DUK_DDDPRINT("abandon check, array stats: old_used=%ld, old_size=%ld, arr_idx=%ld",
                                 (long) old_used, (long) old_size, (long) arr_idx));
 
            /* Note: intentionally use approximations to shave a few instructions:
             *   a_used = old_used  (accurate: old_used + 1)
             *   a_size = arr_idx   (accurate: arr_idx + 1)
             */
            if (duk__abandon_array_density_check(old_used, arr_idx)) {
                DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, "
                                   "decided to abandon array part (would become too sparse)"));
 
                /* abandoning requires a props allocation resize and
                 * 'rechecks' the valstack, invalidating any existing
                 * valstack value pointers!
                 */
                duk__abandon_array_checked(thr, orig);
                DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(orig));
 
                goto write_to_entry_part;
            }
 
            DUK_DDD(DUK_DDDPRINT("=> decided to keep array part"));
        } else {
            DUK_DDD(DUK_DDDPRINT("=> fast resize is OK"));
        }
 
        DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, "
                           "decided to extend current allocation"));
 
        duk__grow_props_for_array_item(thr, orig, arr_idx);
 
     no_array_growth:
 
        /* Note: assume array part is comprehensive, so that either
         * the write goes to the array part, or we've abandoned the
         * array above (and will not come here).
         */
 
        DUK_ASSERT(DUK_HOBJECT_HAS_ARRAY_PART(orig));
        DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(orig));
 
        tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx);
        /* prev value must be unused, no decref */
        DUK_ASSERT(DUK_TVAL_IS_UNUSED(tv));
        DUK_TVAL_SET_TVAL(tv, tv_val);
        DUK_TVAL_INCREF(thr, tv);
        DUK_DD(DUK_DDPRINT("put to new array entry: %ld -> %!T",
                           (long) arr_idx, (duk_tval *) tv));
 
        /* Note: array part values are [[Writable]], [[Enumerable]],
         * and [[Configurable]] which matches the required attributes
         * here.
         */
        goto entry_updated;
    }
 
 write_to_entry_part:
 
    /*
     *  Write to entry part
     */
 
    /* entry allocation updates hash part and increases the key
     * refcount; may need a props allocation resize but doesn't
     * 'recheck' the valstack.
     */
    e_idx = duk__alloc_entry_checked(thr, orig, key);
    DUK_ASSERT(e_idx >= 0);
 
    tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, e_idx);
    /* prev value can be garbage, no decref */
    DUK_TVAL_SET_TVAL(tv, tv_val);
    DUK_TVAL_INCREF(thr, tv);
    DUK_HOBJECT_E_SET_FLAGS(thr->heap, orig, e_idx, DUK_PROPDESC_FLAGS_WEC);
    goto entry_updated;
 
 entry_updated:
 
    /*
     *  Possible pending array length update, which must only be done
     *  if the actual entry write succeeded.
     */
 
    if (new_array_length > 0) {
        /*
         *  Note: zero works as a "no update" marker because the new length
         *  can never be zero after a new property is written.
         *
         *  Note: must re-lookup because calls above (e.g. duk__alloc_entry_checked())
         *  may realloc and compact properties and hence change e_idx.
         */
 
        DUK_DDD(DUK_DDDPRINT("write successful, pending array length update to: %ld",
                             (long) new_array_length));
 
        rc = duk__get_own_propdesc_raw(thr, orig, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &desc, 0 /*flags*/);  /* don't push value */
        DUK_UNREF(rc);
        DUK_ASSERT(rc != 0);
        DUK_ASSERT(desc.e_idx >= 0);
 
        tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        /* no need for decref/incref because value is a number */
        DUK_TVAL_SET_FASTINT_U32(tv, new_array_length);
    }
 
    /*
     *  Arguments exotic behavior not possible for new properties: all
     *  magically bound properties are initially present in the arguments
     *  object, and if they are deleted, the binding is also removed from
     *  parameter map.
     */
 
    goto success_no_arguments_exotic;
 
 success_with_arguments_exotic:
 
    /*
     *  Arguments objects have exotic [[DefineOwnProperty]] which updates
     *  the internal 'map' of arguments for writes to currently mapped
     *  arguments.  More conretely, writes to mapped arguments generate
     *  a write to a bound variable.
     *
     *  The [[Put]] algorithm invokes [[DefineOwnProperty]] for existing
     *  data properties and new properties, but not for existing accessors.
     *  Hence, in E5 Section 10.6 ([[DefinedOwnProperty]] algorithm), we
     *  have a Desc with 'Value' (and possibly other properties too), and
     *  we end up in step 5.b.i.
     */
 
    if (arr_idx != DUK__NO_ARRAY_INDEX &&
        DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(orig)) {
        /* Note: only numbered indices are relevant, so arr_idx fast reject
         * is good (this is valid unless there are more than 4**32-1 arguments).
         */
 
        DUK_DDD(DUK_DDDPRINT("putprop successful, arguments exotic behavior needed"));
 
        /* Note: we can reuse 'desc' here */
 
        /* XXX: top of stack must contain value, which helper doesn't touch,
         * rework to use tv_val directly?
         */
 
        duk_push_tval(ctx, tv_val);
        (void) duk__check_arguments_map_for_put(thr, orig, key, &desc, throw_flag);
        duk_pop(ctx);
    }
    /* fall thru */
 
 success_no_arguments_exotic:
    /* shared exit path now */
    DUK_DDD(DUK_DDDPRINT("result: success"));
    duk_pop(ctx);  /* remove key */
    return 1;
 
#if defined(DUK_USE_ES6_PROXY)
 fail_proxy_rejected:
    DUK_DDD(DUK_DDDPRINT("result: error, proxy rejects"));
    if (throw_flag) {
        DUK_ERROR_TYPE(thr, DUK_STR_PROXY_REJECTED);
    }
    /* Note: no key on stack */
    return 0;
#endif
 
 fail_base_primitive:
    DUK_DDD(DUK_DDDPRINT("result: error, base primitive"));
    if (throw_flag) {
#if defined(DUK_USE_PARANOID_ERRORS)
        DUK_ERROR_TYPE(thr, DUK_STR_INVALID_BASE);
#else
        DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot write property %s of %s",
                       duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj));
#endif
    }
    duk_pop(ctx);  /* remove key */
    return 0;
 
 fail_not_extensible:
    DUK_DDD(DUK_DDDPRINT("result: error, not extensible"));
    if (throw_flag) {
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_EXTENSIBLE);
    }
    duk_pop(ctx);  /* remove key */
    return 0;
 
 fail_not_writable:
    DUK_DDD(DUK_DDDPRINT("result: error, not writable"));
    if (throw_flag) {
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_WRITABLE);
    }
    duk_pop(ctx);  /* remove key */
    return 0;
 
#if defined(DUK_USE_ROM_OBJECTS)
 fail_not_writable_no_pop:
    DUK_DDD(DUK_DDDPRINT("result: error, not writable"));
    if (throw_flag) {
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_WRITABLE);
    }
    return 0;
#endif
 
 fail_array_length_partial:
    DUK_DDD(DUK_DDDPRINT("result: error, array length write only partially successful"));
    if (throw_flag) {
        DUK_ERROR_TYPE(thr, DUK_STR_ARRAY_LENGTH_WRITE_FAILED);
    }
    duk_pop(ctx);  /* remove key */
    return 0;

References duk_propdesc::a_idx, duk_hbufferobject::buf, duk_hthread::builtins, duk__abandon_array_checked(), duk__abandon_array_density_check(), duk__abandon_array_slow_check_required(), duk__alloc_entry_checked(), duk__check_arguments_map_for_put(), duk__compute_a_stats(), duk__get_old_array_length(), duk__get_own_propdesc_raw(), duk__grow_props_for_array_item(), duk__handle_put_array_length(), duk__key_is_lightfunc_ownprop(), DUK__NO_ARRAY_INDEX, duk__proxy_check_prop(), duk__push_tval_to_hstring_arr_idx(), duk__putprop_fastpath_bufobj_tval(), duk__putprop_shallow_fastpath_array_tval(), duk__tval_number_to_arr_idx(), DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_ASSERT_VALSTACK_SPACE, DUK_BIDX_BOOLEAN_PROTOTYPE, DUK_BIDX_BUFFER_PROTOTYPE, DUK_BIDX_FUNCTION_PROTOTYPE, DUK_BIDX_NUMBER_PROTOTYPE, DUK_BIDX_POINTER_PROTOTYPE, DUK_BIDX_STRING_PROTOTYPE, duk_call_method(), DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_dup(), DUK_ERR_TYPE_ERROR, DUK_ERROR_FMT2, DUK_ERROR_RANGE, DUK_ERROR_TYPE, duk_get_tval(), DUK_GETDESC_FLAG_PUSH_VALUE, DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL, duk_hbufferobject_validated_write(), DUK_HEAPHDR_HAS_READONLY, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_E_GET_VALUE_SETTER, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, DUK_HOBJECT_E_SET_FLAGS, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ, DUK_HOBJECT_HAS_EXTENSIBLE, DUK_HOBJECT_IS_BUFFEROBJECT, DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY, DUK_HSTRING_GET_CHARLEN, DUK_HTHREAD_STRING_BYTE_LENGTH, DUK_HTHREAD_STRING_BYTE_OFFSET, DUK_HTHREAD_STRING_BYTES_PER_ELEMENT, DUK_HTHREAD_STRING_LENGTH, duk_js_samevalue, duk_pop(), duk_pop_2(), duk_pop_n(), DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_VIRTUAL, DUK_PROPDESC_FLAG_WRITABLE, DUK_PROPDESC_FLAGS_WEC, duk_push_hobject(), duk_push_string_tval_readable(), duk_push_tval(), duk_require_tval(), DUK_STR_ARRAY_LENGTH_WRITE_FAILED, DUK_STR_INVALID_BASE, DUK_STR_NOT_EXTENSIBLE, DUK_STR_NOT_WRITABLE, DUK_STR_PROTOTYPE_CHAIN_LIMIT, DUK_STR_PROXY_REJECTED, DUK_STR_SETTER_UNDEFINED, DUK_STRIDX_SET, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, duk_to_boolean(), duk_to_number(), duk_to_uint32(), DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_OBJECT, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_INCREF, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_TVAL_SET_FASTINT_U32, DUK_TVAL_SET_OBJECT, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_TVAL_UPDREF, DUK_UNLIKELY, DUK_UNREACHABLE, DUK_UNREF, duk_propdesc::e_idx, duk_propdesc::flags, duk_propdesc::get, duk_hthread::heap, duk_hbufferobject::length, NULL, duk_hbufferobject::offset, duk_propdesc::set, and duk_hbufferobject::shift.

Referenced by duk__putvar_helper(), and duk_hobject_get_length().

◆ duk_hobject_resolve_proxy_target()

DUK_INTERNAL_DECL duk_hobject * duk_hobject_resolve_proxy_target	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 47788 of file duktape-1.8.0/src/duktape.c.

                                                                                               {
    duk_hobject *h_target;
    duk_hobject *h_handler;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(obj != NULL);
 

Referenced by duk_js_instanceof().

◆ duk_hobject_run_finalizer()

DUK_INTERNAL_DECL void duk_hobject_run_finalizer	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 47062 of file duktape-1.8.0/src/duktape.c.

                                   {
        DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable"));
        return 0;
    }
    duk_dup(ctx, -2);
    duk_push_boolean(ctx, DUK_HEAP_HAS_FINALIZER_NORESCUE(thr->heap));
    DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer"));
    duk_call(ctx, 2);  /* [ ... obj finalizer obj heapDestruct ]  -> [ ... obj retval ] */
    DUK_DDD(DUK_DDDPRINT("finalizer finished successfully"));
    return 0;
 
    /* Note: we rely on duk_safe_call() to fix up the stack for the caller,
     * so we don't need to pop stuff here.  There is no return value;
     * caller determines rescued status based on object refcount.
     */
}
 
DUK_INTERNAL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj) {
    duk_context *ctx = (duk_context *) thr;
    duk_ret_t rc;
#ifdef DUK_USE_ASSERTIONS
    duk_idx_t entry_top;
#endif
 
    DUK_DDD(DUK_DDDPRINT("running object finalizer for object: %p", (void *) obj));
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT_VALSTACK_SPACE(thr, 1);
 
#ifdef DUK_USE_ASSERTIONS
    entry_top = duk_get_top(ctx);
#endif
    /*
     *  Get and call the finalizer.  All of this must be wrapped
     *  in a protected call, because even getting the finalizer
     *  may trigger an error (getter may throw one, for instance).
     */
 
    DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));
    if (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) obj)) {
        DUK_D(DUK_DPRINT("object already finalized, avoid running finalizer twice: %!O", obj));
        return;
    }
    DUK_HEAPHDR_SET_FINALIZED((duk_heaphdr *) obj);  /* ensure never re-entered until rescue cycle complete */
    if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) {
        /* This shouldn't happen; call sites should avoid looking up
         * _Finalizer "through" a Proxy, but ignore if we come here
         * with a Proxy to avoid finalizer re-entry.
         */
        DUK_D(DUK_DPRINT("object is a proxy, skip finalizer call"));
        return;
    }
 
    /* XXX: use a NULL error handler for the finalizer call? */

References DUK_DDD, and DUK_DDDPRINT.

◆ duk_hobject_set_length()

DUK_INTERNAL_DECL void duk_hobject_set_length	(	duk_hthread *	thr,
		duk_hobject *	obj,
		duk_uint32_t	length )

Definition at line 52156 of file duktape-1.8.0/src/duktape.c.

◆ duk_hobject_set_length_zero()

DUK_INTERNAL_DECL void duk_hobject_set_length_zero	(	duk_hthread *	thr,
		duk_hobject *	obj )

Definition at line 52169 of file duktape-1.8.0/src/duktape.c.

◆ duk_hobject_set_prototype_updref()

DUK_INTERNAL_DECL void duk_hobject_set_prototype_updref	(	duk_hthread *	thr,
		duk_hobject *	h,
		duk_hobject *	p )

Definition at line 47156 of file duktape-1.8.0/src/duktape.c.

                    {
            return 1;
        }
 
        if (sanity-- == 0) {
            if (ignore_loop) {
                break;
            } else {
                DUK_ERROR_RANGE(thr, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
            }
        }
        h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
    } while (h);
 
    return 0;

◆ duk_hstring_char_code_at_raw()

DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw	(	duk_hthread *	thr,
		duk_hstring *	h,
		duk_uint_t	pos )

Definition at line 53425 of file duktape-1.8.0/src/duktape.c.

                                                                                                             {
    duk_uint32_t boff;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_ucodepoint_t cp;
 
    /* Caller must check character offset to be inside the string. */
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(h != NULL);
    DUK_ASSERT_DISABLE(pos >= 0);  /* unsigned */
    DUK_ASSERT(pos < (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h));
 

References DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_DDD, DUK_DDDPRINT, duk_heap_strcache_offset_char2byte(), DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_CHARLEN, DUK_HSTRING_GET_DATA, duk_unicode_decode_xutf8_checked(), and NULL.

◆ duk_hthread_alloc()

DUK_INTERNAL_DECL duk_hthread * duk_hthread_alloc	(	duk_heap *	heap,
		duk_uint_t	hobject_flags )

Definition at line 46326 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
    duk_hthread *res;
 
    res = (duk_hthread *) DUK_ALLOC(heap, sizeof(duk_hthread));
    if (!res) {
        return NULL;
    }
    DUK_MEMZERO(res, sizeof(duk_hthread));
 
    duk__init_object_parts(heap, &res->obj, hobject_flags);
 
#ifdef DUK_USE_EXPLICIT_NULL_INIT
    res->ptr_curr_pc = NULL;
    res->heap = NULL;
    res->valstack = NULL;
    res->valstack_end = NULL;
    res->valstack_bottom = NULL;
    res->valstack_top = NULL;
    res->callstack = NULL;
    res->catchstack = NULL;
    res->resumer = NULL;
    res->compile_ctx = NULL,
#ifdef DUK_USE_HEAPPTR16
    res->strs16 = NULL;
#else
    res->strs = NULL;
#endif

◆ duk_hthread_callstack_grow()

DUK_INTERNAL_DECL void duk_hthread_callstack_grow ( duk_hthread * thr )

Definition at line 54531 of file duktape-1.8.0/src/duktape.c.

        : This should be probably reworked so that there is a shared
 *  unwind primitive which handles all stacks as requested, and knows
 *  the proper order for unwinding.)
 *
 *  Valstack entries above 'top' are always kept initialized to
 *  "undefined unused".  Callstack and catchstack entries above 'top'
 *  are not zeroed and are left as garbage.
 *
 *  Value stack handling is mostly a part of the API implementation.
 */
 
/* include removed: duk_internal.h */
 
/* check that there is space for at least one new entry */
DUK_INTERNAL void duk_hthread_callstack_grow(duk_hthread *thr) {
    duk_activation *new_ptr;
    duk_size_t old_size;
    duk_size_t new_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);   /* avoid warning (unsigned) */
    DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
 
    if (thr->callstack_top < thr->callstack_size) {
        return;
    }
 
    old_size = thr->callstack_size;
    new_size = old_size + DUK_CALLSTACK_GROW_STEP;
 
    /* this is a bit approximate (errors out before max is reached); this is OK */
    if (new_size >= thr->callstack_max) {
        DUK_ERROR_RANGE(thr, DUK_STR_CALLSTACK_LIMIT);
    }
 
    DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size));

References duk_hthread::callstack_max, duk_hthread::callstack_size, duk_hthread::callstack_top, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CALLSTACK_GROW_STEP, DUK_DD, DUK_DDPRINT, DUK_ERROR_RANGE, DUK_STR_CALLSTACK_LIMIT, and NULL.

Referenced by duk_handle_ecma_call_setup().

◆ duk_hthread_callstack_shrink_check()

DUK_INTERNAL_DECL void duk_hthread_callstack_shrink_check ( duk_hthread * thr )

Definition at line 54571 of file duktape-1.8.0/src/duktape.c.

                  {
        /* No need for a NULL/zero-size check because new_size > 0) */
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    thr->callstack = new_ptr;
    thr->callstack_size = new_size;
 
    /* note: any entries above the callstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_callstack_shrink_check(duk_hthread *thr) {
    duk_size_t new_size;
    duk_activation *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
 
    if (thr->callstack_size - thr->callstack_top < DUK_CALLSTACK_SHRINK_THRESHOLD) {
        return;
    }
 
    new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE;
    DUK_ASSERT(new_size >= thr->callstack_top);
 
    DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.

◆ duk_hthread_callstack_unwind()

DUK_INTERNAL_DECL void duk_hthread_callstack_unwind	(	duk_hthread *	thr,
		duk_size_t	new_top )

Definition at line 54609 of file duktape-1.8.0/src/duktape.c.

           {
        thr->callstack = p;
        thr->callstack_size = new_size;
    } else {
        /* Because new_size != 0, if condition doesn't need to be
         * (p != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("callstack shrink failed, ignoring"));
    }
 
    /* note: any entries above the callstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top) {
    duk_size_t idx;
 
    DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld",
                         (void *) thr,
                         (thr != NULL ? (long) thr->callstack_top : (long) -1),
                         (long) new_top));
 
    DUK_ASSERT(thr);
    DUK_ASSERT(thr->heap);
    DUK_ASSERT_DISABLE(new_top >= 0);  /* unsigned */
    DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top);  /* cannot grow */
 
    /*
     *  The loop below must avoid issues with potential callstack
     *  reallocations.  A resize (and other side effects) may happen
     *  e.g. due to finalizer/errhandler calls caused by a refzero or
     *  mark-and-sweep.  Arbitrary finalizers may run, because when
     *  an environment record is refzero'd, it may refer to arbitrary
     *  values which also become refzero'd.
     *
     *  So, the pointer 'p' is re-looked-up below whenever a side effect
     *  might have changed it.
     */
 
    idx = thr->callstack_top;
    while (idx > new_top) {
        duk_activation *act;
        duk_hobject *func;
#ifdef DUK_USE_REFERENCE_COUNTING
        duk_hobject *tmp;
#endif
#ifdef DUK_USE_DEBUGGER_SUPPORT
        duk_heap *heap;
#endif
 
        idx--;
        DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
        DUK_ASSERT((duk_size_t) idx < thr->callstack_size);  /* true, despite side effect resizes */
 
        act = thr->callstack + idx;
        /* With lightfuncs, act 'func' may be NULL */
 
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
        /*
         *  Restore 'caller' property for non-strict callee functions.
         */
 
        func = DUK_ACT_GET_FUNC(act);
        if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) {
            duk_tval *tv_caller;
            duk_tval tv_tmp;
            duk_hobject *h_tmp;
 
            tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr));
 
            /* The act->prev_caller should only be set if the entry for 'caller'
             * exists (as it is only set in that case, and the property is not
             * configurable), but handle all the cases anyway.
             */
 
            if (tv_caller) {
                DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller);
                if (act->prev_caller) {
                    /* Just transfer the refcount from act->prev_caller to tv_caller,
                     * so no need for a refcount update.  This is the expected case.
                     */
                    DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller);
                    act->prev_caller = NULL;
                } else {
                    DUK_TVAL_SET_NULL(tv_caller);   /* no incref needed */
                    DUK_ASSERT(act->prev_caller == NULL);
                }
                DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
            } else {
                h_tmp = act->prev_caller;
                if (h_tmp) {
                    act->prev_caller = NULL;
                    DUK_HOBJECT_DECREF(thr, h_tmp);  /* side effects */
                }
            }
            act = thr->callstack + idx;  /* avoid side effects */
            DUK_ASSERT(act->prev_caller == NULL);
        }
#endif
 
        /*
         *  Unwind debugger state.  If we unwind while stepping
         *  (either step over or step into), pause execution.
         */
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
        heap = thr->heap;
        if (heap->dbg_step_thread == thr &&
            heap->dbg_step_csindex == idx) {
            /* Pause for all step types: step into, step over, step out.
             * This is the only place explicitly handling a step out.
             */
            DUK_HEAP_SET_PAUSED(heap);
            DUK_ASSERT(heap->dbg_step_thread == NULL);
        }
#endif
 
        /*
         *  Close environment record(s) if they exist.
         *
         *  Only variable environments are closed.  If lex_env != var_env, it
         *  cannot currently contain any register bound declarations.
         *
         *  Only environments created for a NEWENV function are closed.  If an
         *  environment is created for e.g. an eval call, it must not be closed.
         */
 
        func = DUK_ACT_GET_FUNC(act);
        if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) {
            DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation"));
            goto skip_env_close;
        }
        /* func is NULL for lightfunc */
 
        DUK_ASSERT(act->lex_env == act->var_env);
        if (act->var_env != NULL) {
            DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O",
                                 (void *) act->var_env, (duk_heaphdr *) act->var_env));
            duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom);
            act = thr->callstack + idx;  /* avoid side effect issues */
        }
 
#if 0
        if (act->lex_env != NULL) {
            if (act->lex_env == act->var_env) {
                /* common case, already closed, so skip */
                DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env "
                                   "already closed -> skip closing lex_env"));
                ;
            } else {
                DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O",
                                   (void *) act->lex_env, (duk_heaphdr *) act->lex_env));
                duk_js_close_environment_record(thr, act->lex_env, DUK_ACT_GET_FUNC(act), act->idx_bottom);
                act = thr->callstack + idx;  /* avoid side effect issues */
            }
        }
#endif
 
        DUK_ASSERT((act->lex_env == NULL) ||
                   ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
 
        DUK_ASSERT((act->var_env == NULL) ||
                   ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
 
     skip_env_close:
 
        /*
         *  Update preventcount
         */
 
        if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
            DUK_ASSERT(thr->callstack_preventcount >= 1);
            thr->callstack_preventcount--;
        }
 
        /*
         *  Reference count updates
         *
         *  Note: careful manipulation of refcounts.  The top is
         *  not updated yet, so all the activations are reachable
         *  for mark-and-sweep (which may be triggered by decref).
         *  However, the pointers are NULL so this is not an issue.
         */
 
#ifdef DUK_USE_REFERENCE_COUNTING
        tmp = act->var_env;
#endif
        act->var_env = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
        act = thr->callstack + idx;  /* avoid side effect issues */
#endif
 
#ifdef DUK_USE_REFERENCE_COUNTING
        tmp = act->lex_env;
#endif
        act->lex_env = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
        act = thr->callstack + idx;  /* avoid side effect issues */
#endif
 
        /* Note: this may cause a corner case situation where a finalizer
         * may see a currently reachable activation whose 'func' is NULL.
         */
#ifdef DUK_USE_REFERENCE_COUNTING
        tmp = DUK_ACT_GET_FUNC(act);
#endif
        act->func = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
        act = thr->callstack + idx;  /* avoid side effect issues */
        DUK_UNREF(act);
#endif
    }
 
    thr->callstack_top = new_top;

References duk_hthread::callstack, and duk_hthread::callstack_size.

Referenced by duk_handle_ecma_call_setup().

◆ duk_hthread_catchstack_grow()

DUK_INTERNAL_DECL void duk_hthread_catchstack_grow ( duk_hthread * thr )

Definition at line 54836 of file duktape-1.8.0/src/duktape.c.

                                {
        duk_activation *act = thr->callstack + thr->callstack_top - 1;
        act->idx_retval = 0;
    }
#endif
 
    /* Note: any entries above the callstack top are garbage and not zeroed.
     * Also topmost activation idx_retval is garbage (not zeroed), and must
     * be ignored.
     */
}
 
DUK_INTERNAL void duk_hthread_catchstack_grow(duk_hthread *thr) {
    duk_catcher *new_ptr;
    duk_size_t old_size;
    duk_size_t new_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->catchstack_top);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
 
    if (thr->catchstack_top < thr->catchstack_size) {
        return;
    }
 
    old_size = thr->catchstack_size;
    new_size = old_size + DUK_CATCHSTACK_GROW_STEP;
 
    /* this is a bit approximate (errors out before max is reached); this is OK */
    if (new_size >= thr->catchstack_max) {
        DUK_ERROR_RANGE(thr, DUK_STR_CATCHSTACK_LIMIT);
    }
 
    DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size));

References duk_activation::idx_retval.

◆ duk_hthread_catchstack_shrink_check()

DUK_INTERNAL_DECL void duk_hthread_catchstack_shrink_check ( duk_hthread * thr )

Definition at line 54876 of file duktape-1.8.0/src/duktape.c.

                  {
        /* No need for a NULL/zero-size check because new_size > 0) */
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    thr->catchstack = new_ptr;
    thr->catchstack_size = new_size;
 
    /* note: any entries above the catchstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_catchstack_shrink_check(duk_hthread *thr) {
    duk_size_t new_size;
    duk_catcher *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->catchstack_top >= 0);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
 
    if (thr->catchstack_size - thr->catchstack_top < DUK_CATCHSTACK_SHRINK_THRESHOLD) {
        return;
    }
 
    new_size = thr->catchstack_top + DUK_CATCHSTACK_SHRINK_SPARE;
    DUK_ASSERT(new_size >= thr->catchstack_top);
 
    DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.

◆ duk_hthread_catchstack_unwind()

DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind	(	duk_hthread *	thr,
		duk_size_t	new_top )

Definition at line 54914 of file duktape-1.8.0/src/duktape.c.

           {
        thr->catchstack = p;
        thr->catchstack_size = new_size;
    } else {
        /* Because new_size != 0, if condition doesn't need to be
         * (p != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring"));
    }
 
    /* note: any entries above the catchstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top) {
    duk_size_t idx;
 
    DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld",
                         (void *) thr,
                         (thr != NULL ? (long) thr->catchstack_top : (long) -1),
                         (long) new_top));
 
    DUK_ASSERT(thr);
    DUK_ASSERT(thr->heap);
    DUK_ASSERT_DISABLE(new_top >= 0);  /* unsigned */
    DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top);  /* cannot grow */
 
    /*
     *  Since there are no references in the catcher structure,
     *  unwinding is quite simple.  The only thing we need to
     *  look out for is popping a possible lexical environment
     *  established for an active catch clause.
     */
 
    idx = thr->catchstack_top;
    while (idx > new_top) {
        duk_catcher *p;
        duk_activation *act;
        duk_hobject *env;
 
        idx--;
        DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
        DUK_ASSERT((duk_size_t) idx < thr->catchstack_size);
 
        p = thr->catchstack + idx;
 
        if (DUK_CAT_HAS_LEXENV_ACTIVE(p)) {
            DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active",
                                 (long) idx, (long) p->callstack_index, (long) thr->callstack_top));
 
            /* XXX: Here we have a nasty dependency: the need to manipulate
             * the callstack means that catchstack must always be unwound by
             * the caller before unwinding the callstack.  This should be fixed
             * later.
             */
 
            /* Note that multiple catchstack entries may refer to the same
             * callstack entry.
             */
            act = thr->callstack + p->callstack_index;
            DUK_ASSERT(act >= thr->callstack);
            DUK_ASSERT(act < thr->callstack + thr->callstack_top);
 
            DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO",
                                 (long) idx, (long) p->callstack_index,

References duk_hthread::catchstack, and duk_hthread::catchstack_size.

Referenced by duk_handle_ecma_call_setup().

◆ duk_hthread_copy_builtin_objects()

DUK_INTERNAL_DECL void duk_hthread_copy_builtin_objects	(	duk_hthread *	thr_from,
		duk_hthread *	thr_to )

Definition at line 54388 of file duktape-1.8.0/src/duktape.c.

                                               {
        DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO",
                           (long) i, (duk_heaphdr *) duk_require_hobject(ctx, i)));
    }
#endif
 
    /*
     *  Pop built-ins from stack: they are now INCREF'd and

References DUK_DD, DUK_DDPRINT, and duk_require_hobject().

◆ duk_hthread_create_builtin_objects()

DUK_INTERNAL_DECL void duk_hthread_create_builtin_objects ( duk_hthread * thr )

Definition at line 53769 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_double_union du;
    duk_small_uint_t i;
 
    for (i = 0; i < 8; i++) {
        /* Encoding endianness must match target memory layout,
         * build scripts and genbuiltins.py must ensure this.
         */
        du.uc[i] = (duk_uint8_t) duk_bd_decode(bd, 8);
    }
 
    duk_push_number(ctx, du.d);  /* push operation normalizes NaNs */
}
 
DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) {
    duk_context *ctx = (duk_context *) thr;
    duk_bitdecoder_ctx bd_ctx;
    duk_bitdecoder_ctx *bd = &bd_ctx;  /* convenience */
    duk_hobject *h;
    duk_small_uint_t i, j;
 
    DUK_D(DUK_DPRINT("INITBUILTINS BEGIN: DUK_NUM_BUILTINS=%d, DUK_NUM_BUILTINS_ALL=%d", (int) DUK_NUM_BUILTINS, (int) DUK_NUM_ALL_BUILTINS));
 
    DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
    bd->data = (const duk_uint8_t *) duk_builtins_data;
    bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
 
    /*
     *  First create all built-in bare objects on the empty valstack.
     *
     *  Built-ins in the index range [0,DUK_NUM_BUILTINS-1] have value
     *  stack indices matching their eventual thr->builtins[] index.
     *
     *  Built-ins in the index range [DUK_NUM_BUILTINS,DUK_NUM_ALL_BUILTINS]
     *  will exist on the value stack during init but won't be placed
     *  into thr->builtins[].  These are objects referenced in some way
     *  from thr->builtins[] roots but which don't need to be indexed by
     *  Duktape through thr->builtins[] (e.g. user custom objects).
     */
 
    duk_require_stack(ctx, DUK_NUM_ALL_BUILTINS);
 
    DUK_DD(DUK_DDPRINT("create empty built-ins"));
    DUK_ASSERT_TOP(ctx, 0);
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        duk_small_uint_t class_num;
        duk_small_int_t len = -1;  /* must be signed */
 
        class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS);
        len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
 
        if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
            duk_small_uint_t natidx;
            duk_int_t c_nargs;  /* must hold DUK_VARARGS */
            duk_c_function c_func;
            duk_int16_t magic;
 
            DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len));
            DUK_ASSERT(len >= 0);
 
            natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
            c_func = duk_bi_native_functions[natidx];
 
            c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
            if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
                c_nargs = DUK_VARARGS;
            }
 
            /* XXX: set magic directly here? (it could share the c_nargs arg) */
            duk_push_c_function_noexotic(ctx, c_func, c_nargs);
 
            h = duk_require_hobject(ctx, -1);
            DUK_ASSERT(h != NULL);
 
            /* Currently all built-in native functions are strict.
             * duk_push_c_function() now sets strict flag, so
             * assert for it.
             */
            DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h));
 
            /* XXX: function properties */
 
            /* Built-in 'name' is not writable by default.  Function '.name'
             * is writable to allow user code to set a '.name' on a native
             * function.
             */
            duk__push_stridx_or_string(ctx, bd);
            duk_xdef_prop_stridx(ctx,
                                 -2,
                                 DUK_STRIDX_NAME,
                                 (i == DUK_BIDX_FUNCTION_PROTOTYPE) ?
                                     DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE);
 
            /* Almost all global level Function objects are constructable
             * but not all: Function.prototype is a non-constructable,
             * callable Function.
             */
            if (duk_bd_decode_flag(bd)) {
                DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h));
            } else {
                DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h);
            }
 
            /* Cast converts magic to 16-bit signed value */
            magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
            ((duk_hnativefunction *) h)->magic = magic;
        } else {
            /* XXX: ARRAY_PART for Array prototype? */
 
            duk_push_object_helper(ctx,
                                   DUK_HOBJECT_FLAG_EXTENSIBLE,
                                   -1);  /* no prototype or class yet */
 
            h = duk_require_hobject(ctx, -1);
            DUK_ASSERT(h != NULL);
        }
 
        DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
 
        if (i < DUK_NUM_BUILTINS) {
            thr->builtins[i] = h;
            DUK_HOBJECT_INCREF(thr, &h->hdr);
        }
 
        if (len >= 0) {
            /*
             *  For top-level objects, 'length' property has the following
             *  default attributes: non-writable, non-enumerable, non-configurable
             *  (E5 Section 15).
             *
             *  However, 'length' property for Array.prototype has attributes
             *  expected of an Array instance which are different: writable,
             *  non-enumerable, non-configurable (E5 Section 15.4.5.2).
             *
             *  This is currently determined implicitly based on class; there are
             *  no attribute flags in the init data.
             */
 
            duk_push_int(ctx, len);
            duk_xdef_prop_stridx(ctx,
                                 -2,
                                 DUK_STRIDX_LENGTH,
                                 (class_num == DUK_HOBJECT_CLASS_ARRAY ?  /* only Array.prototype matches */
                                  DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE));
        }
 
        /* enable exotic behaviors last */
 
        if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
            DUK_HOBJECT_SET_EXOTIC_ARRAY(h);
        }
        if (class_num == DUK_HOBJECT_CLASS_STRING) {
            DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h);
        }
 
        /* some assertions */
 
        DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h));
        /* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h));
        /* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h));       /* currently, even for Array.prototype */
        /* DUK_HOBJECT_FLAG_STRICT varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) ||  /* all native functions have NEWENV */
                   DUK_HOBJECT_HAS_NEWENV(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h));
        /* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */
        /* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h));
 
        DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len));
    }
 
    /*
     *  Then decode the builtins init data (see genbuiltins.py) to
     *  init objects
     */
 
    DUK_DD(DUK_DDPRINT("initialize built-in object properties"));
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        duk_small_uint_t t;
        duk_small_uint_t num;
 
        DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i));
        h = duk_require_hobject(ctx, i);
        DUK_ASSERT(h != NULL);
 
        t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
        if (t != DUK__NO_BIDX_MARKER) {
            DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t));
            DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, duk_require_hobject(ctx, t));
        }
 
        t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
        if (t != DUK__NO_BIDX_MARKER) {
            /* 'prototype' property for all built-in objects (which have it) has attributes:
             *  [[Writable]] = false,
             *  [[Enumerable]] = false,
             *  [[Configurable]] = false
             */
            DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t));
            duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE);
        }
 
        t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
        if (t != DUK__NO_BIDX_MARKER) {
            /* 'constructor' property for all built-in objects (which have it) has attributes:
             *  [[Writable]] = true,
             *  [[Enumerable]] = false,
             *  [[Configurable]] = true
             */
            DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t));
            duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC);
        }
 
        /* normal valued properties */
        num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS);
        DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num));
        for (j = 0; j < num; j++) {
            duk_small_uint_t prop_flags;
 
            duk__push_stridx_or_string(ctx, bd);
 
            /*
             *  Property attribute defaults are defined in E5 Section 15 (first
             *  few pages); there is a default for all properties and a special
             *  default for 'length' properties.  Variation from the defaults is
             *  signaled using a single flag bit in the bitstream.
             */
 
            if (duk_bd_decode_flag(bd)) {
                prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS);
            } else {
                prop_flags = DUK_PROPDESC_FLAGS_WC;
            }
 
            t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS);
 
            DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, key %!T, flags 0x%02lx, type %ld",
                                 (long) i, (long) j, duk_get_tval(ctx, -1), (unsigned long) prop_flags, (long) t));
 
            switch (t) {
            case DUK__PROP_TYPE_DOUBLE: {
                duk__push_double(ctx, bd);
                break;
            }
            case DUK__PROP_TYPE_STRING: {
                duk__push_string(ctx, bd);
                break;
            }
            case DUK__PROP_TYPE_STRIDX: {
                duk__push_stridx(ctx, bd);
                break;
            }
            case DUK__PROP_TYPE_BUILTIN: {
                duk_small_uint_t bidx;
 
                bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
                DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER);
                duk_dup(ctx, (duk_idx_t) bidx);
                break;
            }
            case DUK__PROP_TYPE_UNDEFINED: {
                duk_push_undefined(ctx);
                break;
            }
            case DUK__PROP_TYPE_BOOLEAN_TRUE: {
                duk_push_true(ctx);
                break;
            }
            case DUK__PROP_TYPE_BOOLEAN_FALSE: {
                duk_push_false(ctx);
                break;
            }
            case DUK__PROP_TYPE_ACCESSOR: {
                duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
                duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
                duk_c_function c_func_getter;
                duk_c_function c_func_setter;
 
                /* XXX: this is a bit awkward because there is no exposed helper
                 * in the API style, only this internal helper.
                 */
                DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, key=%!T, getteridx=%ld, setteridx=%ld, flags=0x%04lx",
                                     (long) i, duk_get_tval(ctx, -1), (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags));
 
                c_func_getter = duk_bi_native_functions[natidx_getter];
                c_func_setter = duk_bi_native_functions[natidx_setter];
                duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0);  /* always 0 args */
                duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1);  /* always 1 arg */
 
                /* XXX: magic for getter/setter? use duk_def_prop()? */
 
                DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_WRITABLE) == 0);  /* genbuiltins.py ensures */
 
                prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR;  /* accessor flag not encoded explicitly */
                duk_hobject_define_accessor_internal(thr,
                                                     duk_require_hobject(ctx, i),
                                                     duk_get_hstring(ctx, -3),
                                                     duk_require_hobject(ctx, -2),
                                                     duk_require_hobject(ctx, -1),
                                                     prop_flags);
                duk_pop_3(ctx);  /* key, getter and setter, now reachable through object */
                goto skip_value;
            }
            default: {
                /* exhaustive */
                DUK_UNREACHABLE();
            }
            }
 
            DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
            duk_xdef_prop(ctx, i, prop_flags);
 
         skip_value:
            continue;  /* avoid empty label at the end of a compound statement */
        }
 
        /* native function properties */
        num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS);
        DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num));
        for (j = 0; j < num; j++) {
            duk_hstring *h_key;
            duk_small_uint_t natidx;
            duk_int_t c_nargs;  /* must hold DUK_VARARGS */
            duk_small_uint_t c_length;
            duk_int16_t magic;
            duk_c_function c_func;
            duk_hnativefunction *h_func;
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
            duk_small_int_t lightfunc_eligible;
#endif
 
            duk__push_stridx_or_string(ctx, bd);
            h_key = duk_get_hstring(ctx, -1);
            DUK_ASSERT(h_key != NULL);
            DUK_UNREF(h_key);
            natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
 
            c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS);
            c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
            if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
                c_nargs = DUK_VARARGS;
            }
 
            c_func = duk_bi_native_functions[natidx];
 
            DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, key %!O, natidx %ld, length %ld, nargs %ld",
                                 (long) i, (long) j, (duk_heaphdr *) h_key, (long) natidx, (long) c_length,
                                 (c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs)));
 
            /* Cast converts magic to 16-bit signed value */
            magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
 
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
            lightfunc_eligible =
                ((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) &&
                (c_length <= DUK_LFUNC_LENGTH_MAX) &&
                (magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX);
 
            if (h_key == DUK_HTHREAD_STRING_EVAL(thr) ||
                h_key == DUK_HTHREAD_STRING_YIELD(thr) ||
                h_key == DUK_HTHREAD_STRING_RESUME(thr) ||
                h_key == DUK_HTHREAD_STRING_REQUIRE(thr)) {
                /* These functions have trouble working as lightfuncs.
                 * Some of them have specific asserts and some may have
                     * additional properties (e.g. 'require.id' may be written).
                 */
                DUK_D(DUK_DPRINT("reject as lightfunc: key=%!O, i=%d, j=%d", (duk_heaphdr *) h_key, (int) i, (int) j));
                lightfunc_eligible = 0;
            }
 
            if (lightfunc_eligible) {
                duk_tval tv_lfunc;
                duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs);
                duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs);
                DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags);
                duk_push_tval(ctx, &tv_lfunc);
                DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1)));
                goto lightfunc_skip;
            }
 
            DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic));
#endif  /* DUK_USE_LIGHTFUNC_BUILTINS */
 
            /* [ (builtin objects) name ] */
 
            duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs);
            h_func = duk_require_hnativefunction(ctx, -1);
            DUK_UNREF(h_func);
 
            /* Currently all built-in native functions are strict.
             * This doesn't matter for many functions, but e.g.
             * String.prototype.charAt (and other string functions)
             * rely on being strict so that their 'this' binding is
             * not automatically coerced.
             */
            DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func);
 
            /* No built-in functions are constructable except the top
             * level ones (Number, etc).
             */
            DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func));
 
            /* XXX: any way to avoid decoding magic bit; there are quite
             * many function properties and relatively few with magic values.
             */
            h_func->magic = magic;
 
            /* [ (builtin objects) name func ] */
 
            duk_push_int(ctx, c_length);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
 
            duk_dup(ctx, -2);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
 
            /* XXX: other properties of function instances; 'arguments', 'caller'. */
 
            DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T",
                               (long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1)));
 
            /* [ (builtin objects) name func ] */
 
            /*
             *  The default property attributes are correct for all
             *  function valued properties of built-in objects now.
             */
 
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
         lightfunc_skip:
#endif
 
            duk_xdef_prop(ctx, i, DUK_PROPDESC_FLAGS_WC);
 
            /* [ (builtin objects) ] */
        }
    }
 
    /*
     *  Special post-tweaks, for cases not covered by the init data format.
     *
     *  - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
     *    toGMTString is required to have the same Function object as
     *    toUTCString in E5 Section B.2.6.  Note that while Smjs respects
     *    this, V8 does not (the Function objects are distinct).
     *
     *  - Make DoubleError non-extensible.
     *
     *  - Add info about most important effective compile options to Duktape.
     *
     *  - Possibly remove some properties (values or methods) which are not
     *    desirable with current feature options but are not currently
     *    conditional in init data.
     */
 
    duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING);
    duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC);
 
    h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR);
    DUK_ASSERT(h != NULL);
    DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
 
#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY)
    DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features"));
    (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW);
#endif
 
#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF)
    DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features"));
    (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW);
#endif
 
    /* XXX: relocate */
    duk_push_string(ctx,
            /* Endianness indicator */
#if defined(DUK_USE_INTEGER_LE)
                    "l"
#elif defined(DUK_USE_INTEGER_BE)
                    "b"
#elif defined(DUK_USE_INTEGER_ME)  /* integer mixed endian not really used now */
                    "m"
#else
                    "?"
#endif
#if defined(DUK_USE_DOUBLE_LE)
                    "l"
#elif defined(DUK_USE_DOUBLE_BE)
                    "b"
#elif defined(DUK_USE_DOUBLE_ME)
                    "m"
#else
                    "?"
#endif
                    " "
            /* Packed or unpacked tval */
#if defined(DUK_USE_PACKED_TVAL)
                    "p"
#else
                    "u"
#endif
#if defined(DUK_USE_FASTINT)
            "f"
#endif
            " "
            /* Low memory options */
#if defined(DUK_USE_STRTAB_CHAIN)
            "c"  /* chain */
#elif defined(DUK_USE_STRTAB_PROBE)
            "p"  /* probe */
#else
            "?"
#endif
#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16)
            "n"
#endif
#if defined(DUK_USE_HEAPPTR16)
            "h"
#endif
#if defined(DUK_USE_DATAPTR16)
            "d"
#endif
#if defined(DUK_USE_FUNCPTR16)
            "f"
#endif
#if defined(DUK_USE_REFCOUNT16)
            "R"
#endif
#if defined(DUK_USE_STRHASH16)
            "H"
#endif
#if defined(DUK_USE_STRLEN16)
            "S"
#endif
#if defined(DUK_USE_BUFLEN16)
            "B"
#endif
#if defined(DUK_USE_OBJSIZES16)
            "O"
#endif
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
            "L"
#endif
#if defined(DUK_USE_ROM_STRINGS) || defined(DUK_USE_ROM_OBJECTS)
            /* XXX: This won't be shown in practice now
             * because this code is not run when builtins
             * are in ROM.
             */
            "Z"
#endif
                    " "
            /* Object property allocation layout */
#if defined(DUK_USE_HOBJECT_LAYOUT_1)
            "p1"
#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
            "p2"
#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
            "p3"
#else
            "p?"
#endif
            " "
            /* Alignment guarantee */
#if (DUK_USE_ALIGN_BY == 4)
            "a4"
#elif (DUK_USE_ALIGN_BY == 8)
            "a8"
#elif (DUK_USE_ALIGN_BY == 1)
            "a1"
#else
#error invalid DUK_USE_ALIGN_BY
#endif
            " "
            /* Architecture, OS, and compiler strings */
                    DUK_USE_ARCH_STRING
            " "
                    DUK_USE_OS_STRING
            " "
                    DUK_USE_COMPILER_STRING);
    duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC);
 
    /*
     *  InitJS code - Ecmascript code evaluated from a built-in source
     *  which provides e.g. backward compatibility.  User can also provide
     *  JS code to be evaluated at startup.
     */
 
#ifdef DUK_USE_BUILTIN_INITJS
    /* XXX: compression */
    DUK_DD(DUK_DDPRINT("running built-in initjs"));
    duk_eval_string(ctx, (const char *) duk_initjs_data);  /* initjs data is NUL terminated */
    duk_pop(ctx);
#endif  /* DUK_USE_BUILTIN_INITJS */
 
#ifdef DUK_USE_USER_INITJS
    /* XXX: compression (as an option) */
    DUK_DD(DUK_DDPRINT("running user initjs"));
    duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS);
#endif  /* DUK_USE_USER_INITJS */
 
    /*
     *  Since built-ins are not often extended, compact them.
     */
 
    DUK_DD(DUK_DDPRINT("compact built-ins"));
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        duk_hobject_compact_props(thr, duk_require_hobject(ctx, i));
    }
 
    DUK_D(DUK_DPRINT("INITBUILTINS END"));

◆ duk_hthread_get_act_prev_pc()

DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_prev_pc	(	duk_hthread *	thr,
		duk_activation *	act )

Definition at line 54459 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    duk_instr_t *bcode;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(act != NULL);
    DUK_UNREF(thr);
 
    /* XXX: store 'bcode' pointer to activation for faster lookup? */
    if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) {
        bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func));
        return (duk_uint_fast32_t) (act->curr_pc - bcode);
    }
    return 0;
}
#endif  /* DUK_USE_DEBUGGER_SUPPORT */
 
DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act) {

References duk_activation::curr_pc, DUK_ASSERT, DUK_HCOMPILEDFUNCTION_GET_CODE_BASE, DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_UNREF, duk_activation::func, duk_hthread::heap, and NULL.

◆ duk_hthread_get_callstack_ptr()

DUK_INTERNAL_DECL void * duk_hthread_get_callstack_ptr	(	duk_heap *	heap,
		void *	ud )

Definition at line 53549 of file duktape-1.8.0/src/duktape.c.

◆ duk_hthread_get_catchstack_ptr()

DUK_INTERNAL_DECL void * duk_hthread_get_catchstack_ptr	(	duk_heap *	heap,
		void *	ud )

Definition at line 53555 of file duktape-1.8.0/src/duktape.c.

◆ duk_hthread_get_current_activation()

DUK_INTERNAL_DECL duk_activation * duk_hthread_get_current_activation ( duk_hthread * thr )

Definition at line 54432 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_current_thread().

◆ duk_hthread_get_valstack_ptr()

DUK_INTERNAL_DECL void * duk_hthread_get_valstack_ptr	(	duk_heap *	heap,
		void *	ud )

Definition at line 53543 of file duktape-1.8.0/src/duktape.c.

53547 :

53548

Referenced by duk__resize_valstack().

◆ duk_hthread_init_stacks()

DUK_INTERNAL_DECL duk_bool_t duk_hthread_init_stacks	(	duk_heap *	heap,
		duk_hthread *	thr )

Definition at line 53477 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    duk_size_t alloc_size;
    duk_size_t i;
 
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->valstack == NULL);
    DUK_ASSERT(thr->valstack_end == NULL);
    DUK_ASSERT(thr->valstack_bottom == NULL);
    DUK_ASSERT(thr->valstack_top == NULL);
    DUK_ASSERT(thr->callstack == NULL);
    DUK_ASSERT(thr->catchstack == NULL);
 
    /* valstack */
    alloc_size = sizeof(duk_tval) * DUK_VALSTACK_INITIAL_SIZE;
    thr->valstack = (duk_tval *) DUK_ALLOC(heap, alloc_size);
    if (!thr->valstack) {
        goto fail;
    }
    DUK_MEMZERO(thr->valstack, alloc_size);
    thr->valstack_end = thr->valstack + DUK_VALSTACK_INITIAL_SIZE;
#if !defined(DUK_USE_PREFER_SIZE)
    thr->valstack_size = DUK_VALSTACK_INITIAL_SIZE;
#endif
    thr->valstack_bottom = thr->valstack;
    thr->valstack_top = thr->valstack;
 
    for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) {
        DUK_TVAL_SET_UNDEFINED(&thr->valstack[i]);
    }
 
    /* callstack */
    alloc_size = sizeof(duk_activation) * DUK_CALLSTACK_INITIAL_SIZE;
    thr->callstack = (duk_activation *) DUK_ALLOC(heap, alloc_size);
    if (!thr->callstack) {
        goto fail;
    }
    DUK_MEMZERO(thr->callstack, alloc_size);
    thr->callstack_size = DUK_CALLSTACK_INITIAL_SIZE;
    DUK_ASSERT(thr->callstack_top == 0);
 
    /* catchstack */
    alloc_size = sizeof(duk_catcher) * DUK_CATCHSTACK_INITIAL_SIZE;
    thr->catchstack = (duk_catcher *) DUK_ALLOC(heap, alloc_size);
    if (!thr->catchstack) {
        goto fail;

◆ duk_hthread_sync_and_null_currpc()

DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc ( duk_hthread * thr )

Definition at line 54492 of file duktape-1.8.0/src/duktape.c.

                                                            {
    duk_activation *act;
 
    DUK_ASSERT(thr != NULL);
 
    if (thr->ptr_curr_pc != NULL) {
        /* ptr_curr_pc != NULL only when bytecode executor is active. */
        DUK_ASSERT(thr->callstack_top > 0);
        act = thr->callstack + thr->callstack_top - 1;

Referenced by duk_err_create_and_throw(), and duk_handle_ecma_call_setup().

◆ duk_hthread_sync_currpc()

DUK_INTERNAL_DECL void duk_hthread_sync_currpc ( duk_hthread * thr )

Definition at line 54479 of file duktape-1.8.0/src/duktape.c.

                                                                 {
        bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func));
        ret = (duk_uint_fast32_t) (act->curr_pc - bcode);
        if (ret > 0) {
            ret--;
        }
        return ret;

◆ duk_hthread_terminate()

DUK_INTERNAL_DECL void duk_hthread_terminate ( duk_hthread * thr )

Definition at line 54403 of file duktape-1.8.0/src/duktape.c.

                                                                                               {
    duk_small_uint_t i;
 
    for (i = 0; i < DUK_NUM_BUILTINS; i++) {
        thr_to->builtins[i] = thr_from->builtins[i];
        DUK_HOBJECT_INCREF_ALLOWNULL(thr_to, thr_to->builtins[i]);  /* side effect free */
    }
}
#line 1 "duk_hthread_misc.c"
/*
 *  Thread support.
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL void duk_hthread_terminate(duk_hthread *thr) {
    DUK_ASSERT(thr != NULL);
 
    /* Order of unwinding is important */
 
    duk_hthread_catchstack_unwind(thr, 0);
 
    duk_hthread_callstack_unwind(thr, 0);  /* side effects, possibly errors */
 
    thr->valstack_bottom = thr->valstack;
    duk_set_top((duk_context *) thr, 0);  /* unwinds valstack, updating refcounts */

References duk_hthread::builtins, DUK_HOBJECT_INCREF_ALLOWNULL, and DUK_NUM_BUILTINS.

◆ duk_insert()

DUK_EXTERNAL void duk_insert	(	duk_context *	ctx,
		duk_idx_t	to_index )

Definition at line 15875 of file duktape-1.8.0/src/duktape.c.

                                                       {
        DUK_ERROR_API_INDEX(thr, -1);
        return;  /* unreachable */
    }
    tv_from = thr->valstack_top - 1;
    tv_to = thr->valstack_top++;
    DUK_ASSERT(tv_from != NULL);
    DUK_ASSERT(tv_to != NULL);
    DUK_TVAL_SET_TVAL(tv_to, tv_from);
    DUK_TVAL_INCREF(thr, tv_to);  /* no side effects */
}
 
DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) {
    duk_tval *p;
    duk_tval *q;
    duk_tval tv_tmp;
    duk_size_t nbytes;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    p = duk_require_tval(ctx, to_index);
    DUK_ASSERT(p != NULL);
    q = duk_require_tval(ctx, -1);
    DUK_ASSERT(q != NULL);
 
    DUK_ASSERT(q >= p);
 
    /*              nbytes
     *           <--------->
     *    [ ... | p | x | x | q ]
     * => [ ... | q | p | x | x ]
     */
 
    nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p));  /* Note: 'q' is top-1 */

Referenced by duk__err_augment_user(), duk_bi_regexp_constructor(), and duk_bi_string_prototype_locale_compare().

◆ duk_instanceof()

DUK_EXTERNAL duk_bool_t duk_instanceof	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 19580 of file duktape-1.8.0/src/duktape.c.

                                        {
        return 0;
    }
 
    /* No coercions or other side effects, so safe */
    return duk_js_strict_equals(tv1, tv2);
}
 
/*
 *  instanceof
 */
 
DUK_EXTERNAL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) {

◆ duk_is_array()

DUK_EXTERNAL duk_bool_t duk_is_array	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17855 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_is_buffer(ctx, idx);
}
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
DUK_EXTERNAL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_POINTER);
}

References DUK_ASSERT_CTX_VALID, and duk_is_buffer().

◆ duk_is_boolean()

DUK_EXTERNAL duk_bool_t duk_is_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17759 of file duktape-1.8.0/src/duktape.c.

17762 {

Referenced by duk_bi_boolean_constructor().

◆ duk_is_bound_function()

DUK_EXTERNAL duk_bool_t duk_is_bound_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17897 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,

◆ duk_is_buffer()

DUK_EXTERNAL duk_bool_t duk_is_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17811 of file duktape-1.8.0/src/duktape.c.

                                        {
        return 0;
    }

Referenced by duk__base64_encode_helper(), and duk_is_array().

◆ duk_is_buffer_data()

DUK_EXTERNAL duk_bool_t duk_is_buffer_data	(	duk_context *	ctx,
		duk_idx_t	idx )

Definition at line 17817 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_STRING);
}
 
DUK_EXTERNAL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_OBJECT);
}
 
DUK_EXTERNAL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_BUFFER);
}
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_EXTERNAL duk_bool_t duk_is_buffer_data(duk_context *ctx, duk_idx_t idx) {
    duk_tval *tv;
 

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_STRING, and index.

◆ duk_is_c_function()

DUK_EXTERNAL duk_bool_t duk_is_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17883 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 

References DUK_ASSERT_CTX_VALID, duk_get_tval(), and index.

◆ duk_is_constructor_call()

DUK_EXTERNAL duk_bool_t duk_is_constructor_call ( duk_context * ctx )

Definition at line 12836 of file duktape-1.8.0/src/duktape.c.

                                 {
        DUK_ERROR_API((duk_hthread *) ctx, DUK_STR_INVALID_CALL_ARGS);
    }
    duk_push_uint(ctx, nargs);
    rc = duk_safe_call(ctx, duk__pnew_helper, nargs + 2 /*nargs*/, 1 /*nrets*/);

References DUK_ERROR_API, and DUK_STR_INVALID_CALL_ARGS.

◆ duk_is_dynamic_buffer()

DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17925 of file duktape-1.8.0/src/duktape.c.

                                                                               {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_HAS_DYNAMIC(h) ? 0 : 1);

◆ duk_is_ecmascript_function()

DUK_EXTERNAL duk_bool_t duk_is_ecmascript_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17890 of file duktape-1.8.0/src/duktape.c.

                                         {
        return 1;
    }
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_COMPILEDFUNCTION |

◆ duk_is_external_buffer()

DUK_EXTERNAL duk_bool_t duk_is_external_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17939 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0);

◆ duk_is_fixed_buffer()

DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17911 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_BOUND);
}
 
DUK_EXTERNAL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,

◆ duk_is_function()

DUK_EXTERNAL duk_bool_t duk_is_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17867 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_LIGHTFUNC);
}
 
DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index) {
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_get_hobject(ctx, index);
    if (obj) {
        return (DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_ARRAY ? 1 : 0);
    }
    return 0;

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_LIGHTFUNC, and index.

◆ duk_is_lightfunc()

DUK_EXTERNAL duk_bool_t duk_is_lightfunc	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17850 of file duktape-1.8.0/src/duktape.c.

◆ duk_is_nan()

DUK_EXTERNAL duk_bool_t duk_is_nan	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17783 of file duktape-1.8.0/src/duktape.c.

             {
        return 0;
    }
    return DUK_TVAL_IS_NUMBER(tv);
}
 

◆ duk_is_null()

DUK_EXTERNAL duk_bool_t duk_is_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17740 of file duktape-1.8.0/src/duktape.c.

17742 {

17743 return 1;

◆ duk_is_null_or_undefined()

DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17745 of file duktape-1.8.0/src/duktape.c.

                                    {
        DUK_ERROR_TYPE(thr, DUK_STR_UNEXPECTED_TYPE);
        DUK_UNREACHABLE();
    }
    return 0;
}
 
DUK_EXTERNAL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_UNDEFINED);
}
 
DUK_EXTERNAL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index) {

References DUK_ERROR_TYPE, DUK_STR_UNEXPECTED_TYPE, and DUK_UNREACHABLE.

◆ duk_is_number()

DUK_EXTERNAL duk_bool_t duk_is_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17764 of file duktape-1.8.0/src/duktape.c.

             {
        return 0;
    }
    tag = DUK_TVAL_GET_TAG(tv);
    return (tag == DUK_TAG_UNDEFINED) || (tag == DUK_TAG_NULL);
}
 
DUK_EXTERNAL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN);
}
 
DUK_EXTERNAL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index) {

◆ duk_is_object()

DUK_EXTERNAL duk_bool_t duk_is_object	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17806 of file duktape-1.8.0/src/duktape.c.

◆ duk_is_pointer()

DUK_EXTERNAL duk_bool_t duk_is_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17845 of file duktape-1.8.0/src/duktape.c.

                                       {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {

◆ duk_is_strict_call()

DUK_EXTERNAL duk_bool_t duk_is_strict_call ( duk_context * ctx )

Definition at line 12851 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
 
    act = duk_hthread_get_current_activation(thr);
    if (act != NULL) {
        return ((act->flags & DUK_ACT_FLAG_CONSTRUCT) != 0 ? 1 : 0);
    }
    return 0;
}
 
DUK_EXTERNAL duk_bool_t duk_is_strict_call(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
 
    /* For user code this could just return 1 (strict) always
     * because all Duktape/C functions are considered strict,
     * and strict is also the default when nothing is running.

◆ duk_is_string()

DUK_EXTERNAL duk_bool_t duk_is_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17801 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), and duk_bi_string_constructor().

◆ duk_is_thread()

DUK_EXTERNAL duk_bool_t duk_is_thread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17904 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,

◆ duk_is_undefined()

DUK_EXTERNAL duk_bool_t duk_is_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17735 of file duktape-1.8.0/src/duktape.c.

17737 {

17738 duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_is_valid_index()

DUK_EXTERNAL duk_bool_t duk_is_valid_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15311 of file duktape-1.8.0/src/duktape.c.

           {
        DUK_ASSERT(index != DUK_INVALID_INDEX);
        uindex = (duk_uidx_t) index;
    }
 

Referenced by duk__base64_encode_helper(), and duk_hobject_define_property_internal().

◆ duk_join()

DUK_EXTERNAL void duk_join	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 19908 of file duktape-1.8.0/src/duktape.c.

◆ duk_js_close_environment_record()

DUK_INTERNAL_DECL void duk_js_close_environment_record	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_hobject *	func,
		duk_size_t	regbase )

Definition at line 72073 of file duktape-1.8.0/src/duktape.c.

                                                                                                                             {
    duk_context *ctx = (duk_context *) thr;
    duk_uint_fast32_t i;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(env != NULL);
    /* func is NULL for lightfuncs */
 
    if (!DUK_HOBJECT_IS_DECENV(env) || DUK_HOBJECT_HAS_ENVRECCLOSED(env)) {
        DUK_DDD(DUK_DDDPRINT("environment record not a declarative record, "
                             "or already closed: %!iO",
                             (duk_heaphdr *) env));
        return;
    }
 
    DUK_DDD(DUK_DDDPRINT("closing environment record: %!iO, func: %!iO, regbase: %ld",
                         (duk_heaphdr *) env, (duk_heaphdr *) func, (long) regbase));
 
    duk_push_hobject(ctx, env);
 
    /* assertions: env must be closed in the same thread as where it runs */
#ifdef DUK_USE_ASSERTIONS
    {
        /* [... env] */
 
        if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE)) {
            DUK_ASSERT(duk_is_object(ctx, -1));
            DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) func);
        }
        duk_pop(ctx);
 
        if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_THREAD)) {
            DUK_ASSERT(duk_is_object(ctx, -1));
            DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) thr);
        }
        duk_pop(ctx);
 
        if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_REGBASE)) {
            DUK_ASSERT(duk_is_number(ctx, -1));
            DUK_ASSERT(duk_get_number(ctx, -1) == (double) regbase);
        }
        duk_pop(ctx);
 
        /* [... env] */
    }
#endif
 
    if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
        duk_hobject *varmap;
        duk_hstring *key;
        duk_tval *tv;
        duk_uint_t regnum;
 
        /* XXX: additional conditions when to close variables? we don't want to do it
         * unless the environment may have "escaped" (referenced in a function closure).
         * With delayed environments, the existence is probably good enough of a check.
         */
 
        /* XXX: any way to detect faster whether something needs to be closed?
         * We now look up _Callee and then skip the rest.
         */
 
        /* Note: we rely on the _Varmap having a bunch of nice properties, like:
         *  - being compacted and unmodified during this process
         *  - not containing an array part
         *  - having correct value types
         */
 
        /* [... env] */
 
        if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE)) {
            DUK_DDD(DUK_DDDPRINT("env has no callee property, nothing to close; re-delete the control properties just in case"));
            duk_pop(ctx);
            goto skip_varmap;
        }
 
        /* [... env callee] */
 
        if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VARMAP)) {
            DUK_DDD(DUK_DDDPRINT("callee has no varmap property, nothing to close; delete the control properties"));
            duk_pop_2(ctx);
            goto skip_varmap;
        }
        varmap = duk_require_hobject(ctx, -1);
        DUK_ASSERT(varmap != NULL);
 
        DUK_DDD(DUK_DDDPRINT("varmap: %!O", (duk_heaphdr *) varmap));
 
        /* [... env callee varmap] */
 
        DUK_DDD(DUK_DDDPRINT("copying bound register values, %ld bound regs", (long) DUK_HOBJECT_GET_ENEXT(varmap)));
 
        for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(varmap); i++) {
            key = DUK_HOBJECT_E_GET_KEY(thr->heap, varmap, i);
            DUK_ASSERT(key != NULL);   /* assume keys are compacted */
 
            DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, varmap, i));  /* assume plain values */
 
            tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, varmap, i);
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));  /* assume value is a number */
            regnum = (duk_uint_t) DUK_TVAL_GET_NUMBER(tv);
            DUK_ASSERT_DISABLE(regnum >= 0);  /* unsigned */
            DUK_ASSERT(regnum < ((duk_hcompiledfunction *) func)->nregs);  /* regnum is sane */
            DUK_ASSERT(thr->valstack + regbase + regnum >= thr->valstack);
            DUK_ASSERT(thr->valstack + regbase + regnum < thr->valstack_top);
 
            /* XXX: slightly awkward */
            duk_push_hstring(ctx, key);
            duk_push_tval(ctx, thr->valstack + regbase + regnum);
            DUK_DDD(DUK_DDDPRINT("closing identifier '%s' -> reg %ld, value %!T",
                                 (const char *) duk_require_string(ctx, -2),
                                 (long) regnum,
                                 (duk_tval *) duk_get_tval(ctx, -1)));
 
            /* [... env callee varmap key val] */
 
            /* if property already exists, overwrites silently */
            duk_xdef_prop(ctx, -5, DUK_PROPDESC_FLAGS_WE);  /* writable but not deletable */
        }
 
        duk_pop_2(ctx);
 
        /* [... env] */

◆ duk_js_compare_helper()

DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_small_int_t	flags )

Definition at line 70942 of file duktape-1.8.0/src/duktape.c.

                                                                                                     {
    /* Similar to String comparison. */
 
    DUK_ASSERT(h1 != NULL);
    DUK_ASSERT(h2 != NULL);
    DUK_UNREF(heap);
 
    return duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h1),
                               (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h2),
                               (duk_size_t) DUK_HBUFFER_GET_SIZE(h1),
                               (duk_size_t) DUK_HBUFFER_GET_SIZE(h2));
}
#endif
 
DUK_INTERNAL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) {
    duk_context *ctx = (duk_context *) thr;
    duk_double_t d1, d2;
    duk_small_int_t c1, c2;
    duk_small_int_t s1, s2;
    duk_small_int_t rc;
    duk_bool_t retval;
 
    /* Fast path for fastints */
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        duk_int64_t v1 = DUK_TVAL_GET_FASTINT(tv_x);
        duk_int64_t v2 = DUK_TVAL_GET_FASTINT(tv_y);
        if (v1 < v2) {
            /* 'lt is true' */
            retval = 1;
        } else {
            retval = 0;
        }
        if (flags & DUK_COMPARE_FLAG_NEGATE) {
            retval ^= 1;
        }
        return retval;
    }
#endif  /* DUK_USE_FASTINT */
 
    /* Fast path for numbers (one of which may be a fastint) */
#if 1  /* XXX: make fast paths optional for size minimization? */
    if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
        d1 = DUK_TVAL_GET_NUMBER(tv_x);
        d2 = DUK_TVAL_GET_NUMBER(tv_y);
        c1 = DUK_FPCLASSIFY(d1);
        c2 = DUK_FPCLASSIFY(d2);
 
        if (c1 == DUK_FP_NORMAL && c2 == DUK_FP_NORMAL) {
            /* XXX: this is a very narrow check, and doesn't cover
             * zeroes, subnormals, infinities, which compare normally.
             */
 
            if (d1 < d2) {
                /* 'lt is true' */
                retval = 1;
            } else {
                retval = 0;
            }
            if (flags & DUK_COMPARE_FLAG_NEGATE) {
                retval ^= 1;
            }
            return retval;
        }
    }
#endif
 
    /* Slow path */
 
    duk_push_tval(ctx, tv_x);
    duk_push_tval(ctx, tv_y);
 
    if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) {
        duk_to_primitive(ctx, -2, DUK_HINT_NUMBER);
        duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
    } else {
        duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
        duk_to_primitive(ctx, -2, DUK_HINT_NUMBER);
    }
 
    /* Note: reuse variables */
    tv_x = DUK_GET_TVAL_NEGIDX(ctx, -2);
    tv_y = DUK_GET_TVAL_NEGIDX(ctx, -1);
 
    if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
        duk_hstring *h1 = DUK_TVAL_GET_STRING(tv_x);
        duk_hstring *h2 = DUK_TVAL_GET_STRING(tv_y);
        DUK_ASSERT(h1 != NULL);
        DUK_ASSERT(h2 != NULL);
 
        rc = duk_js_string_compare(h1, h2);
        if (rc < 0) {
            goto lt_true;
        } else {
            goto lt_false;
        }
    } else {
        /* Ordering should not matter (E5 Section 11.8.5, step 3.a) but
         * preserve it just in case.
         */
 
        if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) {
            d1 = duk_to_number(ctx, -2);
            d2 = duk_to_number(ctx, -1);
        } else {
            d2 = duk_to_number(ctx, -1);
            d1 = duk_to_number(ctx, -2);
        }
 
        c1 = (duk_small_int_t) DUK_FPCLASSIFY(d1);
        s1 = (duk_small_int_t) DUK_SIGNBIT(d1);
        c2 = (duk_small_int_t) DUK_FPCLASSIFY(d2);
        s2 = (duk_small_int_t) DUK_SIGNBIT(d2);
 
        if (c1 == DUK_FP_NAN || c2 == DUK_FP_NAN) {
            goto lt_undefined;
        }
 
        if (c1 == DUK_FP_ZERO && c2 == DUK_FP_ZERO) {
            /* For all combinations: +0 < +0, +0 < -0, -0 < +0, -0 < -0,
             * steps e, f, and g.
             */
            goto lt_false;
        }
 
        if (d1 == d2) {
            goto lt_false;
        }
 
        if (c1 == DUK_FP_INFINITE && s1 == 0) {
            /* x == +Infinity */
            goto lt_false;
        }
 
        if (c2 == DUK_FP_INFINITE && s2 == 0) {
            /* y == +Infinity */
            goto lt_true;
        }
 
        if (c2 == DUK_FP_INFINITE && s2 != 0) {
            /* y == -Infinity */
            goto lt_false;
        }
 
        if (c1 == DUK_FP_INFINITE && s1 != 0) {
            /* x == -Infinity */
            goto lt_true;
        }
 
        if (d1 < d2) {
            goto lt_true;
        }
 
        goto lt_false;
    }
 
 lt_undefined:
    /* Note: undefined from Section 11.8.5 always results in false
     * return (see e.g. Section 11.8.3) - hence special treatment here.
     */
    retval = 0;
    goto cleanup;
 
 lt_true:
    if (flags & DUK_COMPARE_FLAG_NEGATE) {
        retval = 0;
        goto cleanup;
    } else {
        retval = 1;
        goto cleanup;

◆ duk_js_compile()

DUK_INTERNAL_DECL void duk_js_compile	(	duk_hthread *	thr,
		const duk_uint8_t *	src_buffer,
		duk_size_t	src_length,
		duk_small_uint_t	flags )

Definition at line 65545 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                 {
    duk_context *ctx = (duk_context *) thr;
    duk__compiler_stkstate comp_stk;
    duk_compiler_ctx *prev_ctx;
    duk_ret_t safe_rc;
 
    /* XXX: this illustrates that a C catchpoint implemented using duk_safe_call()
     * is a bit heavy at the moment.  The wrapper compiles to ~180 bytes on x64.
     * Alternatives would be nice.
     */
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(src_buffer != NULL);
 
    /* preinitialize lexer state partially */
    DUK_MEMZERO(&comp_stk, sizeof(comp_stk));
    comp_stk.flags = flags;
    DUK_LEXER_INITCTX(&comp_stk.comp_ctx_alloc.lex);
    comp_stk.comp_ctx_alloc.lex.input = src_buffer;

◆ duk_js_data_compare()

DUK_INTERNAL_DECL duk_small_int_t duk_js_data_compare	(	const duk_uint8_t *	buf1,
		const duk_uint8_t *	buf2,
		duk_size_t	len1,
		duk_size_t	len2 )

Definition at line 70874 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                     {
    duk_size_t prefix_len;
    duk_small_int_t rc;
 
    prefix_len = (len1 <= len2 ? len1 : len2);
 
    /* DUK_MEMCMP() is guaranteed to return zero (equal) for zero length
     * inputs so no zero length check is needed.
     */
    rc = DUK_MEMCMP((const void *) buf1,
                    (const void *) buf2,
                    (size_t) prefix_len);

◆ duk_js_declvar_activation()

DUK_INTERNAL_DECL duk_bool_t duk_js_declvar_activation	(	duk_hthread *	thr,
		duk_activation *	act,
		duk_hstring *	name,
		duk_tval *	val,
		duk_small_int_t	prop_flags,
		duk_bool_t	is_func_decl )

Definition at line 73277 of file duktape-1.8.0/src/duktape.c.

                         :
 fail_not_extensible:
    DUK_ERROR_TYPE(thr, "declaration failed");
    return 0;
}
 
DUK_INTERNAL
duk_bool_t duk_js_declvar_activation(duk_hthread *thr,
                                     duk_activation *act,
                                     duk_hstring *name,
                                     duk_tval *val,
                                     duk_small_int_t prop_flags,
                                     duk_bool_t is_func_decl) {
    duk_hobject *env;
    duk_tval tv_val_copy;
    duk_size_t act_off;
 
    DUK_ASSERT(act != NULL);
    act_off = (duk_size_t) ((duk_uint8_t *) act - (duk_uint8_t *) thr->callstack);
 
    /*
     *  Make a value copy of the input val.  This ensures that
     *  side effects cannot invalidate the pointer.
     */
 
    DUK_TVAL_SET_TVAL(&tv_val_copy, val);
    val = &tv_val_copy;
 
    /*

◆ duk_js_delvar_activation()

DUK_INTERNAL_DECL duk_bool_t duk_js_delvar_activation	(	duk_hthread *	thr,
		duk_activation *	act,
		duk_hstring *	name )

Definition at line 72987 of file duktape-1.8.0/src/duktape.c.

                                                            : name=%!O "
                         "(treated as silent success)",
                         (duk_heaphdr *) name));
    return 1;
}

◆ duk_js_equals_helper()

DUK_INTERNAL_DECL duk_bool_t duk_js_equals_helper	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_small_int_t	flags )

Definition at line 70642 of file duktape-1.8.0/src/duktape.c.

                                                                {
            /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
            return 1;
        }
        return 0;
    }
#endif  /* DUK_USE_PARANOID_MATH */
}
 
DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) {
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_tmp;
 
    /* If flags != 0 (strict or SameValue), thr can be NULL.  For loose
     * equals comparison it must be != NULL.
     */
    DUK_ASSERT(flags != 0 || thr != NULL);
 
    /*
     *  Same type?
     *
     *  Note: since number values have no explicit tag in the 8-byte
     *  representation, need the awkward if + switch.
     */
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        if (DUK_TVAL_GET_FASTINT(tv_x) == DUK_TVAL_GET_FASTINT(tv_y)) {
            return 1;
        } else {
            return 0;
        }
    }
    else
#endif
    if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
        /* Catches both doubles and cases where only one argument is a fastint */
        if (DUK_UNLIKELY((flags & DUK_EQUALS_FLAG_SAMEVALUE) != 0)) {
            /* SameValue */
            return duk__js_samevalue_number(DUK_TVAL_GET_NUMBER(tv_x),
                                            DUK_TVAL_GET_NUMBER(tv_y));
        } else {
            /* equals and strict equals */
            return duk__js_equals_number(DUK_TVAL_GET_NUMBER(tv_x),
                                         DUK_TVAL_GET_NUMBER(tv_y));
        }
    } else if (DUK_TVAL_GET_TAG(tv_x) == DUK_TVAL_GET_TAG(tv_y)) {
        switch (DUK_TVAL_GET_TAG(tv_x)) {
        case DUK_TAG_UNDEFINED:
        case DUK_TAG_NULL: {
            return 1;
        }
        case DUK_TAG_BOOLEAN: {
            return DUK_TVAL_GET_BOOLEAN(tv_x) == DUK_TVAL_GET_BOOLEAN(tv_y);
        }
        case DUK_TAG_POINTER: {
            return DUK_TVAL_GET_POINTER(tv_x) == DUK_TVAL_GET_POINTER(tv_y);
        }
        case DUK_TAG_STRING:
        case DUK_TAG_OBJECT: {
            /* heap pointer comparison suffices */
            return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
        }
        case DUK_TAG_BUFFER: {
            if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
                /* heap pointer comparison suffices */
                return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
            } else {
                /* non-strict equality for buffers compares contents */
                duk_hbuffer *h_x = DUK_TVAL_GET_BUFFER(tv_x);
                duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
                duk_size_t len_x = DUK_HBUFFER_GET_SIZE(h_x);
                duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
                void *buf_x;
                void *buf_y;
                if (len_x != len_y) {
                    return 0;
                }
                buf_x = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_x);
                buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
                /* if len_x == len_y == 0, buf_x and/or buf_y may
                 * be NULL, but that's OK.
                 */
                DUK_ASSERT(len_x == len_y);
                DUK_ASSERT(len_x == 0 || buf_x != NULL);
                DUK_ASSERT(len_y == 0 || buf_y != NULL);
                return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0;
            }
        }
        case DUK_TAG_LIGHTFUNC: {
            /* At least 'magic' has a significant impact on function
             * identity.
             */
            duk_small_uint_t lf_flags_x;
            duk_small_uint_t lf_flags_y;
            duk_c_function func_x;
            duk_c_function func_y;
 
            DUK_TVAL_GET_LIGHTFUNC(tv_x, func_x, lf_flags_x);
            DUK_TVAL_GET_LIGHTFUNC(tv_y, func_y, lf_flags_y);
            return ((func_x == func_y) && (lf_flags_x == lf_flags_y)) ? 1 : 0;
        }
#if defined(DUK_USE_FASTINT)
        case DUK_TAG_FASTINT:
#endif
        default: {
            DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_x));
            DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_y));
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_y));
            DUK_UNREACHABLE();
            return 0;
        }
        }
    }
 
    if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
        return 0;
    }
 
    DUK_ASSERT(flags == 0);  /* non-strict equality from here on */
 
    /*
     *  Types are different; various cases for non-strict comparison
     *
     *  Since comparison is symmetric, we use a "swap trick" to reduce
     *  code size.
     */
 
    /* Undefined/null are considered equal (e.g. "null == undefined" -> true). */
    if ((DUK_TVAL_IS_UNDEFINED(tv_x) && DUK_TVAL_IS_NULL(tv_y)) ||
        (DUK_TVAL_IS_NULL(tv_x) && DUK_TVAL_IS_UNDEFINED(tv_y))) {
        return 1;
    }
 
    /* Number/string-or-buffer -> coerce string to number (e.g. "'1.5' == 1.5" -> true). */
    if (DUK_TVAL_IS_NUMBER(tv_x) && (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) {
        /* the next 'if' is guaranteed to match after swap */
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) && DUK_TVAL_IS_NUMBER(tv_y)) {
        /* XXX: this is possible without resorting to the value stack */
        duk_double_t d1, d2;
        d2 = DUK_TVAL_GET_NUMBER(tv_y);
        duk_push_tval(ctx, tv_x);
        duk_to_string(ctx, -1);  /* buffer values are coerced first to string here */
        duk_to_number(ctx, -1);
        d1 = duk_require_number(ctx, -1);
        duk_pop(ctx);
        return duk__js_equals_number(d1, d2);
    }
 
    /* Buffer/string -> compare contents. */
    if (DUK_TVAL_IS_BUFFER(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_BUFFER(tv_y)) {
        duk_hstring *h_x = DUK_TVAL_GET_STRING(tv_x);
        duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
        duk_size_t len_x = DUK_HSTRING_GET_BYTELEN(h_x);
        duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
        const void *buf_x;
        const void *buf_y;
        if (len_x != len_y) {
            return 0;
        }
        buf_x = (const void *) DUK_HSTRING_GET_DATA(h_x);
        buf_y = (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
        /* if len_x == len_y == 0, buf_x and/or buf_y may
         * be NULL, but that's OK.
         */
        DUK_ASSERT(len_x == len_y);
        DUK_ASSERT(len_x == 0 || buf_x != NULL);
        DUK_ASSERT(len_y == 0 || buf_y != NULL);
        return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0;
    }
 
    /* Boolean/any -> coerce boolean to number and try again.  If boolean is
     * compared to a pointer, the final comparison after coercion now always
     * yields false (as pointer vs. number compares to false), but this is
     * not special cased.
     */
    if (DUK_TVAL_IS_BOOLEAN(tv_x)) {
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if (DUK_TVAL_IS_BOOLEAN(tv_y)) {
        /* ToNumber(bool) is +1.0 or 0.0.  Tagged boolean value is always 0 or 1. */
        duk_bool_t rc;
        DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv_y) == 0 || DUK_TVAL_GET_BOOLEAN(tv_y) == 1);
        duk_push_tval(ctx, tv_x);
        duk_push_int(ctx, DUK_TVAL_GET_BOOLEAN(tv_y));
        rc = duk_js_equals_helper(thr,
                                  DUK_GET_TVAL_NEGIDX(ctx, -2),
                                  DUK_GET_TVAL_NEGIDX(ctx, -1),
                                  0 /*flags:nonstrict*/);
        duk_pop_2(ctx);
        return rc;
    }
 
    /* String-number-buffer/object -> coerce object to primitive (apparently without hint), then try again. */
    if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_NUMBER(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) &&
        DUK_TVAL_IS_OBJECT(tv_y)) {
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }

◆ duk_js_execute_bytecode()

DUK_INTERNAL_DECL void duk_js_execute_bytecode ( duk_hthread * exec_thr )

Definition at line 67606 of file duktape-1.8.0/src/duktape.c.

                                        {
        /* Restart bytecode execution, possibly with a changed thread. */
        ;
    } else {
        /* Rethrow error to calling state. */
        DUK_ASSERT(lj_ret == DUK__LONGJMP_RETHROW);
 
        /* Longjmp handling has restored jmpbuf_ptr. */
        DUK_ASSERT(heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr);
 
        /* Thread may have changed, e.g. YIELD converted to THROW. */
        duk_err_longjmp(heap->curr_thread);
        DUK_UNREACHABLE();
    }
}
 
/* Outer executor with setjmp/longjmp handling. */
DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) {
    /* Entry level info. */
    duk_hthread *entry_thread;
    duk_size_t entry_callstack_top;
    duk_int_t entry_call_recursion_depth;
    duk_jmpbuf *entry_jmpbuf_ptr;
    duk_jmpbuf our_jmpbuf;
    duk_heap *heap;
 
    DUK_ASSERT(exec_thr != NULL);
    DUK_ASSERT(exec_thr->heap != NULL);
    DUK_ASSERT(exec_thr->heap->curr_thread != NULL);
    DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR((duk_heaphdr *) exec_thr);
    DUK_ASSERT(exec_thr->callstack_top >= 1);  /* at least one activation, ours */
    DUK_ASSERT(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1) != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1)));
 
    entry_thread = exec_thr;
    heap = entry_thread->heap;
    entry_callstack_top = entry_thread->callstack_top;
    entry_call_recursion_depth = entry_thread->heap->call_recursion_depth;
    entry_jmpbuf_ptr = entry_thread->heap->lj.jmpbuf_ptr;
 
    /*
     *  Note: we currently assume that the setjmp() catchpoint is
     *  not re-entrant (longjmp() cannot be called more than once
     *  for a single setjmp()).
     *
     *  See doc/code-issues.rst for notes on variable assignment
     *  before and after setjmp().
     */
 
    for (;;) {
        heap->lj.jmpbuf_ptr = &our_jmpbuf;
        DUK_ASSERT(heap->lj.jmpbuf_ptr != NULL);
 
#if defined(DUK_USE_CPP_EXCEPTIONS)
        try {
#else
        DUK_ASSERT(heap->lj.jmpbuf_ptr == &our_jmpbuf);
        if (DUK_SETJMP(our_jmpbuf.jb) == 0) {
#endif
            /* Execute bytecode until returned or longjmp(). */
            duk__js_execute_bytecode_inner(entry_thread, entry_callstack_top);
 
            /* Successful return: restore jmpbuf and return to caller. */
            heap->lj.jmpbuf_ptr = entry_jmpbuf_ptr;
 
            return;
#if defined(DUK_USE_CPP_EXCEPTIONS)
        } catch (duk_internal_exception &exc) {
#else
        } else {
#endif
#if defined(DUK_USE_CPP_EXCEPTIONS)
            DUK_UNREF(exc);
#endif
            DUK_DDD(DUK_DDDPRINT("longjmp caught by bytecode executor"));
 
            duk__handle_executor_error(heap,
                                       entry_thread,
                                       entry_callstack_top,
                                       entry_call_recursion_depth,
                                       entry_jmpbuf_ptr);
        }
#if defined(DUK_USE_CPP_EXCEPTIONS)
        catch (std::exception &exc) {
            const char *what = exc.what();
            if (!what) {
                what = "unknown";
            }
            DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)"));
            try {
                DUK_ASSERT(heap->curr_thread != NULL);
                DUK_ERROR_FMT1(heap->curr_thread, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what);
            } catch (duk_internal_exception exc) {
                DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception"));
                DUK_UNREF(exc);
                duk__handle_executor_error(heap,
                                           entry_thread,
                                           entry_callstack_top,
                                           entry_call_recursion_depth,
                                           entry_jmpbuf_ptr);
            }
        } catch (...) {
            DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)"));
            try {

◆ duk_js_getvar_activation()

DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_activation	(	duk_hthread *	thr,
		duk_activation *	act,
		duk_hstring *	name,
		duk_bool_t	throw_flag )

Definition at line 72772 of file duktape-1.8.0/src/duktape.c.

◆ duk_js_getvar_envrec()

DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_envrec	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_hstring *	name,
		duk_bool_t	throw_flag )

Definition at line 72764 of file duktape-1.8.0/src/duktape.c.

72769 {

◆ duk_js_in()

DUK_INTERNAL_DECL duk_bool_t duk_js_in	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y )

Definition at line 71293 of file duktape-1.8.0/src/duktape.c.

             :
    duk_pop_2(ctx);
    return 1;
}
 
/*
 *  in
 */
 
/*
 *  E5 Sections 11.8.7, 8.12.6.
 *
 *  Basically just a property existence check using [[HasProperty]].
 */
 
DUK_INTERNAL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y) {
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t retval;
 
    /*
     *  Get the values onto the stack first.  It would be possible to cover
     *  some normal cases without resorting to the value stack (e.g. if
     *  lval is already a string).
     */
 
    /* XXX: The ES5/5.1/6 specifications require that the key in 'key in obj'
     * must be string coerced before the internal HasProperty() algorithm is
     * invoked.  A fast path skipping coercion could be safely implemented for
     * numbers (as number-to-string coercion has no side effects).  For ES6
     * proxy behavior, the trap 'key' argument must be in a string coerced
     * form (which is a shame).

◆ duk_js_init_activation_environment_records_delayed()

DUK_INTERNAL_DECL void duk_js_init_activation_environment_records_delayed	(	duk_hthread *	thr,
		duk_activation *	act )

Definition at line 72014 of file duktape-1.8.0/src/duktape.c.

                                               {
        duk_push_hthread(ctx, thr);
        duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_THREAD);
        duk_push_hobject(ctx, func);
        duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_CALLEE);
        duk_push_size_t(ctx, idx_bottom);
        duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_REGBASE);
    }
 
    return env;
}
 
DUK_INTERNAL
void duk_js_init_activation_environment_records_delayed(duk_hthread *thr,
                                                        duk_activation *act) {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *func;
    duk_hobject *env;
    duk_size_t act_off;
 
    DUK_ASSERT(act != NULL);
    act_off = (duk_size_t) ((duk_uint8_t *) act - (duk_uint8_t *) thr->callstack);
    func = DUK_ACT_GET_FUNC(act);
    DUK_ASSERT(func != NULL);
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));  /* bound functions are never in act 'func' */
 
    /*
     *  Delayed initialization only occurs for 'NEWENV' functions.
     */
 
    DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
    DUK_ASSERT(act->lex_env == NULL);
    DUK_ASSERT(act->var_env == NULL);
 
    env = duk_create_activation_environment_record(thr, func, act->idx_bottom);
    DUK_ASSERT(env != NULL);
    act = (duk_activation *) ((duk_uint8_t *) thr->callstack + act_off);
 
    DUK_DDD(DUK_DDDPRINT("created delayed fresh env: %!ipO", (duk_heaphdr *) env));

◆ duk_js_instanceof()

DUK_INTERNAL_DECL duk_bool_t duk_js_instanceof	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y )

Definition at line 71136 of file duktape-1.8.0/src/duktape.c.

                                                                                            {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *func;
    duk_hobject *val;
    duk_hobject *proto;
    duk_uint_t sanity;
 
    /*
     *  Get the values onto the stack first.  It would be possible to cover
     *  some normal cases without resorting to the value stack.
     *
     *  The right hand side could be a light function (as they generally
     *  behave like objects).  Light functions never have a 'prototype'
     *  property so E5.1 Section 15.3.5.3 step 3 always throws a TypeError.
     *  Using duk_require_hobject() is thus correct (except for error msg).
     */
 
    duk_push_tval(ctx, tv_x);
    duk_push_tval(ctx, tv_y);
    func = duk_require_hobject(ctx, -1);
 
    /*
     *  For bound objects, [[HasInstance]] just calls the target function
     *  [[HasInstance]].  If that is again a bound object, repeat until
     *  we find a non-bound Function object.
     */
 
    /* XXX: this bound function resolution also happens elsewhere,
     * move into a shared helper.
     */
 
    sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY;
    do {
        /* check func supports [[HasInstance]] (this is checked for every function
         * in the bound chain, including the final one)
         */
 
        if (!DUK_HOBJECT_IS_CALLABLE(func)) {
            /*
             *  Note: of native Ecmascript objects, only Function instances
             *  have a [[HasInstance]] internal property.  Custom objects might
             *  also have it, but not in current implementation.
             *
             *  XXX: add a separate flag, DUK_HOBJECT_FLAG_ALLOW_INSTANCEOF?
             */
            DUK_ERROR_TYPE(thr, "invalid instanceof rval");
        }
 
        if (!DUK_HOBJECT_HAS_BOUND(func)) {
            break;
        }
 
        /* [ ... lval rval ] */
 
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);         /* -> [ ... lval rval new_rval ] */
        duk_replace(ctx, -1);                                        /* -> [ ... lval new_rval ] */
        func = duk_require_hobject(ctx, -1);
 
        /* func support for [[HasInstance]] checked in the beginning of the loop */
    } while (--sanity > 0);
 
    if (sanity == 0) {
        DUK_ERROR_RANGE(thr, DUK_STR_BOUND_CHAIN_LIMIT);
    }
 
    /*
     *  'func' is now a non-bound object which supports [[HasInstance]]
     *  (which here just means DUK_HOBJECT_FLAG_CALLABLE).  Move on
     *  to execute E5 Section 15.3.5.3.
     */
 
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
    DUK_ASSERT(DUK_HOBJECT_IS_CALLABLE(func));
 
    /* [ ... lval rval(func) ] */
 
    /* Handle lightfuncs through object coercion for now. */
    /* XXX: direct implementation */
    val = duk_get_hobject_or_lfunc_coerce(ctx, -2);
    if (!val) {
        goto pop_and_false;
    }
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_PROTOTYPE);  /* -> [ ... lval rval rval.prototype ] */
    proto = duk_require_hobject(ctx, -1);
    duk_pop(ctx);  /* -> [ ... lval rval ] */
 
    DUK_ASSERT(val != NULL);
 
#if defined(DUK_USE_ES6_PROXY)
    val = duk_hobject_resolve_proxy_target(thr, val);
    DUK_ASSERT(val != NULL);
#endif
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        /*
         *  Note: prototype chain is followed BEFORE first comparison.  This
         *  means that the instanceof lval is never itself compared to the
         *  rval.prototype property.  This is apparently intentional, see E5
         *  Section 15.3.5.3, step 4.a.
         *
         *  Also note:
         *
         *      js> (function() {}) instanceof Function
         *      true
         *      js> Function instanceof Function
         *      true
         *
         *  For the latter, h_proto will be Function.prototype, which is the
         *  built-in Function prototype.  Because Function.[[Prototype]] is
         *  also the built-in Function prototype, the result is true.
         */
 
        DUK_ASSERT(val != NULL);
        val = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, val);
 
        if (!val) {
            goto pop_and_false;
        }
 
        DUK_ASSERT(val != NULL);
#if defined(DUK_USE_ES6_PROXY)
        val = duk_hobject_resolve_proxy_target(thr, val);
#endif
 
        if (val == proto) {
            goto pop_and_true;
        }

References DUK_ASSERT, DUK_ERROR_RANGE, DUK_ERROR_TYPE, duk_get_hobject_or_lfunc_coerce(), duk_get_prop_stridx(), DUK_HOBJECT_BOUND_CHAIN_SANITY, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_BOUND, DUK_HOBJECT_IS_CALLABLE, DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY, duk_hobject_resolve_proxy_target(), duk_pop(), duk_pop_2(), duk_push_tval(), duk_replace(), duk_require_hobject(), DUK_STR_BOUND_CHAIN_LIMIT, DUK_STR_PROTOTYPE_CHAIN_LIMIT, DUK_STRIDX_INT_TARGET, DUK_STRIDX_PROTOTYPE, DUK_UNREACHABLE, duk_hthread::heap, NULL, and proto.

◆ duk_js_push_closure()

DUK_INTERNAL_DECL void duk_js_push_closure	(	duk_hthread *	thr,
		duk_hcompiledfunction *	fun_temp,
		duk_hobject *	outer_var_env,
		duk_hobject *	outer_lex_env,
		duk_bool_t	add_auto_proto )

Definition at line 71603 of file duktape-1.8.0/src/duktape.c.

       : if fun_temp has NEWENV, i.e. a new lexical and variable declaration
 * is created when the function is called, only outer_lex_env matters
 * (outer_var_env is ignored and may or may not be same as outer_lex_env).
 */
 
DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[] = {
    /* order: most frequent to least frequent */
    DUK_STRIDX_INT_VARMAP,
    DUK_STRIDX_INT_FORMALS,
    DUK_STRIDX_NAME,
    DUK_STRIDX_INT_PC2LINE,
    DUK_STRIDX_FILE_NAME,
    DUK_STRIDX_INT_SOURCE
};
 
DUK_INTERNAL
void duk_js_push_closure(duk_hthread *thr,
                         duk_hcompiledfunction *fun_temp,
                         duk_hobject *outer_var_env,
                         duk_hobject *outer_lex_env,
                         duk_bool_t add_auto_proto) {
    duk_context *ctx = (duk_context *) thr;
    duk_hcompiledfunction *fun_clos;
    duk_small_uint_t i;
    duk_uint_t len_value;
 
    DUK_ASSERT(fun_temp != NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_temp) != NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_temp) != NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_temp) != NULL);
    DUK_ASSERT(outer_var_env != NULL);
    DUK_ASSERT(outer_lex_env != NULL);
    DUK_UNREF(len_value);
 
    duk_push_compiledfunction(ctx);
    duk_push_hobject(ctx, &fun_temp->obj);  /* -> [ ... closure template ] */
 
    fun_clos = (duk_hcompiledfunction *) duk_get_hcompiledfunction(ctx, -2);
    DUK_ASSERT(fun_clos != NULL);
    DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun_clos));
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos) == NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_clos) == NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_clos) == NULL);
 
    DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_temp));
    DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_temp));
    DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_temp));
 
    /* Note: all references inside 'data' need to get their refcounts
     * upped too.  This is the case because refcounts are decreased
     * through every function referencing 'data' independently.
     */
 
    DUK_HBUFFER_INCREF(thr, DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos));
    duk__inc_data_inner_refcounts(thr, fun_temp);
 
    fun_clos->nregs = fun_temp->nregs;
    fun_clos->nargs = fun_temp->nargs;
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    fun_clos->start_line = fun_temp->start_line;
    fun_clos->end_line = fun_temp->end_line;
#endif
 
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos) != NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_clos) != NULL);
    DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_clos) != NULL);
 
    /* XXX: could also copy from template, but there's no way to have any
     * other value here now (used code has no access to the template).
     */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &fun_clos->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
 
    /*
     *  Init/assert flags, copying them where appropriate.  Some flags
     *  (like NEWENV) are processed separately below.
     */
 
    /* XXX: copy flags using a mask */
 
    DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(&fun_clos->obj));
    DUK_HOBJECT_SET_CONSTRUCTABLE(&fun_clos->obj);  /* Note: not set in template (has no "prototype") */
    DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(&fun_clos->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&fun_clos->obj));
    DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&fun_clos->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&fun_clos->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&fun_clos->obj));
    /* DUK_HOBJECT_FLAG_ARRAY_PART: don't care */
    if (DUK_HOBJECT_HAS_STRICT(&fun_temp->obj)) {
        DUK_HOBJECT_SET_STRICT(&fun_clos->obj);
    }
    if (DUK_HOBJECT_HAS_NOTAIL(&fun_temp->obj)) {
        DUK_HOBJECT_SET_NOTAIL(&fun_clos->obj);
    }
    /* DUK_HOBJECT_FLAG_NEWENV: handled below */
    if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) {
        /* Although NAMEBINDING is not directly needed for using
         * function instances, it's needed by bytecode dump/load
         * so copy it too.
         */
        DUK_HOBJECT_SET_NAMEBINDING(&fun_clos->obj);
    }
    if (DUK_HOBJECT_HAS_CREATEARGS(&fun_temp->obj)) {
        DUK_HOBJECT_SET_CREATEARGS(&fun_clos->obj);
    }
    DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&fun_clos->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&fun_clos->obj));
    DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&fun_clos->obj));
 
    /*
     *  Setup environment record properties based on the template and
     *  its flags.
     *
     *  If DUK_HOBJECT_HAS_NEWENV(fun_temp) is true, the environment
     *  records represent identifiers "outside" the function; the
     *  "inner" environment records are created on demand.  Otherwise,
     *  the environment records are those that will be directly used
     *  (e.g. for declarations).
     *
     *  _Lexenv is always set; _Varenv defaults to _Lexenv if missing,
     *  so _Varenv is only set if _Lexenv != _Varenv.
     *
     *  This is relatively complex, see doc/identifier-handling.rst.
     */
 
    if (DUK_HOBJECT_HAS_NEWENV(&fun_temp->obj)) {
        DUK_HOBJECT_SET_NEWENV(&fun_clos->obj);
 
        if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) {
            duk_hobject *proto;
 
            /*
             *  Named function expression, name needs to be bound
             *  in an intermediate environment record.  The "outer"
             *  lexical/variable environment will thus be:
             *
             *  a) { funcname: <func>, __prototype: outer_lex_env }
             *  b) { funcname: <func>, __prototype:  <globalenv> }  (if outer_lex_env missing)
             */
 
            DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_NAME));  /* required if NAMEBINDING set */
 
            if (outer_lex_env) {
                proto = outer_lex_env;
            } else {
                proto = thr->builtins[DUK_BIDX_GLOBAL_ENV];
            }
 
            /* -> [ ... closure template env ] */
            (void) duk_push_object_helper_proto(ctx,
                                                DUK_HOBJECT_FLAG_EXTENSIBLE |
                                                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
                                                proto);
 
            /* It's important that duk_xdef_prop() is a 'raw define' so that any
             * properties in an ancestor are never an issue (they should never be
             * e.g. non-writable, but just in case).
             */
            duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);       /* -> [ ... closure template env funcname ] */
            duk_dup(ctx, -4);                                    /* -> [ ... closure template env funcname closure ] */
            duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE);     /* -> [ ... closure template env ] */
            /* env[funcname] = closure */
 
            /* [ ... closure template env ] */
 
            duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
            /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
             * will be ignored anyway
             */
 
            /* [ ... closure template ] */
        } else {
            /*
             *  Other cases (function declaration, anonymous function expression,
             *  strict direct eval code).  The "outer" environment will be whatever
             *  the caller gave us.
             */
 
            duk_push_hobject(ctx, outer_lex_env);  /* -> [ ... closure template env ] */
            duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
            /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
             * will be ignored anyway
             */
 
            /* [ ... closure template ] */
        }
    } else {
        /*
         *  Function gets no new environment when called.  This is the
         *  case for global code, indirect eval code, and non-strict
         *  direct eval code.  There is no direct correspondence to the
         *  E5 specification, as global/eval code is not exposed as a
         *  function.
         */
 
        DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj));
 
        duk_push_hobject(ctx, outer_lex_env);  /* -> [ ... closure template env ] */
        duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
 
        if (outer_var_env != outer_lex_env) {
            duk_push_hobject(ctx, outer_var_env);  /* -> [ ... closure template env ] */
            duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_WC);
        }
    }
#ifdef DUK_USE_DDDPRINT
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARENV);
    duk_get_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV);
    DUK_DDD(DUK_DDDPRINT("closure varenv -> %!ipT, lexenv -> %!ipT",
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
    duk_pop_2(ctx);
#endif
 
    /*
     *  Copy some internal properties directly
     *
     *  The properties will be writable and configurable, but not enumerable.
     */
 
    /* [ ... closure template ] */
 
    DUK_DDD(DUK_DDDPRINT("copying properties: closure=%!iT, template=%!iT",
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    for (i = 0; i < (duk_small_uint_t) (sizeof(duk__closure_copy_proplist) / sizeof(duk_uint16_t)); i++) {
        duk_small_int_t stridx = (duk_small_int_t) duk__closure_copy_proplist[i];
        if (duk_get_prop_stridx(ctx, -1, stridx)) {
            /* [ ... closure template val ] */
            DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> found", (long) stridx));
            duk_xdef_prop_stridx(ctx, -3, stridx, DUK_PROPDESC_FLAGS_WC);
        } else {
            DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> not found", (long) stridx));
            duk_pop(ctx);
        }
    }
 
    /*
     *  "length" maps to number of formals (E5 Section 13.2) for function
     *  declarations/expressions (non-bound functions).  Note that 'nargs'
     *  is NOT necessarily equal to the number of arguments.
     */
 
    /* [ ... closure template ] */
 
    len_value = 0;
 
    /* XXX: use helper for size optimization */
    if (duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS)) {
        /* [ ... closure template formals ] */
        DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH));
        DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_UINT_MAX);  /* formal arg limits */
        len_value = (duk_uint_t) duk_get_length(ctx, -1);
    } else {
        /* XXX: what to do if _Formals is not empty but compiler has
         * optimized it away -- read length from an explicit property
         * then?
         */
    }
    duk_pop(ctx);
 
    duk_push_uint(ctx, len_value);  /* [ ... closure template len_value ] */
    duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
 
    /*
     *  "prototype" is, by default, a fresh object with the "constructor"
     *  property.
     *
     *  Note that this creates a circular reference for every function
     *  instance (closure) which prevents refcount-based collection of
     *  function instances.
     *
     *  XXX: Try to avoid creating the default prototype object, because
     *  many functions are not used as constructors and the default
     *  prototype is unnecessary.  Perhaps it could be created on-demand
     *  when it is first accessed?
     */
 
    /* [ ... closure template ] */
 
    if (add_auto_proto) {
        duk_push_object(ctx);  /* -> [ ... closure template newobj ] */
        duk_dup(ctx, -3);          /* -> [ ... closure template newobj closure ] */
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC);  /* -> [ ... closure template newobj ] */
        duk_compact(ctx, -1);  /* compact the prototype */
        duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W);     /* -> [ ... closure template ] */
    }
 
    /*
     *  "arguments" and "caller" must be mapped to throwers for strict
     *  mode and bound functions (E5 Section 15.3.5).
     *
     *  XXX: This is expensive to have for every strict function instance.
     *  Try to implement as virtual properties or on-demand created properties.
     */
 
    /* [ ... closure template ] */
 
    if (DUK_HOBJECT_HAS_STRICT(&fun_clos->obj)) {
        duk_xdef_prop_stridx_thrower(ctx, -2, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
        duk_xdef_prop_stridx_thrower(ctx, -2, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE);
    } else {
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
        DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property in use, add initial 'null' value"));
        duk_push_null(ctx);
        duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
#else
        DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property not used"));
#endif
    }
 
    /*
     *  "name" is a non-standard property found in at least V8, Rhino, smjs.
     *  For Rhino and smjs it is non-writable, non-enumerable, and non-configurable;
     *  for V8 it is writable, non-enumerable, non-configurable.  It is also defined
     *  for an anonymous function expression in which case the value is an empty string.
     *  We could also leave name 'undefined' for anonymous functions but that would
     *  differ from behavior of other engines, so use an empty string.
     *
     *  XXX: make optional?  costs something per function.
     */
 
    /* [ ... closure template ] */
 
    if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME)) {
        /* [ ... closure template name ] */
        DUK_ASSERT(duk_is_string(ctx, -1));
    } else {
        /* [ ... closure template undefined ] */
        duk_pop(ctx);
        duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
    }
    duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);  /* -> [ ... closure template ] */
 
    /*
     *  Compact the closure, in most cases no properties will be added later.
     *  Also, without this the closures end up having unused property slots
     *  (e.g. in Duktape 0.9.0, 8 slots would be allocated and only 7 used).
     *  A better future solution would be to allocate the closure directly
     *  to correct size (and setup the properties directly without going
     *  through the API).
     */
 
    duk_compact(ctx, -2);
 
    /*
     *  Some assertions (E5 Section 13.2).
     */
 
    DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(&fun_clos->obj) == DUK_HOBJECT_CLASS_FUNCTION);
    DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, &fun_clos->obj) == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
    DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(&fun_clos->obj));
    DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH) != 0);
    DUK_ASSERT(add_auto_proto == 0 || duk_has_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE) != 0);
    DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_NAME) != 0);  /* non-standard */
    DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(&fun_clos->obj) ||
               duk_has_prop_stridx(ctx, -2, DUK_STRIDX_CALLER) != 0);

References DUK_STRIDX_FILE_NAME, DUK_STRIDX_INT_FORMALS, DUK_STRIDX_INT_PC2LINE, DUK_STRIDX_INT_SOURCE, DUK_STRIDX_INT_VARMAP, and DUK_STRIDX_NAME.

◆ duk_js_putvar_activation()

DUK_INTERNAL_DECL void duk_js_putvar_activation	(	duk_hthread *	thr,
		duk_activation *	act,
		duk_hstring *	name,
		duk_tval *	val,
		duk_bool_t	strict )

Definition at line 72902 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_del_var().

◆ duk_js_putvar_envrec()

DUK_INTERNAL_DECL void duk_js_putvar_envrec	(	duk_hthread *	thr,
		duk_hobject *	env,
		duk_hstring *	name,
		duk_tval *	val,
		duk_bool_t	strict )

Definition at line 72893 of file duktape-1.8.0/src/duktape.c.

                {
        DUK_DDD(DUK_DDDPRINT("identifier binding not found, strict => reference error"));
        DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "identifier not defined");
    }
 
    DUK_DDD(DUK_DDDPRINT("identifier binding not found, not strict => set to global"));
 

References DUK_DDD, DUK_DDDPRINT, DUK_ERR_REFERENCE_ERROR, and DUK_ERROR.

Referenced by duk_hobject_define_property_helper().

◆ duk_js_string_compare()

DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare	(	duk_hstring *	h1,
		duk_hstring *	h2 )

Definition at line 70904 of file duktape-1.8.0/src/duktape.c.

                {
        return -1;
    } else if (rc > 0) {
        return 1;
    }
 
    /* prefix matches, lengths matter now */
    if (len1 < len2) {
        /* e.g. "x" < "xx" */
        return -1;
    } else if (len1 > len2) {
        return 1;
    }
 
    return 0;
}
 
DUK_INTERNAL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2) {
    /*
     *  String comparison (E5 Section 11.8.5, step 4), which
     *  needs to compare codepoint by codepoint.
     *

◆ duk_js_to_arrayindex_raw_string()

DUK_INTERNAL_DECL duk_small_int_t duk_js_to_arrayindex_raw_string	(	const duk_uint8_t *	str,
		duk_uint32_t	blen,
		duk_uarridx_t *	out_idx )

Definition at line 71414 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                {
    duk_uarridx_t res;
 
    if (blen == 0 || blen > 10) {
        goto parse_fail;
    }
    if (str[0] == DUK_ASC_0 && blen > 1) {
        goto parse_fail;
    }
 
    /* Accept 32-bit decimal integers, no leading zeroes, signs, etc.
     * Leading zeroes are not accepted (zero index "0" is an exception
     * handled above).
     */
 
    res = 0;
    while (blen-- > 0) {
        duk_uint8_t c = *str++;
        if (c >= DUK_ASC_0 && c <= DUK_ASC_9) {
            /* Careful overflow handling.  When multiplying by 10:
             * - 0x19999998 x 10 = 0xfffffff0: no overflow, and adding
             *   0...9 is safe.
             * - 0x19999999 x 10 = 0xfffffffa: no overflow, adding
             *   0...5 is safe, 6...9 overflows.
             * - 0x1999999a x 10 = 0x100000004: always overflow.
             */
            if (DUK_UNLIKELY(res >= 0x19999999UL)) {
                if (res >= 0x1999999aUL) {
                    /* Always overflow. */
                    goto parse_fail;
                }
                DUK_ASSERT(res == 0x19999999UL);
                c -= DUK_ASC_0;
                if (c >= 6) {
                    goto parse_fail;
                }
                res = 0xfffffffaUL + c;

Referenced by duk__alloc_init_hstring().

◆ duk_js_to_arrayindex_string_helper()

DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_string_helper ( duk_hstring * h )

Definition at line 71470 of file duktape-1.8.0/src/duktape.c.

                   {
                res = res * 10U + (duk_uint32_t) (c - DUK_ASC_0);
            }
        } else {
            goto parse_fail;
        }
    }
 
    *out_idx = res;
    return 1;
 
 parse_fail:
    *out_idx = DUK_HSTRING_NO_ARRAY_INDEX;
    return 0;
}

◆ duk_js_toboolean()

DUK_INTERNAL_DECL duk_bool_t duk_js_toboolean ( duk_tval * tv )

Definition at line 70162 of file duktape-1.8.0/src/duktape.c.

                                                       {
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
        return 0;
    case DUK_TAG_BOOLEAN:
        return DUK_TVAL_GET_BOOLEAN(tv);
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HSTRING_GET_BYTELEN(h) > 0 ? 1 : 0);
    }
    case DUK_TAG_OBJECT: {
        return 1;
    }
    case DUK_TAG_BUFFER: {
        /* mimic semantics for strings */
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_GET_SIZE(h) > 0 ? 1 : 0);
    }
    case DUK_TAG_POINTER: {
        void *p = DUK_TVAL_GET_POINTER(tv);
        return (p != NULL ? 1 : 0);
    }
    case DUK_TAG_LIGHTFUNC: {
        return 1;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
        if (DUK_TVAL_GET_FASTINT(tv) != 0) {
            return 1;
        } else {
            return 0;
        }
#endif

References DUK_ASSERT, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_HBUFFER_GET_SIZE, DUK_HSTRING_GET_BYTELEN, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_BOOLEAN, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_DOUBLE, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_DOUBLE, DUK_TVAL_IS_UNUSED, DUK_UNREACHABLE, and NULL.

◆ duk_js_toint32()

DUK_INTERNAL_DECL duk_int32_t duk_js_toint32	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 70424 of file duktape-1.8.0/src/duktape.c.

                 {
        x += DUK_DOUBLE_2TO32;
    }
    /* -> x in [0, 2**32[ */
 
    if (is_toint32) {
        if (x >= DUK_DOUBLE_2TO31) {
            /* x in [2**31, 2**32[ */
 
            x -= DUK_DOUBLE_2TO32;  /* -> x in [-2**31,2**31[ */
        }
    }
 
    return x;
}

References DUK_DOUBLE_2TO32.

Referenced by duk_to_uint32().

◆ duk_js_tointeger()

DUK_INTERNAL_DECL duk_double_t duk_js_tointeger	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 70375 of file duktape-1.8.0/src/duktape.c.

                         {
        return 0.0;
    } else if (c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
        /* XXX: FP_ZERO check can be removed, the else clause handles it
         * correctly (preserving sign).

◆ duk_js_tointeger_number()

DUK_INTERNAL_DECL duk_double_t duk_js_tointeger_number ( duk_double_t x )

Definition at line 70355 of file duktape-1.8.0/src/duktape.c.

           : {
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
        return DUK_TVAL_GET_DOUBLE(tv);
    }
    }
 
    DUK_UNREACHABLE();
}
 
/*
 *  ToInteger()  (E5 Section 9.4)
 */
 
/* exposed, used by e.g. duk_bi_date.c */
DUK_INTERNAL duk_double_t duk_js_tointeger_number(duk_double_t x) {
    duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);

References DUK_ASSERT, DUK_TVAL_GET_DOUBLE, DUK_TVAL_IS_DOUBLE, and DUK_TVAL_IS_UNUSED.

Referenced by duk__div_floor().

◆ duk_js_tonumber()

DUK_INTERNAL_DECL duk_double_t duk_js_tonumber	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 70272 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_context *ctx = (duk_hthread *) thr;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED: {
        /* return a specific NaN (although not strictly necessary) */
        duk_double_union du;
        DUK_DBLUNION_SET_NAN(&du);
        DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
        return du.d;
    }
    case DUK_TAG_NULL: {
        /* +0.0 */
        return 0.0;
    }
    case DUK_TAG_BOOLEAN: {
        if (DUK_TVAL_IS_BOOLEAN_TRUE(tv)) {
            return 1.0;
        }
        return 0.0;
    }
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        duk_push_hstring(ctx, h);
        return duk__tonumber_string_raw(thr);
    }
    case DUK_TAG_OBJECT: {
        /* Note: ToPrimitive(object,hint) == [[DefaultValue]](object,hint),
         * so use [[DefaultValue]] directly.
         */
        duk_double_t d;
        duk_push_tval(ctx, tv);
        duk_to_defaultvalue(ctx, -1, DUK_HINT_NUMBER);  /* 'tv' becomes invalid */
 
        /* recursive call for a primitive value (guaranteed not to cause second
         * recursion).
         */
        d = duk_js_tonumber(thr, duk_require_tval(ctx, -1));
 
        duk_pop(ctx);
        return d;
    }
    case DUK_TAG_BUFFER: {
        /* Coerce like a string.  This makes sense because addition also treats
         * buffers like strings.
         */
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        duk_push_hbuffer(ctx, h);
        duk_to_string(ctx, -1);  /* XXX: expensive, but numconv now expects to see a string */
        return duk__tonumber_string_raw(thr);
    }
    case DUK_TAG_POINTER: {
        /* Coerce like boolean */
        void *p = DUK_TVAL_GET_POINTER(tv);
        return (p != NULL ? 1.0 : 0.0);
    }
    case DUK_TAG_LIGHTFUNC: {

◆ duk_js_touint16()

DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 70460 of file duktape-1.8.0/src/duktape.c.

70463 {

◆ duk_js_touint32()

DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 70442 of file duktape-1.8.0/src/duktape.c.

                                 {
        return DUK_TVAL_GET_FASTINT_I32(tv);
    }
#endif
 
    d = duk_js_tonumber(thr, tv);  /* invalidates tv */
    d = duk__toint32_touint32_helper(d, 1);
    DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL);
    DUK_ASSERT(d >= -2147483648.0 && d <= 2147483647.0);  /* [-0x80000000,0x7fffffff] */
    DUK_ASSERT(d == ((duk_double_t) ((duk_int32_t) d)));  /* whole, won't clip */
    return (duk_int32_t) d;
}
 
 

Referenced by duk_to_uint16().

◆ duk_js_typeof()

DUK_INTERNAL_DECL duk_hstring * duk_js_typeof	(	duk_hthread *	thr,
		duk_tval *	tv_x )

Definition at line 71341 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_small_int_t stridx = 0;
 
    DUK_UNREF(thr);
 
    switch (DUK_TVAL_GET_TAG(tv_x)) {
    case DUK_TAG_UNDEFINED: {
        stridx = DUK_STRIDX_LC_UNDEFINED;
        break;
    }
    case DUK_TAG_NULL: {
        /* Note: not a typo, "object" is returned for a null value */
        stridx = DUK_STRIDX_LC_OBJECT;
        break;
    }
    case DUK_TAG_BOOLEAN: {
        stridx = DUK_STRIDX_LC_BOOLEAN;
        break;
    }
    case DUK_TAG_POINTER: {
        /* implementation specific */
        stridx = DUK_STRIDX_LC_POINTER;
        break;
    }
    case DUK_TAG_STRING: {
        stridx = DUK_STRIDX_LC_STRING;
        break;
    }
    case DUK_TAG_OBJECT: {
        duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_x);
        DUK_ASSERT(obj != NULL);
        if (DUK_HOBJECT_IS_CALLABLE(obj)) {
            stridx = DUK_STRIDX_LC_FUNCTION;
        } else {
            stridx = DUK_STRIDX_LC_OBJECT;
        }
        break;
    }
    case DUK_TAG_BUFFER: {
        /* implementation specific */
        stridx = DUK_STRIDX_LC_BUFFER;
        break;
    }
    case DUK_TAG_LIGHTFUNC: {
        stridx = DUK_STRIDX_LC_FUNCTION;

◆ duk_json_decode()

DUK_EXTERNAL void duk_json_decode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13563 of file duktape-1.8.0/src/duktape.c.

13580 {

13581#ifdef DUK_USE_ASSERTIONS

◆ duk_json_encode()

DUK_EXTERNAL const char * duk_json_encode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13537 of file duktape-1.8.0/src/duktape.c.

                                 {
            goto type_error;
        }
        buf[i >> 1] = (duk_uint8_t) t;
    }
#endif  /* DUK_USE_HEX_FASTPATH */
 
    duk_replace(ctx, index);
    return;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_DECODE_FAILED);
}
 
DUK_EXTERNAL const char *duk_json_encode(duk_context *ctx, duk_idx_t index) {
#ifdef DUK_USE_ASSERTIONS
    duk_idx_t top_at_entry;
#endif
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
#ifdef DUK_USE_ASSERTIONS

◆ duk_lexer_initctx()

DUK_INTERNAL_DECL void duk_lexer_initctx ( duk_lexer_ctx * lex_ctx )

Definition at line 73879 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_context *ctx = (duk_context *) lex_ctx->thr;
 
    DUK_ASSERT(valstack_idx == lex_ctx->slot1_idx || valstack_idx == lex_ctx->slot2_idx);
 
    DUK_BW_PUSH_AS_STRING(lex_ctx->thr, &lex_ctx->bw);
    duk_replace(ctx, valstack_idx);
}
 

References duk_lexer_ctx::bw, DUK_ASSERT, DUK_BW_PUSH_AS_STRING, duk_replace(), duk_lexer_ctx::slot1_idx, duk_lexer_ctx::slot2_idx, and duk_lexer_ctx::thr.

◆ duk_lexer_parse_js_input_element()

DUK_INTERNAL_DECL void duk_lexer_parse_js_input_element	(	duk_lexer_ctx *	lex_ctx,
		duk_token *	out_token,
		duk_bool_t	strict_mode,
		duk_bool_t	regexp_mode )

Definition at line 74017 of file duktape-1.8.0/src/duktape.c.

                                                              {
    duk_codepoint_t x;           /* temporary, must be signed and 32-bit to hold Unicode code points */
    duk_small_uint_t advtok = 0; /* (advance << 8) + token_type, updated at function end,
                                  * init is unnecessary but suppresses "may be used uninitialized" warnings.
                                  */
    duk_bool_t got_lineterm = 0;  /* got lineterm preceding non-whitespace, non-lineterm token */
 
    if (++lex_ctx->token_count >= lex_ctx->token_limit) {
        DUK_ERROR_RANGE(lex_ctx->thr, "token limit");
        return;  /* unreachable */
    }
 
    out_token->t = DUK_TOK_EOF;
    out_token->t_nores = -1;  /* marker: copy t if not changed */
#if 0  /* not necessary to init, disabled for faster parsing */
    out_token->num = DUK_DOUBLE_NAN;
    out_token->str1 = NULL;
    out_token->str2 = NULL;
#endif
    out_token->num_escapes = 0;
    /* out_token->lineterm set by caller */
 
    /* This would be nice, but parsing is faster without resetting the
     * value slots.  The only side effect is that references to temporary
     * string values may linger until lexing is finished; they're then
     * freed normally.
     */
#if 0
    duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
    duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx);
#endif
 
    /* 'advtok' indicates how much to advance and which token id to assign
     * at the end.  This shared functionality minimizes code size.  All
     * code paths are required to set 'advtok' to some value, so no default
     * init value is used.  Code paths calling DUK_ERROR() never return so
     * they don't need to set advtok.
     */
 
    /*
     *  Matching order:
     *
     *    Punctuator first chars, also covers comments, regexps
     *    LineTerminator
     *    Identifier or reserved word, also covers null/true/false literals
     *    NumericLiteral
     *    StringLiteral
     *    EOF
     *
     *  The order does not matter as long as the longest match is
     *  always correctly identified.  There are order dependencies
     *  in the clauses, so it's not trivial to convert to a switch.
     */
 
 restart_lineupdate:
    out_token->start_line = lex_ctx->window[0].line;
 
 restart:
    out_token->start_offset = lex_ctx->window[0].offset;
 
    x = DUK__L0();
 
    switch (x) {
    case DUK_ASC_SPACE:
    case DUK_ASC_HT:  /* fast paths for space and tab */
        DUK__ADVANCECHARS(lex_ctx, 1);
        goto restart;
    case DUK_ASC_LF:  /* LF line terminator; CR LF and Unicode lineterms are handled in slow path */
        DUK__ADVANCECHARS(lex_ctx, 1);
        got_lineterm = 1;
        goto restart_lineupdate;
    case DUK_ASC_SLASH:  /* '/' */
        if (DUK__L1() == '/') {
            /*
             *  E5 Section 7.4, allow SourceCharacter (which is any 16-bit
             *  code point).
             */
 
            /* DUK__ADVANCECHARS(lex_ctx, 2) would be correct here, but it unnecessary */
            for (;;) {
                x = DUK__L0();
                if (x < 0 || duk_unicode_is_line_terminator(x)) {
                    break;
                }
                DUK__ADVANCECHARS(lex_ctx, 1);
            }
            goto restart;  /* line terminator will be handled on next round */
        } else if (DUK__L1() == '*') {
            /*
             *  E5 Section 7.4.  If the multi-line comment contains a newline,
             *  it is treated like a single line terminator for automatic
             *  semicolon insertion.
             */
 
            duk_bool_t last_asterisk = 0;
            DUK__ADVANCECHARS(lex_ctx, 2);
            for (;;) {
                x = DUK__L0();
                if (x < 0) {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "eof in multiline comment");
                }
                DUK__ADVANCECHARS(lex_ctx, 1);
                if (last_asterisk && x == '/') {
                    break;
                }
                if (duk_unicode_is_line_terminator(x)) {
                    got_lineterm = 1;
                }
                last_asterisk = (x == '*');
            }
            goto restart_lineupdate;
        } else if (regexp_mode) {
#if defined(DUK_USE_REGEXP_SUPPORT)
            /*
             *  "/" followed by something in regexp mode.  See E5 Section 7.8.5.
             *
             *  RegExp parsing is a bit complex.  First, the regexp body is delimited
             *  by forward slashes, but the body may also contain forward slashes as
             *  part of an escape sequence or inside a character class (delimited by
             *  square brackets).  A mini state machine is used to implement these.
             *
             *  Further, an early (parse time) error must be thrown if the regexp
             *  would cause a run-time error when used in the expression new RegExp(...).
             *  Parsing here simply extracts the (candidate) regexp, and also accepts
             *  invalid regular expressions (which are delimited properly).  The caller
             *  (compiler) must perform final validation and regexp compilation.
             *
             *  RegExp first char may not be '/' (single line comment) or '*' (multi-
             *  line comment).  These have already been checked above, so there is no
             *  need below for special handling of the first regexp character as in
             *  the E5 productions.
             *
             *  About unicode escapes within regexp literals:
             *
             *      E5 Section 7.8.5 grammar does NOT accept \uHHHH escapes.
             *      However, Section 6 states that regexps accept the escapes,
             *      see paragraph starting with "In string literals...".
             *      The regexp grammar, which sees the decoded regexp literal
             *      (after lexical parsing) DOES have a \uHHHH unicode escape.
             *      So, for instance:
             *
             *          /\u1234/
             *
             *      should first be parsed by the lexical grammar as:
             *
             *          '\' 'u'      RegularExpressionBackslashSequence
             *          '1'          RegularExpressionNonTerminator
             *          '2'          RegularExpressionNonTerminator
             *          '3'          RegularExpressionNonTerminator
             *          '4'          RegularExpressionNonTerminator
             *
             *      and the escape itself is then parsed by the regexp engine.
             *      This is the current implementation.
             *
             *  Minor spec inconsistency:
             *
             *      E5 Section 7.8.5 RegularExpressionBackslashSequence is:
             *
             *         \ RegularExpressionNonTerminator
             *
             *      while Section A.1 RegularExpressionBackslashSequence is:
             *
             *         \ NonTerminator
             *
             *      The latter is not normative and a typo.
             *
             */
 
            /* first, parse regexp body roughly */
 
            duk_small_int_t state = 0;  /* 0=base, 1=esc, 2=class, 3=class+esc */
 
            DUK__INITBUFFER(lex_ctx);
            for (;;) {
                DUK__ADVANCECHARS(lex_ctx, 1);  /* skip opening slash on first loop */
                x = DUK__L0();
                if (x < 0 || duk_unicode_is_line_terminator(x)) {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in regexp");
                }
                x = DUK__L0();  /* re-read to avoid spill / fetch */
                if (state == 0) {
                    if (x == '/') {
                        DUK__ADVANCECHARS(lex_ctx, 1);  /* eat closing slash */
                        break;
                    } else if (x == '\\') {
                        state = 1;
                    } else if (x == '[') {
                        state = 2;
                    }
                } else if (state == 1) {
                    state = 0;
                } else if (state == 2) {
                    if (x == ']') {
                        state = 0;
                    } else if (x == '\\') {
                        state = 3;
                    }
                } else { /* state == 3 */
                    state = 2;
                }
                DUK__APPENDBUFFER(lex_ctx, x);
            }
            duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
            out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
 
            /* second, parse flags */
 
            DUK__INITBUFFER(lex_ctx);
            for (;;) {
                x = DUK__L0();
                if (!duk_unicode_is_identifier_part(x)) {
                    break;
                }
                x = DUK__L0();  /* re-read to avoid spill / fetch */
                DUK__APPENDBUFFER(lex_ctx, x);
                DUK__ADVANCECHARS(lex_ctx, 1);
            }
            duk__internbuffer(lex_ctx, lex_ctx->slot2_idx);
            out_token->str2 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx);
 
            DUK__INITBUFFER(lex_ctx);  /* free some memory */
 
            /* validation of the regexp is caller's responsibility */
 
            advtok = DUK__ADVTOK(0, DUK_TOK_REGEXP);
#else
            DUK_ERROR_SYNTAX(lex_ctx->thr, "regexp support disabled");
#endif
        } else if (DUK__L1() == '=') {
            /* "/=" and not in regexp mode */
            advtok = DUK__ADVTOK(2, DUK_TOK_DIV_EQ);
        } else {
            /* "/" and not in regexp mode */
            advtok = DUK__ADVTOK(1, DUK_TOK_DIV);
        }
        break;
    case DUK_ASC_LCURLY:  /* '{' */
        advtok = DUK__ADVTOK(1, DUK_TOK_LCURLY);
        break;
    case DUK_ASC_RCURLY:  /* '}' */
        advtok = DUK__ADVTOK(1, DUK_TOK_RCURLY);
        break;
    case DUK_ASC_LPAREN:  /* '(' */
        advtok = DUK__ADVTOK(1, DUK_TOK_LPAREN);
        break;
    case DUK_ASC_RPAREN:  /* ')' */
        advtok = DUK__ADVTOK(1, DUK_TOK_RPAREN);
        break;
    case DUK_ASC_LBRACKET:  /* '[' */
        advtok = DUK__ADVTOK(1, DUK_TOK_LBRACKET);
        break;
    case DUK_ASC_RBRACKET:  /* ']' */
        advtok = DUK__ADVTOK(1, DUK_TOK_RBRACKET);
        break;
    case DUK_ASC_PERIOD:  /* '.' */
        if (DUK__ISDIGIT(DUK__L1())) {
            /* Period followed by a digit can only start DecimalLiteral
             * (handled in slow path).  We could jump straight into the
             * DecimalLiteral handling but should avoid goto to inside
             * a block.
             */
            goto slow_path;
        }
        advtok = DUK__ADVTOK(1, DUK_TOK_PERIOD);
        break;
    case DUK_ASC_SEMICOLON:  /* ';' */
        advtok = DUK__ADVTOK(1, DUK_TOK_SEMICOLON);
        break;
    case DUK_ASC_COMMA:  /* ',' */
        advtok = DUK__ADVTOK(1, DUK_TOK_COMMA);
        break;
    case DUK_ASC_LANGLE:  /* '<' */
        if (DUK__L1() == '<' && DUK__L2() == '=') {
            advtok = DUK__ADVTOK(3, DUK_TOK_ALSHIFT_EQ);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_LE);
        } else if (DUK__L1() == '<') {
            advtok = DUK__ADVTOK(2, DUK_TOK_ALSHIFT);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_LT);
        }
        break;
    case DUK_ASC_RANGLE:  /* '>' */
        if (DUK__L1() == '>' && DUK__L2() == '>' && DUK__L3() == '=') {
            advtok = DUK__ADVTOK(4, DUK_TOK_RSHIFT_EQ);
        } else if (DUK__L1() == '>' && DUK__L2() == '>') {
            advtok = DUK__ADVTOK(3, DUK_TOK_RSHIFT);
        } else if (DUK__L1() == '>' && DUK__L2() == '=') {
            advtok = DUK__ADVTOK(3, DUK_TOK_ARSHIFT_EQ);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_GE);
        } else if (DUK__L1() == '>') {
            advtok = DUK__ADVTOK(2, DUK_TOK_ARSHIFT);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_GT);
        }
        break;
    case DUK_ASC_EQUALS:  /* '=' */
        if (DUK__L1() == '=' && DUK__L2() == '=') {
            advtok = DUK__ADVTOK(3, DUK_TOK_SEQ);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_EQUALSIGN);
        }
        break;
    case DUK_ASC_EXCLAMATION:  /* '!' */
        if (DUK__L1() == '=' && DUK__L2() == '=') {
            advtok = DUK__ADVTOK(3, DUK_TOK_SNEQ);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_NEQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_LNOT);
        }
        break;
    case DUK_ASC_PLUS:  /* '+' */
        if (DUK__L1() == '+') {
            advtok = DUK__ADVTOK(2, DUK_TOK_INCREMENT);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_ADD_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_ADD);
        }
        break;
    case DUK_ASC_MINUS:  /* '-' */
        if (DUK__L1() == '-') {
            advtok = DUK__ADVTOK(2, DUK_TOK_DECREMENT);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_SUB_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_SUB);
        }
        break;
    case DUK_ASC_STAR:  /* '*' */
        if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_MUL_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_MUL);
        }
        break;
    case DUK_ASC_PERCENT:  /* '%' */
        if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_MOD_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_MOD);
        }
        break;
    case DUK_ASC_AMP:  /* '&' */
        if (DUK__L1() == '&') {
            advtok = DUK__ADVTOK(2, DUK_TOK_LAND);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_BAND_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_BAND);
        }
        break;
    case DUK_ASC_PIPE:  /* '|' */
        if (DUK__L1() == '|') {
            advtok = DUK__ADVTOK(2, DUK_TOK_LOR);
        } else if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_BOR_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_BOR);
        }
        break;
    case DUK_ASC_CARET:  /* '^' */
        if (DUK__L1() == '=') {
            advtok = DUK__ADVTOK(2, DUK_TOK_BXOR_EQ);
        } else {
            advtok = DUK__ADVTOK(1, DUK_TOK_BXOR);
        }
        break;
    case DUK_ASC_TILDE:  /* '~' */
        advtok = DUK__ADVTOK(1, DUK_TOK_BNOT);
        break;
    case DUK_ASC_QUESTION:  /* '?' */
        advtok = DUK__ADVTOK(1, DUK_TOK_QUESTION);
        break;
    case DUK_ASC_COLON:  /* ':' */
        advtok = DUK__ADVTOK(1, DUK_TOK_COLON);
        break;
    case DUK_ASC_DOUBLEQUOTE:    /* '"' */
    case DUK_ASC_SINGLEQUOTE: {  /* '\'' */
        duk_small_int_t quote = x;  /* Note: duk_uint8_t type yields larger code */
        duk_small_int_t adv;
 
        DUK__INITBUFFER(lex_ctx);
        for (;;) {
            DUK__ADVANCECHARS(lex_ctx, 1);  /* eat opening quote on first loop */
            x = DUK__L0();
            if (x < 0 || duk_unicode_is_line_terminator(x)) {
                DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in string literal");
            }
            if (x == quote) {
                DUK__ADVANCECHARS(lex_ctx, 1);  /* eat closing quote */
                break;
            }
            if (x == '\\') {
                /* DUK__L0        -> '\' char
                 * DUK__L1 ... DUK__L5 -> more lookup
                 */
 
                x = DUK__L1();
 
                /* How much to advance before next loop; note that next loop
                 * will advance by 1 anyway, so -1 from the total escape
                 * length (e.g. len('\uXXXX') - 1 = 6 - 1).  As a default,
                 * 1 is good.
                 */
                adv = 2 - 1;  /* note: long live range */
 
                if (x < 0) {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in string literal");
                }
                if (duk_unicode_is_line_terminator(x)) {
                    /* line continuation */
                    if (x == 0x000d && DUK__L2() == 0x000a) {
                        /* CR LF again a special case */
                        adv = 3 - 1;
                    }
                } else if (x == '\'') {
                    DUK__APPENDBUFFER(lex_ctx, 0x0027);
                } else if (x == '"') {
                    DUK__APPENDBUFFER(lex_ctx, 0x0022);
                } else if (x == '\\') {
                    DUK__APPENDBUFFER(lex_ctx, 0x005c);
                } else if (x == 'b') {
                    DUK__APPENDBUFFER(lex_ctx, 0x0008);
                } else if (x == 'f') {
                    DUK__APPENDBUFFER(lex_ctx, 0x000c);
                } else if (x == 'n') {
                    DUK__APPENDBUFFER(lex_ctx, 0x000a);
                } else if (x == 'r') {
                    DUK__APPENDBUFFER(lex_ctx, 0x000d);
                } else if (x == 't') {
                    DUK__APPENDBUFFER(lex_ctx, 0x0009);
                } else if (x == 'v') {
                    DUK__APPENDBUFFER(lex_ctx, 0x000b);
                } else if (x == 'x') {
                    adv = 4 - 1;
                    DUK__APPENDBUFFER(lex_ctx, duk__decode_hexesc_from_window(lex_ctx, 2));
                } else if (x == 'u') {
                    adv = 6 - 1;
                    DUK__APPENDBUFFER(lex_ctx, duk__decode_uniesc_from_window(lex_ctx, 2));
                } else if (DUK__ISDIGIT(x)) {
                    duk_codepoint_t ch = 0;  /* initialized to avoid warnings of unused var */
 
                    /*
                     *  Octal escape or zero escape:
                     *    \0                                     (lookahead not DecimalDigit)
                     *    \1 ... \7                              (lookahead not DecimalDigit)
                     *    \ZeroToThree OctalDigit                (lookahead not DecimalDigit)
                     *    \FourToSeven OctalDigit                (no lookahead restrictions)
                     *    \ZeroToThree OctalDigit OctalDigit     (no lookahead restrictions)
                     *
                     *  Zero escape is part of the standard syntax.  Octal escapes are
                     *  defined in E5 Section B.1.2, and are only allowed in non-strict mode.
                     *  Any other productions starting with a decimal digit are invalid.
                     */
 
                    if (x == '0' && !DUK__ISDIGIT(DUK__L2())) {
                        /* Zero escape (also allowed in non-strict mode) */
                        ch = 0;
                        /* adv = 2 - 1 default OK */
#if defined(DUK_USE_OCTAL_SUPPORT)
                    } else if (strict_mode) {
                        /* No other escape beginning with a digit in strict mode */
                        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid escape in string literal");
                    } else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(DUK__L2()) && DUK__ISOCTDIGIT(DUK__L3())) {
                        /* Three digit octal escape, digits validated. */
                        adv = 4 - 1;
                        ch = (duk__hexval(lex_ctx, x) << 6) +
                             (duk__hexval(lex_ctx, DUK__L2()) << 3) +
                             duk__hexval(lex_ctx, DUK__L3());
                    } else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) &&
                               DUK__ISOCTDIGIT(DUK__L2())) {
                        /* Two digit octal escape, digits validated.
                         *
                         * The if-condition is a bit tricky.  We could catch e.g.
                         * '\039' in the three-digit escape and fail it there (by
                             * validating the digits), but we want to avoid extra
                         * additional validation code.
                         */
                        adv = 3 - 1;
                        ch = (duk__hexval(lex_ctx, x) << 3) +
                             duk__hexval(lex_ctx, DUK__L2());
                    } else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(DUK__L2())) {
                        /* One digit octal escape, digit validated. */
                        /* adv = 2 default OK */
                        ch = duk__hexval(lex_ctx, x);
#else
                    /* fall through to error */
#endif
                    } else {
                        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid escape in string literal");
                    }
 
                    DUK__APPENDBUFFER(lex_ctx, ch);
                } else {
                    /* escaped NonEscapeCharacter */
                    DUK__APPENDBUFFER(lex_ctx, x);
                }
                DUK__ADVANCECHARS(lex_ctx, adv);
 
                /* Track number of escapes; count not really needed but directive
                 * prologues need to detect whether there were any escapes or line
                 * continuations or not.
                 */
                out_token->num_escapes++;
            } else {
                /* part of string */
                DUK__APPENDBUFFER(lex_ctx, x);
            }
        }
 
        duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
        out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
 
        DUK__INITBUFFER(lex_ctx);  /* free some memory */
 
        advtok = DUK__ADVTOK(0, DUK_TOK_STRING);
        break;
    }
    default:
        goto slow_path;
    }  /* switch */
 
    goto skip_slow_path;
 
 slow_path:
    if (duk_unicode_is_line_terminator(x)) {
        if (x == 0x000d && DUK__L1() == 0x000a) {
            /*
             *  E5 Section 7.3: CR LF is detected as a single line terminator for
             *  line numbers.  Here we also detect it as a single line terminator
             *  token.
             */
            DUK__ADVANCECHARS(lex_ctx, 2);
        } else {
            DUK__ADVANCECHARS(lex_ctx, 1);
        }
        got_lineterm = 1;
        goto restart_lineupdate;
    } else if (duk_unicode_is_identifier_start(x) || x == '\\') {
        /*
         *  Parse an identifier and then check whether it is:
         *    - reserved word (keyword or other reserved word)
         *    - "null"  (NullLiteral)
         *    - "true"  (BooleanLiteral)
         *    - "false" (BooleanLiteral)
         *    - anything else => identifier
         *
         *  This does not follow the E5 productions cleanly, but is
         *  useful and compact.
         *
         *  Note that identifiers may contain Unicode escapes,
         *  see E5 Sections 6 and 7.6.  They must be decoded first,
         *  and the result checked against allowed characters.
         *  The above if-clause accepts an identifier start and an
         *  '\' character -- no other token can begin with a '\'.
         *
         *  Note that "get" and "set" are not reserved words in E5
         *  specification so they are recognized as plain identifiers
         *  (the tokens DUK_TOK_GET and DUK_TOK_SET are actually not
         *  used now).  The compiler needs to work around this.
         *
         *  Strictly speaking, following Ecmascript longest match
         *  specification, an invalid escape for the first character
         *  should cause a syntax error.  However, an invalid escape
         *  for IdentifierParts should just terminate the identifier
         *  early (longest match), and let the next tokenization
         *  fail.  For instance Rhino croaks with 'foo\z' when
         *  parsing the identifier.  This has little practical impact.
         */
 
        duk_small_int_t i, i_end;
        duk_bool_t first = 1;
        duk_hstring *str;
 
        DUK__INITBUFFER(lex_ctx);
        for (;;) {
            /* re-lookup first char on first loop */
            if (DUK__L0() == '\\') {
                duk_codepoint_t ch;
                if (DUK__L1() != 'u') {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid unicode escape in identifier");
                }
 
                ch = duk__decode_uniesc_from_window(lex_ctx, 2);
 
                /* IdentifierStart is stricter than IdentifierPart, so if the first
                 * character is escaped, must have a stricter check here.
                 */
                if (!(first ? duk_unicode_is_identifier_start(ch) : duk_unicode_is_identifier_part(ch))) {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid unicode escape in identifier");
                }
                DUK__APPENDBUFFER(lex_ctx, ch);
                DUK__ADVANCECHARS(lex_ctx, 6);
 
                /* Track number of escapes: necessary for proper keyword
                 * detection.
                 */
                out_token->num_escapes++;
            } else {
                /* Note: first character is checked against this.  But because
                 * IdentifierPart includes all IdentifierStart characters, and
                 * the first character (if unescaped) has already been checked
                 * in the if condition, this is OK.
                 */
                if (!duk_unicode_is_identifier_part(DUK__L0())) {
                    break;
                }
                DUK__APPENDBUFFER(lex_ctx, DUK__L0());
                DUK__ADVANCECHARS(lex_ctx, 1);
            }
            first = 0;
        }
 
        duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
        out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
        str = out_token->str1;
        DUK_ASSERT(str != NULL);
        out_token->t_nores = DUK_TOK_IDENTIFIER;
 
        DUK__INITBUFFER(lex_ctx);  /* free some memory */
 
        /*
         *  Interned identifier is compared against reserved words, which are
         *  currently interned into the heap context.  See genbuiltins.py.
         *
         *  Note that an escape in the identifier disables recognition of
         *  keywords; e.g. "\u0069f = 1;" is a valid statement (assigns to
         *  identifier named "if").  This is not necessarily compliant,
         *  see test-dec-escaped-char-in-keyword.js.
         *
         *  Note: "get" and "set" are awkward.  They are not officially
         *  ReservedWords (and indeed e.g. "var set = 1;" is valid), and
         *  must come out as DUK_TOK_IDENTIFIER.  The compiler needs to
         *  work around this a bit.
         */
 
        /* XXX: optimize by adding the token numbers directly into the
         * always interned duk_hstring objects (there should be enough
         * flag bits free for that)?
         */
 
        i_end = (strict_mode ? DUK_STRIDX_END_RESERVED : DUK_STRIDX_START_STRICT_RESERVED);
 
        advtok = DUK__ADVTOK(0, DUK_TOK_IDENTIFIER);
        if (out_token->num_escapes == 0) {
            for (i = DUK_STRIDX_START_RESERVED; i < i_end; i++) {
                DUK_ASSERT(i >= 0 && i < DUK_HEAP_NUM_STRINGS);
                if (DUK_HTHREAD_GET_STRING(lex_ctx->thr, i) == str) {
                    advtok = DUK__ADVTOK(0, DUK_STRIDX_TO_TOK(i));
                    break;
                }
            }
        }
    } else if (DUK__ISDIGIT(x) || (x == '.')) {
        /* Note: decimal number may start with a period, but must be followed by a digit */
 
        /*
         *  DecimalLiteral, HexIntegerLiteral, OctalIntegerLiteral
         *  "pre-parsing", followed by an actual, accurate parser step.
         *
         *  Note: the leading sign character ('+' or '-') is -not- part of
         *  the production in E5 grammar, and that the a DecimalLiteral
         *  starting with a '0' must be followed by a non-digit.  Leading
         *  zeroes are syntax errors and must be checked for.
         *
         *  XXX: the two step parsing process is quite awkward, it would
         *  be more straightforward to allow numconv to parse the longest
         *  valid prefix (it already does that, it only needs to indicate
         *  where the input ended).  However, the lexer decodes characters
         *  using a lookup window, so this is not a trivial change.
         */
 
        /* XXX: because of the final check below (that the literal is not
         * followed by a digit), this could maybe be simplified, if we bail
         * out early from a leading zero (and if there are no periods etc).
         * Maybe too complex.
         */
 
        duk_double_t val;
        duk_bool_t int_only = 0;
        duk_bool_t allow_hex = 0;
        duk_small_int_t state;  /* 0=before period/exp,
                                 * 1=after period, before exp
                                 * 2=after exp, allow '+' or '-'
                                 * 3=after exp and exp sign
                                 */
        duk_small_uint_t s2n_flags;
        duk_codepoint_t y;
 
        DUK__INITBUFFER(lex_ctx);
        y = DUK__L1();
        if (x == '0' && (y == 'x' || y == 'X')) {
            DUK__APPENDBUFFER(lex_ctx, x);
            DUK__APPENDBUFFER(lex_ctx, y);
            DUK__ADVANCECHARS(lex_ctx, 2);
            int_only = 1;
            allow_hex = 1;
#if defined(DUK_USE_OCTAL_SUPPORT)
        } else if (!strict_mode && x == '0' && DUK__ISDIGIT(y)) {
            /* Note: if DecimalLiteral starts with a '0', it can only be
             * followed by a period or an exponent indicator which starts
             * with 'e' or 'E'.  Hence the if-check above ensures that
             * OctalIntegerLiteral is the only valid NumericLiteral
             * alternative at this point (even if y is, say, '9').
             */
 
            DUK__APPENDBUFFER(lex_ctx, x);
            DUK__ADVANCECHARS(lex_ctx, 1);
            int_only = 1;
#endif
        }
 
        state = 0;
        for (;;) {
            x = DUK__L0();  /* re-lookup curr char on first round */
            if (DUK__ISDIGIT(x)) {
                /* Note: intentionally allow leading zeroes here, as the
                 * actual parser will check for them.
                 */
                if (state == 2) {
                    state = 3;
                }
            } else if (allow_hex && DUK__ISHEXDIGIT(x)) {
                /* Note: 'e' and 'E' are also accepted here. */
                ;
            } else if (x == '.') {
                if (state >= 1 || int_only) {
                    break;
                } else {
                    state = 1;
                }
            } else if (x == 'e' || x == 'E') {
                if (state >= 2 || int_only) {
                    break;
                } else {
                    state = 2;
                }
            } else if (x == '-' || x == '+') {
                if (state != 2) {
                    break;
                } else {
                    state = 3;
                }
            } else {
                break;
            }
            DUK__APPENDBUFFER(lex_ctx, x);
            DUK__ADVANCECHARS(lex_ctx, 1);
        }
 
        /* XXX: better coercion */
        duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
 
        s2n_flags = DUK_S2N_FLAG_ALLOW_EXP |
                    DUK_S2N_FLAG_ALLOW_FRAC |
                    DUK_S2N_FLAG_ALLOW_NAKED_FRAC |
                    DUK_S2N_FLAG_ALLOW_EMPTY_FRAC |
#if defined(DUK_USE_OCTAL_SUPPORT)
                    (strict_mode ? 0 : DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) |
#endif
                    DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
 
        duk_dup((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
        duk_numconv_parse((duk_context *) lex_ctx->thr, 10 /*radix*/, s2n_flags);
        val = duk_to_number((duk_context *) lex_ctx->thr, -1);
        if (DUK_ISNAN(val)) {
            DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid numeric literal");
        }
        duk_replace((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);  /* could also just pop? */
 
        DUK__INITBUFFER(lex_ctx);  /* free some memory */
 
        /* Section 7.8.3 (note): NumericLiteral must be followed by something other than
         * IdentifierStart or DecimalDigit.
         */
 
        if (DUK__ISDIGIT(DUK__L0()) || duk_unicode_is_identifier_start(DUK__L0())) {
            DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid numeric literal");
        }
 
        out_token->num = val;
        advtok = DUK__ADVTOK(0, DUK_TOK_NUMBER);
    } else if (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) {
        DUK__ADVANCECHARS(lex_ctx, 1);
        goto restart;
    } else if (x < 0) {
        advtok = DUK__ADVTOK(0, DUK_TOK_EOF);
    } else {
        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid token");
    }
 skip_slow_path:
 
    /*
     *  Shared exit path
     */
 

References DUK__ADVANCEBYTES, DUK__ADVANCECHARS, DUK__ADVTOK, DUK__APPENDBUFFER, duk__decode_hexesc_from_window(), duk__decode_uniesc_from_window(), duk__hexval(), DUK__INITBUFFER, duk__internbuffer(), DUK__ISDIGIT, DUK__ISDIGIT03, DUK__ISDIGIT47, DUK__ISHEXDIGIT, DUK__ISOCTDIGIT, DUK__L0, DUK__L1, DUK__L2, DUK__L3, DUK__LOOKUP, DUK_ASC_AMP, DUK_ASC_CARET, DUK_ASC_COLON, DUK_ASC_COMMA, DUK_ASC_DOUBLEQUOTE, DUK_ASC_EQUALS, DUK_ASC_EXCLAMATION, DUK_ASC_HT, DUK_ASC_LANGLE, DUK_ASC_LBRACKET, DUK_ASC_LCURLY, DUK_ASC_LF, DUK_ASC_LPAREN, DUK_ASC_MINUS, DUK_ASC_PERCENT, DUK_ASC_PERIOD, DUK_ASC_PIPE, DUK_ASC_PLUS, DUK_ASC_QUESTION, DUK_ASC_RANGLE, DUK_ASC_RBRACKET, DUK_ASC_RCURLY, DUK_ASC_RPAREN, DUK_ASC_SEMICOLON, DUK_ASC_SINGLEQUOTE, DUK_ASC_SLASH, DUK_ASC_SPACE, DUK_ASC_STAR, DUK_ASC_TILDE, DUK_ASSERT, DUK_DOUBLE_NAN, duk_dup(), DUK_ERROR_RANGE, DUK_ERROR_SYNTAX, duk_get_hstring(), DUK_HEAP_NUM_STRINGS, DUK_HTHREAD_GET_STRING, DUK_ISNAN, duk_numconv_parse(), duk_replace(), DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT, DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT, DUK_S2N_FLAG_ALLOW_EMPTY_FRAC, DUK_S2N_FLAG_ALLOW_EXP, DUK_S2N_FLAG_ALLOW_FRAC, DUK_S2N_FLAG_ALLOW_NAKED_FRAC, DUK_STRIDX_END_RESERVED, DUK_STRIDX_START_RESERVED, DUK_STRIDX_START_STRICT_RESERVED, DUK_STRIDX_TO_TOK, duk_to_number(), duk_to_undefined(), DUK_TOK_ADD, DUK_TOK_ADD_EQ, DUK_TOK_ALSHIFT, DUK_TOK_ALSHIFT_EQ, DUK_TOK_ARSHIFT, DUK_TOK_ARSHIFT_EQ, DUK_TOK_BAND, DUK_TOK_BAND_EQ, DUK_TOK_BNOT, DUK_TOK_BOR, DUK_TOK_BOR_EQ, DUK_TOK_BXOR, DUK_TOK_BXOR_EQ, DUK_TOK_COLON, DUK_TOK_COMMA, DUK_TOK_DECREMENT, DUK_TOK_DIV, DUK_TOK_DIV_EQ, DUK_TOK_EOF, DUK_TOK_EQ, DUK_TOK_EQUALSIGN, DUK_TOK_GE, DUK_TOK_GT, DUK_TOK_IDENTIFIER, DUK_TOK_INCREMENT, DUK_TOK_LAND, DUK_TOK_LBRACKET, DUK_TOK_LCURLY, DUK_TOK_LE, DUK_TOK_LNOT, DUK_TOK_LOR, DUK_TOK_LPAREN, DUK_TOK_LT, DUK_TOK_MOD, DUK_TOK_MOD_EQ, DUK_TOK_MUL, DUK_TOK_MUL_EQ, DUK_TOK_NEQ, DUK_TOK_NUMBER, DUK_TOK_PERIOD, DUK_TOK_QUESTION, DUK_TOK_RBRACKET, DUK_TOK_RCURLY, DUK_TOK_REGEXP, DUK_TOK_RPAREN, DUK_TOK_RSHIFT, DUK_TOK_RSHIFT_EQ, DUK_TOK_SEMICOLON, DUK_TOK_SEQ, DUK_TOK_SNEQ, DUK_TOK_STRING, DUK_TOK_SUB, DUK_TOK_SUB_EQ, duk_unicode_is_identifier_part(), duk_unicode_is_identifier_start(), duk_unicode_is_line_terminator(), duk_unicode_is_whitespace(), duk_lexer_codepoint::line, duk_token::lineterm, NULL, duk_token::num, duk_token::num_escapes, duk_lexer_codepoint::offset, duk_lexer_ctx::slot1_idx, duk_lexer_ctx::slot2_idx, duk_token::start_line, duk_token::start_offset, duk_token::str1, duk_token::str2, duk_token::t, duk_token::t_nores, duk_lexer_ctx::thr, duk_lexer_ctx::token_count, duk_lexer_ctx::token_limit, and duk_lexer_ctx::window.

◆ duk_lexer_parse_re_ranges()

DUK_INTERNAL_DECL void duk_lexer_parse_re_ranges	(	duk_lexer_ctx *	lex_ctx,
		duk_re_range_callback	gen_range,
		void *	userdata )

Definition at line 75204 of file duktape-1.8.0/src/duktape.c.

                                                      {
    const duk_uint16_t *ranges_end;
 
    DUK_UNREF(lex_ctx);
 
    ranges_end = ranges + num;
    while (ranges < ranges_end) {
        /* mark range 'direct', bypass canonicalization (see Wiki) */
        gen_range(userdata, (duk_codepoint_t) ranges[0], (duk_codepoint_t) ranges[1], 1);
        ranges += 2;
    }
}
 
DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata) {
    duk_codepoint_t start = -1;
    duk_codepoint_t ch;
    duk_codepoint_t x;
    duk_bool_t dash = 0;
 
    DUK_DD(DUK_DDPRINT("parsing regexp ranges"));
 
    for (;;) {
        x = DUK__L0();
        DUK__ADVANCECHARS(lex_ctx, 1);
 
        ch = -1;  /* not strictly necessary, but avoids "uninitialized variable" warnings */
        DUK_UNREF(ch);
 
        if (x < 0) {
            DUK_ERROR_SYNTAX(lex_ctx->thr, "eof in character class");
        } else if (x == ']') {
            if (start >= 0) {
                gen_range(userdata, start, start, 0);
            }
            break;
        } else if (x == '-') {
            if (start >= 0 && !dash && DUK__L0() != ']') {
                /* '-' as a range indicator */
                dash = 1;
                continue;
            } else {
                /* '-' verbatim */
                ch = x;
            }
        } else if (x == '\\') {
            /*
             *  The escapes are same as outside a character class, except that \b has a
             *  different meaning, and \B and backreferences are prohibited (see E5
             *  Section 15.10.2.19).  However, it's difficult to share code because we
             *  handle e.g. "\n" very differently: here we generate a single character
             *  range for it.
             */
 
            x = DUK__L0();
            DUK__ADVANCECHARS(lex_ctx, 1);
 
            if (x == 'b') {
                /* Note: '\b' in char class is different than outside (assertion),
                 * '\B' is not allowed and is caught by the duk_unicode_is_identifier_part()
                 * check below.
                 */
                ch = 0x0008;
            } else if (x == 'f') {
                ch = 0x000c;
            } else if (x == 'n') {
                ch = 0x000a;
            } else if (x == 't') {
                ch = 0x0009;
            } else if (x == 'r') {
                ch = 0x000d;
            } else if (x == 'v') {
                ch = 0x000b;
            } else if (x == 'c') {
                x = DUK__L0();
                DUK__ADVANCECHARS(lex_ctx, 1);
                if ((x >= 'a' && x <= 'z') ||
                    (x >= 'A' && x <= 'Z')) {
                    ch = (x % 32);
                } else {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
                    return;  /* never reached, but avoids warnings of
                              * potentially unused variables.
                              */
                }
            } else if (x == 'x') {
                ch = duk__decode_hexesc_from_window(lex_ctx, 0);
                DUK__ADVANCECHARS(lex_ctx, 2);
            } else if (x == 'u') {
                ch = duk__decode_uniesc_from_window(lex_ctx, 0);
                DUK__ADVANCECHARS(lex_ctx, 4);
            } else if (x == 'd') {
                duk__emit_u16_direct_ranges(lex_ctx,
                                            gen_range,
                                            userdata,
                                            duk_unicode_re_ranges_digit,
                                            sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t));
                ch = -1;
            } else if (x == 'D') {
                duk__emit_u16_direct_ranges(lex_ctx,
                                            gen_range,
                                            userdata,
                                            duk_unicode_re_ranges_not_digit,
                                            sizeof(duk_unicode_re_ranges_not_digit) / sizeof(duk_uint16_t));
                ch = -1;
            } else if (x == 's') {
                duk__emit_u16_direct_ranges(lex_ctx,
                                            gen_range,
                                            userdata,
                                            duk_unicode_re_ranges_white,
                                            sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t));
                ch = -1;
            } else if (x == 'S') {
                duk__emit_u16_direct_ranges(lex_ctx,
                                            gen_range,
                                            userdata,
                                            duk_unicode_re_ranges_not_white,
                                            sizeof(duk_unicode_re_ranges_not_white) / sizeof(duk_uint16_t));
                ch = -1;
            } else if (x == 'w') {
                duk__emit_u16_direct_ranges(lex_ctx,
                                            gen_range,
                                            userdata,
                                            duk_unicode_re_ranges_wordchar,
                                            sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t));
                ch = -1;
            } else if (x == 'W') {
                duk__emit_u16_direct_ranges(lex_ctx,
                                            gen_range,
                                            userdata,
                                            duk_unicode_re_ranges_not_wordchar,
                                            sizeof(duk_unicode_re_ranges_not_wordchar) / sizeof(duk_uint16_t));
                ch = -1;
            } else if (DUK__ISDIGIT(x)) {
                /* DecimalEscape, only \0 is allowed, no leading zeroes are allowed */
                if (x == '0' && !DUK__ISDIGIT(DUK__L0())) {
                    ch = 0x0000;
                } else {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
                }
            } else if (!duk_unicode_is_identifier_part(x)
#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE)
                       || x == '$'
#endif
                      ) {
                /* IdentityEscape */
                ch = x;
            } else {
                DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
            }
        } else {
            /* character represents itself */
            ch = x;
        }
 
        /* ch is a literal character here or -1 if parsed entity was
         * an escape such as "\s".
         */
 
        if (ch < 0) {
            /* multi-character sets not allowed as part of ranges, see
             * E5 Section 15.10.2.15, abstract operation CharacterRange.
             */
            if (start >= 0) {
                if (dash) {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid range");
                } else {
                    gen_range(userdata, start, start, 0);
                    start = -1;
                    /* dash is already 0 */
                }
            }
        } else {
            if (start >= 0) {
                if (dash) {
                    if (start > ch) {
                        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid range");

References DUK_UNREF.

Referenced by duk__parse_disjunction().

◆ duk_lexer_parse_re_token()

DUK_INTERNAL_DECL void duk_lexer_parse_re_token	(	duk_lexer_ctx *	lex_ctx,
		duk_re_token *	out_token )

Definition at line 74850 of file duktape-1.8.0/src/duktape.c.

           {
        out_token->allow_auto_semi = 0;
    }
}
 
#if defined(DUK_USE_REGEXP_SUPPORT)
 
/*
 *  Parse a RegExp token.  The grammar is described in E5 Section 15.10.
 *  Terminal constructions (such as quantifiers) are parsed directly here.
 *
 *  0xffffffffU is used as a marker for "infinity" in quantifiers.  Further,
 *  DUK__MAX_RE_QUANT_DIGITS limits the maximum number of digits that
 *  will be accepted for a quantifier.
 */
 
DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token) {
    duk_small_int_t advtok = 0;  /* init is unnecessary but suppresses "may be used uninitialized" warnings */
    duk_codepoint_t x, y;
 
    if (++lex_ctx->token_count >= lex_ctx->token_limit) {
        DUK_ERROR_RANGE(lex_ctx->thr, "token limit");
        return;  /* unreachable */
    }
 
    DUK_MEMZERO(out_token, sizeof(*out_token));
 
    x = DUK__L0();
    y = DUK__L1();
 
    DUK_DDD(DUK_DDDPRINT("parsing regexp token, L0=%ld, L1=%ld", (long) x, (long) y));
 
    switch (x) {
    case '|': {
        advtok = DUK__ADVTOK(1, DUK_RETOK_DISJUNCTION);
        break;
    }
    case '^': {
        advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_START);
        break;
    }
    case '$': {
        advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_END);
        break;
    }
    case '?': {
        out_token->qmin = 0;
        out_token->qmax = 1;
        if (y == '?') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
            out_token->greedy = 0;
        } else {
            advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
            out_token->greedy = 1;
        }
        break;
    }
    case '*': {
        out_token->qmin = 0;
        out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
        if (y == '?') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
            out_token->greedy = 0;
        } else {
            advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
            out_token->greedy = 1;
        }
        break;
    }
    case '+': {
        out_token->qmin = 1;
        out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
        if (y == '?') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
            out_token->greedy = 0;
        } else {
            advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
            out_token->greedy = 1;
        }
        break;
    }
    case '{': {
        /* Production allows 'DecimalDigits', including leading zeroes */
        duk_uint_fast32_t val1 = 0;
        duk_uint_fast32_t val2 = DUK_RE_QUANTIFIER_INFINITE;
        duk_small_int_t digits = 0;
#if defined(DUK_USE_ES6_REGEXP_BRACES)
        duk_lexer_point lex_pt;
#endif
 
#if defined(DUK_USE_ES6_REGEXP_BRACES)
        /* Store lexer position, restoring if quantifier is invalid. */
        DUK_LEXER_GETPOINT(lex_ctx, &lex_pt);
#endif
 
        for (;;) {
            DUK__ADVANCECHARS(lex_ctx, 1);  /* eat '{' on entry */
            x = DUK__L0();
            if (DUK__ISDIGIT(x)) {
                digits++;
                val1 = val1 * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x);
            } else if (x == ',') {
                if (digits > DUK__MAX_RE_QUANT_DIGITS) {
                    goto invalid_quantifier;
                }
                if (val2 != DUK_RE_QUANTIFIER_INFINITE) {
                    goto invalid_quantifier;
                }
                if (DUK__L1() == '}') {
                    /* form: { DecimalDigits , }, val1 = min count */
                    if (digits == 0) {
                        goto invalid_quantifier;
                    }
                    out_token->qmin = val1;
                    out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
                    DUK__ADVANCECHARS(lex_ctx, 2);
                    break;
                }
                val2 = val1;
                val1 = 0;
                digits = 0;  /* not strictly necessary because of lookahead '}' above */
            } else if (x == '}') {
                if (digits > DUK__MAX_RE_QUANT_DIGITS) {
                    goto invalid_quantifier;
                }
                if (digits == 0) {
                    goto invalid_quantifier;
                }
                if (val2 != DUK_RE_QUANTIFIER_INFINITE) {
                    /* val2 = min count, val1 = max count */
                    out_token->qmin = val2;
                    out_token->qmax = val1;
                } else {
                    /* val1 = count */
                    out_token->qmin = val1;
                    out_token->qmax = val1;
                }
                DUK__ADVANCECHARS(lex_ctx, 1);
                break;
            } else {
                goto invalid_quantifier;
            }
        }
        if (DUK__L0() == '?') {
            out_token->greedy = 0;
            DUK__ADVANCECHARS(lex_ctx, 1);
        } else {
            out_token->greedy = 1;
        }
        advtok = DUK__ADVTOK(0, DUK_RETOK_QUANTIFIER);
        break;
 invalid_quantifier:
#if defined(DUK_USE_ES6_REGEXP_BRACES)
        /* Failed to match the quantifier, restore lexer and parse
         * opening brace as a literal.
         */
        DUK_LEXER_SETPOINT(lex_ctx, &lex_pt);
        advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_CHAR);
        out_token->num = '{';
#else
        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp quantifier");
#endif
        break;
    }
    case '.': {
        advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_PERIOD);
        break;
    }
    case '\\': {
        /* The E5.1 specification does not seem to allow IdentifierPart characters
         * to be used as identity escapes.  Unfortunately this includes '$', which
         * cannot be escaped as '\$'; it needs to be escaped e.g. as '\u0024'.
         * Many other implementations (including V8 and Rhino, for instance) do
         * accept '\$' as a valid identity escape, which is quite pragmatic.
         * See: test-regexp-identity-escape-dollar.js.
         */
 
        advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR);  /* default: char escape (two chars) */
        if (y == 'b') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_WORD_BOUNDARY);
        } else if (y == 'B') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY);
        } else if (y == 'f') {
            out_token->num = 0x000c;
        } else if (y == 'n') {
            out_token->num = 0x000a;
        } else if (y == 't') {
            out_token->num = 0x0009;
        } else if (y == 'r') {
            out_token->num = 0x000d;
        } else if (y == 'v') {
            out_token->num = 0x000b;
        } else if (y == 'c') {
            x = DUK__L2();
            if ((x >= 'a' && x <= 'z') ||
                (x >= 'A' && x <= 'Z')) {
                out_token->num = (x % 32);
                advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_CHAR);
            } else {
                DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
            }
        } else if (y == 'x') {
            out_token->num = duk__decode_hexesc_from_window(lex_ctx, 2);
            advtok = DUK__ADVTOK(4, DUK_RETOK_ATOM_CHAR);
        } else if (y == 'u') {
            out_token->num = duk__decode_uniesc_from_window(lex_ctx, 2);
            advtok = DUK__ADVTOK(6, DUK_RETOK_ATOM_CHAR);
        } else if (y == 'd') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_DIGIT);
        } else if (y == 'D') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_DIGIT);
        } else if (y == 's') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WHITE);
        } else if (y == 'S') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WHITE);
        } else if (y == 'w') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WORD_CHAR);
        } else if (y == 'W') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WORD_CHAR);
        } else if (DUK__ISDIGIT(y)) {
            /* E5 Section 15.10.2.11 */
            if (y == '0') {
                if (DUK__ISDIGIT(DUK__L2())) {
                    DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
                }
                out_token->num = 0x0000;
                advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR);
            } else {
                /* XXX: shared parsing? */
                duk_uint_fast32_t val = 0;
                duk_small_int_t i;
                for (i = 0; ; i++) {
                    if (i >= DUK__MAX_RE_DECESC_DIGITS) {
                        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
                    }
                    DUK__ADVANCECHARS(lex_ctx, 1);  /* eat backslash on entry */
                    x = DUK__L0();
                    if (!DUK__ISDIGIT(x)) {
                        break;
                    }
                    val = val * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x);
                }
                /* DUK__L0() cannot be a digit, because the loop doesn't terminate if it is */
                advtok = DUK__ADVTOK(0, DUK_RETOK_ATOM_BACKREFERENCE);
                out_token->num = val;
            }
        } else if ((y >= 0 && !duk_unicode_is_identifier_part(y)) ||
#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE)
                   y == '$' ||
#endif
                   y == DUK_UNICODE_CP_ZWNJ ||
                   y == DUK_UNICODE_CP_ZWJ) {
            /* IdentityEscape, with dollar added as a valid additional
             * non-standard escape (see test-regexp-identity-escape-dollar.js).
             * Careful not to match end-of-buffer (<0) here.
             */
            out_token->num = y;
        } else {
            DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
        }
        break;
    }
    case '(': {
        /* XXX: naming is inconsistent: ATOM_END_GROUP ends an ASSERT_START_LOOKAHEAD */
 
        if (y == '?') {
            if (DUK__L2() == '=') {
                /* (?= */
                advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_POS_LOOKAHEAD);
            } else if (DUK__L2() == '!') {
                /* (?! */
                advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD);
            } else if (DUK__L2() == ':') {
                /* (?: */
                advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_START_NONCAPTURE_GROUP);
            } else {
                DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp group");
                return;
            }
        } else {
            /* ( */
            advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CAPTURE_GROUP);
        }
        break;
    }
    case ')': {
        advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_END_GROUP);
        break;
    }
    case '[': {
        /*
         *  To avoid creating a heavy intermediate value for the list of ranges,
         *  only the start token ('[' or '[^') is parsed here.  The regexp
         *  compiler parses the ranges itself.
         */
        advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CHARCLASS);
        if (y == '^') {
            advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_START_CHARCLASS_INVERTED);
        }
        break;
    }
#if !defined(DUK_USE_ES6_REGEXP_BRACES)
    case '}':
#endif
    case ']': {
        /* Although these could be parsed as PatternCharacters unambiguously (here),
         * E5 Section 15.10.1 grammar explicitly forbids these as PatternCharacters.
         */
        DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp character");
        break;
    }
    case -1: {
        /* EOF */
        advtok = DUK__ADVTOK(0, DUK_TOK_EOF);

Referenced by duk__parse_disjunction().

◆ duk_lexer_setpoint()

DUK_INTERNAL_DECL void duk_lexer_setpoint	(	duk_lexer_ctx *	lex_ctx,
		duk_lexer_point *	pt )

Definition at line 73899 of file duktape-1.8.0/src/duktape.c.

◆ duk_load_function()

DUK_EXTERNAL void duk_load_function ( duk_context * ctx )

Definition at line 12319 of file duktape-1.8.0/src/duktape.c.

                                         : %!T", duk_get_tval(ctx, -1)));
 
    duk_remove(ctx, -2);  /* [ ... func buf ] -> [ ... buf ] */
}
 
DUK_EXTERNAL void duk_load_function(duk_context *ctx) {
    duk_hthread *thr;
    duk_uint8_t *p_buf, *p, *p_end;
    duk_size_t sz;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(ctx);
 
    p_buf = (duk_uint8_t *) duk_require_buffer(ctx, -1, &sz);
    DUK_ASSERT(p_buf != NULL);
 
    /* The caller is responsible for being sure that bytecode being loaded
     * is valid and trusted.  Invalid bytecode can cause memory unsafe
     * behavior directly during loading or later during bytecode execution
     * (instruction validation would be quite complex to implement).
     *
     * This signature check is the only sanity check for detecting
     * accidental invalid inputs.  The initial 0xFF byte ensures no
     * ordinary string will be accepted by accident.
     */
    p = p_buf;

◆ duk_log()

DUK_EXTERNAL void duk_log	(	duk_context *	ctx,
		duk_int_t	level,
		const char *	fmt,
			... )

Definition at line 14280 of file duktape-1.8.0/src/duktape.c.

◆ duk_log_va()

DUK_EXTERNAL void duk_log_va	(	duk_context *	ctx,
		duk_int_t	level,
		const char *	fmt,
		va_list	ap )

Definition at line 14247 of file duktape-1.8.0/src/duktape.c.

                                                                                             {
    /* stridx_logfunc[] must be static to allow initializer with old compilers like BCC */
    static const duk_uint16_t stridx_logfunc[6] = {
        DUK_STRIDX_LC_TRACE, DUK_STRIDX_LC_DEBUG, DUK_STRIDX_LC_INFO,
        DUK_STRIDX_LC_WARN, DUK_STRIDX_LC_ERROR, DUK_STRIDX_LC_FATAL
    };
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (level < 0) {
        level = 0;
    } else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) {
        level = (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1;
    }
 

Referenced by duk_alloc_raw().

◆ duk_map_string()

DUK_EXTERNAL void duk_map_string	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_map_char_function	callback,
		void *	udata )

Definition at line 19942 of file duktape-1.8.0/src/duktape.c.

             {
        if (p >= p_end) {
            break;
        }
        cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
        callback(udata, cp);
    }
}
 
DUK_EXTERNAL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_input;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_codepoint_t cp;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_normalize_index(ctx, index);
 
    h_input = duk_require_hstring(ctx, index);
    DUK_ASSERT(h_input != NULL);
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input));  /* reasonable output estimate */
 
    p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
    p = p_start;
 
    for (;;) {

◆ duk_new()

DUK_EXTERNAL void duk_new	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12607 of file duktape-1.8.0/src/duktape.c.

                                                            {
        /* See comments in duk_pcall(). */
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
        return DUK_EXEC_ERROR;  /* unreachable */
    }
 
    rc = duk_handle_safe_call(thr,           /* thread */
                              func,          /* func */
                              nargs,         /* num_stack_args */
                              nrets);        /* num_stack_res */
 
    return rc;
}
 
DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) {
    /*
     *  There are two [[Construct]] operations in the specification:
     *
     *    - E5 Section 13.2.2: for Function objects
     *    - E5 Section 15.3.4.5.2: for "bound" Function objects
     *
     *  The chain of bound functions is resolved in Section 15.3.4.5.2,
     *  with arguments "piling up" until the [[Construct]] internal
     *  method is called on the final, actual Function object.  Note
     *  that the "prototype" property is looked up *only* from the
     *  final object, *before* calling the constructor.
     *
     *  Currently we follow the bound function chain here to get the
     *  "prototype" property value from the final, non-bound function.
     *  However, we let duk_handle_call() handle the argument "piling"
     *  when the constructor is called.  The bound function chain is
     *  thus now processed twice.
     *
     *  When constructing new Array instances, an unnecessary object is
     *  created and discarded now: the standard [[Construct]] creates an
     *  object, and calls the Array constructor.  The Array constructor
     *  returns an Array instance, which is used as the result value for
     *  the "new" operation; the object created before the Array constructor
     *  call is discarded.
     *
     *  This would be easy to fix, e.g. by knowing that the Array constructor
     *  will always create a replacement object and skip creating the fallback
     *  object in that case.
     *
     *  Note: functions called via "new" need to know they are called as a
     *  constructor.  For instance, built-in constructors behave differently
     *  depending on how they are called.
     */
 
    /* XXX: merge this with duk_js_call.c, as this function implements
     * core semantics (or perhaps merge the two files altogether).
     */
 
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *proto;
    duk_hobject *cons;
    duk_hobject *fallback;
    duk_idx_t idx_cons;
    duk_small_uint_t call_flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* [... constructor arg1 ... argN] */
 
    idx_cons = duk_require_normalize_index(ctx, -nargs - 1);
 
    DUK_DDD(DUK_DDDPRINT("top=%ld, nargs=%ld, idx_cons=%ld",
                         (long) duk_get_top(ctx), (long) nargs, (long) idx_cons));
 
    /* XXX: code duplication */
 
    /*
     *  Figure out the final, non-bound constructor, to get "prototype"
     *  property.
     */
 
    duk_dup(ctx, idx_cons);
    for (;;) {
        duk_tval *tv;
        tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
        DUK_ASSERT(tv != NULL);
 
        if (DUK_TVAL_IS_OBJECT(tv)) {
            cons = DUK_TVAL_GET_OBJECT(tv);
            DUK_ASSERT(cons != NULL);
            if (!DUK_HOBJECT_IS_CALLABLE(cons) || !DUK_HOBJECT_HAS_CONSTRUCTABLE(cons)) {
                /* Checking callability of the immediate target
                 * is important, same for constructability.
                 * Checking it for functions down the bound
                 * function chain is not strictly necessary
                 * because .bind() should normally reject them.
                 * But it's good to check anyway because it's
                 * technically possible to edit the bound function
                 * chain via internal keys.
                 */
                goto not_constructable;
            }
            if (!DUK_HOBJECT_HAS_BOUND(cons)) {
                break;
            }
        } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
            /* Lightfuncs cannot be bound. */
            break;
        } else {
            /* Anything else is not constructable. */
            goto not_constructable;
        }
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);  /* -> [... cons target] */
        duk_remove(ctx, -2);                                  /* -> [... target] */
    }
    DUK_ASSERT(duk_is_callable(ctx, -1));
    DUK_ASSERT(duk_is_lightfunc(ctx, -1) ||
               (duk_get_hobject(ctx, -1) != NULL && !DUK_HOBJECT_HAS_BOUND(duk_get_hobject(ctx, -1))));
 
    /* [... constructor arg1 ... argN final_cons] */
 
    /*
     *  Create "fallback" object to be used as the object instance,
     *  unless the constructor returns a replacement value.
     *  Its internal prototype needs to be set based on "prototype"
     *  property of the constructor.
     */
 
    duk_push_object(ctx);  /* class Object, extensible */
 
    /* [... constructor arg1 ... argN final_cons fallback] */
 
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE);
    proto = duk_get_hobject(ctx, -1);
    if (!proto) {
        DUK_DDD(DUK_DDDPRINT("constructor has no 'prototype' property, or value not an object "
                             "-> leave standard Object prototype as fallback prototype"));
    } else {
        DUK_DDD(DUK_DDDPRINT("constructor has 'prototype' property with object value "
                             "-> set fallback prototype to that value: %!iO", (duk_heaphdr *) proto));
        fallback = duk_get_hobject(ctx, -2);
        DUK_ASSERT(fallback != NULL);
        DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, fallback, proto);
    }
    duk_pop(ctx);
 
    /* [... constructor arg1 ... argN final_cons fallback] */
 
    /*
     *  Manipulate callstack for the call.
     */
 
    duk_dup_top(ctx);
    duk_insert(ctx, idx_cons + 1);  /* use fallback as 'this' value */
    duk_insert(ctx, idx_cons);      /* also stash it before constructor,
                                     * in case we need it (as the fallback value)
                                     */
    duk_pop(ctx);                   /* pop final_cons */
 
 
    /* [... fallback constructor fallback(this) arg1 ... argN];
     * Note: idx_cons points to first 'fallback', not 'constructor'.
     */
 
    DUK_DDD(DUK_DDDPRINT("before call, idx_cons+1 (constructor) -> %!T, idx_cons+2 (fallback/this) -> %!T, "
                         "nargs=%ld, top=%ld",
                         (duk_tval *) duk_get_tval(ctx, idx_cons + 1),
                         (duk_tval *) duk_get_tval(ctx, idx_cons + 2),
                         (long) nargs,
                         (long) duk_get_top(ctx)));
 
    /*
     *  Call the constructor function (called in "constructor mode").
     */
 
    call_flags = DUK_CALL_FLAG_CONSTRUCTOR_CALL;  /* not protected, respect reclimit, is a constructor call */
 
    duk_handle_call_unprotected(thr,           /* thread */
                                nargs,         /* num_stack_args */
                                call_flags);   /* call_flags */
 
    /* [... fallback retval] */
 
    DUK_DDD(DUK_DDDPRINT("constructor call finished, fallback=%!iT, retval=%!iT",
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    /*
     *  Determine whether to use the constructor return value as the created
     *  object instance or not.
     */
 
    if (duk_is_object(ctx, -1)) {
        duk_remove(ctx, -2);
    } else {
        duk_pop(ctx);
    }
 
    /*

◆ duk_next()

DUK_EXTERNAL duk_bool_t duk_next	(	duk_context *	ctx,
		duk_idx_t	enum_index,
		duk_bool_t	get_value )

Definition at line 14857 of file duktape-1.8.0/src/duktape.c.

             {
        /* Note: this may fail, caller should protect the call if necessary */
        duk_hobject_compact_props(thr, obj);
    }
}
 

◆ DUK_NORETURN() [1/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_default_fatal_handlerduk_context *ctx, duk_errcode_t code, const char *msg )

◆ DUK_NORETURN() [2/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_default_panic_handlerduk_errcode_t code, const char *msg )

◆ DUK_NORETURN() [3/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_apiduk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message )

◆ DUK_NORETURN() [4/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_api_indexduk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index )

◆ DUK_NORETURN() [5/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_create_and_throwduk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line )

◆ DUK_NORETURN() [6/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_handle_errorduk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg )

◆ DUK_NORETURN() [7/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_handle_error_fmtduk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt,... )

◆ DUK_NORETURN() [8/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_longjmpduk_hthread *thr )

◆ DUK_NORETURN() [9/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_require_type_indexduk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name )

◆ DUK_NORETURN() [10/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_err_unimplemented_defmsgduk_hthread *thr, const char *filename, duk_int_t linenumber )

◆ DUK_NORETURN() [11/11]

DUK_NORETURN ( DUK_INTERNAL_DECL void duk_error_throw_from_negative_rcduk_hthread *thr, duk_ret_t rc )

◆ duk_normalize_index()

DUK_EXTERNAL duk_idx_t duk_normalize_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15187 of file duktape-1.8.0/src/duktape.c.

                 {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER);
        /* not reachable */
    }
    return 0;
}
 
/*
 *  Stack index validation/normalization and getting a stack duk_tval ptr.
 *
 *  These are called by many API entrypoints so the implementations must be
 *  fast and "inlined".
 *
 *  There's some repetition because of this; keep the functions in sync.
 */
 
DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t uindex;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    /* Care must be taken to avoid pointer wrapping in the index
     * validation.  For instance, on a 32-bit platform with 8-byte
     * duk_tval the index 0x20000000UL would wrap the memory space
     * once.
     */
 
    /* Assume value stack sizes (in elements) fits into duk_idx_t. */
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    DUK_ASSERT_DISABLE(vs_size >= 0);  /* unsigned */

References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_NUMBER, and index.

Referenced by duk_get_top(), and duk_handle_ecma_call_setup().

◆ duk_numconv_parse()

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

Definition at line 77130 of file duktape-1.8.0/src/duktape.c.

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

Referenced by duk_lexer_parse_js_input_element().

◆ duk_numconv_stringify()

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

Definition at line 76927 of file duktape-1.8.0/src/duktape.c.

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

◆ duk_pcall()

DUK_EXTERNAL duk_int_t duk_pcall	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12482 of file duktape-1.8.0/src/duktape.c.

                                 {
        DUK_ERROR_API((duk_hthread *) ctx, DUK_STR_INVALID_CALL_ARGS);
    }
 
    duk__call_prop_prep_stack(ctx, obj_index, nargs);
 
    duk_call_method(ctx, nargs);
}
 
DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;
    duk_idx_t idx_func;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    idx_func = duk_get_top(ctx) - nargs - 1;  /* must work for nargs <= 0 */
    if (idx_func < 0 || nargs < 0) {
        /* We can't reliably pop anything here because the stack input
         * shape is incorrect.  So we throw an error; if the caller has
         * no catch point for this, a fatal error will occur.  Another
         * alternative would be to just return an error.  But then the
         * stack would be in an unknown state which might cause some
         * very hard to diagnose problems later on.  Also note that even
         * if we did not throw an error here, the underlying call handler
         * might STILL throw an out-of-memory error or some other internal
         * fatal error.

◆ duk_pcall_method()

DUK_EXTERNAL duk_int_t duk_pcall_method	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12520 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;
    duk_idx_t idx_func;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_pcall_prop()

DUK_EXTERNAL duk_int_t duk_pcall_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_idx_t	nargs )

Definition at line 12565 of file duktape-1.8.0/src/duktape.c.

                                                                                              {
    /*
     *  Must be careful to catch errors related to value stack manipulation

◆ duk_pnew()

DUK_EXTERNAL duk_int_t duk_pnew	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12815 of file duktape-1.8.0/src/duktape.c.

                  :
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_CONSTRUCTABLE);
}
 
DUK_LOCAL duk_ret_t duk__pnew_helper(duk_context *ctx) {
    duk_uint_t nargs;
 
    nargs = duk_to_uint(ctx, -1);
    duk_pop(ctx);
 
    duk_new(ctx, nargs);
    return 1;
}
 
DUK_EXTERNAL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs) {
    duk_int_t rc;
 

◆ duk_pop()

DUK_EXTERNAL void duk_pop ( duk_context * ctx )

Definition at line 19407 of file duktape-1.8.0/src/duktape.c.

                                            {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_pop_n(ctx, 1);
}
#else
DUK_EXTERNAL void duk_pop(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;

Referenced by duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), duk__put_prop_shared(), duk__to_regexp_helper(), duk_bi_buffer_slice_shared(), duk_bi_typedarray_set(), duk_handle_ecma_call_setup(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_prepare_property_descriptor(), duk_hobject_putprop(), duk_js_instanceof(), and duk_to_defaultvalue().

◆ duk_pop_2()

DUK_EXTERNAL void duk_pop_2 ( duk_context * ctx )

Definition at line 19428 of file duktape-1.8.0/src/duktape.c.

19430 {

19431 DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY);

DUK_STR_POP_TOO_MANY

#define DUK_STR_POP_TOO_MANY

Definition duktape-1.8.0/src/duktape.c:2332

Referenced by duk__error_getter_helper(), duk_bi_buffer_slice_shared(), duk_hobject_putprop(), and duk_js_instanceof().

◆ duk_pop_3()

DUK_EXTERNAL void duk_pop_3 ( duk_context * ctx )

Definition at line 19433 of file duktape-1.8.0/src/duktape.c.

◆ duk_pop_n()

DUK_EXTERNAL void duk_pop_n	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 19349 of file duktape-1.8.0/src/duktape.c.

                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(builtin_idx >= 0 && builtin_idx < DUK_NUM_BUILTINS);
    DUK_ASSERT(thr->builtins[builtin_idx] != NULL);
    duk_push_hobject(ctx, thr->builtins[builtin_idx]);
}
 
/*
 *  Poppers
 */
 
DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (DUK_UNLIKELY(count < 0)) {
        DUK_ERROR_API(thr, DUK_STR_INVALID_COUNT);
        return;
    }
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    if (DUK_UNLIKELY((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count)) {
        DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY);
    }
 
    /*
     *  Must be very careful here, every DECREF may cause reallocation
     *  of our valstack.
     */
 
    /* XXX: inlined DECREF macro would be nice here: no NULL check,
     * refzero queueing but no refzero algorithm run (= no pointer
     * instability), inline code.
     */
 
    /* XXX: optimize loops */
 
#if defined(DUK_USE_REFERENCE_COUNTING)
    while (count > 0) {
        count--;

Referenced by duk__error_getter_helper(), duk__realloc_props(), duk_debugger_pause(), duk_hobject_get_length(), and duk_hobject_putprop().

◆ duk_push_array()

DUK_EXTERNAL duk_idx_t duk_push_array ( duk_context * ctx )

Definition at line 18622 of file duktape-1.8.0/src/duktape.c.

                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                  DUK_BIDX_OBJECT_PROTOTYPE);
}
 
DUK_EXTERNAL duk_idx_t duk_push_array(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = duk_push_object_helper(ctx,
                                 DUK_HOBJECT_FLAG_EXTENSIBLE |
                                 DUK_HOBJECT_FLAG_ARRAY_PART |
                                 DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAY),
                                 DUK_BIDX_ARRAY_PROTOTYPE);
 
    obj = duk_require_hobject(ctx, ret);
 
    /*
     *  An array must have a 'length' property (E5 Section 15.4.5.2).
     *  The special array behavior flag must only be enabled once the
     *  length property has been added.
     *

Referenced by duk_bi_duktape_object_info().

◆ duk_push_boolean()

DUK_EXTERNAL void duk_push_boolean	(	duk_context *	ctx,
		duk_bool_t	val )

Definition at line 18037 of file duktape-1.8.0/src/duktape.c.

                                                  {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;

Referenced by duk_bi_array_prototype_to_string(), duk_bi_global_object_decode_uri(), and duk_bi_object_constructor_is_extensible().

◆ duk_push_buffer_object()

DUK_EXTERNAL void duk_push_buffer_object	(	duk_context *	ctx,
		duk_idx_t	idx_buffer,
		duk_size_t	byte_offset,
		duk_size_t	byte_length,
		duk_uint_t	flags )

Definition at line 18958 of file duktape-1.8.0/src/duktape.c.

                                                       {
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_BUFFER_PROTOTYPE,            DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0)   /* DUK_BUFOBJ_DUKTAPE_BUFFER */
};
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
#undef DUK__PACK_ARGS
 
DUK_EXTERNAL void duk_push_buffer_object(duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags) {
    duk_hthread *thr;
    duk_hbufferobject *h_bufobj;
    duk_hbuffer *h_val;
    duk_uint32_t tmp;
    duk_uint_t classnum;
    duk_uint_t protobidx;
    duk_uint_t lookupidx;
    duk_uint_t uint_offset, uint_length, uint_added;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /* The underlying types for offset/length in duk_hbufferobject is
     * duk_uint_t; make sure argument values fit and that offset + length
     * does not wrap.
     */
    uint_offset = (duk_uint_t) byte_offset;
    uint_length = (duk_uint_t) byte_length;
    if (sizeof(duk_size_t) != sizeof(duk_uint_t)) {
        if ((duk_size_t) uint_offset != byte_offset || (duk_size_t) uint_length != byte_length) {
            goto range_error;
        }
    }
    uint_added = uint_offset + uint_length;
    if (uint_added < uint_offset) {
        goto range_error;
    }
    DUK_ASSERT(uint_added >= uint_offset && uint_added >= uint_length);
 
    DUK_ASSERT_DISABLE(flags >= 0);  /* flags is unsigned */
    lookupidx = flags & 0x0f;  /* 4 low bits */
    if (lookupidx >= sizeof(duk__bufobj_flags_lookup) / sizeof(duk_uint32_t)) {
        goto arg_error;
    }
    tmp = duk__bufobj_flags_lookup[lookupidx];
    classnum = tmp >> 24;
    protobidx = (tmp >> 16) & 0xff;
 
    h_val = duk_require_hbuffer(ctx, idx_buffer);
    DUK_ASSERT(h_val != NULL);
 
    h_bufobj = duk_push_bufferobject_raw(ctx,
                                         DUK_HOBJECT_FLAG_EXTENSIBLE |
                                         DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                         DUK_HOBJECT_CLASS_AS_FLAGS(classnum),
                                         protobidx);
    DUK_ASSERT(h_bufobj != NULL);
 
    h_bufobj->buf = h_val;
    DUK_HBUFFER_INCREF(thr, h_val);
    h_bufobj->offset = uint_offset;
    h_bufobj->length = uint_length;
    h_bufobj->shift = (tmp >> 4) & 0x0f;
    h_bufobj->elem_type = (tmp >> 8) & 0xff;
    h_bufobj->is_view = tmp & 0x0f;
    DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
    /* TypedArray views need an automatic ArrayBuffer which must be
     * provided as .buffer property of the view.  Just create a new
     * ArrayBuffer sharing the same underlying buffer.
     *
     * The ArrayBuffer offset is always set to zero, so that if one
     * accesses the ArrayBuffer at the view's .byteOffset, the value
     * matches the view at index 0.
     */
    if (flags & DUK_BUFOBJ_CREATE_ARRBUF) {
        h_bufobj = duk_push_bufferobject_raw(ctx,
                                             DUK_HOBJECT_FLAG_EXTENSIBLE |
                                             DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                             DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER),
                                             DUK_BIDX_ARRAYBUFFER_PROTOTYPE);
 
        DUK_ASSERT(h_bufobj != NULL);
 
        h_bufobj->buf = h_val;
        DUK_HBUFFER_INCREF(thr, h_val);
        h_bufobj->offset = 0;
        h_bufobj->length = uint_offset + uint_length;  /* Wrap checked above. */
        DUK_ASSERT(h_bufobj->shift == 0);
        h_bufobj->elem_type = DUK_HBUFFEROBJECT_ELEM_UINT8;
        DUK_ASSERT(h_bufobj->is_view == 0);

◆ duk_push_buffer_raw()

DUK_EXTERNAL void * duk_push_buffer_raw	(	duk_context *	ctx,
		duk_size_t	size,
		duk_small_uint_t	flags )

Definition at line 19142 of file duktape-1.8.0/src/duktape.c.

                                                                                                                   {
    const char *filename = duk_api_global_filename;
    duk_int_t line = duk_api_global_line;
    va_list ap;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_api_global_filename = NULL;
    duk_api_global_line = 0;
    va_start(ap, fmt);
    ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    return ret;
}
#endif  /* DUK_USE_VARIADIC_MACROS */
 
DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_slot;
    duk_hbuffer *h;
    void *buf_data;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 

References duk_api_global_filename, duk_api_global_line, DUK_ASSERT_CTX_VALID, duk_push_error_object_va_raw(), and NULL.

◆ duk_push_bufferobject_raw()

DUK_INTERNAL_DECL duk_hbufferobject * duk_push_bufferobject_raw	(	duk_context *	ctx,
		duk_uint_t	hobject_flags_and_class,
		duk_small_int_t	prototype_bidx )

Definition at line 18899 of file duktape-1.8.0/src/duktape.c.

                                                                         {
        goto api_error;
    }
 
    lf_flags = DUK_LFUNC_FLAGS_PACK(magic, length, nargs);
    DUK_TVAL_SET_LIGHTFUNC(&tv_tmp, func, lf_flags);
    duk_push_tval(ctx, &tv_tmp);  /* XXX: direct valstack write */
    DUK_ASSERT(thr->valstack_top != thr->valstack_bottom);
    return ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
 
 api_error:
    DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    return 0;  /* not reached */
}
 
DUK_INTERNAL duk_hbufferobject *duk_push_bufferobject_raw(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hbufferobject *obj;
    duk_tval *tv_slot;
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(prototype_bidx >= 0);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);

Referenced by duk_bi_buffer_slice_shared().

◆ duk_push_c_function()

DUK_EXTERNAL duk_idx_t duk_push_c_function	(	duk_context *	ctx,
		duk_c_function	func,
		duk_int_t	nargs )

Definition at line 18814 of file duktape-1.8.0/src/duktape.c.

          :
    DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    return 0;  /* not reached */
}

Referenced by duk_put_number_list().

◆ duk_push_c_function_noconstruct_noexotic()

DUK_INTERNAL_DECL void duk_push_c_function_noconstruct_noexotic	(	duk_context *	ctx,
		duk_c_function	func,
		duk_int_t	nargs )

Definition at line 18847 of file duktape-1.8.0/src/duktape.c.

                                                                                                       {
    duk_uint_t flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
            DUK_HOBJECT_FLAG_CONSTRUCTABLE |
            DUK_HOBJECT_FLAG_NATIVEFUNCTION |
            DUK_HOBJECT_FLAG_NEWENV |
            DUK_HOBJECT_FLAG_STRICT |
            DUK_HOBJECT_FLAG_NOTAIL |
            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
 

References duk__push_c_function_raw(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_FLAG_CONSTRUCTABLE, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NOTAIL, and DUK_HOBJECT_FLAG_STRICT.

◆ duk_push_c_function_noexotic()

DUK_INTERNAL_DECL void duk_push_c_function_noexotic	(	duk_context *	ctx,
		duk_c_function	func,
		duk_int_t	nargs )

Definition at line 18831 of file duktape-1.8.0/src/duktape.c.

                                                                                                   {
    duk_uint_t flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
            DUK_HOBJECT_FLAG_CONSTRUCTABLE |
            DUK_HOBJECT_FLAG_NATIVEFUNCTION |
            DUK_HOBJECT_FLAG_NEWENV |
            DUK_HOBJECT_FLAG_STRICT |
            DUK_HOBJECT_FLAG_NOTAIL |
            DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC |
            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
 
    return duk__push_c_function_raw(ctx, func, nargs, flags);

References duk__push_c_function_raw(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_FLAG_CONSTRUCTABLE, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NOTAIL, and DUK_HOBJECT_FLAG_STRICT.

◆ duk_push_c_lightfunc()

DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc	(	duk_context *	ctx,
		duk_c_function	func,
		duk_idx_t	nargs,
		duk_idx_t	length,
		duk_int_t	magic )

Definition at line 18862 of file duktape-1.8.0/src/duktape.c.

                                                                                                                   {
    duk_uint_t flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
            DUK_HOBJECT_FLAG_NATIVEFUNCTION |
            DUK_HOBJECT_FLAG_NEWENV |
            DUK_HOBJECT_FLAG_STRICT |
            DUK_HOBJECT_FLAG_NOTAIL |
            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
 
    (void) duk__push_c_function_raw(ctx, func, nargs, flags);
}
 
DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval tv_tmp;
    duk_small_uint_t lf_flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    if (nargs >= DUK_LFUNC_NARGS_MIN && nargs <= DUK_LFUNC_NARGS_MAX) {
        /* as is */
    } else if (nargs == DUK_VARARGS) {
        nargs = DUK_LFUNC_NARGS_VARARGS;
    } else {
        goto api_error;
    }

◆ duk_push_compiledfunction()

DUK_INTERNAL_DECL duk_idx_t duk_push_compiledfunction ( duk_context * ctx )

Definition at line 18723 of file duktape-1.8.0/src/duktape.c.

           {
        duk_hthread_copy_builtin_objects(thr, obj);
    }
 
    /* default prototype (Note: 'obj' must be reachable) */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, obj->builtins[DUK_BIDX_THREAD_PROTOTYPE]);
 
    /* Initial stack size satisfies the stack spare constraints so there
     * is no need to require stack here.
     */
    DUK_ASSERT(DUK_VALSTACK_INITIAL_SIZE >=
               DUK_VALSTACK_API_ENTRY_MINIMUM + DUK_VALSTACK_INTERNAL_EXTRA);
 
    return ret;
}
 
DUK_INTERNAL duk_idx_t duk_push_compiledfunction(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hcompiledfunction *obj;
    duk_idx_t ret;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    /* Template functions are not strictly constructable (they don't
     * have a "prototype" property for instance), so leave the
     * DUK_HOBJECT_FLAG_CONSRUCTABLE flag cleared here.
     */
 
    obj = duk_hcompiledfunction_alloc(thr->heap,
                                      DUK_HOBJECT_FLAG_EXTENSIBLE |
                                      DUK_HOBJECT_FLAG_COMPILEDFUNCTION |
                                      DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION));

◆ duk_push_context_dump()

DUK_EXTERNAL void duk_push_context_dump ( duk_context * ctx )

Definition at line 13784 of file duktape-1.8.0/src/duktape.c.

                                                          {
    duk_idx_t idx;
    duk_idx_t top;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* We don't duk_require_stack() here now, but rely on the caller having
     * enough space.
     */
 
    top = duk_get_top(ctx);
    duk_push_array(ctx);
    for (idx = 0; idx < top; idx++) {
        duk_dup(ctx, idx);
        duk_put_prop_index(ctx, -2, idx);
    }

◆ duk_push_current_function()

DUK_EXTERNAL void duk_push_current_function ( duk_context * ctx )

Definition at line 18384 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    duk_hthread *thr;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
 
    DUK_ASSERT(thr->callstack_top > 0);  /* caller required to know */
    DUK_ASSERT(thr->valstack_bottom > thr->valstack);  /* consequence of above */
    DUK_ASSERT(thr->valstack_bottom - 1 >= thr->valstack);  /* 'this' binding exists */
 
    return thr->valstack_bottom - 1;
}

◆ duk_push_current_thread()

DUK_EXTERNAL void duk_push_current_thread ( duk_context * ctx )

Definition at line 18401 of file duktape-1.8.0/src/duktape.c.

                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
    DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
 
    act = duk_hthread_get_current_activation(thr);
    if (act) {
        duk_push_tval(ctx, &act->tv_func);

References duk_hthread::callstack_size, duk_hthread::callstack_top, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, duk_hthread_get_current_activation(), duk_push_tval(), NULL, and duk_activation::tv_func.

◆ duk_push_error_object_raw()

DUK_EXTERNAL duk_idx_t duk_push_error_object_raw	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	filename,
		duk_int_t	line,
		const char *	fmt,
			... )

Definition at line 19112 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_err_create_and_throw().

◆ duk_push_error_object_stash()

DUK_EXTERNAL duk_idx_t duk_push_error_object_stash	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	fmt,
			... )

Definition at line 19125 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                       {
    va_list ap;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    va_start(ap, fmt);
    ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    return ret;
}

◆ duk_push_error_object_va_raw()

DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	filename,
		duk_int_t	line,
		const char *	fmt,
		va_list	ap )

Definition at line 19060 of file duktape-1.8.0/src/duktape.c.

            :
    DUK_ERROR_RANGE(thr, DUK_STR_INVALID_CALL_ARGS);
    return;  /* not reached */
 
 arg_error:
    DUK_ERROR_TYPE(thr, DUK_STR_INVALID_CALL_ARGS);
    return;  /* not reached */
}
 
DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
    duk_hobject *proto;
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
    duk_bool_t noblame_fileline;
#endif
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_UNREF(filename);
    DUK_UNREF(line);
 
    /* Error code also packs a tracedata related flag. */
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
    noblame_fileline = err_code & DUK_ERRCODE_FLAG_NOBLAME_FILELINE;
#endif
    err_code = err_code & (~DUK_ERRCODE_FLAG_NOBLAME_FILELINE);
 
    /* error gets its 'name' from the prototype */
    proto = duk_error_prototype_from_code(thr, err_code);
    ret = duk_push_object_helper_proto(ctx,
                                       DUK_HOBJECT_FLAG_EXTENSIBLE |
                                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR),
                                       proto);
 
    /* ... and its 'message' from an instance property */
    if (fmt) {
        duk_push_vsprintf(ctx, fmt, ap);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
    } else {
        /* If no explicit message given, put error code into message field
         * (as a number).  This is not fully in keeping with the Ecmascript
         * error model because messages are supposed to be strings (Error

Referenced by duk_push_buffer_raw().

◆ duk_push_false()

DUK_EXTERNAL void duk_push_false ( duk_context * ctx )

Definition at line 18061 of file duktape-1.8.0/src/duktape.c.

                 : 0);  /* ensure value is 1 or 0 (not other non-zero) */
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_BOOLEAN(tv_slot, b);
}
 
DUK_EXTERNAL void duk_push_true(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv_slot;
 

◆ duk_push_global_object()

DUK_EXTERNAL void duk_push_global_object ( duk_context * ctx )

Definition at line 18414 of file duktape-1.8.0/src/duktape.c.

18418 {

◆ duk_push_global_stash()

DUK_EXTERNAL void duk_push_global_stash ( duk_context * ctx )

Definition at line 18443 of file duktape-1.8.0/src/duktape.c.

◆ duk_push_hbuffer()

DUK_INTERNAL_DECL void duk_push_hbuffer	(	duk_context *	ctx,
		duk_hbuffer *	h )

Definition at line 19328 of file duktape-1.8.0/src/duktape.c.

                                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
    DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));

◆ duk_push_heap_stash()

DUK_EXTERNAL void duk_push_heap_stash ( duk_context * ctx )

Definition at line 18433 of file duktape-1.8.0/src/duktape.c.

                                                 {
    DUK_ASSERT_CTX_VALID(ctx);
    if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE)) {
        DUK_DDD(DUK_DDDPRINT("creating heap/global/thread stash on first use"));

◆ duk_push_heapptr()

DUK_EXTERNAL duk_idx_t duk_push_heapptr	(	duk_context *	ctx,
		void *	ptr )

Definition at line 19255 of file duktape-1.8.0/src/duktape.c.

           {
        for (curr = thr->heap->heap_allocated;
             curr != NULL;
             curr = DUK_HEAPHDR_GET_NEXT(thr->heap, curr)) {
            if (curr == h) {
                DUK_ASSERT(found == 0);  /* Would indicate corrupted lists. */
                found = 1;
            }
        }
        DUK_ASSERT(found != 0);
    }
}
#endif  /* DUK_USE_ASSERTIONS */
 
DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Reviving an object using a heap pointer is a dangerous API
     * operation: if the application doesn't guarantee that the
     * pointer target is always reachable, difficult-to-diagnose
     * problems may ensue.  Try to validate the 'ptr' argument to
     * the extent possible.
     */
 
#if defined(DUK_USE_ASSERTIONS)
    duk__validate_push_heapptr(ctx, ptr);
#endif
 
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
 
    if (ptr == NULL) {
        goto push_undefined;
    }
 
    switch ((int) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) {
    case DUK_HTYPE_STRING:

◆ duk_push_hobject()

DUK_INTERNAL_DECL void duk_push_hobject	(	duk_context *	ctx,
		duk_hobject *	h )

Definition at line 19320 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_tval tv;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    DUK_TVAL_SET_STRING(&tv, h);

Referenced by duk_hobject_get_length(), duk_hobject_putprop(), duk_push_thread_stash(), and duk_put_global_string().

◆ duk_push_hobject_bidx()

DUK_INTERNAL_DECL void duk_push_hobject_bidx	(	duk_context *	ctx,
		duk_small_int_t	builtin_idx )

Definition at line 19336 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_tval tv;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    DUK_TVAL_SET_OBJECT(&tv, h);
    duk_push_tval(ctx, &tv);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_tval(), DUK_TVAL_SET_OBJECT, and NULL.

Referenced by duk_err_create_and_throw().

◆ duk_push_hobject_class_string()

DUK_INTERNAL_DECL void duk_push_hobject_class_string	(	duk_context *	ctx,
		duk_hobject *	h )

Definition at line 17136 of file duktape-1.8.0/src/duktape.c.

           {
        duk_hobject *h_obj;
 
        duk_to_object(ctx, -1);
        h_obj = duk_get_hobject(ctx, -1);
        DUK_ASSERT(h_obj != NULL);
 
        h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_obj);
    }
    DUK_ASSERT(h_strclass != NULL);
 
    duk_pop(ctx);

◆ duk_push_hstring()

DUK_INTERNAL_DECL void duk_push_hstring	(	duk_context *	ctx,
		duk_hstring *	h )

Definition at line 19305 of file duktape-1.8.0/src/duktape.c.

           :
        goto push_undefined;
    }
    return ret;
 
 push_undefined:
    duk_push_undefined(ctx);

Referenced by duk__get_own_propdesc_raw(), duk__parse_var_decl(), and duk__realloc_props().

◆ duk_push_hstring_stridx()

DUK_INTERNAL_DECL void duk_push_hstring_stridx	(	duk_context *	ctx,
		duk_small_int_t	stridx )

Definition at line 19313 of file duktape-1.8.0/src/duktape.c.

                                                                  {
    return duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),

Referenced by duk__create_escaped_source(), duk__error_getter_helper(), duk_bi_string_constructor(), and duk_hobject_get_length().

◆ duk_push_int()

DUK_EXTERNAL void duk_push_int	(	duk_context *	ctx,
		duk_int_t	val )

Definition at line 18087 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_double_union du;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    du.d = val;
    DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_NUMBER(tv_slot, du.d);
}
 
DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val) {
#if defined(DUK_USE_FASTINT)
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;
#if DUK_INT_MAX <= 0x7fffffffL
    DUK_TVAL_SET_FASTINT_I32(tv_slot, (duk_int32_t) val);
#else
    if (val >= DUK_FASTINT_MIN && val <= DUK_FASTINT_MAX) {
        DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
    } else {

Referenced by duk__error_getter_helper(), duk__get_own_propdesc_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__parse_var_decl(), duk_bi_buffer_readfield(), duk_bi_duktape_object_info(), duk_bi_string_prototype_match(), and duk_err_create_and_throw().

◆ duk_push_lightfunc_name()

DUK_INTERNAL_DECL void duk_push_lightfunc_name	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 19603 of file duktape-1.8.0/src/duktape.c.

                                                                          {
    duk_c_function func;
 
    DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv));
 
    /* Lightfunc name, includes Duktape/C native function pointer, which

Referenced by duk_push_string_funcptr().

◆ duk_push_lightfunc_tostring()

DUK_INTERNAL_DECL void duk_push_lightfunc_tostring	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 19627 of file duktape-1.8.0/src/duktape.c.

◆ duk_push_lstring()

DUK_EXTERNAL const char * duk_push_lstring	(	duk_context *	ctx,
		const char *	str,
		duk_size_t	len )

Definition at line 18168 of file duktape-1.8.0/src/duktape.c.

                                                 {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_double_union du;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    DUK_DBLUNION_SET_NAN(&du);
    DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_NUMBER(tv_slot, du.d);
}
 
DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack before interning (avoid hanging temp) */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    /* NULL with zero length represents an empty string; NULL with higher
     * length is also now trated like an empty string although it is
     * a bit dubious.  This is unlike duk_push_string() which pushes a
     * 'null' if the input string is a NULL.
     */
    if (!str) {

Referenced by duk_push_string_file_raw().

◆ duk_push_nan()

DUK_EXTERNAL void duk_push_nan ( duk_context * ctx )

Definition at line 18154 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_date_constructor_now().

◆ duk_push_null()

DUK_EXTERNAL void duk_push_null ( duk_context * ctx )

Definition at line 18026 of file duktape-1.8.0/src/duktape.c.

                                                       {
    duk_hthread *thr;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
 

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk_push_string_file_raw().

◆ duk_push_number()

DUK_EXTERNAL void duk_push_number	(	duk_context *	ctx,
		duk_double_t	val )

Definition at line 18073 of file duktape-1.8.0/src/duktape.c.

                                                   {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;

Referenced by duk__format_parts_iso8601(), duk_bi_buffer_readfield(), and duk_bi_string_prototype_substring().

◆ duk_push_object()

DUK_EXTERNAL duk_idx_t duk_push_object ( duk_context * ctx )

Definition at line 18613 of file duktape-1.8.0/src/duktape.c.

                                                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_push_object_helper()

DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper	(	duk_context *	ctx,
		duk_uint_t	hobject_flags_and_class,
		duk_small_int_t	prototype_bidx )

Definition at line 18558 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    va_list ap;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* allow fmt==NULL */
    va_start(ap, fmt);
    ret = duk_push_vsprintf(ctx, fmt, ap);
    va_end(ap);
 
    return ret;
}
 
DUK_INTERNAL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_slot;
    duk_hobject *h;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(prototype_bidx == -1 ||
               (prototype_bidx >= 0 && prototype_bidx < DUK_NUM_BUILTINS));
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    h = duk_hobject_alloc(thr->heap, hobject_flags_and_class);
    if (!h) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    DUK_DDD(DUK_DDDPRINT("created object with flags: 0x%08lx", (unsigned long) h->hdr.h_flags));
 

Referenced by duk_bi_string_constructor_from_char_code().

◆ duk_push_object_helper_proto()

DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper_proto	(	duk_context *	ctx,
		duk_uint_t	hobject_flags_and_class,
		duk_hobject *	proto )

Definition at line 18598 of file duktape-1.8.0/src/duktape.c.

                             {
        DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[prototype_bidx]);
    } else {
        DUK_ASSERT(prototype_bidx == -1);
        DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL);
    }
 

◆ duk_push_object_internal()

DUK_INTERNAL_DECL duk_idx_t duk_push_object_internal ( duk_context * ctx )

Definition at line 19298 of file duktape-1.8.0/src/duktape.c.

                         :
        duk_push_hobject(ctx, (duk_hobject *) ptr);
        break;
    case DUK_HTYPE_BUFFER:
        duk_push_hbuffer(ctx, (duk_hbuffer *) ptr);

◆ duk_push_pointer()

DUK_EXTERNAL void duk_push_pointer	(	duk_context *	ctx,
		void *	val )

Definition at line 18285 of file duktape-1.8.0/src/duktape.c.

                                                                                                        {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(path);
 
    if (flags != 0) {
        DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE);  /* only flag now */
        duk_push_undefined(ctx);
    } else {

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_undefined(), DUK_STRING_PUSH_SAFE, and DUK_UNREF.

Referenced by duk_bi_duktape_object_info().

◆ duk_push_sprintf()

DUK_EXTERNAL const char * duk_push_sprintf	(	duk_context *	ctx,
		const char *	fmt,
			... )

Definition at line 18544 of file duktape-1.8.0/src/duktape.c.

                                                 {
            DUK_ERROR_API(thr, DUK_STR_SPRINTF_TOO_LONG);
        }
    }
 
    /* Cannot use duk_to_string() on the buffer because it is usually
     * larger than 'len'.  Also, 'buf' is usually a stack buffer.
     */
    res = duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len);  /* [ buf? res ] */
    if (pushed_buf) {
        duk_remove(ctx, -2);

References DUK_ERROR_API, and DUK_STR_SPRINTF_TOO_LONG.

Referenced by duk__error_getter_helper(), and duk_to_int_clamped_raw().

◆ duk_push_string()

DUK_EXTERNAL const char * duk_push_string	(	duk_context *	ctx,
		const char *	str )

Definition at line 18204 of file duktape-1.8.0/src/duktape.c.

                                       {
        DUK_ERROR_RANGE(thr, DUK_STR_STRING_TOO_LONG);
    }
 
    h = duk_heap_string_intern_checked(thr, (const duk_uint8_t *) str, (duk_uint32_t) len);
    DUK_ASSERT(h != NULL);
 

Referenced by duk_del_prop_stridx(), duk_get_prop_stridx(), duk_has_prop_stridx(), and duk_push_string_funcptr().

◆ duk_push_string_file_raw()

DUK_EXTERNAL const char * duk_push_string_file_raw	(	duk_context *	ctx,
		const char *	path,
		duk_uint_t	flags )

Definition at line 18220 of file duktape-1.8.0/src/duktape.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (str) {
        return duk_push_lstring(ctx, str, DUK_STRLEN(str));
    } else {
        duk_push_null(ctx);
        return NULL;
    }
}
 
#ifdef DUK_USE_FILE_IO
/* This is a bit clunky because it is ANSI C portable.  Should perhaps
 * relocate to another file because this is potentially platform
 * dependent.
 */
DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_file *f = NULL;
    char *buf;
    long sz;  /* ANSI C typing */
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (!path) {
        goto fail;
    }
    f = DUK_FOPEN(path, "rb");
    if (!f) {
        goto fail;
    }
    if (DUK_FSEEK(f, 0, SEEK_END) < 0) {
        goto fail;
    }
    sz = DUK_FTELL(f);
    if (sz < 0) {
        goto fail;
    }
    if (DUK_FSEEK(f, 0, SEEK_SET) < 0) {
        goto fail;
    }
    buf = (char *) duk_push_fixed_buffer(ctx, (duk_size_t) sz);
    DUK_ASSERT(buf != NULL);
    if ((duk_size_t) DUK_FREAD(buf, 1, (size_t) sz, f) != (duk_size_t) sz) {
        goto fail;
    }
    (void) DUK_FCLOSE(f);  /* ignore fclose() error */

References DUK_ASSERT_CTX_VALID, duk_push_lstring(), duk_push_null(), DUK_STRLEN, and NULL.

◆ duk_push_string_funcptr()

DUK_INTERNAL_DECL void duk_push_string_funcptr	(	duk_context *	ctx,
		duk_uint8_t *	ptr,
		duk_size_t	sz )

Definition at line 19643 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv));
 
    duk_push_string(ctx, "function ");
    duk_push_lightfunc_name(ctx, tv);
    duk_push_string(ctx, "() {\"light\"}");
    duk_concat(ctx, 3);
}
 
/*
 *  Function pointers
 *
 *  Printing function pointers is non-portable, so we do that by hex printing
 *  bytes from memory.
 */
 
DUK_INTERNAL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz) {
    duk_uint8_t buf[32 * 2];
    duk_uint8_t *p, *q;
    duk_small_uint_t i;
    duk_small_uint_t t;
 
    DUK_ASSERT(sz <= 32);  /* sanity limit for function pointer size */
 
    p = buf;

References DUK_ASSERT, duk_concat(), duk_push_lightfunc_name(), duk_push_string(), and DUK_TVAL_IS_LIGHTFUNC.

◆ duk_push_string_readable()

DUK_INTERNAL_DECL const char * duk_push_string_readable	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 19784 of file duktape-1.8.0/src/duktape.c.

◆ duk_push_string_tval_readable()

DUK_INTERNAL_DECL const char * duk_push_string_tval_readable	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 19737 of file duktape-1.8.0/src/duktape.c.

                   {
                q += duk_unicode_encode_xutf8(cp, q);
            }
        } else {
            p++;  /* advance manually */
            *q++ = (duk_uint8_t) DUK_ASC_QUESTION;
        }
        nchars++;
    }
    *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE;
 
    duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (q - buf));
}
 
DUK_INTERNAL const char *duk_push_string_tval_readable(duk_context *ctx, duk_tval *tv) {
    duk_hthread *thr;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    if (tv == NULL) {
        duk_push_string(ctx, "none");
    } else {
        switch (DUK_TVAL_GET_TAG(tv)) {
        case DUK_TAG_STRING: {
            duk__push_hstring_readable_unicode(ctx, DUK_TVAL_GET_STRING(tv));
            break;
        }
        case DUK_TAG_OBJECT: {
            duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
            DUK_ASSERT(h != NULL);
            duk_push_hobject_class_string(ctx, h);
            break;
        }
        case DUK_TAG_BUFFER: {
            /* XXX: Hex encoded, length limited buffer summary here? */
            duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
            DUK_ASSERT(h != NULL);
            duk_push_sprintf(ctx, "[buffer:%ld]", (long) DUK_HBUFFER_GET_SIZE(h));
            break;
        }
        case DUK_TAG_POINTER: {

Referenced by duk__concat_and_join_helper(), and duk_hobject_putprop().

◆ duk_push_this()

DUK_EXTERNAL void duk_push_this ( duk_context * ctx )

Definition at line 18335 of file duktape-1.8.0/src/duktape.c.

18338 {

18339 /* XXX: better macro for DUK_TVAL_IS_UNDEFINED_OR_NULL(tv) */

Referenced by duk__error_getter_helper(), duk_bi_boolean_prototype_tostring_shared(), duk_bi_buffer_slice_shared(), duk_bi_regexp_constructor(), and duk_bi_typedarray_set().

◆ duk_push_this_check_object_coercible()

DUK_INTERNAL_DECL void duk_push_this_check_object_coercible ( duk_context * ctx )

Definition at line 18341 of file duktape-1.8.0/src/duktape.c.

◆ duk_push_this_coercible_to_object()

DUK_INTERNAL_DECL duk_hobject * duk_push_this_coercible_to_object ( duk_context * ctx )

Definition at line 18347 of file duktape-1.8.0/src/duktape.c.

           :
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_OBJECT_COERCIBLE);
}
 
DUK_EXTERNAL void duk_push_this(duk_context *ctx) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 0 /*check_object_coercible*/);
}
 

Referenced by duk__push_this_obj_len_u32_limited(), and duk_bi_object_prototype_is_prototype_of().

◆ duk_push_this_coercible_to_string()

DUK_INTERNAL_DECL duk_hstring * duk_push_this_coercible_to_string ( duk_context * ctx )

Definition at line 18359 of file duktape-1.8.0/src/duktape.c.

                                                                              {
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 1 /*check_object_coercible*/);

Referenced by duk_bi_string_prototype_indexof_shared(), and duk_bi_string_prototype_locale_compare().

◆ duk_push_thread_raw()

DUK_EXTERNAL duk_idx_t duk_push_thread_raw	(	duk_context *	ctx,
		duk_uint_t	flags )

Definition at line 18660 of file duktape-1.8.0/src/duktape.c.

                                                                               {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hthread *obj;
    duk_idx_t ret;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    obj = duk_hthread_alloc(thr->heap,
                            DUK_HOBJECT_FLAG_EXTENSIBLE |
                            DUK_HOBJECT_FLAG_THREAD |
                            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD));
    if (!obj) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    obj->state = DUK_HTHREAD_STATE_INACTIVE;
#if defined(DUK_USE_ROM_STRINGS)
    /* Nothing to initialize, strs[] is in ROM. */
#else
#if defined(DUK_USE_HEAPPTR16)
    obj->strs16 = thr->strs16;
#else
    obj->strs = thr->strs;
#endif
#endif
    DUK_DDD(DUK_DDDPRINT("created thread object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
 
    /* make the new thread reachable */
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
    DUK_HTHREAD_INCREF(thr, obj);
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
    thr->valstack_top++;
 
    /* important to do this *after* pushing, to make the thread reachable for gc */
    if (!duk_hthread_init_stacks(thr->heap, obj)) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    /* initialize built-ins - either by copying or creating new ones */

◆ duk_push_thread_stash()

DUK_EXTERNAL void duk_push_thread_stash	(	duk_context *	ctx,
		duk_context *	target_ctx )

Definition at line 18449 of file duktape-1.8.0/src/duktape.c.

                                                        {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
    DUK_ASSERT_CTX_VALID(ctx);
    heap = thr->heap;
    DUK_ASSERT(heap->heap_object != NULL);
    duk_push_hobject(ctx, heap->heap_object);
    duk__push_stash(ctx);
}

References duk__push_stash(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_hobject(), duk_hthread::heap, duk_heap::heap_object, and NULL.

◆ duk_push_true()

DUK_EXTERNAL void duk_push_true ( duk_context * ctx )

Definition at line 18050 of file duktape-1.8.0/src/duktape.c.

                                                                     {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_small_int_t b;
 
    DUK_ASSERT_CTX_VALID(ctx);

Referenced by duk_bi_object_constructor_is_extensible().

◆ duk_push_tval()

DUK_INTERNAL_DECL void duk_push_tval	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 17999 of file duktape-1.8.0/src/duktape.c.

                                                              {
            return DUK_ERR_URI_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_ERROR_PROTOTYPE]) {
            return DUK_ERR_ERROR;
        }
 
        h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
    } while (--sanity > 0);
 
    return DUK_ERR_NONE;
}

References DUK_ERR_URI_ERROR.

Referenced by duk__declvar_helper(), duk__err_augment_user(), duk__get_own_propdesc_raw(), duk__getvar_helper(), duk_hobject_putprop(), duk_js_instanceof(), duk_push_current_thread(), and duk_push_hobject_bidx().

◆ duk_push_uint()

DUK_EXTERNAL void duk_push_uint	(	duk_context *	ctx,
		duk_uint_t	val )

Definition at line 18120 of file duktape-1.8.0/src/duktape.c.

                                                                  {
#if defined(DUK_USE_FASTINT)
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;
#if DUK_UINT_MAX <= 0xffffffffUL
    DUK_TVAL_SET_FASTINT_U32(tv_slot, (duk_uint32_t) val);
#else
    if (val <= DUK_FASTINT_MAX) {  /* val is unsigned so >= 0 */
        /* XXX: take advantage of val being unsigned, no need to mask */
        DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
    } else {

Referenced by duk__get_own_propdesc_raw(), duk_bi_buffer_readfield(), and duk_bi_duktape_object_info().

◆ duk_push_undefined()

DUK_EXTERNAL void duk_push_undefined ( duk_context * ctx )

Definition at line 18012 of file duktape-1.8.0/src/duktape.c.

                                                                {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(tv != NULL);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;

References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_TVAL, NULL, and duk_hthread::valstack_top.

Referenced by duk__err_augment_user(), duk__get_own_propdesc_raw(), duk__getvar_helper(), duk_bi_duktape_object_info(), and duk_push_pointer().

◆ duk_push_vsprintf()

DUK_EXTERNAL const char * duk_push_vsprintf	(	duk_context *	ctx,
		const char *	fmt,
		va_list	ap )

Definition at line 18478 of file duktape-1.8.0/src/duktape.c.

                                                                                                                    {
    duk_int_t len;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(ctx);
 
    /* NUL terminator handling doesn't matter here */
    len = DUK_VSNPRINTF((char *) buf, sz, fmt, ap);
    if (len < (duk_int_t) sz) {
        /* Return value of 'sz' or more indicates output was (potentially)
         * truncated.
         */
        return (duk_int_t) len;
    }
    return -1;
}
 
DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uint8_t stack_buf[DUK_PUSH_SPRINTF_INITIAL_SIZE];
    duk_size_t sz = DUK_PUSH_SPRINTF_INITIAL_SIZE;
    duk_bool_t pushed_buf = 0;
    void *buf;
    duk_int_t len;  /* XXX: duk_ssize_t */
    const char *res;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* special handling of fmt==NULL */
    if (!fmt) {
        duk_hstring *h_str;
        duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
        h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr);  /* rely on interning, must be this string */
        return (const char *) DUK_HSTRING_GET_DATA(h_str);
    }
 
    /* initial estimate based on format string */
    sz = DUK_STRLEN(fmt) + 16;  /* format plus something to avoid just missing */
    if (sz < DUK_PUSH_SPRINTF_INITIAL_SIZE) {
        sz = DUK_PUSH_SPRINTF_INITIAL_SIZE;
    }
    DUK_ASSERT(sz > 0);
 
    /* Try to make do with a stack buffer to avoid allocating a temporary buffer.
     * This works 99% of the time which is quite nice.
     */
    for (;;) {
        va_list ap_copy;  /* copied so that 'ap' can be reused */
 
        if (sz <= sizeof(stack_buf)) {
            buf = stack_buf;
        } else if (!pushed_buf) {
            pushed_buf = 1;
            buf = duk_push_dynamic_buffer(ctx, sz);
        } else {
            buf = duk_resize_buffer(ctx, -1, sz);
        }
        DUK_ASSERT(buf != NULL);
 
        DUK_VA_COPY(ap_copy, ap);
        len = duk__try_push_vsprintf(ctx, buf, sz, fmt, ap_copy);
        va_end(ap_copy);
        if (len >= 0) {
            break;
        }

References DUK_ASSERT_CTX_VALID, DUK_UNREF, and DUK_VSNPRINTF.

◆ duk_put_function_list()

DUK_EXTERNAL void duk_put_function_list	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const duk_function_list_entry *	funcs )

Definition at line 14869 of file duktape-1.8.0/src/duktape.c.

                                                                                               {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_require_hobject(ctx, enum_index);
    duk_dup(ctx, enum_index);
    return duk_hobject_enumerator_next(ctx, get_value);
}
 
/*

◆ duk_put_global_string()

DUK_EXTERNAL duk_bool_t duk_put_global_string	(	duk_context *	ctx,
		const char *	key )

Definition at line 14918 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_bool_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL);
 
    /* XXX: direct implementation */
 
    duk_push_hobject(ctx, thr->builtins[DUK_BIDX_GLOBAL]);
    ret = duk_get_prop_string(ctx, -1, key);
    duk_remove(ctx, -2);
    return ret;

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_BIDX_GLOBAL, duk_get_prop_string(), duk_push_hobject(), duk_remove(), and NULL.

◆ duk_put_number_list()

DUK_EXTERNAL void duk_put_number_list	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const duk_number_list_entry *	numbers )

Definition at line 14884 of file duktape-1.8.0/src/duktape.c.

                                                                                                                     {
    const duk_function_list_entry *ent = funcs;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    if (ent != NULL) {
        while (ent->key != NULL) {
            duk_push_c_function(ctx, ent->value, ent->nargs);
            duk_put_prop_string(ctx, obj_index, ent->key);
            ent++;
        }

References DUK_ASSERT_CTX_VALID, duk_push_c_function(), duk_put_prop_string(), duk_require_normalize_index(), funcs, duk_function_list_entry::key, duk_function_list_entry::nargs, NULL, and duk_function_list_entry::value.

◆ duk_put_prop()

DUK_EXTERNAL duk_bool_t duk_put_prop	(	duk_context *	ctx,
		duk_idx_t	obj_idx )

Definition at line 14508 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2().

◆ duk_put_prop_index()

DUK_EXTERNAL duk_bool_t duk_put_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_idx,
		duk_uarridx_t	arr_idx )

Definition at line 14526 of file duktape-1.8.0/src/duktape.c.

                                                                                                  {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(key != NULL);

Referenced by duk__parse_var_decl(), and duk_bi_typedarray_set().

◆ duk_put_prop_stridx()

DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx )

Definition at line 14534 of file duktape-1.8.0/src/duktape.c.

                                                                                                       {
    DUK_ASSERT_CTX_VALID(ctx);
 

Referenced by duk__format_parts_iso8601(), and duk_bi_logger_prototype_fmt().

◆ duk_put_prop_string()

DUK_EXTERNAL duk_bool_t duk_put_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_idx,
		const char *	key )

Definition at line 14513 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_put_number_list().

◆ duk_put_var()

DUK_EXTERNAL void duk_put_var ( duk_context * ctx )

Definition at line 20165 of file duktape-1.8.0/src/duktape.c.

                                                {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_hstring *h_varname;
    duk_tval *tv_val;
    duk_small_int_t throw_flag;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h_varname = duk_require_hstring(ctx, -2);  /* XXX: tostring? */
    DUK_ASSERT(h_varname != NULL);
 
    tv_val = duk_require_tval(ctx, -1);
 
    throw_flag = duk_is_strict_call(ctx);
 

◆ duk_raw_read_double_be()

DUK_INTERNAL_DECL duk_double_t duk_raw_read_double_be ( duk_uint8_t ** p )

Definition at line 86788 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    union {
        duk_uint8_t b[4];
        duk_uint32_t x;
    } u;
 
    DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
    u.x = DUK_NTOH32(u.x);
    *p += 4;
    return u.x;
}
 

◆ duk_raw_read_u16_be()

DUK_INTERNAL_DECL duk_uint16_t duk_raw_read_u16_be ( duk_uint8_t ** p )

Definition at line 86764 of file duktape-1.8.0/src/duktape.c.

◆ duk_raw_read_u32_be()

DUK_INTERNAL_DECL duk_uint32_t duk_raw_read_u32_be ( duk_uint8_t ** p )

Definition at line 86776 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    union {
        duk_uint8_t b[2];
        duk_uint16_t x;
    } u;
 

References DUK_MEMCPY.

◆ duk_raw_write_double_be()

DUK_INTERNAL_DECL void duk_raw_write_double_be	(	duk_uint8_t **	p,
		duk_double_t	val )

Definition at line 86828 of file duktape-1.8.0/src/duktape.c.

                                                                                            {
    union {
        duk_uint8_t b[4];
        duk_uint32_t x;
    } u;
 
    u.x = DUK_HTON32(val);
    DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4);
    *p += 4;
}

◆ duk_raw_write_u16_be()

DUK_INTERNAL_DECL void duk_raw_write_u16_be	(	duk_uint8_t **	p,
		duk_uint16_t	val )

Definition at line 86806 of file duktape-1.8.0/src/duktape.c.

          {
        duk_uint8_t b[4];
        duk_uint32_t x;
    } u;
 
    DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
    u.x = DUK_NTOH32(u.x);
    du.ui[DUK_DBL_IDX_UI0] = u.x;
    DUK_MEMCPY((void *) u.b, (const void *) (*p + 4), (size_t) 4);

◆ duk_raw_write_u32_be()

DUK_INTERNAL_DECL void duk_raw_write_u32_be	(	duk_uint8_t **	p,
		duk_uint32_t	val )

Definition at line 86817 of file duktape-1.8.0/src/duktape.c.

                                                                                            {
    union {
        duk_uint8_t b[2];
        duk_uint16_t x;

◆ duk_realloc()

DUK_EXTERNAL void * duk_realloc	(	duk_context *	ctx,
		void *	ptr,
		duk_size_t	size )

Definition at line 14336 of file duktape-1.8.0/src/duktape.c.

                                                                {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return DUK_ALLOC(thr->heap, size);
}
 
DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    DUK_FREE(thr->heap, ptr);
}
 

References DUK_ALLOC, DUK_ASSERT_CTX_VALID, and duk_hthread::heap.

◆ duk_realloc_raw()

DUK_EXTERNAL void * duk_realloc_raw	(	duk_context *	ctx,
		void *	ptr,
		duk_size_t	size )

Definition at line 14312 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return DUK_ALLOC_RAW(thr->heap, size);

References DUK_ALLOC_RAW, DUK_ASSERT_CTX_VALID, and duk_hthread::heap.

◆ duk_regexp_compile()

DUK_INTERNAL_DECL void duk_regexp_compile ( duk_hthread * thr )

Definition at line 78549 of file duktape-1.8.0/src/duktape.c.

                                                       {
    duk_context *ctx = (duk_context *) thr;
    duk_re_compiler_ctx re_ctx;
    duk_lexer_point lex_point;
    duk_hstring *h_pattern;
    duk_hstring *h_flags;
    duk__re_disjunction_info ign_disj;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
 
    /*
     *  Args validation
     */
 
    /* TypeError if fails */
    h_pattern = duk_require_hstring(ctx, -2);
    h_flags = duk_require_hstring(ctx, -1);
 
    /*
     *  Create normalized 'source' property (E5 Section 15.10.3).
     */
 
    /* [ ... pattern flags ] */
 
    duk__create_escaped_source(thr, -2);
 
    /* [ ... pattern flags escaped_source ] */
 
    /*
     *  Init compilation context
     */
 
    /* [ ... pattern flags escaped_source buffer ] */
 
    DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
    DUK_LEXER_INITCTX(&re_ctx.lex);  /* duplicate zeroing, expect for (possible) NULL inits */
    re_ctx.thr = thr;
    re_ctx.lex.thr = thr;
    re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern);
    re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern);
    re_ctx.lex.token_limit = DUK_RE_COMPILE_TOKEN_LIMIT;
    re_ctx.recursion_limit = DUK_USE_REGEXP_COMPILER_RECLIMIT;
    re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags);
 
    DUK_BW_INIT_PUSHBUF(thr, &re_ctx.bw, DUK__RE_INITIAL_BUFSIZE);
 
    DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld",
                       (unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit));
 
    /*
     *  Init lexer
     */
 
    lex_point.offset = 0;  /* expensive init, just want to fill window */
    lex_point.line = 1;
    DUK_LEXER_SETPOINT(&re_ctx.lex, &lex_point);
 
    /*
     *  Compilation
     */
 
    DUK_DD(DUK_DDPRINT("starting regexp compilation"));
 
    duk__append_u32(&re_ctx, DUK_REOP_SAVE);
    duk__append_u32(&re_ctx, 0);
    duk__parse_disjunction(&re_ctx, 1 /*expect_eof*/, &ign_disj);
    duk__append_u32(&re_ctx, DUK_REOP_SAVE);
    duk__append_u32(&re_ctx, 1);
    duk__append_u32(&re_ctx, DUK_REOP_MATCH);
 
    /*
     *  Check for invalid backreferences; note that it is NOT an error
     *  to back-reference a capture group which has not yet been introduced
     *  in the pattern (as in /\1(foo)/); in fact, the backreference will
     *  always match!  It IS an error to back-reference a capture group
     *  which will never be introduced in the pattern.  Thus, we can check
     *  for such references only after parsing is complete.
     */
 
    if (re_ctx.highest_backref > re_ctx.captures) {
        DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_BACKREFS);
    }
 
    /*
     *  Emit compiled regexp header: flags, ncaptures
     *  (insertion order inverted on purpose)
     */
 
    duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2);
    duk__insert_u32(&re_ctx, 0, re_ctx.re_flags);
 

◆ duk_regexp_create_instance()

DUK_INTERNAL_DECL void duk_regexp_create_instance ( duk_hthread * thr )

Definition at line 78669 of file duktape-1.8.0/src/duktape.c.

                                                               : %!T, escaped source: %!T",
                       (duk_tval *) duk_get_tval(ctx, -1), (duk_tval *) duk_get_tval(ctx, -2)));
}
 
/*
 *  Create a RegExp instance (E5 Section 15.10.7).
 *
 *  Note: the output stack left by duk_regexp_compile() is directly compatible
 *  with the input here.
 *
 *  Input stack:  [ escaped_source bytecode ]  (both as strings)
 *  Output stack: [ RegExp ]
 */
 
DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *h;
    duk_hstring *h_bc;
    duk_small_int_t re_flags;
 
    /* [ ... escape_source bytecode ] */
 
    h_bc = duk_get_hstring(ctx, -1);
    DUK_ASSERT(h_bc != NULL);
    DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1);          /* always at least the header */
    DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
    DUK_ASSERT((duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);  /* flags always encodes to 1 byte */
    re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
 
    /* [ ... escaped_source bytecode ] */
 
    duk_push_object(ctx);
    h = duk_get_hobject(ctx, -1);
    DUK_ASSERT(h != NULL);
    duk_insert(ctx, -3);
 
    /* [ ... regexp_object escaped_source bytecode ] */
 
    DUK_HOBJECT_SET_CLASS_NUMBER(h, DUK_HOBJECT_CLASS_REGEXP);
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[DUK_BIDX_REGEXP_PROTOTYPE]);
 
    duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_BYTECODE, DUK_PROPDESC_FLAGS_NONE);
 
    /* [ ... regexp_object escaped_source ] */
 
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_SOURCE, DUK_PROPDESC_FLAGS_NONE);

◆ duk_regexp_match()

DUK_INTERNAL_DECL void duk_regexp_match ( duk_hthread * thr )

Definition at line 79719 of file duktape-1.8.0/src/duktape.c.

◆ duk_regexp_match_force_global()

DUK_INTERNAL_DECL void duk_regexp_match_force_global ( duk_hthread * thr )

Definition at line 79726 of file duktape-1.8.0/src/duktape.c.

◆ duk_remove()

DUK_EXTERNAL void duk_remove	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15955 of file duktape-1.8.0/src/duktape.c.

                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv1;
    duk_tval *tv2;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);  /* w/o refcounting */
 
    tv1 = duk_require_tval(ctx, from_index);
    DUK_ASSERT(tv1 != NULL);
    tv2 = duk_require_tval(ctx, to_index);
    DUK_ASSERT(tv2 != NULL);
 
    /* For tv1 == tv2, this is a no-op (no explicit check needed). */
    DUK_TVAL_SET_TVAL_UPDREF(thr, tv2, tv1);  /* side effects */
}
 
DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *p;
    duk_tval *q;
#ifdef DUK_USE_REFERENCE_COUNTING
    duk_tval tv_tmp;
#endif
    duk_size_t nbytes;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    p = duk_require_tval(ctx, index);
    DUK_ASSERT(p != NULL);
    q = duk_require_tval(ctx, -1);
    DUK_ASSERT(q != NULL);
 
    DUK_ASSERT(q >= p);
 
    /*              nbytes            zero size case
     *           <--------->
     *    [ ... | p | x | x | q ]     [ ... | p==q ]
     * => [ ... | x | x | q ]         [ ... ]

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_SET_TVAL_UPDREF, DUK_UNREF, and NULL.

Referenced by duk_handle_ecma_call_setup(), and duk_put_global_string().

◆ duk_repl_fpclassify()

DUK_INTERNAL int duk_repl_fpclassify ( double x )

Definition at line 8666 of file duktape-1.8.0/src/duktape.c.

                                               {
    duk_double_union u;
    duk_uint_fast16_t expt;
    duk_small_int_t mzero;
 
    u.d = x;
    expt = (duk_uint_fast16_t) (u.us[DUK_DBL_IDX_US0] & 0x7ff0UL);
    if (expt > 0x0000UL && expt < 0x7ff0UL) {
        /* expt values [0x001,0x7fe] = normal */
        return DUK_FP_NORMAL;
    }
 

References duk_double_union::d, DUK_FP_NORMAL, duk_double_union::ui, and duk_double_union::us.

◆ duk_repl_isfinite()

DUK_INTERNAL int duk_repl_isfinite ( double x )

Definition at line 8706 of file duktape-1.8.0/src/duktape.c.

               {
            return DUK_FP_NAN;
        }
    }
}
#endif
 

◆ duk_repl_isinf()

DUK_INTERNAL int duk_repl_isinf ( double x )

Definition at line 8724 of file duktape-1.8.0/src/duktape.c.

                                                 {
        return 0;
    } else {

◆ duk_repl_isnan()

DUK_INTERNAL int duk_repl_isnan ( double x )

Definition at line 8717 of file duktape-1.8.0/src/duktape.c.

◆ duk_repl_signbit()

DUK_INTERNAL int duk_repl_signbit ( double x )

Definition at line 8698 of file duktape-1.8.0/src/duktape.c.

                   {
            return DUK_FP_ZERO;
        } else {
            return DUK_FP_SUBNORMAL;
        }

References DUK_FP_ZERO.

◆ duk_replace()

DUK_EXTERNAL void duk_replace	(	duk_context *	ctx,
		duk_idx_t	to_index )

Definition at line 15915 of file duktape-1.8.0/src/duktape.c.

                                    : to_index=%ld, p=%p, q=%p, nbytes=%lu",
                         (long) to_index, (void *) p, (void *) q, (unsigned long) nbytes));
 
    /* No net refcount changes. */
 
    if (nbytes > 0) {
        DUK_TVAL_SET_TVAL(&tv_tmp, q);
        DUK_ASSERT(nbytes > 0);
        DUK_MEMMOVE((void *) (p + 1), (const void *) p, (size_t) nbytes);
        DUK_TVAL_SET_TVAL(p, &tv_tmp);
    } else {
        /* nop: insert top to top */
        DUK_ASSERT(nbytes == 0);
        DUK_ASSERT(p == q);
    }
}
 
DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv1;
    duk_tval *tv2;
    duk_tval tv_tmp;

Referenced by duk__error_getter_helper(), duk__expr_led(), duk_hobject_define_property_helper(), duk_js_instanceof(), duk_lexer_initctx(), duk_lexer_parse_js_input_element(), and duk_to_defaultvalue().

◆ duk_require_boolean()

DUK_EXTERNAL duk_bool_t duk_require_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16115 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_bool_t ret = 0;  /* default: false */
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
        ret = DUK_TVAL_GET_BOOLEAN(tv);
    }
 
    DUK_ASSERT(ret == 0 || ret == 1);
    return ret;

◆ duk_require_buffer()

DUK_EXTERNAL void * duk_require_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16336 of file duktape-1.8.0/src/duktape.c.

16337 {

16338 *out_size = DUK_HBUFFER_GET_SIZE(h);

◆ duk_require_buffer_data()

DUK_EXTERNAL void * duk_require_buffer_data	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16398 of file duktape-1.8.0/src/duktape.c.

◆ duk_require_c_function()

DUK_EXTERNAL duk_c_function duk_require_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16539 of file duktape-1.8.0/src/duktape.c.

                                 {
        return NULL;
    }
    h = DUK_TVAL_GET_OBJECT(tv);
    DUK_ASSERT(h != NULL);
 
    if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        return NULL;
    }
    DUK_ASSERT(DUK_HOBJECT_HAS_NATIVEFUNCTION(h));

◆ duk_require_context()

DUK_EXTERNAL duk_context * duk_require_context	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16564 of file duktape-1.8.0/src/duktape.c.

◆ duk_require_function()

DUK_EXTERNAL void duk_require_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16552 of file duktape-1.8.0/src/duktape.c.

16556 {

◆ duk_require_hbuffer()

DUK_INTERNAL_DECL duk_hbuffer * duk_require_hbuffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16453 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    return (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
}
 
DUK_INTERNAL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index) {
    duk_heaphdr *h;
    h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h == NULL) {

References duk__get_tagged_heaphdr_raw(), DUK_TAG_OBJECT, and index.

◆ duk_require_hcompiledfunction()

DUK_INTERNAL_DECL duk_hcompiledfunction * duk_require_hcompiledfunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16487 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (!(h != NULL && DUK_HOBJECT_IS_THREAD(h))) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "thread", DUK_STR_NOT_THREAD);
    }
    return (duk_hthread *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_IS_THREAD, DUK_STR_NOT_THREAD, DUK_TAG_OBJECT, index, and NULL.

◆ duk_require_heapptr()

DUK_EXTERNAL void * duk_require_heapptr	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16586 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_tval *tv;
    void *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
        ret = (void *) DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(ret != NULL);
        return ret;
    }
 
    return (void *) NULL;
}
 
DUK_EXTERNAL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index) {

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_GET_HEAPHDR, DUK_TVAL_IS_HEAP_ALLOCATED, index, and NULL.

◆ duk_require_hnativefunction()

DUK_INTERNAL_DECL duk_hnativefunction * duk_require_hnativefunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16504 of file duktape-1.8.0/src/duktape.c.

                                                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (!(h != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(h))) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "compiledfunction", DUK_STR_NOT_COMPILEDFUNCTION);
    }
    return (duk_hcompiledfunction *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_STR_NOT_COMPILEDFUNCTION, DUK_TAG_OBJECT, index, and NULL.

◆ duk_require_hobject()

DUK_INTERNAL_DECL duk_hobject * duk_require_hobject	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16440 of file duktape-1.8.0/src/duktape.c.

                                                                             {
    return (duk_hstring *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING);
}
 
DUK_INTERNAL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index) {
    duk_heaphdr *h;
    h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING);
    if (h == NULL) {

References duk__get_tagged_heaphdr_raw(), DUK_TAG_STRING, and index.

Referenced by duk_bi_typedarray_set(), duk_get_hobject_with_class(), duk_hobject_prepare_property_descriptor(), duk_hthread_copy_builtin_objects(), and duk_js_instanceof().

◆ duk_require_hobject_or_lfunc()

DUK_INTERNAL_DECL duk_hobject * duk_require_hobject_or_lfunc	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16638 of file duktape-1.8.0/src/duktape.c.

                                {
        return DUK_TVAL_GET_OBJECT(tv);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_to_object(ctx, index);
        return duk_require_hobject(ctx, index);
    }
 
    return NULL;
}
 
/* Useful for internal call sites where we either expect an object (function)
 * or a lightfunc.  Returns NULL for a lightfunc.

Referenced by duk_bi_object_constructor_is_extensible().

◆ duk_require_hobject_or_lfunc_coerce()

DUK_INTERNAL_DECL duk_hobject * duk_require_hobject_or_lfunc_coerce	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16659 of file duktape-1.8.0/src/duktape.c.

                                {
        return DUK_TVAL_GET_OBJECT(tv);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        return NULL;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "object", DUK_STR_NOT_OBJECT);
    return NULL;  /* not reachable */
}
 
/* Useful for internal call sites where we either expect an object (function)
 * or a lightfunc.  Accepts an object (returned as is) or a lightfunc (coerced
 * to an object).  Return value is never NULL.

◆ duk_require_hobject_with_class()

DUK_INTERNAL_DECL duk_hobject * duk_require_hobject_with_class	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_uint_t	classnum )

Definition at line 16690 of file duktape-1.8.0/src/duktape.c.

                                                                                                                   {
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(classnum >= 0);  /* unsigned */
    DUK_ASSERT(classnum <= DUK_HOBJECT_CLASS_MAX);
 
    h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(h) != classnum) {
        h = NULL;
    }
    return h;
}
 
DUK_INTERNAL duk_hobject *duk_require_hobject_with_class(duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum) {
    duk_hthread *thr;

Referenced by duk_bi_regexp_constructor().

◆ duk_require_hstring()

DUK_INTERNAL_DECL duk_hstring * duk_require_hstring	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16427 of file duktape-1.8.0/src/duktape.c.

                                             {
        duk_heaphdr *ret;
        ret = DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(ret != NULL);  /* tagged null pointers should never occur */
        return ret;

Referenced by duk_hobject_define_property_helper().

◆ duk_require_hthread()

DUK_INTERNAL_DECL duk_hthread * duk_require_hthread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16470 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    duk_heaphdr *h;
    h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER);
    if (h == NULL) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "buffer", DUK_STR_NOT_BUFFER);
    }
    return (duk_hbuffer *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_BUFFER, DUK_TAG_BUFFER, index, and NULL.

◆ duk_require_int()

DUK_EXTERNAL duk_int_t duk_require_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16187 of file duktape-1.8.0/src/duktape.c.

◆ duk_require_lstring()

DUK_EXTERNAL const char * duk_require_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 16227 of file duktape-1.8.0/src/duktape.c.

                                      {
        /* Here we rely on duk_hstring instances always being zero
         * terminated even if the actual string is not.
         */
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
        ret = (const char *) DUK_HSTRING_GET_DATA(h);
        if (out_len) {
            *out_len = DUK_HSTRING_GET_BYTELEN(h);
        }
    }
 
    return ret;
}

◆ duk_require_normalize_index()

DUK_EXTERNAL duk_idx_t duk_require_normalize_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15223 of file duktape-1.8.0/src/duktape.c.

                   {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        /* since index non-negative */
        DUK_ASSERT(index != DUK_INVALID_INDEX);
        uindex = (duk_uidx_t) index;
    }
 
    /* DUK_INVALID_INDEX won't be accepted as a valid index. */
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
 
    if (DUK_LIKELY(uindex < vs_size)) {
        return (duk_idx_t) uindex;
    }
    return DUK_INVALID_INDEX;
}
 
DUK_EXTERNAL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t uindex;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    DUK_ASSERT_DISABLE(vs_size >= 0);  /* unsigned */

References index.

Referenced by duk_del_prop_stridx(), duk_get_prop_stridx(), duk_has_prop_stridx(), duk_hobject_prepare_property_descriptor(), duk_put_number_list(), and duk_to_boolean().

◆ duk_require_null()

DUK_EXTERNAL void duk_require_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16086 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_UNDEFINED(tv)) {
        return;
    }

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_UNDEFINED, DUK_TVAL_IS_UNDEFINED, and index.

◆ duk_require_number()

DUK_EXTERNAL duk_double_t duk_require_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16152 of file duktape-1.8.0/src/duktape.c.

                                      {
        ret.d = DUK_TVAL_GET_NUMBER(tv);
    }
 
    /*
     *  Number should already be in NaN-normalized form, but let's
     *  normalize anyway.
     */
 
    DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret);
    return ret.d;
}
 
DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_require_pointer()

DUK_EXTERNAL void * duk_require_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16270 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_POINTER(tv)) {
        void *p = DUK_TVAL_GET_POINTER(tv);  /* may be NULL */
        return (void *) p;
    }
 
    return NULL;
}
 

◆ duk_require_stack()

DUK_EXTERNAL void duk_require_stack	(	duk_context *	ctx,
		duk_idx_t	extra )

Definition at line 15743 of file duktape-1.8.0/src/duktape.c.

                                 {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        extra = 0;
    }
 
    min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
    return duk_valstack_resize_raw(ctx,
                                   min_new_size,         /* min_new_size */
                                   0 /* no shrink */ |   /* flags */
                                   0 /* no compact */ |
                                   0 /* no throw */);
}
 
DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t min_new_size;
 

Referenced by duk__error_getter_helper(), duk__parse_func_body(), and duk_err_create_and_throw().

◆ duk_require_stack_top()

DUK_EXTERNAL void duk_require_stack_top	(	duk_context *	ctx,
		duk_idx_t	top )

Definition at line 15787 of file duktape-1.8.0/src/duktape.c.

                               {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        top = 0;
    }
 
    min_new_size = (thr->valstack_bottom - thr->valstack) + top + DUK_VALSTACK_INTERNAL_EXTRA;
    return duk_valstack_resize_raw(ctx,
                                   min_new_size,  /* min_new_size */
                                   0 /* no shrink */ |   /* flags */
                                   0 /* no compact */ |
                                   0 /* no throw */);
}
 
DUK_EXTERNAL void duk_require_stack_top(duk_context *ctx, duk_idx_t top) {
    duk_hthread *thr;
    duk_size_t min_new_size;
 

◆ duk_require_string()

DUK_EXTERNAL const char * duk_require_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16250 of file duktape-1.8.0/src/duktape.c.

16254 {

◆ duk_require_top_index()

DUK_EXTERNAL duk_idx_t duk_require_top_index ( duk_context * ctx )

Definition at line 15455 of file duktape-1.8.0/src/duktape.c.

                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
    if (DUK_UNLIKELY(ret < 0)) {
        /* Return invalid index; if caller uses this without checking
         * in another API call, the index won't map to a valid stack
         * entry.
         */
        return DUK_INVALID_INDEX;

References DUK_ASSERT_CTX_VALID, DUK_INVALID_INDEX, DUK_UNLIKELY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

◆ duk_require_tval()

DUK_INTERNAL_DECL duk_tval * duk_require_tval	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15280 of file duktape-1.8.0/src/duktape.c.

                   {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        DUK_ASSERT(index != DUK_INVALID_INDEX);
        uindex = (duk_uidx_t) index;
    }
 
    /* DUK_INVALID_INDEX won't be accepted as a valid index. */
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
 
    if (DUK_LIKELY(uindex < vs_size)) {
        return thr->valstack_bottom + uindex;
    }
    return NULL;
}
 
DUK_INTERNAL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t uindex;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    DUK_ASSERT_DISABLE(vs_size >= 0);  /* unsigned */
 

References index.

Referenced by duk_dup_top(), duk_get_hobject_with_class(), duk_hobject_define_property_helper(), duk_hobject_define_property_internal(), duk_hobject_prepare_property_descriptor(), duk_hobject_putprop(), duk_remove(), duk_to_uint16(), and duk_to_uint32().

◆ duk_require_uint()

DUK_EXTERNAL duk_uint_t duk_require_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16193 of file duktape-1.8.0/src/duktape.c.

◆ duk_require_undefined()

DUK_EXTERNAL void duk_require_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16072 of file duktape-1.8.0/src/duktape.c.

                      {
            p--;
            DUK_TVAL_SET_UNDEFINED(p);
            /* XXX: fast primitive to set a bunch of values to UNDEFINED */
        }
    }
}
 

References DUK_TVAL_SET_UNDEFINED.

◆ duk_require_valid_index()

DUK_EXTERNAL void duk_require_valid_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15319 of file duktape-1.8.0/src/duktape.c.

                                      {
        return thr->valstack_bottom + uindex;
    }
    DUK_ERROR_API_INDEX(thr, index);
    return NULL;
}
 
/* Non-critical. */
DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);

References duk_hthread::valstack_bottom.

◆ duk_resize_buffer()

DUK_EXTERNAL void * duk_resize_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	new_size )

Definition at line 11581 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    DUK_DDD(DUK_DDDPRINT("default free function: %p", (void *) ptr));
    DUK_UNREF(udata);
    DUK_ANSI_FREE(ptr);
}
#endif  /* DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS */
#line 1 "duk_api_buffer.c"
/*
 *  Buffer
 */
 
/* include removed: duk_internal.h */
 
DUK_EXTERNAL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size) {

◆ duk_resume()

DUK_EXTERNAL void duk_resume	(	duk_context *	ctx,
		const duk_thread_state *	state )

Definition at line 14153 of file duktape-1.8.0/src/duktape.c.

14170 {

14171 duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_safe_call()

DUK_EXTERNAL duk_int_t duk_safe_call	(	duk_context *	ctx,
		duk_safe_call_function	func,
		duk_idx_t	nargs,
		duk_idx_t	nrets )

Definition at line 12586 of file duktape-1.8.0/src/duktape.c.

                                 {
        DUK_ERROR_API((duk_hthread *) ctx, DUK_STR_INVALID_CALL_ARGS);
    }
    duk_push_idx(ctx, nargs);
 
    /* Inputs: explicit arguments (nargs), +1 for key, +2 for obj_index/nargs passing.
     * If the value stack does not contain enough args, an error is thrown; this matches
     * behavior of the other protected call API functions.
     */
    return duk_safe_call(ctx, duk__pcall_prop_raw, nargs + 1 + 2 /*nargs*/, 1 /*nrets*/);
}
 
DUK_EXTERNAL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_int_t rc;

◆ duk_safe_to_lstring()

DUK_EXTERNAL const char * duk_safe_to_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 17064 of file duktape-1.8.0/src/duktape.c.

                                                                                                {
    DUK_ASSERT_CTX_VALID(ctx);
 
    (void) duk_to_string(ctx, index);
    return duk_require_lstring(ctx, index, out_len);
}
 
DUK_LOCAL duk_ret_t duk__safe_to_string_raw(duk_context *ctx) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_to_string(ctx, -1);
    return 1;
}
 
DUK_EXTERNAL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
 
    /* We intentionally ignore the duk_safe_call() return value and only
     * check the output type.  This way we don't also need to check that
     * the returned value is indeed a string in the success case.
     */
 
    duk_dup(ctx, index);
    (void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/);
    if (!duk_is_string(ctx, -1)) {
        /* Error: try coercing error to string once. */

◆ duk_set_finalizer()

DUK_EXTERNAL void duk_set_finalizer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14999 of file duktape-1.8.0/src/duktape.c.

◆ duk_set_global_object()

DUK_EXTERNAL void duk_set_global_object ( duk_context * ctx )

Definition at line 14174 of file duktape-1.8.0/src/duktape.c.

                                                          {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_glob;
    duk_hobject *h_prev_glob;
    duk_hobject *h_env;
    duk_hobject *h_prev_env;
 
    DUK_D(DUK_DPRINT("replace global object with: %!T", duk_get_tval(ctx, -1)));
 
    h_glob = duk_require_hobject(ctx, -1);
    DUK_ASSERT(h_glob != NULL);
 
    /*
     *  Replace global object.
     */
 
    h_prev_glob = thr->builtins[DUK_BIDX_GLOBAL];
    DUK_UNREF(h_prev_glob);
    thr->builtins[DUK_BIDX_GLOBAL] = h_glob;
    DUK_HOBJECT_INCREF(thr, h_glob);
    DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_glob);  /* side effects, in theory (referenced by global env) */
 
    /*
     *  Replace lexical environment for global scope
     *
     *  Create a new object environment for the global lexical scope.
     *  We can't just reset the _Target property of the current one,
     *  because the lexical scope is shared by other threads with the
     *  same (initial) built-ins.
     */
 
    (void) duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV),
                                  -1);  /* no prototype, updated below */
 
    duk_dup(ctx, -2);
    duk_dup(ctx, -3);
 
    /* [ ... new_glob new_env new_glob new_glob ] */
 
    duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
    duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);
 
    /* [ ... new_glob new_env ] */

◆ duk_set_length()

DUK_INTERNAL_DECL void duk_set_length	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	length )

Definition at line 16759 of file duktape-1.8.0/src/duktape.c.

                        :
#endif
    default:
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        return 0;
    }

◆ duk_set_magic()

DUK_EXTERNAL void duk_set_magic	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	magic )

Definition at line 12934 of file duktape-1.8.0/src/duktape.c.

                                                {
            goto type_error;
        }
        return (duk_int_t) ((duk_hnativefunction *) h)->magic;
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_small_uint_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
        return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);

◆ duk_set_prototype()

DUK_EXTERNAL void duk_set_prototype	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14958 of file duktape-1.8.0/src/duktape.c.

               {
        duk_push_hobject(ctx, proto);
    } else {
        duk_push_undefined(ctx);
    }
}
 
DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    duk_hobject *proto;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_require_hobject(ctx, index);

◆ duk_set_top()

DUK_EXTERNAL void duk_set_top	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15347 of file duktape-1.8.0/src/duktape.c.

                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
}
 
/* Set stack top within currently allocated range, but don't reallocate.
 * This is performance critical especially for call handling, so whenever
 * changing, profile and look at generated code.
 */
DUK_EXTERNAL void duk_set_top(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t vs_limit;
    duk_uidx_t uindex;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    vs_limit = (duk_uidx_t) (thr->valstack_end - thr->valstack_bottom);
 
    if (index < 0) {
        /* Negative indices are always within allocated stack but
         * must not go below zero index.
         */
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        /* Positive index can be higher than valstack top but must
         * not go above allocated stack (equality is OK).
         */
        uindex = (duk_uidx_t) index;
    }
 
    /* DUK_INVALID_INDEX won't be accepted as a valid index. */
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_limit);
 
#if defined(DUK_USE_VALSTACK_UNSAFE)
    DUK_ASSERT(uindex <= vs_limit);
    DUK_UNREF(vs_limit);
#else
    if (DUK_UNLIKELY(uindex > vs_limit)) {
        DUK_ERROR_API_INDEX(thr, index);
        return;  /* unreachable */
    }
#endif
    DUK_ASSERT(uindex <= vs_limit);
 
    /* Handle change in value stack top.  Respect value stack
     * initialization policy: 'undefined' above top.  Note that
     * DECREF may cause a side effect that reallocates valstack,
     * so must relookup after DECREF.
     */
 
    if (uindex >= vs_size) {
        /* Stack size increases or stays the same. */
#if defined(DUK_USE_ASSERTIONS)
        duk_uidx_t count;
 
        count = uindex - vs_size;
        while (count != 0) {
            count--;
            tv = thr->valstack_top + count;
            DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(tv));
        }
#endif
        thr->valstack_top = thr->valstack_bottom + uindex;
    } else {
        /* Stack size decreases. */
#if defined(DUK_USE_REFERENCE_COUNTING)
        duk_uidx_t count;
 
        count = vs_size - uindex;
        DUK_ASSERT(count > 0);
        while (count > 0) {
            count--;
            tv = --thr->valstack_top;  /* tv -> value just before prev top value; must relookup */
            DUK_ASSERT(tv >= thr->valstack_bottom);
            DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv);  /* side effects */

References DUK_ASSERT_CTX_VALID, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk_bi_string_constructor().

◆ duk_steal_buffer()

DUK_EXTERNAL void * duk_steal_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 11600 of file duktape-1.8.0/src/duktape.c.

                                                                       {
        DUK_ERROR_TYPE(thr, DUK_STR_WRONG_BUFFER_TYPE);
    }
 
    /* maximum size check is handled by callee */
    duk_hbuffer_resize(thr, h, new_size);
 
    return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h);
}
 
DUK_EXTERNAL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hbuffer_dynamic *h;
    void *ptr;
    duk_size_t sz;
 
    DUK_ASSERT(ctx != NULL);
 
    h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index);
    DUK_ASSERT(h != NULL);
 
    if (!(DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h))) {
        DUK_ERROR_TYPE(thr, DUK_STR_WRONG_BUFFER_TYPE);

◆ duk_strict_equals()

DUK_EXTERNAL duk_bool_t duk_strict_equals	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 19561 of file duktape-1.8.0/src/duktape.c.

                                        {
        return 0;
    }
 
    /* Coercion may be needed, the helper handles that by pushing the
     * tagged values to the stack.
     */

◆ duk_substring()

DUK_EXTERNAL void duk_substring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	start_offset,
		duk_size_t	end_offset )

Definition at line 19983 of file duktape-1.8.0/src/duktape.c.

                        {
            break;
        }
        cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
        cp = callback(udata, cp);
 
        DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp);
    }
 
    DUK_BW_COMPACT(thr, bw);
    duk_to_string(ctx, -1);
    duk_replace(ctx, index);
}
 
DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    duk_hstring *res;
    duk_size_t start_byte_offset;
    duk_size_t end_byte_offset;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    h = duk_require_hstring(ctx, index);
    DUK_ASSERT(h != NULL);
 
    if (end_offset >= DUK_HSTRING_GET_CHARLEN(h)) {
        end_offset = DUK_HSTRING_GET_CHARLEN(h);
    }
    if (start_offset > end_offset) {
        start_offset = end_offset;
    }
 
    DUK_ASSERT_DISABLE(start_offset >= 0);
    DUK_ASSERT(start_offset <= end_offset && start_offset <= DUK_HSTRING_GET_CHARLEN(h));
    DUK_ASSERT_DISABLE(end_offset >= 0);
    DUK_ASSERT(end_offset >= start_offset && end_offset <= DUK_HSTRING_GET_CHARLEN(h));
 
    /* guaranteed by string limits */

Referenced by duk__get_own_propdesc_raw().

◆ duk_suspend()

DUK_EXTERNAL void duk_suspend	(	duk_context *	ctx,
		duk_thread_state *	state )

Definition at line 14122 of file duktape-1.8.0/src/duktape.c.

                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
 
    if (!ctx) {
        return;
    }
    heap = thr->heap;
    DUK_ASSERT(heap != NULL);
 
    duk_heap_free(heap);
}
 
DUK_EXTERNAL void duk_suspend(duk_context *ctx, duk_thread_state *state) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_internal_thread_state *snapshot = (duk_internal_thread_state *) (void *) state;
    duk_heap *heap;
    duk_ljstate *lj;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(state != NULL);  /* unvalidated */
 
    heap = thr->heap;
    lj = &heap->lj;

◆ duk_swap()

DUK_EXTERNAL void duk_swap	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 15813 of file duktape-1.8.0/src/duktape.c.

◆ duk_swap_top()

DUK_EXTERNAL void duk_swap_top	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15831 of file duktape-1.8.0/src/duktape.c.

◆ duk_throw()

DUK_EXTERNAL void duk_throw ( duk_context * ctx )

Definition at line 19442 of file duktape-1.8.0/src/duktape.c.

                                              {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_pop_n(ctx, 2);
}
 
DUK_EXTERNAL void duk_pop_3(duk_context *ctx) {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_pop_n(ctx, 3);
}
 
/*
 *  Error throwing
 */
 
DUK_EXTERNAL void duk_throw(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
    if (thr->valstack_top == thr->valstack_bottom) {
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    }
 
    /* Errors are augmented when they are created, not when they are
     * thrown or re-thrown.  The current error handler, however, runs
     * just before an error is thrown.
     */
 
    /* Sync so that augmentation sees up-to-date activations, NULL
     * thr->ptr_curr_pc so that it's not used if side effects occur
     * in augmentation or longjmp handling.
     */
    duk_hthread_sync_and_null_currpc(thr);

◆ duk_to_boolean()

DUK_EXTERNAL duk_bool_t duk_to_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16879 of file duktape-1.8.0/src/duktape.c.

                                                                                      {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(hint == DUK_HINT_NONE || hint == DUK_HINT_NUMBER || hint == DUK_HINT_STRING);
 
    index = duk_require_normalize_index(ctx, index);
 
    if (!duk_check_type_mask(ctx, index, DUK_TYPE_MASK_OBJECT |
                                         DUK_TYPE_MASK_LIGHTFUNC)) {
        /* everything except object stay as is */
        return;
    }
    duk_to_defaultvalue(ctx, index, hint);
}
 
/* E5 Section 9.2 */
DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_bool_t val;

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_check_type_mask(), DUK_HINT_NONE, DUK_HINT_NUMBER, DUK_HINT_STRING, duk_require_normalize_index(), duk_to_defaultvalue(), DUK_TYPE_MASK_LIGHTFUNC, DUK_TYPE_MASK_OBJECT, and index.

Referenced by duk__put_prop_shared(), duk_bi_buffer_readfield(), duk_hobject_prepare_property_descriptor(), and duk_hobject_putprop().

◆ duk_to_buffer_raw()

DUK_EXTERNAL void * duk_to_buffer_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_uint_t	mode )

Definition at line 17321 of file duktape-1.8.0/src/duktape.c.

             :
    return duk_require_string(ctx, index);
}
 
DUK_INTERNAL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index) {
    duk_hstring *ret;
    DUK_ASSERT_CTX_VALID(ctx);
    duk_to_string(ctx, index);
    ret = duk_get_hstring(ctx, index);
    DUK_ASSERT(ret != NULL);
    return ret;
}
 
DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t mode) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hbuffer *h_buf;
    const duk_uint8_t *src_data;
    duk_size_t src_size;
    duk_uint8_t *dst_data;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    index = duk_require_normalize_index(ctx, index);
 
    h_buf = duk_get_hbuffer(ctx, index);
    if (h_buf != NULL) {
        /* Buffer is kept as is, with the fixed/dynamic nature of the
         * buffer only changed if requested.  An external buffer
         * is converted into a non-external dynamic buffer in a
         * duk_to_dynamic_buffer() call.
         */
        duk_uint_t tmp;
        duk_uint8_t *tmp_ptr;
 
        tmp_ptr = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf);
        src_data = (const duk_uint8_t *) tmp_ptr;
        src_size = DUK_HBUFFER_GET_SIZE(h_buf);
 
        tmp = (DUK_HBUFFER_HAS_DYNAMIC(h_buf) ? DUK_BUF_MODE_DYNAMIC : DUK_BUF_MODE_FIXED);
        if ((tmp == mode && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)) ||
            mode == DUK_BUF_MODE_DONTCARE) {
            /* Note: src_data may be NULL if input is a zero-size
             * dynamic buffer.
             */
            dst_data = tmp_ptr;
            goto skip_copy;
        }
    } else {
        /* Non-buffer value is first ToString() coerced, then converted
         * to a buffer (fixed buffer is used unless a dynamic buffer is
         * explicitly requested).
         */
 
        src_data = (const duk_uint8_t *) duk_to_lstring(ctx, index, &src_size);
    }
 

◆ duk_to_defaultvalue()

DUK_EXTERNAL void duk_to_defaultvalue	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	hint )

Definition at line 16800 of file duktape-1.8.0/src/duktape.c.

                                                                                                                      {
    if (duk_get_prop_stridx(ctx, index, func_stridx)) {
        /* [ ... func ] */
        if (duk_is_callable(ctx, -1)) {
            duk_dup(ctx, index);         /* -> [ ... func this ] */
            duk_call_method(ctx, 0);     /* -> [ ... retval ] */
            if (duk_is_primitive(ctx, -1)) {
                duk_replace(ctx, index);
                return 1;
            }
            /* [ ... retval ]; popped below */
        }
    }
    duk_pop(ctx);  /* [ ... func/retval ] -> [ ... ] */
    return 0;
}
 
DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    /* inline initializer for coercers[] is not allowed by old compilers like BCC */
    duk_small_int_t coercers[2];
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    coercers[0] = DUK_STRIDX_VALUE_OF;
    coercers[1] = DUK_STRIDX_TO_STRING;
 
    index = duk_require_normalize_index(ctx, index);
    obj = duk_require_hobject_or_lfunc(ctx, index);
 
    if (hint == DUK_HINT_NONE) {
        if (obj != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_DATE) {
            hint = DUK_HINT_STRING;
        } else {
            hint = DUK_HINT_NUMBER;
        }

References duk_call_method(), duk_dup(), duk_get_prop_stridx(), duk_is_callable, duk_is_primitive, duk_pop(), duk_replace(), and index.

Referenced by duk_to_boolean().

◆ duk_to_hstring()

DUK_INTERNAL_DECL duk_hstring * duk_to_hstring	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17312 of file duktape-1.8.0/src/duktape.c.

◆ duk_to_int()

DUK_EXTERNAL duk_int_t duk_to_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16944 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__init_varmap_and_prologue_for_pass2(), duk_bi_buffer_readfield(), and duk_bi_typedarray_set().

◆ duk_to_int32()

DUK_EXTERNAL duk_int32_t duk_to_int32	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16962 of file duktape-1.8.0/src/duktape.c.

                                                                       {
    /* Value coercion (in stack): ToInteger(), E5 Section 9.4
     * API return value coercion: custom
     */
    DUK_ASSERT_CTX_VALID(ctx);
    (void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger);
    return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/);
}

◆ duk_to_int_check_range()

DUK_INTERNAL_DECL duk_int_t duk_to_int_check_range	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	minval,
		duk_int_t	maxval )

Definition at line 17220 of file duktape-1.8.0/src/duktape.c.

                     {
        *out_clamped = clamped;
    } else {

◆ duk_to_int_clamped()

DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	minval,
		duk_int_t	maxval )

Definition at line 17215 of file duktape-1.8.0/src/duktape.c.

◆ duk_to_int_clamped_raw()

DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	minval,
		duk_int_t	maxval,
		duk_bool_t *	out_clamped )

Definition at line 17152 of file duktape-1.8.0/src/duktape.c.

                                                                                  {
    duk_hthread *thr;
    duk_hstring *h_strclass;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h);
    DUK_ASSERT(h_strclass != NULL);
    duk_push_sprintf(ctx, "[object %s]", (const char *) DUK_HSTRING_GET_DATA(h_strclass));
}
#endif  /* !DUK_USE_PARANOID_ERRORS */
 
/* XXX: other variants like uint, u32 etc */
DUK_INTERNAL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_tval tv_tmp;
    duk_double_t d, dmin, dmax;
    duk_int_t res;
    duk_bool_t clamped = 0;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    d = duk_js_tointeger(thr, tv);  /* E5 Section 9.4, ToInteger() */
 
    dmin = (duk_double_t) minval;
    dmax = (duk_double_t) maxval;
 
    if (d < dmin) {
        clamped = 1;
        res = minval;
        d = dmin;
    } else if (d > dmax) {
        clamped = 1;
        res = maxval;
        d = dmax;
    } else {
        res = (duk_int_t) d;
    }
    DUK_UNREF(d);  /* SCANBUILD: with suitable dmin/dmax limits 'd' is unused */
    /* 'd' and 'res' agree here */
 
    /* Relookup in case duk_js_tointeger() ends up e.g. coercing an object. */
    tv = duk_get_tval(ctx, index);
    DUK_ASSERT(tv != NULL);  /* not popped by side effect */
    DUK_TVAL_SET_TVAL(&tv_tmp, tv);
#if defined(DUK_USE_FASTINT)
#if (DUK_INT_MAX <= 0x7fffffffL)
    DUK_TVAL_SET_FASTINT_I32(tv, res);
#else
    /* Clamping needed if duk_int_t is 64 bits. */
    if (res >= DUK_FASTINT_MIN && res <= DUK_FASTINT_MAX) {
        DUK_TVAL_SET_FASTINT(tv, res);
    } else {
        DUK_TVAL_SET_NUMBER(tv, d);
    }

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_HOBJECT_GET_CLASS_STRING, DUK_HSTRING_GET_DATA, duk_push_sprintf(), DUK_UNREF, duk_hthread::heap, and NULL.

◆ duk_to_lstring()

DUK_EXTERNAL const char * duk_to_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 17050 of file duktape-1.8.0/src/duktape.c.

                  {
        /* Exact halfway, round to even. */
        ret = (duk_uint8_t) d;

Referenced by duk__base64_encode_helper().

◆ duk_to_null()

DUK_EXTERNAL void duk_to_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16851 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);

◆ duk_to_number()

DUK_EXTERNAL duk_double_t duk_to_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16901 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__error_getter_helper(), duk__fmin_fixed(), duk_bi_global_object_decode_uri(), duk_hobject_putprop(), and duk_lexer_parse_js_input_element().

◆ duk_to_object()

DUK_EXTERNAL void duk_to_object	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17434 of file duktape-1.8.0/src/duktape.c.

                        :
#endif
    default:
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        res = NULL;
        break;
    }
 
    duk_push_pointer(ctx, res);
    duk_replace(ctx, index);
    return res;
}
 
DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_uint_t flags = 0;   /* shared flags for a subset of types */
    duk_small_int_t proto = 0;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL: {
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_OBJECT_COERCIBLE);
        break;
    }
    case DUK_TAG_BOOLEAN: {
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BOOLEAN);
        proto = DUK_BIDX_BOOLEAN_PROTOTYPE;
        goto create_object;
    }
    case DUK_TAG_STRING: {
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ |
                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING);
        proto = DUK_BIDX_STRING_PROTOTYPE;
        goto create_object;
    }
    case DUK_TAG_OBJECT: {
        /* nop */
        break;
    }
    case DUK_TAG_BUFFER: {
        /* A plain buffer coerces to a Duktape.Buffer because it's the
         * object counterpart of the plain buffer value.  But it might
         * still make more sense to produce an ArrayBuffer here?
         */
 
        duk_hbufferobject *h_bufobj;
        duk_hbuffer *h_val;
 
        h_val = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h_val != NULL);
 
        h_bufobj = duk_push_bufferobject_raw(ctx,
                                             DUK_HOBJECT_FLAG_EXTENSIBLE |
                                             DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                             DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER),
                                             DUK_BIDX_BUFFER_PROTOTYPE);
        DUK_ASSERT(h_bufobj != NULL);
        DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE((duk_hobject *) h_bufobj));
        DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj));
 
        h_bufobj->buf = h_val;
        DUK_HBUFFER_INCREF(thr, h_val);
        DUK_ASSERT(h_bufobj->offset == 0);
        h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val);
        DUK_ASSERT(h_bufobj->shift == 0);
        DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8);
 
        DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
        goto replace_value;
    }
    case DUK_TAG_POINTER: {
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER);
        proto = DUK_BIDX_POINTER_PROTOTYPE;
        goto create_object;
    }
    case DUK_TAG_LIGHTFUNC: {
        /* Lightfunc coerces to a Function instance with concrete
         * properties.  Since 'length' is virtual for Duktape/C
         * functions, don't need to define that.
         *
         * The result is made extensible to mimic what happens to
         * strings:
         *   > Object.isExtensible(Object('foo'))
         *   true
         */
        duk_small_uint_t lf_flags;
        duk_idx_t nargs;
        duk_small_uint_t lf_len;
        duk_c_function func;
        duk_hnativefunction *nf;
 
        DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags);
 
        nargs = (duk_idx_t) DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
        if (nargs == DUK_LFUNC_NARGS_VARARGS) {
            nargs = (duk_idx_t) DUK_VARARGS;
        }
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_FLAG_CONSTRUCTABLE |
                DUK_HOBJECT_FLAG_NATIVEFUNCTION |
                    DUK_HOBJECT_FLAG_NEWENV |
                    DUK_HOBJECT_FLAG_STRICT |
                    DUK_HOBJECT_FLAG_NOTAIL |
            /* DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC: omitted here intentionally */
                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
        (void) duk__push_c_function_raw(ctx, func, nargs, flags);
 
        lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
        if ((duk_idx_t) lf_len != nargs) {
            /* Explicit length is only needed if it differs from 'nargs'. */
            duk_push_int(ctx, (duk_int_t) lf_len);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
        }
        duk_push_lightfunc_name(ctx, tv);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
 
        nf = duk_get_hnativefunction(ctx, -1);
        DUK_ASSERT(nf != NULL);
        nf->magic = (duk_int16_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
 
        /* Enable DUKFUNC exotic behavior once properties are set up. */
        DUK_HOBJECT_SET_EXOTIC_DUKFUNC((duk_hobject *) nf);
        goto replace_value;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_NUMBER);
        proto = DUK_BIDX_NUMBER_PROTOTYPE;
        goto create_object;
    }
    }
    return;

Referenced by duk_bi_object_getprototype_shared(), and duk_get_hobject_with_class().

◆ duk_to_object_class_string_top()

DUK_INTERNAL_DECL void duk_to_object_class_string_top ( duk_context * ctx )

Definition at line 17106 of file duktape-1.8.0/src/duktape.c.

                                                                                 {
    (void) duk_safe_to_string(ctx, index);
    DUK_ASSERT(duk_is_string(ctx, index));
    DUK_ASSERT(duk_get_hstring(ctx, index) != NULL);
    return duk_get_hstring(ctx, index);
}
#endif
 
/* Coerce top into Object.prototype.toString() output. */
DUK_INTERNAL void duk_to_object_class_string_top(duk_context *ctx) {
    duk_hthread *thr;
    duk_uint_t typemask;
    duk_hstring *h_strclass;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    typemask = duk_get_type_mask(ctx, -1);
    if (typemask & DUK_TYPE_MASK_UNDEFINED) {

◆ duk_to_pointer()

DUK_EXTERNAL void * duk_to_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17383 of file duktape-1.8.0/src/duktape.c.

                                  {
        /* When src_size == 0, src_data may be NULL (if source
         * buffer is dynamic), and dst_data may be NULL (if
         * target buffer is dynamic).  Avoid zero-size memcpy()
         * with an invalid pointer.
         */
        DUK_MEMCPY((void *) dst_data, (const void *) src_data, (size_t) src_size);
    }
    duk_replace(ctx, index);
 skip_copy:
 
    if (out_size) {
        *out_size = src_size;
    }
    return dst_data;
}
 
DUK_EXTERNAL void *duk_to_pointer(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
    void *res;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
    case DUK_TAG_BOOLEAN:
        res = NULL;
        break;
    case DUK_TAG_POINTER:
        res = DUK_TVAL_GET_POINTER(tv);
        break;
    case DUK_TAG_STRING:
    case DUK_TAG_OBJECT:
    case DUK_TAG_BUFFER:
        /* Heap allocated: return heap pointer which is NOT useful
         * for the caller, except for debugging.
         */
        res = (void *) DUK_TVAL_GET_HEAPHDR(tv);
        break;
    case DUK_TAG_LIGHTFUNC:
        /* Function pointers do not always cast correctly to void *
         * (depends on memory and segmentation model for instance),
         * so they coerce to NULL.
         */

References DUK_MEMCPY.

◆ duk_to_primitive()

DUK_EXTERNAL void duk_to_primitive	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	hint )

Definition at line 16864 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);

◆ duk_to_string()

DUK_EXTERNAL const char * duk_to_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17224 of file duktape-1.8.0/src/duktape.c.

                     {
            DUK_ERROR_RANGE(thr, DUK_STR_NUMBER_OUTSIDE_RANGE);
        }
    }
 
    return res;
}
 
DUK_INTERNAL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_idx_t minval, duk_idx_t maxval) {
    duk_bool_t dummy;
    return duk_to_int_clamped_raw(ctx, index, minval, maxval, &dummy);
}
 
DUK_INTERNAL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval) {
    return duk_to_int_clamped_raw(ctx, index, minval, maxval, NULL);  /* out_clamped==NULL -> RangeError if outside range */
}
 
DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    index = duk_require_normalize_index(ctx, index);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED: {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED);
        break;
    }
    case DUK_TAG_NULL: {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL);
        break;
    }
    case DUK_TAG_BOOLEAN: {
        if (DUK_TVAL_GET_BOOLEAN(tv)) {
            duk_push_hstring_stridx(ctx, DUK_STRIDX_TRUE);
        } else {
            duk_push_hstring_stridx(ctx, DUK_STRIDX_FALSE);
        }
        break;
    }
    case DUK_TAG_STRING: {
        /* nop */
        goto skip_replace;
    }
    case DUK_TAG_OBJECT: {
        duk_to_primitive(ctx, index, DUK_HINT_STRING);
        return duk_to_string(ctx, index);  /* Note: recursive call */
    }
    case DUK_TAG_BUFFER: {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
 
        /* Note: this allows creation of internal strings. */
 
        DUK_ASSERT(h != NULL);
        duk_push_lstring(ctx,
                         (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h),
                         (duk_size_t) DUK_HBUFFER_GET_SIZE(h));
        break;
    }
    case DUK_TAG_POINTER: {
        void *ptr = DUK_TVAL_GET_POINTER(tv);
        if (ptr != NULL) {
            duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) ptr);
        } else {
            /* Represent a null pointer as 'null' to be consistent with
             * the JX format variant.  Native '%p' format for a NULL
             * pointer may be e.g. '(nil)'.
             */
            duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL);
        }
        break;
    }
    case DUK_TAG_LIGHTFUNC: {
        /* Should match Function.prototype.toString() */
        duk_push_lightfunc_tostring(ctx, tv);
        break;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {

References DUK_ERROR_RANGE, and DUK_STR_NUMBER_OUTSIDE_RANGE.

Referenced by duk__create_escaped_source(), duk_bi_proxy_constructor(), and duk_bi_string_constructor().

◆ duk_to_uint()

DUK_EXTERNAL duk_uint_t duk_to_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16953 of file duktape-1.8.0/src/duktape.c.

◆ duk_to_uint16()

DUK_EXTERNAL duk_uint16_t duk_to_uint16	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16996 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_uint32_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    ret = duk_js_touint32(thr, tv);
 
    /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
    tv = duk_require_tval(ctx, index);
    DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv, ret);  /* side effects */
    return ret;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_touint32(), duk_require_tval(), DUK_TVAL_SET_FASTINT_U32_UPDREF, index, and NULL.

◆ duk_to_uint32()

DUK_EXTERNAL duk_uint32_t duk_to_uint32	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16979 of file duktape-1.8.0/src/duktape.c.

                                                                         {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_int32_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    ret = duk_js_toint32(thr, tv);
 
    /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
    tv = duk_require_tval(ctx, index);
    DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv, ret);  /* side effects */
    return ret;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_toint32(), duk_require_tval(), DUK_TVAL_SET_FASTINT_I32_UPDREF, index, and NULL.

Referenced by duk__push_this_obj_len_u32_limited(), and duk_hobject_putprop().

◆ duk_to_uint8clamped()

DUK_INTERNAL_DECL duk_uint8_t duk_to_uint8clamped	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17015 of file duktape-1.8.0/src/duktape.c.

                                                                                {
    duk_double_t d;
    duk_double_t t;
    duk_uint8_t ret;
 
    /* XXX: Simplify this algorithm, should be possible to come up with
     * a shorter and faster algorithm by inspecting IEEE representation
     * directly.
     */
 
    d = duk_to_number(ctx, index);
    if (d <= 0.0) {
        return 0;
    } else if (d >= 255) {
        return 255;
    } else if (DUK_ISNAN(d)) {

◆ duk_to_undefined()

DUK_EXTERNAL void duk_to_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16839 of file duktape-1.8.0/src/duktape.c.

                                 {
        coercers[0] = DUK_STRIDX_TO_STRING;
        coercers[1] = DUK_STRIDX_VALUE_OF;
    }
 
    if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[0])) {
        return;
    }
 
    if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[1])) {

References DUK_STRIDX_TO_STRING, and DUK_STRIDX_VALUE_OF.

Referenced by duk_lexer_parse_js_input_element().

◆ duk_trim()

DUK_EXTERNAL void duk_trim	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 20030 of file duktape-1.8.0/src/duktape.c.

                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    const duk_uint8_t *p, *p_start, *p_end, *p_tmp1, *p_tmp2;  /* pointers for scanning */
    const duk_uint8_t *q_start, *q_end;  /* start (incl) and end (excl) of trimmed part */
    duk_codepoint_t cp;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    h = duk_require_hstring(ctx, index);
    DUK_ASSERT(h != NULL);
 
    p_start = DUK_HSTRING_GET_DATA(h);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h);
 
    p = p_start;
    while (p < p_end) {
        p_tmp1 = p;
        cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp1, p_start, p_end);
        if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) {
            break;
        }
        p = p_tmp1;
    }
    q_start = p;
    if (p == p_end) {
        /* entire string is whitespace */
        q_end = p;
        goto scan_done;
    }
 
    p = p_end;
    while (p > p_start) {
        p_tmp1 = p;
        while (p > p_start) {
            p--;
            if (((*p) & 0xc0) != 0x80) {
                break;
            }
        }
        p_tmp2 = p;
 
        cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp2, p_start, p_end);
        if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) {
            p = p_tmp1;
            break;
        }
    }
    q_end = p;
 
 scan_done:
    /* This may happen when forward and backward scanning disagree
     * (possible for non-extended-UTF-8 strings).
     */
    if (q_end < q_start) {
        q_end = q_start;
    }

◆ duk_tval_decref()

DUK_INTERNAL_DECL void duk_tval_decref	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 44606 of file duktape-1.8.0/src/duktape.c.

                                                          {
    if (tv == NULL) {
        return;
    }
    if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)) {
        duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(h != NULL);
        DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));

References DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_HEAPHDR_HTYPE_VALID, DUK_HEAPHDR_PREINC_REFCOUNT, DUK_TVAL_GET_HEAPHDR, DUK_TVAL_NEEDS_REFCOUNT_UPDATE, duk_heaphdr::h_refcount, and NULL.

◆ duk_unicode_case_convert_string()

DUK_INTERNAL_DECL void duk_unicode_case_convert_string	(	duk_hthread *	thr,
		duk_bool_t	uppercase )

Definition at line 10934 of file duktape-1.8.0/src/duktape.c.

           :
    if (bw != NULL) {
        DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp);
    }
    return cp;
 
 /* unused now, not needed until Turkish/Azeri */
#if 0
 nochar:
    return -1;
#endif
}
 
/*
 *  Replace valstack top with case converted version.
 */
 
DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_int_t uppercase) {
    duk_context *ctx = (duk_context *) thr;
    duk_hstring *h_input;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_codepoint_t prev, curr, next;
 
    h_input = duk_require_hstring(ctx, -1);
    DUK_ASSERT(h_input != NULL);
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input));
 
    /* [ ... input buffer ] */
 
    p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
    p = p_start;
 
    prev = -1; DUK_UNREF(prev);
    curr = -1;
    next = -1;
    for (;;) {
        prev = curr;
        curr = next;
        next = -1;
        if (p < p_end) {
            next = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
        } else {
            /* end of input and last char has been processed */
            if (curr < 0) {
                break;
            }
        }
 
        /* on first round, skip */
        if (curr >= 0) {
            /* XXX: could add a fast path to process chunks of input codepoints,
             * but relative benefit would be quite small.
             */

References DUK_BW_WRITE_RAW_XUTF8.

Referenced by duk_bi_string_prototype_indexof_shared().

◆ duk_unicode_decode_xutf8()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_decode_xutf8	(	duk_hthread *	thr,
		const duk_uint8_t **	ptr,
		const duk_uint8_t *	ptr_start,
		const duk_uint8_t *	ptr_end,
		duk_ucodepoint_t *	out_cp )

Definition at line 10114 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                                                     {
    const duk_uint8_t *p;
    duk_uint32_t res;
    duk_uint_fast8_t ch;
    duk_small_int_t n;
 
    DUK_UNREF(thr);
 
    p = *ptr;
    if (p < ptr_start || p >= ptr_end) {
        goto fail;
    }
 
    /*
     *  UTF-8 decoder which accepts longer than standard byte sequences.
     *  This allows full 32-bit code points to be used.
     */
 
    ch = (duk_uint_fast8_t) (*p++);
    if (ch < 0x80) {
        /* 0xxx xxxx   [7 bits] */
        res = (duk_uint32_t) (ch & 0x7f);
        n = 0;
    } else if (ch < 0xc0) {
        /* 10xx xxxx -> invalid */
        goto fail;
    } else if (ch < 0xe0) {
        /* 110x xxxx   10xx xxxx   [11 bits] */
        res = (duk_uint32_t) (ch & 0x1f);
        n = 1;
    } else if (ch < 0xf0) {
        /* 1110 xxxx   10xx xxxx   10xx xxxx   [16 bits] */
        res = (duk_uint32_t) (ch & 0x0f);
        n = 2;
    } else if (ch < 0xf8) {
        /* 1111 0xxx   10xx xxxx   10xx xxxx   10xx xxxx   [21 bits] */
        res = (duk_uint32_t) (ch & 0x07);
        n = 3;
    } else if (ch < 0xfc) {
        /* 1111 10xx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [26 bits] */
        res = (duk_uint32_t) (ch & 0x03);
        n = 4;
    } else if (ch < 0xfe) {
        /* 1111 110x   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [31 bits] */
        res = (duk_uint32_t) (ch & 0x01);
        n = 5;
    } else if (ch < 0xff) {
        /* 1111 1110   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [36 bits] */
        res = (duk_uint32_t) (0);
        n = 6;
    } else {
        /* 8-byte format could be:
         * 1111 1111   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [41 bits]
         *
         * However, this format would not have a zero bit following the
         * leading one bits and would not allow 0xFF to be used as an
         * "invalid xutf-8" marker for internal keys.  Further, 8-byte
         * encodings (up to 41 bit code points) are not currently needed.
         */
        goto fail;
    }
 
    DUK_ASSERT(p >= ptr_start);  /* verified at beginning */
    if (p + n > ptr_end) {
        /* check pointer at end */

◆ duk_unicode_decode_xutf8_checked()

DUK_INTERNAL_DECL duk_ucodepoint_t duk_unicode_decode_xutf8_checked	(	duk_hthread *	thr,
		const duk_uint8_t **	ptr,
		const duk_uint8_t *	ptr_start,
		const duk_uint8_t *	ptr_end )

Definition at line 10198 of file duktape-1.8.0/src/duktape.c.

                  {
        DUK_ASSERT(p >= ptr_start && p < ptr_end);
        res = res << 6;
        res += (duk_uint32_t) ((*p++) & 0x3f);
        n--;
    }
 
    *ptr = p;
    *out_cp = res;

References DUK_ASSERT.

Referenced by duk__inp_get_prev_cp(), duk__utf8_backtrack(), and duk_hstring_char_code_at_raw().

◆ duk_unicode_encode_cesu8()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8	(	duk_ucodepoint_t	cp,
		duk_uint8_t *	out )

Definition at line 10054 of file duktape-1.8.0/src/duktape.c.

               {
            /* Note: masking of 'x' is not necessary because of
             * range check and shifting -> no bits overlapping
             * the marker should be set.
             */
            out[0] = (duk_uint8_t) (marker + x);
        }
    } while (i > 0);
 
    return len;
}
 
/* Encode to CESU-8; 'out' must have space for at least
 * DUK_UNICODE_MAX_CESU8_LENGTH bytes; codepoints above U+10FFFF
 * will encode to garbage but won't overwrite the output buffer.
 */
DUK_INTERNAL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out) {
    duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
    duk_small_int_t len;
 
    if (x < 0x80UL) {
        out[0] = (duk_uint8_t) x;
        len = 1;
    } else if (x < 0x800UL) {
        out[0] = (duk_uint8_t) (0xc0 + ((x >> 6) & 0x1f));
        out[1] = (duk_uint8_t) (0x80 + (x & 0x3f));
        len = 2;
    } else if (x < 0x10000UL) {
        /* surrogate pairs get encoded here */
        out[0] = (duk_uint8_t) (0xe0 + ((x >> 12) & 0x0f));
        out[1] = (duk_uint8_t) (0x80 + ((x >> 6) & 0x3f));
        out[2] = (duk_uint8_t) (0x80 + (x & 0x3f));
        len = 3;
    } else {
        /*
         *  Unicode codepoints above U+FFFF are encoded as surrogate
         *  pairs here.  This ensures that all CESU-8 codepoints are
         *  16-bit values as expected in Ecmascript.  The surrogate
         *  pairs always get a 3-byte encoding (each) in CESU-8.
         *  See: http://en.wikipedia.org/wiki/Surrogate_pair
         *
         *  20-bit codepoint, 10 bits (A and B) per surrogate pair:
         *
         *    x = 0b00000000 0000AAAA AAAAAABB BBBBBBBB
         *  sp1 = 0b110110AA AAAAAAAA  (0xd800 + ((x >> 10) & 0x3ff))
         *  sp2 = 0b110111BB BBBBBBBB  (0xdc00 + (x & 0x3ff))
         *
         *  Encoded into CESU-8:
         *
         *  sp1 -> 0b11101101  (0xe0 + ((sp1 >> 12) & 0x0f))
         *      -> 0b1010AAAA  (0x80 + ((sp1 >> 6) & 0x3f))
         *      -> 0b10AAAAAA  (0x80 + (sp1 & 0x3f))
         *  sp2 -> 0b11101101  (0xe0 + ((sp2 >> 12) & 0x0f))
         *      -> 0b1011BBBB  (0x80 + ((sp2 >> 6) & 0x3f))
         *      -> 0b10BBBBBB  (0x80 + (sp2 & 0x3f))
         *
         *  Note that 0x10000 must be subtracted first.  The code below

◆ duk_unicode_encode_xutf8()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8	(	duk_ucodepoint_t	cp,
		duk_uint8_t *	out )

Definition at line 10020 of file duktape-1.8.0/src/duktape.c.

                                                              {
    0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
};
 
/* Encode to extended UTF-8; 'out' must have space for at least
 * DUK_UNICODE_MAX_XUTF8_LENGTH bytes.  Allows encoding of any
 * 32-bit (unsigned) codepoint.
 */
DUK_INTERNAL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out) {
    duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
    duk_small_int_t len;
    duk_uint8_t marker;
    duk_small_int_t i;
 
    len = duk_unicode_get_xutf8_length(cp);
    DUK_ASSERT(len > 0);
 
    marker = duk_unicode_xutf8_markers[len - 1];  /* 64-bit OK because always >= 0 */
 
    i = len;

◆ duk_unicode_get_xutf8_length()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length ( duk_ucodepoint_t cp )

Definition at line 9964 of file duktape-1.8.0/src/duktape.c.

         : IdentifierPart only
     */
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x00...0x0f */
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x10...0x1f */
    0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x20...0x2f */
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  0,  0,  0,  0,  0,   /* 0x30...0x3f */
    0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,   /* 0x40...0x4f */
    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  1,   /* 0x50...0x5f */
    0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,   /* 0x60...0x6f */
    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0    /* 0x70...0x7f */
};
#endif
 
/*
 *  XUTF-8 and CESU-8 encoding/decoding
 */
 
DUK_INTERNAL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp) {
    duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
    if (x < 0x80UL) {
        /* 7 bits */
        return 1;
    } else if (x < 0x800UL) {
        /* 11 bits */
        return 2;

Referenced by duk__append_jump_offset().

◆ duk_unicode_is_identifier_part()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_part ( duk_codepoint_t cp )

Definition at line 10567 of file duktape-1.8.0/src/duktape.c.

                                                        {
            return 1;
        }
        return 0;
    } else {
        /* without explicit non-BMP support, assume non-BMP characters
         * are always accepted as identifier characters.
         */
        return 1;
    }
#endif
}
 
/*
 *  "IdentifierPart" production check.
 */
 
DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp) {
    /*
     *  E5 Section 7.6:
     *
     *    IdentifierPart:
     *      IdentifierStart
     *      UnicodeCombiningMark
     *      UnicodeDigit
     *      UnicodeConnectorPunctuation
     *      <ZWNJ>  [U+200C]
     *      <ZWJ>   [U+200D]
     *
     *  IdentifierPart production has one multi-character production
     *  as part of its IdentifierStart alternative.  The '\' character
     *  of an escape sequence is not matched here, see discussion in
     *  duk_unicode_is_identifier_start().
     *
     *  To match non-ASCII characters (codepoints >= 0x80), a very slow
     *  linear range-by-range scan is used.  The codepoint is first compared
     *  to the IdentifierStart ranges, and if it doesn't match, then to a
     *  set consisting of code points in IdentifierPart but not in
     *  IdentifierStart.  This is done to keep the unicode range data small,
     *  at the expense of speed.
     *
     *  The ASCII fast path consists of:
     *
     *    0x0030 ... 0x0039     ['0' ... '9', UnicodeDigit]
     *    0x0041 ... 0x005a     ['A' ... 'Z', IdentifierStart]
     *    0x0061 ... 0x007a     ['a' ... 'z', IdentifierStart]
     *    0x0024                ['$', IdentifierStart]
     *    0x005f                ['_', IdentifierStart and
     *                                UnicodeConnectorPunctuation]
     *
     *  UnicodeCombiningMark has no code points <= 0x7f.
     *
     *  The matching code reuses the "identifier start" tables, and then
     *  consults a separate range set for characters in "identifier part"
     *  but not in "identifier start".  These can be extracted with the
     *  "src/extract_chars.py" script.
     *
     *  UnicodeCombiningMark -> categories Mn, Mc
     *  UnicodeDigit -> categories Nd
     *  UnicodeConnectorPunctuation -> categories Pc
     */
 
    /* ASCII (and EOF) fast path -- quick accept and reject */
    if (cp <= 0x7fL) {
#if defined(DUK_USE_IDCHAR_FASTPATH)
        return (cp >= 0) && (duk_is_idchar_tab[cp] != 0);
#else
        if ((cp >= 'a' && cp <= 'z') ||
            (cp >= 'A' && cp <= 'Z') ||
            (cp >= '0' && cp <= '9') ||
            cp == '_' || cp == '$') {
            return 1;
        }
        return 0;
#endif
    }
 
    /* Non-ASCII slow path (range-by-range linear comparison), very slow */
 
#ifdef DUK_USE_SOURCE_NONBMP
    if (duk__uni_range_match(duk_unicode_ids_noa,
                             sizeof(duk_unicode_ids_noa),
                             (duk_codepoint_t) cp) ||
        duk__uni_range_match(duk_unicode_idp_m_ids_noa,
                             sizeof(duk_unicode_idp_m_ids_noa),
                             (duk_codepoint_t) cp)) {
        return 1;
    }
    return 0;
#else
    if (cp < 0x10000L) {

Referenced by duk_lexer_parse_js_input_element().

◆ duk_unicode_is_identifier_start()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start ( duk_codepoint_t cp )

Definition at line 10488 of file duktape-1.8.0/src/duktape.c.

                       {
        return 1;
    }
 
    return 0;
}
 
/*
 *  "IdentifierStart" production check.
 */
 
DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp) {
    /*
     *  E5 Section 7.6:
     *
     *    IdentifierStart:
     *      UnicodeLetter
     *      $
     *      _
     *      \ UnicodeEscapeSequence
     *
     *  IdentifierStart production has one multi-character production:
     *
     *    \ UnicodeEscapeSequence
     *
     *  The '\' character is -not- matched by this function.  Rather, the caller
     *  should decode the escape and then call this function to check whether the
     *  decoded character is acceptable (see discussion in E5 Section 7.6).
     *
     *  The "UnicodeLetter" alternative of the production allows letters
     *  from various Unicode categories.  These can be extracted with the
     *  "src/extract_chars.py" script.
     *
     *  Because the result has hundreds of Unicode codepoint ranges, matching
     *  for any values >= 0x80 are done using a very slow range-by-range scan
     *  and a packed range format.
     *
     *  The ASCII portion (codepoints 0x00 ... 0x7f) is fast-pathed below because
     *  it matters the most.  The ASCII related ranges of IdentifierStart are:
     *
     *    0x0041 ... 0x005a     ['A' ... 'Z']
     *    0x0061 ... 0x007a     ['a' ... 'z']
     *    0x0024                ['$']
     *    0x005f                ['_']
     */
 
    /* ASCII (and EOF) fast path -- quick accept and reject */
    if (cp <= 0x7fL) {
#if defined(DUK_USE_IDCHAR_FASTPATH)
        return (cp >= 0) && (duk_is_idchar_tab[cp] > 0);
#else
        if ((cp >= 'a' && cp <= 'z') ||
            (cp >= 'A' && cp <= 'Z') ||
            cp == '_' || cp == '$') {
            return 1;
        }
        return 0;
#endif
    }
 
    /* Non-ASCII slow path (range-by-range linear comparison), very slow */
 
#ifdef DUK_USE_SOURCE_NONBMP
    if (duk__uni_range_match(duk_unicode_ids_noa,
                             (duk_size_t) sizeof(duk_unicode_ids_noa),
                             (duk_codepoint_t) cp)) {
        return 1;
    }

Referenced by duk_lexer_parse_js_input_element().

◆ duk_unicode_is_letter()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter ( duk_codepoint_t cp )

Definition at line 10663 of file duktape-1.8.0/src/duktape.c.

                                                        {
            return 1;
        }
        return 0;
    } else {
        /* without explicit non-BMP support, assume non-BMP characters
         * are always accepted as identifier characters.
         */
        return 1;
    }
#endif
}
 
/*
 *  Unicode letter check.
 */
 
DUK_INTERNAL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp) {
    /*
     *  Unicode letter is now taken to be the categories:
     *
     *    Lu, Ll, Lt, Lm, Lo
     *
     *  (Not sure if this is exactly correct.)
     *
     *  The ASCII fast path consists of:
     *
     *    0x0041 ... 0x005a     ['A' ... 'Z']
     *    0x0061 ... 0x007a     ['a' ... 'z']
     */
 
    /* ASCII (and EOF) fast path -- quick accept and reject */
    if (cp <= 0x7fL) {
        if ((cp >= 'a' && cp <= 'z') ||
            (cp >= 'A' && cp <= 'Z')) {
            return 1;
        }
        return 0;
    }
 
    /* Non-ASCII slow path (range-by-range linear comparison), very slow */
 
#ifdef DUK_USE_SOURCE_NONBMP
    if (duk__uni_range_match(duk_unicode_ids_noa,
                             sizeof(duk_unicode_ids_noa),
                             (duk_codepoint_t) cp) &&
        !duk__uni_range_match(duk_unicode_ids_m_let_noa,
                              sizeof(duk_unicode_ids_m_let_noa),
                              (duk_codepoint_t) cp)) {
        return 1;
    }
    return 0;
#else
    if (cp < 0x10000L) {

◆ duk_unicode_is_line_terminator()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator ( duk_codepoint_t cp )

Definition at line 10468 of file duktape-1.8.0/src/duktape.c.

                               {
        if (lo <= 0x0aU || lo == 0x2fU || lo == 0x5fU) {
            return 1;
        }
    } else if (cp == 0x1680L || cp == 0x180eL || cp == 0x3000L ||
               cp == 0xfeffL) {
        return 1;
    }
 
    return 0;
}
 
/*
 *  "LineTerminator" production check.

Referenced by duk_lexer_parse_js_input_element().

◆ duk_unicode_is_whitespace()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_whitespace ( duk_codepoint_t cp )

Definition at line 10388 of file duktape-1.8.0/src/duktape.c.

                                                  : cp=%06lx range=[0x%06lx,0x%06lx]",
                             (unsigned long) cp, (unsigned long) r1, (unsigned long) r2));
        if (cp >= r1 && cp <= r2) {
            return 1;
        }
    }
 
    return 0;
}
 
/*
 *  "WhiteSpace" production check.
 */
 
DUK_INTERNAL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp) {
    /*
     *  E5 Section 7.2 specifies six characters specifically as
     *  white space:
     *
     *    0009;<control>;Cc;0;S;;;;;N;CHARACTER TABULATION;;;;
     *    000B;<control>;Cc;0;S;;;;;N;LINE TABULATION;;;;
     *    000C;<control>;Cc;0;WS;;;;;N;FORM FEED (FF);;;;
     *    0020;SPACE;Zs;0;WS;;;;;N;;;;;
     *    00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
     *    FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;;
     *
     *  It also specifies any Unicode category 'Zs' characters as white
     *  space.  These can be extracted with the "src/extract_chars.py" script.
     *  Current result:
     *
     *    RAW OUTPUT:
     *    ===========
     *    0020;SPACE;Zs;0;WS;;;;;N;;;;;
     *    00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
     *    1680;OGHAM SPACE MARK;Zs;0;WS;;;;;N;;;;;
     *    180E;MONGOLIAN VOWEL SEPARATOR;Zs;0;WS;;;;;N;;;;;
     *    2000;EN QUAD;Zs;0;WS;2002;;;;N;;;;;
     *    2001;EM QUAD;Zs;0;WS;2003;;;;N;;;;;
     *    2002;EN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    2003;EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    2004;THREE-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    2005;FOUR-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    2006;SIX-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    2007;FIGURE SPACE;Zs;0;WS;<noBreak> 0020;;;;N;;;;;
     *    2008;PUNCTUATION SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    2009;THIN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    200A;HAIR SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    202F;NARROW NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;;;;;
     *    205F;MEDIUM MATHEMATICAL SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
     *    3000;IDEOGRAPHIC SPACE;Zs;0;WS;<wide> 0020;;;;N;;;;;
     *
     *    RANGES:
     *    =======
     *    0x0020
     *    0x00a0
     *    0x1680
     *    0x180e
     *    0x2000 ... 0x200a
     *    0x202f
     *    0x205f
     *    0x3000
     *
     *  A manual decoder (below) is probably most compact for this.
     */
 
    duk_uint_fast8_t lo;
    duk_uint_fast32_t hi;
 
    /* cp == -1 (EOF) never matches and causes return value 0 */
 
    lo = (duk_uint_fast8_t) (cp & 0xff);
    hi = (duk_uint_fast32_t) (cp >> 8);  /* does not fit into an uchar */

Referenced by duk_lexer_parse_js_input_element().

◆ duk_unicode_re_canonicalize_char()

DUK_INTERNAL_DECL duk_codepoint_t duk_unicode_re_canonicalize_char	(	duk_hthread *	thr,
		duk_codepoint_t	cp )

Definition at line 11002 of file duktape-1.8.0/src/duktape.c.

                                                                                                    {
#if defined(DUK_USE_REGEXP_CANON_WORKAROUND)
    /* Fast canonicalization lookup at the cost of 128kB footprint. */
    DUK_ASSERT(cp >= 0);
    DUK_UNREF(thr);
    if (DUK_LIKELY(cp < 0x10000L)) {
        return (duk_codepoint_t) duk_unicode_re_canon_lookup[cp];
    }
    return cp;
#else  /* DUK_USE_REGEXP_CANON_WORKAROUND */
    duk_codepoint_t y;
 

Referenced by duk__generate_ranges(), duk__inp_get_prev_cp(), and duk__parse_disjunction().

◆ duk_unicode_re_is_wordchar()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar ( duk_codepoint_t cp )

Definition at line 11037 of file duktape-1.8.0/src/duktape.c.

                                             {
        /* multiple codepoint conversion or non-ASCII mapped to ASCII
         * --> leave as is.
         */
        return cp;
    }
 
    return y;
#endif  /* DUK_USE_REGEXP_CANON_WORKAROUND */
}
 
/*

◆ duk_unicode_unvalidated_utf8_length()

DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length	(	const duk_uint8_t *	data,
		duk_size_t	blen )

Definition at line 10250 of file duktape-1.8.0/src/duktape.c.

                       {
        duk_uint8_t x;
        x = *p++;
        if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) {
            ncont++;
        }
    }
 
    DUK_ASSERT(ncont <= blen);
    clen = blen - ncont;
    DUK_ASSERT(clen <= blen);
    return clen;
}
#else  /* DUK_USE_PREFER_SIZE */
/* This seems like a good overall approach.  Fast path for ASCII in 4 byte
 * blocks.
 */
DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) {
    const duk_uint8_t *p;
    const duk_uint8_t *p_end;
    const duk_uint32_t *p32_end;
    const duk_uint32_t *p32;
    duk_size_t ncont;
    duk_size_t clen;
 
    ncont = 0;  /* number of continuation (non-initial) bytes in [0x80,0xbf] */
    p = data;
    p_end = data + blen;
    if (blen < 16) {
        goto skip_fastpath;
    }
 
    /* Align 'p' to 4; the input data may have arbitrary alignment.
     * End of string check not needed because blen >= 16.
     */
    while (((duk_size_t) (const void *) p) & 0x03U) {
        duk_uint8_t x;
        x = *p++;
        if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) {
            ncont++;
        }
    }
 
    /* Full, aligned 4-byte reads. */
    p32_end = (const duk_uint32_t *) (const void *) (p + ((duk_size_t) (p_end - p) & (duk_size_t) (~0x03)));
    p32 = (const duk_uint32_t *) (const void *) p;
    while (p32 != (const duk_uint32_t *) p32_end) {
        duk_uint32_t x;
        x = *p32++;
        if (DUK_LIKELY((x & 0x80808080UL) == 0)) {
            ;  /* ASCII fast path */
        } else {
            /* Flip highest bit of each byte which changes
             * the bit pattern 10xxxxxx into 00xxxxxx which
             * allows an easy bit mask test.
             */
            x ^= 0x80808080UL;
            if (DUK_UNLIKELY(!(x & 0xc0000000UL))) {
                ncont++;
            }
            if (DUK_UNLIKELY(!(x & 0x00c00000UL))) {
                ncont++;
            }
            if (DUK_UNLIKELY(!(x & 0x0000c000UL))) {
                ncont++;
            }
            if (DUK_UNLIKELY(!(x & 0x000000c0UL))) {
                ncont++;
            }
        }
    }

References DUK_UNLIKELY.

Referenced by duk__alloc_init_hstring().

◆ duk_util_get_hash_prime()

DUK_INTERNAL_DECL duk_uint32_t duk_util_get_hash_prime ( duk_uint32_t size )

Definition at line 11373 of file duktape-1.8.0/src/duktape.c.

                                                    {
    2, 3, 5, 7, 11, 13, 19, 31, 41, 47, 59, 67, 73, 79, 89, 101, 103, 107,
    109, 127, 137, 139, 149, 157, 163, 167, 173, 181, 191, 193, 197, 199
};
 
DUK_INTERNAL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size) {
    const duk_int8_t *p = duk__hash_size_corrections;
    duk_uint32_t curr;
 
    curr = (duk_uint32_t) *p++;
    for (;;) {
        duk_small_int_t t = (duk_small_int_t) *p++;
        if (t < 0) {
            /* may happen if size is very close to 2^32-1 */
            break;
        }
 
        /* prediction: portable variant using doubles if 64-bit values not available */
#ifdef DUK_USE_64BIT_OPS

Referenced by duk__get_min_grow_e().

◆ duk_util_tinyrandom_get_bits()

DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits	(	duk_hthread *	thr,
		duk_small_int_t	n )

Definition at line 86920 of file duktape-1.8.0/src/duktape.c.

                                { \
        (rnd) += ((rnd) * (rnd)) | 0x05; \
        (rnd) = ((rnd) & 0xffffffffU);       /* if duk_uint32_t is exactly 32 bits, this is a NOP */ \
    } while (0)
 
#define DUK__RND_BIT(rnd)  ((rnd) >> 31)  /* only use the highest bit */
 

◆ duk_util_tinyrandom_get_double()

DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double ( duk_hthread * thr )

Definition at line 86938 of file duktape-1.8.0/src/duktape.c.

                            {
        DUK__UPDATE_RND(rnd);
        res <<= 1;
        res += DUK__RND_BIT(rnd);
    }
 
    thr->heap->rnd_state = rnd;
 
    return res;
}
 
DUK_INTERNAL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr) {
    duk_double_t t;
    duk_small_int_t n;
    duk_uint32_t rnd;
 
    /*
     *  XXX: could make this a lot faster if we create the double memory
     *  representation directly.  Feasible easily (must be uniform random).
     */
 
    rnd = thr->heap->rnd_state;

References DUK__RND_BIT, and DUK__UPDATE_RND.

◆ duk_valstack_resize_raw()

DUK_INTERNAL_DECL duk_bool_t duk_valstack_resize_raw	(	duk_context *	ctx,
		duk_size_t	min_new_size,
		duk_small_uint_t	flags )

Definition at line 15622 of file duktape-1.8.0/src/duktape.c.

                                  {
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(p));
        p++;
    }
#endif
 
    return 1;
}
 
DUK_INTERNAL
duk_bool_t duk_valstack_resize_raw(duk_context *ctx,
                                   duk_size_t min_new_size,
                                   duk_small_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t old_size;
    duk_size_t new_size;
    duk_bool_t is_shrink = 0;
    duk_small_uint_t shrink_flag = (flags & DUK_VSRESIZE_FLAG_SHRINK);
    duk_small_uint_t compact_flag = (flags & DUK_VSRESIZE_FLAG_COMPACT);
    duk_small_uint_t throw_flag = (flags & DUK_VSRESIZE_FLAG_THROW);
 
    DUK_DDD(DUK_DDDPRINT("check valstack resize: min_new_size=%lu, curr_size=%ld, curr_top=%ld, "
                         "curr_bottom=%ld, shrink=%d, compact=%d, throw=%d",
                         (unsigned long) min_new_size,
                         (long) (thr->valstack_end - thr->valstack),
                         (long) (thr->valstack_top - thr->valstack),
                         (long) (thr->valstack_bottom - thr->valstack),
                         (int) shrink_flag, (int) compact_flag, (int) throw_flag));
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
#if defined(DUK_USE_PREFER_SIZE)
    old_size = (duk_size_t) (thr->valstack_end - thr->valstack);
#else
    DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
    old_size = thr->valstack_size;
#endif
 
    if (min_new_size <= old_size) {
        is_shrink = 1;
        if (!shrink_flag ||
            old_size - min_new_size < DUK_VALSTACK_SHRINK_THRESHOLD) {
            DUK_DDD(DUK_DDDPRINT("no need to grow or shrink valstack"));
            return 1;
        }
    }
 
    new_size = min_new_size;
    if (!compact_flag) {
        if (is_shrink) {
            /* shrink case; leave some spare */
            new_size += DUK_VALSTACK_SHRINK_SPARE;
        }
 
        /* round up roughly to next 'grow step' */
        new_size = (new_size / DUK_VALSTACK_GROW_STEP + 1) * DUK_VALSTACK_GROW_STEP;
    }
 
    DUK_DD(DUK_DDPRINT("want to %s valstack: %lu -> %lu elements (min_new_size %lu)",
                       (const char *) (new_size > old_size ? "grow" : "shrink"),
                       (unsigned long) old_size, (unsigned long) new_size,
                       (unsigned long) min_new_size));
 
    if (new_size > thr->valstack_max) {
        /* Note: may be triggered even if minimal new_size would not reach the limit,
         * plan limit accordingly (taking DUK_VALSTACK_GROW_STEP into account).
         */
        if (throw_flag) {
            DUK_ERROR_RANGE(thr, DUK_STR_VALSTACK_LIMIT);
        } else {
            return 0;
        }
    }
 
    /*
     *  When resizing the valstack, a mark-and-sweep may be triggered for
     *  the allocation of the new valstack.  If the mark-and-sweep needs
     *  to use our thread for something, it may cause *the same valstack*
     *  to be resized recursively.  This happens e.g. when mark-and-sweep
     *  finalizers are called.  This is taken into account carefully in
     *  duk__resize_valstack().
     *
     *  'new_size' is known to be <= valstack_max, which ensures that
     *  size_t and pointer arithmetic won't wrap in duk__resize_valstack().
     */
 
    if (!duk__resize_valstack(ctx, new_size)) {

◆ duk_xcopymove_raw()

DUK_EXTERNAL void duk_xcopymove_raw	(	duk_context *	to_ctx,
		duk_context *	from_ctx,
		duk_idx_t	count,
		duk_bool_t	is_copy )

Definition at line 15999 of file duktape-1.8.0/src/duktape.c.

                                                                                                                     {
    duk_hthread *to_thr = (duk_hthread *) to_ctx;
    duk_hthread *from_thr = (duk_hthread *) from_ctx;
    void *src;
    duk_size_t nbytes;
    duk_tval *p;
    duk_tval *q;
 
    /* XXX: several pointer comparison issues here */
 
    DUK_ASSERT_CTX_VALID(to_ctx);
    DUK_ASSERT_CTX_VALID(from_ctx);
    DUK_ASSERT(to_ctx != NULL);
    DUK_ASSERT(from_ctx != NULL);
 
    if (to_ctx == from_ctx) {
        DUK_ERROR_API(to_thr, DUK_STR_INVALID_CONTEXT);
        return;
    }
    if ((count < 0) ||
        (count > (duk_idx_t) to_thr->valstack_max)) {
        /* Maximum value check ensures 'nbytes' won't wrap below. */
        DUK_ERROR_API(to_thr, DUK_STR_INVALID_COUNT);
        return;
    }
 
    nbytes = sizeof(duk_tval) * count;
    if (nbytes == 0) {
        return;
    }
    DUK_ASSERT(to_thr->valstack_top <= to_thr->valstack_end);
    if ((duk_size_t) ((duk_uint8_t *) to_thr->valstack_end - (duk_uint8_t *) to_thr->valstack_top) < nbytes) {
        DUK_ERROR_API(to_thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
    src = (void *) ((duk_uint8_t *) from_thr->valstack_top - nbytes);
    if (src < (void *) from_thr->valstack_bottom) {
        DUK_ERROR_API(to_thr, DUK_STR_INVALID_COUNT);
    }
 
    /* copy values (no overlap even if to_ctx == from_ctx; that's not
     * allowed now anyway)
     */
    DUK_ASSERT(nbytes > 0);
    DUK_MEMCPY((void *) to_thr->valstack_top, (const void *) src, (size_t) nbytes);
 
    p = to_thr->valstack_top;
    to_thr->valstack_top = (duk_tval *) (void *) (((duk_uint8_t *) p) + nbytes);
 
    if (is_copy) {
        /* Incref copies, keep originals. */
        q = to_thr->valstack_top;

◆ duk_xdef_prop()

DUK_INTERNAL_DECL void duk_xdef_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_uint_t	desc_flags )

Definition at line 14658 of file duktape-1.8.0/src/duktape.c.

◆ duk_xdef_prop_index()

DUK_INTERNAL_DECL void duk_xdef_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index,
		duk_small_uint_t	desc_flags )

Definition at line 14676 of file duktape-1.8.0/src/duktape.c.

◆ duk_xdef_prop_stridx()

DUK_INTERNAL_DECL void duk_xdef_prop_stridx	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx,
		duk_small_uint_t	desc_flags )

Definition at line 14689 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                   {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_require_hobject(ctx, obj_index);
    DUK_ASSERT(obj != NULL);
 
    duk_hobject_define_property_internal_arridx(thr, obj, arr_index, desc_flags);
    /* value popped by call */
}
 
DUK_INTERNAL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags) {

Referenced by duk_bi_buffer_slice_shared(), and duk_bi_string_constructor_from_char_code().

◆ duk_xdef_prop_stridx_builtin()

DUK_INTERNAL_DECL void duk_xdef_prop_stridx_builtin	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx,
		duk_small_int_t	builtin_idx,
		duk_small_uint_t	desc_flags )

Definition at line 14708 of file duktape-1.8.0/src/duktape.c.

                                                                                                                                                                        {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;

◆ duk_xdef_prop_stridx_thrower()

DUK_INTERNAL_DECL void duk_xdef_prop_stridx_thrower	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_small_int_t	stridx,
		duk_small_uint_t	desc_flags )

Definition at line 14734 of file duktape-1.8.0/src/duktape.c.

Variable Documentation

◆ duk__buffer_class_from_elemtype

const duk_uint8_t duk__buffer_class_from_elemtype[9]

static

Initial value:

= {
    DUK_HOBJECT_CLASS_UINT8ARRAY,
    DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY,
    DUK_HOBJECT_CLASS_INT8ARRAY,
    DUK_HOBJECT_CLASS_UINT16ARRAY,
    DUK_HOBJECT_CLASS_INT16ARRAY,
    DUK_HOBJECT_CLASS_UINT32ARRAY,
    DUK_HOBJECT_CLASS_INT32ARRAY,
    DUK_HOBJECT_CLASS_FLOAT32ARRAY,
    DUK_HOBJECT_CLASS_FLOAT64ARRAY
}

Definition at line 21742 of file duktape-1.8.0/src/duktape.c.

◆ duk__buffer_elemtype_copy_compatible

duk_uint16_t duk__buffer_elemtype_copy_compatible[9]

static

Definition at line 21792 of file duktape-1.8.0/src/duktape.c.

                                                              {
    1,  /* DUK__FLD_8BIT */
    2,  /* DUK__FLD_16BIT */
    4,  /* DUK__FLD_32BIT */
    4,  /* DUK__FLD_FLOAT */
    8,  /* DUK__FLD_DOUBLE */
    0   /* DUK__FLD_VARINT; not relevant here */
};
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
/* Bitfield for each DUK_HBUFFEROBJECT_ELEM_xxx indicating which element types
 * are compatible with a blind byte copy for the TypedArray set() method (also
 * used for TypedArray constructor).  Array index is target buffer elem type,
 * bitfield indicates compatible source types.  The types must have same byte
 * size and they must be coercion compatible.
 */
static duk_uint16_t duk__buffer_elemtype_copy_compatible[9] = {
    /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8 */
    (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) |
        (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) |
        (1U << DUK_HBUFFEROBJECT_ELEM_INT8),
 
    /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED
     * Note: INT8 is -not- copy compatible, e.g. -1 would coerce to 0x00.
     */
    (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) |
        (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED),
 
    /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT8 */
    (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) |
        (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) |
        (1U << DUK_HBUFFEROBJECT_ELEM_INT8),
 
    /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT16 */
    (1U << DUK_HBUFFEROBJECT_ELEM_UINT16) |
        (1U << DUK_HBUFFEROBJECT_ELEM_INT16),
 
    /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT16 */

Referenced by duk_bi_typedarray_set().

◆ duk__buffer_nbytes_from_fldtype

const duk_uint8_t duk__buffer_nbytes_from_fldtype[6]

static

Initial value:

Definition at line 21775 of file duktape-1.8.0/src/duktape.c.

                                                              {
    DUK_BIDX_UINT8ARRAY_PROTOTYPE,
    DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE,
    DUK_BIDX_INT8ARRAY_PROTOTYPE,
    DUK_BIDX_UINT16ARRAY_PROTOTYPE,
    DUK_BIDX_INT16ARRAY_PROTOTYPE,
    DUK_BIDX_UINT32ARRAY_PROTOTYPE,

◆ duk__buffer_proto_from_elemtype

const duk_uint8_t duk__buffer_proto_from_elemtype[9]

static

Initial value:

= {
    DUK_BIDX_UINT8ARRAY_PROTOTYPE,
    DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE,
    DUK_BIDX_INT8ARRAY_PROTOTYPE,
    DUK_BIDX_UINT16ARRAY_PROTOTYPE,
    DUK_BIDX_INT16ARRAY_PROTOTYPE,
    DUK_BIDX_UINT32ARRAY_PROTOTYPE,
    DUK_BIDX_INT32ARRAY_PROTOTYPE,
    DUK_BIDX_FLOAT32ARRAY_PROTOTYPE,
    DUK_BIDX_FLOAT64ARRAY_PROTOTYPE
}

Definition at line 21759 of file duktape-1.8.0/src/duktape.c.

                                                              {
    DUK_HOBJECT_CLASS_UINT8ARRAY,
    DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY,
    DUK_HOBJECT_CLASS_INT8ARRAY,
    DUK_HOBJECT_CLASS_UINT16ARRAY,
    DUK_HOBJECT_CLASS_INT16ARRAY,
    DUK_HOBJECT_CLASS_UINT32ARRAY,
    DUK_HOBJECT_CLASS_INT32ARRAY,
    DUK_HOBJECT_CLASS_FLOAT32ARRAY,
    DUK_HOBJECT_CLASS_FLOAT64ARRAY
};

◆ duk__bufferobject_virtual_props

DUK_LOCAL const duk_uint16_t duk__bufferobject_virtual_props[]

Initial value:

= {
    DUK_STRIDX_LENGTH,
    DUK_STRIDX_BYTE_LENGTH,
    DUK_STRIDX_BYTE_OFFSET,
    DUK_STRIDX_BYTES_PER_ELEMENT
}

Definition at line 46407 of file duktape-1.8.0/src/duktape.c.

                                                                            :
 *  non-snapshot-based approaches are difficult to reconcile with mutating
 *  the enumeration target, running multiple long-lived enumerators at the

◆ duk__bufobj_flags_lookup

const duk_uint32_t duk__bufobj_flags_lookup[]

static

Initial value:

= {
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_BUFFER_PROTOTYPE,            DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_NODEJS_BUFFER_PROTOTYPE,     DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_ARRAYBUFFER,       DUK_BIDX_ARRAYBUFFER_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_DATAVIEW,          DUK_BIDX_DATAVIEW_PROTOTYPE,          DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT8ARRAY,         DUK_BIDX_INT8ARRAY_PROTOTYPE,         DUK_HBUFFEROBJECT_ELEM_INT8,         0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8ARRAY,        DUK_BIDX_UINT8ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED, 0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT16ARRAY,        DUK_BIDX_INT16ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_INT16,        1, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT16ARRAY,       DUK_BIDX_UINT16ARRAY_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT16,       1, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT32ARRAY,        DUK_BIDX_INT32ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_INT32,        2, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT32ARRAY,       DUK_BIDX_UINT32ARRAY_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT32,       2, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT32ARRAY,      DUK_BIDX_FLOAT32ARRAY_PROTOTYPE,      DUK_HBUFFEROBJECT_ELEM_FLOAT32,      2, 1),  
   
}

Definition at line 18935 of file duktape-1.8.0/src/duktape.c.

◆ duk__closure_copy_proplist

DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[]

Initial value:

= {
    
    DUK_STRIDX_INT_VARMAP,
    DUK_STRIDX_INT_FORMALS,
    DUK_STRIDX_NAME,
    DUK_STRIDX_INT_PC2LINE,
    DUK_STRIDX_FILE_NAME,
    DUK_STRIDX_INT_SOURCE
}

Definition at line 71592 of file duktape-1.8.0/src/duktape.c.

                              {
        DUK_HEAPHDR_INCREF(thr, (duk_heaphdr *) *funcs);
        funcs++;
    }
}

◆ duk__date_equivyear

DUK_LOCAL duk_uint8_t duk__date_equivyear[14]

Initial value:

= {
 
    DUK__YEAR(2023), DUK__YEAR(2035), DUK__YEAR(2019), DUK__YEAR(2031),
    DUK__YEAR(2015), DUK__YEAR(2027), DUK__YEAR(2011),
 
    DUK__YEAR(2012), DUK__YEAR(2024), DUK__YEAR(2008), DUK__YEAR(2020),
    DUK__YEAR(2032), DUK__YEAR(2016), DUK__YEAR(2028)
 
}

Definition at line 24674 of file duktape-1.8.0/src/duktape.c.

                                        { \
        DUK_D(DUK_DPRINT("dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
                         (double) (dparts)[0], (double) (dparts)[1], \
                         (double) (dparts)[2], (double) (dparts)[3], \
                         (double) (dparts)[4], (double) (dparts)[5], \
                         (double) (dparts)[6], (double) (dparts)[7])); \
    } while (0)
 
/* Equivalent year for DST calculations outside [1970,2038[ range, see
 * E5 Section 15.9.1.8.  Equivalent year has the same leap-year-ness and
 * starts with the same weekday on Jan 1.
 * https://bugzilla.mozilla.org/show_bug.cgi?id=351066
 */
#define DUK__YEAR(x) ((duk_uint8_t) ((x) - 1970))
DUK_LOCAL duk_uint8_t duk__date_equivyear[14] = {
#if 1
    /* This is based on V8 EquivalentYear() algorithm (see src/genequivyear.py):
     * http://code.google.com/p/v8/source/browse/trunk/src/date.h#146
     */
 
    /* non-leap year: sunday, monday, ... */
    DUK__YEAR(2023), DUK__YEAR(2035), DUK__YEAR(2019), DUK__YEAR(2031),
    DUK__YEAR(2015), DUK__YEAR(2027), DUK__YEAR(2011),
 
    /* leap year: sunday, monday, ... */
    DUK__YEAR(2012), DUK__YEAR(2024), DUK__YEAR(2008), DUK__YEAR(2020),

◆ duk__date_magics

duk_uint16_t duk__date_magics[]

static

Definition at line 25913 of file duktape-1.8.0/src/duktape.c.

                                         {
    /* 0: toString */
    DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_LOCALTIME,
 
    /* 1: toDateString */
    DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_LOCALTIME,
 
    /* 2: toTimeString */
    DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_LOCALTIME,
 
    /* 3: toLocaleString */
    DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME,
 
    /* 4: toLocaleDateString */
    DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME,
 
    /* 5: toLocaleTimeString */
    DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME,
 
    /* 6: toUTCString */
    DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME,
 
    /* 7: toISOString */
    DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_NAN_TO_RANGE_ERROR + DUK_DATE_FLAG_SEP_T,
 
    /* 8: getFullYear */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 9: getUTCFullYear */
    0 + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 10: getMonth */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MONTH << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 11: getUTCMonth */
    0 + (DUK_DATE_IDX_MONTH << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 12: getDate */
    DUK_DATE_FLAG_ONEBASED + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_DAY << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 13: getUTCDate */
    DUK_DATE_FLAG_ONEBASED + (DUK_DATE_IDX_DAY << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 14: getDay */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_WEEKDAY << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 15: getUTCDay */
    0 + (DUK_DATE_IDX_WEEKDAY << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 16: getHours */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_HOUR << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 17: getUTCHours */
    0 + (DUK_DATE_IDX_HOUR << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 18: getMinutes */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MINUTE << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 19: getUTCMinutes */
    0 + (DUK_DATE_IDX_MINUTE << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 20: getSeconds */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_SECOND << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 21: getUTCSeconds */
    0 + (DUK_DATE_IDX_SECOND << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 22: getMilliseconds */
    DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MILLISECOND << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 23: getUTCMilliseconds */
    0 + (DUK_DATE_IDX_MILLISECOND << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 24: setMilliseconds */
    DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (1 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 25: setUTCMilliseconds */
    DUK_DATE_FLAG_TIMESETTER + (1 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 26: setSeconds */
    DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (2 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 27: setUTCSeconds */
    DUK_DATE_FLAG_TIMESETTER + (2 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 28: setMinutes */
    DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (3 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 29: setUTCMinutes */
    DUK_DATE_FLAG_TIMESETTER + (3 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 30: setHours */
    DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (4 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 31: setUTCHours */
    DUK_DATE_FLAG_TIMESETTER + (4 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 32: setDate */
    DUK_DATE_FLAG_LOCALTIME + (1 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 33: setUTCDate */
    0 + (1 << DUK_DATE_FLAG_VALUE_SHIFT),
 
    /* 34: setMonth */

◆ duk__days_in_month

DUK_LOCAL duk_uint8_t duk__days_in_month[12]

Initial value:

= {
    (duk_uint8_t) 31, (duk_uint8_t) 28, (duk_uint8_t) 31, (duk_uint8_t) 30,
    (duk_uint8_t) 31, (duk_uint8_t) 30, (duk_uint8_t) 31, (duk_uint8_t) 31,
    (duk_uint8_t) 30, (duk_uint8_t) 31, (duk_uint8_t) 30, (duk_uint8_t) 31
}

Definition at line 25034 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_bi_date_timeval_to_parts().

◆ duk__decode_uri_component_reserved_table

DUK_LOCAL const duk_uint8_t duk__decode_uri_component_reserved_table[16]

Initial value:

= {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
}

Definition at line 27865 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
    DUK__MKBITS(0, 0, 0, 1, 1, 0, 1, 0), DUK__MKBITS(0, 0, 0, 1, 1, 0, 0, 1),  /* 0x20-0x2f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 0, 1),  /* 0x30-0x3f */

Referenced by duk_bi_global_object_unescape().

◆ duk__decode_uri_reserved_table

DUK_LOCAL const duk_uint8_t duk__decode_uri_reserved_table[16]

Initial value:

= {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 1, 1, 0, 1, 0), DUK__MKBITS(0, 0, 0, 1, 1, 0, 0, 1),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 0, 1),  
    DUK__MKBITS(1, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
}

Definition at line 27853 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
    DUK__MKBITS(0, 1, 0, 0, 0, 0, 0, 1), DUK__MKBITS(1, 1, 1, 0, 0, 1, 1, 0),  /* 0x20-0x2f */
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0),  /* 0x30-0x3f */

Referenced by duk_bi_global_object_escape().

◆ duk__encode_uricomponent_unescaped_table

DUK_LOCAL const duk_uint8_t duk__encode_uricomponent_unescaped_table[16]

Initial value:

= {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 1, 0, 0, 0, 0, 0, 1), DUK__MKBITS(1, 1, 1, 0, 0, 1, 1, 0),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1),  
    DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 1, 0),  
}

Definition at line 27841 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
    DUK__MKBITS(0, 1, 0, 1, 1, 0, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x20-0x2f */
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 0, 1, 0, 1),  /* 0x30-0x3f */

◆ duk__encode_uriunescaped_table

DUK_LOCAL const duk_uint8_t duk__encode_uriunescaped_table[16]

Initial value:

= {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 1, 0, 1, 1, 0, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 0, 1, 0, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1),  
    DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 1, 0),  
}

Definition at line 27829 of file duktape-1.8.0/src/duktape.c.

◆ duk__escape_unescaped_table

DUK_LOCAL const duk_uint8_t duk__escape_unescaped_table[16]

Initial value:

= {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1),  
    DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  
    DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 0)   
}

Definition at line 27878 of file duktape-1.8.0/src/duktape.c.

                                                                           {
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x20-0x2f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x30-0x3f */
    DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x40-0x4f */

◆ duk__hash_size_corrections

DUK_LOCAL const duk_int8_t duk__hash_size_corrections[]

Initial value:

= {
    17,  
    4, 3, 4, 1, 4, 1, 1, 2, 2, 2, 2, 1, 6, 6, 9, 5, 1, 2, 2, 5, 1, 3, 3, 3,
    5, 4, 4, 2, 4, 8, 3, 4, 23, 2, 4, 7, 8, 11, 2, 12, 15, 10, 1, 1, 5, 1, 5,
    8, 9, 17, 14, 10, 7, 5, 2, 46, 21, 1, 9, 9, 4, 4, 10, 23, 36, 6, 20, 29,
    18, 6, 19, 21, 16, 11, 5, 5, 48, 9, 1, 39, 14, 8, 4, 29, 9, 1, 15, 48, 12,
    22, 6, 15, 27, 4, 2, 17, 28, 8, 9, 4, 5, 8, 3, 3, 8, 37, 11, 15, 8, 30,
    43, 6, 33, 41, 5, 20, 32, 41, 38, 24, 77, 14, 19, 11, 4, 35, 18, 19, 41,
    10, 23, 16, 9, 2,
    -1
}

Definition at line 11353 of file duktape-1.8.0/src/duktape.c.

◆ duk__json_decnumber_lookup

DUK_LOCAL const duk_uint8_t duk__json_decnumber_lookup[256]

Initial value:

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

Definition at line 29256 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__json_decstr_lookup

DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256]

Initial value:

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

Definition at line 29208 of file duktape-1.8.0/src/duktape.c.

                                                         {
    DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL,
    DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL,
    DUK_ASC_LC_B, DUK_ASC_LC_T, DUK_ASC_LC_N, DUK_ASC_NUL,
    DUK_ASC_LC_F, DUK_ASC_LC_R
};
#endif  /* DUK_USE_JSON_QUOTESTRING_FASTPATH */
 
#if defined(DUK_USE_JSON_DECSTRING_FASTPATH)
DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256] = {
    /* 0x00: slow path
     * other: as is
     */

◆ duk__json_eatwhite_lookup

DUK_LOCAL const duk_uint8_t duk__json_eatwhite_lookup[256]

Initial value:

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

Definition at line 29232 of file duktape-1.8.0/src/duktape.c.

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

◆ duk__json_quotestr_lookup

DUK_LOCAL const duk_uint8_t duk__json_quotestr_lookup[256]

Initial value:

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

Definition at line 29174 of file duktape-1.8.0/src/duktape.c.

                                                             {
    /* 0x00 ... 0x7f: as is
     * 0x80: escape generically
     * 0x81: slow path
     * 0xa0 ... 0xff: backslash + one char
     */
 

◆ duk__log_level_strings

DUK_LOCAL const duk_uint8_t duk__log_level_strings[]

Initial value:

= {
    (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C,
    (duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G,
    (duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F,
    (duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N,
    (duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R,
    (duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L
}

Definition at line 32243 of file duktape-1.8.0/src/duktape.c.

◆ duk__one_arg_funcs

DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[]

Definition at line 32777 of file duktape-1.8.0/src/duktape.c.

                                    {
    return DUK_SIN(x);
}
DUK_LOCAL double duk__sqrt(double x) {
    return DUK_SQRT(x);
}
DUK_LOCAL double duk__tan(double x) {
    return DUK_TAN(x);
}
DUK_LOCAL double duk__atan2(double x, double y) {
    return DUK_ATAN2(x, y);
}
#endif  /* DUK_USE_AVOID_PLATFORM_FUNCPTRS */
 
/* order must match constants in genbuiltins.py */
DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[] = {
#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
    duk__fabs,
    duk__acos,
    duk__asin,
    duk__atan,
    duk__ceil,
    duk__cos,
    duk__exp,
    duk__floor,
    duk__log,
    duk__round_fixed,
    duk__sin,
    duk__sqrt,

◆ duk__parse_iso8601_control

DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[]

Initial value:

= {
    DUK__PACK_RULE(DUK__PM_YEAR, DUK__SM_MINUS, DUK__PI_MONTH, 0),
    DUK__PACK_RULE(DUK__PM_MONTH, DUK__SM_MINUS, DUK__PI_DAY, 0),
    DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY, DUK__SM_T | DUK__SM_SPACE, DUK__PI_HOUR, 0),
    DUK__PACK_RULE(DUK__PM_HOUR, DUK__SM_COLON, DUK__PI_MINUTE, 0),
    DUK__PACK_RULE(DUK__PM_MINUTE, DUK__SM_COLON, DUK__PI_SECOND, 0),
    DUK__PACK_RULE(DUK__PM_SECOND, DUK__SM_PERIOD, DUK__PI_MILLISECOND, 0),
    DUK__PACK_RULE(DUK__PM_TZHOUR, DUK__SM_COLON, DUK__PI_TZMINUTE, 0),
    DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR  | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_PLUS, DUK__PI_TZHOUR, 0),
    DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR  | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_MINUS, DUK__PI_TZHOUR, DUK__CF_NEG),
    DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR  | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_Z, 0, DUK__CF_ACCEPT_NUL),
 
 
    
}

Definition at line 24779 of file duktape-1.8.0/src/duktape.c.

                                                         { \
        (var_nextidx) = (duk_small_uint_t) (((rule) >> 17) & 0x0f); \
        (var_flags) = (duk_small_uint_t) ((rule) >> 21); \
    } while (0)
 
#define DUK__RULE_MASK_PART_SEP  0x1ffffUL
 
/* Matching separator index is used in the control table */
DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[] = {
    DUK_ASC_PLUS /*0*/, DUK_ASC_MINUS /*1*/, DUK_ASC_UC_T /*2*/, DUK_ASC_SPACE /*3*/,
    DUK_ASC_COLON /*4*/, DUK_ASC_PERIOD /*5*/, DUK_ASC_UC_Z /*6*/, DUK_ASC_NUL /*7*/
};
 
/* Rule table: first matching rule is used to determine what to do next. */
DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[] = {
    DUK__PACK_RULE(DUK__PM_YEAR, DUK__SM_MINUS, DUK__PI_MONTH, 0),
    DUK__PACK_RULE(DUK__PM_MONTH, DUK__SM_MINUS, DUK__PI_DAY, 0),

◆ duk__parse_iso8601_seps

DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[]

Initial value:

= {
    DUK_ASC_PLUS , DUK_ASC_MINUS , DUK_ASC_UC_T , DUK_ASC_SPACE ,
    DUK_ASC_COLON , DUK_ASC_PERIOD , DUK_ASC_UC_Z , DUK_ASC_NUL 
}

Definition at line 24773 of file duktape-1.8.0/src/duktape.c.

◆ duk__str2num_digits_for_radix

DUK_LOCAL const duk_uint8_t duk__str2num_digits_for_radix[]

Initial value:

= {
    69, 44, 35, 30, 27, 25, 23, 22, 20, 20,    
    20, 19, 19, 18, 18, 17, 17, 17, 16, 16,    
    16, 16, 16, 15, 15, 15, 15, 15, 15, 14,    
    14, 14, 14, 14, 14                         
}

Definition at line 75421 of file duktape-1.8.0/src/duktape.c.

◆ duk__str2num_exp_limits

DUK_LOCAL const duk__exp_limits duk__str2num_exp_limits[]

Initial value:

= {
    { 957, -1147 }, { 605, -725 },  { 479, -575 },  { 414, -496 },
    { 372, -446 },  { 342, -411 },  { 321, -384 },  { 304, -364 },
    { 291, -346 },  { 279, -334 },  { 268, -323 },  { 260, -312 },
    { 252, -304 },  { 247, -296 },  { 240, -289 },  { 236, -283 },
    { 231, -278 },  { 227, -273 },  { 223, -267 },  { 220, -263 },
    { 216, -260 },  { 213, -256 },  { 210, -253 },  { 208, -249 },
    { 205, -246 },  { 203, -244 },  { 201, -241 },  { 198, -239 },
    { 196, -237 },  { 195, -234 },  { 193, -232 },  { 191, -230 },
    { 190, -228 },  { 188, -226 },  { 187, -225 },
}

Definition at line 75433 of file duktape-1.8.0/src/duktape.c.

                                                              {
    69, 44, 35, 30, 27, 25, 23, 22, 20, 20,    /* 2 to 11 */
    20, 19, 19, 18, 18, 17, 17, 17, 16, 16,    /* 12 to 21 */
    16, 16, 16, 15, 15, 15, 15, 15, 15, 14,    /* 22 to 31 */
    14, 14, 14, 14, 14                         /* 31 to 36 */
};

◆ duk__token_lbp

DUK_LOCAL const duk_uint8_t duk__token_lbp[]

Definition at line 57988 of file duktape-1.8.0/src/duktape.c.

                                               {
    DUK__MK_LBP(DUK__BP_EOF),                                 /* DUK_TOK_EOF */
    DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_IDENTIFIER */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_BREAK */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CASE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CATCH */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CONTINUE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DEBUGGER */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DEFAULT */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DELETE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DO */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_ELSE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FINALLY */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FOR */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FUNCTION */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IF */
    DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_IN */
    DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_INSTANCEOF */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_NEW */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_RETURN */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SWITCH */
    DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_THIS */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_THROW */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_TRY */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_TYPEOF */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_VAR */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CONST */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_VOID */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_WHILE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_WITH */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CLASS */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_ENUM */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_EXPORT */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_EXTENDS */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IMPORT */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SUPER */
    DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_NULL */
    DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_TRUE */
    DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_FALSE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_GET */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SET */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IMPLEMENTS */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_INTERFACE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LET */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PACKAGE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PRIVATE */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PROTECTED */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PUBLIC */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_STATIC */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_YIELD */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LCURLY */
    DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RCURLY */
    DUK__MK_LBP(DUK__BP_MEMBER),                              /* DUK_TOK_LBRACKET */
    DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RBRACKET */
    DUK__MK_LBP(DUK__BP_CALL),                                /* DUK_TOK_LPAREN */
    DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RPAREN */
    DUK__MK_LBP(DUK__BP_MEMBER),                              /* DUK_TOK_PERIOD */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SEMICOLON */
    DUK__MK_LBP(DUK__BP_COMMA),                               /* DUK_TOK_COMMA */
    DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_LT */
    DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_GT */
    DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_LE */
    DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_GE */
    DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_EQ */
    DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_NEQ */
    DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_SEQ */
    DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_SNEQ */
    DUK__MK_LBP(DUK__BP_ADDITIVE),                            /* DUK_TOK_ADD */
    DUK__MK_LBP(DUK__BP_ADDITIVE),                            /* DUK_TOK_SUB */
    DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_MUL */
    DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_DIV */
    DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_MOD */
    DUK__MK_LBP(DUK__BP_POSTFIX),                             /* DUK_TOK_INCREMENT */
    DUK__MK_LBP(DUK__BP_POSTFIX),                             /* DUK_TOK_DECREMENT */
    DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_ALSHIFT */
    DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_ARSHIFT */
    DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_RSHIFT */
    DUK__MK_LBP(DUK__BP_BAND),                                /* DUK_TOK_BAND */
    DUK__MK_LBP(DUK__BP_BOR),                                 /* DUK_TOK_BOR */
    DUK__MK_LBP(DUK__BP_BXOR),                                /* DUK_TOK_BXOR */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LNOT */
    DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_BNOT */
    DUK__MK_LBP(DUK__BP_LAND),                                /* DUK_TOK_LAND */
    DUK__MK_LBP(DUK__BP_LOR),                                 /* DUK_TOK_LOR */
    DUK__MK_LBP(DUK__BP_CONDITIONAL),                         /* DUK_TOK_QUESTION */

◆ duk__two_arg_funcs

DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[]

Initial value:

= {
 
    duk__atan2,
    duk__pow_fixed
 
}

Definition at line 32810 of file duktape-1.8.0/src/duktape.c.

◆ duk_api_global_filename

DUK_EXTERNAL const char* duk_api_global_filename = NULL

Definition at line 15030 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_buffer_raw().

◆ duk_api_global_line

DUK_EXTERNAL duk_int_t duk_api_global_line = 0

Definition at line 15031 of file duktape-1.8.0/src/duktape.c.

Referenced by duk_push_buffer_raw().

◆ duk_base64_dectab

DUK_INTERNAL const duk_int8_t duk_base64_dectab[256]

Initial value:

= {
    
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -1, -1, -2, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,  
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -3, -1, -1,  
    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,  
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,  
    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,  
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1   
}

Definition at line 11287 of file duktape-1.8.0/src/duktape.c.

                                                       {
    0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,  /* A...P */
    0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,  /* Q...f */
    0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,  /* g...v */
    0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f   /* w.../ */
};
#endif  /* DUK_USE_BASE64_FASTPATH */
 
/*
 *  Table for base-64 decoding
 */
 
#if defined(DUK_USE_BASE64_FASTPATH)
DUK_INTERNAL const duk_int8_t duk_base64_dectab[256] = {
    /* -1 = error, -2 = allowed whitespace, -3 = padding ('='), 0...63 decoded bytes */

◆ duk_base64_enctab

DUK_INTERNAL const duk_uint8_t duk_base64_enctab[64]

Initial value:

= {
    0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,  
    0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,  
    0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,  
    0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f   
}

Definition at line 11274 of file duktape-1.8.0/src/duktape.c.

◆ duk_bi_native_functions

DUK_INTERNAL const duk_c_function duk_bi_native_functions[149]

Definition at line 9058 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    duk_bi_array_constructor,
    duk_bi_array_constructor_is_array,
    duk_bi_array_prototype_concat,
    duk_bi_array_prototype_indexof_shared,
    duk_bi_array_prototype_iter_shared,
    duk_bi_array_prototype_join_shared,
    duk_bi_array_prototype_pop,
    duk_bi_array_prototype_push,
    duk_bi_array_prototype_reduce_shared,
    duk_bi_array_prototype_reverse,
    duk_bi_array_prototype_shift,
    duk_bi_array_prototype_slice,
    duk_bi_array_prototype_sort,
    duk_bi_array_prototype_splice,
    duk_bi_array_prototype_to_string,
    duk_bi_array_prototype_unshift,
    duk_bi_arraybuffer_constructor,
    duk_bi_arraybuffer_isview,
    duk_bi_boolean_constructor,
    duk_bi_boolean_prototype_tostring_shared,
    duk_bi_buffer_compare_shared,
    duk_bi_buffer_constructor,
    duk_bi_buffer_prototype_tostring_shared,
    duk_bi_buffer_readfield,
    duk_bi_buffer_slice_shared,
    duk_bi_buffer_writefield,
    duk_bi_dataview_constructor,
    duk_bi_date_constructor,
    duk_bi_date_constructor_now,
    duk_bi_date_constructor_parse,
    duk_bi_date_constructor_utc,
    duk_bi_date_prototype_get_shared,
    duk_bi_date_prototype_get_timezone_offset,
    duk_bi_date_prototype_set_shared,
    duk_bi_date_prototype_set_time,
    duk_bi_date_prototype_to_json,
    duk_bi_date_prototype_tostring_shared,
    duk_bi_date_prototype_value_of,
    duk_bi_duktape_object_act,
    duk_bi_duktape_object_compact,
    duk_bi_duktape_object_dec,
    duk_bi_duktape_object_enc,
    duk_bi_duktape_object_fin,
    duk_bi_duktape_object_gc,
    duk_bi_duktape_object_info,
    duk_bi_error_constructor_shared,
    duk_bi_error_prototype_filename_getter,
    duk_bi_error_prototype_filename_setter,
    duk_bi_error_prototype_linenumber_getter,
    duk_bi_error_prototype_linenumber_setter,
    duk_bi_error_prototype_stack_getter,
    duk_bi_error_prototype_stack_setter,
    duk_bi_error_prototype_to_string,
    duk_bi_function_constructor,
    duk_bi_function_prototype,
    duk_bi_function_prototype_apply,
    duk_bi_function_prototype_bind,
    duk_bi_function_prototype_call,
    duk_bi_function_prototype_to_string,
    duk_bi_global_object_decode_uri,
    duk_bi_global_object_decode_uri_component,
    duk_bi_global_object_encode_uri,
    duk_bi_global_object_encode_uri_component,
    duk_bi_global_object_escape,
    duk_bi_global_object_eval,
    duk_bi_global_object_is_finite,
    duk_bi_global_object_is_nan,
    duk_bi_global_object_parse_float,
    duk_bi_global_object_parse_int,
    duk_bi_global_object_print_helper,
    duk_bi_global_object_require,
    duk_bi_global_object_unescape,
    duk_bi_json_object_parse,
    duk_bi_json_object_stringify,
    duk_bi_logger_constructor,
    duk_bi_logger_prototype_fmt,
    duk_bi_logger_prototype_log_shared,
    duk_bi_logger_prototype_raw,
    duk_bi_math_object_max,
    duk_bi_math_object_min,
    duk_bi_math_object_onearg_shared,
    duk_bi_math_object_random,
    duk_bi_math_object_twoarg_shared,
    duk_bi_nodejs_buffer_byte_length,
    duk_bi_nodejs_buffer_concat,
    duk_bi_nodejs_buffer_constructor,
    duk_bi_nodejs_buffer_copy,
    duk_bi_nodejs_buffer_fill,
    duk_bi_nodejs_buffer_is_buffer,
    duk_bi_nodejs_buffer_is_encoding,
    duk_bi_nodejs_buffer_tojson,
    duk_bi_nodejs_buffer_tostring,
    duk_bi_nodejs_buffer_write,
    duk_bi_number_constructor,
    duk_bi_number_prototype_to_exponential,
    duk_bi_number_prototype_to_fixed,
    duk_bi_number_prototype_to_locale_string,
    duk_bi_number_prototype_to_precision,
    duk_bi_number_prototype_to_string,
    duk_bi_number_prototype_value_of,
    duk_bi_object_constructor,
    duk_bi_object_constructor_create,
    duk_bi_object_constructor_define_properties,
    duk_bi_object_constructor_define_property,
    duk_bi_object_constructor_get_own_property_descriptor,
    duk_bi_object_constructor_is_extensible,
    duk_bi_object_constructor_is_sealed_frozen_shared,
    duk_bi_object_constructor_keys_shared,
    duk_bi_object_constructor_prevent_extensions,
    duk_bi_object_constructor_seal_freeze_shared,
    duk_bi_object_getprototype_shared,
    duk_bi_object_prototype_has_own_property,
    duk_bi_object_prototype_is_prototype_of,
    duk_bi_object_prototype_property_is_enumerable,
    duk_bi_object_prototype_to_locale_string,
    duk_bi_object_prototype_to_string,
    duk_bi_object_prototype_value_of,
    duk_bi_object_setprototype_shared,
    duk_bi_pointer_constructor,
    duk_bi_pointer_prototype_tostring_shared,
    duk_bi_proxy_constructor,
    duk_bi_regexp_constructor,
    duk_bi_regexp_prototype_exec,
    duk_bi_regexp_prototype_test,
    duk_bi_regexp_prototype_to_string,
    duk_bi_string_constructor,
    duk_bi_string_constructor_from_char_code,
    duk_bi_string_prototype_caseconv_shared,
    duk_bi_string_prototype_char_at,
    duk_bi_string_prototype_char_code_at,
    duk_bi_string_prototype_concat,
    duk_bi_string_prototype_indexof_shared,
    duk_bi_string_prototype_locale_compare,

◆ duk_class_number_to_stridx

DUK_INTERNAL duk_uint8_t duk_class_number_to_stridx[32]

Definition at line 11505 of file duktape-1.8.0/src/duktape.c.

                                                          {
    DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
    DUK_STRIDX_UC_ARGUMENTS,
    DUK_STRIDX_ARRAY,
    DUK_STRIDX_UC_BOOLEAN,
    DUK_STRIDX_DATE,
    DUK_STRIDX_UC_ERROR,
    DUK_STRIDX_UC_FUNCTION,
    DUK_STRIDX_JSON,
    DUK_STRIDX_MATH,
    DUK_STRIDX_UC_NUMBER,
    DUK_STRIDX_UC_OBJECT,
    DUK_STRIDX_REG_EXP,
    DUK_STRIDX_UC_STRING,
    DUK_STRIDX_GLOBAL,
    DUK_STRIDX_OBJ_ENV,
    DUK_STRIDX_DEC_ENV,

◆ duk_hex_dectab

DUK_INTERNAL const duk_int8_t duk_hex_dectab[256]

Initial value:

= {
    
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,  
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1   
}

Definition at line 11140 of file duktape-1.8.0/src/duktape.c.

                                                    {
    DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3,
    DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7,
    DUK_ASC_8, DUK_ASC_9, DUK_ASC_UC_A, DUK_ASC_UC_B,
    DUK_ASC_UC_C, DUK_ASC_UC_D, DUK_ASC_UC_E, DUK_ASC_UC_F
};
 
/*
 *  Table for hex decoding ASCII hex digits
 */
 
DUK_INTERNAL const duk_int8_t duk_hex_dectab[256] = {
    /* -1 if invalid */

Referenced by duk__is_hex_digit(), and duk__transform_helper().

◆ duk_hex_dectab_shift4

DUK_INTERNAL const duk_int16_t duk_hex_dectab_shift4[256]

Initial value:

= {
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1   
}

Definition at line 11162 of file duktape-1.8.0/src/duktape.c.

11179 {

◆ duk_hex_enctab

DUK_INTERNAL const duk_uint16_t duk_hex_enctab[256]

Definition at line 11198 of file duktape-1.8.0/src/duktape.c.

                                                      {
#if defined(DUK_USE_INTEGER_BE)
    0x3030U, 0x3031U, 0x3032U, 0x3033U, 0x3034U, 0x3035U, 0x3036U, 0x3037U,
    0x3038U, 0x3039U, 0x3061U, 0x3062U, 0x3063U, 0x3064U, 0x3065U, 0x3066U,
    0x3130U, 0x3131U, 0x3132U, 0x3133U, 0x3134U, 0x3135U, 0x3136U, 0x3137U,
    0x3138U, 0x3139U, 0x3161U, 0x3162U, 0x3163U, 0x3164U, 0x3165U, 0x3166U,
    0x3230U, 0x3231U, 0x3232U, 0x3233U, 0x3234U, 0x3235U, 0x3236U, 0x3237U,
    0x3238U, 0x3239U, 0x3261U, 0x3262U, 0x3263U, 0x3264U, 0x3265U, 0x3266U,
    0x3330U, 0x3331U, 0x3332U, 0x3333U, 0x3334U, 0x3335U, 0x3336U, 0x3337U,
    0x3338U, 0x3339U, 0x3361U, 0x3362U, 0x3363U, 0x3364U, 0x3365U, 0x3366U,
    0x3430U, 0x3431U, 0x3432U, 0x3433U, 0x3434U, 0x3435U, 0x3436U, 0x3437U,
    0x3438U, 0x3439U, 0x3461U, 0x3462U, 0x3463U, 0x3464U, 0x3465U, 0x3466U,
    0x3530U, 0x3531U, 0x3532U, 0x3533U, 0x3534U, 0x3535U, 0x3536U, 0x3537U,
    0x3538U, 0x3539U, 0x3561U, 0x3562U, 0x3563U, 0x3564U, 0x3565U, 0x3566U,
    0x3630U, 0x3631U, 0x3632U, 0x3633U, 0x3634U, 0x3635U, 0x3636U, 0x3637U,
    0x3638U, 0x3639U, 0x3661U, 0x3662U, 0x3663U, 0x3664U, 0x3665U, 0x3666U,
    0x3730U, 0x3731U, 0x3732U, 0x3733U, 0x3734U, 0x3735U, 0x3736U, 0x3737U,
    0x3738U, 0x3739U, 0x3761U, 0x3762U, 0x3763U, 0x3764U, 0x3765U, 0x3766U,
    0x3830U, 0x3831U, 0x3832U, 0x3833U, 0x3834U, 0x3835U, 0x3836U, 0x3837U,
    0x3838U, 0x3839U, 0x3861U, 0x3862U, 0x3863U, 0x3864U, 0x3865U, 0x3866U,
    0x3930U, 0x3931U, 0x3932U, 0x3933U, 0x3934U, 0x3935U, 0x3936U, 0x3937U,
    0x3938U, 0x3939U, 0x3961U, 0x3962U, 0x3963U, 0x3964U, 0x3965U, 0x3966U,
    0x6130U, 0x6131U, 0x6132U, 0x6133U, 0x6134U, 0x6135U, 0x6136U, 0x6137U,
    0x6138U, 0x6139U, 0x6161U, 0x6162U, 0x6163U, 0x6164U, 0x6165U, 0x6166U,
    0x6230U, 0x6231U, 0x6232U, 0x6233U, 0x6234U, 0x6235U, 0x6236U, 0x6237U,
    0x6238U, 0x6239U, 0x6261U, 0x6262U, 0x6263U, 0x6264U, 0x6265U, 0x6266U,
    0x6330U, 0x6331U, 0x6332U, 0x6333U, 0x6334U, 0x6335U, 0x6336U, 0x6337U,
    0x6338U, 0x6339U, 0x6361U, 0x6362U, 0x6363U, 0x6364U, 0x6365U, 0x6366U,
    0x6430U, 0x6431U, 0x6432U, 0x6433U, 0x6434U, 0x6435U, 0x6436U, 0x6437U,
    0x6438U, 0x6439U, 0x6461U, 0x6462U, 0x6463U, 0x6464U, 0x6465U, 0x6466U,
    0x6530U, 0x6531U, 0x6532U, 0x6533U, 0x6534U, 0x6535U, 0x6536U, 0x6537U,
    0x6538U, 0x6539U, 0x6561U, 0x6562U, 0x6563U, 0x6564U, 0x6565U, 0x6566U,
    0x6630U, 0x6631U, 0x6632U, 0x6633U, 0x6634U, 0x6635U, 0x6636U, 0x6637U,
    0x6638U, 0x6639U, 0x6661U, 0x6662U, 0x6663U, 0x6664U, 0x6665U, 0x6666U
#else  /* DUK_USE_INTEGER_BE */
    0x3030U, 0x3130U, 0x3230U, 0x3330U, 0x3430U, 0x3530U, 0x3630U, 0x3730U,
    0x3830U, 0x3930U, 0x6130U, 0x6230U, 0x6330U, 0x6430U, 0x6530U, 0x6630U,
    0x3031U, 0x3131U, 0x3231U, 0x3331U, 0x3431U, 0x3531U, 0x3631U, 0x3731U,
    0x3831U, 0x3931U, 0x6131U, 0x6231U, 0x6331U, 0x6431U, 0x6531U, 0x6631U,
    0x3032U, 0x3132U, 0x3232U, 0x3332U, 0x3432U, 0x3532U, 0x3632U, 0x3732U,
    0x3832U, 0x3932U, 0x6132U, 0x6232U, 0x6332U, 0x6432U, 0x6532U, 0x6632U,
    0x3033U, 0x3133U, 0x3233U, 0x3333U, 0x3433U, 0x3533U, 0x3633U, 0x3733U,
    0x3833U, 0x3933U, 0x6133U, 0x6233U, 0x6333U, 0x6433U, 0x6533U, 0x6633U,
    0x3034U, 0x3134U, 0x3234U, 0x3334U, 0x3434U, 0x3534U, 0x3634U, 0x3734U,
    0x3834U, 0x3934U, 0x6134U, 0x6234U, 0x6334U, 0x6434U, 0x6534U, 0x6634U,
    0x3035U, 0x3135U, 0x3235U, 0x3335U, 0x3435U, 0x3535U, 0x3635U, 0x3735U,
    0x3835U, 0x3935U, 0x6135U, 0x6235U, 0x6335U, 0x6435U, 0x6535U, 0x6635U,
    0x3036U, 0x3136U, 0x3236U, 0x3336U, 0x3436U, 0x3536U, 0x3636U, 0x3736U,
    0x3836U, 0x3936U, 0x6136U, 0x6236U, 0x6336U, 0x6436U, 0x6536U, 0x6636U,
    0x3037U, 0x3137U, 0x3237U, 0x3337U, 0x3437U, 0x3537U, 0x3637U, 0x3737U,
    0x3837U, 0x3937U, 0x6137U, 0x6237U, 0x6337U, 0x6437U, 0x6537U, 0x6637U,
    0x3038U, 0x3138U, 0x3238U, 0x3338U, 0x3438U, 0x3538U, 0x3638U, 0x3738U,

◆ duk_initjs_data

DUK_INTERNAL const duk_uint8_t duk_initjs_data[204]

Initial value:

= {
40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116,
105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101,
102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97,
108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117,
109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98,
108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99,
108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34,
41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,79,98,106,
101,99,116,46,99,114,101,97,116,101,40,110,117,108,108,41,41,125,41,40,116,
104,105,115,44,68,117,107,116,97,112,101,41,59,10,0,
}

Definition at line 9210 of file duktape-1.8.0/src/duktape.c.

◆ duk_is_idchar_tab

DUK_INTERNAL const duk_int8_t duk_is_idchar_tab[128]

Initial value:

= {
    
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   
    0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  0,  0,  0,  0,  0,   
    0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,   
    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  1,   
    0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,   
    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0    
}

Definition at line 9944 of file duktape-1.8.0/src/duktape.c.

◆ duk_lc_digits

DUK_INTERNAL const duk_uint8_t duk_lc_digits[36]

Initial value:

= {
    DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3,
    DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7,
    DUK_ASC_8, DUK_ASC_9, DUK_ASC_LC_A, DUK_ASC_LC_B,
    DUK_ASC_LC_C, DUK_ASC_LC_D, DUK_ASC_LC_E, DUK_ASC_LC_F,
    DUK_ASC_LC_G, DUK_ASC_LC_H, DUK_ASC_LC_I, DUK_ASC_LC_J,
    DUK_ASC_LC_K, DUK_ASC_LC_L, DUK_ASC_LC_M, DUK_ASC_LC_N,
    DUK_ASC_LC_O, DUK_ASC_LC_P, DUK_ASC_LC_Q, DUK_ASC_LC_R,
    DUK_ASC_LC_S, DUK_ASC_LC_T, DUK_ASC_LC_U, DUK_ASC_LC_V,
    DUK_ASC_LC_W, DUK_ASC_LC_X, DUK_ASC_LC_Y, DUK_ASC_LC_Z
}

Definition at line 11117 of file duktape-1.8.0/src/duktape.c.

Referenced by duk__enc_buffer_data().

◆ duk_str_alloc_failed

DUK_INTERNAL const char* duk_str_alloc_failed = "alloc failed"

Definition at line 8760 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_array_length_not_writable

DUK_INTERNAL const char* duk_str_array_length_not_writable = "array length non-writable"

Definition at line 8785 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_array_length_over_2g

DUK_INTERNAL const char* duk_str_array_length_over_2g = "array length over 2G"

Definition at line 8769 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_array_length_write_failed

DUK_INTERNAL const char* duk_str_array_length_write_failed = "array length write failed"

Definition at line 8784 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_bound_chain_limit

DUK_INTERNAL const char* duk_str_bound_chain_limit = "function call bound chain limit"

Definition at line 8832 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_buffer_too_long

DUK_INTERNAL const char* duk_str_buffer_too_long = "buffer too long"

Definition at line 8758 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_bytecode_limit

DUK_INTERNAL const char* duk_str_bytecode_limit = "bytecode limit"

Definition at line 8835 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_c_callstack_limit

DUK_INTERNAL const char* duk_str_c_callstack_limit = "C call stack depth limit"

Definition at line 8833 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_callstack_limit

DUK_INTERNAL const char* duk_str_callstack_limit = "callstack limit"

Definition at line 8829 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_cannot_delete_identifier

DUK_INTERNAL const char* duk_str_cannot_delete_identifier = "cannot delete identifier"

Definition at line 8798 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_catchstack_limit

DUK_INTERNAL const char* duk_str_catchstack_limit = "catchstack limit"

Definition at line 8830 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_compiler_recursion_limit

DUK_INTERNAL const char* duk_str_compiler_recursion_limit = "compiler recursion limit"

Definition at line 8834 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_concat_result_too_long

DUK_INTERNAL const char* duk_str_concat_result_too_long = "concat result too long"

Definition at line 8766 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_const_limit

DUK_INTERNAL const char* duk_str_const_limit = "const limit"

Definition at line 8838 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_cyclic_input

DUK_INTERNAL const char* duk_str_cyclic_input = "cyclic input"

Definition at line 8776 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_decode_failed

DUK_INTERNAL const char* duk_str_decode_failed = "decode failed"

Definition at line 8764 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_defaultvalue_coerce_failed

DUK_INTERNAL const char* duk_str_defaultvalue_coerce_failed = "[[DefaultValue]] coerce failed"

Definition at line 8754 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_duplicate_label

DUK_INTERNAL const char* duk_str_duplicate_label = "duplicate label"

Definition at line 8793 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_empty_expr_not_allowed

DUK_INTERNAL const char* duk_str_empty_expr_not_allowed = "empty expression not allowed"

Definition at line 8802 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_encode_failed

DUK_INTERNAL const char* duk_str_encode_failed = "encode failed"

Definition at line 8763 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_expected_identifier

DUK_INTERNAL const char* duk_str_expected_identifier = "expected identifier"

Definition at line 8801 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_fmt_invalid_json

DUK_INTERNAL const char* duk_str_fmt_invalid_json = "invalid json (at offset %ld)"

Definition at line 8773 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_fmt_ptr

DUK_INTERNAL const char* duk_str_fmt_ptr = "%p"

Definition at line 8772 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_func_limit

DUK_INTERNAL const char* duk_str_func_limit = "function limit"

Definition at line 8839 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_func_name_required

DUK_INTERNAL const char* duk_str_func_name_required = "function name required"

Definition at line 8815 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_func_stmt_not_allowed

DUK_INTERNAL const char* duk_str_func_stmt_not_allowed = "function statement not allowed"

Definition at line 8810 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_internal_error

DUK_INTERNAL const char* duk_str_internal_error = "internal error"

Definition at line 8741 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_arg_name

DUK_INTERNAL const char* duk_str_invalid_arg_name = "invalid argument name"

Definition at line 8812 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_array_length

DUK_INTERNAL const char* duk_str_invalid_array_length = "invalid array length"

Definition at line 8783 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_array_literal

DUK_INTERNAL const char* duk_str_invalid_array_literal = "invalid array literal"

Definition at line 8795 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_backrefs

DUK_INTERNAL const char* duk_str_invalid_backrefs = "invalid backreference(s)"

Definition at line 8825 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_base

DUK_INTERNAL const char* duk_str_invalid_base = "invalid base value"

Definition at line 8780 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_break_cont_label

DUK_INTERNAL const char* duk_str_invalid_break_cont_label = "invalid break/continue label"

Definition at line 8805 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_call_args

DUK_INTERNAL const char* duk_str_invalid_call_args = "invalid call args"

Definition at line 8743 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_context

DUK_INTERNAL const char* duk_str_invalid_context = "invalid context"

Definition at line 8750 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_count

DUK_INTERNAL const char* duk_str_invalid_count = "invalid count"

Definition at line 8742 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_descriptor

DUK_INTERNAL const char* duk_str_invalid_descriptor = "invalid descriptor"

Definition at line 8788 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_expression

DUK_INTERNAL const char* duk_str_invalid_expression = "invalid expression"

Definition at line 8799 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_for

DUK_INTERNAL const char* duk_str_invalid_for = "invalid for statement"

Definition at line 8803 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_func_name

DUK_INTERNAL const char* duk_str_invalid_func_name = "invalid function name"

Definition at line 8813 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_getset_name

DUK_INTERNAL const char* duk_str_invalid_getset_name = "invalid getter/setter name"

Definition at line 8814 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_label

DUK_INTERNAL const char* duk_str_invalid_label = "invalid label"

Definition at line 8794 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_lvalue

DUK_INTERNAL const char* duk_str_invalid_lvalue = "invalid lvalue"

Definition at line 8800 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_object_literal

DUK_INTERNAL const char* duk_str_invalid_object_literal = "invalid object literal"

Definition at line 8796 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_quantifier_no_atom

DUK_INTERNAL const char* duk_str_invalid_quantifier_no_atom = "quantifier without preceding atom"

Definition at line 8818 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_quantifier_values

DUK_INTERNAL const char* duk_str_invalid_quantifier_values = "quantifier values invalid (qmin > qmax)"

Definition at line 8819 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_regexp_flags

DUK_INTERNAL const char* duk_str_invalid_regexp_flags = "invalid regexp flags"

Definition at line 8824 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_return

DUK_INTERNAL const char* duk_str_invalid_return = "invalid return"

Definition at line 8806 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_switch

DUK_INTERNAL const char* duk_str_invalid_switch = "invalid switch statement"

Definition at line 8804 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_throw

DUK_INTERNAL const char* duk_str_invalid_throw = "invalid throw"

Definition at line 8808 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_try

DUK_INTERNAL const char* duk_str_invalid_try = "invalid try"

Definition at line 8807 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_invalid_var_declaration

DUK_INTERNAL const char* duk_str_invalid_var_declaration = "invalid variable declaration"

Definition at line 8797 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_jsondec_reclimit

DUK_INTERNAL const char* duk_str_jsondec_reclimit = "json decode recursion limit"

Definition at line 8774 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_jsonenc_reclimit

DUK_INTERNAL const char* duk_str_jsonenc_reclimit = "json encode recursion limit"

Definition at line 8775 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_no_sourcecode

DUK_INTERNAL const char* duk_str_no_sourcecode = "no sourcecode"

Definition at line 8765 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_buffer

DUK_INTERNAL const char* duk_str_not_buffer = "not buffer"

Definition at line 8752 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_callable

DUK_INTERNAL const char* duk_str_not_callable = "not callable"

Definition at line 8745 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_configurable

DUK_INTERNAL const char* duk_str_not_configurable = "not configurable"

Definition at line 8748 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_constructable

DUK_INTERNAL const char* duk_str_not_constructable = "not constructable"

Definition at line 8744 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_extensible

DUK_INTERNAL const char* duk_str_not_extensible = "not extensible"

Definition at line 8746 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_object_coercible

DUK_INTERNAL const char* duk_str_not_object_coercible = "not object coercible"

Definition at line 8756 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_not_writable

DUK_INTERNAL const char* duk_str_not_writable = "not writable"

Definition at line 8747 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_number_outside_range

DUK_INTERNAL const char* duk_str_number_outside_range = "number outside range"

Definition at line 8755 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_parse_error

DUK_INTERNAL const char* duk_str_parse_error = "parse error"

Definition at line 8792 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_pop_too_many

DUK_INTERNAL const char* duk_str_pop_too_many = "attempt to pop too many entries"

Definition at line 8761 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_property_is_virtual

DUK_INTERNAL const char* duk_str_property_is_virtual = "property is virtual"

Definition at line 8789 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_prototype_chain_limit

DUK_INTERNAL const char* duk_str_prototype_chain_limit = "prototype chain limit"

Definition at line 8831 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_proxy_rejected

DUK_INTERNAL const char* duk_str_proxy_rejected = "proxy rejected"

Definition at line 8782 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_proxy_revoked

DUK_INTERNAL const char* duk_str_proxy_revoked = "proxy revoked"

Definition at line 8779 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_push_beyond_alloc_stack

DUK_INTERNAL const char* duk_str_push_beyond_alloc_stack = "attempt to push beyond currently allocated stack"

Definition at line 8751 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_quantifier_too_many_copies

DUK_INTERNAL const char* duk_str_quantifier_too_many_copies = "quantifier expansion requires too many atom copies"

Definition at line 8820 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_redefine_virt_prop

DUK_INTERNAL const char* duk_str_redefine_virt_prop = "attempt to redefine virtual property"

Definition at line 8787 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_reg_limit

DUK_INTERNAL const char* duk_str_reg_limit = "register limit"

Definition at line 8836 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_regexp_compiler_recursion_limit

DUK_INTERNAL const char* duk_str_regexp_compiler_recursion_limit = "regexp compiler recursion limit"

Definition at line 8840 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_regexp_executor_recursion_limit

DUK_INTERNAL const char* duk_str_regexp_executor_recursion_limit = "regexp executor recursion limit"

Definition at line 8841 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_regexp_executor_step_limit

DUK_INTERNAL const char* duk_str_regexp_executor_step_limit = "regexp step limit"

Definition at line 8842 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_setter_undefined

DUK_INTERNAL const char* duk_str_setter_undefined = "setter undefined"

Definition at line 8786 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_sprintf_too_long

DUK_INTERNAL const char* duk_str_sprintf_too_long = "sprintf message too long"

Definition at line 8759 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_strict_caller_read

DUK_INTERNAL const char* duk_str_strict_caller_read = "attempt to read strict 'caller'"

Definition at line 8781 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_string_too_long

DUK_INTERNAL const char* duk_str_string_too_long = "string too long"

Definition at line 8757 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_temp_limit

DUK_INTERNAL const char* duk_str_temp_limit = "temp limit"

Definition at line 8837 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unexpected_closing_paren

DUK_INTERNAL const char* duk_str_unexpected_closing_paren = "unexpected closing parenthesis"

Definition at line 8821 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unexpected_end_of_pattern

DUK_INTERNAL const char* duk_str_unexpected_end_of_pattern = "unexpected end of pattern"

Definition at line 8822 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unexpected_regexp_token

DUK_INTERNAL const char* duk_str_unexpected_regexp_token = "unexpected token in regexp"

Definition at line 8823 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unexpected_type

DUK_INTERNAL const char* duk_str_unexpected_type = "unexpected type"

Definition at line 8753 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unimplemented

DUK_INTERNAL const char* duk_str_unimplemented = "unimplemented"

Definition at line 8767 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unsupported

DUK_INTERNAL const char* duk_str_unsupported = "unsupported"

Definition at line 8768 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_unterminated_stmt

DUK_INTERNAL const char* duk_str_unterminated_stmt = "unterminated statement"

Definition at line 8811 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_valstack_limit

DUK_INTERNAL const char* duk_str_valstack_limit = "valstack limit"

Definition at line 8828 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_with_in_strict_mode

DUK_INTERNAL const char* duk_str_with_in_strict_mode = "with in strict mode"

Definition at line 8809 of file duktape-1.8.0/src/duktape.c.

◆ duk_str_wrong_buffer_type

DUK_INTERNAL const char* duk_str_wrong_buffer_type = "wrong buffer type"

Definition at line 8762 of file duktape-1.8.0/src/duktape.c.

◆ duk_strings_data

DUK_INTERNAL const duk_uint8_t duk_strings_data[1049]

Definition at line 9000 of file duktape-1.8.0/src/duktape.c.

                                                        {
79,104,209,144,168,105,6,78,182,139,90,122,8,154,140,35,103,35,117,193,73,
5,52,116,180,104,166,135,52,189,4,98,12,27,178,156,80,211,31,161,115,150,
64,52,221,109,24,18,68,157,24,38,67,118,36,55,73,119,151,164,140,93,18,117,
128,153,201,228,201,205,2,250,8,196,24,232,104,82,146,40,232,193,48,118,
168,37,147,212,54,127,113,208,70,32,194,187,68,54,127,113,208,70,32,196,
123,68,54,127,113,209,44,12,121,7,208,70,32,194,186,134,207,236,126,219,
160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253,159,217,
116,17,136,48,190,209,13,159,217,253,151,65,24,131,12,233,86,224,79,236,
254,203,160,140,65,134,116,171,112,39,246,223,105,208,70,32,193,140,183,4,
11,55,92,20,244,141,169,186,50,11,164,109,77,208,208,165,36,79,215,185,13,
153,34,110,204,241,32,6,66,84,11,112,200,84,52,157,124,92,242,70,120,45,64,
186,17,22,138,38,0,172,140,19,154,84,26,145,0,86,69,17,180,97,34,0,172,132,
75,144,215,77,221,91,132,5,147,178,156,80,211,30,160,93,9,215,21,115,119,
169,49,75,211,138,26,101,205,222,68,157,47,78,40,105,151,55,120,204,156,
189,56,161,166,52,157,72,136,138,65,154,232,147,162,4,136,150,81,115,66,
208,210,37,96,148,250,134,140,151,39,212,125,255,221,125,73,80,209,146,233,
124,93,55,79,15,34,196,230,202,113,160,166,232,157,132,148,128,98,28,46,
114,200,6,153,180,96,73,19,74,113,67,76,103,5,36,20,211,70,140,133,67,72,
49,245,160,235,81,212,52,168,106,39,132,253,111,80,210,161,168,158,5,245,
191,96,31,172,15,208,23,226,190,131,232,62,131,232,11,251,127,93,245,223,
93,251,172,234,27,80,45,3,250,14,140,19,34,65,19,81,132,108,228,97,1,107,
33,12,32,45,100,136,206,9,12,196,155,134,69,146,100,235,226,231,146,51,194,
72,218,48,145,4,200,119,89,189,81,49,39,72,147,235,226,233,186,120,121,58,
226,167,90,124,93,55,107,71,137,33,68,68,130,64,206,75,189,209,156,144,84,
44,141,3,8,137,187,178,156,80,211,26,110,242,100,230,146,120,121,8,48,76,6,
89,26,105,157,65,196,201,213,145,166,153,212,28,76,157,113,75,34,78,62,14,
38,73,105,228,142,136,178,48,141,152,228,73,150,83,0,148,39,137,75,67,73,
214,209,129,36,85,190,206,32,17,6,9,128,141,3,8,130,161,100,235,64,194,24,
52,41,73,19,189,200,108,201,19,111,181,2,232,66,239,173,37,230,157,244,56,
153,4,225,145,27,233,93,22,1,114,62,251,80,69,128,121,247,213,146,228,109,
79,190,212,17,35,106,125,246,78,164,68,68,111,175,23,217,45,13,33,119,208,
68,210,38,250,192,61,91,233,80,208,45,25,36,81,190,156,13,26,201,19,239,
162,2,214,66,31,125,153,226,64,13,27,236,72,96,130,68,62,251,48,68,196,153,
119,217,157,18,56,156,199,161,100,42,26,250,77,36,140,122,40,144,19,34,9,

◆ duk_uc_nybbles

DUK_INTERNAL const duk_uint8_t duk_uc_nybbles[16]

Initial value:

= {
    DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3,
    DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7,
    DUK_ASC_8, DUK_ASC_9, DUK_ASC_UC_A, DUK_ASC_UC_B,
    DUK_ASC_UC_C, DUK_ASC_UC_D, DUK_ASC_UC_E, DUK_ASC_UC_F
}

Definition at line 11129 of file duktape-1.8.0/src/duktape.c.

11134 {

◆ duk_unicode_caseconv_lc

const duk_uint8_t duk_unicode_caseconv_lc[616]

Initial value:

= {
144,3,0,3,128,184,6,192,7,192,112,24,144,37,96,64,54,32,81,64,128,226,0,
235,65,129,199,1,230,130,3,145,3,177,34,7,70,7,134,36,15,244,13,236,24,32,
0,34,129,0,65,0,67,4,0,166,32,172,41,132,40,11,64,19,15,132,15,128,8,31,24,
31,16,12,62,80,62,64,32,124,224,124,192,64,250,64,250,0,97,246,129,246,1,3,
241,3,240,2,7,230,7,228,4,15,212,15,208,8,31,184,31,176,4,63,116,62,224,8,
127,32,125,200,32,254,192,254,128,33,253,161,247,96,67,253,3,252,0,135,250,
135,222,129,15,252,15,188,2,31,250,31,124,4,66,192,66,224,64,146,216,147,
64,209,96,1,97,130,242,199,224,35,240,95,228,63,232,38,161,1,0,1,1,48,2,
100,2,102,12,4,228,4,232,64,10,80,10,89,112,23,144,23,160,96,48,64,48,96,
128,104,0,104,65,128,217,128,218,2,1,203,1,204,18,3,188,3,190,36,7,200,7,
204,16,15,192,15,201,64,34,32,34,49,32,72,192,72,225,64,220,0,220,65,1,236,
1,236,140,4,96,4,97,34,9,20,9,22,108,19,4,19,8,56,38,128,38,138,193,224,1,
224,25,99,212,3,212,44,7,214,71,212,66,22,51,150,52,3,44,128,44,129,100,89,
214,89,216,10,153,2,153,4,189,52,5,52,8,202,114,42,114,48,244,230,84,230,
103,233,222,105,222,129,83,191,83,191,133,167,160,167,161,10,48,13,48,20,0,
32,26,192,26,208,64,56,128,56,192,192,113,64,113,129,1,251,129,252,2,44,
114,44,115,4,16,12,56,12,64,32,27,128,27,144,64,211,197,211,198,2,8,6,88,9,
164,16,17,216,17,224,47,245,1,120,0,255,1,129,2,83,1,134,2,84,1,142,1,221,
1,143,2,89,1,144,2,91,1,145,1,146,1,147,2,96,1,148,2,99,1,151,2,104,1,152,
1,153,1,157,2,114,1,159,2,117,1,167,1,168,1,174,2,136,1,183,2,146,1,241,1,
243,1,246,1,149,1,247,1,191,2,32,1,158,2,58,44,101,2,61,1,154,2,62,44,102,
2,67,1,128,2,68,2,137,2,69,2,140,3,118,3,119,3,134,3,172,3,140,3,204,3,207,
3,215,3,244,3,184,3,249,3,242,4,192,4,207,30,158,0,223,31,188,31,179,31,
204,31,195,31,236,31,229,31,252,31,243,33,38,3,201,33,42,0,107,33,43,0,229,
33,50,33,78,33,131,33,132,44,96,44,97,44,98,2,107,44,99,29,125,44,100,2,
125,44,109,2,81,44,110,2,113,44,111,2,80,44,112,2,82,167,125,29,121,167,
141,2,101,2,2,97,0,52,129,131,128,
}

Definition at line 80502 of file duktape-1.8.0/src/duktape.c.

                                                 {
144,3,0,3,128,184,6,192,7,192,112,24,144,37,96,64,54,32,81,64,128,226,0,
235,65,129,199,1,230,130,3,145,3,177,34,7,70,7,134,36,15,244,13,236,24,32,
0,34,129,0,65,0,67,4,0,166,32,172,41,132,40,11,64,19,15,132,15,128,8,31,24,
31,16,12,62,80,62,64,32,124,224,124,192,64,250,64,250,0,97,246,129,246,1,3,
241,3,240,2,7,230,7,228,4,15,212,15,208,8,31,184,31,176,4,63,116,62,224,8,
127,32,125,200,32,254,192,254,128,33,253,161,247,96,67,253,3,252,0,135,250,
135,222,129,15,252,15,188,2,31,250,31,124,4,66,192,66,224,64,146,216,147,
64,209,96,1,97,130,242,199,224,35,240,95,228,63,232,38,161,1,0,1,1,48,2,
100,2,102,12,4,228,4,232,64,10,80,10,89,112,23,144,23,160,96,48,64,48,96,
128,104,0,104,65,128,217,128,218,2,1,203,1,204,18,3,188,3,190,36,7,200,7,
204,16,15,192,15,201,64,34,32,34,49,32,72,192,72,225,64,220,0,220,65,1,236,

◆ duk_unicode_caseconv_uc

const duk_uint8_t duk_unicode_caseconv_uc[1288]

Definition at line 80441 of file duktape-1.8.0/src/duktape.c.

                                                  {
132,3,128,3,0,184,7,192,6,192,112,35,242,199,224,64,74,192,49,32,128,162,
128,108,65,1,189,129,254,131,3,173,3,136,6,7,98,7,34,68,15,12,14,140,72,30,
104,28,112,32,67,0,65,4,0,138,0,128,4,1,88,65,76,83,15,128,15,132,8,31,16,
31,24,12,62,64,62,80,32,124,192,124,224,64,250,0,250,64,97,246,1,246,129,3,
238,3,247,64,135,220,135,242,2,15,187,15,237,2,31,120,31,248,4,62,244,63,
212,8,125,240,127,232,16,253,128,253,192,33,253,1,253,128,67,252,3,253,0,
136,92,8,88,8,18,104,18,91,26,44,48,44,0,94,90,0,33,64,155,253,7,252,132,
212,0,32,32,32,6,0,76,192,76,129,128,157,0,156,136,1,75,1,74,46,2,244,2,
242,12,6,12,6,8,16,13,8,13,0,48,27,64,27,48,64,57,192,57,162,0,119,192,119,
132,128,252,128,252,20,2,35,2,34,18,4,142,4,140,20,13,196,13,192,16,30,200,
30,192,192,70,16,70,2,32,145,96,145,70,193,48,129,48,67,130,104,130,104,44,
30,1,30,0,150,61,66,61,64,192,125,68,125,100,33,99,65,99,56,50,200,18,200,
6,69,157,133,157,96,169,144,105,144,11,211,64,211,64,12,167,35,167,34,15,
78,103,78,100,126,157,234,157,228,21,59,253,59,240,90,122,26,122,0,163,128,
214,128,214,2,1,197,1,196,6,3,140,3,136,12,7,200,7,196,16,20,0,13,48,32,63,
128,63,112,69,142,101,142,64,130,1,136,1,135,4,3,114,3,112,8,26,120,202,
120,176,65,1,30,1,29,130,2,105,1,150,5,255,96,22,160,115,128,31,224,47,0,
38,32,9,32,47,224,10,96,48,0,72,96,50,64,50,32,50,160,62,192,51,32,51,0,51,
64,71,160,51,192,68,0,53,0,52,224,55,224,62,224,59,160,49,192,62,96,62,32,
74,5,141,224,74,37,141,160,74,69,142,0,74,96,48,32,74,128,48,192,75,32,49,
224,75,96,50,0,76,0,50,96,76,96,50,128,76,180,241,160,77,0,50,224,77,101,
140,64,78,37,141,192,78,64,51,160,78,160,51,224,79,165,140,128,81,0,53,192,
81,32,72,128,81,128,72,160,82,64,54,224,104,160,115,32,110,224,110,192,117,
128,112,192,120,64,116,96,121,128,113,128,122,0,114,64,122,32,115,0,122,
160,116,192,122,192,116,0,122,224,121,224,126,0,115,64,126,32,116,32,126,
64,127,32,126,160,114,160,153,224,152,3,175,52,239,163,175,165,140,99,211,
99,204,3,247,192,115,35,252,163,253,132,41,196,38,68,48,132,48,101,140,37,
140,5,140,160,71,69,140,192,71,217,128,55,224,5,48,5,48,20,152,10,240,1,56,
7,194,0,74,3,12,3,144,192,230,64,194,0,192,64,236,48,58,80,48,128,48,16,88,
120,20,212,21,72,122,90,0,72,3,49,30,151,128,21,0,194,7,166,32,5,112,48,
161,233,152,1,100,12,40,122,106,0,65,2,190,31,80,128,233,64,196,199,212,
176,58,80,49,48,48,1,245,76,14,148,12,76,12,4,125,91,3,165,3,19,3,66,31,
128,135,194,0,230,71,224,97,240,144,57,145,248,40,124,40,14,100,126,14,31,
11,3,153,31,132,135,195,0,230,71,225,97,240,208,57,145,248,104,124,56,14,
100,126,30,31,15,3,153,31,136,135,194,0,230,71,226,97,240,144,57,145,248,
168,124,40,14,100,126,46,31,11,3,153,31,140,135,195,0,230,71,227,97,240,
208,57,145,248,232,124,56,14,100,126,62,31,15,3,153,31,144,135,202,0,230,
71,228,97,242,144,57,145,249,40,124,168,14,100,126,78,31,43,3,153,31,148,
135,203,0,230,71,229,97,242,208,57,145,249,104,124,184,14,100,126,94,31,47,
3,153,31,152,135,202,0,230,71,230,97,242,144,57,145,249,168,124,168,14,100,
126,110,31,43,3,153,31,156,135,203,0,230,71,231,97,242,208,57,145,249,232,
124,184,14,100,126,126,31,47,3,153,31,160,135,218,0,230,71,232,97,246,144,
57,145,250,40,125,168,14,100,126,142,31,107,3,153,31,164,135,219,0,230,71,

◆ duk_unicode_idp_m_ids_noa

const duk_uint8_t duk_unicode_idp_m_ids_noa[397]

Initial value:

= {
255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112,
245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34,
36,241,210,249,99,242,130,47,2,38,177,57,240,50,242,160,38,49,50,160,177,
57,240,50,242,160,36,81,50,64,240,107,64,194,242,160,39,34,34,240,97,57,
240,50,242,160,38,49,50,145,177,57,240,64,242,212,66,35,160,240,9,240,50,
242,198,34,35,129,193,57,240,65,242,160,38,34,35,129,193,57,240,65,242,198,
34,35,160,177,57,240,65,243,128,85,32,39,240,65,242,240,54,215,41,244,144,
53,33,197,57,243,1,121,192,32,32,81,242,63,4,33,106,47,20,160,245,111,4,41,
211,82,34,54,67,235,46,255,225,179,47,254,42,98,240,242,240,241,241,1,243,
79,14,160,57,241,50,57,248,16,246,139,91,185,245,47,1,129,121,242,244,242,
185,47,13,58,121,245,132,242,31,1,201,240,56,210,241,9,105,241,237,242,47,
4,153,121,246,130,47,5,80,80,251,255,23,240,115,255,225,0,31,35,31,5,15,
109,197,4,191,254,175,34,247,240,245,47,16,255,225,30,95,91,31,255,0,100,
121,159,55,13,31,100,31,254,0,64,64,80,240,148,244,161,242,79,1,201,127,2,
240,9,240,231,240,188,241,227,242,29,240,25,244,29,208,145,57,241,48,242,
96,34,49,97,32,255,224,21,114,19,159,255,0,62,24,15,254,29,95,0,240,38,209,
240,162,251,41,241,112,255,225,177,15,254,25,105,255,228,75,34,22,63,26,37,
15,254,75,66,242,126,241,25,240,34,241,250,255,240,10,249,228,69,151,54,
241,3,248,98,255,228,125,242,47,255,12,23,244,254,0,
}

Definition at line 80381 of file duktape-1.8.0/src/duktape.c.

                                                     {
255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89,
249,0,
};
#endif
 
#ifdef DUK_USE_SOURCE_NONBMP
/* IdentifierPart production with IdentifierStart and ASCII excluded */
/* duk_unicode_idp_m_ids_noa[] */
/*
 *  Automatically generated by extract_chars.py, do not edit!
 */
 
const duk_uint8_t duk_unicode_idp_m_ids_noa[397] = {
255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112,
245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34,
36,241,210,249,99,242,130,47,2,38,177,57,240,50,242,160,38,49,50,160,177,

◆ duk_unicode_ids_m_let_noa

const duk_uint8_t duk_unicode_ids_m_let_noa[42]

Initial value:

= {
255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89,
249,255,240,4,148,79,37,255,224,192,9,15,120,79,255,0,15,30,245,48,
}

Definition at line 80357 of file duktape-1.8.0/src/duktape.c.

◆ duk_unicode_ids_noa

const duk_uint8_t duk_unicode_ids_noa[791]

Definition at line 80274 of file duktape-1.8.0/src/duktape.c.

                                             {
249,176,176,80,111,7,47,15,47,254,11,197,191,0,72,2,15,115,66,19,57,2,34,2,
240,66,244,50,247,185,248,234,241,99,8,241,127,58,240,182,47,31,241,191,21,
18,245,50,15,1,24,27,35,15,2,2,240,239,15,244,156,15,10,241,26,21,6,240,
101,10,4,15,9,240,159,157,242,100,15,4,8,159,1,98,102,115,19,240,98,98,4,
52,15,2,14,18,47,0,31,5,85,19,240,98,98,18,18,31,17,50,15,5,47,2,130,34,
240,98,98,18,68,15,4,15,1,31,21,115,19,240,98,98,18,68,15,16,18,47,1,15,3,
2,84,34,52,18,2,20,20,36,191,8,15,38,114,34,240,114,146,68,15,12,23,31,21,
114,34,240,114,146,68,15,18,2,31,1,31,4,114,34,241,147,15,2,15,3,31,10,86,
240,36,240,130,130,3,111,44,242,2,29,111,44,18,3,18,3,7,50,98,34,2,3,18,50,
26,3,66,15,7,31,20,15,49,114,241,79,13,79,101,241,191,6,15,2,85,52,4,24,37,
205,15,3,241,107,241,178,4,255,224,59,35,54,32,35,63,25,35,63,17,35,54,32,
35,62,47,41,35,63,51,241,127,0,240,47,69,223,254,21,227,240,18,240,166,243,
180,47,1,194,63,0,240,47,0,240,47,0,194,47,1,242,79,21,5,15,53,244,137,241,
146,6,243,107,240,223,37,240,227,76,241,207,7,111,42,240,122,242,95,68,15,
79,241,255,3,111,41,240,238,31,2,241,111,12,241,79,27,43,241,79,93,50,63,0,
251,15,50,255,224,8,53,63,22,53,55,32,32,32,47,15,63,37,38,32,66,38,67,53,
92,98,38,246,96,224,240,44,245,112,80,57,32,68,112,32,32,35,42,51,100,80,
240,63,25,255,233,107,241,242,241,242,247,87,63,3,241,107,242,106,15,2,240,
122,98,98,98,98,98,98,98,111,66,15,254,12,146,240,184,132,52,95,70,114,47,
74,35,111,25,79,78,240,63,11,242,127,0,255,224,244,255,240,0,138,143,60,

◆ duk_unicode_re_ranges_digit

DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_digit[2]

Initial value:

= {
    (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
}

Definition at line 11056 of file duktape-1.8.0/src/duktape.c.

            : the description in E5 Section 15.10.2.6 has a typo, it
     *  contains 'A' twice and lacks 'a'; the intent is [0-9a-zA-Z_].
     */

Referenced by duk__parse_disjunction().

◆ duk_unicode_re_ranges_not_digit

DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_digit[4]

Initial value:

= {
    (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x002FUL,
    (duk_uint16_t) 0x003AUL, (duk_uint16_t) 0xFFFFUL,
}

Definition at line 11078 of file duktape-1.8.0/src/duktape.c.

◆ duk_unicode_re_ranges_not_white

DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_white[24]

Initial value:

= {
    (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x0008UL,
    (duk_uint16_t) 0x000EUL, (duk_uint16_t) 0x001FUL,
    (duk_uint16_t) 0x0021UL, (duk_uint16_t) 0x009FUL,
    (duk_uint16_t) 0x00A1UL, (duk_uint16_t) 0x167FUL,
    (duk_uint16_t) 0x1681UL, (duk_uint16_t) 0x180DUL,
    (duk_uint16_t) 0x180FUL, (duk_uint16_t) 0x1FFFUL,
    (duk_uint16_t) 0x200BUL, (duk_uint16_t) 0x2027UL,
    (duk_uint16_t) 0x202AUL, (duk_uint16_t) 0x202EUL,
    (duk_uint16_t) 0x2030UL, (duk_uint16_t) 0x205EUL,
    (duk_uint16_t) 0x2060UL, (duk_uint16_t) 0x2FFFUL,
    (duk_uint16_t) 0x3001UL, (duk_uint16_t) 0xFEFEUL,
    (duk_uint16_t) 0xFF00UL, (duk_uint16_t) 0xFFFFUL,
}

Definition at line 11082 of file duktape-1.8.0/src/duktape.c.

                                                                    {
    (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
    (duk_uint16_t) 0x0041UL, (duk_uint16_t) 0x005AUL,
    (duk_uint16_t) 0x005FUL, (duk_uint16_t) 0x005FUL,
    (duk_uint16_t) 0x0061UL, (duk_uint16_t) 0x007AUL,
};
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_digit[4] = {

◆ duk_unicode_re_ranges_not_wordchar

DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_wordchar[10]

Initial value:

= {
    (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x002FUL,
    (duk_uint16_t) 0x003AUL, (duk_uint16_t) 0x0040UL,
    (duk_uint16_t) 0x005BUL, (duk_uint16_t) 0x005EUL,
    (duk_uint16_t) 0x0060UL, (duk_uint16_t) 0x0060UL,
    (duk_uint16_t) 0x007BUL, (duk_uint16_t) 0xFFFFUL,
}

Definition at line 11096 of file duktape-1.8.0/src/duktape.c.

                                                                      {
    (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x0008UL,
    (duk_uint16_t) 0x000EUL, (duk_uint16_t) 0x001FUL,
    (duk_uint16_t) 0x0021UL, (duk_uint16_t) 0x009FUL,

◆ duk_unicode_re_ranges_white

DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_white[22]

Initial value:

= {
    (duk_uint16_t) 0x0009UL, (duk_uint16_t) 0x000DUL,
    (duk_uint16_t) 0x0020UL, (duk_uint16_t) 0x0020UL,
    (duk_uint16_t) 0x00A0UL, (duk_uint16_t) 0x00A0UL,
    (duk_uint16_t) 0x1680UL, (duk_uint16_t) 0x1680UL,
    (duk_uint16_t) 0x180EUL, (duk_uint16_t) 0x180EUL,
    (duk_uint16_t) 0x2000UL, (duk_uint16_t) 0x200AUL,
    (duk_uint16_t) 0x2028UL, (duk_uint16_t) 0x2029UL,
    (duk_uint16_t) 0x202FUL, (duk_uint16_t) 0x202FUL,
    (duk_uint16_t) 0x205FUL, (duk_uint16_t) 0x205FUL,
    (duk_uint16_t) 0x3000UL, (duk_uint16_t) 0x3000UL,
    (duk_uint16_t) 0xFEFFUL, (duk_uint16_t) 0xFEFFUL,
}

Definition at line 11059 of file duktape-1.8.0/src/duktape.c.

                    {
        return 1;
    }
    return 0;
}
 
/*
 *  Regexp range tables
 */
 

Referenced by duk__parse_disjunction().

◆ duk_unicode_re_ranges_wordchar

DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_wordchar[8]

Initial value:

= {
    (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
    (duk_uint16_t) 0x0041UL, (duk_uint16_t) 0x005AUL,
    (duk_uint16_t) 0x005FUL, (duk_uint16_t) 0x005FUL,
    (duk_uint16_t) 0x0061UL, (duk_uint16_t) 0x007AUL,
}

Definition at line 11072 of file duktape-1.8.0/src/duktape.c.

                                                                 {
    (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
};
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_white[22] = {
    (duk_uint16_t) 0x0009UL, (duk_uint16_t) 0x000DUL,

Referenced by duk__parse_disjunction().

◆ duk_unicode_xutf8_markers

DUK_INTERNAL const duk_uint8_t duk_unicode_xutf8_markers[7]

Initial value:

= {
    0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
}

Definition at line 10012 of file duktape-1.8.0/src/duktape.c.

10013 {

10014 /* 11 bits */

◆ duk_util_probe_steps

DUK_INTERNAL duk_uint8_t duk_util_probe_steps[32]

Initial value:

= {
    2, 3, 5, 7, 11, 13, 19, 31, 41, 47, 59, 67, 73, 79, 89, 101, 103, 107,
    109, 127, 137, 139, 149, 157, 163, 167, 173, 181, 191, 193, 197, 199
}

Definition at line 11368 of file duktape-1.8.0/src/duktape.c.

11370 {

11371 17, /* minimum prime */

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DUK__ADVANCEBYTES

◆ DUK__ADVANCECHARS

◆ DUK__ADVTOK

◆ DUK__ALLOCTEMP

◆ DUK__ALLOCTEMPS

◆ DUK__ALLOW_AUTO_SEMI_ALWAYS

◆ DUK__APPENDBUFFER

◆ DUK__ARRAY_MID_JOIN_LIMIT

◆ DUK__ASSERT_LEFT

◆ DUK__BC_INITIAL_INSTS

◆ DUK__BI_MAX_PARTS

◆ DUK__BI_PRINT

◆ DUK__BIDX_BITS

◆ DUK__BITPACK_FF

◆ DUK__BITPACK_LETTER_LIMIT

◆ DUK__BITPACK_SEVENBIT

◆ DUK__BITPACK_SWITCH

◆ DUK__BITPACK_SWITCH1

◆ DUK__BITPACK_UNDERSCORE

◆ DUK__BP_ADDITIVE

◆ DUK__BP_ASSIGNMENT

◆ DUK__BP_BAND

◆ DUK__BP_BOR

◆ DUK__BP_BXOR

◆ DUK__BP_CALL

◆ DUK__BP_CLOSING

◆ DUK__BP_COMMA

◆ DUK__BP_CONDITIONAL

◆ DUK__BP_EOF

◆ DUK__BP_EQUALITY

◆ DUK__BP_FOR_EXPR

◆ DUK__BP_INVALID

◆ DUK__BP_LAND

◆ DUK__BP_LOR

◆ DUK__BP_MEMBER

◆ DUK__BP_MULTIPLICATIVE

◆ DUK__BP_POSTFIX

◆ DUK__BP_RELATIONAL

◆ DUK__BP_SHIFT

◆ DUK__BYTECODE_INITIAL_ALLOC

◆ DUK__CF_ACCEPT

◆ DUK__CF_ACCEPT_NUL

◆ DUK__CF_NEG

◆ DUK__CHECK_BITMASK

◆ DUK__CHECK_SPACE

◆ DUK__CLASS_BITS

◆ DUK__COMPILE_ENTRY_SLOTS

◆ DUK__CONST

◆ DUK__CONST_MARKER

◆ DUK__CONSTP

◆ DUK__DELETED_MARKER

◆ DUK__DIGITCHAR

◆ DUK__DPRINT_DPARTS

◆ DUK__DPRINT_PARTS

◆ DUK__DPRINT_PARTS_AND_DPARTS

◆ DUK__DRAGON4_OUTPUT_PREINC

◆ DUK__DUMP_ISPEC

◆ DUK__DUMP_IVALUE

◆ DUK__EMIT_1

◆ DUK__EMIT_2

◆ DUK__EMIT_CSTR

◆ DUK__EMIT_FLAG_A_IS_SOURCE

◆ DUK__EMIT_FLAG_B_IS_TARGET

◆ DUK__EMIT_FLAG_B_IS_TARGETSOURCE

◆ DUK__EMIT_FLAG_C_IS_TARGET

◆ DUK__EMIT_FLAG_NO_SHUFFLE_A

◆ DUK__EMIT_FLAG_NO_SHUFFLE_B

◆ DUK__EMIT_FLAG_NO_SHUFFLE_C

◆ DUK__EMIT_FLAG_RESERVE_JUMPSLOT

◆ DUK__EMIT_HSTR

◆ DUK__EMIT_STRIDX

◆ DUK__ENUM_START_INDEX

◆ DUK__ERRFMT_BUFSIZE

◆ DUK__EXPR_FLAG_ALLOW_EMPTY