Github User Fetcher 1.0.0
C Application with Server and GUI
Loading...
Searching...
No Matches
duktape.c File Reference
#include "duktape.h"

Go to the source code of this file.

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__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 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_tvalduk_get_tval (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_tvalduk_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_hobjectduk_push_this_coercible_to_object (duk_context *ctx)
 
DUK_INTERNAL_DECL duk_hstringduk_push_this_coercible_to_string (duk_context *ctx)
 
DUK_INTERNAL_DECL duk_tvalduk_get_borrowed_this_tval (duk_context *ctx)
 
DUK_INTERNAL_DECL duk_hstringduk_get_hstring (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hobjectduk_get_hobject (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hbufferduk_get_hbuffer (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hthreadduk_get_hthread (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hcompiledfunctionduk_get_hcompiledfunction (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hnativefunctionduk_get_hnativefunction (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hobjectduk_get_hobject_with_class (duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)
 
DUK_INTERNAL_DECL duk_hobjectduk_get_hobject_or_lfunc_coerce (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hstringduk_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_hstringduk_require_hstring (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hobjectduk_require_hobject (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hbufferduk_require_hbuffer (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hthreadduk_require_hthread (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hcompiledfunctionduk_require_hcompiledfunction (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hnativefunctionduk_require_hnativefunction (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hobjectduk_require_hobject_with_class (duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)
 
DUK_INTERNAL_DECL duk_hobjectduk_require_hobject_or_lfunc (duk_context *ctx, duk_idx_t index)
 
DUK_INTERNAL_DECL duk_hobjectduk_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_hbufferobjectduk_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_hobjectduk_hobject_alloc (duk_heap *heap, duk_uint_t hobject_flags)
 
DUK_INTERNAL_DECL duk_hcompiledfunctionduk_hcompiledfunction_alloc (duk_heap *heap, duk_uint_t hobject_flags)
 
DUK_INTERNAL_DECL duk_hnativefunctionduk_hnativefunction_alloc (duk_heap *heap, duk_uint_t hobject_flags)
 
DUK_INTERNAL duk_hbufferobjectduk_hbufferobject_alloc (duk_heap *heap, duk_uint_t hobject_flags)
 
DUK_INTERNAL_DECL duk_hthreadduk_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_tvalduk_hobject_find_existing_entry_tval_ptr (duk_heap *heap, duk_hobject *obj, duk_hstring *key)
 
DUK_INTERNAL_DECL duk_tvalduk_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_tvalduk_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_hstringduk_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_hobjectduk_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_activationduk_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_hbufferduk_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_heapduk_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_hstringduk_heap_string_intern (duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen)
 
DUK_INTERNAL_DECL duk_hstringduk_heap_string_intern_checked (duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len)
 
DUK_INTERNAL_DECL duk_hstringduk_heap_string_intern_u32 (duk_heap *heap, duk_uint32_t val)
 
DUK_INTERNAL_DECL duk_hstringduk_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_hobjectduk_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_hstringduk_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_hobjectduk_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_contextduk_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_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_heaphdrduk__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_contextduk_get_context (duk_context *ctx, duk_idx_t index)
 
DUK_EXTERNAL duk_contextduk_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_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_hbufferobjectduk__getrequire_bufobj_this (duk_context *ctx, duk_bool_t throw_flag)
 
DUK_LOCAL duk_hbufferobjectduk__get_bufobj_this (duk_context *ctx)
 
DUK_LOCAL duk_hbufferobjectduk__require_bufobj_this (duk_context *ctx)
 
DUK_LOCAL duk_hbufferobjectduk__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_hbufferobjectduk__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_hthreadduk__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_hstringduk__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_hstringduk__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_hstringduk__do_intern (duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash)
 
DUK_LOCAL duk_hstringduk__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_tvalduk__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_hobjectduk__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_instrduk__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 73123 of file duktape-1.5.2/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 73122 of file duktape-1.5.2/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 73136 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__ALLOCTEMP

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

◆ DUK__ALLOCTEMPS

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

◆ DUK__ALLOW_AUTO_SEMI_ALWAYS

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

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

◆ DUK__APPENDBUFFER

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

Definition at line 73125 of file duktape-1.5.2/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 20055 of file duktape-1.5.2/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 12010 of file duktape-1.5.2/src/duktape.c.

12010 p = duk__dump_formals(thr, p, bw_ctx, (duk_hobject *) func);
12011
12012 DUK_DD(DUK_DDPRINT("serialized function %p -> final pointer %p", (void *) func, (void *) p));
DUK_LOCAL duk_uint8_t * duk__dump_formals(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func)
#define DUK_DD(x)
#define DUK_DDPRINT

◆ DUK__BC_INITIAL_INSTS

#define DUK__BC_INITIAL_INSTS   256

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

◆ DUK__BI_MAX_PARTS

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

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

◆ DUK__BI_PRINT

#define DUK__BI_PRINT ( name,
x )

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

◆ DUK__BIDX_BITS

#define DUK__BIDX_BITS   7

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

◆ DUK__BITPACK_FF

#define DUK__BITPACK_FF   27

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

◆ DUK__BITPACK_LETTER_LIMIT

#define DUK__BITPACK_LETTER_LIMIT   26

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

◆ DUK__BITPACK_SEVENBIT

#define DUK__BITPACK_SEVENBIT   31

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

◆ DUK__BITPACK_SWITCH

#define DUK__BITPACK_SWITCH   30

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

◆ DUK__BITPACK_SWITCH1

#define DUK__BITPACK_SWITCH1   29

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

◆ DUK__BITPACK_UNDERSCORE

#define DUK__BITPACK_UNDERSCORE   26

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

◆ DUK__BP_ADDITIVE

#define DUK__BP_ADDITIVE   28

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

◆ DUK__BP_ASSIGNMENT

#define DUK__BP_ASSIGNMENT   8

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

◆ DUK__BP_BAND

#define DUK__BP_BAND   20

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

◆ DUK__BP_BOR

#define DUK__BP_BOR   16

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

◆ DUK__BP_BXOR

#define DUK__BP_BXOR   18

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

◆ DUK__BP_CALL

#define DUK__BP_CALL   34

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

◆ DUK__BP_CLOSING

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

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

◆ DUK__BP_COMMA

#define DUK__BP_COMMA   6

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

Referenced by duk__parse_var_decl().

◆ DUK__BP_CONDITIONAL

#define DUK__BP_CONDITIONAL   10

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

◆ DUK__BP_EOF

#define DUK__BP_EOF   2

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

◆ DUK__BP_EQUALITY

#define DUK__BP_EQUALITY   22

Definition at line 57718 of file duktape-1.5.2/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 57709 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_try_stmt().

◆ DUK__BP_INVALID

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

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

◆ DUK__BP_LAND

#define DUK__BP_LAND   14

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

◆ DUK__BP_LOR

#define DUK__BP_LOR   12

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

◆ DUK__BP_MEMBER

#define DUK__BP_MEMBER   36

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

◆ DUK__BP_MULTIPLICATIVE

#define DUK__BP_MULTIPLICATIVE   30

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

◆ DUK__BP_POSTFIX

#define DUK__BP_POSTFIX   32

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

◆ DUK__BP_RELATIONAL

#define DUK__BP_RELATIONAL   24

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

◆ DUK__BP_SHIFT

#define DUK__BP_SHIFT   26

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

◆ DUK__BYTECODE_INITIAL_ALLOC

#define DUK__BYTECODE_INITIAL_ALLOC   256

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

◆ DUK__CF_ACCEPT

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

Definition at line 24548 of file duktape-1.5.2/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 24549 of file duktape-1.5.2/src/duktape.c.

◆ DUK__CF_NEG

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

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

◆ DUK__CHECK_BITMASK

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

Definition at line 27618 of file duktape-1.5.2/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)
#define DUK_STR_PUSH_BEYOND_ALLOC_STACK

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

14969
14970#ifndef DUK_USE_VARIADIC_MACROS
14973#endif
duk_int_fast32_t duk_int_t
DUK_EXTERNAL duk_int_t duk_api_global_line
DUK_EXTERNAL const char * duk_api_global_filename
#define NULL
Definition gmacros.h:924

Referenced by duk_dup_top(), and duk_push_undefined().

◆ DUK__CLASS_BITS

#define DUK__CLASS_BITS   5

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

◆ DUK__COMPILE_ENTRY_SLOTS

#define DUK__COMPILE_ENTRY_SLOTS   8

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

◆ DUK__CONST

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

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

◆ DUK__CONST_MARKER

#define DUK__CONST_MARKER   DUK_JS_CONST_MARKER

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

Referenced by duk__ispec_toregconst_raw().

◆ DUK__CONSTP

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

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

◆ DUK__DELETED_MARKER

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

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

◆ DUK__DIGITCHAR

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

Definition at line 75117 of file duktape-1.5.2/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)
#define DUK_DPRINT

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

24452 DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld, dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
24453 (long) (parts)[0], (long) (parts)[1], \
24454 (long) (parts)[2], (long) (parts)[3], \
24455 (long) (parts)[4], (long) (parts)[5], \
24456 (long) (parts)[6], (long) (parts)[7], \
24457 (double) (dparts)[0], (double) (dparts)[1], \
24458 (double) (dparts)[2], (double) (dparts)[3], \
#define DUK_D(x)

◆ 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 24445 of file duktape-1.5.2/src/duktape.c.

24445
24446/*
24447 * Other file level defines
24448 */
24449
24450/* Debug macro to print all parts and dparts (used manually because of debug level). */
24451#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 24434 of file duktape-1.5.2/src/duktape.c.

24434
24435/* include removed: duk_internal.h */
24436
24437/*
24438 * Forward declarations
24439 */
24440
unsigned int duk_small_uint_t
duk_small_int_t duk_ret_t
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_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, 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_double_t duk__push_this_get_timeval(duk_context *ctx, 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)
#define DUK__MAX_OUTPUT_DIGITS

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

75766 duk_small_int_t e; /* exponent for 'f' */
75767 duk_small_int_t b; /* input radix */
75768 duk_small_int_t B; /* output radix */
75769 duk_small_int_t k; /* see algorithm */
75770 duk_small_int_t low_ok; /* see algorithm */

◆ DUK__DUMP_ISPEC

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

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

◆ DUK__DUMP_IVALUE

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

Definition at line 59276 of file duktape-1.5.2/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 29928 of file duktape-1.5.2/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 29929 of file duktape-1.5.2/src/duktape.c.

◆ DUK__EMIT_CSTR

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

Definition at line 29932 of file duktape-1.5.2/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 58471 of file duktape-1.5.2/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 58472 of file duktape-1.5.2/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 58474 of file duktape-1.5.2/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 58473 of file duktape-1.5.2/src/duktape.c.

◆ DUK__EMIT_FLAG_NO_SHUFFLE_A

#define DUK__EMIT_FLAG_NO_SHUFFLE_A   (1 << 8)

◆ DUK__EMIT_FLAG_NO_SHUFFLE_B

#define DUK__EMIT_FLAG_NO_SHUFFLE_B   (1 << 9)

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

◆ DUK__EMIT_FLAG_NO_SHUFFLE_C

#define DUK__EMIT_FLAG_NO_SHUFFLE_C   (1 << 10)

Definition at line 58470 of file duktape-1.5.2/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 58475 of file duktape-1.5.2/src/duktape.c.

◆ DUK__EMIT_HSTR

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

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

◆ DUK__EMIT_STRIDX

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

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

◆ DUK__ENUM_START_INDEX

#define DUK__ENUM_START_INDEX   2

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

Referenced by duk__sort_array_indices().

◆ DUK__ERRFMT_BUFSIZE

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

Definition at line 9769 of file duktape-1.5.2/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 62225 of file duktape-1.5.2/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 62224 of file duktape-1.5.2/src/duktape.c.

◆ DUK__EXPR_FLAG_REQUIRE_INIT

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

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

◆ DUK__EXPR_RBP_MASK

#define DUK__EXPR_RBP_MASK   0xff

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

◆ DUK__FLD_16BIT

#define DUK__FLD_16BIT   1

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

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_32BIT

#define DUK__FLD_32BIT   2

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

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_8BIT

#define DUK__FLD_8BIT   0

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

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_BIGENDIAN

#define DUK__FLD_BIGENDIAN   (1 << 3)

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

◆ DUK__FLD_DOUBLE

#define DUK__FLD_DOUBLE   4

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

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_FLOAT

#define DUK__FLD_FLOAT   3

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

Referenced by duk_bi_buffer_readfield().

◆ DUK__FLD_SIGNED

#define DUK__FLD_SIGNED   (1 << 4)

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

◆ DUK__FLD_TYPEDARRAY

#define DUK__FLD_TYPEDARRAY   (1 << 5)

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

◆ DUK__FLD_VARINT

#define DUK__FLD_VARINT   5

Definition at line 23842 of file duktape-1.5.2/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 67265 of file duktape-1.5.2/src/duktape.c.

◆ DUK__FUNCTION_BODY_REQUIRE_SLOTS

#define DUK__FUNCTION_BODY_REQUIRE_SLOTS   16

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

Referenced by duk__parse_func_body().

◆ DUK__FUNCTION_INIT_REQUIRE_SLOTS

#define DUK__FUNCTION_INIT_REQUIRE_SLOTS   16

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

◆ DUK__GETCONST_MAX_CONSTS_CHECK

#define DUK__GETCONST_MAX_CONSTS_CHECK   256

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

◆ DUK__GETTEMP

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

Definition at line 59239 of file duktape-1.5.2/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 62417 of file duktape-1.5.2/src/duktape.c.

◆ DUK__HAS_VAL

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

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

◆ DUK__HASH_DELETED

#define DUK__HASH_DELETED   DUK_HOBJECT_HASHIDX_DELETED

Definition at line 47231 of file duktape-1.5.2/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 44762 of file duktape-1.5.2/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 44762 of file duktape-1.5.2/src/duktape.c.

◆ DUK__HASH_PROBE_STEP [1/2]

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

Definition at line 44763 of file duktape-1.5.2/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 44763 of file duktape-1.5.2/src/duktape.c.

◆ DUK__HASH_SIZE_RATIO

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

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

◆ DUK__HASH_UNUSED

#define DUK__HASH_UNUSED   DUK_HOBJECT_HASHIDX_UNUSED

Definition at line 47230 of file duktape-1.5.2/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 6696 of file duktape-1.5.2/src/duktape.c.

6696#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING (1 << 3) /* an error handler (user callback to augment/replace error) is running */
6697#define DUK_HEAP_FLAG_INTERRUPT_RUNNING (1 << 4) /* executor interrupt running (used to avoid nested interrupts) */
6698#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 6692 of file duktape-1.5.2/src/duktape.c.

◆ DUK__HEAP_SET_FLAGS

#define DUK__HEAP_SET_FLAGS ( heap,
bits )
Value:
do { \
(heap)->flags |= (bits); \
} while (0)

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

6693#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING (1 << 0) /* mark-and-sweep is currently running */
6694#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED (1 << 1) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
6695#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 28614 of file duktape-1.5.2/src/duktape.c.

◆ DUK__IDX_EXPORTS

#define DUK__IDX_EXPORTS   9 /* Default exports table */

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

◆ DUK__IDX_FRESH_REQUIRE

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

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

◆ DUK__IDX_LASTCOMP

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

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

◆ DUK__IDX_MODLOADED

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

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

◆ DUK__IDX_MODULE

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

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

◆ DUK__IDX_REQUESTED_ID

#define DUK__IDX_REQUESTED_ID   0 /* Module id requested */

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

◆ DUK__IDX_REQUIRE

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

Definition at line 28610 of file duktape-1.5.2/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 28611 of file duktape-1.5.2/src/duktape.c.

◆ DUK__IDX_RESOLVED_ID

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

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

◆ DUK__IDX_UNDEFINED

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

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

◆ DUK__IEEE_DOUBLE_EXP_BIAS

#define DUK__IEEE_DOUBLE_EXP_BIAS   1023

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

◆ DUK__IEEE_DOUBLE_EXP_MIN

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

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

Referenced by duk__dragon4_ctx_to_double().

◆ DUK__INITBUFFER

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

Definition at line 73124 of file duktape-1.5.2/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 67291 of file duktape-1.5.2/src/duktape.c.

67291#define DUK__CONST(x) (*(consts + (x)))
67292#define DUK__CONSTP(x) (consts + (x))
67293#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 62420 of file duktape-1.5.2/src/duktape.c.

◆ DUK__ISCONST

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

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

◆ DUK__ISDIGIT

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

Definition at line 73114 of file duktape-1.5.2/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 73117 of file duktape-1.5.2/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 73118 of file duktape-1.5.2/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 73115 of file duktape-1.5.2/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 73116 of file duktape-1.5.2/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 59236 of file duktape-1.5.2/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 59238 of file duktape-1.5.2/src/duktape.c.

◆ DUK__ITER_EVERY

#define DUK__ITER_EVERY   0

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

◆ DUK__ITER_FILTER

#define DUK__ITER_FILTER   4

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

◆ DUK__ITER_FOREACH

#define DUK__ITER_FOREACH   2

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

◆ DUK__ITER_MAP

#define DUK__ITER_MAP   3

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

◆ DUK__ITER_SOME

#define DUK__ITER_SOME   1

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

◆ DUK__IVAL_FLAG_ALLOW_CONST

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

◆ 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 59251 of file duktape-1.5.2/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) */

◆ DUK__JSON_DECSTR_BUFSIZE

#define DUK__JSON_DECSTR_BUFSIZE   128

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

◆ DUK__JSON_DECSTR_CHUNKSIZE

#define DUK__JSON_DECSTR_CHUNKSIZE   64

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

◆ DUK__JSON_ENCSTR_CHUNKSIZE

#define DUK__JSON_ENCSTR_CHUNKSIZE   64

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

◆ DUK__JSON_MAX_ESC_LEN

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

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

◆ DUK__JSON_STRINGIFY_BUFSIZE

#define DUK__JSON_STRINGIFY_BUFSIZE   128

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

◆ DUK__L0

#define DUK__L0 ( )    DUK__LOOKUP(lex_ctx, 0)

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L1

#define DUK__L1 ( )    DUK__LOOKUP(lex_ctx, 1)

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L2

#define DUK__L2 ( )    DUK__LOOKUP(lex_ctx, 2)

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L3

#define DUK__L3 ( )    DUK__LOOKUP(lex_ctx, 3)

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__L4

#define DUK__L4 ( )    DUK__LOOKUP(lex_ctx, 4)

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

◆ DUK__L5

#define DUK__L5 ( )    DUK__LOOKUP(lex_ctx, 5)

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

◆ DUK__LENGTH_PROP_BITS

#define DUK__LENGTH_PROP_BITS   3

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

◆ DUK__LOCAL_TZOFFSET_MAXITER

#define DUK__LOCAL_TZOFFSET_MAXITER   4

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

◆ DUK__LONGJMP_RESTART

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

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

◆ DUK__LONGJMP_RETHROW

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

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

◆ DUK__LOOKUP

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

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK__MAGIC_BITS

#define DUK__MAGIC_BITS   16

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

◆ DUK__MAX_ARRAY_INIT_VALUES

#define DUK__MAX_ARRAY_INIT_VALUES   20

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

◆ DUK__MAX_CONSTS

#define DUK__MAX_CONSTS   DUK_BC_BC_MAX

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

◆ DUK__MAX_FORMATTED_LENGTH

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

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

◆ DUK__MAX_FUNCS

#define DUK__MAX_FUNCS   DUK_BC_BC_MAX

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

◆ DUK__MAX_OBJECT_INIT_PAIRS

#define DUK__MAX_OBJECT_INIT_PAIRS   10

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

◆ DUK__MAX_OUTPUT_DIGITS

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

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

◆ DUK__MAX_RE_DECESC_DIGITS

#define DUK__MAX_RE_DECESC_DIGITS   9

Definition at line 73110 of file duktape-1.5.2/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 73111 of file duktape-1.5.2/src/duktape.c.

◆ DUK__MAX_TEMPS

#define DUK__MAX_TEMPS   0xffffL

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

◆ DUK__MK_LBP

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

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

◆ DUK__MK_LBP_FLAGS

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

Definition at line 57735 of file duktape-1.5.2/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 27614 of file duktape-1.5.2/src/duktape.c.

27614 * Global object built-ins
27615 */
27616
27617/* 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))
duk_uint32_t duk_uint_fast32_t

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

29971
29973 duk_hstring *h;
29974
DUK_LOCAL_DECL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx)

◆ DUK__NARGS_BITS

#define DUK__NARGS_BITS   3

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

◆ DUK__NARGS_VARARGS_MARKER

#define DUK__NARGS_VARARGS_MARKER   0x07

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

◆ DUK__NATIDX_BITS

#define DUK__NATIDX_BITS   8

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

◆ DUK__NO_ARRAY_INDEX

◆ DUK__NO_BIDX_MARKER

#define DUK__NO_BIDX_MARKER   0x7f

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

◆ DUK__NO_CLASS_MARKER

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

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

◆ DUK__NO_EXP

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

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

◆ DUK__NO_STRIDX_MARKER

#define DUK__NO_STRIDX_MARKER   0xff

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

◆ DUK__NUM_FUNC_PROPS_BITS

#define DUK__NUM_FUNC_PROPS_BITS   6

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

◆ DUK__NUM_ISO8601_PARSER_PARTS

#define DUK__NUM_ISO8601_PARSER_PARTS   9

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

◆ DUK__NUM_NORMAL_PROPS_BITS

#define DUK__NUM_NORMAL_PROPS_BITS   6

Definition at line 53330 of file duktape-1.5.2/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 75735 of file duktape-1.5.2/src/duktape.c.

◆ DUK__NUMCONV_CTX_NUM_BIGINTS

#define DUK__NUMCONV_CTX_NUM_BIGINTS   7

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

◆ DUK__OBJ_LIT_KEY_GET

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

Definition at line 60201 of file duktape-1.5.2/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 60200 of file duktape-1.5.2/src/duktape.c.

◆ DUK__OBJ_LIT_KEY_SET

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

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

◆ DUK__OUTPUT_TYPE_FILENAME

#define DUK__OUTPUT_TYPE_FILENAME   0

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

Referenced by duk__error_getter_helper().

◆ DUK__OUTPUT_TYPE_LINENUMBER

#define DUK__OUTPUT_TYPE_LINENUMBER   1

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

Referenced by duk__error_getter_helper().

◆ DUK__OUTPUT_TYPE_TRACEBACK

#define DUK__OUTPUT_TYPE_TRACEBACK   (-1)

Definition at line 26977 of file duktape-1.5.2/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 18822 of file duktape-1.5.2/src/duktape.c.

18823 }
#define DUK_ERROR_ALLOC_DEFMSG(thr)

◆ 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 24551 of file duktape-1.5.2/src/duktape.c.

24551#define DUK__SI_NUL 7
24552
24553/* Parser separator masks. */
24554#define DUK__SM_PLUS (1 << DUK__SI_PLUS)
24555#define DUK__SM_MINUS (1 << DUK__SI_MINUS)

◆ DUK__PARSE_EXPR_SLOTS

#define DUK__PARSE_EXPR_SLOTS   16

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

◆ DUK__PARSE_STATEMENTS_SLOTS

#define DUK__PARSE_STATEMENTS_SLOTS   16

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

◆ DUK__PI_DAY

#define DUK__PI_DAY   2

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

◆ DUK__PI_HOUR

#define DUK__PI_HOUR   3

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

◆ DUK__PI_MILLISECOND

#define DUK__PI_MILLISECOND   6

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

◆ DUK__PI_MINUTE

#define DUK__PI_MINUTE   4

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

◆ DUK__PI_MONTH

#define DUK__PI_MONTH   1

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

◆ DUK__PI_SECOND

#define DUK__PI_SECOND   5

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

◆ DUK__PI_TZHOUR

#define DUK__PI_TZHOUR   7

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

◆ DUK__PI_TZMINUTE

#define DUK__PI_TZMINUTE   8

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

◆ DUK__PI_YEAR

#define DUK__PI_YEAR   0

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

◆ DUK__PM_DAY

#define DUK__PM_DAY   (1 << DUK__PI_DAY)

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

◆ DUK__PM_HOUR

#define DUK__PM_HOUR   (1 << DUK__PI_HOUR)

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

◆ DUK__PM_MILLISECOND

#define DUK__PM_MILLISECOND   (1 << DUK__PI_MILLISECOND)

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

◆ DUK__PM_MINUTE

#define DUK__PM_MINUTE   (1 << DUK__PI_MINUTE)

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

◆ DUK__PM_MONTH

#define DUK__PM_MONTH   (1 << DUK__PI_MONTH)

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

◆ DUK__PM_SECOND

#define DUK__PM_SECOND   (1 << DUK__PI_SECOND)

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

◆ DUK__PM_TZHOUR

#define DUK__PM_TZHOUR   (1 << DUK__PI_TZHOUR)

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

◆ DUK__PM_TZMINUTE

#define DUK__PM_TZMINUTE   (1 << DUK__PI_TZMINUTE)

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

◆ DUK__PM_YEAR

#define DUK__PM_YEAR   (1 << DUK__PI_YEAR)

Definition at line 24516 of file duktape-1.5.2/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)
#define DUK_MS_FLAG_NO_OBJECT_COMPACTION
#define DUK_MS_FLAG_NO_FINALIZERS
#define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE

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

44769 return 0;
44770}
44771#line 1 "duk_heap_stringtable.c"
44772/*
44773 * Heap stringtable handling, string interning.
#define DUK_ERROR_INTERNAL_DEFMSG(thr)

◆ DUK__PROP_FLAGS_BITS

#define DUK__PROP_FLAGS_BITS   3

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

◆ DUK__PROP_TYPE_ACCESSOR

#define DUK__PROP_TYPE_ACCESSOR   7

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

◆ DUK__PROP_TYPE_BITS

#define DUK__PROP_TYPE_BITS   3

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

◆ DUK__PROP_TYPE_BOOLEAN_FALSE

#define DUK__PROP_TYPE_BOOLEAN_FALSE   6

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

◆ DUK__PROP_TYPE_BOOLEAN_TRUE

#define DUK__PROP_TYPE_BOOLEAN_TRUE   5

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

◆ DUK__PROP_TYPE_BUILTIN

#define DUK__PROP_TYPE_BUILTIN   3

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

◆ DUK__PROP_TYPE_DOUBLE

#define DUK__PROP_TYPE_DOUBLE   0

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

◆ DUK__PROP_TYPE_STRIDX

#define DUK__PROP_TYPE_STRIDX   2

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

◆ DUK__PROP_TYPE_STRING

#define DUK__PROP_TYPE_STRING   1

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

◆ DUK__PROP_TYPE_UNDEFINED

#define DUK__PROP_TYPE_UNDEFINED   4

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

◆ DUK__RCISREG

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

Definition at line 67286 of file duktape-1.5.2/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 77398 of file duktape-1.5.2/src/duktape.c.

77398 * maximum supported size. This could be done by limiting the maximum
77399 * 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 77395 of file duktape-1.5.2/src/duktape.c.

◆ DUK__READABLE_STRING_MAXCHARS

#define DUK__READABLE_STRING_MAXCHARS   32

Definition at line 19472 of file duktape-1.5.2/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)
#define DUK_DDDPRINT

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

57520#define DUK__GETCONST_MAX_CONSTS_CHECK 256
57521
57522/* These limits are based on bytecode limits. Max temps is limited
57523 * 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 57515 of file duktape-1.5.2/src/duktape.c.

57515/* for array and object literals */
57516#define DUK__MAX_ARRAY_INIT_VALUES 20
57517#define DUK__MAX_OBJECT_INIT_PAIRS 10
57518

Referenced by duk__parse_func_body().

◆ DUK__REG

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

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

◆ DUK__REGCONST

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

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

◆ DUK__REGCONSTP

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

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

◆ DUK__REGP

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

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

◆ DUK__RETHAND_FINISHED

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

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

◆ DUK__RETHAND_RESTART

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

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

◆ DUK__RND_BIT

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

Definition at line 86631 of file duktape-1.5.2/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 24562 of file duktape-1.5.2/src/duktape.c.

◆ DUK__SER_MARKER

#define DUK__SER_MARKER   0xff

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

◆ DUK__SER_NUMBER

#define DUK__SER_NUMBER   0x01

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

◆ DUK__SER_STRING

#define DUK__SER_STRING   0x00

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

◆ DUK__SER_VERSION

#define DUK__SER_VERSION   0x00

Definition at line 11661 of file duktape-1.5.2/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) */

◆ DUK__SETTEMP_CHECKMAX

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

◆ DUK__SI_COLON

#define DUK__SI_COLON   4

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

◆ DUK__SI_MINUS

#define DUK__SI_MINUS   1

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

◆ DUK__SI_NUL

#define DUK__SI_NUL   7

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

◆ DUK__SI_PERIOD

#define DUK__SI_PERIOD   5

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

◆ DUK__SI_PLUS

#define DUK__SI_PLUS   0

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

◆ DUK__SI_SPACE

#define DUK__SI_SPACE   3

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

◆ DUK__SI_T

#define DUK__SI_T   2

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

◆ DUK__SI_Z

#define DUK__SI_Z   6

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

◆ DUK__SM_COLON

#define DUK__SM_COLON   (1 << DUK__SI_COLON)

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

◆ DUK__SM_MINUS

#define DUK__SM_MINUS   (1 << DUK__SI_MINUS)

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

◆ DUK__SM_NUL

#define DUK__SM_NUL   (1 << DUK__SI_NUL)

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

◆ DUK__SM_PERIOD

#define DUK__SM_PERIOD   (1 << DUK__SI_PERIOD)

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

◆ DUK__SM_PLUS

#define DUK__SM_PLUS   (1 << DUK__SI_PLUS)

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

◆ DUK__SM_SPACE

#define DUK__SM_SPACE   (1 << DUK__SI_SPACE)

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

◆ DUK__SM_T

#define DUK__SM_T   (1 << DUK__SI_T)

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

◆ DUK__SM_Z

#define DUK__SM_Z   (1 << DUK__SI_Z)

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

◆ DUK__STILL_PROLOGUE

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

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

◆ DUK__STRFTIME_BUF_SIZE

#define DUK__STRFTIME_BUF_SIZE   64

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

◆ DUK__STRICT

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

Definition at line 67267 of file duktape-1.5.2/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 53328 of file duktape-1.5.2/src/duktape.c.

◆ DUK__STRING_CHAR_BITS

#define DUK__STRING_CHAR_BITS   7

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

Referenced by duk__push_double().

◆ DUK__STRING_LENGTH_BITS

#define DUK__STRING_LENGTH_BITS   8

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

◆ DUK__STRPTIME_BUF_SIZE

#define DUK__STRPTIME_BUF_SIZE   64

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

◆ DUK__SYNC_AND_NULL_CURR_PC

#define DUK__SYNC_AND_NULL_CURR_PC ( )
Value:
do { \
act = thr->callstack + thr->callstack_top - 1; \
act->curr_pc = curr_pc; \
thr->ptr_curr_pc = NULL; \
} while (0)

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

67305#define DUK__REGCONSTP(x) ((DUK__RCISREG((x)) ? thr->valstack_bottom : consts2) + (x))
67306
67307#ifdef DUK_USE_VERBOSE_EXECUTOR_ERRORS
67308#define DUK__INTERNAL_ERROR(msg) do { \
67309 DUK_ERROR_INTERNAL(thr, (msg)); \
67310 } while (0)

◆ DUK__SYNC_CURR_PC

#define DUK__SYNC_CURR_PC ( )
Value:
do { \
act = thr->callstack + thr->callstack_top - 1; \
act->curr_pc = curr_pc; \
} while (0)

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

67300 * DUK_LIKELY/DUK_UNLIKELY increases code footprint and doesn't seem to
67301 * improve performance on x64 (and actually harms performance in some tests).
67302 */
67303#define DUK__RCISREG(x) (((x) & 0x100) == 0)
67304#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.5.2/src/duktape.c.

◆ DUK__TOKEN_LBP_BP_MASK

#define DUK__TOKEN_LBP_BP_MASK   0x1f

Definition at line 57727 of file duktape-1.5.2/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 57728 of file duktape-1.5.2/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 57729 of file duktape-1.5.2/src/duktape.c.

◆ DUK__TOKEN_LBP_FLAG_UNUSED

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

Definition at line 57730 of file duktape-1.5.2/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 57732 of file duktape-1.5.2/src/duktape.c.

◆ DUK__UNEMIT_1

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

Definition at line 29935 of file duktape-1.5.2/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 24557 of file duktape-1.5.2/src/duktape.c.

24557#define DUK__SM_SPACE (1 << DUK__SI_SPACE)
24558#define DUK__SM_COLON (1 << DUK__SI_COLON)
24559#define DUK__SM_PERIOD (1 << DUK__SI_PERIOD)
24560#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 86626 of file duktape-1.5.2/src/duktape.c.

86626 h *= DUK__MAGIC_M;
86627 h ^= h >> 15;
86628
86629 return h;

Referenced by duk_util_tinyrandom_get_double().

◆ DUK__VALSTACK_PROXY_LOOKUP

#define DUK__VALSTACK_PROXY_LOOKUP   20

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

◆ DUK__VALSTACK_SPACE

◆ 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 43391 of file duktape-1.5.2/src/duktape.c.

43391#endif /* DUK_USE_MARK_AND_SWEEP */
43392#line 1 "duk_heap_memory.c"
43393/*
43394 * Memory allocation handling.
43395 */
43396

◆ DUK__WEEKDAY_MOD_ADDER

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

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

◆ DUK__YEAR

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

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

◆ DUK_ACT_FLAG_BREAKPOINT_ACTIVE

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

Definition at line 6014 of file duktape-1.5.2/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 6011 of file duktape-1.5.2/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 6013 of file duktape-1.5.2/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") */

◆ DUK_ACT_FLAG_STRICT

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

◆ DUK_ACT_FLAG_TAILCALLED

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

◆ DUK_ACT_GET_FUNC

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

◆ DUK_ALLOC

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

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

Referenced by duk__alloc_init_hstring(), and duk_realloc().

◆ DUK_ALLOC_RAW

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

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

6846 ((heap)->strs[(idx)])
6847#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 6887 of file duktape-1.5.2/src/duktape.c.

◆ DUK_API_INTERNAL_H_INCLUDED

#define DUK_API_INTERNAL_H_INCLUDED

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

◆ DUK_ASC_0

#define DUK_ASC_0   0x30

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

◆ DUK_ASC_1

#define DUK_ASC_1   0x31

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

◆ DUK_ASC_2

#define DUK_ASC_2   0x32

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

◆ DUK_ASC_3

#define DUK_ASC_3   0x33

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

◆ DUK_ASC_4

#define DUK_ASC_4   0x34

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

◆ DUK_ASC_5

#define DUK_ASC_5   0x35

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

◆ DUK_ASC_6

#define DUK_ASC_6   0x36

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

◆ DUK_ASC_7

#define DUK_ASC_7   0x37

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

◆ DUK_ASC_8

#define DUK_ASC_8   0x38

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

◆ DUK_ASC_9

#define DUK_ASC_9   0x39

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

◆ DUK_ASC_ACK

#define DUK_ASC_ACK   0x06

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

◆ DUK_ASC_AMP

#define DUK_ASC_AMP   0x26

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_ATSIGN

#define DUK_ASC_ATSIGN   0x40

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

◆ DUK_ASC_BACKSLASH

#define DUK_ASC_BACKSLASH   0x5c

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

Referenced by duk__create_escaped_source().

◆ DUK_ASC_BEL

#define DUK_ASC_BEL   0x07

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

◆ DUK_ASC_BS

#define DUK_ASC_BS   0x08

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

◆ DUK_ASC_CAN

#define DUK_ASC_CAN   0x18

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

◆ DUK_ASC_CARET

#define DUK_ASC_CARET   0x5e

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_COLON

#define DUK_ASC_COLON   0x3a

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_COMMA

#define DUK_ASC_COMMA   0x2c

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_CR

#define DUK_ASC_CR   0x0d

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

◆ DUK_ASC_DC1

#define DUK_ASC_DC1   0x11

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

◆ DUK_ASC_DC2

#define DUK_ASC_DC2   0x12

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

◆ DUK_ASC_DC3

#define DUK_ASC_DC3   0x13

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

◆ DUK_ASC_DC4

#define DUK_ASC_DC4   0x14

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

◆ DUK_ASC_DEL

#define DUK_ASC_DEL   0x7f

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

◆ DUK_ASC_DLE

#define DUK_ASC_DLE   0x10

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

◆ DUK_ASC_DOLLAR

#define DUK_ASC_DOLLAR   0x24

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

◆ DUK_ASC_DOUBLEQUOTE

#define DUK_ASC_DOUBLEQUOTE   0x22

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_EM

#define DUK_ASC_EM   0x19

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

◆ DUK_ASC_ENQ

#define DUK_ASC_ENQ   0x05

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

◆ DUK_ASC_EOT

#define DUK_ASC_EOT   0x04

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

◆ DUK_ASC_EQUALS

#define DUK_ASC_EQUALS   0x3d

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_ESC

#define DUK_ASC_ESC   0x1b

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

◆ DUK_ASC_ETB

#define DUK_ASC_ETB   0x17

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

◆ DUK_ASC_ETX

#define DUK_ASC_ETX   0x03

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

◆ DUK_ASC_EXCLAMATION

#define DUK_ASC_EXCLAMATION   0x21

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_FF

#define DUK_ASC_FF   0x0c

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

◆ DUK_ASC_FS

#define DUK_ASC_FS   0x1c

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

◆ DUK_ASC_GRAVE

#define DUK_ASC_GRAVE   0x60

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

◆ DUK_ASC_GS

#define DUK_ASC_GS   0x1d

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

◆ DUK_ASC_HASH

#define DUK_ASC_HASH   0x23

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

◆ DUK_ASC_HT

#define DUK_ASC_HT   0x09

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LANGLE

#define DUK_ASC_LANGLE   0x3c

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LBRACKET

#define DUK_ASC_LBRACKET   0x5b

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LC_A

#define DUK_ASC_LC_A   0x61

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

◆ DUK_ASC_LC_B

#define DUK_ASC_LC_B   0x62

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

◆ DUK_ASC_LC_C

#define DUK_ASC_LC_C   0x63

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

◆ DUK_ASC_LC_D

#define DUK_ASC_LC_D   0x64

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

◆ DUK_ASC_LC_E

#define DUK_ASC_LC_E   0x65

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

◆ DUK_ASC_LC_F

#define DUK_ASC_LC_F   0x66

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

◆ DUK_ASC_LC_G

#define DUK_ASC_LC_G   0x67

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

◆ DUK_ASC_LC_H

#define DUK_ASC_LC_H   0x68

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

◆ DUK_ASC_LC_I

#define DUK_ASC_LC_I   0x69

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

◆ DUK_ASC_LC_J

#define DUK_ASC_LC_J   0x6a

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

◆ DUK_ASC_LC_K

#define DUK_ASC_LC_K   0x6b

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

◆ DUK_ASC_LC_L

#define DUK_ASC_LC_L   0x6c

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

◆ DUK_ASC_LC_M

#define DUK_ASC_LC_M   0x6d

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

◆ DUK_ASC_LC_N

#define DUK_ASC_LC_N   0x6e

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

◆ DUK_ASC_LC_O

#define DUK_ASC_LC_O   0x6f

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

◆ DUK_ASC_LC_P

#define DUK_ASC_LC_P   0x70

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

◆ DUK_ASC_LC_Q

#define DUK_ASC_LC_Q   0x71

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

◆ DUK_ASC_LC_R

#define DUK_ASC_LC_R   0x72

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

◆ DUK_ASC_LC_S

#define DUK_ASC_LC_S   0x73

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

◆ DUK_ASC_LC_T

#define DUK_ASC_LC_T   0x74

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

◆ DUK_ASC_LC_U

#define DUK_ASC_LC_U   0x75

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

◆ DUK_ASC_LC_V

#define DUK_ASC_LC_V   0x76

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

◆ DUK_ASC_LC_W

#define DUK_ASC_LC_W   0x77

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

◆ DUK_ASC_LC_X

#define DUK_ASC_LC_X   0x78

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

◆ DUK_ASC_LC_Y

#define DUK_ASC_LC_Y   0x79

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

◆ DUK_ASC_LC_Z

#define DUK_ASC_LC_Z   0x7a

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

◆ DUK_ASC_LCURLY

#define DUK_ASC_LCURLY   0x7b

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LF

#define DUK_ASC_LF   0x0a

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_LPAREN

#define DUK_ASC_LPAREN   0x28

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_MINUS

#define DUK_ASC_MINUS   0x2d

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_NAK

#define DUK_ASC_NAK   0x15

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

◆ DUK_ASC_NUL

#define DUK_ASC_NUL   0x00

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

◆ DUK_ASC_PERCENT

#define DUK_ASC_PERCENT   0x25

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_PERIOD

#define DUK_ASC_PERIOD   0x2e

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_PIPE

#define DUK_ASC_PIPE   0x7c

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_PLUS

#define DUK_ASC_PLUS   0x2b

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_QUESTION

#define DUK_ASC_QUESTION   0x3f

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RANGLE

#define DUK_ASC_RANGLE   0x3e

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RBRACKET

#define DUK_ASC_RBRACKET   0x5d

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RCURLY

#define DUK_ASC_RCURLY   0x7d

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RPAREN

#define DUK_ASC_RPAREN   0x29

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_RS

#define DUK_ASC_RS   0x1e

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

◆ DUK_ASC_SEMICOLON

#define DUK_ASC_SEMICOLON   0x3b

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_SI

#define DUK_ASC_SI   0x0f

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

◆ DUK_ASC_SINGLEQUOTE

#define DUK_ASC_SINGLEQUOTE   0x27

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_SLASH

#define DUK_ASC_SLASH   0x2f

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_SO

#define DUK_ASC_SO   0x0e

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

◆ DUK_ASC_SOH

#define DUK_ASC_SOH   0x01

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

◆ DUK_ASC_SPACE

#define DUK_ASC_SPACE   0x20

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_STAR

#define DUK_ASC_STAR   0x2a

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_STX

#define DUK_ASC_STX   0x02

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

◆ DUK_ASC_SUB

#define DUK_ASC_SUB   0x1a

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

◆ DUK_ASC_SYN

#define DUK_ASC_SYN   0x16

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

◆ DUK_ASC_TILDE

#define DUK_ASC_TILDE   0x7e

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

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_ASC_UC_A

#define DUK_ASC_UC_A   0x41

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

◆ DUK_ASC_UC_B

#define DUK_ASC_UC_B   0x42

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_C

#define DUK_ASC_UC_C   0x43

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_D

#define DUK_ASC_UC_D   0x44

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_E

#define DUK_ASC_UC_E   0x45

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_F

#define DUK_ASC_UC_F   0x46

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_G

#define DUK_ASC_UC_G   0x47

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_H

#define DUK_ASC_UC_H   0x48

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

◆ DUK_ASC_UC_I

#define DUK_ASC_UC_I   0x49

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_J

#define DUK_ASC_UC_J   0x4a

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

◆ DUK_ASC_UC_K

#define DUK_ASC_UC_K   0x4b

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

◆ DUK_ASC_UC_L

#define DUK_ASC_UC_L   0x4c

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_M

#define DUK_ASC_UC_M   0x4d

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

◆ DUK_ASC_UC_N

#define DUK_ASC_UC_N   0x4e

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_O

#define DUK_ASC_UC_O   0x4f

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

◆ DUK_ASC_UC_P

#define DUK_ASC_UC_P   0x50

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

◆ DUK_ASC_UC_Q

#define DUK_ASC_UC_Q   0x51

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

◆ DUK_ASC_UC_R

#define DUK_ASC_UC_R   0x52

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_S

#define DUK_ASC_UC_S   0x53

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

◆ DUK_ASC_UC_T

#define DUK_ASC_UC_T   0x54

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_U

#define DUK_ASC_UC_U   0x55

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

◆ DUK_ASC_UC_V

#define DUK_ASC_UC_V   0x56

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

◆ DUK_ASC_UC_W

#define DUK_ASC_UC_W   0x57

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

Referenced by duk_bi_logger_constructor().

◆ DUK_ASC_UC_X

#define DUK_ASC_UC_X   0x58

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

◆ DUK_ASC_UC_Y

#define DUK_ASC_UC_Y   0x59

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

◆ DUK_ASC_UC_Z

#define DUK_ASC_UC_Z   0x5a

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

◆ DUK_ASC_UNDERSCORE

#define DUK_ASC_UNDERSCORE   0x5f

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

◆ DUK_ASC_US

#define DUK_ASC_US   0x1f

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

◆ DUK_ASC_VT

#define DUK_ASC_VT   0x0b

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

◆ DUK_ASSERT

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

Definition at line 7782 of file duktape-1.5.2/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)
#define DUK_HEAPHDR_GET_TYPE(h)
#define DUK_HOBJECT_IS_THREAD(h)
#define DUK_HTYPE_OBJECT

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

6128
6129#if defined(DUK_USE_PREFER_SIZE)
6130#define DUK_ASSERT_CTX_VSSIZE(ctx) /*nop*/
6131#else
6132#define DUK_ASSERT_CTX_VSSIZE(ctx) \
6133 DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \
6134 ((duk_hthread *) (ctx))->valstack_size)
6135#endif
6136#define DUK_ASSERT_CTX_VALID(ctx) do { \
6137 DUK_ASSERT((ctx) != NULL); \
6138 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \
6139 DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \
6140 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_c_function(), duk_is_function(), duk_pcall(), 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)
#define DUK_ASSERT(x)

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

6124 * This is used by public API call entrypoints to catch invalid 'ctx' pointers
6125 * as early as possible; invalid 'ctx' pointers cause very odd and difficult to
6126 * diagnose behavior so it's worth checking even when the check is not 100%.

◆ DUK_ASSERT_DISABLE

◆ DUK_ASSERT_DOUBLE_IS_NORMALIZED

#define DUK_ASSERT_DOUBLE_IS_NORMALIZED ( dval)    /* nop */

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

◆ DUK_ASSERT_EXPR

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

Definition at line 7784 of file duktape-1.5.2/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)
#define DUK_HBUFFEROBJECT_ELEM_INT32
#define DUK_HBUFFEROBJECT_ELEM_MAX
#define DUK_HBUFFEROBJECT_ELEM_INT16
#define DUK_HOBJECT_IS_BUFFEROBJECT(h)
#define DUK_HBUFFEROBJECT_ELEM_FLOAT64
#define DUK_HBUFFEROBJECT_ELEM_UINT32
#define DUK_HBUFFEROBJECT_ELEM_UINT16
#define DUK_HBUFFEROBJECT_ELEM_FLOAT32
#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED
#define DUK_HBUFFEROBJECT_ELEM_INT8
#define DUK_HBUFFEROBJECT_ELEM_UINT8

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

5850#define DUK_HBUFFEROBJECT_ELEM_MAX 8
5851
5852#define DUK_ASSERT_HBUFFEROBJECT_VALID(h) do { \
5853 DUK_ASSERT((h) != NULL); \
5854 DUK_ASSERT((h)->shift <= 3); \
5855 DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \
5856 DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \
5857 ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \
5858 ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \
5859 ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \
5860 ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \
5861 ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \
5862 ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \
5863 ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \
5864 ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \
5865 DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \
5866 DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \
5867 if ((h)->buf == NULL) { \
5868 DUK_ASSERT((h)->offset == 0); \
5869 DUK_ASSERT((h)->length == 0); \
5870 } else { \
5871 /* No assertions for offset or length; in particular, \
5872 * 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 3724 of file duktape-1.5.2/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_ASSERT(!DUK_HOBJECT_IS_BUFFEROBJECT((h)) || \
} while (0)
#define DUK_HOBJECT_CLASS_BUFFER
#define DUK_HOBJECT_CLASS_INT32ARRAY
#define DUK_HOBJECT_CLASS_INT16ARRAY
#define DUK_HOBJECT_CLASS_FUNCTION
#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY
#define DUK_HOBJECT_IS_CALLABLE(h)
#define DUK_HOBJECT_CLASS_FLOAT32ARRAY
#define DUK_HOBJECT_CLASS_UINT8ARRAY
#define DUK_HOBJECT_CLASS_UINT32ARRAY
#define DUK_HOBJECT_CLASS_INT8ARRAY
#define DUK_HOBJECT_CLASS_UINT16ARRAY
#define DUK_HOBJECT_GET_CLASS_NUMBER(h)
#define DUK_HOBJECT_CLASS_ARRAYBUFFER
#define DUK_HOBJECT_CLASS_DATAVIEW
#define DUK_HOBJECT_CLASS_FLOAT64ARRAY

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

4919 */
4920
4921#define DUK_ASSERT_HOBJECT_VALID(h) do { \
4922 DUK_ASSERT((h) != NULL); \
4923 DUK_ASSERT(!DUK_HOBJECT_IS_CALLABLE((h)) || \
4924 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FUNCTION); \
4925 DUK_ASSERT(!DUK_HOBJECT_IS_BUFFEROBJECT((h)) || \
4926 (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_BUFFER || \
4927 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAYBUFFER || \
4928 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DATAVIEW || \
4929 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT8ARRAY || \
4930 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8ARRAY || \
4931 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY || \
4932 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT16ARRAY || \
4933 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT16ARRAY || \
4934 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT32ARRAY || \
4935 DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT32ARRAY || \
4936 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 */

◆ DUK_ASSERT_REFCOUNT_NONZERO_TVAL

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

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

Referenced by duk__putvar_helper().

◆ DUK_ASSERT_TOP

◆ 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 4398 of file duktape-1.5.2/src/duktape.c.

4398#define DUK_ASSERT_VALID_NEGIDX(ctx,idx) \
4399 (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 4400 of file duktape-1.5.2/src/duktape.c.

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

◆ DUK_ASSERT_VALSTACK_SPACE

◆ DUK_BC_A_MAX

#define DUK_BC_A_MAX   0xffL

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

◆ DUK_BC_A_MIN

#define DUK_BC_A_MIN   0

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

◆ DUK_BC_ABC_MAX

#define DUK_BC_ABC_MAX   0x3ffffffL

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

◆ DUK_BC_ABC_MIN

#define DUK_BC_ABC_MIN   0

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

◆ DUK_BC_B_MAX

#define DUK_BC_B_MAX   0x1ffL

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

◆ DUK_BC_B_MIN

#define DUK_BC_B_MIN   0

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

◆ DUK_BC_BC_MAX

#define DUK_BC_BC_MAX   0x3ffffL

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

◆ DUK_BC_BC_MIN

#define DUK_BC_BC_MIN   0

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

◆ DUK_BC_C_MAX

#define DUK_BC_C_MAX   0x1ffL

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

◆ DUK_BC_C_MIN

#define DUK_BC_C_MIN   0

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

◆ DUK_BC_CALL_FLAG_EVALCALL

#define DUK_BC_CALL_FLAG_EVALCALL   (1 << 1)

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

◆ DUK_BC_CALL_FLAG_TAILCALL

#define DUK_BC_CALL_FLAG_TAILCALL   (1 << 0)

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

◆ DUK_BC_DECLVAR_FLAG_FUNC_DECL

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

◆ DUK_BC_DECLVAR_FLAG_UNDEF_VALUE

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

◆ DUK_BC_EXTRAOP_MAX

#define DUK_BC_EXTRAOP_MAX   DUK_BC_A_MAX

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

◆ DUK_BC_EXTRAOP_MIN

#define DUK_BC_EXTRAOP_MIN   DUK_BC_A_MIN

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

◆ DUK_BC_ISCONST

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

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

◆ DUK_BC_ISREG

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

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

◆ DUK_BC_JUMP_BIAS

#define DUK_BC_JUMP_BIAS   (1L << 25)

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

◆ DUK_BC_LDINT_BIAS

#define DUK_BC_LDINT_BIAS   (1L << 17)

Definition at line 2717 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BC_OP_MAX

#define DUK_BC_OP_MAX   0x3fL

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

◆ DUK_BC_OP_MIN

#define DUK_BC_OP_MIN   0

Definition at line 2579 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_BI_COMMONJS_MODULE_ID_LIMIT

#define DUK_BI_COMMONJS_MODULE_ID_LIMIT   256

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

◆ DUK_BI_DATE_ISO8601_BUFSIZE

#define DUK_BI_DATE_ISO8601_BUFSIZE   48

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

◆ DUK_BIDX_ARRAY_CONSTRUCTOR

#define DUK_BIDX_ARRAY_CONSTRUCTOR   6

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

◆ DUK_BIDX_ARRAY_PROTOTYPE

#define DUK_BIDX_ARRAY_PROTOTYPE   7

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

◆ DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR

#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR   46

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

◆ DUK_BIDX_ARRAYBUFFER_PROTOTYPE

#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE   47

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

◆ DUK_BIDX_BOOLEAN_CONSTRUCTOR

#define DUK_BIDX_BOOLEAN_CONSTRUCTOR   10

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

◆ DUK_BIDX_BOOLEAN_PROTOTYPE

#define DUK_BIDX_BOOLEAN_PROTOTYPE   11

Definition at line 1647 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_BUFFER_PROTOTYPE

#define DUK_BIDX_BUFFER_PROTOTYPE   40

Definition at line 1676 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_DATAVIEW_PROTOTYPE

#define DUK_BIDX_DATAVIEW_PROTOTYPE   49

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

◆ DUK_BIDX_DATE_CONSTRUCTOR

#define DUK_BIDX_DATE_CONSTRUCTOR   14

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

◆ DUK_BIDX_DATE_PROTOTYPE

#define DUK_BIDX_DATE_PROTOTYPE   15

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

◆ DUK_BIDX_DOUBLE_ERROR

#define DUK_BIDX_DOUBLE_ERROR   45

Definition at line 1681 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_ERROR_PROTOTYPE

#define DUK_BIDX_ERROR_PROTOTYPE   19

Definition at line 1655 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_EVAL_ERROR_PROTOTYPE

#define DUK_BIDX_EVAL_ERROR_PROTOTYPE   21

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

◆ DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR

#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR   65

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

◆ DUK_BIDX_FLOAT32ARRAY_PROTOTYPE

#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE   66

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

◆ DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR

#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR   67

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

◆ DUK_BIDX_FLOAT64ARRAY_PROTOTYPE

#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE   68

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

◆ DUK_BIDX_FUNCTION_CONSTRUCTOR

#define DUK_BIDX_FUNCTION_CONSTRUCTOR   4

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

◆ DUK_BIDX_FUNCTION_PROTOTYPE

#define DUK_BIDX_FUNCTION_PROTOTYPE   5

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

Referenced by duk_hobject_putprop().

◆ DUK_BIDX_GLOBAL

#define DUK_BIDX_GLOBAL   0

◆ DUK_BIDX_GLOBAL_ENV

#define DUK_BIDX_GLOBAL_ENV   1

Definition at line 1637 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_INT16ARRAY_PROTOTYPE

#define DUK_BIDX_INT16ARRAY_PROTOTYPE   58

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

◆ DUK_BIDX_INT32ARRAY_CONSTRUCTOR

#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR   61

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

◆ DUK_BIDX_INT32ARRAY_PROTOTYPE

#define DUK_BIDX_INT32ARRAY_PROTOTYPE   62

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

◆ DUK_BIDX_INT8ARRAY_CONSTRUCTOR

#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR   51

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

◆ DUK_BIDX_INT8ARRAY_PROTOTYPE

#define DUK_BIDX_INT8ARRAY_PROTOTYPE   52

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

◆ DUK_BIDX_JSON

#define DUK_BIDX_JSON   33

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

◆ DUK_BIDX_LOGGER_CONSTRUCTOR

#define DUK_BIDX_LOGGER_CONSTRUCTOR   43

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

◆ DUK_BIDX_LOGGER_PROTOTYPE

#define DUK_BIDX_LOGGER_PROTOTYPE   44

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

◆ DUK_BIDX_MATH

#define DUK_BIDX_MATH   32

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

◆ DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR

#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR   69

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

◆ DUK_BIDX_NODEJS_BUFFER_PROTOTYPE

#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE   70

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

◆ DUK_BIDX_NUMBER_CONSTRUCTOR

#define DUK_BIDX_NUMBER_CONSTRUCTOR   12

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

◆ DUK_BIDX_NUMBER_PROTOTYPE

#define DUK_BIDX_NUMBER_PROTOTYPE   13

Definition at line 1649 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_OBJECT_PROTOTYPE

#define DUK_BIDX_OBJECT_PROTOTYPE   3

Definition at line 1639 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_POINTER_PROTOTYPE

#define DUK_BIDX_POINTER_PROTOTYPE   42

Definition at line 1678 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_BIDX_RANGE_ERROR_CONSTRUCTOR

#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR   22

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

◆ DUK_BIDX_RANGE_ERROR_PROTOTYPE

#define DUK_BIDX_RANGE_ERROR_PROTOTYPE   23

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

◆ DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR

#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR   24

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

◆ DUK_BIDX_REFERENCE_ERROR_PROTOTYPE

#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE   25

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

◆ DUK_BIDX_REGEXP_CONSTRUCTOR

#define DUK_BIDX_REGEXP_CONSTRUCTOR   16

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

◆ DUK_BIDX_REGEXP_PROTOTYPE

#define DUK_BIDX_REGEXP_PROTOTYPE   17

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

◆ DUK_BIDX_STRING_CONSTRUCTOR

#define DUK_BIDX_STRING_CONSTRUCTOR   8

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

◆ DUK_BIDX_STRING_PROTOTYPE

#define DUK_BIDX_STRING_PROTOTYPE   9

◆ DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR

#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR   26

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

◆ DUK_BIDX_SYNTAX_ERROR_PROTOTYPE

#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE   27

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

◆ DUK_BIDX_THREAD_CONSTRUCTOR

#define DUK_BIDX_THREAD_CONSTRUCTOR   37

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

◆ DUK_BIDX_THREAD_PROTOTYPE

#define DUK_BIDX_THREAD_PROTOTYPE   38

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

◆ DUK_BIDX_TYPE_ERROR_CONSTRUCTOR

#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR   28

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

◆ DUK_BIDX_TYPE_ERROR_PROTOTYPE

#define DUK_BIDX_TYPE_ERROR_PROTOTYPE   29

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

◆ DUK_BIDX_TYPE_ERROR_THROWER

#define DUK_BIDX_TYPE_ERROR_THROWER   34

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

◆ DUK_BIDX_TYPEDARRAY_PROTOTYPE

#define DUK_BIDX_TYPEDARRAY_PROTOTYPE   50

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

◆ DUK_BIDX_UINT16ARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR   59

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

◆ DUK_BIDX_UINT16ARRAY_PROTOTYPE

#define DUK_BIDX_UINT16ARRAY_PROTOTYPE   60

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

◆ DUK_BIDX_UINT32ARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR   63

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

◆ DUK_BIDX_UINT32ARRAY_PROTOTYPE

#define DUK_BIDX_UINT32ARRAY_PROTOTYPE   64

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

◆ DUK_BIDX_UINT8ARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR   53

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

◆ DUK_BIDX_UINT8ARRAY_PROTOTYPE

#define DUK_BIDX_UINT8ARRAY_PROTOTYPE   54

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

◆ DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR

#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR   55

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

◆ DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE

#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE   56

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

◆ DUK_BIDX_URI_ERROR_CONSTRUCTOR

#define DUK_BIDX_URI_ERROR_CONSTRUCTOR   30

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

◆ DUK_BIDX_URI_ERROR_PROTOTYPE

#define DUK_BIDX_URI_ERROR_PROTOTYPE   31

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

◆ DUK_BUILTIN_INITJS_DATA_LENGTH

#define DUK_BUILTIN_INITJS_DATA_LENGTH   204

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

◆ DUK_BUILTIN_PROTOS_H_INCLUDED

#define DUK_BUILTIN_PROTOS_H_INCLUDED

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

◆ DUK_BUILTINS_H_INCLUDED

#define DUK_BUILTINS_H_INCLUDED

Definition at line 881 of file duktape-1.5.2/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.5.2/src/duktape.c.

1902#define DUK_BW_ADD_PTR(thr,bw_ctx,delta) do { \
1903 (bw_ctx)->p += (delta); \
1904 } 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.5.2/src/duktape.c.

1944#define DUK_BW_ASSERT_SPACE(thr,bw_ctx,sz) do { \
1945 DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \
1946 } 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)))
#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx)

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

1941#define DUK_BW_ASSERT_SPACE_EXPR(thr,bw_ctx,sz) \
1942 (DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \
1943 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.5.2/src/duktape.c.

1891#define DUK_BW_ASSERT_VALID(thr,bw_ctx) do { \
1892 DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \
1893 } 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)))
#define DUK_HBUFFER_DYNAMIC_GET_SIZE(x)
#define DUK_ASSERT_EXPR(x)

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

1881#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx) \
1882 DUK_ASSERT_EXPR((bw_ctx) != NULL && \
1883 (bw_ctx)->buf != NULL && \
1884 ((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \
1885 ((bw_ctx)->p != NULL && \
1886 (bw_ctx)->p_base != NULL && \
1887 (bw_ctx)->p_limit != NULL && \
1888 (bw_ctx)->p_limit >= (bw_ctx)->p_base && \
1889 (bw_ctx)->p >= (bw_ctx)->p_base && \
1890 (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.5.2/src/duktape.c.

1867#define DUK_BW_COMPACT(thr,bw_ctx) do { \
1868 /* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \
1869 duk_bw_compact((thr), (bw_ctx)); \
1870 } 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)
DUK_INTERNAL_DECL duk_uint8_t * duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz)

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

1924#define DUK_BW_ENSURE(thr,bw_ctx,sz) do { \
1925 duk_size_t duk__sz, duk__space; \
1926 DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \
1927 duk__sz = (sz); \
1928 duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \
1929 if (duk__space < duk__sz) { \
1930 (void) duk_bw_resize((thr), (bw_ctx), duk__sz); \
1931 } \
1932 } 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.5.2/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.5.2/src/duktape.c.

1935#define DUK_BW_ENSURE_RAW(thr,bw_ctx,sz,ptr) \
1936 (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \
1937 (ptr) : \
1938 ((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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

1861#define DUK_BW_INIT_PUSHBUF(thr,bw_ctx,sz) do { \
1862 duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \
1863 } 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.5.2/src/duktape.c.

1864#define DUK_BW_INIT_WITHBUF(thr,bw_ctx,buf) do { \
1865 duk_bw_init((thr), (bw_ctx), (buf)); \
1866 } 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.5.2/src/duktape.c.

2186#define DUK_BW_INSERT_ENSURE_AREA(thr,bw,off,len) \
2187 /* Evaluates to (duk_uint8_t *) pointing to start of area. */ \
2188 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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

1871#define DUK_BW_PUSH_AS_STRING(thr,bw_ctx) do { \
1872 duk_push_lstring((duk_context *) (thr), \
1873 (const char *) (bw_ctx)->p_base, \
1874 (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
1875 } 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.5.2/src/duktape.c.

2189#define DUK_BW_REMOVE_ENSURE_SLICE(thr,bw,off,len) \
2190 /* No difference between raw/ensure because the buffer shrinks. */ \
2191 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.5.2/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.5.2/src/duktape.c.

1915#define DUK_BW_RESET_SIZE(thr,bw_ctx) do { \
1916 /* Reset to zero size, keep current limit. */ \
1917 (bw_ctx)->p = (bw_ctx)->p_base; \
1918 } 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.5.2/src/duktape.c.

1899#define DUK_BW_SET_PTR(thr,bw_ctx,ptr) do { \
1900 (bw_ctx)->p = (ptr); \
1901 } 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.5.2/src/duktape.c.

1911#define DUK_BW_SET_SIZE(thr,bw_ctx,sz) do { \
1912 DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
1913 (bw_ctx)->p = (bw_ctx)->p_base + (sz); \
1914 } 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.5.2/src/duktape.c.

1950#define DUK_BW_SETPTR_AND_COMPACT(thr,bw_ctx,ptr) do { \
1951 (bw_ctx)->p = (ptr); \
1952 duk_bw_compact((thr), (bw_ctx)); \
1953 } 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.5.2/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.5.2/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.5.2/src/duktape.c.

2133#define DUK_BW_WRITE_ENSURE_BYTES(thr,bw_ctx,valptr,valsz) do { \
2134 const void *duk__valptr; \
2135 duk_size_t duk__valsz; \
2136 duk__valptr = (const void *) (valptr); \
2137 duk__valsz = (duk_size_t) (valsz); \
2138 DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \
2139 DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
2140 (bw_ctx)->p += duk__valsz; \
2141 } 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)
#define DUK_UNICODE_MAX_CESU8_LENGTH

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

2128#define DUK_BW_WRITE_ENSURE_CESU8(thr,bw_ctx,cp) do { \
2129 DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \
2130 DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \
2131 } 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.5.2/src/duktape.c.

2142#define DUK_BW_WRITE_ENSURE_CSTRING(thr,bw_ctx,val) do { \
2143 const duk_uint8_t *duk__val; \
2144 duk_size_t duk__val_len; \
2145 duk__val = (const duk_uint8_t *) (val); \
2146 duk__val_len = DUK_STRLEN((const char *) duk__val); \
2147 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
2148 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
2149 (bw_ctx)->p += duk__val_len; \
2150 } 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)
#define DUK_HBUFFER_GET_DATA_PTR(heap, x)
#define DUK_HBUFFER_GET_SIZE(x)

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

2158#define DUK_BW_WRITE_ENSURE_HBUFFER(thr,bw_ctx,val) do { \
2159 duk_size_t duk__val_len; \
2160 duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
2161 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
2162 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
2163 (bw_ctx)->p += duk__val_len; \
2164 } 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)
#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, x)

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

2172#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
2173 duk_size_t duk__val_len; \
2174 duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
2175 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
2176 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
2177 (bw_ctx)->p += duk__val_len; \
2178 } 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)
#define DUK_HBUFFER_FIXED_GET_SIZE(x)
#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap, x)

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

2165#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr,bw_ctx,val) do { \
2166 duk_size_t duk__val_len; \
2167 duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
2168 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
2169 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
2170 (bw_ctx)->p += duk__val_len; \
2171 } 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)
#define DUK_HSTRING_GET_DATA(x)
#define DUK_HSTRING_GET_BYTELEN(x)

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

2151#define DUK_BW_WRITE_ENSURE_HSTRING(thr,bw_ctx,val) do { \
2152 duk_size_t duk__val_len; \
2153 duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
2154 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
2155 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
2156 (bw_ctx)->p += duk__val_len; \
2157 } 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.5.2/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.5.2/src/duktape.c.

2100#define DUK_BW_WRITE_ENSURE_U8(thr,bw_ctx,val) do { \
2101 DUK_BW_ENSURE((thr), (bw_ctx), 1); \
2102 DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \
2103 } 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.5.2/src/duktape.c.

2104#define DUK_BW_WRITE_ENSURE_U8_2(thr,bw_ctx,val1,val2) do { \
2105 DUK_BW_ENSURE((thr), (bw_ctx), 2); \
2106 DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \
2107 } 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.5.2/src/duktape.c.

2108#define DUK_BW_WRITE_ENSURE_U8_3(thr,bw_ctx,val1,val2,val3) do { \
2109 DUK_BW_ENSURE((thr), (bw_ctx), 3); \
2110 DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \
2111 } 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.5.2/src/duktape.c.

2112#define DUK_BW_WRITE_ENSURE_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
2113 DUK_BW_ENSURE((thr), (bw_ctx), 4); \
2114 DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \
2115 } 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.5.2/src/duktape.c.

2116#define DUK_BW_WRITE_ENSURE_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
2117 DUK_BW_ENSURE((thr), (bw_ctx), 5); \
2118 DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \
2119 } 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.5.2/src/duktape.c.

2120#define DUK_BW_WRITE_ENSURE_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
2121 DUK_BW_ENSURE((thr), (bw_ctx), 6); \
2122 DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \
2123 } 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)
#define DUK_UNICODE_MAX_XUTF8_LENGTH

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

2124#define DUK_BW_WRITE_ENSURE_XUTF8(thr,bw_ctx,cp) do { \
2125 DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \
2126 DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \
2127 } 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.5.2/src/duktape.c.

2032#define DUK_BW_WRITE_RAW_BYTES(thr,bw_ctx,valptr,valsz) do { \
2033 const void *duk__valptr; \
2034 duk_size_t duk__valsz; \
2035 duk__valptr = (const void *) (valptr); \
2036 duk__valsz = (duk_size_t) (valsz); \
2037 DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
2038 (bw_ctx)->p += duk__valsz; \
2039 } 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)
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out)

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

2023#define DUK_BW_WRITE_RAW_CESU8(thr,bw_ctx,cp) do { \
2024 duk_ucodepoint_t duk__cp; \
2025 duk_small_int_t duk__enc_len; \
2026 duk__cp = (duk_ucodepoint_t) (cp); \
2027 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \
2028 duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \
2029 (bw_ctx)->p += duk__enc_len; \
2030 } 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.5.2/src/duktape.c.

2040#define DUK_BW_WRITE_RAW_CSTRING(thr,bw_ctx,val) do { \
2041 const duk_uint8_t *duk__val; \
2042 duk_size_t duk__val_len; \
2043 duk__val = (const duk_uint8_t *) (val); \
2044 duk__val_len = DUK_STRLEN((const char *) duk__val); \
2045 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
2046 (bw_ctx)->p += duk__val_len; \
2047 } 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.5.2/src/duktape.c.

2054#define DUK_BW_WRITE_RAW_HBUFFER(thr,bw_ctx,val) do { \
2055 duk_size_t duk__val_len; \
2056 duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
2057 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
2058 (bw_ctx)->p += duk__val_len; \
2059 } 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.5.2/src/duktape.c.

2066#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
2067 duk_size_t duk__val_len; \
2068 duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
2069 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
2070 (bw_ctx)->p += duk__val_len; \
2071 } 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.5.2/src/duktape.c.

2060#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr,bw_ctx,val) do { \
2061 duk_size_t duk__val_len; \
2062 duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
2063 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
2064 (bw_ctx)->p += duk__val_len; \
2065 } 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.5.2/src/duktape.c.

2048#define DUK_BW_WRITE_RAW_HSTRING(thr,bw_ctx,val) do { \
2049 duk_size_t duk__val_len; \
2050 duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
2051 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
2052 (bw_ctx)->p += duk__val_len; \
2053 } 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.5.2/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.5.2/src/duktape.c.

1961#define DUK_BW_WRITE_RAW_U8(thr,bw_ctx,val) do { \
1962 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \
1963 *(bw_ctx)->p++ = (duk_uint8_t) (val); \
1964 } 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.5.2/src/duktape.c.

1965#define DUK_BW_WRITE_RAW_U8_2(thr,bw_ctx,val1,val2) do { \
1966 duk_uint8_t *duk__p; \
1967 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \
1968 duk__p = (bw_ctx)->p; \
1969 *duk__p++ = (duk_uint8_t) (val1); \
1970 *duk__p++ = (duk_uint8_t) (val2); \
1971 (bw_ctx)->p = duk__p; \
1972 } 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.5.2/src/duktape.c.

1973#define DUK_BW_WRITE_RAW_U8_3(thr,bw_ctx,val1,val2,val3) do { \
1974 duk_uint8_t *duk__p; \
1975 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \
1976 duk__p = (bw_ctx)->p; \
1977 *duk__p++ = (duk_uint8_t) (val1); \
1978 *duk__p++ = (duk_uint8_t) (val2); \
1979 *duk__p++ = (duk_uint8_t) (val3); \
1980 (bw_ctx)->p = duk__p; \
1981 } 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.5.2/src/duktape.c.

1982#define DUK_BW_WRITE_RAW_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
1983 duk_uint8_t *duk__p; \
1984 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \
1985 duk__p = (bw_ctx)->p; \
1986 *duk__p++ = (duk_uint8_t) (val1); \
1987 *duk__p++ = (duk_uint8_t) (val2); \
1988 *duk__p++ = (duk_uint8_t) (val3); \
1989 *duk__p++ = (duk_uint8_t) (val4); \
1990 (bw_ctx)->p = duk__p; \
1991 } 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.5.2/src/duktape.c.

1992#define DUK_BW_WRITE_RAW_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
1993 duk_uint8_t *duk__p; \
1994 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \
1995 duk__p = (bw_ctx)->p; \
1996 *duk__p++ = (duk_uint8_t) (val1); \
1997 *duk__p++ = (duk_uint8_t) (val2); \
1998 *duk__p++ = (duk_uint8_t) (val3); \
1999 *duk__p++ = (duk_uint8_t) (val4); \
2000 *duk__p++ = (duk_uint8_t) (val5); \
2001 (bw_ctx)->p = duk__p; \
2002 } 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.5.2/src/duktape.c.

2003#define DUK_BW_WRITE_RAW_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
2004 duk_uint8_t *duk__p; \
2005 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \
2006 duk__p = (bw_ctx)->p; \
2007 *duk__p++ = (duk_uint8_t) (val1); \
2008 *duk__p++ = (duk_uint8_t) (val2); \
2009 *duk__p++ = (duk_uint8_t) (val3); \
2010 *duk__p++ = (duk_uint8_t) (val4); \
2011 *duk__p++ = (duk_uint8_t) (val5); \
2012 *duk__p++ = (duk_uint8_t) (val6); \
2013 (bw_ctx)->p = duk__p; \
2014 } 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)
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)

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

2015#define DUK_BW_WRITE_RAW_XUTF8(thr,bw_ctx,cp) do { \
2016 duk_ucodepoint_t duk__cp; \
2017 duk_small_int_t duk__enc_len; \
2018 duk__cp = (cp); \
2019 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \
2020 duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \
2021 (bw_ctx)->p += duk__enc_len; \
2022 } 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 8374 of file duktape-1.5.2/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 8377 of file duktape-1.5.2/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) */

◆ 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 8375 of file duktape-1.5.2/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 8376 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_handle_ecma_call_setup().

◆ DUK_CALLSTACK_DEFAULT_MAX

#define DUK_CALLSTACK_DEFAULT_MAX   10000L

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

Referenced by duk_err_create_and_throw().

◆ DUK_CALLSTACK_GROW_STEP

#define DUK_CALLSTACK_GROW_STEP   8 /* roughly 256 bytes */

◆ DUK_CALLSTACK_INITIAL_SIZE

#define DUK_CALLSTACK_INITIAL_SIZE   8

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

◆ DUK_CALLSTACK_SHRINK_SPARE

#define DUK_CALLSTACK_SHRINK_SPARE   8 /* roughly 256 bytes */

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

◆ DUK_CALLSTACK_SHRINK_THRESHOLD

#define DUK_CALLSTACK_SHRINK_THRESHOLD   16 /* roughly 512 bytes */

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

◆ DUK_CAT_CLEAR_CATCH_BINDING_ENABLED

#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED ( c)
Value:
do { \
} while (0)
#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED

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

6071 } while (0)
6072
6073#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)
#define DUK_CAT_FLAG_CATCH_ENABLED

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

6065 } while (0)
6066#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c) do { \
6067 (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)
#define DUK_CAT_FLAG_FINALLY_ENABLED

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

6068 } while (0)
6069#define DUK_CAT_SET_LEXENV_ACTIVE(c) do { \
6070 (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)
#define DUK_CAT_FLAG_LEXENV_ACTIVE

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

6074 (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \
6075 } while (0)
6076#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 6037 of file duktape-1.5.2/src/duktape.c.

◆ DUK_CAT_FLAG_CATCH_ENABLED

#define DUK_CAT_FLAG_CATCH_ENABLED   (1 << 4) /* catch part will catch */

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

◆ DUK_CAT_FLAG_FINALLY_ENABLED

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

Definition at line 6036 of file duktape-1.5.2/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 6038 of file duktape-1.5.2/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 6045 of file duktape-1.5.2/src/duktape.c.

◆ DUK_CAT_GET_TYPE

#define DUK_CAT_GET_TYPE ( c)    ((c)->flags & DUK_CAT_TYPE_MASK)

Definition at line 6044 of file duktape-1.5.2/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 6049 of file duktape-1.5.2/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 6047 of file duktape-1.5.2/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 6048 of file duktape-1.5.2/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 6050 of file duktape-1.5.2/src/duktape.c.

◆ DUK_CAT_LABEL_BITS

#define DUK_CAT_LABEL_BITS   24

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

◆ DUK_CAT_LABEL_MASK

#define DUK_CAT_LABEL_MASK   0xffffff00UL

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

◆ DUK_CAT_LABEL_SHIFT

#define DUK_CAT_LABEL_SHIFT   8

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

◆ DUK_CAT_SET_CATCH_BINDING_ENABLED

#define DUK_CAT_SET_CATCH_BINDING_ENABLED ( c)
Value:
do { \
} while (0)

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

6058#define DUK_CAT_HAS_LEXENV_ACTIVE(c) ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)
6059
6060#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 6052 of file duktape-1.5.2/src/duktape.c.

6052#define DUK_CAT_GET_TYPE(c) ((c)->flags & DUK_CAT_TYPE_MASK)
6053#define DUK_CAT_GET_LABEL(c) (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT)
6054

◆ DUK_CAT_SET_FINALLY_ENABLED

#define DUK_CAT_SET_FINALLY_ENABLED ( c)
Value:
do { \
} while (0)

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

6055#define DUK_CAT_HAS_CATCH_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED)
6056#define DUK_CAT_HAS_FINALLY_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED)
6057#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 6061 of file duktape-1.5.2/src/duktape.c.

6061 (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \
6062 } while (0)
6063#define DUK_CAT_SET_FINALLY_ENABLED(c) do { \

◆ DUK_CAT_TYPE_BITS

#define DUK_CAT_TYPE_BITS   4

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

◆ DUK_CAT_TYPE_LABEL

#define DUK_CAT_TYPE_LABEL   2

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

Referenced by duk_handle_ecma_call_setup().

◆ DUK_CAT_TYPE_MASK

#define DUK_CAT_TYPE_MASK   0x0000000fUL

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

◆ DUK_CAT_TYPE_TCF

#define DUK_CAT_TYPE_TCF   1

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

◆ DUK_CAT_TYPE_UNKNOWN

#define DUK_CAT_TYPE_UNKNOWN   0

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

◆ DUK_CATCHSTACK_DEFAULT_MAX

#define DUK_CATCHSTACK_DEFAULT_MAX   10000L

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

◆ DUK_CATCHSTACK_GROW_STEP

#define DUK_CATCHSTACK_GROW_STEP   4 /* roughly 64 bytes */

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

◆ DUK_CATCHSTACK_INITIAL_SIZE

#define DUK_CATCHSTACK_INITIAL_SIZE   4

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

◆ DUK_CATCHSTACK_SHRINK_SPARE

#define DUK_CATCHSTACK_SHRINK_SPARE   4 /* roughly 64 bytes */

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

◆ DUK_CATCHSTACK_SHRINK_THRESHOLD

#define DUK_CATCHSTACK_SHRINK_THRESHOLD   8 /* roughly 128 bytes */

Definition at line 6000 of file duktape-1.5.2/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 8384 of file duktape-1.5.2/src/duktape.c.

◆ DUK_COMPARE_FLAG_NEGATE

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

Definition at line 8385 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_COMPILER_PEEPHOLE_MAXITER

#define DUK_COMPILER_PEEPHOLE_MAXITER   3

Definition at line 3167 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_COMPILING_DUKTAPE

#define DUK_COMPILING_DUKTAPE

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

◆ DUK_D

◆ DUK_DBG_CMD_ADDBREAK

#define DUK_DBG_CMD_ADDBREAK   0x18

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

◆ DUK_DBG_CMD_ALERT

#define DUK_DBG_CMD_ALERT   0x03

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

◆ DUK_DBG_CMD_APPNOTIFY

#define DUK_DBG_CMD_APPNOTIFY   0x07

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

◆ DUK_DBG_CMD_APPREQUEST

#define DUK_DBG_CMD_APPREQUEST   0x22

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

◆ DUK_DBG_CMD_BASICINFO

#define DUK_DBG_CMD_BASICINFO   0x10

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

◆ DUK_DBG_CMD_DELBREAK

#define DUK_DBG_CMD_DELBREAK   0x19

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

◆ DUK_DBG_CMD_DETACH

#define DUK_DBG_CMD_DETACH   0x1f

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

◆ DUK_DBG_CMD_DETACHING

#define DUK_DBG_CMD_DETACHING   0x06

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

◆ DUK_DBG_CMD_DUMPHEAP

#define DUK_DBG_CMD_DUMPHEAP   0x20

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

◆ DUK_DBG_CMD_EVAL

#define DUK_DBG_CMD_EVAL   0x1e

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

◆ DUK_DBG_CMD_GETBYTECODE

#define DUK_DBG_CMD_GETBYTECODE   0x21

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

◆ DUK_DBG_CMD_GETCALLSTACK

#define DUK_DBG_CMD_GETCALLSTACK   0x1c

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

◆ DUK_DBG_CMD_GETHEAPOBJINFO

#define DUK_DBG_CMD_GETHEAPOBJINFO   0x23

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

◆ DUK_DBG_CMD_GETLOCALS

#define DUK_DBG_CMD_GETLOCALS   0x1d

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

◆ DUK_DBG_CMD_GETOBJPROPDESC

#define DUK_DBG_CMD_GETOBJPROPDESC   0x24

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

◆ DUK_DBG_CMD_GETOBJPROPDESCRANGE

#define DUK_DBG_CMD_GETOBJPROPDESCRANGE   0x25

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

◆ DUK_DBG_CMD_GETVAR

#define DUK_DBG_CMD_GETVAR   0x1a

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

◆ DUK_DBG_CMD_LISTBREAK

#define DUK_DBG_CMD_LISTBREAK   0x17

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

◆ DUK_DBG_CMD_LOG

#define DUK_DBG_CMD_LOG   0x04

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

◆ DUK_DBG_CMD_PAUSE

#define DUK_DBG_CMD_PAUSE   0x12

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

◆ DUK_DBG_CMD_PRINT

#define DUK_DBG_CMD_PRINT   0x02

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

◆ DUK_DBG_CMD_PUTVAR

#define DUK_DBG_CMD_PUTVAR   0x1b

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

◆ DUK_DBG_CMD_RESUME

#define DUK_DBG_CMD_RESUME   0x13

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

◆ DUK_DBG_CMD_STATUS

#define DUK_DBG_CMD_STATUS   0x01

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

◆ DUK_DBG_CMD_STEPINTO

#define DUK_DBG_CMD_STEPINTO   0x14

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

◆ DUK_DBG_CMD_STEPOUT

#define DUK_DBG_CMD_STEPOUT   0x16

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

◆ DUK_DBG_CMD_STEPOVER

#define DUK_DBG_CMD_STEPOVER   0x15

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

◆ DUK_DBG_CMD_THROW

#define DUK_DBG_CMD_THROW   0x05

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

◆ DUK_DBG_CMD_TRIGGERSTATUS

#define DUK_DBG_CMD_TRIGGERSTATUS   0x11

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

◆ DUK_DBG_ERR_APPLICATION

#define DUK_DBG_ERR_APPLICATION   0x04

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

◆ DUK_DBG_ERR_NOTFOUND

#define DUK_DBG_ERR_NOTFOUND   0x03

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

◆ DUK_DBG_ERR_TOOMANY

#define DUK_DBG_ERR_TOOMANY   0x02

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

◆ DUK_DBG_ERR_UNKNOWN

#define DUK_DBG_ERR_UNKNOWN   0x00

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

◆ DUK_DBG_ERR_UNSUPPORTED

#define DUK_DBG_ERR_UNSUPPORTED   0x01

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

◆ DUK_DBG_IB_BUF2

#define DUK_DBG_IB_BUF2   0x14

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

◆ DUK_DBG_IB_BUF4

#define DUK_DBG_IB_BUF4   0x13

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

◆ DUK_DBG_IB_EOM

#define DUK_DBG_IB_EOM   0x00

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

◆ DUK_DBG_IB_ERROR

#define DUK_DBG_IB_ERROR   0x03

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

◆ DUK_DBG_IB_FALSE

#define DUK_DBG_IB_FALSE   0x19

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

◆ DUK_DBG_IB_HEAPPTR

#define DUK_DBG_IB_HEAPPTR   0x1e

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

◆ DUK_DBG_IB_INT4

#define DUK_DBG_IB_INT4   0x10

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

◆ DUK_DBG_IB_LIGHTFUNC

#define DUK_DBG_IB_LIGHTFUNC   0x1d

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

◆ DUK_DBG_IB_NOTIFY

#define DUK_DBG_IB_NOTIFY   0x04

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

◆ DUK_DBG_IB_NULL

#define DUK_DBG_IB_NULL   0x17

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

◆ DUK_DBG_IB_NUMBER

#define DUK_DBG_IB_NUMBER   0x1a

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

◆ DUK_DBG_IB_OBJECT

#define DUK_DBG_IB_OBJECT   0x1b

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

◆ DUK_DBG_IB_POINTER

#define DUK_DBG_IB_POINTER   0x1c

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

◆ DUK_DBG_IB_REPLY

#define DUK_DBG_IB_REPLY   0x02

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

◆ DUK_DBG_IB_REQUEST

#define DUK_DBG_IB_REQUEST   0x01

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

◆ DUK_DBG_IB_STR2

#define DUK_DBG_IB_STR2   0x12

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

◆ DUK_DBG_IB_STR4

#define DUK_DBG_IB_STR4   0x11

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

◆ DUK_DBG_IB_TRUE

#define DUK_DBG_IB_TRUE   0x18

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

◆ DUK_DBG_IB_UNDEFINED

#define DUK_DBG_IB_UNDEFINED   0x16

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

◆ DUK_DBG_IB_UNUSED

#define DUK_DBG_IB_UNUSED   0x15

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

◆ DUK_DBG_PROPFLAG_INTERNAL

#define DUK_DBG_PROPFLAG_INTERNAL   (1 << 8)

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

◆ DUK_DD

◆ DUK_DDD

◆ DUK_DDDPRINT

◆ DUK_DDPRINT

◆ DUK_DEBUG_H_INCLUDED

#define DUK_DEBUG_H_INCLUDED

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

◆ DUK_DEBUGGER_H_INCLUDED

#define DUK_DEBUGGER_H_INCLUDED

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

◆ DUK_DEC_A

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

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

◆ DUK_DEC_ABC

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

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

◆ DUK_DEC_B

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

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

◆ DUK_DEC_BC

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

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

◆ DUK_DEC_C

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

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

◆ DUK_DEC_OP

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

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

◆ DUK_DECL_TYPE_FUNC

#define DUK_DECL_TYPE_FUNC   1

◆ DUK_DECL_TYPE_VAR

#define DUK_DECL_TYPE_VAR   0

◆ DUK_DELPROP_FLAG_FORCE

#define DUK_DELPROP_FLAG_FORCE   (1 << 1)

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

◆ DUK_DELPROP_FLAG_THROW

#define DUK_DELPROP_FLAG_THROW   (1 << 0)

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

◆ DUK_DPRINT

◆ DUK_ENC_OP

#define DUK_ENC_OP ( op)    ((duk_instr_t) (op))

Definition at line 2557 of file duktape-1.5.2/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.5.2/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.5.2/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)) \
))
duk_uint32_t duk_instr_t
duk_uint32_t duk_instr_t

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

2567#define DUK_ENC_OP_A_B_C(op,a,b,c) ((duk_instr_t) ( \
2568 (((duk_instr_t) (c)) << 23) | \
2569 (((duk_instr_t) (b)) << 14) | \
2570 (((duk_instr_t) (a)) << 6) | \
2571 ((duk_instr_t) (op)) \
2572 ))

◆ 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.5.2/src/duktape.c.

2562#define DUK_ENC_OP_A_BC(op,a,bc) ((duk_instr_t) ( \
2563 (((duk_instr_t) (bc)) << 14) | \
2564 (((duk_instr_t) (a)) << 6) | \
2565 ((duk_instr_t) (op)) \
2566 ))

◆ 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.5.2/src/duktape.c.

2558#define DUK_ENC_OP_ABC(op,abc) ((duk_instr_t) ( \
2559 (((duk_instr_t) (abc)) << 6) | \
2560 ((duk_instr_t) (op)) \
2561 ))

◆ DUK_EQUALS_FLAG_SAMEVALUE

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

Definition at line 8380 of file duktape-1.5.2/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 8381 of file duktape-1.5.2/src/duktape.c.

◆ DUK_ERRCODE_FLAG_NOBLAME_FILELINE

#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE   (1L << 24)

Definition at line 4233 of file duktape-1.5.2/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.5.2/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)
duk_uint_fast32_t duk_uint_t

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

7644 * because vararg call sites are larger than normal, and there are a lot
7645 * of call sites with no formatting.
7646 *
7647 * Note that special formatting provided by debug macros is NOT available.
7648 *

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 7886 of file duktape-1.5.2/src/duktape.c.

7886#define DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr) do { \
7887 duk_err_unimplemented_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
7888 } while (0)

◆ DUK_ERROR_ALLOC_DEFMSG

#define DUK_ERROR_ALLOC_DEFMSG ( thr)
Value:
do { \
DUK_ERROR_ALLOC((thr), DUK_STR_ALLOC_FAILED); \
} while (0)
#define DUK_STR_ALLOC_FAILED

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

7889#define DUK_ERROR_UNSUPPORTED(thr,msg) do { \
7890 DUK_ERROR((thr), DUK_ERR_UNSUPPORTED_ERROR, (msg)); \
7891 } 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 7896 of file duktape-1.5.2/src/duktape.c.

7896#endif
7897#define DUK_ERROR_INTERNAL(thr,msg) do { \
7898 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(), 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)
guint index

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

7893#define DUK_ERROR_UNSUPPORTED_DEFMSG(thr) do { \
7894 duk_err_unsupported_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
7895 } 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 7655 of file duktape-1.5.2/src/duktape.c.

7655
7656/* Because there are quite many call sites, pack error code (require at most
7657 * 8-bit) into a single argument.
7658 */
7659#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 7666 of file duktape-1.5.2/src/duktape.c.

7666 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7667 duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
7668 } while (0)
7669
7670#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 7677 of file duktape-1.5.2/src/duktape.c.

7677 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7678 duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
7679 } while (0)
7680
7681#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 7688 of file duktape-1.5.2/src/duktape.c.

7688 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7689 duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
7690 } while (0)
7691
7692#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) do { \

◆ DUK_ERROR_H_INCLUDED

#define DUK_ERROR_H_INCLUDED

Definition at line 7605 of file duktape-1.5.2/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 7880 of file duktape-1.5.2/src/duktape.c.

7880 } while (0)
7881#endif /* DUK_USE_PARANOID_ERRORS */
7882

◆ 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 7883 of file duktape-1.5.2/src/duktape.c.

7883#define DUK_ERROR_UNIMPLEMENTED(thr,msg) do { \
7884 DUK_ERROR((thr), DUK_ERR_UNIMPLEMENTED_ERROR, (msg)); \
7885 } 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 7902 of file duktape-1.5.2/src/duktape.c.

7902 } while (0)
7903#define DUK_ERROR_ALLOC(thr,msg) do { \
7904 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(), duk_push_heapptr(), 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 7649 of file duktape-1.5.2/src/duktape.c.

7649 * The _RAW variants allow the caller to specify file and line. This makes
7650 * it easier to write checked calls which want to use the call site of the
7651 * checked function, not the error macro call inside the checked function.
7652 */
7653
static void error(LoadState *S, const char *why)

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 7660 of file duktape-1.5.2/src/duktape.c.

7660 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
7661 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7662 duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
7663 } while (0)
7664#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 7671 of file duktape-1.5.2/src/duktape.c.

7671 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
7672 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7673 duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
7674 } while (0)
7675#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 7682 of file duktape-1.5.2/src/duktape.c.

7682 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
7683 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7684 duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
7685 } while (0)
7686#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 7693 of file duktape-1.5.2/src/duktape.c.

7693 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
7694 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
7695 duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
7696 } while (0)
7697#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 7861 of file duktape-1.5.2/src/duktape.c.

7861 * The goal is to provide verbose and configurable error messages. Call
7862 * sites should be clean in source code and compile to a small footprint.
7863 * 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)
#define DUK_ERR_SYNTAX_ERROR

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

7906#define DUK_ERROR_ALLOC_DEFMSG(thr) do { \
7907 DUK_ERROR_ALLOC((thr), DUK_STR_ALLOC_FAILED); \
7908 } 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 7909 of file duktape-1.5.2/src/duktape.c.

7909/* DUK_ERR_ASSERTION_ERROR: no macros needed */
7910#define DUK_ERROR_API_INDEX(thr,index) do { \
7911 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)
#define DUK_ERR_UNIMPLEMENTED_ERROR

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

7866 */
7867
7868#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 7869 of file duktape-1.5.2/src/duktape.c.

7869/* Verbose errors with key/value summaries (non-paranoid) or without key/value
7870 * summaries (paranoid, for some security sensitive environments), the paranoid
7871 * 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)
#define DUK_ERR_UNSUPPORTED_ERROR

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

7872 */
7873#if defined(DUK_USE_PARANOID_ERRORS)
7874#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.5.2/src/duktape.c.

◆ DUK_EXTRAOP_BNOT

#define DUK_EXTRAOP_BNOT   28

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

◆ DUK_EXTRAOP_BREAK

#define DUK_EXTRAOP_BREAK   26

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

◆ DUK_EXTRAOP_CONTINUE

#define DUK_EXTRAOP_CONTINUE   27

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

◆ DUK_EXTRAOP_DEBUGGER

#define DUK_EXTRAOP_DEBUGGER   25

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

◆ DUK_EXTRAOP_ENDCATCH

#define DUK_EXTRAOP_ENDCATCH   19

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

◆ DUK_EXTRAOP_ENDFIN

#define DUK_EXTRAOP_ENDFIN   20

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

◆ DUK_EXTRAOP_ENDLABEL

#define DUK_EXTRAOP_ENDLABEL   33

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

◆ DUK_EXTRAOP_ENDTRY

#define DUK_EXTRAOP_ENDTRY   18

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

◆ DUK_EXTRAOP_IN

#define DUK_EXTRAOP_IN   31

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

◆ DUK_EXTRAOP_INITENUM

#define DUK_EXTRAOP_INITENUM   12

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

◆ DUK_EXTRAOP_INITGET

#define DUK_EXTRAOP_INITGET   16

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

◆ DUK_EXTRAOP_INITGETI

#define DUK_EXTRAOP_INITGETI   17

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

◆ DUK_EXTRAOP_INITSET

#define DUK_EXTRAOP_INITSET   14

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

◆ DUK_EXTRAOP_INITSETI

#define DUK_EXTRAOP_INITSETI   15

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

◆ DUK_EXTRAOP_INSTOF

#define DUK_EXTRAOP_INSTOF   30

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

◆ DUK_EXTRAOP_INVALID

#define DUK_EXTRAOP_INVALID   1

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

◆ DUK_EXTRAOP_INVLHS

#define DUK_EXTRAOP_INVLHS   22

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

◆ DUK_EXTRAOP_LABEL

#define DUK_EXTRAOP_LABEL   32

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

◆ DUK_EXTRAOP_LDFALSE

#define DUK_EXTRAOP_LDFALSE   6

Definition at line 2667 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_EXTRAOP_LDTRUE

#define DUK_EXTRAOP_LDTRUE   5

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

Referenced by duk__ispec_toregconst_raw().

◆ DUK_EXTRAOP_LDUNDEF

#define DUK_EXTRAOP_LDUNDEF   3

◆ DUK_EXTRAOP_LNOT

#define DUK_EXTRAOP_LNOT   29

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

◆ DUK_EXTRAOP_NEWARR

#define DUK_EXTRAOP_NEWARR   8

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

◆ DUK_EXTRAOP_NEWOBJ

#define DUK_EXTRAOP_NEWOBJ   7

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

◆ DUK_EXTRAOP_NEXTENUM

#define DUK_EXTRAOP_NEXTENUM   13

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

◆ DUK_EXTRAOP_NOP

#define DUK_EXTRAOP_NOP   0

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

◆ DUK_EXTRAOP_SETALEN

#define DUK_EXTRAOP_SETALEN   9

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

◆ DUK_EXTRAOP_THROW

#define DUK_EXTRAOP_THROW   21

Definition at line 2682 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_EXTRAOP_TYPEOFID

#define DUK_EXTRAOP_TYPEOFID   11

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

◆ DUK_EXTRAOP_UNM

#define DUK_EXTRAOP_UNM   23

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

◆ DUK_EXTRAOP_UNP

#define DUK_EXTRAOP_UNP   24

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

◆ DUK_FORWDECL_H_INCLUDED

#define DUK_FORWDECL_H_INCLUDED

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

◆ DUK_FREE

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

◆ DUK_FREE_RAW

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

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

6852 */
6853

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 4406 of file duktape-1.5.2/src/duktape.c.

4406#define DUK_GET_HOBJECT_NEGIDX(ctx,idx) \
4407 (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 4408 of file duktape-1.5.2/src/duktape.c.

4408#define DUK_GET_HOBJECT_POSIDX(ctx,idx) \
4409 (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 4402 of file duktape-1.5.2/src/duktape.c.

4402#define DUK_GET_TVAL_NEGIDX(ctx,idx) \
4403 (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 4404 of file duktape-1.5.2/src/duktape.c.

4404#define DUK_GET_TVAL_POSIDX(ctx,idx) \
4405 (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 4911 of file duktape-1.5.2/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 */

◆ DUK_HBUFFER_ADD_SIZE

#define DUK_HBUFFER_ADD_SIZE ( x,
dv )
Value:
do { \
(x)->size += (dv); \
} while (0)

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

6420#define DUK_HBUFFER_SUB_SIZE(x,dv) do { \
6421 (x)->hdr.h_flags -= ((dv) << 16); \
6422 } 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 6371 of file duktape-1.5.2/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 6372 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HBUFFER_DECREF

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

Definition at line 3840 of file duktape-1.5.2/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 6433 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HBUFFER_DYNAMIC_GET_DATA_PTR

#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR ( heap,
x )   ((x)->curr_alloc)

Definition at line 6451 of file duktape-1.5.2/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 6431 of file duktape-1.5.2/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 6452 of file duktape-1.5.2/src/duktape.c.

6452#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v) do { \
6453 ((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
6454 } 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 6455 of file duktape-1.5.2/src/duktape.c.

6455#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x) do { \
6456 ((duk_heaphdr *) (x))->h_extra16 = 0; /* assume 0 <=> NULL */ \
6457 } 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 6432 of file duktape-1.5.2/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 6434 of file duktape-1.5.2/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 6473 of file duktape-1.5.2/src/duktape.c.

6473 ((void *) (x)->curr_alloc)
6474#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v) do { \
#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, x, v)

◆ DUK_HBUFFER_EXTERNAL_GET_SIZE

#define DUK_HBUFFER_EXTERNAL_GET_SIZE ( x)    DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))

Definition at line 6436 of file duktape-1.5.2/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 6475 of file duktape-1.5.2/src/duktape.c.

6475 (x)->curr_alloc = (void *) (v); \
6476 } while (0)
6477#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 6478 of file duktape-1.5.2/src/duktape.c.

6478 (x)->curr_alloc = (void *) NULL; \
6479 } while (0)
6480#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 6437 of file duktape-1.5.2/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 6439 of file duktape-1.5.2/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 6428 of file duktape-1.5.2/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 6429 of file duktape-1.5.2/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 6362 of file duktape-1.5.2/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 6363 of file duktape-1.5.2/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)) : \
)

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

6501 ) : \
6503 )
6504#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)

◆ DUK_HBUFFER_H_INCLUDED

#define DUK_HBUFFER_H_INCLUDED

Definition at line 6352 of file duktape-1.5.2/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 6365 of file duktape-1.5.2/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 6366 of file duktape-1.5.2/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 3839 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_bi_buffer_slice_shared().

◆ DUK_HBUFFER_MAX_BYTELEN

#define DUK_HBUFFER_MAX_BYTELEN   (0x7ffffffeUL)

Definition at line 6390 of file duktape-1.5.2/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 6368 of file duktape-1.5.2/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 6369 of file duktape-1.5.2/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 6417 of file duktape-1.5.2/src/duktape.c.

6417#define DUK_HBUFFER_ADD_SIZE(x,dv) do { \
6418 (x)->hdr.h_flags += ((dv) << 16); \
6419 } while (0)

◆ DUK_HBUFFER_SUB_SIZE

#define DUK_HBUFFER_SUB_SIZE ( x,
dv )
Value:
do { \
(x)->size -= (dv); \
} while (0)

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

6423#else
6424#define DUK_HBUFFER_GET_SIZE(x) (((duk_hbuffer *) (x))->size)
6425#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 5918 of file duktape-1.5.2/src/duktape.c.

5918 * duk_hbufferobject 'length') to the current dynamic buffer limits to
5919 * yield a byte length limit that's safe for memory accesses. This value
5920 * 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 3846 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HBUFFEROBJECT_ELEM_FLOAT32

#define DUK_HBUFFEROBJECT_ELEM_FLOAT32   7

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

◆ DUK_HBUFFEROBJECT_ELEM_FLOAT64

#define DUK_HBUFFEROBJECT_ELEM_FLOAT64   8

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

◆ DUK_HBUFFEROBJECT_ELEM_INT16

#define DUK_HBUFFEROBJECT_ELEM_INT16   4

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

◆ DUK_HBUFFEROBJECT_ELEM_INT32

#define DUK_HBUFFEROBJECT_ELEM_INT32   6

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

◆ DUK_HBUFFEROBJECT_ELEM_INT8

#define DUK_HBUFFEROBJECT_ELEM_INT8   2

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

◆ DUK_HBUFFEROBJECT_ELEM_MAX

#define DUK_HBUFFEROBJECT_ELEM_MAX   8

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

◆ DUK_HBUFFEROBJECT_ELEM_UINT16

#define DUK_HBUFFEROBJECT_ELEM_UINT16   3

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

◆ DUK_HBUFFEROBJECT_ELEM_UINT32

#define DUK_HBUFFEROBJECT_ELEM_UINT32   5

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

◆ DUK_HBUFFEROBJECT_ELEM_UINT8

#define DUK_HBUFFEROBJECT_ELEM_UINT8   0

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

◆ DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED

#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED   1

Definition at line 5840 of file duktape-1.5.2/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 5886 of file duktape-1.5.2/src/duktape.c.

5886/* True if slice is full, i.e. offset is zero and length covers the entire
5887 * buffer. This status may change independently of the duk_hbufferobject if
5888 * 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 5877 of file duktape-1.5.2/src/duktape.c.

5877 } while (0)
5878
5879/* 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 5836 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HBUFFEROBJECT_INCREF

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

Definition at line 3845 of file duktape-1.5.2/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 5908 of file duktape-1.5.2/src/duktape.c.

5908 */
5909#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h,off) \
5910 (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 5904 of file duktape-1.5.2/src/duktape.c.

5904 * buffer size. This is a safety check which is needed to ensure
5905 * that even a misconfigured duk_hbufferobject never causes memory
5906 * unsafe behavior (e.g. if an underlying dynamic buffer changes
#define check(x)
static void changes(sqlite3_context *context, int NotUsed, sqlite3_value **NotUsed2)
Definition sqlite3.c:117622

◆ 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 5893 of file duktape-1.5.2/src/duktape.c.

5893 ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf)))
5894
5895/* 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 3842 of file duktape-1.5.2/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 5613 of file duktape-1.5.2/src/duktape.c.

5613
5614/* Note: assumes 'data' is always a fixed buffer */

◆ DUK_HCOMPILEDFUNCTION_GET_BYTECODE

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

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

5601 (h)->funcs = (v); \
5602 } while (0)
static const luaL_Reg funcs[]

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_BASE

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

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

5623
#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap, h)

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 5669 of file duktape-1.5.2/src/duktape.c.

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

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_END

#define DUK_HCOMPILEDFUNCTION_GET_CODE_END ( heap,
h )
Value:
DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h))))
#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap, h)

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

5632
5633/* XXX: double evaluation of DUK_HCOMPILEDFUNCTION_GET_DATA() */
5634#define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap,h) \

◆ DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE ( heap,
h )
Value:
( \
( \
((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \
((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \
) \
)
#define DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap, h)
#define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap, h)

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

5654 )
5655
5657 ( \
5658 (duk_size_t) \
5659 ( \
5660 ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \
5661 ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \
#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(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)))

◆ 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 5663 of file duktape-1.5.2/src/duktape.c.

5663 )
5664

◆ 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 5625 of file duktape-1.5.2/src/duktape.c.

5626
#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap, h)

Referenced by duk__inc_data_inner_refcounts().

◆ DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE ( heap,
h )
Value:
( \
( \
((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \
((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE((heap), (h))) \
) \
)
#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, h)
#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, h)

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

5637
5638#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap,h) \
5639 ( \
5640 (duk_size_t) \
5641 ( \
5642 ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \
5643 ((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 5591 of file duktape-1.5.2/src/duktape.c.

5591 } while (0)
5592#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 5596 of file duktape-1.5.2/src/duktape.c.

5596 (h)->data = (duk_hbuffer *) (v); \
5597 } while (0)

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE

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

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

5619 ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h)))
5620
#define DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE(heap, h)

◆ 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 5666 of file duktape-1.5.2/src/duktape.c.

5666 ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))
5667
struct duk_tval_struct duk_tval
#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap, h)

◆ 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 5628 of file duktape-1.5.2/src/duktape.c.

5628 ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)))
5629

◆ DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE

#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE ( heap,
h )
Value:
( \
( \
((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \
((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \
) \
)
#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, h)
#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, h)

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

5645 )
5646
5648 ( \
5649 (duk_size_t) \
5650 ( \
5651 ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \
5652 ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \

◆ DUK_HCOMPILEDFUNCTION_H_INCLUDED

#define DUK_HCOMPILEDFUNCTION_H_INCLUDED

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

◆ DUK_HCOMPILEDFUNCTION_INCREF

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

Definition at line 3841 of file duktape-1.5.2/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 5603 of file duktape-1.5.2/src/duktape.c.

5603#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h) \
5604 ((h)->bytecode)
5605#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 5593 of file duktape-1.5.2/src/duktape.c.

5593#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \
5594 ((duk_hbuffer_fixed *) (void *) (h)->data)
5595#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 5598 of file duktape-1.5.2/src/duktape.c.

5598#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h) \
5599 ((h)->funcs)
5600#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 6898 of file duktape-1.5.2/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 6896 of file duktape-1.5.2/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 6717 of file duktape-1.5.2/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 6719 of file duktape-1.5.2/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 6718 of file duktape-1.5.2/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 6715 of file duktape-1.5.2/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 6714 of file duktape-1.5.2/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 6716 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAP_DBG_RATELIMIT_MILLISECS

#define DUK_HEAP_DBG_RATELIMIT_MILLISECS   200

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

◆ DUK_HEAP_DBG_RATELIMIT_OPCODES

#define DUK_HEAP_DBG_RATELIMIT_OPCODES   4000

Definition at line 6914 of file duktape-1.5.2/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 6688 of file duktape-1.5.2/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 6690 of file duktape-1.5.2/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 6689 of file duktape-1.5.2/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 6686 of file duktape-1.5.2/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 6685 of file duktape-1.5.2/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 6687 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAP_GET_STRING

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

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

6837#if defined(DUK_USE_ROM_STRINGS)
6838#define DUK_HEAP_GET_STRING(heap,idx) \

◆ DUK_HEAP_H_INCLUDED

#define DUK_HEAP_H_INCLUDED

Definition at line 6677 of file duktape-1.5.2/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 6703 of file duktape-1.5.2/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 6705 of file duktape-1.5.2/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 6704 of file duktape-1.5.2/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 6701 of file duktape-1.5.2/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 6700 of file duktape-1.5.2/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 6702 of file duktape-1.5.2/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 6797 of file duktape-1.5.2/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 6781 of file duktape-1.5.2/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 6780 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP

#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP   256L

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

◆ DUK_HEAP_MAX_BREAKPOINTS

#define DUK_HEAP_MAX_BREAKPOINTS   16

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

◆ DUK_HEAP_NUM_STRINGS

#define DUK_HEAP_NUM_STRINGS   191

◆ 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 6710 of file duktape-1.5.2/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 6712 of file duktape-1.5.2/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 6711 of file duktape-1.5.2/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 6708 of file duktape-1.5.2/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 6707 of file duktape-1.5.2/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 6709 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAP_STRCACHE_SIZE

#define DUK_HEAP_STRCACHE_SIZE   4

Definition at line 6793 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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 6794 of file duktape-1.5.2/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 6759 of file duktape-1.5.2/src/duktape.c.

6759 * To switch heap->curr_thread, use the macro below so that interrupt counters
6760 * get updated correctly. The macro allows a NULL target thread because that
6761 * 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 3661 of file duktape-1.5.2/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 3672 of file duktape-1.5.2/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 3676 of file duktape-1.5.2/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)
#define DUK_HEAPHDR_FLAGS_FLAG_MASK

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

3656#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits) do { \
3657 DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
3658 (h)->h_flags &= ~((bits)); \
3659 } 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 3664 of file duktape-1.5.2/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 3680 of file duktape-1.5.2/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 3668 of file duktape-1.5.2/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 3826 of file duktape-1.5.2/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_PREDEC_REFCOUNT(duk__h) == 0) { \
duk_heaphdr_refzero((thr), duk__h); \
} \
} \
} while (0)
#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)
#define DUK_HEAPHDR_HTYPE_VALID(h)
#define DUK_HEAPHDR_GET_REFCOUNT(h)
#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)

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

3790#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \
3791 duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
3792 DUK_ASSERT(duk__h != NULL); \
3793 DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
3794 DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
3795 if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
3796 if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
3797 duk_heaphdr_refzero((thr), duk__h); \
3798 } \
3799 } \
3800 } 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 3814 of file duktape-1.5.2/src/duktape.c.

3814#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \
3815 duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
3816 } 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 3566 of file duktape-1.5.2/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 3567 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAPHDR_FLAG_REACHABLE

#define DUK_HEAPHDR_FLAG_REACHABLE   DUK_HEAPHDR_HEAP_FLAG(0) /* mark-and-sweep: reachable */

Definition at line 3564 of file duktape-1.5.2/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 3568 of file duktape-1.5.2/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 3565 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAPHDR_FLAGS_FLAG_MASK

#define DUK_HEAPHDR_FLAGS_FLAG_MASK   (~DUK_HEAPHDR_FLAGS_TYPE_MASK)

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

◆ DUK_HEAPHDR_FLAGS_HEAP_START

#define DUK_HEAPHDR_FLAGS_HEAP_START   2 /* 5 heap flags */

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

◆ DUK_HEAPHDR_FLAGS_TYPE_MASK

#define DUK_HEAPHDR_FLAGS_TYPE_MASK   0x00000003UL

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

◆ DUK_HEAPHDR_FLAGS_USER_START

#define DUK_HEAPHDR_FLAGS_USER_START   7 /* 25 user flags */

Definition at line 3557 of file duktape-1.5.2/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 3684 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAPHDR_GET_FLAGS

#define DUK_HEAPHDR_GET_FLAGS ( h)    ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)

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

◆ DUK_HEAPHDR_GET_FLAGS_RAW

#define DUK_HEAPHDR_GET_FLAGS_RAW ( h)    ((h)->h_flags)

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

◆ DUK_HEAPHDR_GET_NEXT

#define DUK_HEAPHDR_GET_NEXT ( heap,
h )   ((h)->h_next)

◆ DUK_HEAPHDR_GET_PREV

#define DUK_HEAPHDR_GET_PREV ( heap,
h )   ((h)->h_prev)

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

◆ DUK_HEAPHDR_GET_REFCOUNT

#define DUK_HEAPHDR_GET_REFCOUNT ( h)    ((h)->h_refcount)

Definition at line 3613 of file duktape-1.5.2/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 3636 of file duktape-1.5.2/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.5.2/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 3673 of file duktape-1.5.2/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 3677 of file duktape-1.5.2/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 3665 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAPHDR_HAS_READONLY

◆ DUK_HEAPHDR_HAS_TEMPROOT

#define DUK_HEAPHDR_HAS_TEMPROOT ( h)    DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)

Definition at line 3669 of file duktape-1.5.2/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 3561 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAPHDR_HEAP_FLAG_NUMBER

#define DUK_HEAPHDR_HEAP_FLAG_NUMBER ( n)    (DUK_HEAPHDR_FLAGS_HEAP_START + (n))

Definition at line 3559 of file duktape-1.5.2/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 \
)
#define DUK_HTYPE_MIN
#define DUK_HTYPE_MAX

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

3641#define DUK_HEAPHDR_HTYPE_VALID(h) ( \
3642 DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \
3643 DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
3644 )

Referenced by duk_tval_decref().

◆ DUK_HEAPHDR_INCREF

#define DUK_HEAPHDR_INCREF ( thr,
h )   DUK_HEAPHDR_INCREF_FAST((thr),(h))

Definition at line 3825 of file duktape-1.5.2/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)); \
DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
} \
} while (0)

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

3782#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
3783 duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
3784 DUK_ASSERT(duk__h != NULL); \
3785 DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
3786 if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
3787 DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
3788 } \
3789 } 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 3811 of file duktape-1.5.2/src/duktape.c.

3811#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \
3812 duk_heaphdr_incref((duk_heaphdr *) (h)); \
3813 } 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 3694 of file duktape-1.5.2/src/duktape.c.

3694#define DUK_HEAPHDR_INIT_NULLS(h) do { \
3695 DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
3696 DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
3697 } while (0)

◆ DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE

#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE ( h)    1

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

◆ DUK_HEAPHDR_PREDEC_REFCOUNT

#define DUK_HEAPHDR_PREDEC_REFCOUNT ( h)    (--(h)->h_refcount) /* result: updated refcount */

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

◆ DUK_HEAPHDR_PREINC_REFCOUNT

#define DUK_HEAPHDR_PREINC_REFCOUNT ( h)    (++(h)->h_refcount) /* result: updated refcount */

Definition at line 3617 of file duktape-1.5.2/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 3671 of file duktape-1.5.2/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 3675 of file duktape-1.5.2/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 3651 of file duktape-1.5.2/src/duktape.c.

3651#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits) do { \
3652 DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
3653 (h)->h_flags |= (bits); \
3654 } 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 & (~(((1 << (n)) - 1) << (m)))) \
| ((v) << (m)); \
} while (0)

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

3686#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v) do { \
3687 (h)->h_flags = \
3688 ((h)->h_flags & (~(((1 << (n)) - 1) << (m)))) \
3689 | ((v) << (m)); \
3690 } 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 3632 of file duktape-1.5.2/src/duktape.c.

3632#define DUK_HEAPHDR_SET_FLAGS(h,val) do { \
3633 (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
3634 } 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 3584 of file duktape-1.5.2/src/duktape.c.

3584#define DUK_HEAPHDR_SET_NEXT(heap,h,val) do { \
3585 (h)->h_next = (val); \
3586 } 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 3598 of file duktape-1.5.2/src/duktape.c.

3598#define DUK_HEAPHDR_SET_PREV(heap,h,val) do { \
3599 (h)->h_prev = (val); \
3600 } 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 3663 of file duktape-1.5.2/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 3679 of file duktape-1.5.2/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 3614 of file duktape-1.5.2/src/duktape.c.

3614#define DUK_HEAPHDR_SET_REFCOUNT(h,val) do { \
3615 (h)->h_refcount = (val); \
3616 } 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 3667 of file duktape-1.5.2/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)
#define DUK_HEAPHDR_FLAGS_TYPE_MASK

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

3637#define DUK_HEAPHDR_SET_TYPE(h,val) do { \
3638 (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
3639 } 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) | \
} while (0)

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

3646#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval) do { \
3647 (h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
3648 ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
3649 } 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 3704 of file duktape-1.5.2/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 3562 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HEAPHDR_USER_FLAG_NUMBER

#define DUK_HEAPHDR_USER_FLAG_NUMBER ( n)    (DUK_HEAPHDR_FLAGS_USER_START + (n))

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

◆ DUK_HNATIVEFUNCTION_DECREF

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

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

◆ DUK_HNATIVEFUNCTION_H_INCLUDED

#define DUK_HNATIVEFUNCTION_H_INCLUDED

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

◆ DUK_HNATIVEFUNCTION_INCREF

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

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

◆ DUK_HNATIVEFUNCTION_NARGS_MAX

#define DUK_HNATIVEFUNCTION_NARGS_MAX   ((duk_int16_t) 0x7fff)

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

◆ DUK_HNATIVEFUNCTION_NARGS_VARARGS

#define DUK_HNATIVEFUNCTION_NARGS_VARARGS   ((duk_int16_t) -1)

Definition at line 5805 of file duktape-1.5.2/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 5282 of file duktape-1.5.2/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 5278 of file duktape-1.5.2/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))) \
))
#define DUK_HOBJECT_GET_ESIZE(h)

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

5019 DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
5020 ))
5021#define DUK_HOBJECT_A_GET_BASE(heap,h) \
5022 ((duk_tval *) (void *) ( \
5023 DUK_HOBJECT_GET_PROPS((heap), (h)) + \
5024 DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
#define DUK_HOBJECT_GET_PROPS(heap, h)
#define DUK_HOBJECT_A_GET_BASE(heap, h)

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 5110 of file duktape-1.5.2/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)])

◆ DUK_HOBJECT_A_MIN_GROW_ADD

#define DUK_HOBJECT_A_MIN_GROW_ADD   16

Definition at line 5300 of file duktape-1.5.2/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 5301 of file duktape-1.5.2/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 5133 of file duktape-1.5.2/src/duktape.c.

5133 DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (duk_uint8_t) (f); \
5134 } while (0)
5135#define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v) do { \
#define DUK_HOBJECT_E_GET_FLAGS(heap, h, i)

◆ 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 5136 of file duktape-1.5.2/src/duktape.c.

5136 DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \
5137 } while (0)
#define DUK_HOBJECT_A_GET_VALUE(heap, h, i)

◆ DUK_HOBJECT_ALIGN_TARGET

#define DUK_HOBJECT_ALIGN_TARGET   8

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

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_BOUND_CHAIN_SANITY

#define DUK_HOBJECT_BOUND_CHAIN_SANITY   10000L

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

Referenced by duk_js_instanceof().

◆ DUK_HOBJECT_CLASS_ARGUMENTS

#define DUK_HOBJECT_CLASS_ARGUMENTS   1

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

◆ DUK_HOBJECT_CLASS_ARRAY

#define DUK_HOBJECT_CLASS_ARRAY   2

Definition at line 4711 of file duktape-1.5.2/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 4728 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_CLASS_AS_FLAGS

◆ DUK_HOBJECT_CLASS_BOOLEAN

#define DUK_HOBJECT_CLASS_BOOLEAN   3

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

◆ DUK_HOBJECT_CLASS_BUFFER

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

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

◆ DUK_HOBJECT_CLASS_DATAVIEW

#define DUK_HOBJECT_CLASS_DATAVIEW   20

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

◆ DUK_HOBJECT_CLASS_DATE

#define DUK_HOBJECT_CLASS_DATE   4

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

◆ DUK_HOBJECT_CLASS_DECENV

#define DUK_HOBJECT_CLASS_DECENV   15 /* custom */

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

◆ DUK_HOBJECT_CLASS_ERROR

#define DUK_HOBJECT_CLASS_ERROR   5

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

◆ DUK_HOBJECT_CLASS_FLOAT32ARRAY

#define DUK_HOBJECT_CLASS_FLOAT32ARRAY   28

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

◆ DUK_HOBJECT_CLASS_FLOAT64ARRAY

#define DUK_HOBJECT_CLASS_FLOAT64ARRAY   29

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

◆ DUK_HOBJECT_CLASS_FUNCTION

#define DUK_HOBJECT_CLASS_FUNCTION   6

◆ DUK_HOBJECT_CLASS_GLOBAL

#define DUK_HOBJECT_CLASS_GLOBAL   13

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

Referenced by duk__declvar_helper().

◆ DUK_HOBJECT_CLASS_INT16ARRAY

#define DUK_HOBJECT_CLASS_INT16ARRAY   24

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

◆ DUK_HOBJECT_CLASS_INT32ARRAY

#define DUK_HOBJECT_CLASS_INT32ARRAY   26

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

◆ DUK_HOBJECT_CLASS_INT8ARRAY

#define DUK_HOBJECT_CLASS_INT8ARRAY   21

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

◆ DUK_HOBJECT_CLASS_JSON

#define DUK_HOBJECT_CLASS_JSON   7

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

◆ DUK_HOBJECT_CLASS_MATH

#define DUK_HOBJECT_CLASS_MATH   8

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

◆ DUK_HOBJECT_CLASS_MAX

#define DUK_HOBJECT_CLASS_MAX   29

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

◆ DUK_HOBJECT_CLASS_NUMBER

#define DUK_HOBJECT_CLASS_NUMBER   9

Definition at line 4718 of file duktape-1.5.2/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 5226 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_CLASS_OBJECT

#define DUK_HOBJECT_CLASS_OBJECT   10

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

◆ DUK_HOBJECT_CLASS_OBJENV

#define DUK_HOBJECT_CLASS_OBJENV   14 /* custom */

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

◆ DUK_HOBJECT_CLASS_POINTER

#define DUK_HOBJECT_CLASS_POINTER   17 /* custom */

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

◆ DUK_HOBJECT_CLASS_REGEXP

#define DUK_HOBJECT_CLASS_REGEXP   11

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

Referenced by duk_bi_regexp_constructor().

◆ DUK_HOBJECT_CLASS_STRING

#define DUK_HOBJECT_CLASS_STRING   12

◆ DUK_HOBJECT_CLASS_THREAD

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

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

◆ DUK_HOBJECT_CLASS_UINT16ARRAY

#define DUK_HOBJECT_CLASS_UINT16ARRAY   25

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

◆ DUK_HOBJECT_CLASS_UINT32ARRAY

#define DUK_HOBJECT_CLASS_UINT32ARRAY   27

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

◆ DUK_HOBJECT_CLASS_UINT8ARRAY

#define DUK_HOBJECT_CLASS_UINT8ARRAY   22

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

◆ DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY

#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY   23

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

◆ DUK_HOBJECT_CLASS_UNUSED

#define DUK_HOBJECT_CLASS_UNUSED   0

Definition at line 4709 of file duktape-1.5.2/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 4868 of file duktape-1.5.2/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 4863 of file duktape-1.5.2/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 4866 of file duktape-1.5.2/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 4864 of file duktape-1.5.2/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 4862 of file duktape-1.5.2/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 4873 of file duktape-1.5.2/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 4874 of file duktape-1.5.2/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 4877 of file duktape-1.5.2/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 4875 of file duktape-1.5.2/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 4878 of file duktape-1.5.2/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 4879 of file duktape-1.5.2/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 4876 of file duktape-1.5.2/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 4861 of file duktape-1.5.2/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 4872 of file duktape-1.5.2/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 4865 of file duktape-1.5.2/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 4871 of file duktape-1.5.2/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 4870 of file duktape-1.5.2/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 4869 of file duktape-1.5.2/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 4867 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_CMASK_ALL

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

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

◆ DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS

#define DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS
Value:
#define DUK_HOBJECT_CMASK_INT16ARRAY
#define DUK_HOBJECT_CMASK_ARRAYBUFFER
#define DUK_HOBJECT_CMASK_BUFFER
#define DUK_HOBJECT_CMASK_FLOAT32ARRAY
#define DUK_HOBJECT_CMASK_INT8ARRAY
#define DUK_HOBJECT_CMASK_DATAVIEW
#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY
#define DUK_HOBJECT_CMASK_UINT16ARRAY
#define DUK_HOBJECT_CMASK_UINT8ARRAY
#define DUK_HOBJECT_CMASK_UINT32ARRAY
#define DUK_HOBJECT_CMASK_INT32ARRAY
#define DUK_HOBJECT_CMASK_FLOAT64ARRAY

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

4774#define DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS \
4775 (DUK_HOBJECT_CMASK_BUFFER | \
4776 DUK_HOBJECT_CMASK_ARRAYBUFFER | \
4777 DUK_HOBJECT_CMASK_DATAVIEW | \
4778 DUK_HOBJECT_CMASK_INT8ARRAY | \
4779 DUK_HOBJECT_CMASK_UINT8ARRAY | \
4780 DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | \
4781 DUK_HOBJECT_CMASK_INT16ARRAY | \
4782 DUK_HOBJECT_CMASK_UINT16ARRAY | \
4783 DUK_HOBJECT_CMASK_INT32ARRAY | \
4784 DUK_HOBJECT_CMASK_UINT32ARRAY | \
4785 DUK_HOBJECT_CMASK_FLOAT32ARRAY | \
4786 DUK_HOBJECT_CMASK_FLOAT64ARRAY)

◆ DUK_HOBJECT_CMASK_ARGUMENTS

#define DUK_HOBJECT_CMASK_ARGUMENTS   (1UL << DUK_HOBJECT_CLASS_ARGUMENTS)

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

◆ DUK_HOBJECT_CMASK_ARRAY

#define DUK_HOBJECT_CMASK_ARRAY   (1UL << DUK_HOBJECT_CLASS_ARRAY)

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

◆ DUK_HOBJECT_CMASK_ARRAYBUFFER

#define DUK_HOBJECT_CMASK_ARRAYBUFFER   (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER)

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

◆ DUK_HOBJECT_CMASK_BOOLEAN

#define DUK_HOBJECT_CMASK_BOOLEAN   (1UL << DUK_HOBJECT_CLASS_BOOLEAN)

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

◆ DUK_HOBJECT_CMASK_BUFFER

#define DUK_HOBJECT_CMASK_BUFFER   (1UL << DUK_HOBJECT_CLASS_BUFFER)

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

◆ DUK_HOBJECT_CMASK_DATAVIEW

#define DUK_HOBJECT_CMASK_DATAVIEW   (1UL << DUK_HOBJECT_CLASS_DATAVIEW)

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

◆ DUK_HOBJECT_CMASK_DATE

#define DUK_HOBJECT_CMASK_DATE   (1UL << DUK_HOBJECT_CLASS_DATE)

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

◆ DUK_HOBJECT_CMASK_DECENV

#define DUK_HOBJECT_CMASK_DECENV   (1UL << DUK_HOBJECT_CLASS_DECENV)

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

◆ DUK_HOBJECT_CMASK_ERROR

#define DUK_HOBJECT_CMASK_ERROR   (1UL << DUK_HOBJECT_CLASS_ERROR)

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

◆ DUK_HOBJECT_CMASK_FLOAT32ARRAY

#define DUK_HOBJECT_CMASK_FLOAT32ARRAY   (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY)

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

◆ DUK_HOBJECT_CMASK_FLOAT64ARRAY

#define DUK_HOBJECT_CMASK_FLOAT64ARRAY   (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY)

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

◆ DUK_HOBJECT_CMASK_FUNCTION

#define DUK_HOBJECT_CMASK_FUNCTION   (1UL << DUK_HOBJECT_CLASS_FUNCTION)

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

◆ DUK_HOBJECT_CMASK_GLOBAL

#define DUK_HOBJECT_CMASK_GLOBAL   (1UL << DUK_HOBJECT_CLASS_GLOBAL)

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

◆ DUK_HOBJECT_CMASK_INT16ARRAY

#define DUK_HOBJECT_CMASK_INT16ARRAY   (1UL << DUK_HOBJECT_CLASS_INT16ARRAY)

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

◆ DUK_HOBJECT_CMASK_INT32ARRAY

#define DUK_HOBJECT_CMASK_INT32ARRAY   (1UL << DUK_HOBJECT_CLASS_INT32ARRAY)

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

◆ DUK_HOBJECT_CMASK_INT8ARRAY

#define DUK_HOBJECT_CMASK_INT8ARRAY   (1UL << DUK_HOBJECT_CLASS_INT8ARRAY)

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

◆ DUK_HOBJECT_CMASK_JSON

#define DUK_HOBJECT_CMASK_JSON   (1UL << DUK_HOBJECT_CLASS_JSON)

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

◆ DUK_HOBJECT_CMASK_MATH

#define DUK_HOBJECT_CMASK_MATH   (1UL << DUK_HOBJECT_CLASS_MATH)

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

◆ DUK_HOBJECT_CMASK_NUMBER

#define DUK_HOBJECT_CMASK_NUMBER   (1UL << DUK_HOBJECT_CLASS_NUMBER)

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

◆ DUK_HOBJECT_CMASK_OBJECT

#define DUK_HOBJECT_CMASK_OBJECT   (1UL << DUK_HOBJECT_CLASS_OBJECT)

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

◆ DUK_HOBJECT_CMASK_OBJENV

#define DUK_HOBJECT_CMASK_OBJENV   (1UL << DUK_HOBJECT_CLASS_OBJENV)

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

◆ DUK_HOBJECT_CMASK_POINTER

#define DUK_HOBJECT_CMASK_POINTER   (1UL << DUK_HOBJECT_CLASS_POINTER)

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

◆ DUK_HOBJECT_CMASK_REGEXP

#define DUK_HOBJECT_CMASK_REGEXP   (1UL << DUK_HOBJECT_CLASS_REGEXP)

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

◆ DUK_HOBJECT_CMASK_STRING

#define DUK_HOBJECT_CMASK_STRING   (1UL << DUK_HOBJECT_CLASS_STRING)

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

◆ DUK_HOBJECT_CMASK_THREAD

#define DUK_HOBJECT_CMASK_THREAD   (1UL << DUK_HOBJECT_CLASS_THREAD)

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

◆ DUK_HOBJECT_CMASK_UINT16ARRAY

#define DUK_HOBJECT_CMASK_UINT16ARRAY   (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY)

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

◆ DUK_HOBJECT_CMASK_UINT32ARRAY

#define DUK_HOBJECT_CMASK_UINT32ARRAY   (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY)

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

◆ DUK_HOBJECT_CMASK_UINT8ARRAY

#define DUK_HOBJECT_CMASK_UINT8ARRAY   (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY)

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

◆ DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY

#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY   (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY)

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

◆ DUK_HOBJECT_CMASK_UNUSED

#define DUK_HOBJECT_CMASK_UNUSED   (1UL << DUK_HOBJECT_CLASS_UNUSED)

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

◆ DUK_HOBJECT_DECREF

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

Definition at line 3838 of file duktape-1.5.2/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 3858 of file duktape-1.5.2/src/duktape.c.

3858#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
3859 if ((h) != NULL) { \
3860 DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
3861 } \
3862 } 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)
#define mask(n)

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

5146 } while (0)
5147
5148#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 5000 of file duktape-1.5.2/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)])

◆ 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 5015 of file duktape-1.5.2/src/duktape.c.

5015 DUK_HOBJECT_GET_PROPS((heap), (h)) \
5016 ))
5017#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
5018 ((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 5109 of file duktape-1.5.2/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 5098 of file duktape-1.5.2/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) \
))
union duk_propvalue duk_propvalue

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

5006#error invalid DUK_USE_ALIGN_BY
5007#endif
5008#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
5009 ((duk_hstring **) (void *) ( \
5010 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 5099 of file duktape-1.5.2/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 5100 of file duktape-1.5.2/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 5011 of file duktape-1.5.2/src/duktape.c.

5011 DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
5012 ))
5013#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
5014 ((duk_propvalue *) (void *) ( \
#define DUK_HOBJECT_E_GET_VALUE_BASE(heap, h)

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

◆ 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 5105 of file duktape-1.5.2/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 5101 of file duktape-1.5.2/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)

◆ 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 5107 of file duktape-1.5.2/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 5102 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_E_GET_VALUE_TVAL_PTR

◆ DUK_HOBJECT_E_MIN_GROW_ADD

#define DUK_HOBJECT_E_MIN_GROW_ADD   16

Definition at line 5296 of file duktape-1.5.2/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 5297 of file duktape-1.5.2/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 5142 of file duktape-1.5.2/src/duktape.c.

5142 } while (0)
5143
5144#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 5130 of file duktape-1.5.2/src/duktape.c.

5130 DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \
5131 } while (0)
5132#define DUK_HOBJECT_E_SET_FLAGS(heap,h,i,f) do { \
#define DUK_HOBJECT_E_GET_VALUE(heap, h, i)

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 5115 of file duktape-1.5.2/src/duktape.c.

5115#define DUK_HOBJECT_H_GET_INDEX_PTR(heap,h,i) (&DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
5116
5117#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 5118 of file duktape-1.5.2/src/duktape.c.

5118 DUK_HOBJECT_E_GET_KEY((heap), (h), (i)) = (k); \
5119 } while (0)
5120#define DUK_HOBJECT_E_SET_VALUE(heap,h,i,v) do { \
#define DUK_HOBJECT_E_GET_KEY(heap, h, i)

◆ 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 5124 of file duktape-1.5.2/src/duktape.c.

5124 DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v = (v); \
5125 } while (0)
5126#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 5127 of file duktape-1.5.2/src/duktape.c.

5127 DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get = (v); \
5128 } while (0)
5129#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 5121 of file duktape-1.5.2/src/duktape.c.

5121 DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)) = (v); \
5122 } while (0)
5123#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 5163 of file duktape-1.5.2/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 5162 of file duktape-1.5.2/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 5161 of file duktape-1.5.2/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 5160 of file duktape-1.5.2/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)

◆ 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 5152 of file duktape-1.5.2/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 5151 of file duktape-1.5.2/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 5150 of file duktape-1.5.2/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 5158 of file duktape-1.5.2/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 5157 of file duktape-1.5.2/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 5156 of file duktape-1.5.2/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 5155 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_E_USE_HASH_LIMIT

#define DUK_HOBJECT_E_USE_HASH_LIMIT   32

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

◆ DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS

#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS
Value:

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

4812#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \
4813 DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \
4814 DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
4815 DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \
4816 DUK_HOBJECT_FLAG_BUFFEROBJECT | \
4817 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 4677 of file duktape-1.5.2/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 4672 of file duktape-1.5.2/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 4675 of file duktape-1.5.2/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 4690 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_FLAG_CLASS_BITS

#define DUK_HOBJECT_FLAG_CLASS_BITS   5

Definition at line 4691 of file duktape-1.5.2/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 4673 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_FLAG_CONSTRUCTABLE

#define DUK_HOBJECT_FLAG_CONSTRUCTABLE   DUK_HEAPHDR_USER_FLAG(1) /* object is constructable */

◆ 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 4682 of file duktape-1.5.2/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 4683 of file duktape-1.5.2/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 4686 of file duktape-1.5.2/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 4684 of file duktape-1.5.2/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 4687 of file duktape-1.5.2/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 4688 of file duktape-1.5.2/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 */

◆ DUK_HOBJECT_FLAG_EXTENSIBLE

◆ 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 4681 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_FLAG_NATIVEFUNCTION

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

◆ DUK_HOBJECT_FLAG_NEWENV

#define DUK_HOBJECT_FLAG_NEWENV   DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompiledfunction) */

◆ DUK_HOBJECT_FLAG_NOTAIL

#define DUK_HOBJECT_FLAG_NOTAIL   DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */

◆ DUK_HOBJECT_FLAG_STRICT

#define DUK_HOBJECT_FLAG_STRICT   DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */

◆ DUK_HOBJECT_FLAG_THREAD

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

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

◆ DUK_HOBJECT_GET_ASIZE

◆ 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 4698 of file duktape-1.5.2/src/duktape.c.

4698#define DUK_HOBJECT_GET_CLASS_MASK(h) \
4699 (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 4693 of file duktape-1.5.2/src/duktape.c.

4693#define DUK_HOBJECT_GET_CLASS_NUMBER(h) \
4694 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:
(heap), \
)
#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n)
#define DUK_HEAP_GET_STRING(heap, idx)

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

5228#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n) duk_class_number_to_stridx[(n)]
5229
5230#define DUK_HOBJECT_GET_CLASS_STRING(heap,h) \
5231 DUK_HEAP_GET_STRING( \
5232 (heap), \

Referenced by duk_to_int_clamped_raw().

◆ DUK_HOBJECT_GET_ENEXT

#define DUK_HOBJECT_GET_ENEXT ( h)    ((h)->e_next)

◆ DUK_HOBJECT_GET_ESIZE

#define DUK_HOBJECT_GET_ESIZE ( h)    ((h)->e_size)

Definition at line 5193 of file duktape-1.5.2/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 5201 of file duktape-1.5.2/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 5479 of file duktape-1.5.2/src/duktape.c.

5479 * slot for internal value; this call can then access it directly.
5480 */
int value
Definition lsqlite3.c:2155

◆ DUK_HOBJECT_GET_PROPS

#define DUK_HOBJECT_GET_PROPS ( heap,
h )    ((h)->props)

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

4949 } while (0)
4950#else

Referenced by duk__realloc_props(), and duk_free_hobject_inner().

◆ DUK_HOBJECT_GET_PROTOTYPE

#define DUK_HOBJECT_GET_PROTOTYPE ( heap,
h )    ((h)->prototype)

◆ 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 5025 of file duktape-1.5.2/src/duktape.c.

5026 ))
5027#define DUK_HOBJECT_H_GET_BASE(heap,h) \
5028 ((duk_uint32_t *) (void *) ( \
5029 DUK_HOBJECT_GET_PROPS((heap), (h)) + \
5030 DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
5031 DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \
#define DUK_HOBJECT_E_FLAG_PADDING(e_sz)

◆ 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 5112 of file duktape-1.5.2/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 5113 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_H_INCLUDED

#define DUK_HOBJECT_H_INCLUDED

Definition at line 4665 of file duktape-1.5.2/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 5138 of file duktape-1.5.2/src/duktape.c.

5138#define DUK_HOBJECT_A_SET_VALUE_TVAL(heap,h,i,v) \
5139 DUK_HOBJECT_A_SET_VALUE((heap), (h), (i), (v)) /* alias for above */
5140#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 5275 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__get_min_grow_e().

◆ DUK_HOBJECT_HAS_ARRAY_PART

◆ DUK_HOBJECT_HAS_BOUND

#define DUK_HOBJECT_HAS_BOUND ( h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)

Definition at line 4823 of file duktape-1.5.2/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 4826 of file duktape-1.5.2/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 4824 of file duktape-1.5.2/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 4822 of file duktape-1.5.2/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 4833 of file duktape-1.5.2/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 4834 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS

◆ DUK_HOBJECT_HAS_EXOTIC_ARRAY

#define DUK_HOBJECT_HAS_EXOTIC_ARRAY ( h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)

◆ 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 4819 of file duktape-1.5.2/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 4838 of file duktape-1.5.2/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)

◆ DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ

#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ ( h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)

◆ DUK_HOBJECT_HAS_EXTENSIBLE

◆ DUK_HOBJECT_HAS_NAMEBINDING

#define DUK_HOBJECT_HAS_NAMEBINDING ( h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)

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

◆ DUK_HOBJECT_HAS_NATIVEFUNCTION

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

◆ DUK_HOBJECT_HAS_NEWENV

#define DUK_HOBJECT_HAS_NEWENV ( h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)

Definition at line 4831 of file duktape-1.5.2/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 4830 of file duktape-1.5.2/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)

◆ DUK_HOBJECT_HAS_THREAD

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

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

◆ DUK_HOBJECT_HASH_INITIAL

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

Definition at line 5304 of file duktape-1.5.2/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 5305 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_HASHIDX_DELETED

#define DUK_HOBJECT_HASHIDX_DELETED   0xfffffffeUL

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

◆ DUK_HOBJECT_HASHIDX_UNUSED

#define DUK_HOBJECT_HASHIDX_UNUSED   0xffffffffUL

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

◆ DUK_HOBJECT_INCREF

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

◆ 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 3853 of file duktape-1.5.2/src/duktape.c.

3853#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
3854 if ((h) != NULL) { \
3855 DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
3856 } \
3857 } 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 4791 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_IS_BUFFEROBJECT

◆ DUK_HOBJECT_IS_CALLABLE

#define DUK_HOBJECT_IS_CALLABLE ( h)
Value:

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

4806#define DUK_HOBJECT_IS_CALLABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
4807 DUK_HOBJECT_FLAG_BOUND | \
4808 DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
4809 DUK_HOBJECT_FLAG_NATIVEFUNCTION)

Referenced by duk_hobject_prepare_property_descriptor(), and duk_js_instanceof().

◆ DUK_HOBJECT_IS_COMPILEDFUNCTION

◆ DUK_HOBJECT_IS_DECENV

#define DUK_HOBJECT_IS_DECENV ( h)    (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV)

◆ DUK_HOBJECT_IS_ENV

#define DUK_HOBJECT_IS_ENV ( h)    (DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_DECENV((h)))

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

◆ DUK_HOBJECT_IS_FUNCTION

#define DUK_HOBJECT_IS_FUNCTION ( h)
Value:

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

4801#define DUK_HOBJECT_IS_FUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
4802 DUK_HOBJECT_FLAG_BOUND | \
4803 DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
4804 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)

◆ DUK_HOBJECT_IS_NONBOUND_FUNCTION

#define DUK_HOBJECT_IS_NONBOUND_FUNCTION ( h)
Value:

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

4797#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
4798 DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
4799 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 4788 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__declvar_helper().

◆ DUK_HOBJECT_IS_THREAD

◆ DUK_HOBJECT_MAX_PROPERTIES

#define DUK_HOBJECT_MAX_PROPERTIES   0x7fffffffUL /* 2**31-1 ~= 2G properties */

Definition at line 5268 of file duktape-1.5.2/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 5095 of file duktape-1.5.2/src/duktape.c.

5095#endif /* hobject property layout */
5096

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)) + \
(n_arr) * sizeof(duk_tval) + \
(n_hash) * sizeof(duk_uint32_t) \
)

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

5032 DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
5033 ))
5034#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
5035 ( \
5036 (n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
5037 DUK_HOBJECT_E_FLAG_PADDING((n_ent)) + \
5038 (n_arr) * sizeof(duk_tval) + \
#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent, n_arr, n_hash)
#define DUK_HOBJECT_GET_ASIZE(h)

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) + \
(set_h) = (duk_uint32_t *) (void *) ((set_a) + (n_arr)); \
} while (0)

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

5039 (n_hash) * sizeof(duk_uint32_t) \
5040 )
5041#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 { \
5042 (set_e_pv) = (duk_propvalue *) (void *) (p_base); \
5043 (set_e_k) = (duk_hstring **) (void *) ((set_e_pv) + (n_ent)); \
5044 (set_e_f) = (duk_uint8_t *) (void *) ((set_e_k) + (n_ent)); \
5045 (set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + \
5046 sizeof(duk_uint8_t) * (n_ent) + \
5047 DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \
#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)

Referenced by duk__realloc_props().

◆ DUK_HOBJECT_POSTINC_ENEXT

#define DUK_HOBJECT_POSTINC_ENEXT ( h)    ((h)->e_next++)

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

◆ DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY

#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY   10000L

◆ 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 4848 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_SET_ASIZE

#define DUK_HOBJECT_SET_ASIZE ( h,
v )   do { (h)->a_size = (v); } while (0)

Definition at line 5199 of file duktape-1.5.2/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 4843 of file duktape-1.5.2/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 4846 of file duktape-1.5.2/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 4695 of file duktape-1.5.2/src/duktape.c.

4695#define DUK_HOBJECT_SET_CLASS_NUMBER(h,v) \
4696 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 4844 of file duktape-1.5.2/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 4842 of file duktape-1.5.2/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 4853 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_SET_ENEXT

#define DUK_HOBJECT_SET_ENEXT ( h,
v )   do { (h)->e_next = (v); } while (0)

Definition at line 5196 of file duktape-1.5.2/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 4854 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_SET_ESIZE

#define DUK_HOBJECT_SET_ESIZE ( h,
v )   do { (h)->e_size = (v); } while (0)

Definition at line 5194 of file duktape-1.5.2/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 4857 of file duktape-1.5.2/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 4855 of file duktape-1.5.2/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 4858 of file duktape-1.5.2/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 4859 of file duktape-1.5.2/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 4856 of file duktape-1.5.2/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 4841 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HOBJECT_SET_HSIZE

#define DUK_HOBJECT_SET_HSIZE ( h,
v )   do { (h)->h_size = (v); } while (0)

Definition at line 5202 of file duktape-1.5.2/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 4852 of file duktape-1.5.2/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 4845 of file duktape-1.5.2/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 4851 of file duktape-1.5.2/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 4850 of file duktape-1.5.2/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 4951 of file duktape-1.5.2/src/duktape.c.

4951#define DUK_HOBJECT_GET_PROPS(heap,h) \
4952 ((h)->props)
4953#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 5247 of file duktape-1.5.2/src/duktape.c.

5247#define DUK_HOBJECT_GET_PROTOTYPE(heap,h) \
5248 ((h)->prototype)
5249#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 5253 of file duktape-1.5.2/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 4849 of file duktape-1.5.2/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 4847 of file duktape-1.5.2/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 4478 of file duktape-1.5.2/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 4477 of file duktape-1.5.2/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 4482 of file duktape-1.5.2/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 4483 of file duktape-1.5.2/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 4479 of file duktape-1.5.2/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 4480 of file duktape-1.5.2/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 4481 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HSTRING_DECREF

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

Definition at line 3836 of file duktape-1.5.2/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 4454 of file duktape-1.5.2/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 4453 of file duktape-1.5.2/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 4458 of file duktape-1.5.2/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 4459 of file duktape-1.5.2/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 4455 of file duktape-1.5.2/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 4456 of file duktape-1.5.2/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 4457 of file duktape-1.5.2/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 4552 of file duktape-1.5.2/src/duktape.c.

4552#define DUK_HSTRING_GET_ARRIDX_FAST(h) \
4553 (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 4556 of file duktape-1.5.2/src/duktape.c.

4556#define DUK_HSTRING_GET_ARRIDX_SLOW(h) \
4557 (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

◆ DUK_HSTRING_GET_CHARLEN

#define DUK_HSTRING_GET_CHARLEN ( x)    ((x)->clen)

◆ DUK_HSTRING_GET_DATA

#define DUK_HSTRING_GET_DATA ( x)     ((const duk_uint8_t *) ((x) + 1))

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

4539#define DUK_HSTRING_GET_DATA(x) \
4540 ((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 4543 of file duktape-1.5.2/src/duktape.c.

4543#define DUK_HSTRING_GET_DATA_END(x) \
4544 (DUK_HSTRING_GET_DATA((x)) + (x)->blen)

◆ DUK_HSTRING_GET_HASH

#define DUK_HSTRING_GET_HASH ( x)    ((x)->hash)

Definition at line 4499 of file duktape-1.5.2/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 4430 of file duktape-1.5.2/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 4462 of file duktape-1.5.2/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 4461 of file duktape-1.5.2/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 4466 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HSTRING_HAS_EXTDATA

#define DUK_HSTRING_HAS_EXTDATA ( x)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)

◆ DUK_HSTRING_HAS_INTERNAL

#define DUK_HSTRING_HAS_INTERNAL ( x)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)

Definition at line 4463 of file duktape-1.5.2/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 4464 of file duktape-1.5.2/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)

◆ DUK_HSTRING_INCREF

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

Definition at line 3835 of file duktape-1.5.2/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 4490 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HSTRING_IS_EMPTY

#define DUK_HSTRING_IS_EMPTY ( x)    (DUK_HSTRING_GET_BYTELEN((x)) == 0)

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

◆ DUK_HSTRING_MAX_BYTELEN

#define DUK_HSTRING_MAX_BYTELEN   (0x7fffffffUL)

Definition at line 4444 of file duktape-1.5.2/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 4547 of file duktape-1.5.2/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 4470 of file duktape-1.5.2/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 4469 of file duktape-1.5.2/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 4523 of file duktape-1.5.2/src/duktape.c.

4523#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
4524 (x)->blen = (v); \
4525 } 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 4527 of file duktape-1.5.2/src/duktape.c.

4527#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
4528 (x)->clen = (v); \
4529 } 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 4474 of file duktape-1.5.2/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 4475 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HSTRING_SET_HASH

#define DUK_HSTRING_SET_HASH ( x,
v )
Value:
do { \
(x)->hash = (v); \
} while (0)

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

4500#define DUK_HSTRING_SET_HASH(x,v) do { \
4501 (x)->hash = (v); \
4502 } 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 4471 of file duktape-1.5.2/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 4472 of file duktape-1.5.2/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 4473 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HTHREAD_DECREF

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

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

◆ DUK_HTHREAD_GET_CURRENT_ACTIVATION

#define DUK_HTHREAD_GET_CURRENT_ACTIVATION ( thr)    (&(thr)->callstack[(thr)->callstack_top - 1])

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

◆ DUK_HTHREAD_GET_STRING

#define DUK_HTHREAD_GET_STRING ( thr,
idx )    ((thr)->strs[(idx)])

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

6090#if defined(DUK_USE_ROM_STRINGS)
6091#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 5970 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HTHREAD_INCREF

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

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

◆ DUK_HTHREAD_STATE_INACTIVE

#define DUK_HTHREAD_STATE_INACTIVE   1 /* thread not currently running */

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

◆ DUK_HTHREAD_STATE_RESUMED

#define DUK_HTHREAD_STATE_RESUMED   3 /* thread resumed another thread (active but not running) */

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

◆ DUK_HTHREAD_STATE_RUNNING

#define DUK_HTHREAD_STATE_RUNNING   2 /* thread currently running (only one at a time) */

Definition at line 6099 of file duktape-1.5.2/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 6102 of file duktape-1.5.2/src/duktape.c.

◆ DUK_HTHREAD_STATE_YIELDED

#define DUK_HTHREAD_STATE_YIELDED   4 /* thread has yielded */

Definition at line 6101 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_HTHREAD_STRING_LC_ARGUMENTS

#define DUK_HTHREAD_STRING_LC_ARGUMENTS ( thr)    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)

◆ 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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_HTHREAD_STRING_LENGTH

#define DUK_HTHREAD_STRING_LENGTH ( thr)    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)

◆ 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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_HTYPE_BUFFER

#define DUK_HTYPE_BUFFER   3

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

Referenced by duk_bi_duktape_object_info().

◆ DUK_HTYPE_MAX

#define DUK_HTYPE_MAX   3

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

◆ DUK_HTYPE_MIN

#define DUK_HTYPE_MIN   1

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

◆ DUK_HTYPE_OBJECT

#define DUK_HTYPE_OBJECT   2

◆ DUK_HTYPE_STRING

#define DUK_HTYPE_STRING   1

◆ DUK_INTERNAL_H_INCLUDED

#define DUK_INTERNAL_H_INCLUDED

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

◆ DUK_ISPEC_NONE

#define DUK_ISPEC_NONE   0 /* no value */

Definition at line 3187 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_IVAL_NONE

#define DUK_IVAL_NONE   0 /* no value */

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

◆ DUK_IVAL_PLAIN

#define DUK_IVAL_PLAIN   1 /* register, constant, or value */

Definition at line 3181 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_IVAL_VAR

#define DUK_IVAL_VAR   5 /* variable access */

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

◆ DUK_JMPBUF_H_INCLUDED

#define DUK_JMPBUF_H_INCLUDED

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

◆ DUK_JS_BYTECODE_H_INCLUDED

#define DUK_JS_BYTECODE_H_INCLUDED

Definition at line 2522 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_JS_COMPILER_H_INCLUDED

#define DUK_JS_COMPILER_H_INCLUDED

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

◆ DUK_JS_CONST_MARKER

#define DUK_JS_CONST_MARKER   0x80000000UL

Definition at line 3192 of file duktape-1.5.2/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 8408 of file duktape-1.5.2/src/duktape.c.

DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv)
DUK_INTERNAL_DECL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv)

◆ 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 8420 of file duktape-1.5.2/src/duktape.c.

duk_small_int_t duk_bool_t
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_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags)

◆ 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 8428 of file duktape-1.5.2/src/duktape.c.

8429#define duk_js_samevalue(tv_x,tv_y) \
#define DUK_EQUALS_FLAG_STRICT
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_JS_H_INCLUDED

#define DUK_JS_H_INCLUDED

Definition at line 8370 of file duktape-1.5.2/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 8416 of file duktape-1.5.2/src/duktape.c.

8417#if 0 /* unused */
DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2)

◆ 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 8424 of file duktape-1.5.2/src/duktape.c.

8424
8425#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 8412 of file duktape-1.5.2/src/duktape.c.

8412DUK_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_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)

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 8410 of file duktape-1.5.2/src/duktape.c.

DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv)
DUK_INTERNAL_DECL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv)

◆ DUK_JSON_DEC_REQSTACK

#define DUK_JSON_DEC_REQSTACK   32

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

◆ DUK_JSON_ENC_LOOPARRAY

#define DUK_JSON_ENC_LOOPARRAY   64

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

◆ DUK_JSON_ENC_REQSTACK

#define DUK_JSON_ENC_REQSTACK   32

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

◆ DUK_JSON_FLAG_ASCII_ONLY

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

Definition at line 8304 of file duktape-1.5.2/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 8305 of file duktape-1.5.2/src/duktape.c.

◆ DUK_JSON_FLAG_EXT_COMPATIBLE

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

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

◆ DUK_JSON_FLAG_EXT_CUSTOM

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

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

◆ DUK_JSON_H_INCLUDED

#define DUK_JSON_H_INCLUDED

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

◆ DUK_LABEL_FLAG_ALLOW_BREAK

#define DUK_LABEL_FLAG_ALLOW_BREAK   (1 << 0)

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

◆ DUK_LABEL_FLAG_ALLOW_CONTINUE

#define DUK_LABEL_FLAG_ALLOW_CONTINUE   (1 << 1)

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

◆ DUK_LEXER_BUFFER_SIZE

#define DUK_LEXER_BUFFER_SIZE   64

Definition at line 2761 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_LEXER_INITCTX

#define DUK_LEXER_INITCTX ( ctx)    duk_lexer_initctx((ctx))

Definition at line 2751 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_LFUNC_LENGTH_MIN

#define DUK_LFUNC_LENGTH_MIN   0x00

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

◆ DUK_LFUNC_MAGIC_MAX

#define DUK_LFUNC_MAGIC_MAX   0x7f

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

◆ DUK_LFUNC_MAGIC_MIN

#define DUK_LFUNC_MAGIC_MIN   (-0x80)

Definition at line 862 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_LFUNC_NARGS_MIN

#define DUK_LFUNC_NARGS_MIN   0x00

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

◆ DUK_LFUNC_NARGS_VARARGS

#define DUK_LFUNC_NARGS_VARARGS   0x0f /* varargs marker */

Definition at line 857 of file duktape-1.5.2/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 6729 of file duktape-1.5.2/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 6730 of file duktape-1.5.2/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 6732 of file duktape-1.5.2/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 6728 of file duktape-1.5.2/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 6731 of file duktape-1.5.2/src/duktape.c.

◆ DUK_LJ_TYPE_THROW

#define DUK_LJ_TYPE_THROW   1 /* value1 -> error object */

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

◆ DUK_LJ_TYPE_UNKNOWN

#define DUK_LJ_TYPE_UNKNOWN   0 /* unused */

Definition at line 6725 of file duktape-1.5.2/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 6727 of file duktape-1.5.2/src/duktape.c.

◆ DUK_MS_FLAG_EMERGENCY

#define DUK_MS_FLAG_EMERGENCY   (1 << 0) /* emergency mode: try extra hard */

Definition at line 6742 of file duktape-1.5.2/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 6745 of file duktape-1.5.2/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 6744 of file duktape-1.5.2/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 6743 of file duktape-1.5.2/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 6746 of file duktape-1.5.2/src/duktape.c.

◆ DUK_N2S_FLAG_FIXED_FORMAT

#define DUK_N2S_FLAG_FIXED_FORMAT   (1 << 0)

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

◆ DUK_N2S_FLAG_FORCE_EXP

#define DUK_N2S_FLAG_FORCE_EXP   (1 << 1)

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

◆ DUK_N2S_FLAG_FRACTION_DIGITS

#define DUK_N2S_FLAG_FRACTION_DIGITS   (1 << 3)

Definition at line 8492 of file duktape-1.5.2/src/duktape.c.

◆ DUK_N2S_FLAG_NO_ZERO_PAD

#define DUK_N2S_FLAG_NO_ZERO_PAD   (1 << 2)

Definition at line 8486 of file duktape-1.5.2/src/duktape.c.

◆ DUK_NUM_ALL_BUILTINS

#define DUK_NUM_ALL_BUILTINS   71

Definition at line 1709 of file duktape-1.5.2/src/duktape.c.

◆ DUK_NUM_BIDX_BUILTINS

#define DUK_NUM_BIDX_BUILTINS   71

Definition at line 1708 of file duktape-1.5.2/src/duktape.c.

◆ DUK_NUM_BUILTINS

#define DUK_NUM_BUILTINS   71

Definition at line 1707 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_hthread_terminate().

◆ DUK_NUMCONV_H_INCLUDED

#define DUK_NUMCONV_H_INCLUDED

Definition at line 8466 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_ADD

#define DUK_OP_ADD   26

Definition at line 2620 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_BAND

#define DUK_OP_BAND   31

Definition at line 2625 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_BASL

#define DUK_OP_BASL   34

Definition at line 2628 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_BASR

#define DUK_OP_BASR   36

Definition at line 2630 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_BLSR

#define DUK_OP_BLSR   35

Definition at line 2629 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_BOR

#define DUK_OP_BOR   32

Definition at line 2626 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_BXOR

#define DUK_OP_BXOR   33

Definition at line 2627 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CALL

#define DUK_OP_CALL   48

Definition at line 2642 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CALLI

#define DUK_OP_CALLI   49

Definition at line 2643 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CLOSURE

#define DUK_OP_CLOSURE   20

◆ DUK_OP_CSPROP

#define DUK_OP_CSPROP   24

Definition at line 2618 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CSPROPI

#define DUK_OP_CSPROPI   25

Definition at line 2619 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CSREG

#define DUK_OP_CSREG   12

Definition at line 2606 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CSREGI

#define DUK_OP_CSREGI   13

Definition at line 2607 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CSVAR

#define DUK_OP_CSVAR   18

Definition at line 2612 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_CSVARI

#define DUK_OP_CSVARI   19

Definition at line 2613 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_DECLVAR

#define DUK_OP_DECLVAR   16

◆ DUK_OP_DELPROP

#define DUK_OP_DELPROP   23

Definition at line 2617 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_DELVAR

#define DUK_OP_DELVAR   17

Definition at line 2611 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_DIV

#define DUK_OP_DIV   29

Definition at line 2623 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_EQ

#define DUK_OP_EQ   37

Definition at line 2631 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_EXTRA

#define DUK_OP_EXTRA   51

Definition at line 2645 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_GE

#define DUK_OP_GE   42

Definition at line 2636 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_GETPROP

#define DUK_OP_GETPROP   21

Definition at line 2615 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_GETVAR

#define DUK_OP_GETVAR   14

Definition at line 2608 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_GT

#define DUK_OP_GT   41

Definition at line 2635 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_IF

#define DUK_OP_IF   45

Definition at line 2639 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__emit_invalid().

◆ DUK_OP_JUMP

#define DUK_OP_JUMP   46

Definition at line 2640 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_LDCONST

#define DUK_OP_LDCONST   2

Definition at line 2596 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_OP_LDREG

#define DUK_OP_LDREG   0

Definition at line 2594 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_OP_LT

#define DUK_OP_LT   43

Definition at line 2637 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_MOD

#define DUK_OP_MOD   30

Definition at line 2624 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_MPUTARR

#define DUK_OP_MPUTARR   7

Definition at line 2601 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_MPUTARRI

#define DUK_OP_MPUTARRI   8

Definition at line 2602 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_MPUTOBJ

#define DUK_OP_MPUTOBJ   5

Definition at line 2599 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_MPUTOBJI

#define DUK_OP_MPUTOBJI   6

Definition at line 2600 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_MUL

#define DUK_OP_MUL   28

Definition at line 2622 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_NEQ

#define DUK_OP_NEQ   38

Definition at line 2632 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_NEW

#define DUK_OP_NEW   9

Definition at line 2603 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_NEWI

#define DUK_OP_NEWI   10

Definition at line 2604 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_NONE

#define DUK_OP_NONE   64 /* dummy value used as marker */

Definition at line 2658 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_POSTDECP

#define DUK_OP_POSTDECP   63

Definition at line 2657 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_POSTDECR

#define DUK_OP_POSTDECR   55

Definition at line 2649 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_POSTDECV

#define DUK_OP_POSTDECV   59

Definition at line 2653 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_POSTINCP

#define DUK_OP_POSTINCP   62

Definition at line 2656 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_POSTINCR

#define DUK_OP_POSTINCR   54

Definition at line 2648 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_POSTINCV

#define DUK_OP_POSTINCV   58

Definition at line 2652 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_PREDECP

#define DUK_OP_PREDECP   61

Definition at line 2655 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_PREDECR

#define DUK_OP_PREDECR   53 /* see duk_js_executor.c */

Definition at line 2647 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_PREDECV

#define DUK_OP_PREDECV   57

Definition at line 2651 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_PREINCP

#define DUK_OP_PREINCP   60

Definition at line 2654 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_OP_PREINCV

#define DUK_OP_PREINCV   56

Definition at line 2650 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_PUTPROP

#define DUK_OP_PUTPROP   22

Definition at line 2616 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_PUTVAR

#define DUK_OP_PUTVAR   15

Definition at line 2609 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_OP_RETURN

#define DUK_OP_RETURN   47

Definition at line 2641 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_OP_SNEQ

#define DUK_OP_SNEQ   40

Definition at line 2634 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_STREG

#define DUK_OP_STREG   1

Definition at line 2595 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_SUB

#define DUK_OP_SUB   27

Definition at line 2621 of file duktape-1.5.2/src/duktape.c.

◆ DUK_OP_TRYCATCH

#define DUK_OP_TRYCATCH   50

Definition at line 2644 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PANIC

#define DUK_PANIC ( code,
msg )   duk_default_panic_handler((code),(msg))

Definition at line 7745 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PC2LINE_MAX_DIFF_LENGTH

#define DUK_PC2LINE_MAX_DIFF_LENGTH   (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8)

Definition at line 5314 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PC2LINE_SKIP

#define DUK_PC2LINE_SKIP   64

Definition at line 5311 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAG_ACCESSOR

#define DUK_PROPDESC_FLAG_ACCESSOR   (1 << 3) /* accessor */

◆ DUK_PROPDESC_FLAG_CONFIGURABLE

◆ DUK_PROPDESC_FLAG_ENUMERABLE

#define DUK_PROPDESC_FLAG_ENUMERABLE   (1 << 1) /* E5 Section 8.6.1 */

◆ DUK_PROPDESC_FLAG_NO_OVERWRITE

#define DUK_PROPDESC_FLAG_NO_OVERWRITE   (1 << 4) /* internal define property: skip write silently if exists */

Definition at line 4895 of file duktape-1.5.2/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 4886 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__get_own_propdesc_raw(), duk_hobject_define_property_helper(), and duk_hobject_putprop().

◆ DUK_PROPDESC_FLAG_WRITABLE

◆ DUK_PROPDESC_FLAGS_C

#define DUK_PROPDESC_FLAGS_C   (DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4901 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_E

#define DUK_PROPDESC_FLAGS_E   (DUK_PROPDESC_FLAG_ENUMERABLE)

Definition at line 4900 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_EC

#define DUK_PROPDESC_FLAGS_EC   (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4904 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_MASK

#define DUK_PROPDESC_FLAGS_MASK
Value:

Definition at line 4887 of file duktape-1.5.2/src/duktape.c.

4887 * (used by e.g. buffer virtual properties)
4888 */
#define DUK_PROPDESC_FLAGS_MASK

Referenced by duk_hobject_define_property_internal().

◆ DUK_PROPDESC_FLAGS_NONE

#define DUK_PROPDESC_FLAGS_NONE   0

◆ DUK_PROPDESC_FLAGS_W

#define DUK_PROPDESC_FLAGS_W   (DUK_PROPDESC_FLAG_WRITABLE)

Definition at line 4899 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_WC

#define DUK_PROPDESC_FLAGS_WC   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)

Definition at line 4903 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_WE

#define DUK_PROPDESC_FLAGS_WE   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE)

Definition at line 4902 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_FLAGS_WEC

#define DUK_PROPDESC_FLAGS_WEC
Value:

Definition at line 4905 of file duktape-1.5.2/src/duktape.c.

4905#define DUK_PROPDESC_FLAGS_WC (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
4906#define DUK_PROPDESC_FLAGS_EC (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
4907#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 5168 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_IS_CONFIGURABLE

#define DUK_PROPDESC_IS_CONFIGURABLE ( p)    (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)

Definition at line 5167 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_IS_ENUMERABLE

#define DUK_PROPDESC_IS_ENUMERABLE ( p)    (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)

Definition at line 5166 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PROPDESC_IS_WRITABLE

#define DUK_PROPDESC_IS_WRITABLE ( p)    (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0)

Definition at line 5165 of file duktape-1.5.2/src/duktape.c.

◆ duk_push_hcompiledfunction

#define duk_push_hcompiledfunction ( ctx,
h )    duk_push_hobject((ctx), (duk_hobject *) (h))

Definition at line 4345 of file duktape-1.5.2/src/duktape.c.

4345#define duk_push_hcompiledfunction(ctx,h) \
4346 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 4347 of file duktape-1.5.2/src/duktape.c.

4347#define duk_push_hnativefunction(ctx,h) \
4348 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 4343 of file duktape-1.5.2/src/duktape.c.

4343#define duk_push_hthread(ctx,h) \
4344 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 4282 of file duktape-1.5.2/src/duktape.c.

4282#define duk_push_i32(ctx,val) \
4283 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 4276 of file duktape-1.5.2/src/duktape.c.

4276#define duk_push_i64(ctx,val) \
4277 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 4286 of file duktape-1.5.2/src/duktape.c.

4286#define duk_push_idx(ctx,val) \
4287 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 4290 of file duktape-1.5.2/src/duktape.c.

4290#define duk_push_size_t(ctx,val) \
4291 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 4227 of file duktape-1.5.2/src/duktape.c.

◆ DUK_PUSH_SPRINTF_SANITY_LIMIT

#define DUK_PUSH_SPRINTF_SANITY_LIMIT   (1L * 1024L * 1024L * 1024L)

Definition at line 4228 of file duktape-1.5.2/src/duktape.c.

◆ duk_push_u32

#define duk_push_u32 ( ctx,
val )    duk_push_uint((ctx), (duk_uint_t) (val))

Definition at line 4280 of file duktape-1.5.2/src/duktape.c.

4280#define duk_push_u32(ctx,val) \
4281 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 4274 of file duktape-1.5.2/src/duktape.c.

4274#define duk_push_u64(ctx,val) \
4275 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 4288 of file duktape-1.5.2/src/duktape.c.

4288#define duk_push_uarridx(ctx,val) \
4289 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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

1809#define DUK_RAW_WRITE_CESU8(ptr,val) do { \
1810 /* 'ptr' is evaluated both as LHS and RHS. */ \
1811 duk_uint8_t *duk__ptr; \
1812 duk_small_int_t duk__len; \
1813 duk__ptr = (duk_uint8_t *) (ptr); \
1814 duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \
1815 duk__ptr += duk__len; \
1816 (ptr) = duk__ptr; \
1817 } 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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

1794#define DUK_RAW_WRITE_U8(ptr,val) do { \
1795 *(ptr)++ = (duk_uint8_t) (val); \
1796 } 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.5.2/src/duktape.c.

1800#define DUK_RAW_WRITE_XUTF8(ptr,val) do { \
1801 /* 'ptr' is evaluated both as LHS and RHS. */ \
1802 duk_uint8_t *duk__ptr; \
1803 duk_small_int_t duk__len; \
1804 duk__ptr = (duk_uint8_t *) (ptr); \
1805 duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \
1806 duk__ptr += duk__len; \
1807 (ptr) = duk__ptr; \
1808 } while (0)

◆ DUK_RE_COMPILE_TOKEN_LIMIT

#define DUK_RE_COMPILE_TOKEN_LIMIT   100000000L /* 1e8 */

Definition at line 3395 of file duktape-1.5.2/src/duktape.c.

◆ DUK_RE_EXECUTE_STEPS_LIMIT

#define DUK_RE_EXECUTE_STEPS_LIMIT   1000000000L /* 1e9 */

Definition at line 3398 of file duktape-1.5.2/src/duktape.c.

◆ DUK_RE_FLAG_GLOBAL

#define DUK_RE_FLAG_GLOBAL   (1 << 0)

Definition at line 3422 of file duktape-1.5.2/src/duktape.c.

◆ DUK_RE_FLAG_IGNORE_CASE

#define DUK_RE_FLAG_IGNORE_CASE   (1 << 1)

◆ DUK_RE_FLAG_MULTILINE

#define DUK_RE_FLAG_MULTILINE   (1 << 2)

Definition at line 3424 of file duktape-1.5.2/src/duktape.c.

◆ DUK_RE_MAX_ATOM_COPIES

#define DUK_RE_MAX_ATOM_COPIES   1000

Definition at line 3392 of file duktape-1.5.2/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.5.2/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 6888 of file duktape-1.5.2/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 6889 of file duktape-1.5.2/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 6849 of file duktape-1.5.2/src/duktape.c.

6849
6850/*

Referenced by duk_free().

◆ DUK_REGEXP_H_INCLUDED

#define DUK_REGEXP_H_INCLUDED

Definition at line 3389 of file duktape-1.5.2/src/duktape.c.

◆ DUK_REOP_ASSERT_END

#define DUK_REOP_ASSERT_END   17

Definition at line 3417 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_BACKREFERENCE

#define DUK_REOP_BACKREFERENCE   15

Definition at line 3415 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_CHAR

#define DUK_REOP_CHAR   2

Definition at line 3402 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_INVRANGES

#define DUK_REOP_INVRANGES   5

Definition at line 3405 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_JUMP

#define DUK_REOP_JUMP   6

Definition at line 3406 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_LOOKNEG

#define DUK_REOP_LOOKNEG   14

Definition at line 3414 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_LOOKPOS

#define DUK_REOP_LOOKPOS   13

Definition at line 3413 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_MATCH

#define DUK_REOP_MATCH   1

Definition at line 3401 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_PERIOD

#define DUK_REOP_PERIOD   3

Definition at line 3403 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_RANGES

#define DUK_REOP_RANGES   4

Definition at line 3404 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SAVE

#define DUK_REOP_SAVE   11

Definition at line 3411 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SPLIT1

#define DUK_REOP_SPLIT1   7

Definition at line 3407 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SPLIT2

#define DUK_REOP_SPLIT2   8

Definition at line 3408 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SQGREEDY

#define DUK_REOP_SQGREEDY   10

Definition at line 3410 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_SQMINIMAL

#define DUK_REOP_SQMINIMAL   9

Definition at line 3409 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_REOP_WIPERANGE

#define DUK_REOP_WIPERANGE   12

Definition at line 3412 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_RETOK_ASSERT_END

#define DUK_RETOK_ASSERT_END   4

Definition at line 3046 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_DISJUNCTION

#define DUK_RETOK_DISJUNCTION   1

Definition at line 3043 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_EOF

#define DUK_RETOK_EOF   0

Definition at line 3042 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__parse_disjunction().

◆ DUK_RETOK_QUANTIFIER

#define DUK_RETOK_QUANTIFIER   2

Definition at line 3044 of file duktape-1.5.2/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 8540 of file duktape-1.5.2/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 8545 of file duktape-1.5.2/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 8532 of file duktape-1.5.2/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_EMPTY_FRAC

#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC   (1 << 8)

Definition at line 8529 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_S2N_FLAG_ALLOW_EXP

#define DUK_S2N_FLAG_ALLOW_EXP   (1 << 1)

◆ DUK_S2N_FLAG_ALLOW_FRAC

#define DUK_S2N_FLAG_ALLOW_FRAC   (1 << 6)

Definition at line 8523 of file duktape-1.5.2/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 8511 of file duktape-1.5.2/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_INF

#define DUK_S2N_FLAG_ALLOW_INF   (1 << 5)

Definition at line 8520 of file duktape-1.5.2/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_LEADING_ZERO

#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO   (1 << 10)

Definition at line 8535 of file duktape-1.5.2/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_MINUS

#define DUK_S2N_FLAG_ALLOW_MINUS   (1 << 4)

Definition at line 8517 of file duktape-1.5.2/src/duktape.c.

◆ DUK_S2N_FLAG_ALLOW_NAKED_FRAC

#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC   (1 << 7)

Definition at line 8526 of file duktape-1.5.2/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 8514 of file duktape-1.5.2/src/duktape.c.

◆ DUK_S2N_FLAG_TRIM_WHITE

#define DUK_S2N_FLAG_TRIM_WHITE   (1 << 0)

Definition at line 8505 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__tonumber_string_raw().

◆ DUK_S2N_MAX_EXPONENT

#define DUK_S2N_MAX_EXPONENT   1000000000

Definition at line 8502 of file duktape-1.5.2/src/duktape.c.

◆ DUK_SELFTEST_H_INCLUDED

#define DUK_SELFTEST_H_INCLUDED

Definition at line 8631 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STEP_TYPE_INTO

#define DUK_STEP_TYPE_INTO   1

Definition at line 6921 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STEP_TYPE_NONE

#define DUK_STEP_TYPE_NONE   0

Definition at line 6920 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STEP_TYPE_OUT

#define DUK_STEP_TYPE_OUT   3

Definition at line 6923 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STEP_TYPE_OVER

#define DUK_STEP_TYPE_OVER   2

Definition at line 6922 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_ALLOC_FAILED

#define DUK_STR_ALLOC_FAILED   duk_str_alloc_failed

Definition at line 2331 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

Referenced by duk_push_heapptr().

◆ DUK_STR_BYTECODE_LIMIT

#define DUK_STR_BYTECODE_LIMIT   duk_str_bytecode_limit

Definition at line 2484 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_CALLSTACK_LIMIT

#define DUK_STR_CALLSTACK_LIMIT   duk_str_callstack_limit

Definition at line 2478 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_CATCHSTACK_LIMIT

#define DUK_STR_CATCHSTACK_LIMIT   duk_str_catchstack_limit

Definition at line 2479 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_CONST_LIMIT

#define DUK_STR_CONST_LIMIT   duk_str_const_limit

Definition at line 2487 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_CYCLIC_INPUT

#define DUK_STR_CYCLIC_INPUT   duk_str_cyclic_input

Definition at line 2369 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_DECODE_FAILED

#define DUK_STR_DECODE_FAILED   duk_str_decode_failed

Definition at line 2335 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_DUPLICATE_LABEL

#define DUK_STR_DUPLICATE_LABEL   duk_str_duplicate_label

Definition at line 2406 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_ENCODE_FAILED

#define DUK_STR_ENCODE_FAILED   duk_str_encode_failed

Definition at line 2334 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_EXPECTED_IDENTIFIER

#define DUK_STR_EXPECTED_IDENTIFIER   duk_str_expected_identifier

Definition at line 2414 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_FUNC_LIMIT

#define DUK_STR_FUNC_LIMIT   duk_str_func_limit

Definition at line 2488 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_INTERNAL_ERROR

#define DUK_STR_INTERNAL_ERROR   duk_str_internal_error

Definition at line 2287 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_ARG_NAME

#define DUK_STR_INVALID_ARG_NAME   duk_str_invalid_arg_name

◆ DUK_STR_INVALID_ARRAY_LENGTH

#define DUK_STR_INVALID_ARRAY_LENGTH   duk_str_invalid_array_length

Definition at line 2383 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_INVALID_BACKREFS

#define DUK_STR_INVALID_BACKREFS   duk_str_invalid_backrefs

Definition at line 2464 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_BASE

#define DUK_STR_INVALID_BASE   duk_str_invalid_base

Definition at line 2380 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_INVALID_CALL_ARGS

#define DUK_STR_INVALID_CALL_ARGS   duk_str_invalid_call_args

◆ DUK_STR_INVALID_CONTEXT

#define DUK_STR_INVALID_CONTEXT   duk_str_invalid_context

Definition at line 2307 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_COUNT

#define DUK_STR_INVALID_COUNT   duk_str_invalid_count

Definition at line 2288 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_DESCRIPTOR

#define DUK_STR_INVALID_DESCRIPTOR   duk_str_invalid_descriptor

◆ DUK_STR_INVALID_EXPRESSION

#define DUK_STR_INVALID_EXPRESSION   duk_str_invalid_expression

Definition at line 2412 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_FOR

#define DUK_STR_INVALID_FOR   duk_str_invalid_for

Definition at line 2416 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_INVALID_LABEL

#define DUK_STR_INVALID_LABEL   duk_str_invalid_label

Definition at line 2407 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_LVALUE

#define DUK_STR_INVALID_LVALUE   duk_str_invalid_lvalue

Definition at line 2413 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_INVALID_RETURN

#define DUK_STR_INVALID_RETURN   duk_str_invalid_return

Definition at line 2419 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_SWITCH

#define DUK_STR_INVALID_SWITCH   duk_str_invalid_switch

Definition at line 2417 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_INVALID_THROW

#define DUK_STR_INVALID_THROW   duk_str_invalid_throw

Definition at line 2421 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_JSONDEC_RECLIMIT

#define DUK_STR_JSONDEC_RECLIMIT   duk_str_jsondec_reclimit

Definition at line 2367 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_JSONENC_RECLIMIT

#define DUK_STR_JSONENC_RECLIMIT   duk_str_jsonenc_reclimit

Definition at line 2368 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NO_SOURCECODE

#define DUK_STR_NO_SOURCECODE   duk_str_no_sourcecode

Definition at line 2336 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_BOOLEAN

#define DUK_STR_NOT_BOOLEAN   duk_str_unexpected_type

Definition at line 2312 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_NOT_CALLABLE

#define DUK_STR_NOT_CALLABLE   duk_str_not_callable

Definition at line 2291 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_COMPILEDFUNCTION

#define DUK_STR_NOT_COMPILEDFUNCTION   duk_str_unexpected_type

Definition at line 2320 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_NOT_CONSTRUCTABLE

#define DUK_STR_NOT_CONSTRUCTABLE   duk_str_not_constructable

Definition at line 2290 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_EXTENSIBLE

#define DUK_STR_NOT_EXTENSIBLE   duk_str_not_extensible

Definition at line 2292 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_NOT_NULL

#define DUK_STR_NOT_NULL   duk_str_unexpected_type

Definition at line 2311 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_NUMBER

#define DUK_STR_NOT_NUMBER   duk_str_unexpected_type

Definition at line 2313 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_NOT_POINTER

#define DUK_STR_NOT_POINTER   duk_str_unexpected_type

Definition at line 2316 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_REGEXP

#define DUK_STR_NOT_REGEXP   duk_str_unexpected_type

Definition at line 2324 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_STRING

#define DUK_STR_NOT_STRING   duk_str_unexpected_type

Definition at line 2314 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_NOT_THREAD

#define DUK_STR_NOT_THREAD   duk_str_unexpected_type

Definition at line 2319 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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

◆ DUK_STR_PROXY_REJECTED

#define DUK_STR_PROXY_REJECTED   duk_str_proxy_rejected

Definition at line 2382 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_REG_LIMIT

#define DUK_STR_REG_LIMIT   duk_str_reg_limit

◆ 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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_SETTER_UNDEFINED

#define DUK_STR_SETTER_UNDEFINED   duk_str_setter_undefined

Definition at line 2386 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_TEMP_LIMIT

#define DUK_STR_TEMP_LIMIT   duk_str_temp_limit

Definition at line 2486 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STR_UNSUPPORTED

#define DUK_STR_UNSUPPORTED   duk_str_unsupported

Definition at line 2339 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_UNTERMINATED_STMT

#define DUK_STR_UNTERMINATED_STMT   duk_str_unterminated_stmt

Definition at line 2424 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STR_VALSTACK_LIMIT

#define DUK_STR_VALSTACK_LIMIT   duk_str_valstack_limit

Definition at line 2477 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRDATA_DATA_LENGTH

#define DUK_STRDATA_DATA_LENGTH   1049

Definition at line 1472 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRDATA_MAX_STRLEN

#define DUK_STRDATA_MAX_STRLEN   17

Definition at line 1471 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX___PROTO__

#define DUK_STRIDX___PROTO__   76 /* '__proto__' */

Definition at line 1114 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ARRAY

#define DUK_STRIDX_ARRAY   5 /* 'Array' */

Definition at line 901 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ARRAY_BUFFER

#define DUK_STRIDX_ARRAY_BUFFER   15 /* 'ArrayBuffer' */

Definition at line 931 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_BASE64

#define DUK_STRIDX_BASE64   124 /* 'base64' */

Definition at line 1258 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_BRACKETED_ELLIPSIS

#define DUK_STRIDX_BRACKETED_ELLIPSIS   65 /* '[...]' */

Definition at line 1081 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_BYTE_LENGTH

#define DUK_STRIDX_BYTE_LENGTH   86 /* 'byteLength' */

Definition at line 1144 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_BYTE_OFFSET

#define DUK_STRIDX_BYTE_OFFSET   87 /* 'byteOffset' */

Definition at line 1147 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_CALLEE

#define DUK_STRIDX_CALLEE   68 /* 'callee' */

Definition at line 1090 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CALLER

#define DUK_STRIDX_CALLER   69 /* 'caller' */

Definition at line 1093 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CASE

#define DUK_STRIDX_CASE   147 /* 'case' */

Definition at line 1327 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CATCH

#define DUK_STRIDX_CATCH   148 /* 'catch' */

Definition at line 1330 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CLASS

#define DUK_STRIDX_CLASS   173 /* 'class' */

Definition at line 1405 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CLOG

#define DUK_STRIDX_CLOG   138 /* 'clog' */

Definition at line 1300 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_COMMA

#define DUK_STRIDX_COMMA   62 /* ',' */

Definition at line 1072 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_COMPILE

#define DUK_STRIDX_COMPILE   116 /* 'compile' */

Definition at line 1234 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CONFIGURABLE

#define DUK_STRIDX_CONFIGURABLE   36 /* 'configurable' */

◆ DUK_STRIDX_CONST

#define DUK_STRIDX_CONST   169 /* 'const' */

Definition at line 1393 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CONSTRUCTOR

#define DUK_STRIDX_CONSTRUCTOR   51 /* 'constructor' */

Definition at line 1039 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_CONTINUE

#define DUK_STRIDX_CONTINUE   149 /* 'continue' */

Definition at line 1333 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DATA

#define DUK_STRIDX_DATA   84 /* 'data' */

Definition at line 1138 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DATA_VIEW

#define DUK_STRIDX_DATA_VIEW   16 /* 'DataView' */

Definition at line 934 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DATE

#define DUK_STRIDX_DATE   9 /* 'Date' */

Definition at line 913 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DEBUGGER

#define DUK_STRIDX_DEBUGGER   150 /* 'debugger' */

Definition at line 1336 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DEC_ENV

#define DUK_STRIDX_DEC_ENV   28 /* 'DecEnv' */

Definition at line 970 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DEFAULT

#define DUK_STRIDX_DEFAULT   151 /* 'default' */

Definition at line 1339 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DEFINE_PROPERTY

#define DUK_STRIDX_DEFINE_PROPERTY   33 /* 'defineProperty' */

Definition at line 985 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DELETE

#define DUK_STRIDX_DELETE   152 /* 'delete' */

Definition at line 1342 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DELETE_PROPERTY

#define DUK_STRIDX_DELETE_PROPERTY   72 /* 'deleteProperty' */

Definition at line 1102 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_DO

#define DUK_STRIDX_DO   153 /* 'do' */

Definition at line 1345 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ELSE

#define DUK_STRIDX_ELSE   154 /* 'else' */

Definition at line 1348 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_EMPTY_STRING

#define DUK_STRIDX_EMPTY_STRING   14 /* '' */

Definition at line 928 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_ENUMERABLE

#define DUK_STRIDX_ENUMERABLE   37 /* 'enumerable' */

◆ DUK_STRIDX_ENUMERATE

#define DUK_STRIDX_ENUMERATE   73 /* 'enumerate' */

Definition at line 1105 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ENV

#define DUK_STRIDX_ENV   122 /* 'env' */

Definition at line 1252 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ERR_CREATE

#define DUK_STRIDX_ERR_CREATE   118 /* 'errCreate' */

Definition at line 1240 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ERR_THROW

#define DUK_STRIDX_ERR_THROW   119 /* 'errThrow' */

Definition at line 1243 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_EXPORT

#define DUK_STRIDX_EXPORT   175 /* 'export' */

Definition at line 1411 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_EXPORTS

#define DUK_STRIDX_EXPORTS   79 /* 'exports' */

Definition at line 1123 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_EXTENDS

#define DUK_STRIDX_EXTENDS   176 /* 'extends' */

Definition at line 1414 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_FALSE

#define DUK_STRIDX_FALSE   181 /* 'false' */

Definition at line 1429 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_FILE_NAME

#define DUK_STRIDX_FILE_NAME   95 /* 'fileName' */

Definition at line 1171 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_FINALLY

#define DUK_STRIDX_FINALLY   155 /* 'finally' */

Definition at line 1351 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_FLOAT32_ARRAY

#define DUK_STRIDX_FLOAT32_ARRAY   24 /* 'Float32Array' */

Definition at line 958 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_FLOAT64_ARRAY

#define DUK_STRIDX_FLOAT64_ARRAY   25 /* 'Float64Array' */

Definition at line 961 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_FMT

#define DUK_STRIDX_FMT   128 /* 'fmt' */

Definition at line 1270 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_FOR

#define DUK_STRIDX_FOR   156 /* 'for' */

Definition at line 1354 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_GET

#define DUK_STRIDX_GET   71 /* 'get' */

◆ DUK_STRIDX_GLOBAL

#define DUK_STRIDX_GLOBAL   26 /* 'global' */

Definition at line 964 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_HAS

#define DUK_STRIDX_HAS   70 /* 'has' */

Definition at line 1096 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_HEX

#define DUK_STRIDX_HEX   123 /* 'hex' */

Definition at line 1255 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_ID

#define DUK_STRIDX_ID   78 /* 'id' */

Definition at line 1120 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_IF

#define DUK_STRIDX_IF   158 /* 'if' */

Definition at line 1360 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_IGNORE_CASE

#define DUK_STRIDX_IGNORE_CASE   45 /* 'ignoreCase' */

Definition at line 1021 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_IMPLEMENTS

#define DUK_STRIDX_IMPLEMENTS   182 /* 'implements' */

Definition at line 1432 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_IMPORT

#define DUK_STRIDX_IMPORT   177 /* 'import' */

Definition at line 1417 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_IN

#define DUK_STRIDX_IN   159 /* 'in' */

Definition at line 1363 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INDEX

#define DUK_STRIDX_INDEX   49 /* 'index' */

Definition at line 1033 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INFINITY

#define DUK_STRIDX_INFINITY   59 /* 'Infinity' */

Definition at line 1063 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INPUT

#define DUK_STRIDX_INPUT   117 /* 'input' */

Definition at line 1237 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INSTANCEOF

#define DUK_STRIDX_INSTANCEOF   160 /* 'instanceof' */

Definition at line 1366 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT16_ARRAY

#define DUK_STRIDX_INT16_ARRAY   20 /* 'Int16Array' */

Definition at line 946 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT32_ARRAY

#define DUK_STRIDX_INT32_ARRAY   22 /* 'Int32Array' */

Definition at line 952 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT8_ARRAY

#define DUK_STRIDX_INT8_ARRAY   17 /* 'Int8Array' */

Definition at line 937 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_ARGS

#define DUK_STRIDX_INT_ARGS   107 /* '\xffArgs' */

Definition at line 1207 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_BYTECODE

#define DUK_STRIDX_INT_BYTECODE   100 /* '\xffBytecode' */

Definition at line 1186 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_CALLEE

#define DUK_STRIDX_INT_CALLEE   111 /* '\xffCallee' */

Definition at line 1219 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_FINALIZER

#define DUK_STRIDX_INT_FINALIZER   109 /* '\xffFinalizer' */

Definition at line 1213 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_LEXENV

#define DUK_STRIDX_INT_LEXENV   103 /* '\xffLexenv' */

Definition at line 1195 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_MAP

#define DUK_STRIDX_INT_MAP   108 /* '\xffMap' */

Definition at line 1210 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_NEXT

#define DUK_STRIDX_INT_NEXT   99 /* '\xffNext' */

Definition at line 1183 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_PC2LINE

#define DUK_STRIDX_INT_PC2LINE   106 /* '\xffPc2line' */

Definition at line 1204 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_SOURCE

#define DUK_STRIDX_INT_SOURCE   105 /* '\xffSource' */

Definition at line 1201 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_THREAD

#define DUK_STRIDX_INT_THREAD   112 /* '\xffThread' */

Definition at line 1222 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_TRACEDATA

#define DUK_STRIDX_INT_TRACEDATA   93 /* '\xffTracedata' */

Definition at line 1165 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__error_getter_helper().

◆ DUK_STRIDX_INT_VALUE

#define DUK_STRIDX_INT_VALUE   98 /* '\xffValue' */

◆ DUK_STRIDX_INT_VARENV

#define DUK_STRIDX_INT_VARENV   104 /* '\xffVarenv' */

Definition at line 1198 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_INT_VARMAP

#define DUK_STRIDX_INT_VARMAP   102 /* '\xffVarmap' */

Definition at line 1192 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_INVALID_DATE

#define DUK_STRIDX_INVALID_DATE   66 /* 'Invalid Date' */

Definition at line 1084 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_JC

#define DUK_STRIDX_JC   126 /* 'jc' */

Definition at line 1264 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_JOIN

#define DUK_STRIDX_JOIN   38 /* 'join' */

Definition at line 1000 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_JSON

#define DUK_STRIDX_JSON   13 /* 'JSON' */

Definition at line 925 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_JX

#define DUK_STRIDX_JX   125 /* 'jx' */

Definition at line 1261 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LAST_INDEX

#define DUK_STRIDX_LAST_INDEX   47 /* 'lastIndex' */

Definition at line 1027 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_ARGUMENTS

#define DUK_STRIDX_LC_ARGUMENTS   67 /* 'arguments' */

◆ DUK_STRIDX_LC_BOOLEAN

#define DUK_STRIDX_LC_BOOLEAN   53 /* 'boolean' */

Definition at line 1045 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_BUFFER

#define DUK_STRIDX_LC_BUFFER   96 /* 'buffer' */

Definition at line 1174 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_ERROR

#define DUK_STRIDX_LC_ERROR   134 /* 'error' */

Definition at line 1288 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_FATAL

#define DUK_STRIDX_LC_FATAL   135 /* 'fatal' */

Definition at line 1291 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_FUNCTION

#define DUK_STRIDX_LC_FUNCTION   157 /* 'function' */

Definition at line 1357 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_INFO

#define DUK_STRIDX_LC_INFO   132 /* 'info' */

Definition at line 1282 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_L

#define DUK_STRIDX_LC_L   137 /* 'l' */

Definition at line 1297 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_N

#define DUK_STRIDX_LC_N   136 /* 'n' */

Definition at line 1294 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_NUMBER

#define DUK_STRIDX_LC_NUMBER   54 /* 'number' */

Definition at line 1048 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_OBJECT

#define DUK_STRIDX_LC_OBJECT   56 /* 'object' */

Definition at line 1054 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_POINTER

#define DUK_STRIDX_LC_POINTER   97 /* 'pointer' */

Definition at line 1177 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_STRING

#define DUK_STRIDX_LC_STRING   55 /* 'string' */

Definition at line 1051 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_TRACE

#define DUK_STRIDX_LC_TRACE   130 /* 'trace' */

Definition at line 1276 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_UNDEFINED

#define DUK_STRIDX_LC_UNDEFINED   57 /* 'undefined' */

Definition at line 1057 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LC_WARN

#define DUK_STRIDX_LC_WARN   133 /* 'warn' */

Definition at line 1285 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LENGTH

#define DUK_STRIDX_LENGTH   85 /* 'length' */

◆ DUK_STRIDX_LET

#define DUK_STRIDX_LET   184 /* 'let' */

Definition at line 1438 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_LINE_NUMBER

#define DUK_STRIDX_LINE_NUMBER   92 /* 'lineNumber' */

Definition at line 1162 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MATH

#define DUK_STRIDX_MATH   12 /* 'Math' */

Definition at line 922 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MESSAGE

#define DUK_STRIDX_MESSAGE   52 /* 'message' */

Definition at line 1042 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MINUS_INFINITY

#define DUK_STRIDX_MINUS_INFINITY   60 /* '-Infinity' */

Definition at line 1066 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MINUS_ZERO

#define DUK_STRIDX_MINUS_ZERO   61 /* '-0' */

Definition at line 1069 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MOD_LOADED

#define DUK_STRIDX_MOD_LOADED   121 /* 'modLoaded' */

Definition at line 1249 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MOD_SEARCH

#define DUK_STRIDX_MOD_SEARCH   120 /* 'modSearch' */

Definition at line 1246 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_MULTILINE

#define DUK_STRIDX_MULTILINE   46 /* 'multiline' */

Definition at line 1024 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_NAME

#define DUK_STRIDX_NAME   94 /* 'name' */

Definition at line 1168 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_NEW

#define DUK_STRIDX_NEW   161 /* 'new' */

Definition at line 1369 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_NEWLINE_4SPACE

#define DUK_STRIDX_NEWLINE_4SPACE   64 /* '\n ' */

Definition at line 1078 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_OWN_KEYS

#define DUK_STRIDX_OWN_KEYS   74 /* 'ownKeys' */

Definition at line 1108 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_PACKAGE

#define DUK_STRIDX_PACKAGE   185 /* 'package' */

Definition at line 1441 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_PC

#define DUK_STRIDX_PC   91 /* 'pc' */

Definition at line 1159 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_PRIVATE

#define DUK_STRIDX_PRIVATE   186 /* 'private' */

Definition at line 1444 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_PROTECTED

#define DUK_STRIDX_PROTECTED   187 /* 'protected' */

Definition at line 1447 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_PROTOTYPE

#define DUK_STRIDX_PROTOTYPE   50 /* 'prototype' */

Definition at line 1036 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_RAW

#define DUK_STRIDX_RAW   129 /* 'raw' */

Definition at line 1273 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_REG_EXP

#define DUK_STRIDX_REG_EXP   10 /* 'RegExp' */

Definition at line 916 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_REQUIRE

#define DUK_STRIDX_REQUIRE   77 /* 'require' */

Definition at line 1117 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_RESUME

#define DUK_STRIDX_RESUME   127 /* 'resume' */

Definition at line 1267 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_RETURN

#define DUK_STRIDX_RETURN   162 /* 'return' */

Definition at line 1372 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_SET

#define DUK_STRIDX_SET   89 /* 'set' */

◆ DUK_STRIDX_SET_PROTOTYPE_OF

#define DUK_STRIDX_SET_PROTOTYPE_OF   75 /* 'setPrototypeOf' */

Definition at line 1111 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_SOURCE

#define DUK_STRIDX_SOURCE   44 /* 'source' */

Definition at line 1018 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_SPACE

#define DUK_STRIDX_SPACE   63 /* ' ' */

Definition at line 1075 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_STACK

#define DUK_STRIDX_STACK   90 /* 'stack' */

Definition at line 1156 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_START_RESERVED

#define DUK_STRIDX_START_RESERVED   146

Definition at line 1461 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_SUPER

#define DUK_STRIDX_SUPER   178 /* 'super' */

Definition at line 1420 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_SWITCH

#define DUK_STRIDX_SWITCH   163 /* 'switch' */

Definition at line 1375 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_THIS

#define DUK_STRIDX_THIS   164 /* 'this' */

Definition at line 1378 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_THROW

#define DUK_STRIDX_THROW   165 /* 'throw' */

Definition at line 1381 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TO_GMT_STRING

#define DUK_STRIDX_TO_GMT_STRING   43 /* 'toGMTString' */

Definition at line 1015 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TO_ISO_STRING

#define DUK_STRIDX_TO_ISO_STRING   42 /* 'toISOString' */

Definition at line 1012 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TO_JSON

#define DUK_STRIDX_TO_JSON   82 /* 'toJSON' */

Definition at line 1132 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TO_LOCALE_STRING

#define DUK_STRIDX_TO_LOCALE_STRING   39 /* 'toLocaleString' */

Definition at line 1003 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TO_LOG_STRING

#define DUK_STRIDX_TO_LOG_STRING   139 /* 'toLogString' */

Definition at line 1303 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TO_STRING

#define DUK_STRIDX_TO_STRING   81 /* 'toString' */

◆ 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.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_TRUE

#define DUK_STRIDX_TRUE   180 /* 'true' */

Definition at line 1426 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TRY

#define DUK_STRIDX_TRY   166 /* 'try' */

Definition at line 1384 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TYPE

#define DUK_STRIDX_TYPE   83 /* 'type' */

Definition at line 1135 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_TYPEOF

#define DUK_STRIDX_TYPEOF   167 /* 'typeof' */

Definition at line 1387 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_ARGUMENTS

#define DUK_STRIDX_UC_ARGUMENTS   2 /* 'Arguments' */

Definition at line 892 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_BOOLEAN

#define DUK_STRIDX_UC_BOOLEAN   7 /* 'Boolean' */

Definition at line 907 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_BUFFER

#define DUK_STRIDX_UC_BUFFER   29 /* 'Buffer' */

Definition at line 973 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_ERROR

#define DUK_STRIDX_UC_ERROR   11 /* 'Error' */

Definition at line 919 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_FUNCTION

#define DUK_STRIDX_UC_FUNCTION   4 /* 'Function' */

Definition at line 898 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_NULL

#define DUK_STRIDX_UC_NULL   1 /* 'Null' */

Definition at line 889 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_NUMBER

#define DUK_STRIDX_UC_NUMBER   8 /* 'Number' */

Definition at line 910 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_OBJECT

#define DUK_STRIDX_UC_OBJECT   3 /* 'Object' */

Definition at line 895 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_POINTER

#define DUK_STRIDX_UC_POINTER   30 /* 'Pointer' */

Definition at line 976 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_STRING

#define DUK_STRIDX_UC_STRING   6 /* 'String' */

Definition at line 904 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_THREAD

#define DUK_STRIDX_UC_THREAD   31 /* 'Thread' */

Definition at line 979 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UC_UNDEFINED

#define DUK_STRIDX_UC_UNDEFINED   0 /* 'Undefined' */

Definition at line 886 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UINT16_ARRAY

#define DUK_STRIDX_UINT16_ARRAY   21 /* 'Uint16Array' */

Definition at line 949 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UINT32_ARRAY

#define DUK_STRIDX_UINT32_ARRAY   23 /* 'Uint32Array' */

Definition at line 955 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UINT8_ARRAY

#define DUK_STRIDX_UINT8_ARRAY   18 /* 'Uint8Array' */

Definition at line 940 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_UINT8_CLAMPED_ARRAY

#define DUK_STRIDX_UINT8_CLAMPED_ARRAY   19 /* 'Uint8ClampedArray' */

Definition at line 943 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_VALUE

#define DUK_STRIDX_VALUE   34 /* 'value' */

◆ DUK_STRIDX_VALUE_OF

#define DUK_STRIDX_VALUE_OF   40 /* 'valueOf' */

Definition at line 1006 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_STRIDX_VOID

#define DUK_STRIDX_VOID   170 /* 'void' */

Definition at line 1396 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_WHILE

#define DUK_STRIDX_WHILE   171 /* 'while' */

Definition at line 1399 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_WITH

#define DUK_STRIDX_WITH   172 /* 'with' */

Definition at line 1402 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRIDX_WRITABLE

#define DUK_STRIDX_WRITABLE   35 /* 'writable' */

◆ DUK_STRIDX_YIELD

#define DUK_STRIDX_YIELD   190 /* 'yield' */

Definition at line 1456 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_CHAIN_SIZE

#define DUK_STRTAB_CHAIN_SIZE   DUK_USE_STRTAB_CHAIN_SIZE

Definition at line 6822 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_DELETED_MARKER

#define DUK_STRTAB_DELETED_MARKER ( heap)    ((duk_hstring *) heap)

Definition at line 6807 of file duktape-1.5.2/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 6812 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_HASH_INITIAL

#define DUK_STRTAB_HASH_INITIAL ( hash,
h_size )   ((hash) % (h_size))

Definition at line 6818 of file duktape-1.5.2/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 6819 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_HIGHEST_32BIT_PRIME

#define DUK_STRTAB_HIGHEST_32BIT_PRIME   0xfffffffbUL

Definition at line 6815 of file duktape-1.5.2/src/duktape.c.

Referenced by duk__recheck_strtab_size_probe().

◆ DUK_STRTAB_INITIAL_SIZE

#define DUK_STRTAB_INITIAL_SIZE   17

Definition at line 6804 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_MIN_FREE_DIVISOR

#define DUK_STRTAB_MIN_FREE_DIVISOR   4 /* load factor max 75% */

Definition at line 6810 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_MIN_USED_DIVISOR

#define DUK_STRTAB_MIN_USED_DIVISOR   4 /* load factor min 25% */

Definition at line 6811 of file duktape-1.5.2/src/duktape.c.

◆ DUK_STRTAB_U32_MAX_STRLEN

#define DUK_STRTAB_U32_MAX_STRLEN   10 /* 4'294'967'295 */

Definition at line 6814 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_heap_string_intern_u32_checked().

◆ DUK_TAG_BOOLEAN

#define DUK_TAG_BOOLEAN   4

◆ DUK_TAG_BUFFER

#define DUK_TAG_BUFFER   10

◆ DUK_TAG_LIGHTFUNC

◆ DUK_TAG_NULL

◆ DUK_TAG_OBJECT

◆ DUK_TAG_POINTER

#define DUK_TAG_POINTER   5

◆ DUK_TAG_STRING

#define DUK_TAG_STRING   8 /* first heap allocated, match bit boundary */

◆ DUK_TAG_UNDEFINED

#define DUK_TAG_UNDEFINED   2

◆ DUK_TAG_UNUSED

#define DUK_TAG_UNUSED   7 /* marker; not actual tagged type */

Definition at line 652 of file duktape-1.5.2/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 6022 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_BXOR

#define DUK_TOK_BXOR   78

Definition at line 2867 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_CATCH

#define DUK_TOK_CATCH   4

Definition at line 2776 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_CLASS

#define DUK_TOK_CLASS   29

Definition at line 2803 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_COLON

#define DUK_TOK_COLON   84

Definition at line 2873 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_COMMA

#define DUK_TOK_COMMA   57

◆ DUK_TOK_CONST

#define DUK_TOK_CONST   25

Definition at line 2797 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_CONTINUE

#define DUK_TOK_CONTINUE   5

Definition at line 2777 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_DEBUGGER

#define DUK_TOK_DEBUGGER   6

Definition at line 2778 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_DECREMENT

#define DUK_TOK_DECREMENT   72

Definition at line 2861 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_DELETE

#define DUK_TOK_DELETE   8

Definition at line 2780 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_DIV

#define DUK_TOK_DIV   69

Definition at line 2858 of file duktape-1.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_ELSE

#define DUK_TOK_ELSE   10

Definition at line 2782 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_END_RESERVED

#define DUK_TOK_END_RESERVED   47 /* exclusive */

Definition at line 2829 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_ENUM

#define DUK_TOK_ENUM   30

Definition at line 2804 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_EOF

#define DUK_TOK_EOF   0

Definition at line 2767 of file duktape-1.5.2/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.5.2/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_EQUALSIGN

#define DUK_TOK_EQUALSIGN   85

◆ DUK_TOK_EXPORT

#define DUK_TOK_EXPORT   31

Definition at line 2805 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_EXTENDS

#define DUK_TOK_EXTENDS   32

Definition at line 2806 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_FALSE

#define DUK_TOK_FALSE   37

Definition at line 2815 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_FINALLY

#define DUK_TOK_FINALLY   11

Definition at line 2783 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_FOR

#define DUK_TOK_FOR   12

Definition at line 2784 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_FUNCTION

#define DUK_TOK_FUNCTION   13

Definition at line 2785 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_GE

#define DUK_TOK_GE   61

Definition at line 2850 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_GT

#define DUK_TOK_GT   59

Definition at line 2848 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_IDENTIFIER

#define DUK_TOK_IDENTIFIER   1

◆ DUK_TOK_IF

#define DUK_TOK_IF   14

Definition at line 2786 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_IMPLEMENTS

#define DUK_TOK_IMPLEMENTS   38

Definition at line 2819 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_IMPORT

#define DUK_TOK_IMPORT   33

Definition at line 2807 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_IN

#define DUK_TOK_IN   15

Definition at line 2787 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_INCREMENT

#define DUK_TOK_INCREMENT   71

Definition at line 2860 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_INTERFACE

#define DUK_TOK_INTERFACE   39

Definition at line 2820 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_LAND

#define DUK_TOK_LAND   81

Definition at line 2870 of file duktape-1.5.2/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.5.2/src/duktape.c.

Referenced by duk_lexer_parse_js_input_element().

◆ DUK_TOK_LCURLY

#define DUK_TOK_LCURLY   49

◆ DUK_TOK_LE

#define DUK_TOK_LE   60

Definition at line 2849 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_LNOT

#define DUK_TOK_LNOT   79

Definition at line 2868 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_MINVAL

#define DUK_TOK_MINVAL   0

Definition at line 2764 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_MOD

#define DUK_TOK_MOD   70

Definition at line 2859 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_NULL

#define DUK_TOK_NULL   35

Definition at line 2813 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_NUMBER

#define DUK_TOK_NUMBER   97

Definition at line 2890 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_PERIOD

#define DUK_TOK_PERIOD   55

Definition at line 2844 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_PROTECTED

#define DUK_TOK_PROTECTED   43

Definition at line 2824 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_PUBLIC

#define DUK_TOK_PUBLIC   44

Definition at line 2825 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_QUESTION

#define DUK_TOK_QUESTION   83

Definition at line 2872 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_RPAREN

#define DUK_TOK_RPAREN   54

◆ DUK_TOK_RSHIFT

#define DUK_TOK_RSHIFT   75

Definition at line 2864 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_SNEQ

#define DUK_TOK_SNEQ   65

Definition at line 2854 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_START_STRICT_RESERVED

#define DUK_TOK_START_STRICT_RESERVED   38 /* inclusive */

Definition at line 2818 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_STATIC

#define DUK_TOK_STATIC   45

Definition at line 2826 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_STRING

#define DUK_TOK_STRING   98

Definition at line 2891 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TOK_SWITCH

#define DUK_TOK_SWITCH   19

Definition at line 2791 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_THIS

#define DUK_TOK_THIS   20

Definition at line 2792 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_THROW

#define DUK_TOK_THROW   21

Definition at line 2793 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_TRUE

#define DUK_TOK_TRUE   36

Definition at line 2814 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_TRY

#define DUK_TOK_TRY   22

Definition at line 2794 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_TYPEOF

#define DUK_TOK_TYPEOF   23

Definition at line 2795 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_VAR

#define DUK_TOK_VAR   24

Definition at line 2796 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_VOID

#define DUK_TOK_VOID   26

Definition at line 2798 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_WHILE

#define DUK_TOK_WHILE   27

Definition at line 2799 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_WITH

#define DUK_TOK_WITH   28

Definition at line 2800 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TOK_YIELD

#define DUK_TOK_YIELD   46

Definition at line 2827 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TVAL_CHKFAST_INPLACE

#define DUK_TVAL_CHKFAST_INPLACE ( v)    do { } while (0)

Definition at line 726 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TVAL_DECREF

#define DUK_TVAL_DECREF ( thr,
tv )   DUK_TVAL_DECREF_FAST((thr),(tv))

Definition at line 3824 of file duktape-1.5.2/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); \
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)
#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)
#define DUK_TVAL_GET_HEAPHDR(tv)

Definition at line 3769 of file duktape-1.5.2/src/duktape.c.

3769#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
3770 duk_tval *duk__tv = (tv); \
3771 DUK_ASSERT(duk__tv != NULL); \
3772 if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
3773 duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
3774 DUK_ASSERT(duk__h != NULL); \
3775 DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
3776 DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
3777 if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
3778 duk_heaphdr_refzero((thr), duk__h); \
3779 } \
3780 } \
3781 } 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 3808 of file duktape-1.5.2/src/duktape.c.

3808#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \
3809 duk_tval_decref((thr), (tv)); \
3810 } while (0)

◆ DUK_TVAL_GET_BOOLEAN

#define DUK_TVAL_GET_BOOLEAN ( tv)    ((tv)->v.i)

◆ DUK_TVAL_GET_BUFFER

#define DUK_TVAL_GET_BUFFER ( tv)    ((tv)->v.hbuffer)

Definition at line 794 of file duktape-1.5.2/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.5.2/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)

◆ 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.5.2/src/duktape.c.

786#define DUK_TVAL_GET_LIGHTFUNC(tv,out_fp,out_flags) do { \
787 (out_flags) = (duk_uint32_t) (tv)->v_extra; \
788 (out_fp) = (tv)->v.lightfunc; \
789 } 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.5.2/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.5.2/src/duktape.c.

◆ DUK_TVAL_GET_NUMBER

#define DUK_TVAL_GET_NUMBER ( tv)    ((tv)->v.d)

◆ DUK_TVAL_GET_OBJECT

#define DUK_TVAL_GET_OBJECT ( tv)    ((tv)->v.hobject)

◆ DUK_TVAL_GET_POINTER

#define DUK_TVAL_GET_POINTER ( tv)    ((tv)->v.voidptr)

Definition at line 785 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_js_toboolean().

◆ DUK_TVAL_GET_STRING

#define DUK_TVAL_GET_STRING ( tv)    ((tv)->v.hstring)

◆ DUK_TVAL_GET_TAG

◆ DUK_TVAL_H_INCLUDED

#define DUK_TVAL_H_INCLUDED

Definition at line 378 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TVAL_INCREF

◆ DUK_TVAL_INCREF_FAST

#define DUK_TVAL_INCREF_FAST ( thr,
tv )
Value:
do { \
duk_tval *duk__tv = (tv); \
DUK_ASSERT(duk__tv != NULL); \
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 3759 of file duktape-1.5.2/src/duktape.c.

3759#define DUK_TVAL_INCREF_FAST(thr,tv) do { \
3760 duk_tval *duk__tv = (tv); \
3761 DUK_ASSERT(duk__tv != NULL); \
3762 if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
3763 duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
3764 DUK_ASSERT(duk__h != NULL); \
3765 DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
3766 DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
3767 } \
3768 } while (0)

◆ DUK_TVAL_INCREF_SLOW

#define DUK_TVAL_INCREF_SLOW ( thr,
tv )
Value:
do { \
duk_tval_incref((tv)); \
} while (0)

Definition at line 3805 of file duktape-1.5.2/src/duktape.c.

3805#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \
3806 duk_tval_incref((tv)); \
3807 } while (0)

◆ DUK_TVAL_IS_BOOLEAN

#define DUK_TVAL_IS_BOOLEAN ( tv)    ((tv)->t == DUK_TAG_BOOLEAN)

◆ 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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ DUK_TVAL_IS_DOUBLE

#define DUK_TVAL_IS_DOUBLE ( v)    DUK_TVAL_IS_NUMBER((v))

◆ DUK_TVAL_IS_HEAP_ALLOCATED

#define DUK_TVAL_IS_HEAP_ALLOCATED ( tv)    ((tv)->t & 0x08)

◆ DUK_TVAL_IS_LIGHTFUNC

#define DUK_TVAL_IS_LIGHTFUNC ( tv)    ((tv)->t == DUK_TAG_LIGHTFUNC)

◆ DUK_TVAL_IS_NULL

#define DUK_TVAL_IS_NULL ( tv)    ((tv)->t == DUK_TAG_NULL)

Definition at line 801 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TVAL_IS_NUMBER

#define DUK_TVAL_IS_NUMBER ( tv)    ((tv)->t == DUK__TAG_NUMBER)

◆ DUK_TVAL_IS_OBJECT

◆ DUK_TVAL_IS_POINTER

#define DUK_TVAL_IS_POINTER ( tv)    ((tv)->t == DUK_TAG_POINTER)

Definition at line 814 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_TVAL_IS_UNDEFINED

#define DUK_TVAL_IS_UNDEFINED ( tv)    ((tv)->t == DUK_TAG_UNDEFINED)

◆ DUK_TVAL_IS_UNUSED

◆ DUK_TVAL_NEEDS_REFCOUNT_UPDATE

#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE ( tv)    DUK_TVAL_IS_HEAP_ALLOCATED((tv))

Definition at line 3750 of file duktape-1.5.2/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)
#define DUK_TAG_BOOLEAN

Definition at line 676 of file duktape-1.5.2/src/duktape.c.

676#define DUK_TVAL_SET_BOOLEAN(tv,val) do { \
677 (tv)->t = DUK_TAG_BOOLEAN; \
678 (tv)->v.i = (val); \
679 } 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.5.2/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.5.2/src/duktape.c.

◆ DUK_TVAL_SET_BOOLEAN_UPDREF

#define DUK_TVAL_SET_BOOLEAN_UPDREF   DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0

Definition at line 4022 of file duktape-1.5.2/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 3891 of file duktape-1.5.2/src/duktape.c.

3891#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3892 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3893 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3894 DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
3895 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3896 } 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)
#define DUK_TAG_BUFFER

Definition at line 750 of file duktape-1.5.2/src/duktape.c.

750#define DUK_TVAL_SET_BUFFER(tv,hptr) do { \
751 (tv)->t = DUK_TAG_BUFFER; \
752 (tv)->v.hbuffer = (hptr); \
753 } while (0)

◆ DUK_TVAL_SET_BUFFER_UPDREF

#define DUK_TVAL_SET_BUFFER_UPDREF   DUK_TVAL_SET_BUFFER_UPDREF_ALT0

Definition at line 4039 of file duktape-1.5.2/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 3969 of file duktape-1.5.2/src/duktape.c.

3969#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3970 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3971 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3972 DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
3973 DUK_HBUFFER_INCREF((thr), (newval)); \
3974 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3975 } 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.5.2/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 3942 of file duktape-1.5.2/src/duktape.c.

3942#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
3943 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 4025 of file duktape-1.5.2/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 3910 of file duktape-1.5.2/src/duktape.c.

3910#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3911 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3912 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3913 DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
3914 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3915 } 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.5.2/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.5.2/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 4033 of file duktape-1.5.2/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.5.2/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 4034 of file duktape-1.5.2/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 4032 of file duktape-1.5.2/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)
duk_ret_t(* duk_c_function)(duk_context *ctx)
#define DUK_TAG_LIGHTFUNC

Definition at line 734 of file duktape-1.5.2/src/duktape.c.

734#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags) do { \
735 (tv)->t = DUK_TAG_LIGHTFUNC; \
736 (tv)->v_extra = (flags); \
737 (tv)->v.lightfunc = (duk_c_function) (fp); \
738 } while (0)

◆ DUK_TVAL_SET_LIGHTFUNC_UPDREF

#define DUK_TVAL_SET_LIGHTFUNC_UPDREF   DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0

Definition at line 4036 of file duktape-1.5.2/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 3946 of file duktape-1.5.2/src/duktape.c.

3946#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
3947 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3948 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3949 DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
3950 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3951 } 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)
#define DUK__TAG_NUMBER

Definition at line 755 of file duktape-1.5.2/src/duktape.c.

755#define DUK_TVAL_SET_NAN(tv) do { \
756 /* in non-packed representation we don't care about which NaN is used */ \
757 (tv)->t = DUK__TAG_NUMBER; \
758 (tv)->v.d = DUK_DOUBLE_NAN; \
759 } while (0)

◆ DUK_TVAL_SET_NAN_UPDREF

#define DUK_TVAL_SET_NAN_UPDREF   DUK_TVAL_SET_NAN_UPDREF_ALT0

Definition at line 4026 of file duktape-1.5.2/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 3916 of file duktape-1.5.2/src/duktape.c.

3916#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
3917 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3918 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3919 DUK_TVAL_SET_NAN(tv__dst); \
3920 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3921 } while (0)

◆ DUK_TVAL_SET_NULL

#define DUK_TVAL_SET_NULL ( tv)
Value:
do { \
(tv)->t = DUK_TAG_NULL; \
} while (0)
#define DUK_TAG_NULL

Definition at line 672 of file duktape-1.5.2/src/duktape.c.

672#define DUK_TVAL_SET_NULL(tv) do { \
673 (tv)->t = DUK_TAG_NULL; \
674 } while (0)

◆ DUK_TVAL_SET_NULL_UPDREF

#define DUK_TVAL_SET_NULL_UPDREF   DUK_TVAL_SET_NULL_UPDREF_ALT0

Definition at line 4021 of file duktape-1.5.2/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 3884 of file duktape-1.5.2/src/duktape.c.

3884#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
3885 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3886 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3887 DUK_TVAL_SET_NULL(tv__dst); \
3888 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3889 } 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.5.2/src/duktape.c.

720#define DUK_TVAL_SET_NUMBER(tv,val) do { \
721 (tv)->t = DUK__TAG_NUMBER; \
722 (tv)->v.d = (val); \
723 } 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.5.2/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 4024 of file duktape-1.5.2/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 3904 of file duktape-1.5.2/src/duktape.c.

3904#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3905 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3906 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3907 DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
3908 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3909 } while (0)

◆ DUK_TVAL_SET_NUMBER_UPDREF

#define DUK_TVAL_SET_NUMBER_UPDREF   DUK_TVAL_SET_NUMBER_UPDREF_ALT0

Definition at line 4023 of file duktape-1.5.2/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 3898 of file duktape-1.5.2/src/duktape.c.

3898#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3899 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3900 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3901 DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
3902 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3903 } 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)
#define DUK_TAG_OBJECT

Definition at line 745 of file duktape-1.5.2/src/duktape.c.

745#define DUK_TVAL_SET_OBJECT(tv,hptr) do { \
746 (tv)->t = DUK_TAG_OBJECT; \
747 (tv)->v.hobject = (hptr); \
748 } 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 4038 of file duktape-1.5.2/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 3961 of file duktape-1.5.2/src/duktape.c.

3961#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3962 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3963 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3964 DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
3965 DUK_HOBJECT_INCREF((thr), (newval)); \
3966 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3967 } 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)
#define DUK_TAG_POINTER

Definition at line 729 of file duktape-1.5.2/src/duktape.c.

729#define DUK_TVAL_SET_POINTER(tv,hptr) do { \
730 (tv)->t = DUK_TAG_POINTER; \
731 (tv)->v.voidptr = (hptr); \
732 } while (0)

◆ DUK_TVAL_SET_POINTER_UPDREF

#define DUK_TVAL_SET_POINTER_UPDREF   DUK_TVAL_SET_POINTER_UPDREF_ALT0

Definition at line 4040 of file duktape-1.5.2/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 3977 of file duktape-1.5.2/src/duktape.c.

3977#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3978 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3979 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3980 DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
3981 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3982 } 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)
#define DUK_TAG_STRING

Definition at line 740 of file duktape-1.5.2/src/duktape.c.

740#define DUK_TVAL_SET_STRING(tv,hptr) do { \
741 (tv)->t = DUK_TAG_STRING; \
742 (tv)->v.hstring = (hptr); \
743 } 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 4037 of file duktape-1.5.2/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 3953 of file duktape-1.5.2/src/duktape.c.

3953#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
3954 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3955 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3956 DUK_TVAL_SET_STRING(tv__dst, (newval)); \
3957 DUK_HSTRING_INCREF((thr), (newval)); \
3958 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3959 } while (0)

◆ DUK_TVAL_SET_TVAL

#define DUK_TVAL_SET_TVAL ( v,
x )   do { *(v) = *(x); } while (0)

◆ DUK_TVAL_SET_TVAL_UPDREF

◆ 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 3992 of file duktape-1.5.2/src/duktape.c.

3992#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
3993 duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \
3994 tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
3995 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3996 DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
3997 DUK_TVAL_INCREF((thr), tv__src); \
3998 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3999 } 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); \
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 4004 of file duktape-1.5.2/src/duktape.c.

4004#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr,tvptr_dst,tvptr_src) do { \
4005 duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \
4006 tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
4007 DUK_TVAL_INCREF_FAST((thr), tv__src); \
4008 if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv__dst)) { \
4009 h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \
4010 DUK_ASSERT(h__obj != NULL); \
4011 DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
4012 DUK_HEAPHDR_DECREF_FAST((thr), h__obj); /* side effects */ \
4013 } else { \
4014 DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
4015 } \
4016 } while (0)

◆ DUK_TVAL_SET_TVAL_UPDREF_FAST

#define DUK_TVAL_SET_TVAL_UPDREF_FAST   DUK_TVAL_SET_TVAL_UPDREF_ALT1

Definition at line 4045 of file duktape-1.5.2/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 4046 of file duktape-1.5.2/src/duktape.c.

◆ DUK_TVAL_SET_UNDEFINED

#define DUK_TVAL_SET_UNDEFINED ( tv)
Value:
do { \
(tv)->t = DUK_TAG_UNDEFINED; \
} while (0)
#define DUK_TAG_UNDEFINED

Definition at line 664 of file duktape-1.5.2/src/duktape.c.

664#define DUK_TVAL_SET_UNDEFINED(tv) do { \
665 (tv)->t = DUK_TAG_UNDEFINED; \
666 } 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 4019 of file duktape-1.5.2/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 3870 of file duktape-1.5.2/src/duktape.c.

3870#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
3871 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3872 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3873 DUK_TVAL_SET_UNDEFINED(tv__dst); \
3874 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3875 } while (0)

◆ DUK_TVAL_SET_UNUSED

#define DUK_TVAL_SET_UNUSED ( tv)
Value:
do { \
(tv)->t = DUK_TAG_UNUSED; \
} while (0)
#define DUK_TAG_UNUSED

Definition at line 668 of file duktape-1.5.2/src/duktape.c.

668#define DUK_TVAL_SET_UNUSED(tv) do { \
669 (tv)->t = DUK_TAG_UNUSED; \
670 } 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 4020 of file duktape-1.5.2/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 3877 of file duktape-1.5.2/src/duktape.c.

3877#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
3878 duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
3879 DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
3880 DUK_TVAL_SET_UNUSED(tv__dst); \
3881 DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
3882 } 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 8053 of file duktape-1.5.2/src/duktape.c.

◆ DUK_UNICODE_CP_ZWJ

#define DUK_UNICODE_CP_ZWJ   0x200dL /* zero-width joiner */

Definition at line 8052 of file duktape-1.5.2/src/duktape.c.

◆ DUK_UNICODE_CP_ZWNJ

#define DUK_UNICODE_CP_ZWNJ   0x200cL /* zero-width non-joiner */

Definition at line 8051 of file duktape-1.5.2/src/duktape.c.

◆ DUK_UNICODE_H_INCLUDED

#define DUK_UNICODE_H_INCLUDED

Definition at line 8033 of file duktape-1.5.2/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 8042 of file duktape-1.5.2/src/duktape.c.

◆ DUK_UNICODE_MAX_CESU8_LENGTH

#define DUK_UNICODE_MAX_CESU8_LENGTH   6 /* all codepoints up to U+10FFFF */

Definition at line 8041 of file duktape-1.5.2/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 8040 of file duktape-1.5.2/src/duktape.c.

◆ DUK_UNICODE_MAX_XUTF8_LENGTH

#define DUK_UNICODE_MAX_XUTF8_LENGTH   7 /* up to 36 bit codepoints */

Definition at line 8039 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_UTIL_H_INCLUDED

#define DUK_UTIL_H_INCLUDED

Definition at line 1738 of file duktape-1.5.2/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.5.2/src/duktape.c.

◆ DUK_VALSTACK_API_ENTRY_MINIMUM

#define DUK_VALSTACK_API_ENTRY_MINIMUM   DUK_API_ENTRY_STACK

Definition at line 5981 of file duktape-1.5.2/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 7831 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VALSTACK_DEFAULT_MAX

#define DUK_VALSTACK_DEFAULT_MAX   1000000L

Definition at line 5991 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VALSTACK_GROW_STEP

#define DUK_VALSTACK_GROW_STEP   128 /* roughly 1 kiB */

Definition at line 5976 of file duktape-1.5.2/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 5979 of file duktape-1.5.2/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 5980 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VALSTACK_SHRINK_SPARE

#define DUK_VALSTACK_SHRINK_SPARE   64 /* roughly 0.5 kiB */

Definition at line 5978 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VALSTACK_SHRINK_THRESHOLD

#define DUK_VALSTACK_SHRINK_THRESHOLD   256 /* roughly 2 kiB */

Definition at line 5977 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VSRESIZE_FLAG_COMPACT

#define DUK_VSRESIZE_FLAG_COMPACT   (1 << 1)

Definition at line 4237 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VSRESIZE_FLAG_SHRINK

#define DUK_VSRESIZE_FLAG_SHRINK   (1 << 0)

Definition at line 4236 of file duktape-1.5.2/src/duktape.c.

◆ DUK_VSRESIZE_FLAG_THROW

#define DUK_VSRESIZE_FLAG_THROW   (1 << 2)

Definition at line 4238 of file duktape-1.5.2/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 4385 of file duktape-1.5.2/src/duktape.c.

4385#define duk_xdef_prop_index_wec(ctx,obj_index,arr_index) \
4386 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 4387 of file duktape-1.5.2/src/duktape.c.

4387#define duk_xdef_prop_stridx_wec(ctx,obj_index,stridx) \
4388 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 4383 of file duktape-1.5.2/src/duktape.c.

4383#define duk_xdef_prop_wec(ctx,obj_index) \
4384 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 13573 of file duktape-1.5.2/src/duktape.c.

◆ duk__one_arg_func

typedef double(* duk__one_arg_func) (double)

Definition at line 32347 of file duktape-1.5.2/src/duktape.c.

◆ duk__toint_coercer

typedef duk_double_t(* duk__toint_coercer) (duk_hthread *thr, duk_tval *tv)

Definition at line 16843 of file duktape-1.5.2/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 27693 of file duktape-1.5.2/src/duktape.c.

◆ duk__two_arg_func

typedef double(* duk__two_arg_func) (double, double)

Definition at line 32348 of file duktape-1.5.2/src/duktape.c.

◆ duk_activation

typedef struct duk_activation duk_activation

Definition at line 328 of file duktape-1.5.2/src/duktape.c.

◆ duk_bitdecoder_ctx

typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx

Definition at line 338 of file duktape-1.5.2/src/duktape.c.

◆ duk_bitencoder_ctx

typedef struct duk_bitencoder_ctx duk_bitencoder_ctx

Definition at line 339 of file duktape-1.5.2/src/duktape.c.

◆ duk_breakpoint

typedef struct duk_breakpoint duk_breakpoint

Definition at line 326 of file duktape-1.5.2/src/duktape.c.

◆ duk_bufwriter_ctx

typedef struct duk_bufwriter_ctx duk_bufwriter_ctx

Definition at line 340 of file duktape-1.5.2/src/duktape.c.

◆ duk_catcher

typedef struct duk_catcher duk_catcher

Definition at line 329 of file duktape-1.5.2/src/duktape.c.

◆ duk_compiler_ctx

typedef struct duk_compiler_ctx duk_compiler_ctx

Definition at line 350 of file duktape-1.5.2/src/duktape.c.

◆ duk_compiler_func

typedef struct duk_compiler_func duk_compiler_func

Definition at line 349 of file duktape-1.5.2/src/duktape.c.

◆ duk_compiler_instr

typedef struct duk_compiler_instr duk_compiler_instr

Definition at line 348 of file duktape-1.5.2/src/duktape.c.

◆ duk_hbuffer

typedef struct duk_hbuffer duk_hbuffer

Definition at line 316 of file duktape-1.5.2/src/duktape.c.

◆ duk_hbuffer_dynamic

typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic

Definition at line 318 of file duktape-1.5.2/src/duktape.c.

◆ duk_hbuffer_external

typedef struct duk_hbuffer_external duk_hbuffer_external

Definition at line 319 of file duktape-1.5.2/src/duktape.c.

◆ duk_hbuffer_fixed

typedef struct duk_hbuffer_fixed duk_hbuffer_fixed

Definition at line 317 of file duktape-1.5.2/src/duktape.c.

◆ duk_hbufferobject

typedef struct duk_hbufferobject duk_hbufferobject

Definition at line 314 of file duktape-1.5.2/src/duktape.c.

◆ duk_hcompiledfunction

typedef struct duk_hcompiledfunction duk_hcompiledfunction

Definition at line 312 of file duktape-1.5.2/src/duktape.c.

◆ duk_heap

typedef struct duk_heap duk_heap

Definition at line 325 of file duktape-1.5.2/src/duktape.c.

◆ duk_heaphdr

typedef struct duk_heaphdr duk_heaphdr

Definition at line 307 of file duktape-1.5.2/src/duktape.c.

◆ duk_heaphdr_string

typedef struct duk_heaphdr_string duk_heaphdr_string

Definition at line 308 of file duktape-1.5.2/src/duktape.c.

◆ duk_hnativefunction

typedef struct duk_hnativefunction duk_hnativefunction

Definition at line 313 of file duktape-1.5.2/src/duktape.c.

◆ duk_hobject

typedef struct duk_hobject duk_hobject

Definition at line 311 of file duktape-1.5.2/src/duktape.c.

◆ duk_hstring

typedef struct duk_hstring duk_hstring

Definition at line 309 of file duktape-1.5.2/src/duktape.c.

◆ duk_hstring_external

typedef struct duk_hstring_external duk_hstring_external

Definition at line 310 of file duktape-1.5.2/src/duktape.c.

◆ duk_hthread

typedef struct duk_hthread duk_hthread

Definition at line 315 of file duktape-1.5.2/src/duktape.c.

◆ duk_instr_t

typedef duk_uint32_t duk_instr_t

Definition at line 2548 of file duktape-1.5.2/src/duktape.c.

◆ duk_jmpbuf

typedef struct duk_jmpbuf duk_jmpbuf

Definition at line 303 of file duktape-1.5.2/src/duktape.c.

◆ duk_lexer_codepoint

typedef struct duk_lexer_codepoint duk_lexer_codepoint

Definition at line 346 of file duktape-1.5.2/src/duktape.c.

◆ duk_lexer_ctx

typedef struct duk_lexer_ctx duk_lexer_ctx

Definition at line 345 of file duktape-1.5.2/src/duktape.c.

◆ duk_lexer_point

typedef struct duk_lexer_point duk_lexer_point

Definition at line 344 of file duktape-1.5.2/src/duktape.c.

◆ duk_ljstate

typedef struct duk_ljstate duk_ljstate

Definition at line 331 of file duktape-1.5.2/src/duktape.c.

◆ duk_mem_getptr

typedef void *(* duk_mem_getptr) (duk_heap *heap, void *ud)

Definition at line 6884 of file duktape-1.5.2/src/duktape.c.

◆ duk_propaccessor

typedef struct duk_propaccessor duk_propaccessor

Definition at line 321 of file duktape-1.5.2/src/duktape.c.

◆ duk_propdesc

typedef struct duk_propdesc duk_propdesc

Definition at line 323 of file duktape-1.5.2/src/duktape.c.

◆ duk_propvalue

typedef union duk_propvalue duk_propvalue

Definition at line 322 of file duktape-1.5.2/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.5.2/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.5.2/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.5.2/src/duktape.c.

◆ duk_re_token

typedef struct duk_re_token duk_re_token

Definition at line 343 of file duktape-1.5.2/src/duktape.c.

◆ duk_reg_t

typedef duk_int32_t duk_reg_t

Definition at line 3198 of file duktape-1.5.2/src/duktape.c.

◆ duk_regconst_t

typedef duk_uint32_t duk_regconst_t

Definition at line 3195 of file duktape-1.5.2/src/duktape.c.

◆ duk_strcache

typedef struct duk_strcache duk_strcache

Definition at line 330 of file duktape-1.5.2/src/duktape.c.

◆ duk_strtab_entry

typedef struct duk_strtab_entry duk_strtab_entry

Definition at line 332 of file duktape-1.5.2/src/duktape.c.

◆ duk_token

typedef struct duk_token duk_token

Definition at line 342 of file duktape-1.5.2/src/duktape.c.

◆ duk_tval

typedef struct duk_tval_struct duk_tval

Definition at line 620 of file duktape-1.5.2/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 48169 of file duktape-1.5.2/src/duktape.c.

48186 {
48187 duk_uint32_t new_e_size;
48188 duk_uint32_t new_a_size;
48189 duk_uint32_t new_h_size;
48190 duk_uint32_t e_used; /* actually used, non-NULL keys */
48191 duk_uint32_t a_used;
48192 duk_uint32_t a_size;
48193
48194 DUK_ASSERT(thr != NULL);
48195 DUK_ASSERT(obj != NULL);
48196
48197 e_used = duk__count_used_e_keys(thr, obj);
48198 duk__compute_a_stats(thr, obj, &a_used, &a_size);
48199
48200 /*
48201 * Must guarantee all actually used array entries will fit into
48202 * new entry part. Add one growth step to ensure we don't run out
48203 * of space right away.
48204 */
48205
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)

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 47438 of file duktape-1.5.2/src/duktape.c.

47439 {
47440 used++;
47441 highest_idx = i;
47442 }
47443 }
47444
47445 /* Initial value for highest_idx is -1 coerced to unsigned. This
47446 * is a bit odd, but (highest_idx + 1) will then wrap to 0 below
47447 * for out_min_size as intended.
47448 */
47449
47450 *out_used = used;
47451 *out_min_size = highest_idx + 1; /* 0 if no used entries */
47452}
47453
47454/* Check array density and indicate whether or not the array part should be abandoned. */
47455DUK_LOCAL duk_bool_t duk__abandon_array_density_check(duk_uint32_t a_used, duk_uint32_t a_size) {
47456 /*
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 47459 of file duktape-1.5.2/src/duktape.c.

47462 :8
47463 * new_used < limit' * (new_size / 8)
47464 *
47465 * Here, new_used = a_used, new_size = a_size.
47466 *
47467 * Note: some callers use approximate values for a_used and/or a_size
47468 * (e.g. dropping a '+1' term). This doesn't affect the usefulness
47469 * of the check, but may confuse debugging.
47470 */
47471
47472 return (a_used < DUK_HOBJECT_A_ABANDON_LIMIT * (a_size >> 3));
47473}
47474
47475/* Fast check for extending array: check whether or not a slow density check is required. */
47476DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required(duk_uint32_t arr_idx, duk_uint32_t old_size) {
47477 /*
47478 * In a fast check we assume old_size equals old_used (i.e., existing
47479 * array is fully dense).
47480 *
47481 * Slow check if:
47482 *

Referenced by duk_hobject_putprop().

◆ duk__acos()

DUK_LOCAL double duk__acos ( double x)

Definition at line 32531 of file duktape-1.5.2/src/duktape.c.

◆ duk__add_compiler_error_line()

DUK_LOCAL void duk__add_compiler_error_line ( duk_hthread * thr)

Definition at line 40032 of file duktape-1.5.2/src/duktape.c.

40035 :
40036 /* [ ... error lineNumber fileName ] */
40037#if defined(DUK_USE_ASSERTIONS)
40038 DUK_ASSERT(duk_get_top(ctx) == entry_top + 2);
40039#endif
40042}
40043#endif /* !DUK_USE_TRACEBACKS */
40044
40045/*
40046 * Add line number to a compiler error.
40047 */
40048
40050 duk_context *ctx;
40051
40052 /* Append a "(line NNN)" to the "message" property of any error
40053 * thrown during compilation. Usually compilation errors are
40054 * SyntaxErrors but they can also be out-of-memory errors and
40055 * the like.
40056 */
40057
40058 /* [ ... error ] */
40059
40060 ctx = (duk_context *) thr;
40061 DUK_ASSERT(duk_is_object(ctx, -1));
40062
40063 if (!(thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL)) {
#define DUK_STRIDX_LINE_NUMBER
#define DUK_STRIDX_FILE_NAME
#define DUK_PROPDESC_FLAG_NO_OVERWRITE
DUK_EXTERNAL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_idx_t duk_get_top(duk_context *ctx)
#define DUK_PROPDESC_FLAGS_WC
DUK_LOCAL void duk__add_compiler_error_line(duk_hthread *thr)
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__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 60001 of file duktape-1.5.2/src/duktape.c.

60002 {
60003 rc_varname = duk__getconst(comp_ctx);
60004 *out_reg_varbind = -1;
60005 *out_rc_varname = rc_varname;
60006 return 0;
60007 }
60008}
60009
60010/*
60011 * Label handling
60012 *
60013 * Labels are initially added with flags prohibiting both break and continue.
60014 * When the statement type is finally uncovered (after potentially multiple
60015 * labels), all the labels are updated to allow/prohibit break and continue.
60016 */
60017
60018DUK_LOCAL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id) {
60019 duk_hthread *thr = comp_ctx->thr;
60020 duk_context *ctx = (duk_context *) thr;
60021 duk_size_t n;
60022 duk_size_t new_size;
60023 duk_uint8_t *p;
60024 duk_labelinfo *li_start, *li;
60025
60026 /* Duplicate (shadowing) labels are not allowed, except for the empty
60027 * labels (which are used as default labels for switch and iteration
60028 * statements).
60029 *
60030 * We could also allow shadowing of non-empty pending labels without any
60031 * other issues than breaking the required label shadowing requirements
60032 * of the E5 specification, see Section 12.12.
60033 */
60034
60035 p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
60036 li_start = (duk_labelinfo *) (void *) p;
60037 li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
60038 n = (duk_size_t) (li - li_start);
60039
60040 while (li > li_start) {
60041 li--;
60042
60043 if (li->h_label == h_label && h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) {
60045 }
60046 }
60047
60048 duk_push_hstring(ctx, h_label);
60049 DUK_ASSERT(n <= DUK_UARRIDX_MAX); /* label limits */
60050 (void) duk_put_prop_index(ctx, comp_ctx->curr_func.labelnames_idx, (duk_uarridx_t) n);
60051
60052 new_size = (n + 1) * sizeof(duk_labelinfo);
60053 duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size);
60054 /* XXX: spare handling, slow now */
60055
60056 /* relookup after possible realloc */
60057 p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
60058 li_start = (duk_labelinfo *) (void *) p;
60059 DUK_UNREF(li_start); /* silence scan-build warning */
60060 li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
60061 li--;
60062
DUK_INTERNAL_DECL void duk_push_hstring(duk_context *ctx, duk_hstring *h)
DUK_EXTERNAL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx)
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)
#define DUK_ERROR_SYNTAX(thr, msg)
#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)
DUK_LOCAL_DECL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx)
#define DUK_STR_DUPLICATE_LABEL
DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size)

◆ 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 39781 of file duktape-1.5.2/src/duktape.c.

39798 {
39799 duk_context *ctx = (duk_context *) thr;
39801 duk_int_t i, i_min;
39802 duk_uarridx_t arr_idx;
39803 duk_double_t d;
39804
39805 DUK_ASSERT(thr != NULL);
39806 DUK_ASSERT(thr_callstack != NULL);
39807 DUK_ASSERT(ctx != NULL);
39808
39809 /* [ ... error ] */
39810
39811 /*
39812 * The traceback format is pretty arcane in an attempt to keep it compact
39813 * and cheap to create. It may change arbitrarily from version to version.
39814 * It should be decoded/accessed through version specific accessors only.
39815 *
39816 * See doc/error-objects.rst.
39817 */
39818
39819 DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
39820 (duk_tval *) duk_get_tval(ctx, -1)));
39821
39822 duk_push_array(ctx); /* XXX: specify array size, as we know it */
39823 arr_idx = 0;
39824
39825 /* Compiler SyntaxErrors (and other errors) come first, and are
39826 * blamed by default (not flagged "noblame").
39827 */
39828 if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
39830 duk_xdef_prop_index_wec(ctx, -2, arr_idx);
39831 arr_idx++;
39832
39833 duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line); /* (flags<<32) + (line), flags = 0 */
39834 duk_xdef_prop_index_wec(ctx, -2, arr_idx);
39835 arr_idx++;
39836 }
39837
39838 /* Filename/line from C macros (__FILE__, __LINE__) are added as an
39839 * entry with a special format: (string, number). The number contains
39840 * the line and flags.
39841 */
39842
39843 /* XXX: optimize: allocate an array part to the necessary size (upwards
39844 * estimate) and fill in the values directly into the array part; finally
39845 * update 'length'.
39846 */
39847
39848 /* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype
39849 * has write-protected array index named properties. This was seen as DoubleErrors
39850 * in e.g. some test262 test cases. Using duk_xdef_prop_index() is better but heavier.
39851 * The best fix is to fill in the tracedata directly into the array part. There are
39852 * no side effect concerns if the array part is allocated directly and only INCREFs
39853 * happen after that.
39854 */
39855
39856 /* [ ... error arr ] */
39857
39858 if (c_filename) {
39859 duk_push_string(ctx, c_filename);
39860 duk_xdef_prop_index_wec(ctx, -2, arr_idx);
39861 arr_idx++;
39862
39863 d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
39864 (duk_double_t) c_line;
39865 duk_push_number(ctx, d);
39866 duk_xdef_prop_index_wec(ctx, -2, arr_idx);
39867 arr_idx++;
39868 }
39869
39870 /* traceback depth doesn't take into account the filename/line
39871 * special handling above (intentional)
39872 */
39874 i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
39875 DUK_ASSERT(i_min >= 0);
39876
39877 /* [ ... error arr ] */
39878
39879 DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX); /* callstack limits */
39880 for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
39881 duk_uint32_t pc;
39882
39883 /*
39884 * Note: each API operation potentially resizes the callstack,
39885 * so be careful to re-lookup after every operation. Currently
39886 * these is no issue because we don't store a temporary 'act'
39887 * pointer at all. (This would be a non-issue if we operated
39888 * directly on the array part.)
39889 */
39890
39891 /* [... arr] */
39892
39893 DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0); /* unsigned */
39894
39895 /* Add function object. */
39896 duk_push_tval(ctx, &(thr_callstack->callstack + i)->tv_func);
39897 duk_xdef_prop_index_wec(ctx, -2, arr_idx);
39898 arr_idx++;
39899
39900 /* Add a number containing: pc, activation flags.
39901 *
39902 * PC points to next instruction, find offending PC. Note that
39903 * PC == 0 for native code.
39904 */
guint depth
DUK_EXTERNAL const char * duk_push_string(duk_context *ctx, const char *str)
#define DUK_DDD(x)
DUK_INTERNAL_DECL void duk_push_tval(duk_context *ctx, duk_tval *tv)
#define duk_xdef_prop_index_wec(ctx, obj_index, arr_index)
#define DUK_TB_FLAG_NOBLAME_FILELINE
#define DUK_ASSERT_DISABLE(x)
DUK_EXTERNAL void duk_push_uint(duk_context *ctx, duk_uint_t val)
DUK_EXTERNAL void duk_push_number(duk_context *ctx, duk_double_t val)
DUK_EXTERNAL duk_idx_t duk_push_array(duk_context *ctx)
DUK_INTERNAL_DECL duk_tval * duk_get_tval(duk_context *ctx, duk_idx_t index)

◆ 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 55518 of file duktape-1.5.2/src/duktape.c.

55518 :
55519 DUK_ASSERT(tv_func != NULL);
55520#if defined(DUK_USE_PARANOID_ERRORS)
55522#else
55523 DUK_ERROR_FMT1(thr, DUK_ERR_TYPE_ERROR, "%s not callable", duk_push_string_tval_readable(ctx, tv_func));
55524#endif
55526 return NULL; /* never executed */
55527}
55528
55529/*
55530 * Value stack resize and stack top adjustment helper.
55531 *
55532 * XXX: This should all be merged to duk_valstack_resize_raw().
55533 */
55534
55536 duk_idx_t num_stack_args,
55537 duk_idx_t idx_args,
55538 duk_idx_t nregs,
55539 duk_idx_t nargs,
55540 duk_hobject *func) {
55541 duk_context *ctx = (duk_context *) thr;
55542 duk_size_t vs_min_size;
55543 duk_bool_t adjusted_top = 0;
55544
55545 vs_min_size = (thr->valstack_bottom - thr->valstack) + /* bottom of current func */
55546 idx_args; /* bottom of new func */
55547
55548 if (nregs >= 0) {
55549 DUK_ASSERT(nargs >= 0);
55550 DUK_ASSERT(nregs >= nargs);
55551 vs_min_size += nregs;
55552 } else {
55553 /* 'func' wants stack "as is" */
55554 vs_min_size += num_stack_args; /* num entries of new func at entry */
55555 }
55556 if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
55557 vs_min_size += DUK_VALSTACK_API_ENTRY_MINIMUM; /* Duktape/C API guaranteed entries (on top of args) */
55558 }
55559 vs_min_size += DUK_VALSTACK_INTERNAL_EXTRA; /* + spare */
55560
55561 /* XXX: We can't resize the value stack to a size smaller than the
55562 * current top, so the order of the resize and adjusting the stack
55563 * top depends on the current vs. final size of the value stack.
55564 * The operations could be combined to avoid this, but the proper
55565 * fix is to only grow the value stack on a function call, and only
55566 * shrink it (without throwing if the shrink fails) on function
55567 * return.
55568 */
55569
55570 if (vs_min_size < (duk_size_t) (thr->valstack_top - thr->valstack)) {
55571 DUK_DDD(DUK_DDDPRINT(("final size smaller, set top before resize")));
55572
55573 DUK_ASSERT(nregs >= 0); /* can't happen when keeping current stack size */
55574 duk_set_top(ctx, idx_args + nargs); /* clamp anything above nargs */
55575 duk_set_top(ctx, idx_args + nregs); /* extend with undefined */
DUK_INTERNAL_DECL const char * duk_push_string_tval_readable(duk_context *ctx, duk_tval *tv)
#define DUK_STR_NOT_CALLABLE
#define DUK_ERROR_TYPE(thr, msg)
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)
#define DUK_HOBJECT_IS_NATIVEFUNCTION(h)
DUK_EXTERNAL void duk_set_top(duk_context *ctx, duk_idx_t index)
#define DUK_VALSTACK_API_ENTRY_MINIMUM
#define DUK_ERROR_FMT1(thr, err, fmt, arg1)
#define DUK_VALSTACK_INTERNAL_EXTRA

Referenced by duk_handle_ecma_call_setup().

◆ duk__advance()

◆ duk__advance_bytes()

DUK_LOCAL void duk__advance_bytes ( duk_lexer_ctx * lex_ctx,
duk_small_uint_t count_bytes )

Definition at line 73348 of file duktape-1.5.2/src/duktape.c.

73357 : /* clipped codepoint */
73358 error_encoding: /* invalid codepoint encoding or codepoint */
73359 lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input);
73360 lex_ctx->input_line = input_line;
73361
73362 DUK_ERROR_SYNTAX(lex_ctx->thr, "utf-8 decode failed");
73363}
73364
73365DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) {
73366 duk_small_uint_t used_bytes, avail_bytes;
73367
73368 DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */
73370 DUK_ASSERT(lex_ctx->window >= lex_ctx->buffer);
73371 DUK_ASSERT(lex_ctx->window < lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE);
73372 DUK_ASSERT((duk_uint8_t *) lex_ctx->window + count_bytes <= (duk_uint8_t *) lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint));
73373
73374 /* Zero 'count' is also allowed to make call sites easier.
#define DUK_LEXER_BUFFER_SIZE
#define DUK_LEXER_WINDOW_SIZE
DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes)
duk_lexer_codepoint buffer[DUK_LEXER_BUFFER_SIZE]

◆ duk__advance_expect()

DUK_LOCAL_DECL void duk__advance_expect ( duk_compiler_ctx * comp_ctx,
duk_small_int_t expect )

Definition at line 57938 of file duktape-1.5.2/src/duktape.c.

57938 : curr: tok=%ld/%ld,%ld,term=%ld,%!T,%!T "
57939 "prev: tok=%ld/%ld,%ld,term=%ld,%!T,%!T",
57940 (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 57879 of file duktape-1.5.2/src/duktape.c.

57882 {
57883 DUK_ASSERT(h != NULL);
57884 return (comp_ctx->curr_func.is_strict &&
57886}
57887
57888/*
57889 * Parser duk__advance() token eating functions
57890 */
57891
57892/* XXX: valstack handling is awkward. Add a valstack helper which
57893 * avoids dup():ing; valstack_copy(src, dst)?
57894 */
57895
57897 duk_hthread *thr = comp_ctx->thr;
57898 duk_context *ctx = (duk_context *) thr;
57899 duk_bool_t regexp;
57900
57901 DUK_ASSERT(comp_ctx->curr_token.t >= 0 && comp_ctx->curr_token.t <= DUK_TOK_MAXVAL); /* MAXVAL is inclusive */
57902
57903 /*
57904 * Use current token to decide whether a RegExp can follow.
57905 *
57906 * We can use either 't' or 't_nores'; the latter would not
57907 * recognize keywords. Some keywords can be followed by a
57908 * RegExp (e.g. "return"), so using 't' is better. This is
57909 * not trivial, see doc/compiler.rst.
57910 */
57911
57912 regexp = 1;
57914 regexp = 0;
57915 }
57916 if (comp_ctx->curr_func.reject_regexp_in_adv) {
57917 comp_ctx->curr_func.reject_regexp_in_adv = 0;
57918 regexp = 0;
57919 }
57920
57921 if (expect >= 0 && comp_ctx->curr_token.t != expect) {
57922 DUK_D(DUK_DPRINT("parse error: expect=%ld, got=%ld",
57923 (long) expect, (long) comp_ctx->curr_token.t));
57925 }
57926
57927 /* make current token the previous; need to fiddle with valstack "backing store" */
57928 DUK_MEMCPY(&comp_ctx->prev_token, &comp_ctx->curr_token, sizeof(duk_token));
57929 duk_copy(ctx, comp_ctx->tok11_idx, comp_ctx->tok21_idx);
57930 duk_copy(ctx, comp_ctx->tok12_idx, comp_ctx->tok22_idx);
57931
57932 /* parse new token */
57934 &comp_ctx->curr_token,
57935 comp_ctx->curr_func.is_strict,
DUK_LOCAL const duk_uint8_t duk__token_lbp[]
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)
#define DUK_TOK_MAXVAL
DUK_LOCAL_DECL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect)
#define DUK_STR_PARSE_ERROR
DUK_EXTERNAL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index)
#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(x)
#define DUK__TOKEN_LBP_FLAG_NO_REGEXP

◆ 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 48428 of file duktape-1.5.2/src/duktape.c.

48429 {
48430 return NULL;
48431 }
48432 tv = DUK_HOBJECT_A_GET_VALUE_PTR(heap, obj, i);
48433 return tv;
48434}
48435
48436/*
48437 * Allocate and initialize a new entry, resizing the properties allocation
48438 * if necessary. Returns entry index (e_idx) or throws an error if alloc fails.
48439 *
48440 * Sets the key of the entry (increasing the key's refcount), and updates
48441 * the hash part if it exists. Caller must set value and flags, and update
48442 * the entry value refcount. A decref for the previous value is not necessary.
48443 */
48444
48446 duk_uint32_t idx;
48447
48448 DUK_ASSERT(thr != NULL);
48449 DUK_ASSERT(obj != NULL);
48450 DUK_ASSERT(key != NULL);
48452
48453#ifdef DUK_USE_ASSERTIONS
48454 /* key must not already exist in entry part */
48455 {
48457 for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
48458 DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != key);
48459 }
48460 }
48461#endif
48462
48464 /* only need to guarantee 1 more slot, but allocation growth is in chunks */
48465 DUK_DDD(DUK_DDDPRINT("entry part full, allocate space for one more entry"));
48467 }
48469 idx = DUK_HOBJECT_POSTINC_ENEXT(obj);
48470
48471 /* previous value is assumed to be garbage, so don't touch it */
48472 DUK_HOBJECT_E_SET_KEY(thr->heap, obj, idx, key);
48473 DUK_HSTRING_INCREF(thr, key);
48474
48475#if defined(DUK_USE_HOBJECT_HASH_PART)
48476 if (DUK_UNLIKELY(DUK_HOBJECT_GET_HSIZE(obj) > 0)) {
48477 duk_uint32_t n;
48478 duk_uint32_t i, step;
48479 duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj);
48480
48481 n = DUK_HOBJECT_GET_HSIZE(obj);
48484
48485 for (;;) {
48486 duk_uint32_t t = h_base[i];
48487 if (t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED) {
48488 DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() inserted key into hash part, %ld -> %ld",
48489 (long) i, (long) idx));
48490 DUK_ASSERT_DISABLE(i >= 0); /* unsigned */
48492 DUK_ASSERT_DISABLE(idx >= 0);
48494 h_base[i] = idx;
48495 break;
48496 }
48497 DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() miss %ld", (long) i));
#define DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i)
#define DUK_HOBJECT_POSTINC_ENEXT(h)
DUK_LOCAL void duk__grow_props_for_new_entry_item(duk_hthread *thr, duk_hobject *obj)
#define DUK_HOBJECT_GET_ENEXT(h)
DUK_LOCAL duk_bool_t duk__alloc_entry_checked(duk_hthread *thr, duk_hobject *obj, duk_hstring *key)
#define DUK_HSTRING_GET_HASH(x)
#define DUK_HOBJECT_E_SET_KEY(heap, h, i, k)
#define DUK__HASH_INITIAL(hash, h_size)
#define DUK_HSTRING_INCREF(thr, h)
#define DUK_HOBJECT_GET_HSIZE(h)
#define DUK__HASH_PROBE_STEP(hash)
#define DUK__HASH_UNUSED
#define DUK__HASH_DELETED
#define DUK_HOBJECT_H_GET_BASE(heap, h)

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 44786 of file duktape-1.5.2/src/duktape.c.

44807 {
44808 duk_hstring *res = NULL;
44809 duk_uint8_t *data;
44810 duk_size_t alloc_size;
44812 duk_uint32_t clen;
44813
44814#if defined(DUK_USE_STRLEN16)
44815 /* If blen <= 0xffffUL, clen is also guaranteed to be <= 0xffffUL. */
44816 if (blen > 0xffffUL) {
44817 DUK_D(DUK_DPRINT("16-bit string blen/clen active and blen over 16 bits, reject intern"));
44818 return NULL;
44819 }
44820#endif
44821
44822 if (extdata) {
44823 alloc_size = (duk_size_t) sizeof(duk_hstring_external);
44824 res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
44825 if (!res) {
44826 goto alloc_error;
44827 }
44828 DUK_MEMZERO(res, sizeof(duk_hstring_external));
44829#if defined(DUK_USE_EXPLICIT_NULL_INIT)
44831#endif
44833
44834 ((duk_hstring_external *) res)->extdata = extdata;
44835 } else {
44836 /* NUL terminate for convenient C access */
44837 alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1);
44838 res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
44839 if (!res) {
44840 goto alloc_error;
44841 }
44842 DUK_MEMZERO(res, sizeof(duk_hstring));
44843#if defined(DUK_USE_EXPLICIT_NULL_INIT)
44845#endif
44847
44848 data = (duk_uint8_t *) (res + 1);
44849 DUK_MEMCPY(data, str, blen);
44850 data[blen] = (duk_uint8_t) 0;
44851 }
44852
44854 if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
44856 }
44857
44858 /* All strings beginning with 0xff are treated as "internal",
44859 * even strings interned by the user. This allows user code to
44860 * create internal properties too, and makes behavior consistent
44861 * in case user code happens to use a string also used by Duktape
44862 * (such as string has already been interned and has the 'internal'
44863 * flag set).
44864 */
44866 if (blen > 0 && str[0] == (duk_uint8_t) 0xff) {
44868 }
44869
44870 DUK_HSTRING_SET_HASH(res, strhash);
44871 DUK_HSTRING_SET_BYTELEN(res, blen);
44872
44873 clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen);
44874 DUK_ASSERT(clen <= blen);
44875#if defined(DUK_USE_HSTRING_CLEN)
44876 DUK_HSTRING_SET_CHARLEN(res, clen);
44877#endif
44878
44879 /* Using an explicit 'ASCII' flag has larger footprint (one call site
44880 * only) but is quite useful for the case when there's no explicit
44881 * 'clen' in duk_hstring.
44882 */
#define DUK_MEMZERO(p, n)
#define DUK_HSTRING_HAS_ASCII(x)
#define DUK_ALLOC(heap, size)
#define DUK_HEAPHDR_STRING_INIT_NULLS(h)
#define DUK_HSTRING_SET_CHARLEN(x, v)
#define DUK_HSTRING_FLAG_EXTDATA
#define DUK_HSTRING_SET_HASH(x, v)
#define DUK_HSTRING_SET_ARRIDX(x)
#define DUK_HSTRING_HAS_INTERNAL(x)
#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h, tval, fval)
#define DUK_HSTRING_HAS_ARRIDX(x)
#define DUK_HSTRING_SET_INTERNAL(x)
#define DUK_HSTRING_SET_BYTELEN(x, v)
#define DUK_HTYPE_STRING
DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen)

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 59338 of file duktape-1.5.2/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 59320 of file duktape-1.5.2/src/duktape.c.

59323 {
59324 /* Don't allow negative zero as it will cause trouble with
59325 * LDINT+LDINTX. But positive zero is OK.
59326 */
59327 t = (duk_int32_t) x;
59328 if ((duk_double_t) t == x) {
59329 *ival = t;
59330 return 1;
59331 }
59332 }
59333
59334 return 0;
59335}
59336

◆ 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 14978 of file duktape-1.5.2/src/duktape.c.

14982 { \
14983 DUK_ASSERT(!(thr->valstack_top >= thr->valstack_end)); \
14984 } while (0)
14985#else
14986#define DUK__CHECK_SPACE() do { \
14987 if (DUK_UNLIKELY(thr->valstack_top >= thr->valstack_end)) { \
14988 DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \
14989 } \
14990 } while (0)
14991#endif
14992
14994
14996 duk_hthread *thr;
14997 duk_tval *tv;
14999 duk_double_t d;
15000
15001 thr = (duk_hthread *) ctx;
15002
15003 tv = duk_get_tval(ctx, index);
15004 if (tv == NULL) {
15005 goto error_notnumber;
15006 }
15007
15008 /*
15009 * Special cases like NaN and +/- Infinity are handled explicitly
15010 * because a plain C coercion from double to int handles these cases
15011 * in undesirable ways. For instance, NaN may coerce to INT_MIN
15012 * (not zero), and INT_MAX + 1 may coerce to INT_MIN (not INT_MAX).
15013 *
15014 * This double-to-int coercion differs from ToInteger() because it
15015 * has a finite range (ToInteger() allows e.g. +/- Infinity). It
15016 * also differs from ToInt32() because the INT_MIN/INT_MAX clamping
15017 * depends on the size of the int type on the platform. In particular,
15018 * on platforms with a 64-bit int type, the full range is allowed.
15019 */
15020
15021#if defined(DUK_USE_FASTINT)
15022 if (DUK_TVAL_IS_FASTINT(tv)) {
15023 duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
15024#if (DUK_INT_MAX <= 0x7fffffffL)
15025 /* Clamping only necessary for 32-bit ints. */
15026 if (t < DUK_INT_MIN) {
15027 t = DUK_INT_MIN;
15028 } else if (t > DUK_INT_MAX) {
15029 t = DUK_INT_MAX;
15030 }
15031#endif
15032 return (duk_int_t) t;
15033 }
15034#endif
15035
15036 if (DUK_TVAL_IS_NUMBER(tv)) {
15037 d = DUK_TVAL_GET_NUMBER(tv);
15039 if (c == DUK_FP_NAN) {
15040 return 0;
15041 } else if (d < (duk_double_t) DUK_INT_MIN) {
15042 /* covers -Infinity */
15043 return DUK_INT_MIN;
#define DUK_TVAL_IS_NUMBER(tv)
DUK_LOCAL duk_int_t duk__api_coerce_d2i(duk_context *ctx, duk_idx_t index, duk_bool_t require)
DUK_LOCAL_DECL duk_heaphdr * duk__get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t tag)
#define DUK_TVAL_GET_NUMBER(tv)

◆ 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 15045 of file duktape-1.5.2/src/duktape.c.

15047 {
15048 /* coerce towards zero */
15049 return (duk_int_t) d;
15050 }
15051 }
15052
15053 error_notnumber:
15054
15055 if (require) {
15057 /* not reachable */
15058 }
15059 return 0;
15060}
15061
15063 duk_hthread *thr;
15064 duk_tval *tv;
15066 duk_double_t d;
15067
15068 /* Same as above but for unsigned int range. */
15069
15070 thr = (duk_hthread *) ctx;
15071
15072 tv = duk_get_tval(ctx, index);
15073 if (tv == NULL) {
15074 goto error_notnumber;
15075 }
15076
15077#if defined(DUK_USE_FASTINT)
15078 if (DUK_TVAL_IS_FASTINT(tv)) {
15079 duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
15080 if (t < 0) {
15081 t = 0;
15082 }
15083#if (DUK_UINT_MAX <= 0xffffffffUL)
15084 /* Clamping only necessary for 32-bit ints. */
15085 else if (t > DUK_UINT_MAX) {
15086 t = DUK_UINT_MAX;
15087 }
15088#endif
15089 return (duk_uint_t) t;
15090 }
15091#endif
15092
15093 if (DUK_TVAL_IS_NUMBER(tv)) {
15094 d = DUK_TVAL_GET_NUMBER(tv);
15096 if (c == DUK_FP_NAN) {
15097 return 0;
15098 } else if (d < 0.0) {
15099 /* covers -Infinity */
15100 return (duk_uint_t) 0;
#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, expectname, lowmemstr)
#define DUK_STR_NOT_NUMBER
DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk_bool_t require)

◆ duk__append_jump_offset()

DUK_LOCAL duk_uint32_t duk__append_jump_offset ( duk_re_compiler_ctx * re_ctx,
duk_int32_t skip )

◆ 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 77492 of file duktape-1.5.2/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 77480 of file duktape-1.5.2/src/duktape.c.

77486 {

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 77460 of file duktape-1.5.2/src/duktape.c.

77460 {
77461 return ((duk_uint32_t) x) * 2;
77462 }
77463}
77464
77465/* XXX: return type should probably be duk_size_t, or explicit checks are needed for
77466 * maximum size.
77467 */

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 73560 of file duktape-1.5.2/src/duktape.c.

73560 {
73561 /* Reuse buffer as is unless buffer has grown large. */
73563 /* Keep current size */
73564 } else {
73566 }
73567
73568 DUK_BW_INIT_WITHBUF(lex_ctx->thr, &lex_ctx->bw, lex_ctx->buf);
73569}
73570
73571/*
73572 * Append a Unicode codepoint to the temporary byte buffer. Performs
73573 * CESU-8 surrogate pair encoding for codepoints above the BMP.
73574 * Existing surrogate pairs are allowed and also encoded into CESU-8.
#define DUK_LEXER_TEMP_BUF_LIMIT
#define DUK_BW_INIT_WITHBUF(thr, bw_ctx, buf)

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 20608 of file duktape-1.5.2/src/duktape.c.

20609 {
20610 *ptr++ = '>';
20611 } else if (i >= lo && i <= hi) {
20612 *ptr++ = '-';
20613 } else {
20614 *ptr++ = ' ';
20615 }
20616 }
20617 *ptr++ = ']';
20618 *ptr++ = '\0';
20619
20620 DUK_DDD(DUK_DDDPRINT("%s (lo=%ld, hi=%ld, pivot=%ld)",
20621 (const char *) buf, (long) lo, (long) hi, (long) pivot));
20622}
20623#endif
20624
20626 duk_hthread *thr = (duk_hthread *) ctx;
20627 duk_int_t p, l, r;
20628
20629 /* The lo/hi indices may be crossed and hi < 0 is possible at entry. */
20630
20631 DUK_DDD(DUK_DDDPRINT("duk__array_qsort: lo=%ld, hi=%ld, obj=%!T",
20632 (long) lo, (long) hi, (duk_tval *) duk_get_tval(ctx, 1)));
20633
20634 DUK_ASSERT_TOP(ctx, 3);
20635
20636 /* In some cases it may be that lo > hi, or hi < 0; these
20637 * degenerate cases happen e.g. for empty arrays, and in
20638 * recursion leaves.
20639 */
20640
20641 /* trivial cases */
20642 if (hi - lo < 1) {
20643 DUK_DDD(DUK_DDDPRINT("degenerate case, return immediately"));
20644 return;
20645 }
20646 DUK_ASSERT(hi > lo);
20647 DUK_ASSERT(hi - lo + 1 >= 2);
20648
20649 /* randomized pivot selection */
20650 p = lo + (duk_util_tinyrandom_get_bits(thr, 30) % (hi - lo + 1)); /* rnd in [lo,hi] */
20651 DUK_ASSERT(p >= lo && p <= hi);
20652 DUK_DDD(DUK_DDDPRINT("lo=%ld, hi=%ld, chose pivot p=%ld",
20653 (long) lo, (long) hi, (long) p));
20654
20655 /* move pivot out of the way */
20656 duk__array_sort_swap(ctx, p, lo);
20657 p = lo;
20658 DUK_DDD(DUK_DDDPRINT("pivot moved out of the way: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
20659
20660 l = lo + 1;
20661 r = hi;
20662 for (;;) {
20663 /* find elements to swap */
20664 for (;;) {
20665 DUK_DDD(DUK_DDDPRINT("left scan: l=%ld, r=%ld, p=%ld",
20666 (long) l, (long) r, (long) p));
20667 if (l >= hi) {
20668 break;
20669 }
20670 if (duk__array_sort_compare(ctx, l, p) >= 0) { /* !(l < p) */
20671 break;
20672 }
20673 l++;
20674 }
20675 for (;;) {
20676 DUK_DDD(DUK_DDDPRINT("right scan: l=%ld, r=%ld, p=%ld",
20677 (long) l, (long) r, (long) p));
20678 if (r <= lo) {
20679 break;
20680 }
20681 if (duk__array_sort_compare(ctx, p, r) >= 0) { /* !(p < r) */
20682 break;
20683 }
20684 r--;
20685 }
20686 if (l >= r) {
20687 goto done;
20688 }
20689 DUK_ASSERT(l < r);
20690
20691 DUK_DDD(DUK_DDDPRINT("swap %ld and %ld", (long) l, (long) r));
20692
20693 duk__array_sort_swap(ctx, l, r);
20694
20695 DUK_DDD(DUK_DDDPRINT("after swap: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
20696 l++;
20697 r--;
20698 }
20699 done:
20700 /* Note that 'l' and 'r' may cross, i.e. r < l */
20701 DUK_ASSERT(l >= lo && l <= hi);
20702 DUK_ASSERT(r >= lo && r <= hi);
20703
20704 /* XXX: there's no explicit recursion bound here now. For the average
DUK_LOCAL void duk__array_sort_swap(duk_context *ctx, duk_int_t l, duk_int_t r)
DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n)
#define DUK_ASSERT_TOP(ctx, n)
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_qsort(duk_context *ctx, duk_int_t lo, duk_int_t hi)

◆ 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 20430 of file duktape-1.5.2/src/duktape.c.

20447 {
20448 duk_bool_t have1, have2;
20449 duk_bool_t undef1, undef2;
20450 duk_small_int_t ret;
20451 duk_idx_t idx_obj = 1; /* fixed offsets in valstack */
20452 duk_idx_t idx_fn = 0;
20453 duk_hstring *h1, *h2;
20454
20455 /* Fast exit if indices are identical. This is valid for a non-existent property,
20456 * for an undefined value, and almost always for ToString() coerced comparison of
20457 * arbitrary values (corner cases where this is not the case include e.g. a an
20458 * object with varying ToString() coercion).
20459 *
20460 * The specification does not prohibit "caching" of values read from the array, so
20461 * assuming equality for comparing an index with itself falls into the category of
20462 * "caching".
20463 *
20464 * Also, compareFn may be inconsistent, so skipping a call to compareFn here may
20465 * have an effect on the final result. The specification does not require any
20466 * specific behavior for inconsistent compare functions, so again, this fast path
20467 * is OK.
20468 */
20469
20470 if (idx1 == idx2) {
20471 DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld -> indices identical, quick exit",
20472 (long) idx1, (long) idx2));
20473 return 0;
20474 }
20475
20476 have1 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx1);
20477 have2 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx2);
20478
20479 DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld, have1=%ld, have2=%ld, val1=%!T, val2=%!T",
20480 (long) idx1, (long) idx2, (long) have1, (long) have2,
20481 (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
20482
20483 if (have1) {
20484 if (have2) {
20485 ;
20486 } else {
20487 ret = -1;
20488 goto pop_ret;
20489 }
20490 } else {
20491 if (have2) {
20492 ret = 1;
20493 goto pop_ret;
20494 } else {
20495 ret = 0;
20496 goto pop_ret;
20497 }
20498 }
20499
20500 undef1 = duk_is_undefined(ctx, -2);
20501 undef2 = duk_is_undefined(ctx, -1);
20502 if (undef1) {
20503 if (undef2) {
20504 ret = 0;
20505 goto pop_ret;
20506 } else {
20507 ret = 1;
20508 goto pop_ret;
20509 }
20510 } else {
20511 if (undef2) {
20512 ret = -1;
20513 goto pop_ret;
20514 } else {
20515 ;
20516 }
20517 }
20518
20519 if (!duk_is_undefined(ctx, idx_fn)) {
20520 duk_double_t d;
20521
20522 /* no need to check callable; duk_call() will do that */
20523 duk_dup(ctx, idx_fn); /* -> [ ... x y fn ] */
20524 duk_insert(ctx, -3); /* -> [ ... fn x y ] */
20525 duk_call(ctx, 2); /* -> [ ... res ] */
20526
20527 /* The specification is a bit vague what to do if the return
20528 * value is not a number. Other implementations seem to
20529 * tolerate non-numbers but e.g. V8 won't apparently do a
20530 * ToNumber().
20531 */
20532
20533 /* XXX: best behavior for real world compatibility? */
20534
20535 d = duk_to_number(ctx, -1);
20536 if (d < 0.0) {
20537 ret = -1;
20538 } else if (d > 0.0) {
20539 ret = 1;
20540 } else {
20541 ret = 0;
20542 }
20543
20544 duk_pop(ctx);
20545 DUK_DDD(DUK_DDDPRINT("-> result %ld (from comparefn, after coercion)", (long) ret));
20546 return ret;
DUK_EXTERNAL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void duk_dup(duk_context *ctx, duk_idx_t from_index)
DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index)
DUK_EXTERNAL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)
DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs)
DUK_EXTERNAL void duk_pop(duk_context *ctx)

◆ 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 20548 of file duktape-1.5.2/src/duktape.c.

20559 :
20560 duk_pop_2(ctx);
20561 DUK_DDD(DUK_DDDPRINT("-> result %ld", (long) ret));
20562 return ret;
20563}
20564
20566 duk_bool_t have_l, have_r;
20567 duk_idx_t idx_obj = 1; /* fixed offset in valstack */
20568
20569 if (l == r) {
20570 return;
20571 }
20572
20573 /* swap elements; deal with non-existent elements correctly */
20574 have_l = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
DUK_EXTERNAL void duk_pop_2(duk_context *ctx)

◆ duk__asin()

DUK_LOCAL double duk__asin ( double x)

Definition at line 32534 of file duktape-1.5.2/src/duktape.c.

32536 :
32537

◆ duk__atan()

DUK_LOCAL double duk__atan ( double x)

Definition at line 32537 of file duktape-1.5.2/src/duktape.c.

◆ duk__atan2()

DUK_LOCAL double duk__atan2 ( double x,
double y )

Definition at line 32564 of file duktape-1.5.2/src/duktape.c.

32566 {

◆ 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 13066 of file duktape-1.5.2/src/duktape.c.

13066 {
13067 y = x - 26 + 'a';
13068 } else if (x <= 61) {
13069 y = x - 52 + '0';
13070 } else if (x == 62) {
13071 y = '+';
13072 } else {
13073 y = '/';
13074 }
13075
13076 *dst++ = (duk_uint8_t) y;
13077 }
13078 }
13079}
13080#endif /* DUK_USE_BASE64_FASTPATH */
13081
13082#if defined(DUK_USE_BASE64_FASTPATH)
13083DUK_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) {
13084 duk_int_t x;
13085 duk_int_t t;
13086 duk_small_uint_t n_equal;
13087 duk_small_uint_t n_chars;
13088 const duk_uint8_t *src_end;
13089 const duk_uint8_t *src_end_safe;
13090
13091 src_end = src + srclen;
13092 src_end_safe = src_end - 4; /* if 'src < src_end_safe', safe to read 4 bytes */
13093
13094 /* Innermost fast path processes 4 valid base-64 characters at a time
13095 * but bails out on whitespace, padding chars ('=') and invalid chars.
13096 * Once the slow path segment has been processed, we return to the
13097 * inner fast path again. This handles e.g. base64 with newlines
13098 * reasonably well because the majority of a line is in the fast path.
13099 */
13100 for (;;) {
13101 /* Fast path, handle units with just actual encoding characters. */
13102
13103 while (src <= src_end_safe) {
13104 /* The lookup byte is intentionally sign extended to (at least)
13105 * 32 bits and then ORed. This ensures that is at least 1 byte
13106 * is negative, the highest bit of 't' will be set at the end
13107 * and we don't need to check every byte.
13108 */
13109 DUK_DDD(DUK_DDDPRINT("fast loop: src=%p, src_end_safe=%p, src_end=%p",
13110 (const void *) src, (const void *) src_end_safe, (const void *) src_end));
13111
13112 t = (duk_int_t) duk_base64_dectab[*src++];
13113 t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++];
13114 t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++];
13115 t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++];
13116
13117 if (DUK_UNLIKELY(t < 0)) {
13118 DUK_DDD(DUK_DDDPRINT("fast loop unit was not clean, process one slow path unit"));
13119 src -= 4;
13120 break;
13121 }
13122
13123 DUK_ASSERT(t <= 0xffffffL);
13124 DUK_ASSERT((t >> 24) == 0);
13125 *dst++ = (duk_uint8_t) (t >> 16);
13126 *dst++ = (duk_uint8_t) ((t >> 8) & 0xff);
13127 *dst++ = (duk_uint8_t) (t & 0xff);
13128 }
13129
13130 /* Handle one slow path unit (or finish if we're done). */
13131
13132 n_equal = 0;
13133 n_chars = 0;
13134 t = 0;
13135 for (;;) {
13136 DUK_DDD(DUK_DDDPRINT("slow loop: src=%p, src_end=%p, n_chars=%ld, n_equal=%ld, t=%ld",
13137 (const void *) src, (const void *) src_end, (long) n_chars, (long) n_equal, (long) t));
13138
13139 if (DUK_UNLIKELY(src >= src_end)) {
13140 goto done; /* two level break */
13141 }
13142
13143 x = duk_base64_dectab[*src++];
13144 if (DUK_UNLIKELY(x < 0)) {
13145 if (x == -2) {
13146 continue; /* allowed ascii whitespace */
13147 } else if (x == -3) {
13148 n_equal++;
13149 t <<= 6;
13150 } else {
13151 DUK_ASSERT(x == -1);
13152 goto error;
13153 }
13154 } else {
13155 DUK_ASSERT(x >= 0 && x <= 63);
13156 if (n_equal > 0) {
13157 /* Don't allow actual chars after equal sign. */
13158 goto error;
13159 }
13160 t = (t << 6) + x;
13161 }
13162
13163 if (DUK_UNLIKELY(n_chars == 3)) {
13164 /* Emit 3 bytes and backtrack if there was padding. There's
13165 * always space for the whole 3 bytes so no check needed.
13166 */
13167 DUK_ASSERT(t <= 0xffffffL);
13168 DUK_ASSERT((t >> 24) == 0);
13169 *dst++ = (duk_uint8_t) (t >> 16);
13170 *dst++ = (duk_uint8_t) ((t >> 8) & 0xff);
13171 *dst++ = (duk_uint8_t) (t & 0xff);
13172
13173 if (DUK_UNLIKELY(n_equal > 0)) {
13174 DUK_ASSERT(n_equal <= 4);
13175
13176 /* There may be whitespace between the equal signs. */
13177 if (n_equal == 1) {
13178 /* XXX= */
13179 dst -= 1;
13180 } else if (n_equal == 2) {
13181 /* XX== */
13182 dst -= 2;
13183 } else {
13184 goto error; /* invalid padding */
13185 }
13186
13187 /* Continue parsing after padding, allows concatenated,
13188 * padded base64.
13189 */
13190 }
13191 break; /* back to fast loop */
13192 } else {
13193 n_chars++;
13194 }
13195 }
13196 }
13197 done:
13198 DUK_DDD(DUK_DDDPRINT("done; src=%p, src_end=%p, n_chars=%ld",
13199 (const void *) src, (const void *) src_end, (long) n_chars));
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_INTERNAL const duk_int8_t duk_base64_dectab[256]

◆ 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 12952 of file duktape-1.5.2/src/duktape.c.

12959 {
12960 DUK_ASSERT(duk_is_valid_index(ctx, index)); /* checked by caller */
12961 if (duk_is_buffer(ctx, index)) {
12962 return (const duk_uint8_t *) duk_get_buffer(ctx, index, out_len);
12963 } else {
12964 return (const duk_uint8_t *) duk_to_lstring(ctx, index, out_len);
12965 }
12966}
12967
12968#if defined(DUK_USE_BASE64_FASTPATH)
12969DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst) {
12970 duk_uint_t t;
12971 duk_size_t n_full, n_full3, n_final;
12972 const duk_uint8_t *src_end_fast;
12973
12974 n_full = srclen / 3; /* full 3-byte -> 4-char conversions */
12975 n_full3 = n_full * 3;
12976 n_final = srclen - n_full3;
12977 DUK_ASSERT_DISABLE(n_final >= 0);
12978 DUK_ASSERT(n_final <= 2);
12979
12980 src_end_fast = src + n_full3;
12981 while (DUK_UNLIKELY(src != src_end_fast)) {
12982 t = (duk_uint_t) (*src++);
12983 t = (t << 8) + (duk_uint_t) (*src++);
12984 t = (t << 8) + (duk_uint_t) (*src++);
12985
12986 *dst++ = duk_base64_enctab[t >> 18];
12987 *dst++ = duk_base64_enctab[(t >> 12) & 0x3f];
12988 *dst++ = duk_base64_enctab[(t >> 6) & 0x3f];
12989 *dst++ = duk_base64_enctab[t & 0x3f];
12990
12991#if 0 /* Tested: not faster on x64 */
12992 /* aaaaaabb bbbbcccc ccdddddd */
12993 dst[0] = duk_base64_enctab[(src[0] >> 2) & 0x3f];
12994 dst[1] = duk_base64_enctab[((src[0] << 4) & 0x30) | ((src[1] >> 4) & 0x0f)];
12995 dst[2] = duk_base64_enctab[((src[1] << 2) & 0x3f) | ((src[2] >> 6) & 0x03)];
12996 dst[3] = duk_base64_enctab[src[2] & 0x3f];
12997 src += 3; dst += 4;
12998#endif
12999 }
13000
13001 switch (n_final) {
13002 /* case 0: nop */
13003 case 1: {
13004 /* XX== */
13005 t = (duk_uint_t) (*src++);
13006 *dst++ = duk_base64_enctab[t >> 2]; /* XXXXXX-- */
DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void * duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size)
DUK_EXTERNAL const char * duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_INTERNAL const duk_uint8_t duk_base64_enctab[64]
DUK_EXTERNAL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index)
DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst)

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 78471 of file duktape-1.5.2/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 78467 of file duktape-1.5.2/src/duktape.c.

◆ duk__bi_add()

DUK_LOCAL void duk__bi_add ( duk__bigint * x,
duk__bigint * y,
duk__bigint * z )

Definition at line 75328 of file duktape-1.5.2/src/duktape.c.

75328 {
75329 tmp += z->v[i];
75330 }
75331 x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL);
75332 tmp = tmp >> 32;
75333 }
75334 if (tmp != 0U) {
75336 x->v[i++] = (duk_uint32_t) tmp;
75337 }
75338 x->n = i;
75340
75341 /* no need to normalize */
75342 DUK_ASSERT(duk__bi_is_valid(x));
75343}
75344#else /* DUK_USE_64BIT_OPS */
75346 duk_uint32_t carry, tmp1, tmp2;
75347 duk_small_int_t i, ny, nz;
75348
75349 DUK_ASSERT(duk__bi_is_valid(y));
75350 DUK_ASSERT(duk__bi_is_valid(z));
75351
75352 if (z->n > y->n) {
75353 duk__bigint *t;
75354 t = y; y = z; z = t;
75355 }
75356 DUK_ASSERT(y->n >= z->n);
75357
75358 ny = y->n; nz = z->n;
75359 carry = 0U;
75360 for (i = 0; i < ny; i++) {
75361 /* Carry is detected based on wrapping which relies on exact 32-bit
75362 * types.
75363 */
75365 tmp1 = y->v[i];
75366 tmp2 = tmp1;
75367 if (i < nz) {
75368 tmp2 += z->v[i];
75369 }
75370
75371 /* Careful with carry condition:
75372 * - If carry not added: 0x12345678 + 0 + 0xffffffff = 0x12345677 (< 0x12345678)
75373 * - If carry added: 0x12345678 + 1 + 0xffffffff = 0x12345678 (== 0x12345678)
75374 */
75375 if (carry) {
75376 tmp2++;
75377 carry = (tmp2 <= tmp1 ? 1U : 0U);
#define DUK__BI_MAX_PARTS
DUK_LOCAL void duk__bi_add(duk__bigint *x, duk__bigint *y, duk__bigint *z)
duk_uint32_t v[DUK__BI_MAX_PARTS]

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 75381 of file duktape-1.5.2/src/duktape.c.

75384 {
75386 DUK_ASSERT(carry == 1U);
75387 x->v[i++] = carry;
75388 }
75389 x->n = i;
75391

◆ duk__bi_compare()

DUK_LOCAL int duk__bi_compare ( duk__bigint * x,
duk__bigint * y )

Definition at line 75255 of file duktape-1.5.2/src/duktape.c.

75258 {
75259 if (v == 0U) {
75260 x->n = 0;
75261 } else {
75262 x->n = 1;
75263 x->v[0] = v;
75264 }
75265 DUK_ASSERT(duk__bi_is_valid(x));
75266}
75267
75268/* Return value: <0 <=> x < y
75269 * 0 <=> x == y
75270 * >0 <=> x > y
75271 */
75273 duk_small_int_t i, nx, ny;
75274 duk_uint32_t tx, ty;
75275
75276 DUK_ASSERT(duk__bi_is_valid(x));
75277 DUK_ASSERT(duk__bi_is_valid(y));
75278
75279 nx = x->n;
75280 ny = y->n;
75281 if (nx > ny) {
75282 goto ret_gt;
75283 }
75284 if (nx < ny) {
75285 goto ret_lt;
75286 }
75287 for (i = nx - 1; i >= 0; i--) {
75288 tx = x->v[i];
75289 ty = y->v[i];
DUK_LOCAL int duk__bi_compare(duk__bigint *x, duk__bigint *y)

◆ duk__bi_copy()

DUK_LOCAL void duk__bi_copy ( duk__bigint * x,
duk__bigint * y )

Definition at line 75230 of file duktape-1.5.2/src/duktape.c.

75232 {
75234
75235 for (i = x->n - 1; i >= 0; i--) {
75236 if (x->v[i] != 0) {
75237 break;
75238 }
75239 }

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 75670 of file duktape-1.5.2/src/duktape.c.

75675 {
75676 duk_small_int_t n, r;
75677
75678 n = (y / 32) + 1;
75679 DUK_ASSERT(n > 0);
75680 r = y % 32;
75681 DUK_MEMZERO((void *) x->v, sizeof(duk_uint32_t) * n);
75682 x->n = n;
75683 x->v[n - 1] = (((duk_uint32_t) 1) << r);
75684}
75685
75686/* x <- b^y; use t1 and t2 as temps */
75688 /* Fast path the binary case */
75689
75690 DUK_ASSERT(x != t1 && x != t2 && t1 != t2); /* distinct bignums, easy mistake to make */
75691 DUK_ASSERT(b >= 0);
75692 DUK_ASSERT(y >= 0);
75693
75694 if (b == 2) {
75695 duk__bi_twoexp(x, y);
75696 return;
75697 }
75698
75699 /* http://en.wikipedia.org/wiki/Exponentiation_by_squaring */
75700
75701 DUK_DDD(DUK_DDDPRINT("exp_small: b=%ld, y=%ld", (long) b, (long) y));
75702
75703 duk__bi_set_small(x, 1);
75704 duk__bi_set_small(t1, b);
DUK_LOCAL void duk__bi_set_small(duk__bigint *x, duk_uint32_t v)
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 void duk__bi_twoexp(duk__bigint *x, duk_small_int_t y)

◆ 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 28437 of file duktape-1.5.2/src/duktape.c.

28438 {
28439 DUK_UNREF(ctx);
28440 return 0;
28441}
28442#else /* print provider */
28444 DUK_UNREF(ctx);
28446}
28447#endif /* print provider */
28448
28449/*
28450 * CommonJS require() and modules support
28451 */
28452
28453#if defined(DUK_USE_COMMONJS_MODULES)
28454DUK_LOCAL void duk__bi_global_resolve_module_id(duk_context *ctx, const char *req_id, const char *mod_id) {
28455 duk_hthread *thr = (duk_hthread *) ctx;
28456 duk_uint8_t buf[DUK_BI_COMMONJS_MODULE_ID_LIMIT];
28457 duk_uint8_t *p;
28458 duk_uint8_t *q;
28459 duk_uint8_t *q_last; /* last component */
28460 duk_int_t int_rc;
28461
28462 DUK_ASSERT(req_id != NULL);
28463 /* mod_id may be NULL */
28464
28465 /*
28466 * A few notes on the algorithm:
28467 *
28468 * - Terms are not allowed to begin with a period unless the term
28469 * is either '.' or '..'. This simplifies implementation (and
28470 * is within CommonJS modules specification).
28471 *
28472 * - There are few output bound checks here. This is on purpose:
28473 * the resolution input is length checked and the output is never
28474 * longer than the input. The resolved output is written directly
28475 * over the input because it's never longer than the input at any
28476 * point in the algorithm.
28477 *
28478 * - Non-ASCII characters are processed as individual bytes and
28479 * need no special treatment. However, U+0000 terminates the
28480 * algorithm; this is not an issue because U+0000 is not a
28481 * desirable term character anyway.
28482 */
28483
28484 /*
28485 * Set up the resolution input which is the requested ID directly
28486 * (if absolute or no current module path) or with current module
28487 * ID prepended (if relative and current module path exists).
28488 *
28489 * Suppose current module is 'foo/bar' and relative path is './quux'.
28490 * The 'bar' component must be replaced so the initial input here is
28491 * 'foo/bar/.././quux'.
28492 */
28493
28494 if (mod_id != NULL && req_id[0] == '.') {
28495 int_rc = DUK_SNPRINTF((char *) buf, sizeof(buf), "%s/../%s", mod_id, req_id);
28496 } else {
28497 int_rc = DUK_SNPRINTF((char *) buf, sizeof(buf), "%s", req_id);
28498 }
28499 if (int_rc >= (duk_int_t) sizeof(buf) || int_rc < 0) {
28500 /* Potentially truncated, NUL not guaranteed in any case.
28501 * The (int_rc < 0) case should not occur in practice.
28502 */
28503 DUK_DD(DUK_DDPRINT("resolve error: temporary working module ID doesn't fit into resolve buffer"));
28504 goto resolve_error;
28505 }
28506 DUK_ASSERT(DUK_STRLEN((const char *) buf) < sizeof(buf)); /* at most sizeof(buf) - 1 */
28507
28508 DUK_DDD(DUK_DDDPRINT("input module id: '%s'", (const char *) buf));
28509
28510 /*
28511 * Resolution loop. At the top of the loop we're expecting a valid
28512 * term: '.', '..', or a non-empty identifier not starting with a period.
28513 */
28514
28515 p = buf;
28516 q = buf;
28517 for (;;) {
28519
28520 /* Here 'p' always points to the start of a term.
28521 *
28522 * We can also unconditionally reset q_last here: if this is
28523 * the last (non-empty) term q_last will have the right value
28524 * on loop exit.
28525 */
28526
28527 DUK_ASSERT(p >= q); /* output is never longer than input during resolution */
28528
28529 DUK_DDD(DUK_DDDPRINT("resolve loop top: p -> '%s', q=%p, buf=%p",
28530 (const char *) p, (void *) q, (void *) buf));
28531
28532 q_last = q;
28533
28534 c = *p++;
28535 if (DUK_UNLIKELY(c == 0)) {
28536 DUK_DD(DUK_DDPRINT("resolve error: requested ID must end with a non-empty term"));
28537 goto resolve_error;
28538 } else if (DUK_UNLIKELY(c == '.')) {
28539 c = *p++;
28540 if (c == '/') {
28541 /* Term was '.' and is eaten entirely (including dup slashes). */
28542 goto eat_dup_slashes;
28543 }
28544 if (c == '.' && *p == '/') {
28545 /* Term was '..', backtrack resolved name by one component.
28546 * q[-1] = previous slash (or beyond start of buffer)
28547 * q[-2] = last char of previous component (or beyond start of buffer)
28548 */
28549 p++; /* eat (first) input slash */
28550 DUK_ASSERT(q >= buf);
28551 if (q == buf) {
28552 DUK_DD(DUK_DDPRINT("resolve error: term was '..' but nothing to backtrack"));
28553 goto resolve_error;
28554 }
28555 DUK_ASSERT(*(q - 1) == '/');
28556 q--; /* backtrack to last output slash (dups already eliminated) */
28557 for (;;) {
28558 /* Backtrack to previous slash or start of buffer. */
28559 DUK_ASSERT(q >= buf);
28560 if (q == buf) {
28561 break;
28562 }
28563 if (*(q - 1) == '/') {
28564 break;
28565 }
28566 q--;
28567 }
28568 goto eat_dup_slashes;
28569 }
28570 DUK_DD(DUK_DDPRINT("resolve error: term begins with '.' but is not '.' or '..' (not allowed now)"));
28571 goto resolve_error;
28572 } else if (DUK_UNLIKELY(c == '/')) {
28573 /* e.g. require('/foo'), empty terms not allowed */
28574 DUK_DD(DUK_DDPRINT("resolve error: empty term (not allowed now)"));
28575 goto resolve_error;
28576 } else {
28577 for (;;) {
28578 /* Copy term name until end or '/'. */
28579 *q++ = c;
28580 c = *p++;
28581 if (DUK_UNLIKELY(c == 0)) {
28582 /* This was the last term, and q_last was
28583 * updated to match this term at loop top.
28584 */
28585 goto loop_done;
28586 } else if (DUK_UNLIKELY(c == '/')) {
28587 *q++ = '/';
28588 break;
28589 } else {
28590 /* write on next loop */
28591 }
28592 }
28593 }
28594
28595 eat_dup_slashes:
28596 for (;;) {
28597 /* eat dup slashes */
28598 c = *p;
28599 if (DUK_LIKELY(c != '/')) {
28600 break;
28601 }
28602 p++;
28603 }
28604 }
duk_uint8_t duk_uint_fast8_t
#define DUK_RET_UNSUPPORTED_ERROR
#define DUK_BI_COMMONJS_MODULE_ID_LIMIT
DUK_LOCAL void duk__bi_global_resolve_module_id(duk_context *ctx, const char *req_id, const char *mod_id)
DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx)

References DUK_UNREF.

◆ duk__bi_is_2to52()

DUK_LOCAL duk_small_int_t duk__bi_is_2to52 ( duk__bigint * x)

Definition at line 75651 of file duktape-1.5.2/src/duktape.c.

75652 {
75653 DUK_ASSERT(duk__bi_is_valid(x));
75654 return (x->n == 0) || ((x->v[0] & 0x01) == 0);
75655}

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 75635 of file duktape-1.5.2/src/duktape.c.

◆ duk__bi_is_zero()

DUK_LOCAL int duk__bi_is_zero ( duk__bigint * x)

Definition at line 75640 of file duktape-1.5.2/src/duktape.c.

75641 {
75642 duk__bi_mul(t, x, y);
75643 duk__bi_copy(x, t);
DUK_LOCAL void duk__bi_mul(duk__bigint *x, duk__bigint *y, duk__bigint *z)
DUK_LOCAL void duk__bi_copy(duk__bigint *x, duk__bigint *y)

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 75497 of file duktape-1.5.2/src/duktape.c.

75508 {
75509 duk__bi_sub(t, x, y);
75510 duk__bi_copy(x, t);
75511}
75512
75513/* x <- y * z */
75515 duk_small_int_t i, j, nx, nz;
75516
75517 DUK_ASSERT(duk__bi_is_valid(y));
75518 DUK_ASSERT(duk__bi_is_valid(z));
75519
75520 nx = y->n + z->n; /* max possible */
75522
75523 if (nx == 0) {
75524 /* Both inputs are zero; cases where only one is zero can go
75525 * through main algorithm.
75526 */
75527 x->n = 0;
75528 return;
75529 }
75530
75531 DUK_MEMZERO((void *) x->v, (size_t) (sizeof(duk_uint32_t) * nx));
75532 x->n = nx;
75533
75534 nz = z->n;
75535 for (i = 0; i < y->n; i++) {
75536#ifdef DUK_USE_64BIT_OPS
75537 duk_uint64_t tmp = 0U;
75538 for (j = 0; j < nz; j++) {
75539 tmp += (duk_uint64_t) y->v[i] * (duk_uint64_t) z->v[j] + x->v[i+j];
75540 x->v[i+j] = (duk_uint32_t) (tmp & 0xffffffffUL);
75541 tmp = tmp >> 32;
75542 }
75543 if (tmp > 0) {
75544 DUK_ASSERT(i + j < nx);
75546 DUK_ASSERT(x->v[i+j] == 0U);
75547 x->v[i+j] = (duk_uint32_t) tmp;
75548 }
75549#else
75550 /*
75551 * Multiply + add + carry for 32-bit components using only 16x16->32
75552 * multiplies and carry detection based on unsigned overflow.
75553 *
75554 * 1st mult, 32-bit: (A*2^16 + B)
75555 * 2nd mult, 32-bit: (C*2^16 + D)
75556 * 3rd add, 32-bit: E
75557 * 4th add, 32-bit: F
75558 *
75559 * (AC*2^16 + B) * (C*2^16 + D) + E + F
75560 * = AC*2^32 + AD*2^16 + BC*2^16 + BD + E + F
75561 * = AC*2^32 + (AD + BC)*2^16 + (BD + E + F)
75562 * = AC*2^32 + AD*2^16 + BC*2^16 + (BD + E + F)
75563 */
75564 duk_uint32_t a, b, c, d, e, f;
75565 duk_uint32_t r, s, t;
75566
75567 a = y->v[i]; b = a & 0xffffUL; a = a >> 16;
75568
75569 f = 0;
75570 for (j = 0; j < nz; j++) {
75571 c = z->v[j]; d = c & 0xffffUL; c = c >> 16;
75572 e = x->v[i+j];
75573
75574 /* build result as: (r << 32) + s: start with (BD + E + F) */
75575 r = 0;
75576 s = b * d;
75577
75578 /* add E */
75579 t = s + e;
75580 if (t < s) { r++; } /* carry */
75581 s = t;
75582
75583 /* add F */
75584 t = s + f;
75585 if (t < s) { r++; } /* carry */
75586 s = t;
75587
75588 /* add BC*2^16 */
75589 t = b * c;
75590 r += (t >> 16);
75591 t = s + ((t & 0xffffUL) << 16);
75592 if (t < s) { r++; } /* carry */
75593 s = t;
75594
75595 /* add AD*2^16 */
75596 t = a * d;
75597 r += (t >> 16);
75598 t = s + ((t & 0xffffUL) << 16);
75599 if (t < s) { r++; } /* carry */
75600 s = t;
75601
75602 /* add AC*2^32 */
75603 t = a * c;
75604 r += t;
75605
75606 DUK_DDD(DUK_DDDPRINT("ab=%08lx cd=%08lx ef=%08lx -> rs=%08lx %08lx",
75607 (unsigned long) y->v[i], (unsigned long) z->v[j],
75608 (unsigned long) x->v[i+j], (unsigned long) r,
DUK_LOCAL void duk__bi_sub(duk__bigint *x, duk__bigint *y, duk__bigint *z)
CURL_EXTERN CURLMcode curl_socket_t s
Definition multi.h:318

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 75624 of file duktape-1.5.2/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 75611 of file duktape-1.5.2/src/duktape.c.

75614 {
75615 DUK_ASSERT(i + j < nx);
75617 DUK_ASSERT(x->v[i+j] == 0U);
75618 x->v[i+j] = (duk_uint32_t) f;
75619 }
75620#endif /* DUK_USE_64BIT_OPS */
75621 }

◆ 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 75630 of file duktape-1.5.2/src/duktape.c.

◆ duk__bi_normalize()

DUK_LOCAL void duk__bi_normalize ( duk__bigint * x)

Definition at line 75215 of file duktape-1.5.2/src/duktape.c.

75216 {
75217 p += DUK_SPRINTF(p, " %08lx", (unsigned long) x->v[i]);
75218 }
75219
75220 DUK_DDD(DUK_DDDPRINT("%s: %s", (const char *) name, (const char *) buf));
75221}
75222#endif
75223
75224#ifdef DUK_USE_ASSERTIONS
75225DUK_LOCAL duk_small_int_t duk__bi_is_valid(duk__bigint *x) {
75226 return (duk_small_int_t)
75227 ( ((x->n >= 0) && (x->n <= DUK__BI_MAX_PARTS)) /* is valid size */ &&
const char * name
Definition lsqlite3.c:2154

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 75241 of file duktape-1.5.2/src/duktape.c.

75247 {
75249

◆ duk__bi_sub()

DUK_LOCAL void duk__bi_sub ( duk__bigint * x,
duk__bigint * y,
duk__bigint * z )

Definition at line 75433 of file duktape-1.5.2/src/duktape.c.

75434 {
75435 tz = z->v[i];
75436 } else {
75437 tz = 0;
75438 }
75439 tmp = (duk_int64_t) ty - (duk_int64_t) tz + tmp;
75440 x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL);
75441 tmp = tmp >> 32; /* 0 or -1 */
75442 }
75443 DUK_ASSERT(tmp == 0);
75444
75445 x->n = i;
75446 duk__bi_normalize(x); /* need to normalize, may even cancel to 0 */
75447 DUK_ASSERT(duk__bi_is_valid(x));
75448}
75449#else
75451 duk_small_int_t i, ny, nz;
75452 duk_uint32_t tmp1, tmp2, borrow;
75453
75454 DUK_ASSERT(duk__bi_is_valid(y));
75455 DUK_ASSERT(duk__bi_is_valid(z));
75456 DUK_ASSERT(duk__bi_compare(y, z) >= 0);
75457 DUK_ASSERT(y->n >= z->n);
75458
75459 ny = y->n; nz = z->n;
75460 borrow = 0U;
75461 for (i = 0; i < ny; i++) {
75462 /* Borrow is detected based on wrapping which relies on exact 32-bit
75463 * types.
75464 */
75465 tmp1 = y->v[i];
75466 tmp2 = tmp1;
75467 if (i < nz) {
75468 tmp2 -= z->v[i];
75469 }
75470
75471 /* Careful with borrow condition:
75472 * - If borrow not subtracted: 0x12345678 - 0 - 0xffffffff = 0x12345679 (> 0x12345678)
DUK_LOCAL void duk__bi_normalize(duk__bigint *x)

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 75491 of file duktape-1.5.2/src/duktape.c.

75494 {

◆ duk__bi_twoexp()

DUK_LOCAL void duk__bi_twoexp ( duk__bigint * x,
duk_small_int_t y )

Definition at line 75658 of file duktape-1.5.2/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 86207 of file duktape-1.5.2/src/duktape.c.

86208 {
86209 duk_be_encode(ctx, 0, npad);
86210 }
86211 DUK_ASSERT(ctx->currbits == 0);
86212}
86213#line 1 "duk_util_bufwriter.c"
86214/*
86215 * Fast buffer writer with spare management.
86216 */
86217
86218/* include removed: duk_internal.h */
86219
DUK_INTERNAL_DECL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits)

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 12383 of file duktape-1.5.2/src/duktape.c.

12383 {
12385}
12386
12387#endif /* DUK_USE_BYTECODE_DUMP_SUPPORT */
12388#line 1 "duk_api_call.c"
12389/*
12390 * Calls.
12391 *
12392 * Protected variants should avoid ever throwing an error.
12393 */
12394
12395/* include removed: duk_internal.h */
12396
12397/* Prepare value stack for a method call through an object property.
12398 * May currently throw an error e.g. when getting the property.
12399 */
12400DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs) {
12402
12403 DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_index=%ld, nargs=%ld, stacktop=%ld",
12404 (long) normalized_obj_index, (long) nargs, (long) duk_get_top(ctx)));
12405
12406 /* [... key arg1 ... argN] */
12407
#define DUK_ERROR_UNSUPPORTED_DEFMSG(thr)
#define DUK_ASSERT_CTX_VALID(ctx)
DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs)

References DUK_ERROR_UNSUPPORTED_DEFMSG.

Referenced by duk_pcall().

◆ 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 10840 of file duktape-1.5.2/src/duktape.c.

10840 {
10842 }
10843 return cp;
10844}
10845
10846/*
10847 * Case conversion helper, with context/local sensitivity.
10848 * For proper case conversion, one needs to know the character
10849 * and the preceding and following characters, as well as
10850 * locale/language.
10851 */
10852
10853/* XXX: add 'language' argument when locale/language sensitive rule
10854 * support added.
10855 */
10859 duk_codepoint_t cp,
10860 duk_codepoint_t prev,
10862 duk_bool_t uppercase) {
10863 duk_bitdecoder_ctx bd_ctx;
10864
10865 /* fast path for ASCII */
10866 if (cp < 0x80L) {
10867 /* XXX: there are language sensitive rules for the ASCII range.
10868 * If/when language/locale support is implemented, they need to
10869 * be implemented here for the fast path. There are no context
10870 * sensitive rules for ASCII range.
10871 */
10872
10873 if (uppercase) {
10874 if (cp >= 'a' && cp <= 'z') {
10875 cp = cp - 'a' + 'A';
10876 }
10877 } else {
10878 if (cp >= 'A' && cp <= 'Z') {
10879 cp = cp - 'A' + 'a';
10880 }
10881 }
10882
10883 if (bw != NULL) {
10884 DUK_BW_WRITE_RAW_U8(thr, bw, (duk_uint8_t) cp);
10885 }
10886 return cp;
10887 }
10888
10889 /* context and locale specific rules which cannot currently be represented
10890 * in the caseconv bitstream: hardcoded rules in C
10891 */
10892 if (uppercase) {
10893 /* XXX: turkish / azeri */
10894 } else {
10895 /*
10896 * Final sigma context specific rule. This is a rather tricky
10897 * rule and this handling is probably not 100% correct now.
10898 * The rule is not locale/language specific so it is supported.
10899 */
10900
10901 if (cp == 0x03a3L && /* U+03A3 = GREEK CAPITAL LETTER SIGMA */
10902 duk_unicode_is_letter(prev) && /* prev exists and is not a letter */
10903 !duk_unicode_is_letter(next)) { /* next does not exist or next is not a letter */
10904 /* Capital sigma occurred at "end of word", lowercase to
10905 * U+03C2 = GREEK SMALL LETTER FINAL SIGMA. Otherwise
10906 * fall through and let the normal rules lowercase it to
10907 * U+03C3 = GREEK SMALL LETTER SIGMA.
10908 */
10909 cp = 0x03c2L;
10910 goto singlechar;
10911 }
10912
10913 /* XXX: lithuanian not implemented */
10914 /* XXX: lithuanian, explicit dot rules */
10915 /* XXX: turkish / azeri, lowercase rules */
10916 }
10917
10918 /* 1:1 or special conversions, but not locale/context specific: script generated rules */
10919 DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
10920 if (uppercase) {
10921 bd_ctx.data = (const duk_uint8_t *) duk_unicode_caseconv_uc;
10922 bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_uc);
10923 } else {
const duk_uint8_t duk_unicode_caseconv_uc[1288]
#define DUK_BW_WRITE_RAW_U8(thr, bw_ctx, val)
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_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp)
#define DUK_BW_WRITE_RAW_XUTF8(thr, bw_ctx, cp)
#define next(ls)

References DUK_BW_WRITE_RAW_XUTF8.

◆ duk__ceil()

DUK_LOCAL double duk__ceil ( double x)

Definition at line 32540 of file duktape-1.5.2/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 48699 of file duktape-1.5.2/src/duktape.c.

48716 {
48717 duk_context *ctx = (duk_context *) thr;
48718 duk_hobject *map;
48719
48721
#define DUK_GETDESC_FLAG_PUSH_VALUE
#define DUK_ASSERT_VALSTACK_SPACE(thr, n)
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)
#define DUK_HTHREAD_STRING_INT_MAP(thr)
#define DUK__VALSTACK_SPACE

◆ 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 48617 of file duktape-1.5.2/src/duktape.c.

48622 : %!dO", (duk_heaphdr *) varenv));
48623
48624 /* success: leave varname in stack */
48625 *out_map = map;
48626 *out_varenv = varenv;
48627 return 1; /* [... varname] */
48628}
48629
48630/* Lookup 'key' from arguments internal 'map', and leave replacement value
48631 * on stack top if mapped (and return non-zero).
48632 * Used in E5 Section 10.6 algorithm for [[GetOwnProperty]] (used by [[Get]]).
48633 */
48634DUK_LOCAL duk_bool_t duk__check_arguments_map_for_get(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc) {
48635 duk_context *ctx = (duk_context *) thr;
48636 duk_hobject *map;
48637 duk_hobject *varenv;
48638 duk_hstring *varname;
48639
48640 DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
48641
48642 if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) {
48643 DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic get behavior"));
48644 return 0;
48645 }
48646
48647 /* [... varname] */
48648
48649 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 48655 of file duktape-1.5.2/src/duktape.c.

48672 {
48673 duk_context *ctx = (duk_context *) thr;
48674 duk_hobject *map;
48675 duk_hobject *varenv;
48676 duk_hstring *varname;
48677
48679
48680 if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) {
48681 DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic put behavior"));
48682 return;
48683 }
48684
48685 /* [... put_value varname] */
48686
48687 varname = duk_require_hstring(ctx, -1);
48688 DUK_ASSERT(varname != NULL);
48689 duk_pop(ctx); /* varname is still reachable */
48690
48691 DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; "
48692 "key=%!O, varname=%!O, value=%!T",
48693 (duk_heaphdr *) 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_INTERNAL_DECL duk_hstring * duk_require_hstring(duk_context *ctx, duk_idx_t index)

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 21851 of file duktape-1.5.2/src/duktape.c.

21873 {
21874 duk_int_t buffer_length;
21875 duk_int_t start_offset;
21876 duk_int_t end_offset;
21877
21878 DUK_ASSERT(out_start_offset != NULL);
21879 DUK_ASSERT(out_end_offset != NULL);
21880
21881 buffer_length = (duk_int_t) h_bufobj->length;
21882 buffer_length >>= h_bufobj->shift; /* as elements */
21883
21884 /* Resolve start/end offset as element indices first; arguments
21885 * at idx_start/idx_end are element offsets. Working with element
21886 * indices first also avoids potential for wrapping.
21887 */
21888
21889 start_offset = duk_to_int(ctx, idx_start);
21890 if (start_offset < 0) {
21891 start_offset = buffer_length + start_offset;
21892 }
21893 if (duk_is_undefined(ctx, idx_end)) {
21894 end_offset = buffer_length;
21895 } else {
21896 end_offset = duk_to_int(ctx, idx_end);
21897 if (end_offset < 0) {
21898 end_offset = buffer_length + end_offset;
21899 }
21900 }
21901 /* Note: start_offset/end_offset can still be < 0 here. */
21902
21903 if (start_offset < 0) {
21904 start_offset = 0;
21905 } else if (start_offset > buffer_length) {
21906 start_offset = buffer_length;
21907 }
21908 if (end_offset < start_offset) {
DUK_EXTERNAL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index)

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 21809 of file duktape-1.5.2/src/duktape.c.

21817 :
21819}
21820#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
21821
21822#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21823/* Shared lenient buffer length clamping helper. No negative indices, no
21824 * element/byte shifting.
21825 */
21827 duk_hbufferobject *h_bufobj,
21828 duk_idx_t idx_start,
21829 duk_idx_t idx_end,
21830 duk_int_t *out_start_offset,
21831 duk_int_t *out_end_offset) {
21832 duk_int_t buffer_length;
21833 duk_int_t start_offset;
21834 duk_int_t end_offset;
21835
21836 DUK_ASSERT(out_start_offset != NULL);
21837 DUK_ASSERT(out_end_offset != NULL);
21838
21839 buffer_length = (duk_int_t) h_bufobj->length;
21840
#define DUK_ERROR_RANGE(thr, msg)
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)
#define DUK_STR_INVALID_CALL_ARGS

◆ duk__cleanup_varmap()

DUK_LOCAL_DECL duk_int_t duk__cleanup_varmap ( duk_compiler_ctx * comp_ctx)

Definition at line 58044 of file duktape-1.5.2/src/duktape.c.

58061 {
58062 duk_hthread *thr = comp_ctx->thr;
58063 duk_context *ctx = (duk_context *) thr;
58064 duk_hobject *h_varmap;
58065 duk_hstring *h_key;
58066 duk_tval *tv;
58067 duk_uint32_t i, e_next;
58068 duk_int_t ret;
58069
58070 /* [ ... varmap ] */
58071
58072 h_varmap = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
58073 DUK_ASSERT(h_varmap != NULL);
58074
58075 ret = 0;
58076 e_next = DUK_HOBJECT_GET_ENEXT(h_varmap);
58077 for (i = 0; i < e_next; i++) {
58078 h_key = DUK_HOBJECT_E_GET_KEY(thr->heap, h_varmap, i);
58079 if (!h_key) {
58080 continue;
58081 }
58082
58083 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h_varmap, i));
58084
58085 /* The entries can either be register numbers or 'null' values.
58086 * Thus, no need to DECREF them and get side effects. DECREF'ing
58087 * the keys (strings) can cause memory to be freed but no side
58088 * effects as strings don't have finalizers. This is why we can
58089 * rely on the object properties not changing from underneath us.
#define DUK_GET_HOBJECT_NEGIDX(ctx, idx)
#define DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)

◆ duk__clear_finalize_list_flags()

DUK_LOCAL void duk__clear_finalize_list_flags ( duk_heap * heap)

Definition at line 42462 of file duktape-1.5.2/src/duktape.c.

◆ duk__clear_refzero_list_flags()

DUK_LOCAL void duk__clear_refzero_list_flags ( duk_heap * heap)

Definition at line 42435 of file duktape-1.5.2/src/duktape.c.

42438 : %p", (void *) hdr));
42439 duk_heaphdr_refcount_finalize(thr, hdr);
42440 }
42441
42442 hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
42443 }
42444}
42445#endif /* DUK_USE_REFERENCE_COUNTING */
42446
42447/*
42448 * 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 55401 of file duktape-1.5.2/src/duktape.c.

55408 :
55409 *
55410 * - global code: this=global object
55411 * - direct eval: this=copy from eval() caller's this binding
55412 * - other eval: this=global object
55413 *
55414 * Note: this function may cause a recursive function call with arbitrary
55415 * side effects, because ToObject() may be called.
55416 */
55417
55419 duk_hobject *func,
55420 duk_idx_t idx_this) {
55421 duk_context *ctx = (duk_context *) thr;
55422 duk_tval *tv_this;
55423 duk_hobject *obj_global;
55424
55425 if (func == NULL || DUK_HOBJECT_HAS_STRICT(func)) {
55426 /* Lightfuncs are always considered strict. */
55427 DUK_DDD(DUK_DDDPRINT("this binding: strict -> use directly"));
55428 return;
55429 }
55430
55431 /* XXX: byte offset */
55432 tv_this = thr->valstack_bottom + idx_this;
55433 switch (DUK_TVAL_GET_TAG(tv_this)) {
55434 case DUK_TAG_OBJECT:
55435 case DUK_TAG_LIGHTFUNC: /* lightfuncs are treated like objects and not coerced */
55436 DUK_DDD(DUK_DDDPRINT("this binding: non-strict, object -> use directly"));
55437 break;
55438 case DUK_TAG_UNDEFINED:
55439 case DUK_TAG_NULL:
55440 DUK_DDD(DUK_DDDPRINT("this binding: non-strict, undefined/null -> use global object"));
55441 obj_global = thr->builtins[DUK_BIDX_GLOBAL];
55442 /* XXX: avoid this check somehow */
55443 if (DUK_LIKELY(obj_global != NULL)) {
55444 DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_this)); /* no need to decref previous value */
55445 DUK_TVAL_SET_OBJECT(tv_this, obj_global);
DUK_LOCAL void duk__coerce_effective_this_binding(duk_hthread *thr, duk_hobject *func, duk_idx_t idx_this)
#define DUK_TVAL_SET_OBJECT(tv, hptr)
#define DUK_TVAL_GET_TAG(tv)
#define DUK_BIDX_GLOBAL
#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)
#define DUK_HOBJECT_HAS_STRICT(h)

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 42905 of file duktape-1.5.2/src/duktape.c.

42910 {
42911 /* XXX: for threads, compact value stack, call stack, catch stack? */
42912
42913 duk_hobject *obj = duk_get_hobject(ctx, -1);
42914 DUK_ASSERT(obj != NULL);
42916 return 0;
42917}
42918
42919#ifdef DUK_USE_DEBUG
42920DUK_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) {
42921#else
42923#endif
42924 duk_heaphdr *curr;
42925#ifdef DUK_USE_DEBUG
42926 duk_size_t old_size, new_size;
42927#endif
42928 duk_hobject *obj;
42929
42930 DUK_UNREF(heap);
42931
42932 curr = start;
42933 while (curr) {
42934 DUK_DDD(DUK_DDDPRINT("mark-and-sweep compact: %p", (void *) curr));
42935
42937 goto next;
42938 }
42939 obj = (duk_hobject *) curr;
42940
42941#ifdef DUK_USE_DEBUG
42945#endif
42946
42947 DUK_DD(DUK_DDPRINT("compact object: %p", (void *) obj));
42948 duk_push_hobject((duk_context *) thr, obj);
42949 /* XXX: disable error handlers for duration of compaction? */
42951
42952#ifdef DUK_USE_DEBUG
DUK_LOCAL int duk__protected_compact_object(duk_context *ctx)
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_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start)
DUK_INTERNAL_DECL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject *obj)
DUK_INTERNAL_DECL duk_hobject * duk_get_hobject(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL void duk_push_hobject(duk_context *ctx, duk_hobject *h)

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 42954 of file duktape-1.5.2/src/duktape.c.

42963 :
42964 curr = DUK_HEAPHDR_GET_NEXT(heap, curr);
42965#ifdef DUK_USE_DEBUG
42966 (*p_count_check)++;
42967#endif
42968 }
42969}
42970
42972 /* XXX: which lists should participate? to be finalized? */
42973#ifdef DUK_USE_DEBUG
42974 duk_size_t count_check = 0;
42975 duk_size_t count_compact = 0;
42976 duk_size_t count_bytes_saved = 0;
42977#endif
42978 duk_hthread *thr;
42979
42980 DUK_DD(DUK_DDPRINT("duk__compact_objects: %p", (void *) heap));
42981
42982 thr = duk__get_temp_hthread(heap);
42983 DUK_ASSERT(thr != NULL);
42984
42985#ifdef DUK_USE_DEBUG
42986 duk__compact_object_list(heap, thr, heap->heap_allocated, &count_check, &count_compact, &count_bytes_saved);
DUK_LOCAL void duk__compact_objects(duk_heap *heap)
#define DUK_HEAPHDR_GET_NEXT(heap, h)
DUK_LOCAL duk_hthread * duk__get_temp_hthread(duk_heap *heap)

◆ 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 47408 of file duktape-1.5.2/src/duktape.c.

47412 {
47413 if (*e++) {
47414 n++;
47415 }
47416 }
47417 return (duk_uint32_t) n;
47418}
47419
47420/* Count actually used array part entries and array minimum size.
47421 * NOTE: 'out_min_size' can be computed much faster by starting from the
47422 * end and breaking out early when finding first used entry, but this is
47423 * not needed now.
47424 */
47425DUK_LOCAL void duk__compute_a_stats(duk_hthread *thr, duk_hobject *obj, duk_uint32_t *out_used, duk_uint32_t *out_min_size) {
47427 duk_uint_fast32_t used = 0;
47428 duk_uint_fast32_t highest_idx = (duk_uint_fast32_t) -1; /* see below */
47429 duk_tval *a;
47430
47431 DUK_ASSERT(obj != NULL);
47432 DUK_ASSERT(out_used != NULL);
47433 DUK_ASSERT(out_min_size != NULL);
47434 DUK_UNREF(thr);
47435

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 65358 of file duktape-1.5.2/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 19594 of file duktape-1.5.2/src/duktape.c.

19595 {
19598}
19599#endif /* !DUK_USE_PARANOID_ERRORS */
19600
19601#undef DUK__CHECK_SPACE
19602#undef DUK__PACK_ARGS
19603#undef DUK__READABLE_STRING_MAXCHARS
19604#line 1 "duk_api_string.c"
19605/*
19606 * String manipulation
19607 */
19608
19609/* include removed: duk_internal.h */
19610
19612 duk_hthread *thr = (duk_hthread *) ctx;
19613 duk_uint_t count;
19614 duk_uint_t i;
19615 duk_size_t idx;
19616 duk_size_t len;
19617 duk_hstring *h;
19618 duk_uint8_t *buf;
19619
19621
19622 if (DUK_UNLIKELY(count_in <= 0)) {
19623 if (count_in < 0) {
19625 return;
19626 }
19627 DUK_ASSERT(count_in == 0);
19629 return;
19630 }
19631 count = (duk_uint_t) count_in;
19632
19633 if (is_join) {
19634 duk_size_t t1, t2, limit;
19635 h = duk_to_hstring(ctx, -((duk_idx_t) count) - 1);
19636 DUK_ASSERT(h != NULL);
19637
19638 /* A bit tricky overflow test, see doc/code-issues.rst. */
19640 t2 = (duk_size_t) (count - 1);
19642 if (DUK_UNLIKELY(t2 != 0 && t1 > limit / t2)) {
19643 /* Combined size of separators already overflows */
19644 goto error_overflow;
19645 }
19646 len = (duk_size_t) (t1 * t2);
19647 } else {
19648 len = (duk_size_t) 0;
19649 }
19650
19651 for (i = count; i >= 1; i--) {
19652 duk_size_t new_len;
19653 duk_to_string(ctx, -((duk_idx_t) i));
19654 h = duk_require_hstring(ctx, -((duk_idx_t) i));
19655 new_len = len + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
19656
19657 /* Impose a string maximum length, need to handle overflow
19658 * correctly.
19659 */
19660 if (new_len < len || /* wrapped */
19661 new_len > (duk_size_t) DUK_HSTRING_MAX_BYTELEN) {
19662 goto error_overflow;
19663 }
19664 len = new_len;
19665 }
19666
19667 DUK_DDD(DUK_DDDPRINT("join/concat %lu strings, total length %lu bytes",
19668 (unsigned long) count, (unsigned long) len));
19669
19670 /* use stack allocated buffer to ensure reachability in errors (e.g. intern error) */
19671 buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, len);
19672 DUK_ASSERT(buf != NULL);
19673
19674 /* [... (sep) str1 str2 ... strN buf] */
19675
19676 idx = 0;
19677 for (i = count; i >= 1; i--) {
19678 if (is_join && i != count) {
19679 h = duk_require_hstring(ctx, -((duk_idx_t) count) - 2); /* extra -1 for buffer */
19681 idx += DUK_HSTRING_GET_BYTELEN(h);
19682 }
19683 h = duk_require_hstring(ctx, -((duk_idx_t) i) - 1); /* extra -1 for buffer */
19685 idx += DUK_HSTRING_GET_BYTELEN(h);
19686 }
19687
19688 DUK_ASSERT(idx == len);
19689
19690 /* [... (sep) str1 str2 ... strN buf] */
19691
19692 /* get rid of the strings early to minimize memory use before intern */
19693
19694 if (is_join) {
#define duk_push_fixed_buffer(ctx, size)
DUK_INTERNAL_DECL duk_hstring * duk_to_hstring(duk_context *ctx, duk_idx_t index)
#define DUK_ERROR_API(thr, msg)
#define DUK_STR_INVALID_COUNT
#define DUK_STRIDX_EMPTY_STRING
DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, duk_bool_t is_join)
#define DUK_HSTRING_MAX_BYTELEN
DUK_INTERNAL_DECL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx)
DUK_EXTERNAL const char * duk_to_string(duk_context *ctx, duk_idx_t index)

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 58095 of file duktape-1.5.2/src/duktape.c.

58098 {
58099 ret++;
58100 }
58101 }
58102
58103 duk_compact(ctx, -1);
58104
58105 return ret;
58106}
58107
58108/* convert duk_compiler_func into a function template, leaving the result
58109 * on top of stack.
58110 */
58111/* XXX: awkward and bloated asm -- use faster internal accesses */
58112DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind) {
58113 duk_compiler_func *func = &comp_ctx->curr_func;
58114 duk_hthread *thr = comp_ctx->thr;
58115 duk_context *ctx = (duk_context *) thr;
58116 duk_hcompiledfunction *h_res;
58117 duk_hbuffer_fixed *h_data;
58118 duk_size_t consts_count;
58119 duk_size_t funcs_count;
58120 duk_size_t code_count;
58121 duk_size_t code_size;
58122 duk_size_t data_size;
58123 duk_size_t i;
58124 duk_tval *p_const;
58125 duk_hobject **p_func;
58126 duk_instr_t *p_instr;
58127 duk_compiler_instr *q_instr;
58128 duk_tval *tv;
58129
58130 DUK_DDD(DUK_DDDPRINT("converting duk_compiler_func to function/template"));
58131
58132 /*
58133 * Push result object and init its flags
58134 */
58135
58136 /* Valstack should suffice here, required on function valstack init */
58137
58138 (void) duk_push_compiledfunction(ctx);
58139 h_res = (duk_hcompiledfunction *) DUK_GET_HOBJECT_NEGIDX(ctx, -1); /* XXX: specific getter */
58140 DUK_ASSERT(h_res != NULL);
58141
58142 if (func->is_function) {
58143 DUK_DDD(DUK_DDDPRINT("function -> set NEWENV"));
58145
58146 if (!func->is_arguments_shadowed) {
58147 /* arguments object would be accessible; note that shadowing
58148 * bindings are arguments or function declarations, neither
58149 * of which are deletable, so this is safe.
58150 */
58151
58152 if (func->id_access_arguments || func->may_direct_eval) {
58153 DUK_DDD(DUK_DDDPRINT("function may access 'arguments' object directly or "
58154 "indirectly -> set CREATEARGS"));
58156 }
58157 }
58158 } else if (func->is_eval && func->is_strict) {
58159 DUK_DDD(DUK_DDDPRINT("strict eval code -> set NEWENV"));
58161 } else {
58162 /* non-strict eval: env is caller's env or global env (direct vs. indirect call)
58163 * global code: env is is global env
58164 */
58165 DUK_DDD(DUK_DDDPRINT("non-strict eval code or global code -> no NEWENV"));
58167 }
58168
58169 if (func->is_function && !func->is_decl && func->h_name != NULL && !force_no_namebind) {
58170 /* Object literal set/get functions have a name (property
58171 * name) but must not have a lexical name binding, see
58172 * test-bug-getset-func-name.js.
58173 */
58174 DUK_DDD(DUK_DDDPRINT("function expression with a name -> set NAMEBINDING"));
58176 }
58177
58178 if (func->is_strict) {
58179 DUK_DDD(DUK_DDDPRINT("function is strict -> set STRICT"));
58181 }
58182
58183 if (func->is_notail) {
58184 DUK_DDD(DUK_DDDPRINT("function is notail -> set NOTAIL"));
58186 }
58187
58188 /*
58189 * Build function fixed size 'data' buffer, which contains bytecode,
58190 * constants, and inner function references.
58191 *
58192 * During the building phase 'data' is reachable but incomplete.
58193 * Only incref's occur during building (no refzero or GC happens),
58194 * so the building process is atomic.
58195 */
58196
58197 consts_count = duk_hobject_get_length(thr, func->h_consts);
58198 funcs_count = duk_hobject_get_length(thr, func->h_funcs) / 3;
58199 code_count = DUK_BW_GET_SIZE(thr, &func->bw_code) / sizeof(duk_compiler_instr);
58200 code_size = code_count * sizeof(duk_instr_t);
58201
58202 data_size = consts_count * sizeof(duk_tval) +
58203 funcs_count * sizeof(duk_hobject *) +
58204 code_size;
58205
58206 DUK_DDD(DUK_DDDPRINT("consts_count=%ld, funcs_count=%ld, code_size=%ld -> "
58207 "data_size=%ld*%ld + %ld*%ld + %ld = %ld",
58208 (long) consts_count, (long) funcs_count, (long) code_size,
58209 (long) consts_count, (long) sizeof(duk_tval),
58210 (long) funcs_count, (long) sizeof(duk_hobject *),
58211 (long) code_size, (long) data_size));
58212
58213 duk_push_fixed_buffer(ctx, data_size);
58214 h_data = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1);
58215 DUK_ASSERT(h_data != NULL);
58216
58217 DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_res, (duk_hbuffer *) h_data);
58218 DUK_HEAPHDR_INCREF(thr, h_data);
58219
58220 p_const = (duk_tval *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data);
58221 for (i = 0; i < consts_count; i++) {
58222 DUK_ASSERT(i <= DUK_UARRIDX_MAX); /* const limits */
58224 DUK_ASSERT(tv != NULL);
58225 DUK_TVAL_SET_TVAL(p_const, tv);
58226 p_const++;
58227 DUK_TVAL_INCREF(thr, tv); /* may be a string constant */
58228
58229 DUK_DDD(DUK_DDDPRINT("constant: %!T", (duk_tval *) tv));
58230 }
58231
58232 p_func = (duk_hobject **) p_const;
58233 DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_res, p_func);
58234 for (i = 0; i < funcs_count; i++) {
58235 duk_hobject *h;
58236 DUK_ASSERT(i * 3 <= DUK_UARRIDX_MAX); /* func limits */
58238 DUK_ASSERT(tv != NULL);
58240 h = DUK_TVAL_GET_OBJECT(tv);
58241 DUK_ASSERT(h != NULL);
58243 *p_func++ = h;
58244 DUK_HOBJECT_INCREF(thr, h);
58245
58246 DUK_DDD(DUK_DDDPRINT("inner function: %p -> %!iO",
58247 (void *) h, (duk_heaphdr *) h));
58248 }
58249
58250 p_instr = (duk_instr_t *) p_func;
58251 DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_res, p_instr);
58252
58253 /* copy bytecode instructions one at a time */
58254 q_instr = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(thr, &func->bw_code);
58255 for (i = 0; i < code_count; i++) {
58256 p_instr[i] = q_instr[i].ins;
58257 }
58258 /* Note: 'q_instr' is still used below */
58259
58260 DUK_ASSERT((duk_uint8_t *) (p_instr + code_count) == DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data) + data_size);
58261
58262 duk_pop(ctx); /* 'data' (and everything in it) is reachable through h_res now */
58263
58264 /*
58265 * Init object properties
58266 *
58267 * Properties should be added in decreasing order of access frequency.
58268 * (Not very critical for function templates.)
58269 */
58270
58271 DUK_DDD(DUK_DDDPRINT("init function properties"));
58272
58273 /* [ ... res ] */
58274
58275 /* _Varmap: omitted if function is guaranteed not to do slow path identifier
58276 * accesses or if it would turn out to be empty of actual register mappings
58277 * after a cleanup. When debugging is enabled, we always need the varmap to
58278 * be able to lookup variables at any point.
58279 */
58280#if defined(DUK_USE_DEBUGGER_SUPPORT)
58281 if (1) {
58282#else
58283 if (func->id_access_slow || /* directly uses slow accesses */
58284 func->may_direct_eval || /* may indirectly slow access through a direct eval */
58285 funcs_count > 0) { /* has inner functions which may slow access (XXX: this can be optimized by looking at the inner functions) */
58286#endif
58287 duk_int_t num_used;
58288 duk_dup(ctx, func->varmap_idx);
58289 num_used = duk__cleanup_varmap(comp_ctx);
58290 DUK_DDD(DUK_DDDPRINT("cleaned up varmap: %!T (num_used=%ld)",
58291 (duk_tval *) duk_get_tval(ctx, -1), (long) num_used));
58292
58293 if (num_used > 0) {
58295 } else {
58296 DUK_DDD(DUK_DDDPRINT("varmap is empty after cleanup -> no need to add"));
58297 duk_pop(ctx);
58298 }
58299 }
58300
58301 /* _Formals: omitted if function is guaranteed not to need a (non-strict) arguments object */
58302 if (1) {
58303 /* XXX: Add a proper condition. If formals list is omitted, recheck
58304 * handling for 'length' in duk_js_push_closure(); it currently relies
58305 * on _Formals being set. Removal may need to be conditional to debugging
58306 * being enabled/disabled too.
58307 */
58308 duk_dup(ctx, func->argnames_idx);
58310 }
58311
58312 /* name */
58313 if (func->h_name) {
58314 duk_push_hstring(ctx, func->h_name);
58316 }
58317
58318 /* _Source */
58319#if defined(DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY)
58320 if (0) {
58321 /* XXX: Currently function source code is not stored, as it is not
58322 * required by the standard. Source code should not be stored by
58323 * default (user should enable it explicitly), and the source should
58324 * probably be compressed with a trivial text compressor; average
58325 * compression of 20-30% is quite easy to achieve even with a trivial
58326 * compressor (RLE + backwards lookup).
58327 *
58328 * Debugging needs source code to be useful: sometimes input code is
58329 * not found in files as it may be generated and then eval()'d, given
58330 * by dynamic C code, etc.
58331 *
58332 * Other issues:
58333 *
58334 * - Need tokenizer indices for start and end to substring
58335 * - Always normalize function declaration part?
58336 * - If we keep _Formals, only need to store body
58337 */
58338
58339 /*
58340 * For global or eval code this is straightforward. For functions
58341 * created with the Function constructor we only get the source for
58342 * the body and must manufacture the "function ..." part.
58343 *
58344 * For instance, for constructed functions (v8):
58345 *
58346 * > a = new Function("foo", "bar", "print(foo)");
58347 * [Function]
58348 * > a.toString()
58349 * 'function anonymous(foo,bar) {\nprint(foo)\n}'
58350 *
58351 * Similarly for e.g. getters (v8):
58352 *
58353 * > x = { get a(foo,bar) { print(foo); } }
58354 * { a: [Getter] }
58355 * > Object.getOwnPropertyDescriptor(x, 'a').get.toString()
58356 * 'function a(foo,bar) { print(foo); }'
58357 */
58358
58359#if 0
58360 duk_push_string(ctx, "XXX");
58362#endif
58363 }
58364#endif /* DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY */
58365
58366 /* _Pc2line */
58367#if defined(DUK_USE_PC2LINE)
58368 if (1) {
58369 /*
58370 * Size-optimized pc->line mapping.
58371 */
58372
58374 duk_hobject_pc2line_pack(thr, q_instr, (duk_uint_fast32_t) code_count); /* -> pushes fixed buffer */
58376
58377 /* XXX: if assertions enabled, walk through all valid PCs
58378 * and check line mapping.
58379 */
58380 }
58381#endif /* DUK_USE_PC2LINE */
58382
58383 /* fileName */
58384 if (comp_ctx->h_filename) {
58385 /*
58386 * Source filename (or equivalent), for identifying thrown errors.
58387 */
58388
58389 duk_push_hstring(ctx, comp_ctx->h_filename);
58391 }
58392
58393 /*
58394 * Init remaining result fields
58395 *
58396 * 'nregs' controls how large a register frame is allocated.
58397 *
58398 * 'nargs' controls how many formal arguments are written to registers:
58399 * r0, ... r(nargs-1). The remaining registers are initialized to
58400 * undefined.
58401 */
58402
58403 DUK_ASSERT(func->temp_max >= 0);
58404 h_res->nregs = (duk_uint16_t) func->temp_max;
58405 h_res->nargs = (duk_uint16_t) duk_hobject_get_length(thr, func->h_argnames);
58406 DUK_ASSERT(h_res->nregs >= h_res->nargs); /* pass2 allocation handles this */
58407#if defined(DUK_USE_DEBUGGER_SUPPORT)
58408 h_res->start_line = (duk_uint32_t) func->min_line;
58409 h_res->end_line = (duk_uint32_t) func->max_line;
58410#endif
58411
58412 DUK_DD(DUK_DDPRINT("converted function: %!ixT",
58413 (duk_tval *) duk_get_tval(ctx, -1)));
58414
58415 /*
58416 * Compact the function template.
58417 */
58418
58419 duk_compact(ctx, -1);
58420
58421 /*
58422 * Debug dumping
58423 */
58424
58425#ifdef DUK_USE_DDDPRINT
58426 {
58428 duk_instr_t *p, *p_start, *p_end;
58429
58430 h = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap, h, v)
#define DUK_TVAL_SET_TVAL(v, x)
#define DUK_COMPILER_MAX_BYTECODE_LENGTH
DUK_INTERNAL_DECL duk_hbuffer * duk_get_hbuffer(duk_context *ctx, duk_idx_t index)
#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap, h, v)
#define DUK_STRIDX_INT_FORMALS
DUK_LOCAL_DECL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind)
#define DUK_TVAL_GET_OBJECT(tv)
DUK_EXTERNAL void duk_compact(duk_context *ctx, duk_idx_t obj_index)
#define DUK_HOBJECT_IS_COMPILEDFUNCTION(h)
#define DUK_TVAL_IS_OBJECT(tv)
#define DUK_HOBJECT_SET_CREATEARGS(h)
#define DUK_PROPDESC_FLAGS_NONE
struct duk_compiler_instr duk_compiler_instr
#define DUK_TVAL_INCREF(thr, tv)
#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap, h, v)
#define DUK_BW_GET_BASEPTR(thr, bw_ctx)
#define DUK_HOBJECT_SET_NOTAIL(h)
#define DUK_HOBJECT_SET_STRICT(h)
#define DUK_STRIDX_NAME
#define DUK_BW_GET_SIZE(thr, bw_ctx)
#define DUK_STRIDX_INT_VARMAP
DUK_LOCAL_DECL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx)
DUK_INTERNAL_DECL duk_uint32_t duk_hobject_get_length(duk_hthread *thr, duk_hobject *obj)
#define DUK_HEAPHDR_INCREF(thr, h)
#define DUK_HOBJECT_HAS_NEWENV(h)
#define DUK_STRIDX_INT_PC2LINE
DUK_INTERNAL_DECL duk_tval * duk_hobject_find_existing_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i)
#define DUK_HOBJECT_INCREF(thr, h)
#define DUK_HOBJECT_SET_NAMEBINDING(h)
DUK_INTERNAL_DECL duk_idx_t duk_push_compiledfunction(duk_context *ctx)
#define DUK_STRIDX_INT_SOURCE
DUK_INTERNAL_DECL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr *instrs, duk_uint_fast32_t length)
#define DUK_HOBJECT_SET_NEWENV(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 59279 of file duktape-1.5.2/src/duktape.c.

59281 {
59282 DUK_D(DUK_DPRINT("ivalue dump: t=%ld op=%ld "
59283 "x1={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T} "
59284 "x2={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T}",
59285 (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 59287 of file duktape-1.5.2/src/duktape.c.

59292 {} while (0)
59293#define DUK__DUMP_IVALUE(comp_ctx,x) do {} while (0)
59294#endif
59295
59296DUK_LOCAL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst) {
59297 duk_context *ctx = (duk_context *) comp_ctx->thr;
59298
DUK_LOCAL_DECL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst)

◆ duk__cos()

DUK_LOCAL double duk__cos ( double x)

Definition at line 32543 of file duktape-1.5.2/src/duktape.c.

32545 {

◆ duk__count_used_e_keys()

DUK_LOCAL duk_uint32_t duk__count_used_e_keys ( duk_hthread * thr,
duk_hobject * obj )

Definition at line 47386 of file duktape-1.5.2/src/duktape.c.

47392 {
47393 duk_uint32_t res;
47394
47396
47398 DUK_ASSERT(res >= 1); /* important for callers */
47399 return res;
47400}
47401
#define DUK_HOBJECT_A_MIN_GROW_ADD
#define DUK_HOBJECT_MAX_PROPERTIES
#define DUK_HOBJECT_A_MIN_GROW_DIVISOR

◆ duk__count_used_probe()

DUK_LOCAL duk_int_t duk__count_used_probe ( duk_heap * heap)

Definition at line 45223 of file duktape-1.5.2/src/duktape.c.

45240 {
45241 duk_int_t res = 0;
45242 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 54845 of file duktape-1.5.2/src/duktape.c.

54866 { /* num args starting from idx_argbase */
54867 duk_context *ctx = (duk_context *) thr;
54868 duk_hobject *arg; /* 'arguments' */
54869 duk_hobject *formals; /* formals for 'func' (may be NULL if func is a C function) */
54870 duk_idx_t i_arg;
54871 duk_idx_t i_map;
54872 duk_idx_t i_mappednames;
54873 duk_idx_t i_formals;
54874 duk_idx_t i_argbase;
54875 duk_idx_t n_formals;
54876 duk_idx_t idx;
54877 duk_bool_t need_map;
54878
54879 DUK_DDD(DUK_DDDPRINT("creating arguments object for func=%!iO, varenv=%!iO, "
54880 "idx_argbase=%ld, num_stack_args=%ld",
54881 (duk_heaphdr *) func, (duk_heaphdr *) varenv,
54882 (long) idx_argbase, (long) num_stack_args));
54883
54884 DUK_ASSERT(thr != NULL);
54885 DUK_ASSERT(func != NULL);
54887 DUK_ASSERT(varenv != NULL);
54888 DUK_ASSERT(idx_argbase >= 0); /* assumed to bottom relative */
54889 DUK_ASSERT(num_stack_args >= 0);
54890
54891 need_map = 0;
54892
54893 i_argbase = idx_argbase;
54894 DUK_ASSERT(i_argbase >= 0);
54895
54896 duk_push_hobject(ctx, func);
54898 formals = duk_get_hobject(ctx, -1);
54899 n_formals = 0;
54900 if (formals) {
54902 n_formals = (duk_idx_t) duk_require_int(ctx, -1);
54903 duk_pop(ctx);
54904 }
54905 duk_remove(ctx, -2); /* leave formals on stack for later use */
54906 i_formals = duk_require_top_index(ctx);
54907
54908 DUK_ASSERT(n_formals >= 0);
54909 DUK_ASSERT(formals != NULL || n_formals == 0);
54910
54911 DUK_DDD(DUK_DDDPRINT("func=%!O, formals=%!O, n_formals=%ld",
54912 (duk_heaphdr *) func, (duk_heaphdr *) formals,
54913 (long) n_formals));
54914
54915 /* [ ... formals ] */
54916
54917 /*
54918 * Create required objects:
54919 * - 'arguments' object: array-like, but not an array
54920 * - 'map' object: internal object, tied to 'arguments'
54921 * - 'mappedNames' object: temporary value used during construction
54922 */
54923
54924 i_arg = duk_push_object_helper(ctx,
54929 DUK_ASSERT(i_arg >= 0);
54930 arg = duk_require_hobject(ctx, -1);
54931 DUK_ASSERT(arg != NULL);
54932
54933 i_map = duk_push_object_helper(ctx,
54936 -1); /* no prototype */
54937 DUK_ASSERT(i_map >= 0);
54938
54939 i_mappednames = duk_push_object_helper(ctx,
54942 -1); /* no prototype */
54943 DUK_ASSERT(i_mappednames >= 0);
54944
54945 /* [ ... formals arguments map mappedNames ] */
54946
54947 DUK_DDD(DUK_DDDPRINT("created arguments related objects: "
54948 "arguments at index %ld -> %!O "
54949 "map at index %ld -> %!O "
54950 "mappednames at index %ld -> %!O",
54951 (long) i_arg, (duk_heaphdr *) duk_get_hobject(ctx, i_arg),
54952 (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map),
54953 (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames)));
54954
54955 /*
54956 * Init arguments properties, map, etc.
54957 */
54958
54959 duk_push_int(ctx, num_stack_args);
54961
54962 /*
54963 * Init argument related properties
54964 */
54965
54966 /* step 11 */
54967 idx = num_stack_args - 1;
54968 while (idx >= 0) {
54969 DUK_DDD(DUK_DDDPRINT("arg idx %ld, argbase=%ld, argidx=%ld",
54970 (long) idx, (long) i_argbase, (long) (i_argbase + idx)));
54971
54972 DUK_DDD(DUK_DDDPRINT("define arguments[%ld]=arg", (long) idx));
54973 duk_dup(ctx, i_argbase + idx);
54974 duk_xdef_prop_index_wec(ctx, i_arg, (duk_uarridx_t) idx);
54975 DUK_DDD(DUK_DDDPRINT("defined arguments[%ld]=arg", (long) idx));
54976
54977 /* step 11.c is relevant only if non-strict (checked in 11.c.ii) */
54978 if (!DUK_HOBJECT_HAS_STRICT(func) && idx < n_formals) {
54979 DUK_ASSERT(formals != NULL);
54980
54981 DUK_DDD(DUK_DDDPRINT("strict function, index within formals (%ld < %ld)",
54982 (long) idx, (long) n_formals));
54983
54984 duk_get_prop_index(ctx, i_formals, idx);
54985 DUK_ASSERT(duk_is_string(ctx, -1));
54986
54987 duk_dup(ctx, -1); /* [ ... name name ] */
54988
54989 if (!duk_has_prop(ctx, i_mappednames)) {
54990 /* steps 11.c.ii.1 - 11.c.ii.4, but our internal book-keeping
54991 * differs from the reference model
54992 */
54993
54994 /* [ ... name ] */
54995
54996 need_map = 1;
54997
54998 DUK_DDD(DUK_DDDPRINT("set mappednames[%s]=%ld",
54999 (const char *) duk_get_string(ctx, -1),
55000 (long) idx));
55001 duk_dup(ctx, -1); /* name */
55002 duk_push_uint(ctx, (duk_uint_t) idx); /* index */
55003 duk_to_string(ctx, -1);
55004 duk_xdef_prop_wec(ctx, i_mappednames); /* out of spec, must be configurable */
55005
55006 DUK_DDD(DUK_DDDPRINT("set map[%ld]=%s",
55007 (long) idx,
55008 duk_get_string(ctx, -1)));
55009 duk_dup(ctx, -1); /* name */
55010 duk_xdef_prop_index_wec(ctx, i_map, (duk_uarridx_t) idx); /* out of spec, must be configurable */
55011 } else {
55012 /* duk_has_prop() popped the second 'name' */
55013 }
55014
55015 /* [ ... name ] */
55016 duk_pop(ctx); /* pop 'name' */
55017 }
55018
55019 idx--;
55020 }
55021
55022 DUK_DDD(DUK_DDDPRINT("actual arguments processed"));
55023
55024 /* step 12 */
55025 if (need_map) {
55026 DUK_DDD(DUK_DDDPRINT("adding 'map' and 'varenv' to arguments object"));
55027
55028 /* should never happen for a strict callee */
55030
55031 duk_dup(ctx, i_map);
55032 duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_MAP, DUK_PROPDESC_FLAGS_NONE); /* out of spec, don't care */
55033
55034 /* The variable environment for magic variable bindings needs to be
55035 * given by the caller and recorded in the arguments object.
55036 *
55037 * See E5 Section 10.6, the creation of setters/getters.
55038 *
55039 * The variable environment also provides access to the callee, so
55040 * an explicit (internal) callee property is not needed.
55041 */
55042
55043 duk_push_hobject(ctx, varenv);
55044 duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_NONE); /* out of spec, don't care */
55045 }
55046
55047 /* steps 13-14 */
55048 if (DUK_HOBJECT_HAS_STRICT(func)) {
55049 /* Callee/caller are throwers and are not deletable etc. They
55050 * could be implemented as virtual properties, but currently
55051 * there is no support for virtual properties which are accessors
55052 * (only plain virtual properties). This would not be difficult
55053 * to change in duk_hobject_props, but we can make the throwers
55054 * normal, concrete properties just as easily.
55055 *
55056 * Note that the specification requires that the *same* thrower
55057 * built-in object is used here! See E5 Section 10.6 main
55058 * algoritm, step 14, and Section 13.2.3 which describes the
55059 * thrower. See test case test-arguments-throwers.js.
55060 */
55061
55062 DUK_DDD(DUK_DDDPRINT("strict function, setting caller/callee to throwers"));
55063
55066 } else {
55067 DUK_DDD(DUK_DDDPRINT("non-strict function, setting callee to actual value"));
55068 duk_push_hobject(ctx, func);
55070 }
55071
55072 /* set exotic behavior only after we're done */
55073 if (need_map) {
55074 /* Exotic behaviors are only enabled for arguments objects
55075 * which have a parameter map (see E5 Section 10.6 main
55076 * algorithm, step 12).
55077 *
55078 * In particular, a non-strict arguments object with no
55079 * mapped formals does *NOT* get exotic behavior, even
55080 * for e.g. "caller" property. This seems counterintuitive
55081 * but seems to be the case.
55082 */
55083
55084 /* cannot be strict (never mapped variables) */
55086
55087 DUK_DDD(DUK_DDDPRINT("enabling exotic behavior for arguments object"));
55089 } else {
55090 DUK_DDD(DUK_DDDPRINT("not enabling exotic behavior for arguments object"));
CURL_EXTERN int void * arg
Definition curl.h:2622
#define DUK_HOBJECT_CLASS_OBJECT
#define DUK_BIDX_OBJECT_PROTOTYPE
#define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(h)
#define duk_xdef_prop_wec(ctx, obj_index)
DUK_EXTERNAL duk_idx_t duk_require_top_index(duk_context *ctx)
DUK_INTERNAL_DECL duk_hobject * duk_require_hobject(duk_context *ctx, duk_idx_t index)
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)
#define DUK_HOBJECT_CLASS_ARGUMENTS
#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)
DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val)
#define DUK_HOBJECT_CLASS_AS_FLAGS(v)
DUK_EXTERNAL const char * duk_get_string(duk_context *ctx, duk_idx_t index)
#define DUK_STRIDX_LENGTH
DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)
#define DUK_HOBJECT_FLAG_EXTENSIBLE
#define DUK_STRIDX_INT_VARENV
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)
#define DUK_STRIDX_INT_MAP
#define DUK_STRIDX_CALLEE
DUK_EXTERNAL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index)
#define DUK_STRIDX_CALLER
#define DUK_HOBJECT_FLAG_ARRAY_PART
DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index)

◆ duk__create_escaped_source()

DUK_LOCAL void duk__create_escaped_source ( duk_hthread * thr,
int idx_pattern )

Definition at line 78200 of file duktape-1.5.2/src/duktape.c.

78201 :)') and otherwise replace unescaped '/' characters
78202 * with '\/' regardless of where they occur in the regexp.
78203 *
78204 * Note that normalization does not seem to be necessary for
78205 * RegExp literals (e.g. '/foo/') because to be acceptable as
78206 * a RegExp literal, the text between forward slashes must
78207 * already match the escaping requirements (e.g. must not contain
78208 * unescaped forward slashes or be empty). Escaping IS needed
78209 * for expressions like 'new Regexp("...", "")' however.
78210 * Currently, we re-escape in either case.
78211 *
78212 * Also note that we process the source here in UTF-8 encoded
78213 * form. This is correct, because any non-ASCII characters are
78214 * passed through without change.
78215 */
78216
78217DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern) {
78218 duk_context *ctx = (duk_context *) thr;
78219 duk_hstring *h;
78220 const duk_uint8_t *p;
78221 duk_bufwriter_ctx bw_alloc;
78222 duk_bufwriter_ctx *bw;
78223 duk_uint8_t *q;
78224 duk_size_t i, n;
78225 duk_uint_fast8_t c_prev, c;
78226
78227 h = duk_get_hstring(ctx, idx_pattern);
78228 DUK_ASSERT(h != NULL);
78229 p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
78230 n = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
78231
78232 if (n == 0) {
78233 /* return '(?:)' */
78234 duk_push_hstring_stridx(ctx, DUK_STRIDX_ESCAPED_EMPTY_REGEXP);
78235 return;
78236 }
78237
78238 bw = &bw_alloc;
78239 DUK_BW_INIT_PUSHBUF(thr, bw, n);
78240 q = DUK_BW_GET_PTR(thr, bw);
78241
78242 c_prev = (duk_uint_fast8_t) 0;
78243
78244 for (i = 0; i < n; i++) {
78245 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__day_from_year()

DUK_LOCAL duk_int_t duk__day_from_year ( duk_int_t year)

Definition at line 24900 of file duktape-1.5.2/src/duktape.c.

24903 {
24904 DUK_ASSERT(b > 0);
24905 if (a >= 0) {
24906 return a / b;
24907 } else {
24908 /* 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 29695 of file duktape-1.5.2/src/duktape.c.

29701 : final object is %!T",
29702 (duk_tval *) duk_get_tval(ctx, -1)));
29703
29704 duk__dec_objarr_exit(js_ctx);
29705 return;
29706
29707 syntax_error:
29708 duk__dec_syntax_error(js_ctx);
29709 DUK_UNREACHABLE();
29710}
29711
29712DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) {
29713 duk_context *ctx = (duk_context *) js_ctx->thr;
29714 duk_uarridx_t arr_idx;
29715 duk_uint8_t x;
29716
29717 DUK_DDD(DUK_DDDPRINT("parse_array"));
29718
29719 duk__dec_objarr_entry(js_ctx);
29720
29721 duk_push_array(ctx);
29722
29723 /* Initial '[' has been checked and eaten by caller. */
29724
29725 arr_idx = 0;
29726 for (;;) {
29727 x = duk__dec_get_nonwhite(js_ctx);
29728
29729 DUK_DDD(DUK_DDDPRINT("parse_array: arr=%!T, x=%ld, arr_idx=%ld",
29730 (duk_tval *) duk_get_tval(ctx, -1),
29731 (long) x, (long) arr_idx));
29732
29733 /* handle comma and closing bracket */
29734
29735 if ((x == DUK_ASC_COMMA) && (arr_idx != 0)) {
29736 /* accept comma, expect new value */
29737 ;
29738 } else if (x == DUK_ASC_RBRACKET) {
29739 /* eat closing bracket */
29740 break;
29741 } else if (arr_idx == 0) {
29742 /* accept anything, expect first value (EOF will be
29743 * caught by duk__dec_value() below.
29744 */
29745 js_ctx->p--; /* backtrack (safe) */
29746 } else {
29747 /* catches EOF (NUL) and initial comma */
29748 goto syntax_error;
29749 }
29750
29751 /* parse value */
29752
29753 duk__dec_value(js_ctx);
29754
29755 /* [ ... arr val ] */
29756
29757 duk_xdef_prop_index_wec(ctx, -2, arr_idx);
29758 arr_idx++;
29759 }
29760
29761 /* 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 29467 of file duktape-1.5.2/src/duktape.c.

29477 :
29478 duk__dec_syntax_error(js_ctx);
29480}
29481#endif /* DUK_USE_JX */
29482
29483#ifdef DUK_USE_JX
29485 duk_hthread *thr = js_ctx->thr;
29486 duk_context *ctx = (duk_context *) thr;
29487 const duk_uint8_t *p;
29488 duk_uint8_t *buf;
29489 duk_size_t src_len;
29491
29492 /* Caller has already eaten the first character ('|') which we don't need. */
29493
29494 p = js_ctx->p;
29495
29496 /* XXX: Would be nice to share the fast path loop from duk_hex_decode()
29497 * and avoid creating a temporary buffer. However, there are some
29498 * differences which prevent trivial sharing:
29499 *
29500 * - Pipe char detection
29501 * - EOF detection
29502 * - Unknown length of input and output
29503 *
29504 * The best approach here would be a bufwriter and a reasonaly sized
29505 * safe inner loop (e.g. 64 output bytes at a time).
29506 */
29507
29508 for (;;) {
29509 x = *p;
29510
29511 /* This loop intentionally does not ensure characters are valid
29512 * ([0-9a-fA-F]) because the hex decode call below will do that.
29513 */
29514 if (x == DUK_ASC_PIPE) {
29515 break;
29516 } else if (x <= 0) {
29517 /* NUL term or -1 (EOF), NUL check would suffice */
29518 goto syntax_error;
29519 }
29520 p++;
29521 }
#define DUK_ASC_PIPE
DUK_LOCAL_DECL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx)
DUK_LOCAL_DECL void duk__dec_buffer(duk_json_dec_ctx *js_ctx)

◆ 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 29140 of file duktape-1.5.2/src/duktape.c.

29141 {
29142 DUK_ASSERT(js_ctx->p <= js_ctx->p_end);
29143 return *js_ctx->p;
29144}
29145
29146DUK_LOCAL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx) {
29147 DUK_ASSERT(js_ctx->p <= js_ctx->p_end);
29148 return *js_ctx->p++;
29149}
29150
29152 duk__dec_eat_white(js_ctx);
29153 return duk__dec_get(js_ctx);
29154}
29155
29156/* For JX, expressing the whole unsigned 32-bit range matters. */
29159 duk_uint_fast32_t res = 0;
29160 duk_uint8_t x;
29162
29163 for (i = 0; i < n; i++) {
29164 /* XXX: share helper from lexer; duk_lexer.c / hexval(). */
29165
29166 x = duk__dec_get(js_ctx);
29167 DUK_DDD(DUK_DDDPRINT("decode_hex_escape: i=%ld, n=%ld, res=%ld, x=%ld",
29168 (long) i, (long) n, (long) res, (long) x));
29169
29170 /* x == 0x00 (EOF) causes syntax_error */
29171 DUK_ASSERT(duk_hex_dectab[0] == -1);
DUK_LOCAL_DECL duk_uint8_t duk__dec_get_nonwhite(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_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_eat_white(duk_json_dec_ctx *js_ctx)
DUK_INTERNAL const duk_int8_t duk_hex_dectab[256]

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 29094 of file duktape-1.5.2/src/duktape.c.

29102 {
29103 /* Shared handler to minimize parser size. Cause will be
29104 * hidden, unfortunately, but we'll have an offset which
29105 * is often quite enough.
29106 */
29108 (long) (js_ctx->p - js_ctx->p_start));
29109}
29110
29112 const duk_uint8_t *p;
29113 duk_uint8_t t;
29114
29115 p = js_ctx->p;
29116 for (;;) {
29117 DUK_ASSERT(p <= js_ctx->p_end);
29118 t = *p;
29119
29120#if defined(DUK_USE_JSON_EATWHITE_FASTPATH)
29121 /* This fast path is pretty marginal in practice.
29122 * XXX: candidate for removal.
#define DUK_STR_FMT_INVALID_JSON

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 29129 of file duktape-1.5.2/src/duktape.c.

29129 {
29130 /* NUL also comes here. Comparison order matters, 0x20
29131 * is most common whitespace.
29132 */

◆ duk__dec_get_nonwhite()

DUK_LOCAL_DECL duk_uint8_t duk__dec_get_nonwhite ( duk_json_dec_ctx * js_ctx)

Definition at line 29134 of file duktape-1.5.2/src/duktape.c.

◆ duk__dec_number()

DUK_LOCAL_DECL void duk__dec_number ( duk_json_dec_ctx * js_ctx)

Definition at line 29525 of file duktape-1.5.2/src/duktape.c.

29535 :
29536 duk__dec_syntax_error(js_ctx);
29538}
29539#endif /* DUK_USE_JX */
29540
29541/* Parse a number, other than NaN or +/- Infinity */
29543 duk_context *ctx = (duk_context *) js_ctx->thr;
29544 const duk_uint8_t *p_start;
29545 const duk_uint8_t *p;
29546 duk_uint8_t x;
29547 duk_small_uint_t s2n_flags;
29548
29549 DUK_DDD(DUK_DDDPRINT("parse_number"));
29550
29551 p_start = js_ctx->p;
29552
29553 /* First pass parse is very lenient (e.g. allows '1.2.3') and extracts a
29554 * string for strict number parsing.
29555 */
29556
29557 p = js_ctx->p;
29558 for (;;) {
29559 x = *p;
29560
29561 DUK_DDD(DUK_DDDPRINT("parse_number: p_start=%p, p=%p, p_end=%p, x=%ld",
29562 (const void *) p_start, (const void *) p,
29563 (const void *) js_ctx->p_end, (long) x));
29564
29565#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH)
29566 /* This fast path is pretty marginal in practice.
29567 * XXX: candidate for removal.
29568 */
29569 DUK_ASSERT(duk__json_decnumber_lookup[0x00] == 0x00); /* end-of-input breaks */
29570 if (duk__json_decnumber_lookup[x] == 0) {
29571 break;
29572 }
29573#else /* DUK_USE_JSON_DECNUMBER_FASTPATH */
29574 if (!((x >= DUK_ASC_0 && x <= DUK_ASC_9) ||
29575 (x == DUK_ASC_PERIOD || x == DUK_ASC_LC_E ||
29576 x == DUK_ASC_UC_E || x == DUK_ASC_MINUS || x == DUK_ASC_PLUS))) {
29577 /* Plus sign must be accepted for positive exponents
29578 * (e.g. '1.5e+2'). This clause catches NULs.
29579 */
29580 break;
29581 }
29582#endif /* DUK_USE_JSON_DECNUMBER_FASTPATH */
29583 p++; /* safe, because matched (NUL causes a break) */
29584 }
29585 js_ctx->p = p;
29586
29587 DUK_ASSERT(js_ctx->p > p_start);
29588 duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (p - p_start));
DUK_LOCAL_DECL void duk__dec_number(duk_json_dec_ctx *js_ctx)
#define DUK_ASC_9
DUK_EXTERNAL const char * duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len)
#define DUK_ASC_MINUS
#define DUK_ASC_PLUS
DUK_LOCAL const duk_uint8_t duk__json_decnumber_lookup[256]
#define DUK_ASC_0
#define DUK_ASC_LC_E
#define DUK_ASC_PERIOD
#define DUK_ASC_UC_E

◆ duk__dec_objarr_entry()

DUK_LOCAL_DECL void duk__dec_objarr_entry ( duk_json_dec_ctx * js_ctx)

Definition at line 29590 of file duktape-1.5.2/src/duktape.c.

29594 : string before parsing: %!T",
29595 (duk_tval *) duk_get_tval(ctx, -1)));
29596 duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags);
29597 if (duk_is_nan(ctx, -1)) {
29598 duk__dec_syntax_error(js_ctx);
29599 }
29600 DUK_ASSERT(duk_is_number(ctx, -1));
29601 DUK_DDD(DUK_DDDPRINT("parse_number: final number: %!T",
29602 (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 29604 of file duktape-1.5.2/src/duktape.c.

29607 {
29608 duk_context *ctx = (duk_context *) js_ctx->thr;
29610
DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra)
#define DUK_JSON_DEC_REQSTACK

◆ duk__dec_object()

DUK_LOCAL_DECL void duk__dec_object ( duk_json_dec_ctx * js_ctx)

Definition at line 29612 of file duktape-1.5.2/src/duktape.c.

29615 {
29617 }
29618 js_ctx->recursion_depth++;
29619}
29620
29622 /* c recursion check */
29623
29624 DUK_ASSERT(js_ctx->recursion_depth > 0);
29625 DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
29626 js_ctx->recursion_depth--;
29627}
29628
29630 duk_context *ctx = (duk_context *) js_ctx->thr;
29631 duk_int_t key_count; /* XXX: a "first" flag would suffice */
29632 duk_uint8_t x;
29633
29634 DUK_DDD(DUK_DDDPRINT("parse_object"));
29635
29636 duk__dec_objarr_entry(js_ctx);
29637
29638 duk_push_object(ctx);
29639
29640 /* Initial '{' has been checked and eaten by caller. */
29641
29642 key_count = 0;
29643 for (;;) {
29644 x = duk__dec_get_nonwhite(js_ctx);
29645
29646 DUK_DDD(DUK_DDDPRINT("parse_object: obj=%!T, x=%ld, key_count=%ld",
29647 (duk_tval *) duk_get_tval(ctx, -1),
29648 (long) x, (long) key_count));
29649
29650 /* handle comma and closing brace */
29651
29652 if (x == DUK_ASC_COMMA && key_count > 0) {
29653 /* accept comma, expect new value */
29654 x = duk__dec_get_nonwhite(js_ctx);
29655 } else if (x == DUK_ASC_RCURLY) {
29656 /* eat closing brace */
29657 break;
29658 } else if (key_count == 0) {
29659 /* accept anything, expect first value (EOF will be
29660 * caught by key parsing below.
29661 */
29662 ;
29663 } else {
29664 /* catches EOF (NUL) and initial comma */
29665 goto syntax_error;
29666 }
29667
29668 /* parse key and value */
29669
29670 if (x == DUK_ASC_DOUBLEQUOTE) {
29671 duk__dec_string(js_ctx);
29672#ifdef DUK_USE_JX
29673 } else if (js_ctx->flag_ext_custom &&
29675 duk__dec_plain_string(js_ctx);
29676#endif
29677 } else {
29678 goto syntax_error;
29679 }
29680
29681 /* [ ... obj key ] */
29682
29683 x = duk__dec_get_nonwhite(js_ctx);
29684 if (x != DUK_ASC_COLON) {
29685 goto syntax_error;
29686 }
29687
29688 duk__dec_value(js_ctx);
29689
29690 /* [ ... obj key val ] */
29691
29692 duk_xdef_prop_wec(ctx, -3);
29693
#define DUK_ASC_DOUBLEQUOTE
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp)
DUK_LOCAL_DECL void duk__dec_object(duk_json_dec_ctx *js_ctx)
#define DUK_ASC_COLON
#define DUK_STR_JSONDEC_RECLIMIT
DUK_EXTERNAL duk_idx_t duk_push_object(duk_context *ctx)
DUK_LOCAL_DECL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx)
#define DUK_ASC_RCURLY
DUK_LOCAL_DECL void duk__dec_string(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_objarr_entry(duk_json_dec_ctx *js_ctx)
#define DUK_ASC_COMMA
DUK_LOCAL_DECL void duk__dec_value(duk_json_dec_ctx *js_ctx)

◆ duk__dec_peek()

DUK_LOCAL_DECL duk_uint8_t duk__dec_peek ( duk_json_dec_ctx * js_ctx)

Definition at line 29124 of file duktape-1.5.2/src/duktape.c.

29125 {
29126 break;
29127 }

◆ duk__dec_plain_string()

DUK_LOCAL_DECL void duk__dec_plain_string ( duk_json_dec_ctx * js_ctx)

Definition at line 29370 of file duktape-1.5.2/src/duktape.c.

29378 :
29379 duk__dec_syntax_error(js_ctx);
29381}
29382
29383#ifdef DUK_USE_JX
29384/* Decode a plain string consisting entirely of identifier characters.
29385 * Used to parse plain keys (e.g. "foo: 123").
29386 */
29388 duk_hthread *thr = js_ctx->thr;
29389 duk_context *ctx = (duk_context *) thr;
29390 const duk_uint8_t *p;
29392
29393 /* Caller has already eaten the first char so backtrack one byte. */
29394
29395 js_ctx->p--; /* safe */
29396 p = js_ctx->p;
29397
29398 /* Here again we parse bytes, and non-ASCII UTF-8 will cause end of
29399 * parsing (which is correct except if there are non-shortest encodings).
29400 * There is also no need to check explicitly for end of input buffer as
29401 * the input is NUL padded and NUL will exit the parsing loop.
29402 *
29403 * Because no unescaping takes place, we can just scan to the end of the
29404 * plain string and intern from the input buffer.
29405 */
29406
29407 for (;;) {
29408 x = *p;
29409

◆ duk__dec_pointer()

DUK_LOCAL_DECL void duk__dec_pointer ( duk_json_dec_ctx * js_ctx)

Definition at line 29413 of file duktape-1.5.2/src/duktape.c.

29416 {
29417 break;
29418 }
29419 p++;
29420 }
29421
29422 duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p));
29423 js_ctx->p = p;
29424
29425 /* [ ... str ] */
29426}
29427#endif /* DUK_USE_JX */
29428
29429#ifdef DUK_USE_JX
29431 duk_hthread *thr = js_ctx->thr;
29432 duk_context *ctx = (duk_context *) thr;
29433 const duk_uint8_t *p;
29435 void *voidptr;
29436
29437 /* Caller has already eaten the first character ('(') which we don't need. */
29438
29439 p = js_ctx->p;
29440
29441 for (;;) {
29442 x = *p;
29443
29444 /* Assume that the native representation never contains a closing
29445 * parenthesis.
29446 */
29447
29448 if (x == DUK_ASC_RPAREN) {
29449 break;
29450 } else if (x <= 0) {
29451 /* NUL term or -1 (EOF), NUL check would suffice */
29452 goto syntax_error;
29453 }
29454 p++;
29455 }
29456
29457 /* There is no need to NUL delimit the sscanf() call: trailing garbage is
29458 * ignored and there is always a NUL terminator which will force an error
29459 * if no error is encountered before it. It's possible that the scan
29460 * would scan further than between [js_ctx->p,p[ though and we'd advance
29461 * by less than the scanned value.
29462 *
29463 * Because pointers are platform specific, a failure to scan a pointer
DUK_LOCAL_DECL void duk__dec_pointer(duk_json_dec_ctx *js_ctx)
#define DUK_ASC_RPAREN

◆ 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 29173 of file duktape-1.5.2/src/duktape.c.

29173 {
29174 res = (res * 16) + t;
29175 } else {
29176 /* catches EOF and invalid digits */
29177 goto syntax_error;
29178 }
29179 }
29180
29181 DUK_DDD(DUK_DDDPRINT("final hex decoded value: %ld", (long) res));
29182 return res;
29183
29184 syntax_error:
29185 duk__dec_syntax_error(js_ctx);
29187 return 0;
29188}
29189
29191 duk_hstring *h;
29192 const duk_uint8_t *p;
29193 duk_uint8_t x, y;
29194
29195 /* First character has already been eaten and checked by the caller.
29196 * We can scan until a NUL in stridx string because no built-in strings
29197 * have internal NULs.
29198 */
29199
29200 DUK_ASSERT_DISABLE(stridx >= 0); /* unsigned */
29202 h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx);
29203 DUK_ASSERT(h != NULL);
29204
29205 p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h) + 1;
29206 DUK_ASSERT(*(js_ctx->p - 1) == *(p - 1)); /* first character has been matched */
29207
29208 for (;;) {
29209 x = *p;
#define DUK_HEAP_NUM_STRINGS
#define DUK_HTHREAD_GET_STRING(thr, idx)
DUK_LOCAL_DECL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx)

◆ duk__dec_reviver_walk()

DUK_LOCAL_DECL void duk__dec_reviver_walk ( duk_json_dec_ctx * js_ctx)

Definition at line 29835 of file duktape-1.5.2/src/duktape.c.

29843 :
29844 duk__dec_syntax_error(js_ctx);
29846}
29847
29848/* Recursive value reviver, implements the Walk() algorithm. No C recursion
29849 * check is done here because the initial parsing step will already ensure
29850 * there is a reasonable limit on C recursion depth and hence object depth.
29851 */
29853 duk_context *ctx = (duk_context *) js_ctx->thr;
29854 duk_hobject *h;
29855 duk_uarridx_t i, arr_len;
29856
29857 DUK_DDD(DUK_DDDPRINT("walk: top=%ld, holder=%!T, name=%!T",
29858 (long) duk_get_top(ctx),
29859 (duk_tval *) duk_get_tval(ctx, -2),
29860 (duk_tval *) duk_get_tval(ctx, -1)));
29861
29862 duk_dup_top(ctx);
29863 duk_get_prop(ctx, -3); /* -> [ ... holder name val ] */
29864
29865 h = duk_get_hobject(ctx, -1);
29866 if (h != NULL) {
29868 arr_len = (duk_uarridx_t) duk_get_length(ctx, -1);
29869 for (i = 0; i < arr_len; i++) {
29870 /* [ ... holder name val ] */
29871
29872 DUK_DDD(DUK_DDDPRINT("walk: array, top=%ld, i=%ld, arr_len=%ld, holder=%!T, name=%!T, val=%!T",
29873 (long) duk_get_top(ctx), (long) i, (long) arr_len,
29874 (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
29875 (duk_tval *) duk_get_tval(ctx, -1)));
29876
29877 /* XXX: push_uint_string / push_u32_string */
29878 duk_dup_top(ctx);
29879 duk_push_uint(ctx, (duk_uint_t) i);
29880 duk_to_string(ctx, -1); /* -> [ ... holder name val val ToString(i) ] */
29881 duk__dec_reviver_walk(js_ctx); /* -> [ ... holder name val new_elem ] */
29882
29883 if (duk_is_undefined(ctx, -1)) {
29884 duk_pop(ctx);
29885 duk_del_prop_index(ctx, -1, i);
29886 } else {
29887 /* XXX: duk_xdef_prop_index_wec() would be more appropriate
29888 * here but it currently makes some assumptions that might
29889 * not hold (e.g. that previous property is not an accessor).
29890 */
29891 duk_put_prop_index(ctx, -2, i);
29892 }
29893 }
29894 } else {
29895 /* [ ... holder name val ] */
29896 duk_enum(ctx, -1, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/);
29897 while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) {
29898 DUK_DDD(DUK_DDDPRINT("walk: object, top=%ld, holder=%!T, name=%!T, val=%!T, enum=%!iT, obj_key=%!T",
29899 (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -5),
29900 (duk_tval *) duk_get_tval(ctx, -4), (duk_tval *) duk_get_tval(ctx, -3),
29901 (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
29902
29903 /* [ ... holder name val enum obj_key ] */
29904 duk_dup(ctx, -3);
29905 duk_dup(ctx, -2);
29906
29907 /* [ ... holder name val enum obj_key val obj_key ] */
29908 duk__dec_reviver_walk(js_ctx);
29909
29910 /* [ ... holder name val enum obj_key new_elem ] */
29911 if (duk_is_undefined(ctx, -1)) {
29912 duk_pop(ctx);
29913 duk_del_prop(ctx, -3);
29914 } else {
29915 /* XXX: duk_xdef_prop_index_wec() would be more appropriate
29916 * here but it currently makes some assumptions that might
29917 * not hold (e.g. that previous property is not an accessor).
29918 *
29919 * Using duk_put_prop() works incorrectly with '__proto__'
29920 * if the own property with that name has been deleted. This
29921 * does not happen normally, but a clever reviver can trigger
29922 * that, see complex reviver case in: test-bug-json-parse-__proto__.js.
#define DUK_ENUM_OWN_PROPERTIES_ONLY
DUK_EXTERNAL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags)
DUK_EXTERNAL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)
DUK_LOCAL_DECL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx)
DUK_EXTERNAL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value)
DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index)
#define DUK_HOBJECT_CLASS_ARRAY
DUK_EXTERNAL void duk_dup_top(duk_context *ctx)
DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index)
DUK_EXTERNAL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index)

◆ duk__dec_string()

DUK_LOCAL_DECL void duk__dec_string ( duk_json_dec_ctx * js_ctx)

Definition at line 29260 of file duktape-1.5.2/src/duktape.c.

29261 {
29262 return 1; /* syntax error */
29263 }
29264 break;
29265 }
29266#endif /* DUK_USE_JX */
29267 default:
29268 /* catches EOF (0x00) */
29269 return 1; /* syntax error */
29270 }
29271
29272 DUK_RAW_WRITE_XUTF8(*ext_p, cp);
29273
29274 return 0;
29275}
29276
29278 duk_hthread *thr = js_ctx->thr;
29279 duk_context *ctx = (duk_context *) thr;
29280 duk_bufwriter_ctx bw_alloc;
29282 duk_uint8_t *q;
29283
29284 /* '"' was eaten by caller */
29285
29286 /* Note that we currently parse -bytes-, not codepoints.
29287 * All non-ASCII extended UTF-8 will encode to bytes >= 0x80,
29288 * so they'll simply pass through (valid UTF-8 or not).
29289 */
29290
29291 bw = &bw_alloc;
29293 q = DUK_BW_GET_PTR(js_ctx->thr, bw);
29294
29295#if defined(DUK_USE_JSON_DECSTRING_FASTPATH)
29296 for (;;) {
29297 duk_small_uint_t safe;
29298 duk_uint8_t b, x;
29299 const duk_uint8_t *p;
29300
29301 /* Select a safe loop count where no output checks are
29302 * needed assuming we won't encounter escapes. Input
29303 * bound checks are not necessary as a NUL (guaranteed)
29304 * will cause a SyntaxError before we read out of bounds.
29305 */
29306
29308
29309 /* Ensure space for 1:1 output plus one escape. */
29310 q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, safe + DUK_UNICODE_MAX_XUTF8_LENGTH, q);
29311
29312 p = js_ctx->p; /* temp copy, write back for next loop */
29313 for (;;) {
29314 if (safe == 0) {
29315 js_ctx->p = p;
29316 break;
29317 }
29318 safe--;
29319
29320 /* End of input (NUL) goes through slow path and causes SyntaxError. */
29322
29323 b = *p++;
29325 if (DUK_LIKELY(x != 0)) {
29326 /* Fast path, decode as is. */
29327 *q++ = b;
29328 } else if (b == DUK_ASC_DOUBLEQUOTE) {
29329 js_ctx->p = p;
29330 goto found_quote;
29331 } else if (b == DUK_ASC_BACKSLASH) {
29332 /* We've ensured space for one escaped input; then
29333 * bail out and recheck (this makes escape handling
29334 * quite slow but it's uncommon).
29335 */
29336 js_ctx->p = p;
29337 if (duk__dec_string_escape(js_ctx, &q) != 0) {
29338 goto syntax_error;
29339 }
29340 break;
29341 } else {
29342 js_ctx->p = p;
29343 goto syntax_error;
29344 }
29345 }
29346 }
29347 found_quote:
29348#else /* DUK_USE_JSON_DECSTRING_FASTPATH */
29349 for (;;) {
29350 duk_uint8_t x;
29351
29353
29354 x = duk__dec_get(js_ctx);
29355
29356 if (x == DUK_ASC_DOUBLEQUOTE) {
29357 break;
29358 } else if (x == DUK_ASC_BACKSLASH) {
29359 if (duk__dec_string_escape(js_ctx, &q) != 0) {
29360 goto syntax_error;
29361 }
29362 } else if (x < 0x20) {
29363 /* catches EOF (NUL) */
29364 goto syntax_error;
DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256]
#define DUK__JSON_DECSTR_CHUNKSIZE
#define DUK__JSON_DECSTR_BUFSIZE
DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_uint8_t **ext_p)
#define DUK_ASC_BACKSLASH
#define DUK_BW_ENSURE_RAW(thr, bw_ctx, sz, ptr)
#define DUK_BW_INIT_PUSHBUF(thr, bw_ctx, sz)
#define DUK_BW_GET_PTR(thr, bw_ctx)
#define DUK_RAW_WRITE_XUTF8(ptr, val)

◆ 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 29211 of file duktape-1.5.2/src/duktape.c.

29214 {
29215 /* Catches EOF of JSON input. */
29216 goto syntax_error;
29217 }
29218 p++;
29219 }
29220
29221 return;
29222
29223 syntax_error:
29224 duk__dec_syntax_error(js_ctx);
29226}
29227
29230
29231 /* EOF (-1) will be cast to an unsigned value first
29232 * and then re-cast for the switch. In any case, it
29233 * will match the default case (syntax error).
29234 */
29235 cp = (duk_uint_fast32_t) duk__dec_get(js_ctx);
29236 switch ((int) cp) {
29237 case DUK_ASC_BACKSLASH: break;
29238 case DUK_ASC_DOUBLEQUOTE: break;
29239 case DUK_ASC_SLASH: break;
29240 case DUK_ASC_LC_T: cp = 0x09; break;
29241 case DUK_ASC_LC_N: cp = 0x0a; break;
29242 case DUK_ASC_LC_R: cp = 0x0d; break;
29243 case DUK_ASC_LC_F: cp = 0x0c; break;
29244 case DUK_ASC_LC_B: cp = 0x08; break;
29245 case DUK_ASC_LC_U: {
29246 cp = duk__dec_decode_hex_escape(js_ctx, 4);
29247 break;
29248 }
29249#ifdef DUK_USE_JX
29250 case DUK_ASC_UC_U: {
29251 if (js_ctx->flag_ext_custom) {
29252 cp = duk__dec_decode_hex_escape(js_ctx, 8);
29253 } else {
29254 return 1; /* syntax error */
29255 }
29256 break;
29257 }
29258 case DUK_ASC_LC_X: {
#define DUK_ASC_SLASH
#define DUK_ASC_LC_N
#define DUK_ASC_LC_U
#define DUK_ASC_LC_X
#define DUK_ASC_LC_B
#define DUK_ASC_LC_R
#define DUK_ASC_LC_F
#define DUK_ASC_UC_U
#define DUK_ASC_LC_T

◆ duk__dec_syntax_error()

DUK_LOCAL_DECL void duk__dec_syntax_error ( duk_json_dec_ctx * js_ctx)

Definition at line 29085 of file duktape-1.5.2/src/duktape.c.

◆ duk__dec_value()

DUK_LOCAL_DECL void duk__dec_value ( duk_json_dec_ctx * js_ctx)

Definition at line 29763 of file duktape-1.5.2/src/duktape.c.

29769 : final array is %!T",
29770 (duk_tval *) duk_get_tval(ctx, -1)));
29771
29772 duk__dec_objarr_exit(js_ctx);
29773 return;
29774
29775 syntax_error:
29776 duk__dec_syntax_error(js_ctx);
29777 DUK_UNREACHABLE();
29778}
29779
29780DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) {
29781 duk_context *ctx = (duk_context *) js_ctx->thr;
29782 duk_uint8_t x;
29783
29784 x = duk__dec_get_nonwhite(js_ctx);
29785
29786 DUK_DDD(DUK_DDDPRINT("parse_value: initial x=%ld", (long) x));
29787
29788 /* Note: duk__dec_req_stridx() backtracks one char */
29789
29790 if (x == DUK_ASC_DOUBLEQUOTE) {
29791 duk__dec_string(js_ctx);
29792 } else if ((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_MINUS)) {
29793#ifdef DUK_USE_JX
29794 if (js_ctx->flag_ext_custom && x == DUK_ASC_MINUS && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) {
29795 duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY); /* "-Infinity", '-' has been eaten */
29796 duk_push_number(ctx, -DUK_DOUBLE_INFINITY);
29797 } else {
29798#else
29799 { /* unconditional block */
29800#endif
29801 /* We already ate 'x', so backup one byte. */
29802 js_ctx->p--; /* safe */
29803 duk__dec_number(js_ctx);
29804 }
29805 } else if (x == DUK_ASC_LC_T) {
29806 duk__dec_req_stridx(js_ctx, DUK_STRIDX_TRUE);
29807 duk_push_true(ctx);
29808 } else if (x == DUK_ASC_LC_F) {
29809 duk__dec_req_stridx(js_ctx, DUK_STRIDX_FALSE);
29810 duk_push_false(ctx);
29811 } else if (x == DUK_ASC_LC_N) {
29812 duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_NULL);
29813 duk_push_null(ctx);
29814#ifdef DUK_USE_JX
29815 } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LC_U) {
29816 duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_UNDEFINED);
29817 duk_push_undefined(ctx);
29818 } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_N) {
29819 duk__dec_req_stridx(js_ctx, DUK_STRIDX_NAN);
29820 duk_push_nan(ctx);
29821 } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_I) {
29822 duk__dec_req_stridx(js_ctx, DUK_STRIDX_INFINITY);
29823 duk_push_number(ctx, DUK_DOUBLE_INFINITY);
29824 } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LPAREN) {
29825 duk__dec_pointer(js_ctx);
29826 } else if (js_ctx->flag_ext_custom && x == DUK_ASC_PIPE) {
29827 duk__dec_buffer(js_ctx);
29828#endif
29829 } 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 72765 of file duktape-1.5.2/src/duktape.c.

72787 {
72788 duk_context *ctx = (duk_context *) thr;
72789 duk_hobject *holder;
72790 duk_bool_t parents;
72792 duk_tval *tv;
72793
72794 DUK_DDD(DUK_DDDPRINT("declvar: thr=%p, env=%p, name=%!O, val=%!T, prop_flags=0x%08lx, is_func_decl=%ld "
72795 "(env -> %!iO)",
72796 (void *) thr, (void *) env, (duk_heaphdr *) name,
72797 (duk_tval *) val, (unsigned long) prop_flags,
72798 (unsigned int) is_func_decl, (duk_heaphdr *) env));
72799
72800 DUK_ASSERT(thr != NULL);
72801 DUK_ASSERT(env != NULL);
72802 DUK_ASSERT(name != NULL);
72803 DUK_ASSERT(val != NULL);
72804
72805 /* Note: in strict mode the compiler should reject explicit
72806 * declaration of 'eval' or 'arguments'. However, internal
72807 * bytecode may declare 'arguments' in the function prologue.
72808 * We don't bother checking (or asserting) for these now.
72809 */
72810
72811 /* Note: val is a stable duk_tval pointer. The caller makes
72812 * a value copy into its stack frame, so 'tv_val' is not subject
72813 * to side effects here.
72814 */
72815
72816 /*
72817 * Check whether already declared.
72818 *
72819 * We need to check whether the binding exists in the environment
72820 * without walking its parents. However, we still need to check
72821 * register-bound identifiers and the prototype chain of an object
72822 * environment target object.
72823 */
72824
72825 parents = 0; /* just check 'env' */
72826 if (duk__get_identifier_reference(thr, env, name, NULL, parents, &ref)) {
72827 duk_int_t e_idx;
72828 duk_int_t h_idx;
72829 duk_small_int_t flags;
72830
72831 /*
72832 * Variable already declared, ignore re-declaration.
72833 * The only exception is the updated behavior of E5.1 for
72834 * global function declarations, E5.1 Section 10.5, step 5.e.
72835 * This behavior does not apply to global variable declarations.
72836 */
72837
72838 if (!(is_func_decl && env == thr->builtins[DUK_BIDX_GLOBAL_ENV])) {
72839 DUK_DDD(DUK_DDDPRINT("re-declare a binding, ignoring"));
72840 return 1; /* 1 -> needs a PUTVAR */
72841 }
72842
72843 /*
72844 * Special behavior in E5.1.
72845 *
72846 * Note that even though parents == 0, the conflicting property
72847 * may be an inherited property (currently our global object's
72848 * prototype is Object.prototype). Step 5.e first operates on
72849 * the existing property (which is potentially in an ancestor)
72850 * and then defines a new property in the global object (and
72851 * never modifies the ancestor).
72852 *
72853 * Also note that this logic would become even more complicated
72854 * if the conflicting property might be a virtual one. Object
72855 * prototype has no virtual properties, though.
72856 *
72857 * XXX: this is now very awkward, rework.
72858 */
72859
72860 DUK_DDD(DUK_DDDPRINT("re-declare a function binding in global object, "
72861 "updated E5.1 processing"));
72862
72863 DUK_ASSERT(ref.holder != NULL);
72864 holder = ref.holder;
72865
72866 /* holder will be set to the target object, not the actual object
72867 * where the property was found (see duk__get_identifier_reference()).
72868 */
72870 DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(holder)); /* global object doesn't have array part */
72871
72872 /* XXX: use a helper for prototype traversal; no loop check here */
72873 /* must be found: was found earlier, and cannot be inherited */
72874 for (;;) {
72875 DUK_ASSERT(holder != NULL);
72876 duk_hobject_find_existing_entry(thr->heap, holder, name, &e_idx, &h_idx);
72877 if (e_idx >= 0) {
72878 break;
72879 }
72880 /* SCANBUILD: NULL pointer dereference, doesn't actually trigger,
72881 * asserted above.
72882 */
72883 holder = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, holder);
72884 }
72885 DUK_ASSERT(holder != NULL);
72886 DUK_ASSERT(e_idx >= 0);
72887 /* SCANBUILD: scan-build produces a NULL pointer dereference warning
72888 * below; it never actually triggers because holder is actually never
72889 * NULL.
72890 */
72891
72892 /* ref.holder is global object, holder is the object with the
72893 * conflicting property.
72894 */
72895
72896 flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, holder, e_idx);
72897 if (!(flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
72898 if (flags & DUK_PROPDESC_FLAG_ACCESSOR) {
72899 DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable "
72900 "accessor -> reject"));
72901 goto fail_existing_attributes;
72902 }
72903 if (!((flags & DUK_PROPDESC_FLAG_WRITABLE) &&
72904 (flags & DUK_PROPDESC_FLAG_ENUMERABLE))) {
72905 DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable "
72906 "plain property which is not writable and "
72907 "enumerable -> reject"));
72908 goto fail_existing_attributes;
72909 }
72910
72911 DUK_DDD(DUK_DDDPRINT("existing property is not configurable but "
72912 "is plain, enumerable, and writable -> "
72913 "allow redeclaration"));
72914 }
72915
72916 if (holder == ref.holder) {
72917 /* XXX: if duk_hobject_define_property_internal() was updated
72918 * to handle a pre-existing accessor property, this would be
72919 * a simple call (like for the ancestor case).
72920 */
72921 DUK_DDD(DUK_DDDPRINT("redefine, offending property in global object itself"));
72922
72923 if (flags & DUK_PROPDESC_FLAG_ACCESSOR) {
72924 duk_hobject *tmp;
72925
72926 tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, holder, e_idx);
72927 DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, holder, e_idx, NULL);
72929 DUK_UNREF(tmp);
72930 tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, holder, e_idx);
72931 DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, holder, e_idx, NULL);
72933 DUK_UNREF(tmp);
72934 } else {
72935 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx);
72937 }
72938
72939 /* Here val would be potentially invalid if we didn't make
72940 * a value copy at the caller.
72941 */
72942
72943 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx);
72944 DUK_TVAL_SET_TVAL(tv, val);
72945 DUK_TVAL_INCREF(thr, tv);
72946 DUK_HOBJECT_E_SET_FLAGS(thr->heap, holder, e_idx, prop_flags);
72947
72948 DUK_DDD(DUK_DDDPRINT("updated global binding, final result: "
72949 "value -> %!T, prop_flags=0x%08lx",
72950 (duk_tval *) DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx),
72951 (unsigned long) prop_flags));
72952 } else {
72953 DUK_DDD(DUK_DDDPRINT("redefine, offending property in ancestor"));
72954
72955 DUK_ASSERT(ref.holder == thr->builtins[DUK_BIDX_GLOBAL]);
72956 duk_push_tval(ctx, val);
72957 duk_hobject_define_property_internal(thr, ref.holder, name, prop_flags);
72958 }
72959
72960 return 0;
72961 }
72962
72963 /*
72964 * Not found (in registers or record objects). Declare
72965 * to current variable environment.
72966 */
72967
72968 /*
72969 * Get holder object
72970 */
72971
72972 if (DUK_HOBJECT_IS_DECENV(env)) {
72973 holder = env;
72974 } else {
72976
72978 DUK_ASSERT(tv != NULL);
72980 holder = DUK_TVAL_GET_OBJECT(tv);
72981 DUK_ASSERT(holder != NULL);
72982 }
72983
72984 /*
72985 * Define new property
72986 *
72987 * Note: this may fail if the holder is not extensible.
72988 */
72989
72990 /* XXX: this is awkward as we use an internal method which doesn't handle
72991 * extensibility etc correctly. Basically we'd want to do a [[DefineOwnProperty]]
72992 * or Object.defineProperty() here.
72993 */
72994
#define DUK_HOBJECT_DECREF_ALLOWNULL(thr, h)
#define DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)
#define DUK_HOBJECT_GET_PROTOTYPE(heap, h)
#define DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, h, i)
#define DUK_HOBJECT_IS_OBJENV(h)
#define DUK_HTHREAD_STRING_INT_TARGET(thr)
#define DUK_HOBJECT_E_GET_VALUE_SETTER(heap, h, i)
DUK_INTERNAL_DECL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags)
#define DUK_BIDX_GLOBAL_ENV
#define DUK_HOBJECT_CLASS_GLOBAL
#define DUK_HOBJECT_E_SET_VALUE_SETTER(heap, h, i, v)
#define DUK_HOBJECT_E_SET_FLAGS(heap, h, i, f)
#define DUK_HOBJECT_IS_DECENV(h)
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)
#define DUK_HOBJECT_E_SET_VALUE_GETTER(heap, h, i, v)
#define DUK_TVAL_SET_UNDEFINED_UPDREF
#define DUK_HOBJECT_E_GET_VALUE_GETTER(heap, h, i)
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)

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 27696 of file duktape-1.5.2/src/duktape.c.

27701 {
27702 duk_hthread *thr;
27703 duk_hstring *h_str;
27705 const duk_uint8_t *p;
27706 const duk_uint8_t *p_start;
27707 const duk_uint8_t *p_end;
27709
27710typedef void (*duk__transform_callback)(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp);
27711
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 73653 of file duktape-1.5.2/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 73659 of file duktape-1.5.2/src/duktape.c.

73663 {
73664 if (DUK_LIKELY(x >= 0 && x <= 0xff)) {
73665 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 16703 of file duktape-1.5.2/src/duktape.c.

16703 {
16704 return;
16705 }
16706
16707 duk_hobject_set_length(thr, h, (duk_uint32_t) length); /* XXX: typing */
16708}
16709
16710/*
16711 * Conversions and coercions
16712 *
16713 * The conversion/coercions are in-place operations on the value stack.
16714 * Some operations are implemented here directly, while others call a
16715 * helper in duk_js_ops.c after validating arguments.
16716 */
16717
16718/* E5 Section 8.12.8 */
DUK_INTERNAL_DECL void duk_hobject_set_length(duk_hthread *thr, duk_hobject *obj, duk_uint32_t length)

◆ 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 72651 of file duktape-1.5.2/src/duktape.c.

72651 :
72652 * 11.4.1 The delete operator
72653 * 10.2.1.1.5 DeleteBinding (N) [declarative environment record]
72654 * 10.2.1.2.5 DeleteBinding (N) [object environment record]
72655 *
72656 * Variable bindings established inside eval() are deletable (configurable),
72657 * other bindings are not, including variables declared in global level.
72658 * Registers are always non-deletable, and the deletion of other bindings
72659 * is controlled by the configurable flag.
72660 *
72661 * For strict mode code, the 'delete' operator should fail with a compile
72662 * time SyntaxError if applied to identifiers. Hence, no strict mode
72663 * run-time deletion of identifiers should ever happen. This function
72664 * should never be called from strict mode code!
72665 */
72666
72669 duk_hobject *env,
72670 duk_activation *act,
72671 duk_hstring *name) {
72673 duk_bool_t parents;
72674
72675 DUK_DDD(DUK_DDDPRINT("delvar: thr=%p, env=%p, act=%p, name=%!O "
72676 "(env -> %!dO)",
72677 (void *) thr, (void *) env, (void *) act,
72678 (duk_heaphdr *) name, (duk_heaphdr *) env));
72679
72680 DUK_ASSERT(thr != NULL);
72681 DUK_ASSERT(name != NULL);
72682 /* env and act may be NULL */
72683
72685
72686 parents = 1; /* follow parent chain */
72687
72688 if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
72689 if (ref.value && !(ref.attrs & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
72690 /* Identifier found in registers (always non-deletable)
72691 * or declarative environment record and non-configurable.
72692 */
72693 return 0;
72694 }
72695 DUK_ASSERT(ref.holder != NULL);
#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h)
DUK_LOCAL duk_bool_t duk__delvar_helper(duk_hthread *thr, duk_hobject *env, duk_activation *act, duk_hstring *name)

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 24886 of file duktape-1.5.2/src/duktape.c.

24887 {
24888 if (!DUK_ISFINITE(x)) {
24889 return DUK_DOUBLE_NAN;
24890 }
24891
24893 return DUK_DOUBLE_NAN;
24894 }
24895
24897
DUK_INTERNAL_DECL duk_double_t duk_js_tointeger_number(duk_double_t x)
DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_valid_range(duk_double_t 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 13627 of file duktape-1.5.2/src/duktape.c.

13628 {
13629 duk_call_method(ctx, 0);
13630 rc = DUK_EXEC_SUCCESS;
13631 }
13632
13633 /* [ ... result/error ] */
13634
13635 got_rc:
13636 if (flags & DUK_COMPILE_NORESULT) {
13637 duk_pop(ctx);
13638 }
13639
13640 return rc;
13641}
13642
13643/* Helper which can be called both directly and with duk_safe_call(). */
13645 duk_hthread *thr = (duk_hthread *) ctx;
13646 duk__compile_raw_args *comp_args;
13647 duk_uint_t flags;
13648 duk_small_uint_t comp_flags;
13649 duk_hcompiledfunction *h_templ;
13650
13652
13653 /* Note: strictness is not inherited from the current Duktape/C
13654 * context. Otherwise it would not be possible to compile
13655 * non-strict code inside a Duktape/C activation (which is
13656 * always strict now). See tests/api/test-eval-strictness.c
13657 * for discussion.
13658 */
13659
13660 /* [ ... source? filename? &comp_args ] (depends on flags) */
13661
13662 comp_args = (duk__compile_raw_args *) duk_require_pointer(ctx, -1);
13663 flags = comp_args->flags;
13664 duk_pop(ctx);
13665
13666 /* [ ... source? filename? ] */
13667
13668 if (flags & DUK_COMPILE_NOFILENAME) {
13669 /* Automatic filename: 'eval' or 'input'. */
13671 }
13672
13673 /* [ ... source? filename ] */
13674
13675 if (!comp_args->src_buffer) {
13676 duk_hstring *h_sourcecode;
13677
13678 h_sourcecode = duk_get_hstring(ctx, -2);
13679 if ((flags & DUK_COMPILE_NOSOURCE) || /* args incorrect */
13680 (h_sourcecode == NULL)) { /* e.g. duk_push_string_file_raw() pushed undefined */
13681 /* XXX: when this error is caused by a nonexistent
13682 * file given to duk_peval_file() or similar, the
13683 * error message is not the best possible.
13684 */
13686 }
13687 DUK_ASSERT(h_sourcecode != NULL);
13688 comp_args->src_buffer = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode);
13689 comp_args->src_length = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode);
13690 }
13691 DUK_ASSERT(comp_args->src_buffer != NULL);
13692
13693 /* XXX: unnecessary translation of flags */
13694 comp_flags = 0;
13695 if (flags & DUK_COMPILE_EVAL) {
13696 comp_flags |= DUK_JS_COMPILE_FLAG_EVAL;
13697 }
13698 if (flags & DUK_COMPILE_FUNCTION) {
13699 comp_flags |= DUK_JS_COMPILE_FLAG_EVAL |
13701 }
13702 if (flags & DUK_COMPILE_STRICT) {
13703 comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
13704 }
13705
13706 /* [ ... source? filename ] */
13707
13708 duk_js_compile(thr, comp_args->src_buffer, comp_args->src_length, comp_flags);
13709
13710 /* [ ... source? func_template ] */
13711
13712 if (flags & DUK_COMPILE_NOSOURCE) {
13713 ;
13714 } else {
13715 duk_remove(ctx, -2);
#define DUK_COMPILE_NORESULT
#define DUK_COMPILE_FUNCTION
#define DUK_COMPILE_NOSOURCE
#define DUK_COMPILE_NOFILENAME
#define DUK_STR_NO_SOURCECODE
#define DUK_JS_COMPILE_FLAG_EVAL
DUK_EXTERNAL void * duk_require_pointer(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL duk_hstring * duk_get_hstring(duk_context *ctx, duk_idx_t index)
#define DUK_JS_COMPILE_FLAG_FUNCEXPR
#define DUK_STRIDX_EVAL
DUK_EXTERNAL void duk_call_method(duk_context *ctx, duk_idx_t nargs)
#define DUK_JS_COMPILE_FLAG_STRICT
#define DUK_STRIDX_INPUT
DUK_LOCAL duk_ret_t duk__do_compile(duk_context *ctx)
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__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 45587 of file duktape-1.5.2/src/duktape.c.

45604 {
45605 duk_hstring *res;
45606 const duk_uint8_t *extdata;
45607#if defined(DUK_USE_MARK_AND_SWEEP)
45608 duk_small_uint_t prev_mark_and_sweep_base_flags;
45609#endif
45610
45611 /* Prevent any side effects on the string table and the caller provided
45612 * str/blen arguments while interning is in progress. For example, if
45613 * the caller provided str/blen from a dynamic buffer, a finalizer might
45614 * resize that dynamic buffer, invalidating the call arguments.
45615 */
45616#if defined(DUK_USE_MARK_AND_SWEEP)
45618 prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
45620#endif
45621
45622#if defined(DUK_USE_STRTAB_PROBE)
45623 if (duk__recheck_strtab_size_probe(heap, heap->st_used + 1)) {
45624 goto failed;
45625 }
45626#endif
45627
45628 /* For manual testing only. */
45629#if 0
45630 {
45631 duk_size_t i;
45632 DUK_PRINTF("INTERN: \"");
45633 for (i = 0; i < blen; i++) {
45634 duk_uint8_t x = str[i];
45635 if (x >= 0x20 && x <= 0x7e && x != '"' && x != '\\') {
45636 DUK_PRINTF("%c", (int) x); /* char: use int cast */
45637 } else {
45638 DUK_PRINTF("\\x%02lx", (long) x);
45639 }
45640 }
45641 DUK_PRINTF("\"\n");
45642 }
45643#endif
45644
45645#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_INTERN_CHECK)
45646 extdata = (const duk_uint8_t *) DUK_USE_EXTSTR_INTERN_CHECK(heap->heap_udata, (void *) DUK_LOSE_CONST(str), (duk_size_t) blen);
45647#else
45648 extdata = (const duk_uint8_t *) NULL;
45649#endif
45650 res = duk__alloc_init_hstring(heap, str, blen, strhash, extdata);
45651 if (!res) {
45652 goto failed;
45653 }
45654
45655#if defined(DUK_USE_STRTAB_CHAIN)
45656 if (duk__insert_hstring_chain(heap, res)) {
45657 /* failed */
45658 DUK_FREE(heap, res);
45659 goto failed;
45660 }
45661#elif defined(DUK_USE_STRTAB_PROBE)
45662 /* guaranteed to succeed */
45664#if defined(DUK_USE_HEAPPTR16)
45665 heap->strtable16,
45666#else
45667 heap->strtable,
45668#endif
45669 heap->st_size,
45670 &heap->st_used,
45671 res);
45672#else
45673#error internal error, invalid strtab options
#define DUK_LOSE_CONST(src)
DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe(duk_heap *heap, duk_uint32_t new_used)
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__alloc_init_hstring(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash, const duk_uint8_t *extdata)
#define DUK_FREE(heap, ptr)
#define DUK__PREVENT_MS_SIDE_EFFECTS(heap)
duk_small_uint_t mark_and_sweep_base_flags

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 45675 of file duktape-1.5.2/src/duktape.c.

45681 :
45682#if defined(DUK_USE_MARK_AND_SWEEP)
45683 heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
45684#endif
45685 return res;
45686
45687 failed:
45688 res = NULL;
45689 goto done;
45690}
45691
45692DUK_LOCAL duk_hstring *duk__do_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t *out_strhash) {
45693 duk_hstring *res;
45694
45695 DUK_ASSERT(out_strhash);
45696
45697 *out_strhash = duk_heap_hashstring(heap, str, (duk_size_t) blen);
45698
45699#if defined(DUK_USE_ROM_STRINGS)
45700 {
45702 /* XXX: This is VERY inefficient now, and should be e.g. a
45703 * binary search or perfect hash, to be fixed.
45704 */
45705 for (i = 0; i < (duk_small_uint_t) (sizeof(duk_rom_strings) / sizeof(duk_hstring *)); i++) {
45706 duk_hstring *romstr;
45707 romstr = (duk_hstring *) DUK_LOSE_CONST(duk_rom_strings[i]);
45708 if (blen == DUK_HSTRING_GET_BYTELEN(romstr) &&
45709 DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(romstr), blen) == 0) {
45710 DUK_DD(DUK_DDPRINT("intern check: rom string: %!O, computed hash 0x%08lx, rom hash 0x%08lx",
45711 romstr, (unsigned long) *out_strhash, (unsigned long) DUK_HSTRING_GET_HASH(romstr)));
45712 DUK_ASSERT(*out_strhash == DUK_HSTRING_GET_HASH(romstr));
45713 *out_strhash = DUK_HSTRING_GET_HASH(romstr);
45714 return romstr;
45715 }
45716 }
45717 }
45718#endif /* DUK_USE_ROM_STRINGS */
45719
45720#if defined(DUK_USE_STRTAB_CHAIN)
45721 res = duk__find_matching_string_chain(heap, str, blen, *out_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_INTERNAL_DECL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len)

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 76298 of file duktape-1.5.2/src/duktape.c.

76299 : %ld", (long) t));
76300 if (++t < nc_ctx->B) {
76301 DUK_DDD(DUK_DDDPRINT("rounding carry terminated"));
76302 *p = (duk_uint8_t) t;
76303 break;
76304 }
76305
76306 DUK_DDD(DUK_DDDPRINT("wraps, carry to next digit"));
76307 }
76308 }
76309
76310 return ret;
76311}
76312
76313#define DUK__NO_EXP (65536) /* arbitrary marker, outside valid exp range */
76314
76315DUK_LOCAL void duk__dragon4_convert_and_push(duk__numconv_stringify_ctx *nc_ctx,
76316 duk_context *ctx,
76317 duk_small_int_t radix,
76318 duk_small_int_t digits,
76319 duk_small_uint_t flags,
76320 duk_small_int_t neg) {
76321 duk_small_int_t k;
76322 duk_small_int_t pos, pos_end;
76323 duk_small_int_t expt;
76324 duk_small_int_t dig;
76325 duk_uint8_t *q;
76326 duk_uint8_t *buf;
76327
76328 /*
76329 * The string conversion here incorporates all the necessary Ecmascript
76330 * semantics without attempting to be generic. nc_ctx->digits contains
76331 * nc_ctx->count digits (>= 1), with the topmost digit's 'position'
76332 * indicated by nc_ctx->k as follows:
76333 *
76334 * digits="123" count=3 k=0 --> 0.123
76335 * digits="123" count=3 k=1 --> 1.23
76336 * digits="123" count=3 k=5 --> 12300
76337 * digits="123" count=3 k=-1 --> 0.0123
76338 *
76339 * Note that the identifier names used for format selection are different
76340 * in Burger-Dybvig paper and Ecmascript specification (quite confusingly
76341 * so, because e.g. 'k' has a totally different meaning in each). See
76342 * documentation for discussion.
76343 *
76344 * Ecmascript doesn't specify any specific behavior for format selection
76345 * (e.g. when to use exponent notation) for non-base-10 numbers.
76346 *
76347 * The bigint space in the context is reused for string output, as there
76348 * is more than enough space for that (>1kB at the moment), and we avoid
76349 * allocating even more stack.
76350 */
76351
76352 DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= DUK__MAX_FORMATTED_LENGTH);
76353 DUK_ASSERT(nc_ctx->count >= 1);
76354
76355 k = nc_ctx->k;
76356 buf = (duk_uint8_t *) &nc_ctx->f; /* XXX: union would be more correct */
76357 q = buf;
76358
76359 /* Exponent handling: if exponent format is used, record exponent value and
76360 * fake k such that one leading digit is generated (e.g. digits=123 -> "1.23").
76361 *
76362 * toFixed() prevents exponent use; otherwise apply a set of criteria to
76363 * match the other API calls (toString(), toPrecision, etc).
76364 */
76365
76366 expt = DUK__NO_EXP;
76367 if (!nc_ctx->abs_pos /* toFixed() */) {
76368 if ((flags & DUK_N2S_FLAG_FORCE_EXP) || /* exponential notation forced */
76369 ((flags & DUK_N2S_FLAG_NO_ZERO_PAD) && /* fixed precision and zero padding would be required */
76370 (k - digits >= 1)) || /* (e.g. k=3, digits=2 -> "12X") */
76371 ((k > 21 || k <= -6) && (radix == 10))) { /* toString() conditions */
76372 DUK_DDD(DUK_DDDPRINT("use exponential notation: k=%ld -> expt=%ld",
76373 (long) k, (long) (k - 1)));
76374 expt = k - 1; /* e.g. 12.3 -> digits="123" k=2 -> 1.23e1 */
76375 k = 1; /* generate mantissa with a single leading whole number digit */
76376 }
76377 }
76378
76379 if (neg) {
76380 *q++ = '-';
76381 }
76382
76383 /* Start position (inclusive) and end position (exclusive) */
76384 pos = (k >= 1 ? k : 1);
76385 if (nc_ctx->is_fixed) {
76386 if (nc_ctx->abs_pos) {
76387 /* toFixed() */
76388 pos_end = -digits;
76389 } else {
76390 pos_end = k - digits;
76391 }
76392 } else {
76393 pos_end = k - nc_ctx->count;
76394 }
76395 if (pos_end > 0) {
76396 pos_end = 0;
76397 }
76398
76399 DUK_DDD(DUK_DDDPRINT("expt=%ld, k=%ld, count=%ld, pos=%ld, pos_end=%ld, is_fixed=%ld, "
76400 "digits=%ld, abs_pos=%ld",
76401 (long) expt, (long) k, (long) nc_ctx->count, (long) pos, (long) pos_end,
76402 (long) nc_ctx->is_fixed, (long) digits, (long) nc_ctx->abs_pos));
76403
76404 /* Digit generation */
76405 while (pos > pos_end) {
76406 DUK_DDD(DUK_DDDPRINT("digit generation: pos=%ld, pos_end=%ld",
76407 (long) pos, (long) pos_end));
76408 if (pos == 0) {
76409 *q++ = (duk_uint8_t) '.';
76410 }
76411 if (pos > k) {
76412 *q++ = (duk_uint8_t) '0';
76413 } else if (pos <= k - nc_ctx->count) {
76414 *q++ = (duk_uint8_t) '0';
76415 } else {
76416 dig = nc_ctx->digits[k - pos];
76417 DUK_ASSERT(dig >= 0 && dig < nc_ctx->B);
76418 *q++ = (duk_uint8_t) DUK__DIGITCHAR(dig);
76419 }
76420
76421 pos--;
76422 }
76423 DUK_ASSERT(pos <= 1);
76424
76425 /* Exponent */
76426 if (expt != DUK__NO_EXP) {
76427 /*
76428 * Exponent notation for non-base-10 numbers isn't specified in Ecmascript
76429 * specification, as it never explicitly turns up: non-decimal numbers can
76430 * only be formatted with Number.prototype.toString([radix]) and for that,
76431 * behavior is not explicitly specified.
76432 *
76433 * Logical choices include formatting the exponent as decimal (e.g. binary
76434 * 100000 as 1e+5) or in current radix (e.g. binary 100000 as 1e+101).
76435 * The Dragon4 algorithm (in the original paper) prints the exponent value
76436 * in the target radix B. However, for radix values 15 and above, the
76437 * exponent separator 'e' is no longer easily parseable. Consider, for
76438 * instance, the number "1.faecee+1c".
76439 */
76440
static int digit(int c)

◆ 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 76491 of file duktape-1.5.2/src/duktape.c.

76492 {
76493 /* denormal */
76494 expt = DUK__IEEE_DOUBLE_EXP_MIN - 52;
76495 duk__bi_normalize(&nc_ctx->f);
76496 } else {
76497 /* normal: implicit leading 1-bit */
76498 nc_ctx->f.v[1] |= 0x00100000UL;
76499 expt = expt - DUK__IEEE_DOUBLE_EXP_BIAS - 52;
76500 DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f)); /* true, because v[1] has at least one bit set */
76501 }
76502
76503 DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f));
76504
76505 nc_ctx->e = expt;
76506}
76507
76510 duk_small_int_t expt;
76512 duk_small_int_t bitstart;
76513 duk_small_int_t bitround;
76514 duk_small_int_t bitidx;
76515 duk_small_int_t skip_round;
76516 duk_uint32_t t, v;
76517
76518 DUK_ASSERT(nc_ctx->count == 53 + 1);
76519
76520 /* Sometimes this assert is not true right now; it will be true after
76521 * rounding. See: test-bug-numconv-mantissa-assert.js.
76522 */
76523 DUK_ASSERT_DISABLE(nc_ctx->digits[0] == 1); /* zero handled by caller */
76524
76525 /* Should not be required because the code below always sets both high
76526 * and low parts, but at least gcc-4.4.5 fails to deduce this correctly
76527 * (perhaps because the low part is set (seemingly) conditionally in a
76528 * loop), so this is here to avoid the bogus warning.
76529 */
76530 DUK_MEMZERO((void *) &u, sizeof(u));
76531
76532 /*
76533 * Figure out how generated digits match up with the mantissa,
76534 * and then perform rounding. If mantissa overflows, need to
76535 * recompute the exponent (it is bumped and may overflow to
76536 * infinity).
76537 *
76538 * For normal numbers the leading '1' is hidden and ignored,
76539 * and the last bit is used for rounding:
76540 *
76541 * rounding pt
76542 * <--------52------->|
76543 * 1 x x x x ... x x x x|y ==> x x x x ... x x x x
76544 *
76545 * For denormals, the leading '1' is included in the number,
76546 * and the rounding point is different:
76547 *
76548 * rounding pt
76549 * <--52 or less--->|
76550 * 1 x x x x ... x x|x x y ==> 0 0 ... 1 x x ... x x
76551 *
76552 * The largest denormals will have a mantissa beginning with
76553 * a '1' (the explicit leading bit); smaller denormals will
76554 * have leading zero bits.
76555 *
76556 * If the exponent would become too high, the result becomes
76557 * Infinity. If the exponent is so small that the entire
76558 * mantissa becomes zero, the result becomes zero.
76559 *
76560 * Note: the Dragon4 'k' is off-by-one with respect to the IEEE
76561 * exponent. For instance, k==0 indicates that the leading '1'
76562 * digit is at the first binary fraction position (0.1xxx...);
76563 * the corresponding IEEE exponent would be -1.
76564 */
76565
76566 skip_round = 0;
76567
76568 recheck_exp:
76569
76570 expt = nc_ctx->k - 1; /* IEEE exp without bias */
76571 if (expt > 1023) {
76572 /* Infinity */
76573 bitstart = -255; /* needed for inf: causes mantissa to become zero,
76574 * and rounding to be skipped.
76575 */
76576 expt = 2047;
76577 } else if (expt >= -1022) {
76578 /* normal */
76579 bitstart = 1; /* skip leading digit */
76581 DUK_ASSERT(expt >= 1 && expt <= 2046);
76582 } else {
76583 /* denormal or zero */
76584 bitstart = 1023 + expt; /* expt==-1023 -> bitstart=0 (leading 1);
76585 * expt==-1024 -> bitstart=-1 (one left of leading 1), etc
76586 */
76587 expt = 0;
76588 }
76589 bitround = bitstart + 52;
76590
76591 DUK_DDD(DUK_DDDPRINT("ieee expt=%ld, bitstart=%ld, bitround=%ld",
76592 (long) expt, (long) bitstart, (long) bitround));
76593
76594 if (!skip_round) {
76595 if (duk__dragon4_fixed_format_round(nc_ctx, bitround)) {
76596 /* Corner case: see test-numconv-parse-mant-carry.js. We could
76597 * just bump the exponent and update bitstart, but it's more robust
76598 * to recompute (but avoid rounding twice).
76599 */
76600 DUK_DDD(DUK_DDDPRINT("rounding caused exponent to be bumped, recheck exponent"));
76601 skip_round = 1;
76602 goto recheck_exp;
76603 }
76604 }
76605
76606 /*
76607 * Create mantissa
76608 */
76609
76610 t = 0;
76611 for (i = 0; i < 52; i++) {
76612 bitidx = bitstart + 52 - 1 - i;
76613 if (bitidx >= nc_ctx->count) {
76614 v = 0;
76615 } else if (bitidx < 0) {
76616 v = 0;
76617 } else {
76618 v = nc_ctx->digits[bitidx];
76619 }
76620 DUK_ASSERT(v == 0 || v == 1);
76621 t += v << (i % 32);
76622 if (i == 31) {
76623 /* low 32 bits is complete */
76625 t = 0;
76626 }
76627 }
76628 /* t has high mantissa */
76629
76630 DUK_DDD(DUK_DDDPRINT("mantissa is complete: %08lx %08lx",
76631 (unsigned long) t,
#define DUK_DBLUNION_SET_LOW32(u, v)
#define DUK__IEEE_DOUBLE_EXP_BIAS
DUK_LOCAL void duk__dragon4_ctx_to_double(duk__numconv_stringify_ctx *nc_ctx, duk_double_t *x)
DUK_LOCAL duk_small_int_t duk__dragon4_fixed_format_round(duk__numconv_stringify_ctx *nc_ctx, duk_small_int_t round_idx)
#define DUK__IEEE_DOUBLE_EXP_MIN
duk_uint8_t digits[DUK__MAX_OUTPUT_DIGITS]

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 76446 of file duktape-1.5.2/src/duktape.c.

76447 {
76448 expt_sign = '-';
76449 expt = -expt;
76450 }
76451 *q++ = (duk_uint8_t) expt_sign;
76452 len = duk__dragon4_format_uint32(q, (duk_uint32_t) expt, radix);
76453 q += len;
76454 }
76455
76456 duk_push_lstring(ctx, (const char *) buf, (size_t) (q - buf));
76457}
76458
76459/*
76460 * Conversion helpers
76461 */
76462
76465 duk_uint32_t tmp;
76466 duk_small_int_t expt;
76467
76468 /*
76469 * seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff
76470 * A B C D E F G H
76471 *
76472 * s sign bit
76473 * eee... exponent field
76474 * fff... fraction
76475 *
76476 * ieee value = 1.ffff... * 2^(e - 1023) (normal)
76477 * = 0.ffff... * 2^(-1022) (denormal)
76478 *
76479 * algorithm v = f * b^e
76480 */
76481
76483
76484 nc_ctx->f.n = 2;
76485
76486 tmp = DUK_DBLUNION_GET_LOW32(&u);
76487 nc_ctx->f.v[0] = tmp;
76488 tmp = DUK_DBLUNION_GET_HIGH32(&u);
76489 nc_ctx->f.v[1] = tmp & 0x000fffffUL;
#define DUK_DBLUNION_GET_LOW32(u)
#define DUK_DBLUNION_SET_DOUBLE(u, v)
#define DUK_DBLUNION_GET_HIGH32(u)
DUK_LOCAL void duk__dragon4_double_to_ctx(duk__numconv_stringify_ctx *nc_ctx, duk_double_t x)
DUK_LOCAL duk_size_t duk__dragon4_format_uint32(duk_uint8_t *buf, duk_uint32_t x, duk_small_int_t radix)

◆ 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 76227 of file duktape-1.5.2/src/duktape.c.

76244 {
76246 duk_uint8_t *p;
76247 duk_uint8_t roundup_limit;
76248 duk_small_int_t ret = 0;
76249
76250 /*
76251 * round_idx points to the digit which is considered for rounding; the
76252 * digit to its left is the final digit of the rounded value. If round_idx
76253 * is zero, rounding will be performed; the result will either be an empty
76254 * rounded value or if carry happens a '1' digit is generated.
76255 */
76256
76257 if (round_idx >= nc_ctx->count) {
76258 DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld >= %ld (count)) -> no rounding",
76259 (long) round_idx, (long) nc_ctx->count));
76260 return 0;
76261 } else if (round_idx < 0) {
76262 DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld < 0) -> no rounding",
76263 (long) round_idx));
76264 return 0;
76265 }
76266
76267 /*
76268 * Round-up limit.
76269 *
76270 * For even values, divides evenly, e.g. 10 -> roundup_limit=5.
76271 *
76272 * For odd values, rounds up, e.g. 3 -> roundup_limit=2.
76273 * If radix is 3, 0/3 -> down, 1/3 -> down, 2/3 -> up.
76274 */
76275 roundup_limit = (duk_uint8_t) ((nc_ctx->B + 1) / 2);
76276
76277 p = &nc_ctx->digits[round_idx];
76278 if (*p >= roundup_limit) {
76279 DUK_DDD(DUK_DDDPRINT("fixed-format rounding carry required"));
76280 /* carry */
76281 for (;;) {
76282 *p = 0;
76283 if (p == &nc_ctx->digits[0]) {
76284 DUK_DDD(DUK_DDDPRINT("carry propagated to first digit -> special case handling"));
76285 DUK_MEMMOVE((void *) (&nc_ctx->digits[1]),
76286 (const void *) (&nc_ctx->digits[0]),
76287 (size_t) (sizeof(char) * nc_ctx->count));
76288 nc_ctx->digits[0] = 1; /* don't increase 'count' */
76289 nc_ctx->k++; /* position of highest digit changed */
76290 nc_ctx->count++; /* number of digits changed */
76291 ret = 1;
76292 break;
76293 }
76294

◆ 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 75772 of file duktape-1.5.2/src/duktape.c.

75783 { \
75784 DUK_ASSERT((preinc_idx) - 1 >= 0); \
75785 DUK_ASSERT((preinc_idx) - 1 < DUK__MAX_OUTPUT_DIGITS); \
75786 ((nc_ctx)->digits[(preinc_idx) - 1]) = (duk_uint8_t) (x); \
75787 } while (0)
75788
75789DUK_LOCAL duk_size_t duk__dragon4_format_uint32(duk_uint8_t *buf, duk_uint32_t x, duk_small_int_t radix) {
75790 duk_uint8_t *p;
75791 duk_size_t len;
75792 duk_small_int_t dig;
75794
75795 DUK_ASSERT(radix >= 2 && radix <= 36);
75796
75797 /* A 32-bit unsigned integer formats to at most 32 digits (the
75798 * worst case happens with radix == 2). Output the digits backwards,
75799 * and use a memmove() to get them in the right place.
75800 */
75801
75802 p = buf + 32;
75803 for (;;) {

◆ duk__dragon4_generate()

DUK_LOCAL void duk__dragon4_generate ( duk__numconv_stringify_ctx * nc_ctx)

Definition at line 76052 of file duktape-1.5.2/src/duktape.c.

76054 :
76055
76056 if (!nc_ctx->unequal_gaps) {
76057 DUK_DDD(DUK_DDDPRINT("equal gaps, copy m- from m+"));
76058 duk__bi_copy(&nc_ctx->mm, &nc_ctx->mp); /* mm <- mp */
76059 }
76060 nc_ctx->k = k;
76061
76062 DUK_DDD(DUK_DDDPRINT("final k: %ld", (long) k));
76063 DUK__BI_PRINT("r(final)", &nc_ctx->r);
76064 DUK__BI_PRINT("s(final)", &nc_ctx->s);
76065 DUK__BI_PRINT("mp(final)", &nc_ctx->mp);
76066 DUK__BI_PRINT("mm(final)", &nc_ctx->mm);
76067}
76068
76070 duk_small_int_t tc1, tc2; /* terminating conditions */
76071 duk_small_int_t d; /* current digit */
76072 duk_small_int_t count = 0; /* digit count */
76073
76074 /*
76075 * Digit generation loop.
76076 *
76077 * Different termination conditions:
76078 *
76079 * 1. Free format output. Terminate when shortest accurate
76080 * representation found.
76081 *
76082 * 2. Fixed format output, with specific number of digits.
76083 * Ignore termination conditions, terminate when digits
76084 * generated. Caller requests an extra digit and rounds.
76085 *
76086 * 3. Fixed format output, with a specific absolute cut-off
76087 * position (e.g. 10 digits after decimal point). Note
76088 * that we always generate at least one digit, even if
76089 * the digit is below the cut-off point already.
76090 */
76091
76092 for (;;) {
76093 DUK_DDD(DUK_DDDPRINT("generate loop, count=%ld, k=%ld, B=%ld, low_ok=%ld, high_ok=%ld",
76094 (long) count, (long) nc_ctx->k, (long) nc_ctx->B,
76095 (long) nc_ctx->low_ok, (long) nc_ctx->high_ok));
76096 DUK__BI_PRINT("r", &nc_ctx->r);
76097 DUK__BI_PRINT("s", &nc_ctx->s);
76098 DUK__BI_PRINT("m+", &nc_ctx->mp);
76099 DUK__BI_PRINT("m-", &nc_ctx->mm);
76100
76101 /* (quotient-remainder (* r B) s) using a dummy subtraction loop */
76102 duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, nc_ctx->B); /* t1 <- (* r B) */
76103 d = 0;
76104 for (;;) {
76105 if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) {
76106 break;
76107 }
76108 duk__bi_sub_copy(&nc_ctx->t1, &nc_ctx->s, &nc_ctx->t2); /* t1 <- t1 - s */
76109 d++;
76110 }
76111 duk__bi_copy(&nc_ctx->r, &nc_ctx->t1); /* r <- (remainder (* r B) s) */
76112 /* d <- (quotient (* r B) s) (in range 0...B-1) */
76113 DUK_DDD(DUK_DDDPRINT("-> d(quot)=%ld", (long) d));
76114 DUK__BI_PRINT("r(rem)", &nc_ctx->r);
76115
76116 duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t2); /* m+ <- (* m+ B) */
76117 duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t2); /* m- <- (* m- B) */
76118 DUK__BI_PRINT("mp(upd)", &nc_ctx->mp);
76119 DUK__BI_PRINT("mm(upd)", &nc_ctx->mm);
76120
76121 /* Terminating conditions. For fixed width output, we just ignore the
76122 * terminating conditions (and pretend that tc1 == tc2 == false). The
76123 * the current shortcut for fixed-format output is to generate a few
76124 * extra digits and use rounding (with carry) to finish the output.
76125 */
76126
76127 if (nc_ctx->is_fixed == 0) {
76128 /* free-form */
76129 tc1 = (duk__bi_compare(&nc_ctx->r, &nc_ctx->mm) <= (nc_ctx->low_ok ? 0 : -1));
76130
76131 duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 <- (+ r m+) */
76132 tc2 = (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1));
76133
76134 DUK_DDD(DUK_DDDPRINT("tc1=%ld, tc2=%ld", (long) tc1, (long) tc2));
76135 } else {
76136 /* fixed-format */
76137 tc1 = 0;
76138 tc2 = 0;
76139 }
76140
76141 /* Count is incremented before DUK__DRAGON4_OUTPUT_PREINC() call
76142 * on purpose, which is taken into account by the macro.
76143 */
76144 count++;
76145
76146 if (tc1) {
76147 if (tc2) {
76148 /* tc1 = true, tc2 = true */
76149 duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, 2);
76150 if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) { /* (< (* r 2) s) */
76151 DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r > s: output d --> %ld (k=%ld)",
76152 (long) d, (long) nc_ctx->k));
76153 DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
76154 } else {
76155 DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r <= s: output d+1 --> %ld (k=%ld)",
76156 (long) (d + 1), (long) nc_ctx->k));
76157 DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1);
76158 }
76159 break;
76160 } else {
76161 /* tc1 = true, tc2 = false */
76162 DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=false: output d --> %ld (k=%ld)",
76163 (long) d, (long) nc_ctx->k));
76164 DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
76165 break;
76166 }
76167 } else {
76168 if (tc2) {
76169 /* tc1 = false, tc2 = true */
76170 DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=true: output d+1 --> %ld (k=%ld)",
76171 (long) (d + 1), (long) nc_ctx->k));
76172 DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1);
76173 break;
76174 } else {
76175 /* tc1 = false, tc2 = false */
76176 DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=false: output d --> %ld (k=%ld)",
76177 (long) d, (long) nc_ctx->k));
76178 DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
76179
76180 /* r <- r (updated above: r <- (remainder (* r B) s)
76181 * s <- s
76182 * m+ <- m+ (updated above: m+ <- (* m+ B)
76183 * m- <- m- (updated above: m- <- (* m- B)
76184 * B, low_ok, high_ok are fixed
76185 */
76186
76187 /* fall through and continue for-loop */
76188 }
76189 }
76190
76191 /* fixed-format termination conditions */
76192 if (nc_ctx->is_fixed) {
76193 if (nc_ctx->abs_pos) {
76194 int pos = nc_ctx->k - count + 1; /* count is already incremented, take into account */
76195 DUK_DDD(DUK_DDDPRINT("fixed format, absolute: abs pos=%ld, k=%ld, count=%ld, req=%ld",
76196 (long) pos, (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits));
76197 if (pos <= nc_ctx->req_digits) {
76198 DUK_DDD(DUK_DDDPRINT("digit position reached req_digits, end generate loop"));
76199 break;
76200 }
76201 } else {
76202 DUK_DDD(DUK_DDDPRINT("fixed format, relative: k=%ld, count=%ld, req=%ld",
76203 (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits));
76204 if (count >= nc_ctx->req_digits) {
76205 DUK_DDD(DUK_DDDPRINT("digit count reached req_digits, end generate loop"));
76206 break;
76207 }
76208 }
76209 }
76210 } /* for */
76211
76212 nc_ctx->count = count;
76213
76214 DUK_DDD(DUK_DDDPRINT("generate finished"));
76215
76216#ifdef DUK_USE_DDDPRINT
DUK_LOCAL void duk__bi_sub_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t)
DUK_LOCAL void duk__bi_mul_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z)
DUK_LOCAL void duk__bi_mul_small_copy(duk__bigint *x, duk_uint32_t y, duk__bigint *t)
DUK_LOCAL void duk__dragon4_generate(duk__numconv_stringify_ctx *nc_ctx)
#define DUK__BI_PRINT(name, x)
#define DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, preinc_idx, x)

◆ duk__dragon4_prepare()

DUK_LOCAL void duk__dragon4_prepare ( duk__numconv_stringify_ctx * nc_ctx)

Definition at line 75805 of file duktape-1.5.2/src/duktape.c.

75811 {
75812 break;
75813 }
75814 }
75815 len = (duk_size_t) ((buf + 32) - p);
75816
75817 DUK_MEMMOVE((void *) buf, (const void *) p, (size_t) len);
75818
75819 return len;
75820}
75821
75823 duk_small_int_t lowest_mantissa;
75824
75825#if 1
75826 /* Assume IEEE round-to-even, so that shorter encoding can be used
75827 * when round-to-even would produce correct result. By removing
75828 * this check (and having low_ok == high_ok == 0) the results would
75829 * still be accurate but in some cases longer than necessary.
75830 */
75831 if (duk__bi_is_even(&nc_ctx->f)) {
75832 DUK_DDD(DUK_DDDPRINT("f is even"));
75833 nc_ctx->low_ok = 1;
75834 nc_ctx->high_ok = 1;
75835 } else {
75836 DUK_DDD(DUK_DDDPRINT("f is odd"));
75837 nc_ctx->low_ok = 0;
75838 nc_ctx->high_ok = 0;
75839 }
75840#else
75841 /* Note: not honoring round-to-even should work but now generates incorrect
75842 * results. For instance, 1e23 serializes to "a000...", i.e. the first digit
75843 * equals the radix (10). Scaling stops one step too early in this case.
75844 * Don't know why this is the case, but since this code path is unused, it
75845 * doesn't matter.
75846 */
75847 nc_ctx->low_ok = 0;
75848 nc_ctx->high_ok = 0;
75849#endif
75850
75851 /* For string-to-number, pretend we never have the lowest mantissa as there
75852 * is no natural "precision" for inputs. Having lowest_mantissa == 0, we'll
75853 * fall into the base cases for both e >= 0 and e < 0.
75854 */
75855 if (nc_ctx->is_s2n) {
75856 lowest_mantissa = 0;
75857 } else {
75858 lowest_mantissa = duk__bi_is_2to52(&nc_ctx->f);
75859 }
75860
75861 nc_ctx->unequal_gaps = 0;
75862 if (nc_ctx->e >= 0) {
75863 /* exponent non-negative (and thus not minimum exponent) */
75864
75865 if (lowest_mantissa) {
75866 /* (>= e 0) AND (= f (expt b (- p 1)))
75867 *
75868 * be <- (expt b e) == b^e
75869 * be1 <- (* be b) == (expt b (+ e 1)) == b^(e+1)
75870 * r <- (* f be1 2) == 2 * f * b^(e+1) [if b==2 -> f * b^(e+2)]
75871 * s <- (* b 2) [if b==2 -> 4]
75872 * m+ <- be1 == b^(e+1)
75873 * m- <- be == b^e
75874 * k <- 0
75875 * B <- B
75876 * low_ok <- round
75877 * high_ok <- round
75878 */
75879
75880 DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); "
75881 "lowest mantissa value for this exponent -> "
75882 "unequal gaps"));
75883
75884 duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2); /* mm <- b^e */
75885 duk__bi_mul_small(&nc_ctx->mp, &nc_ctx->mm, nc_ctx->b); /* mp <- b^(e+1) */
75886 duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2);
75887 duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp); /* r <- (2 * f) * b^(e+1) */
75888 duk__bi_set_small(&nc_ctx->s, nc_ctx->b * 2); /* s <- 2 * b */
75889 nc_ctx->unequal_gaps = 1;
75890 } else {
75891 /* (>= e 0) AND (not (= f (expt b (- p 1))))
75892 *
75893 * be <- (expt b e) == b^e
75894 * r <- (* f be 2) == 2 * f * b^e [if b==2 -> f * b^(e+1)]
75895 * s <- 2
75896 * m+ <- be == b^e
75897 * m- <- be == b^e
75898 * k <- 0
75899 * B <- B
75900 * low_ok <- round
75901 * high_ok <- round
75902 */
75903
75904 DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); "
75905 "not lowest mantissa for this exponent -> "
75906 "equal gaps"));
75907
75908 duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2); /* mm <- b^e */
75909 duk__bi_copy(&nc_ctx->mp, &nc_ctx->mm); /* mp <- b^e */
75910 duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2);
75911 duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp); /* r <- (2 * f) * b^e */
75912 duk__bi_set_small(&nc_ctx->s, 2); /* s <- 2 */
75913 }
75914 } else {
75915 /* When doing string-to-number, lowest_mantissa is always 0 so
75916 * the exponent check, while incorrect, won't matter.
75917 */
75918 if (nc_ctx->e > DUK__IEEE_DOUBLE_EXP_MIN /*not minimum exponent*/ &&
75919 lowest_mantissa /* lowest mantissa for this exponent*/) {
75920 /* r <- (* f b 2) [if b==2 -> (* f 4)]
75921 * s <- (* (expt b (- 1 e)) 2) == b^(1-e) * 2 [if b==2 -> b^(2-e)]
75922 * m+ <- b == 2
75923 * m- <- 1
75924 * k <- 0
75925 * B <- B
75926 * low_ok <- round
75927 * high_ok <- round
75928 */
75929
75930 DUK_DDD(DUK_DDDPRINT("negative exponent; not minimum exponent and "
75931 "lowest mantissa for this exponent -> "
75932 "unequal gaps"));
75933
75934 duk__bi_mul_small(&nc_ctx->r, &nc_ctx->f, nc_ctx->b * 2); /* r <- (2 * b) * f */
75935 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 */
75936 duk__bi_mul_small(&nc_ctx->s, &nc_ctx->t1, 2); /* s <- b^(1-e) * 2 */
75937 duk__bi_set_small(&nc_ctx->mp, 2);
75938 duk__bi_set_small(&nc_ctx->mm, 1);
75939 nc_ctx->unequal_gaps = 1;
75940 } else {
75941 /* r <- (* f 2)
75942 * s <- (* (expt b (- e)) 2) == b^(-e) * 2 [if b==2 -> b^(1-e)]
75943 * m+ <- 1
75944 * m- <- 1
75945 * k <- 0
DUK_LOCAL int duk__bi_is_even(duk__bigint *x)
DUK_LOCAL duk_small_int_t duk__bi_is_2to52(duk__bigint *x)
DUK_LOCAL void duk__dragon4_prepare(duk__numconv_stringify_ctx *nc_ctx)

◆ duk__dragon4_scale()

DUK_LOCAL void duk__dragon4_scale ( duk__numconv_stringify_ctx * nc_ctx)

Definition at line 75947 of file duktape-1.5.2/src/duktape.c.

75964 {
75965 duk_small_int_t k = 0;
75966
75967 /* This is essentially the 'scale' algorithm, with recursion removed.
75968 * Note that 'k' is either correct immediately, or will move in one
75969 * direction in the loop. There's no need to do the low/high checks
75970 * on every round (like the Scheme algorithm does).
75971 *
75972 * The scheme algorithm finds 'k' and updates 's' simultaneously,
75973 * while the logical algorithm finds 'k' with 's' having its initial
75974 * value, after which 's' is updated separately (see the Burger-Dybvig
75975 * paper, Section 3.1, steps 2 and 3).
75976 *
75977 * The case where m+ == m- (almost always) is optimized for, because
75978 * it reduces the bigint operations considerably and almost always
75979 * applies. The scale loop only needs to work with m+, so this works.
75980 */
75981
75982 /* XXX: this algorithm could be optimized quite a lot by using e.g.
75983 * a logarithm based estimator for 'k' and performing B^n multiplication
75984 * using a lookup table or using some bit-representation based exp
75985 * algorithm. Currently we just loop, with significant performance
75986 * impact for very large and very small numbers.
75987 */
75988
75989 DUK_DDD(DUK_DDDPRINT("scale: B=%ld, low_ok=%ld, high_ok=%ld",
75990 (long) nc_ctx->B, (long) nc_ctx->low_ok, (long) nc_ctx->high_ok));
75991 DUK__BI_PRINT("r(init)", &nc_ctx->r);
75992 DUK__BI_PRINT("s(init)", &nc_ctx->s);
75993 DUK__BI_PRINT("mp(init)", &nc_ctx->mp);
75994 DUK__BI_PRINT("mm(init)", &nc_ctx->mm);
75995
75996 for (;;) {
75997 DUK_DDD(DUK_DDDPRINT("scale loop (inc k), k=%ld", (long) k));
75998 DUK__BI_PRINT("r", &nc_ctx->r);
75999 DUK__BI_PRINT("s", &nc_ctx->s);
76000 DUK__BI_PRINT("m+", &nc_ctx->mp);
76001 DUK__BI_PRINT("m-", &nc_ctx->mm);
76002
76003 duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 = (+ r m+) */
76004 if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1)) {
76005 DUK_DDD(DUK_DDDPRINT("k is too low"));
76006 /* r <- r
76007 * s <- (* s B)
76008 * m+ <- m+
76009 * m- <- m-
76010 * k <- (+ k 1)
76011 */
76012
76013 duk__bi_mul_small_copy(&nc_ctx->s, nc_ctx->B, &nc_ctx->t1);
76014 k++;
76015 } else {
76016 break;
76017 }
76018 }
76019
76020 /* k > 0 -> k was too low, and cannot be too high */
76021 if (k > 0) {
76022 goto skip_dec_k;
76023 }
76024
76025 for (;;) {
76026 DUK_DDD(DUK_DDDPRINT("scale loop (dec k), k=%ld", (long) k));
76027 DUK__BI_PRINT("r", &nc_ctx->r);
76028 DUK__BI_PRINT("s", &nc_ctx->s);
76029 DUK__BI_PRINT("m+", &nc_ctx->mp);
76030 DUK__BI_PRINT("m-", &nc_ctx->mm);
76031
76032 duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 = (+ r m+) */
76033 duk__bi_mul_small(&nc_ctx->t2, &nc_ctx->t1, nc_ctx->B); /* t2 = (* (+ r m+) B) */
76034 if (duk__bi_compare(&nc_ctx->t2, &nc_ctx->s) <= (nc_ctx->high_ok ? -1 : 0)) {
76035 DUK_DDD(DUK_DDDPRINT("k is too high"));
76036 /* r <- (* r B)
76037 * s <- s
76038 * m+ <- (* m+ B)
76039 * m- <- (* m- B)
76040 * k <- (- k 1)
76041 */
76042 duk__bi_mul_small_copy(&nc_ctx->r, nc_ctx->B, &nc_ctx->t1);
76043 duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t1);
76044 if (nc_ctx->unequal_gaps) {
76045 DUK_DDD(DUK_DDDPRINT("m+ != m- -> need to update m- too"));
76046 duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t1);
76047 }
76048 k--;
76049 } else {
76050 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 11745 of file duktape-1.5.2/src/duktape.c.

11749 {
11750 h_str = DUK_TVAL_GET_STRING(tv);
11751 DUK_ASSERT(h_str != NULL);
11752 } else {
11754 DUK_ASSERT(h_str != NULL);
11755 }
11756 DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
11757 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(h_str), p);
11758 p = duk__dump_hstring_raw(p, h_str);
11759 return p;
11760}
11761
#define DUK_TVAL_GET_STRING(tv)
DUK_LOCAL duk_uint8_t * duk__dump_hstring_raw(duk_uint8_t *p, duk_hstring *h)

◆ 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 11824 of file duktape-1.5.2/src/duktape.c.

11841 {
11842 duk_tval *tv;
11843
11845 if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) {
11846 duk_hobject *h;
11848
11849 h = DUK_TVAL_GET_OBJECT(tv);
11850 DUK_ASSERT(h != NULL);
11851
11852 /* We know _Formals is dense and all entries will be in the
11853 * array part. GC and finalizers shouldn't affect _Formals
11854 * so side effects should be fine.
11855 */
11856 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
11857 duk_tval *tv_val;
11858 duk_hstring *varname;
11859
11860 tv_val = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i);
11861 DUK_ASSERT(tv_val != NULL);
#define DUK_HTHREAD_STRING_INT_FORMALS(thr)

◆ 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 11863 of file duktape-1.5.2/src/duktape.c.

11880 {
11881 duk_hthread *thr;
11882 duk_tval *tv, *tv_end;
11883 duk_instr_t *ins, *ins_end;
11884 duk_hobject **fn, **fn_end;
11885 duk_hstring *h_str;
11886 duk_uint32_t count_instr;
11887 duk_uint32_t tmp32;
11888 duk_uint16_t tmp16;
11889 duk_double_t d;
11890
11891 thr = (duk_hthread *) ctx;
11892 DUK_UNREF(ctx);
11893 DUK_UNREF(thr);
11894
11895 DUK_DD(DUK_DDPRINT("dumping function %p to %p: "
11896 "consts=[%p,%p[ (%ld bytes, %ld items), "
11897 "funcs=[%p,%p[ (%ld bytes, %ld items), "
11898 "code=[%p,%p[ (%ld bytes, %ld items)",
11899 (void *) func,
11900 (void *) p,
11901 (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func),
11902 (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func),
11905 (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func),
11906 (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func),
11907 (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(thr->heap, func),
11909 (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func),
11910 (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func),
11911 (long) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(thr->heap, func),
11912 (long) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func)));
11913
11914 DUK_ASSERT(DUK_USE_ESBC_MAX_BYTES <= 0x7fffffffUL); /* ensures no overflow */
11915 count_instr = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func);
11916 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 3 * 4 + 2 * 2 + 3 * 4 + count_instr * 4, p);
11917
11918 /* Fixed header info. */
11919 tmp32 = count_instr;
11920 DUK_RAW_WRITE_U32_BE(p, tmp32);
11921 tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func);
11922 DUK_RAW_WRITE_U32_BE(p, tmp32);
11923 tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func);
11924 DUK_RAW_WRITE_U32_BE(p, tmp32);
11925 tmp16 = func->nregs;
11926 DUK_RAW_WRITE_U16_BE(p, tmp16);
11927 tmp16 = func->nargs;
11928 DUK_RAW_WRITE_U16_BE(p, tmp16);
11929#if defined(DUK_USE_DEBUGGER_SUPPORT)
11930 tmp32 = func->start_line;
11931 DUK_RAW_WRITE_U32_BE(p, tmp32);
11932 tmp32 = func->end_line;
11933 DUK_RAW_WRITE_U32_BE(p, tmp32);
11934#else
11937#endif
11938 tmp32 = ((duk_heaphdr *) func)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK;
11939 DUK_RAW_WRITE_U32_BE(p, tmp32);
11940
11941 /* Bytecode instructions: endian conversion needed unless
11942 * platform is big endian.
11943 */
11944 ins = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func);
11945 ins_end = DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func);
11946 DUK_ASSERT((duk_size_t) (ins_end - ins) == (duk_size_t) count_instr);
11947#if defined(DUK_USE_INTEGER_BE)
11948 DUK_MEMCPY((void *) p, (const void *) ins, (size_t) (ins_end - ins));
11949 p += (size_t) (ins_end - ins);
11950#else
11951 while (ins != ins_end) {
11952 tmp32 = (duk_uint32_t) (*ins);
11953 DUK_RAW_WRITE_U32_BE(p, tmp32);
11954 ins++;
11955 }
11956#endif
11957
11958 /* Constants: variable size encoding. */
11960 tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func);
11961 while (tv != tv_end) {
11962 /* constants are strings or numbers now */
11964 DUK_TVAL_IS_NUMBER(tv));
11965
11966 if (DUK_TVAL_IS_STRING(tv)) {
11967 h_str = DUK_TVAL_GET_STRING(tv);
11968 DUK_ASSERT(h_str != NULL);
11969 DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
11970 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 4 + DUK_HSTRING_GET_BYTELEN(h_str), p),
11971 *p++ = DUK__SER_STRING;
11972 p = duk__dump_hstring_raw(p, h_str);
11973 } else {
11975 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 8, p);
11976 *p++ = DUK__SER_NUMBER;
11977 d = DUK_TVAL_GET_NUMBER(tv);
11979 }
11980 tv++;
11981 }
11982
11983 /* Inner functions recursively. */
11985 fn_end = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func);
11986 while (fn != fn_end) {
11987 /* XXX: This causes recursion up to inner function depth
11988 * which is normally not an issue, e.g. mark-and-sweep uses
11989 * a recursion limiter to avoid C stack issues. Avoiding
11990 * this would mean some sort of a work list or just refusing
11991 * to serialize deep functions.
11992 */
11994 p = duk__dump_func(ctx, (duk_hcompiledfunction *) *fn, bw_ctx, p);
11995 fn++;
11996 }
11997
11998 /* Object extra properties.
#define DUK__SER_STRING
#define DUK_RAW_WRITE_U16_BE(ptr, val)
#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap, h)
#define DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(heap, h)
#define DUK_TVAL_IS_STRING(tv)
#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap, h)
#define DUK_RAW_WRITE_DOUBLE_BE(ptr, val)
#define DUK_RAW_WRITE_U32_BE(ptr, val)
#define DUK__SER_NUMBER
static duk_uint8_t * duk__dump_func(duk_context *ctx, duk_hcompiledfunction *func, duk_bufwriter_ctx *bw_ctx, duk_uint8_t *p)

◆ 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 11708 of file duktape-1.5.2/src/duktape.c.

11708 {
11709 duk_size_t len;
11710 duk_uint32_t tmp32;
11711
11712 DUK_ASSERT(h != NULL);
11713
11714 len = DUK_HSTRING_GET_BYTELEN(h);
11715 DUK_ASSERT(len <= 0xffffffffUL); /* string limits */
11716 tmp32 = (duk_uint32_t) len;
11717 DUK_RAW_WRITE_U32_BE(p, tmp32);
11718 DUK_MEMCPY((void *) p,
11719 (const void *) DUK_HSTRING_GET_DATA(h),
11720 len);
11721 p += len;
11722 return p;
11723}
11724
11725DUK_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_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 11691 of file duktape-1.5.2/src/duktape.c.

11696 {
11697 duk_uint32_t len;
11698 duk_uint8_t *buf;
11699
11700 len = DUK_RAW_READ_U32_BE(p);
11701 buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
11702 DUK_ASSERT(buf != NULL);
11703 DUK_MEMCPY((void *) buf, (const void *) p, (size_t) len);
11704 p += len;
11705 return p;
11706}
#define DUK_RAW_READ_U32_BE(ptr)

◆ 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 11727 of file duktape-1.5.2/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 11763 of file duktape-1.5.2/src/duktape.c.

11766 {
11767 duk_hbuffer *h_buf;
11768 h_buf = DUK_TVAL_GET_BUFFER(tv);
11769 DUK_ASSERT(h_buf != NULL);
11770 DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
11771 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HBUFFER_GET_SIZE(h_buf), p);
11772 p = duk__dump_hbuffer_raw(thr, p, h_buf);
11773 } else {
11774 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p);
11776 }
#define DUK_HBUFFER_MAX_BYTELEN
#define DUK_TVAL_GET_BUFFER(tv)

◆ 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 11778 of file duktape-1.5.2/src/duktape.c.

11780 {
11781 duk_tval *tv;
11782 duk_uint32_t val;
11783
11785 if (tv != NULL && DUK_TVAL_IS_NUMBER(tv)) {
11786 val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv);
11787 } else {
11788 val = def_value;
11789 }
11790 p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p);
11791 DUK_RAW_WRITE_U32_BE(p, val);
11792 return p;
11793}
11794
11795DUK_LOCAL duk_uint8_t *duk__dump_varmap(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func) {
11796 duk_tval *tv;
11797
11799 if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) {
11800 duk_hobject *h;
11802
11803 h = DUK_TVAL_GET_OBJECT(tv);
11804 DUK_ASSERT(h != NULL);
11805
11806 /* We know _Varmap only has own properties so walk property
11807 * table directly. We also know _Varmap is dense and all
11808 * values are numbers; assert for these. GC and finalizers
11809 * shouldn't affect _Varmap so side effects should be fine.
11810 */
11811 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
11812 duk_hstring *key;
11813 duk_tval *tv_val;
11814 duk_uint32_t val;
11815
11816 key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
11817 DUK_ASSERT(key != NULL); /* _Varmap is dense */
11819 tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i);
11820 DUK_ASSERT(tv_val != NULL);
11821 DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_val)); /* known to be number; in fact an integer */
11822#if defined(DUK_USE_FASTINT)
#define DUK_HTHREAD_STRING_INT_VARMAP(thr)
DUK_LOCAL duk_uint8_t * duk__dump_varmap(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func)

◆ duk__emit()

DUK_LOCAL_DECL void duk__emit ( duk_compiler_ctx * comp_ctx,
duk_instr_t ins )

Definition at line 58496 of file duktape-1.5.2/src/duktape.c.

58498 {
58499 duk_compiler_func *func;
58500 func = &comp_ctx->curr_func;
58501 return (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &func->bw_code) / sizeof(duk_compiler_instr));
58502}
58503
58505 DUK_ASSERT(pc >= 0);
58506 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)));
58507 return ((duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code)) + pc;
58508}
58509
58510/* emit instruction; could return PC but that's not needed in the majority
58511 * of cases.
58512 */
58513DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) {
58514#if defined(DUK_USE_PC2LINE)
58515 duk_int_t line;
58516#endif
58517 duk_compiler_instr *instr;
58518
58519 DUK_DDD(DUK_DDDPRINT("duk__emit: 0x%08lx curr_token.start_line=%ld prev_token.start_line=%ld pc=%ld --> %!I",
58520 (unsigned long) ins,
58521 (long) comp_ctx->curr_token.start_line,
58522 (long) comp_ctx->prev_token.start_line,
58523 (long) duk__get_current_pc(comp_ctx),
58524 (duk_instr_t) ins));
58525
58526 instr = (duk_compiler_instr *) (void *) DUK_BW_ENSURE_GETPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
58527 DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
58528
58529#if defined(DUK_USE_PC2LINE)
58530 /* The line number tracking is a bit inconsistent right now, which
58531 * affects debugger accuracy. Mostly call sites emit opcodes when
58532 * they have parsed a token (say a terminating semicolon) and called
58533 * duk__advance(). In this case the line number of the previous
58534 * token is the most accurate one (except in prologue where
58535 * prev_token.start_line is 0). This is probably not 100% correct
58536 * right now.
58537 */
58538 /* approximation, close enough */
58539 line = comp_ctx->prev_token.start_line;
58540 if (line == 0) {
58541 line = comp_ctx->curr_token.start_line;
58542 }
58543#endif
58544
58545 instr->ins = ins;
58546#if defined(DUK_USE_PC2LINE)
58547 instr->line = line;
58548#endif
58549#if defined(DUK_USE_DEBUGGER_SUPPORT)
58550 if (line < comp_ctx->curr_func.min_line) {
58551 comp_ctx->curr_func.min_line = line;
58552 }
58553 if (line > comp_ctx->curr_func.max_line) {
58554 comp_ctx->curr_func.max_line = line;
58555 }
58556#endif
58557
58558 /* Limit checks for bytecode byte size and line number. */
58560 goto fail_bc_limit;
58561 }
58562#if defined(DUK_USE_PC2LINE) && defined(DUK_USE_ESBC_LIMITS)
#define DUK_BW_ADD_PTR(thr, bw_ctx, delta)
DUK_LOCAL_DECL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins)
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)
#define DUK_BW_ENSURE_GETPTR(thr, bw_ctx, sz)
#define curr_func(L)

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 29937 of file duktape-1.5.2/src/duktape.c.

29937 : top=%ld, result=%!T",
29938 (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -1)));
29939}

◆ 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 29941 of file duktape-1.5.2/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 58843 of file duktape-1.5.2/src/duktape.c.

58844 {
58845 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 58595 of file duktape-1.5.2/src/duktape.c.

58597 {
58598 comp_ctx->curr_func.max_line = line;
58599 }
58600#else
58601 DUK_UNREF(comp_ctx);
58602#endif
58603}
58604
58605#if 0 /* unused */
58606DUK_LOCAL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op) {
58607 duk__emit(comp_ctx, DUK_ENC_OP_ABC(op, 0));
58608}
58609#endif
58610
58611/* Important main primitive. */
58613 duk_instr_t ins = 0;
58614 duk_int_t a_out = -1;
58615 duk_int_t b_out = -1;
58616 duk_int_t c_out = -1;
58617 duk_int_t tmp;
58618
58619 DUK_DDD(DUK_DDDPRINT("emit: op_flags=%04lx, a=%ld, b=%ld, c=%ld",
58620 (unsigned long) op_flags, (long) a, (long) b, (long) c));
58621
58622 /* We could rely on max temp/const checks: if they don't exceed BC
58623 * limit, nothing here can either (just asserts would be enough).
58624 * Currently we check for the limits, which provides additional
58625 * protection against creating invalid bytecode due to compiler
58626 * bugs.
58627 */
58628
58629 DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN); /* unsigned */
58630 DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
58631
58632 /* Input shuffling happens before the actual operation, while output
58633 * shuffling happens afterwards. Output shuffling decisions are still
58634 * made at the same time to reduce branch clutter; output shuffle decisions
58635 * are recorded into X_out variables.
58636 */
58637
58638 /* Slot A */
58639
58640#if defined(DUK_USE_SHUFFLE_TORTURE)
58641 if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
58642#else
58643 if (a <= DUK_BC_A_MAX) {
58644#endif
58645 ;
58646 } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
58647 DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but shuffle prohibited, a: %ld", (long) a));
58648 goto error_outofregs;
58649 } else if (a <= DUK_BC_BC_MAX) {
58650 comp_ctx->curr_func.needs_shuffle = 1;
58651 tmp = comp_ctx->curr_func.shuffle1;
58652 if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) {
58653 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
58654 } else {
58655 duk_small_int_t op = op_flags & 0xff;
58656 if (op == DUK_OP_CSVAR || op == DUK_OP_CSREG || op == DUK_OP_CSPROP) {
58657 /* Special handling for call setup instructions. The target
58658 * is expressed indirectly, but there is no output shuffling.
58659 */
58660 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) == 0);
58661 duk__emit_load_int32_noshuffle(comp_ctx, tmp, a);
58665 op_flags++; /* indirect opcode follows direct */
58666 } else {
58667 /* Output shuffle needed after main operation */
58668 a_out = a;
58669 }
58670 }
58671 a = tmp;
58672 } else {
58673 DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but does not fit into BC, a: %ld", (long) a));
58674 goto error_outofregs;
58675 }
58676
58677 /* Slot B */
58678
58679 if (b & DUK__CONST_MARKER) {
58680 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) == 0);
58681 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
58682 DUK_ASSERT((op_flags & 0xff) != DUK_OP_CALL);
58683 DUK_ASSERT((op_flags & 0xff) != DUK_OP_NEW);
58684 b = b & ~DUK__CONST_MARKER;
58685#if defined(DUK_USE_SHUFFLE_TORTURE)
58686 if (0) {
58687#else
58688 if (b <= 0xff) {
58689#endif
58690 ins |= DUK_ENC_OP_A_B_C(0, 0, 0x100, 0); /* const flag for B */
58691 } else if (b <= DUK_BC_BC_MAX) {
58692 comp_ctx->curr_func.needs_shuffle = 1;
58693 tmp = comp_ctx->curr_func.shuffle2;
58694 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, b));
58695 b = tmp;
58696 } else {
58697 DUK_D(DUK_DPRINT("out of regs: 'b' (const) needs shuffling but does not fit into BC, b: %ld", (long) b));
58698 goto error_outofregs;
58699 }
58700 } else {
58701#if defined(DUK_USE_SHUFFLE_TORTURE)
58702 if (b <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B)) {
58703#else
58704 if (b <= 0xff) {
58705#endif
58706 ;
58707 } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) {
58708 if (b > DUK_BC_B_MAX) {
58709 /* Note: 0xff != DUK_BC_B_MAX */
58710 DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but shuffle prohibited, b: %ld", (long) b));
58711 goto error_outofregs;
58712 }
58713 } else if (b <= DUK_BC_BC_MAX) {
58714 comp_ctx->curr_func.needs_shuffle = 1;
58715 tmp = comp_ctx->curr_func.shuffle2;
58716 if (op_flags & DUK__EMIT_FLAG_B_IS_TARGET) {
58717 /* Output shuffle needed after main operation */
58718 b_out = b;
58719 }
58720 if (!(op_flags & DUK__EMIT_FLAG_B_IS_TARGET) || (op_flags & DUK__EMIT_FLAG_B_IS_TARGETSOURCE)) {
58721 duk_small_int_t op = op_flags & 0xff;
58722 if (op == DUK_OP_CALL || op == DUK_OP_NEW ||
58723 op == DUK_OP_MPUTOBJ || op == DUK_OP_MPUTARR) {
58724 /* Special handling for CALL/NEW/MPUTOBJ/MPUTARR shuffling.
58725 * For each, slot B identifies the first register of a range
58726 * of registers, so normal shuffling won't work. Instead,
58727 * an indirect version of the opcode is used.
58728 */
58729 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
58730 duk__emit_load_int32_noshuffle(comp_ctx, tmp, b);
58735 op_flags++; /* indirect opcode follows direct */
58736 } else {
58737 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, b));
58738 }
58739 }
58740 b = tmp;
58741 } else {
58742 DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but does not fit into BC, b: %ld", (long) b));
58743 goto error_outofregs;
58744 }
58745 }
58746
58747 /* Slot C */
58748
58749 if (c & DUK__CONST_MARKER) {
58750 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) == 0);
58751 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
58752 c = c & ~DUK__CONST_MARKER;
58753#if defined(DUK_USE_SHUFFLE_TORTURE)
58754 if (0) {
58755#else
58756 if (c <= 0xff) {
58757#endif
58758 ins |= DUK_ENC_OP_A_B_C(0, 0, 0, 0x100); /* const flag for C */
58759 } else if (c <= DUK_BC_BC_MAX) {
58760 comp_ctx->curr_func.needs_shuffle = 1;
58761 tmp = comp_ctx->curr_func.shuffle3;
58762 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, c));
58763 c = tmp;
58764 } else {
58765 DUK_D(DUK_DPRINT("out of regs: 'c' (const) needs shuffling but does not fit into BC, c: %ld", (long) c));
58766 goto error_outofregs;
58767 }
58768 } else {
58769#if defined(DUK_USE_SHUFFLE_TORTURE)
58770 if (c <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C)) {
58771#else
58772 if (c <= 0xff) {
58773#endif
58774 ;
58775 } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) {
58776 if (c > DUK_BC_C_MAX) {
58777 /* Note: 0xff != DUK_BC_C_MAX */
58778 DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but shuffle prohibited, c: %ld", (long) c));
58779 goto error_outofregs;
58780 }
58781 } else if (c <= DUK_BC_BC_MAX) {
58782 comp_ctx->curr_func.needs_shuffle = 1;
58783 tmp = comp_ctx->curr_func.shuffle3;
58784 if (op_flags & DUK__EMIT_FLAG_C_IS_TARGET) {
58785 /* Output shuffle needed after main operation */
58786 c_out = c;
58787 } else {
58788 duk_small_int_t op = op_flags & 0xff;
58789 if (op == DUK_OP_EXTRA &&
58791 /* Special shuffling for INITGET/INITSET, where slot C
58792 * identifies a register pair and cannot be shuffled
58793 * normally. Use an indirect variant instead.
58794 */
58795 DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
58796 duk__emit_load_int32_noshuffle(comp_ctx, tmp, c);
58799 a++; /* indirect opcode follows direct */
58800 } else {
58801 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, c));
58802 }
58803 }
58804 c = tmp;
58805 } else {
58806 DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but does not fit into BC, c: %ld", (long) c));
58807 goto error_outofregs;
58808 }
58809 }
58810
58811 /* Main operation */
58812
58813 DUK_ASSERT_DISABLE(a >= DUK_BC_A_MIN); /* unsigned */
58815 DUK_ASSERT_DISABLE(b >= DUK_BC_B_MIN); /* unsigned */
58817 DUK_ASSERT_DISABLE(c >= DUK_BC_C_MIN); /* unsigned */
58819
58820 ins |= DUK_ENC_OP_A_B_C(op_flags & 0xff, a, b, c);
58821 duk__emit(comp_ctx, ins);
58822
58823 /* NEXTENUM needs a jump slot right after the main instruction.
58824 * When the JUMP is taken, output spilling is not needed so this
58825 * workaround is possible. The jump slot PC is exceptionally
58826 * plumbed through comp_ctx to minimize call sites.
58827 */
58828 if (op_flags & DUK__EMIT_FLAG_RESERVE_JUMPSLOT) {
58829 comp_ctx->emit_jumpslot_pc = duk__get_current_pc(comp_ctx);
58830 duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
58831 }
58832
58833 /* Output shuffling: only one output register is realistically possible.
58834 *
58835 * (Zero would normally be an OK marker value: if the target register
58836 * was zero, it would never be shuffled. But with DUK_USE_SHUFFLE_TORTURE
58837 * this is no longer true, so use -1 as a marker instead.)
58838 */
58839
58840 if (a_out >= 0) {
58841 DUK_ASSERT(b_out < 0);
duk_uint32_t duk_regconst_t
#define DUK__EMIT_FLAG_NO_SHUFFLE_B
#define DUK_OP_JUMP
DUK_LOCAL_DECL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc)
#define DUK_OP_MPUTOBJ
#define DUK_OP_LDREG
#define DUK__EMIT_FLAG_B_IS_TARGETSOURCE
#define DUK_ENC_OP_A_B_C(op, a, b, c)
DUK_LOCAL_DECL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val)
#define DUK_OP_CSREGI
#define DUK_OP_CALL
#define DUK_BC_OP_MAX
#define DUK_BC_BC_MAX
#define DUK_OP_CSVAR
#define DUK_OP_MPUTOBJI
#define DUK_ENC_OP_A_BC(op, a, bc)
#define DUK_OP_MPUTARRI
#define DUK_EXTRAOP_INITSET
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)
#define DUK_OP_EXTRA
#define DUK_BC_B_MIN
#define DUK_OP_CSVARI
#define DUK__CONST_MARKER
#define DUK_OP_CSPROP
#define DUK__EMIT_FLAG_NO_SHUFFLE_A
#define DUK_OP_CALLI
#define DUK_ENC_OP_ABC(op, abc)
#define DUK_EXTRAOP_INITSETI
#define DUK_OP_CSREG
#define DUK_OP_CSPROPI
#define DUK_OP_MPUTARR
#define DUK__EMIT_FLAG_A_IS_SOURCE
#define DUK_BC_B_MAX
#define DUK__EMIT_FLAG_B_IS_TARGET
#define DUK__EMIT_FLAG_RESERVE_JUMPSLOT
#define DUK_OP_LDCONST
#define DUK_BC_A_MIN
#define DUK_BC_C_MIN
#define DUK_EXTRAOP_INITGET
#define DUK_OP_NEW
#define DUK_BC_C_MAX
#define DUK__EMIT_FLAG_C_IS_TARGET
#define DUK_BC_A_MAX
#define DUK_EXTRAOP_INITGETI
#define DUK__EMIT_FLAG_NO_SHUFFLE_C
#define DUK_BC_OP_MIN
#define DUK_OP_NEWI

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 58853 of file duktape-1.5.2/src/duktape.c.

58856 :
58858}
58859
58861 duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, b, 0);
58862}
58863
58864#if 0 /* unused */
58865DUK_LOCAL void duk__emit_a(duk_compiler_ctx *comp_ctx, int op_flags, int a) {
58867}
58868#endif
58869
58871 duk_instr_t ins;
58872 duk_int_t tmp;
58873
58874 /* allow caller to give a const number with the DUK__CONST_MARKER */
58875 bc = bc & (~DUK__CONST_MARKER);
58876
58877 DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN); /* unsigned */
58878 DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
58879 DUK_ASSERT_DISABLE(bc >= DUK_BC_BC_MIN); /* unsigned */
58881 DUK_ASSERT((bc & DUK__CONST_MARKER) == 0);
58882
58883 if (bc <= DUK_BC_BC_MAX) {
58884 ;
58885 } else {
58886 /* No BC shuffling now. */
58887 goto error_outofregs;
58888 }
58889
58890#if defined(DUK_USE_SHUFFLE_TORTURE)
58891 if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
58892#else
58893 if (a <= DUK_BC_A_MAX) {
58894#endif
58895 ins = DUK_ENC_OP_A_BC(op_flags & 0xff, a, bc);
58896 duk__emit(comp_ctx, ins);
58897 } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
58898 goto error_outofregs;
58899 } else if (a <= DUK_BC_BC_MAX) {
58900 comp_ctx->curr_func.needs_shuffle = 1;
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)
#define DUK_STR_REG_LIMIT
#define DUK_BC_BC_MIN
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)

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 58902 of file duktape-1.5.2/src/duktape.c.

58903 {
58904 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
58905 duk__emit(comp_ctx, ins);
58906 } else {
58907 duk__emit(comp_ctx, ins);
58908 duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, tmp, a));
58909 }
58910 } else {
58911 goto error_outofregs;
58912 }
58913 return;
58914
58915 error_outofregs:
58917}
58918
58920 duk_instr_t ins;
58921
58922 DUK_ASSERT_DISABLE(op >= DUK_BC_OP_MIN); /* unsigned */
58924 DUK_ASSERT_DISABLE(abc >= DUK_BC_ABC_MIN); /* unsigned */
58925 DUK_ASSERT(abc <= DUK_BC_ABC_MAX);
58926 DUK_ASSERT((abc & DUK__CONST_MARKER) == 0);
#define DUK_OP_STREG
#define DUK_BC_ABC_MIN
#define DUK_BC_ABC_MAX

◆ duk__emit_cstring()

DUK_LOCAL void duk__emit_cstring ( duk_json_enc_ctx * js_ctx,
const char * str )

Definition at line 29950 of file duktape-1.5.2/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 29976 of file duktape-1.5.2/src/duktape.c.

29983 {
29984 DUK_ASSERT(DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw) >= 1);
29985 DUK_BW_ADD_PTR(js_ctx->thr, &js_ctx->bw, -1);
29986}
29987
29988#define DUK__MKESC(nybbles,esc1,esc2) \
29989 (((duk_uint_fast32_t) (nybbles)) << 16) | \
29990 (((duk_uint_fast32_t) (esc1)) << 8) | \
29991 ((duk_uint_fast32_t) (esc2))
29992
29993DUK_LOCAL duk_uint8_t *duk__emit_esc_auto_fast(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp, duk_uint8_t *q) {
29995 duk_small_uint_t dig;
29996
29997 DUK_UNREF(js_ctx);
29998
29999 /* Caller ensures space for at least DUK__JSON_MAX_ESC_LEN. */
30000
30001 /* Select appropriate escape format automatically, and set 'tmp' to a
30002 * value encoding both the escape format character and the nybble count:
30003 *
30004 * (nybble_count << 16) | (escape_char1) | (escape_char2)
30005 */
30006
30007#ifdef DUK_USE_JX
30008 if (DUK_LIKELY(cp < 0x100UL)) {
30009 if (DUK_UNLIKELY(js_ctx->flag_ext_custom)) {
30011 } else {
30013 }
30014 } else
30015#endif
30016 if (DUK_LIKELY(cp < 0x10000UL)) {
30018 } else {
30019#ifdef DUK_USE_JX
30020 if (DUK_LIKELY(js_ctx->flag_ext_custom)) {
30022 } else
30023#endif
30024 {
30025 /* In compatible mode and standard JSON mode, output
30026 * something useful for non-BMP characters. This won't
30027 * roundtrip but will still be more or less readable and
30028 * more useful than an error.
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)
#define DUK__MKESC(nybbles, esc1, esc2)

◆ 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 58941 of file duktape-1.5.2/src/duktape.c.

58941 :
58943}
58944
58946 DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN); /* unsigned */
58947 DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
58948 /* Setting "no shuffle A" is covered by the assert, but it's needed
58949 * with DUK_USE_SHUFFLE_TORTURE.
58950 */
58951 duk__emit_a_b_c(comp_ctx,
58952 DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff), /* transfer flags */
#define DUK_BC_EXTRAOP_MAX
#define DUK_BC_EXTRAOP_MIN
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__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 58928 of file duktape-1.5.2/src/duktape.c.

58928 {
58929 ;
58930 } else {
58931 goto error_outofregs;
58932 }
58933 ins = DUK_ENC_OP_ABC(op, abc);
58934 DUK_DDD(DUK_DDDPRINT("duk__emit_abc: 0x%08lx line=%ld pc=%ld op=%ld (%!C) abc=%ld (%!I)",
58935 (unsigned long) ins, (long) comp_ctx->curr_token.start_line,
58936 (long) duk__get_current_pc(comp_ctx), (long) op, (long) op,
58937 (long) abc, (duk_instr_t) ins));
58938 duk__emit(comp_ctx, ins);
58939 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 58954 of file duktape-1.5.2/src/duktape.c.

58958 {
58959 DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN); /* unsigned */
58960 DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
58961 /* Setting "no shuffle A" is covered by the assert, but it's needed
58962 * with DUK_USE_SHUFFLE_TORTURE.
58963 */
58964 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 58966 of file duktape-1.5.2/src/duktape.c.

58971 {
58972 DUK_ASSERT_DISABLE(extraop >= DUK_BC_EXTRAOP_MIN); /* unsigned */
58973 DUK_ASSERT(extraop <= DUK_BC_EXTRAOP_MAX);
58974 /* Setting "no shuffle A" is covered by the assert, but it's needed
58975 * with DUK_USE_SHUFFLE_TORTURE.
58976 */
58977 duk__emit_a_bc(comp_ctx,

◆ duk__emit_hstring()

DUK_LOCAL_DECL void duk__emit_hstring ( duk_json_enc_ctx * js_ctx,
duk_hstring * h )

Definition at line 29945 of file duktape-1.5.2/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 59145 of file duktape-1.5.2/src/duktape.c.

59148 {
59149 /* No catch variable, e.g. a try-finally; replace LDCONST with
59150 * NOP to avoid a bogus LDCONST.
59151 */

◆ 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 59153 of file duktape-1.5.2/src/duktape.c.

◆ duk__emit_invalid()

DUK_LOCAL_DECL void duk__emit_invalid ( duk_compiler_ctx * comp_ctx)

◆ duk__emit_jump()

DUK_LOCAL_DECL void duk__emit_jump ( duk_compiler_ctx * comp_ctx,
duk_int_t target_pc )

Definition at line 59022 of file duktape-1.5.2/src/duktape.c.

59026 {
59027 duk__emit_load_int32_raw(comp_ctx, reg, val, DUK__EMIT_FLAG_NO_SHUFFLE_A /*op_flags*/);
59028}
59029#else
59030DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
59031 /* When torture not enabled, can just use the same helper because
duk_int32_t duk_reg_t
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)

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 59033 of file duktape-1.5.2/src/duktape.c.

59039 {

◆ 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 )

◆ 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 59013 of file duktape-1.5.2/src/duktape.c.

59018 {
59019 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 58980 of file duktape-1.5.2/src/duktape.c.

58983 {
58984 DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN); /* unsigned */
58985 DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
58986 /* Setting "no shuffle A" is covered by the assert, but it's needed
58987 * with DUK_USE_SHUFFLE_TORTURE.
58988 */
58989 duk__emit_a_b_c(comp_ctx,
58991 DUK__EMIT_FLAG_NO_SHUFFLE_C | (extraop_flags & ~0xff), /* transfer flags */
58992 extraop_flags & 0xff,
58993 0,
58994 0);
58995}
58996
58997DUK_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) {
58998 /* XXX: Shuffling support could be implemented here so that LDINT+LDINTX
58999 * 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 29955 of file duktape-1.5.2/src/duktape.c.

29958 {
29959 DUK_BW_WRITE_ENSURE_U8_2(js_ctx->thr, &js_ctx->bw, ch1, ch2);
29960}
29961
29963 DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h);
29964}
DUK_LOCAL_DECL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h)
#define DUK_BW_WRITE_ENSURE_HSTRING(thr, bw_ctx, val)
#define DUK_BW_WRITE_ENSURE_U8_2(thr, bw_ctx, val1, val2)

◆ 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 74899 of file duktape-1.5.2/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 31071 of file duktape-1.5.2/src/duktape.c.

31078 :
31079 duk_pop_2(ctx); /* [ ... key val ] -> [ ... ] */
31080 return 1; /* emitted */
31081
31082 pop2_undef:
31083 duk_pop_2(ctx); /* [ ... key val ] -> [ ... ] */
31084 return 0; /* not emitted */
31085}
31086
31087/* E5 Section 15.12.3, main algorithm, step 4.b.ii steps 1-4. */
DUK_LOCAL_DECL 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 30747 of file duktape-1.5.2/src/duktape.c.

30748 {
30749 DUK_ASSERT(js_ctx->recursion_depth >= 1);
30750 duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1);
30751 }
30752 }
30753 DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY);
30754
30755 duk__enc_objarr_exit(js_ctx, &entry_top);
30756
30757 DUK_ASSERT_TOP(ctx, entry_top);
30758}
30759
30760/* The JA(value) operation: encode array.
30761 *
30762 * Stack policy: [ array ] -> [ array ].
30763 */
30765 duk_context *ctx = (duk_context *) js_ctx->thr;
30766 duk_idx_t entry_top;
30767 duk_idx_t idx_arr;
30768 duk_bool_t emitted;
30769 duk_uarridx_t i, arr_len;
30770
30771 DUK_DDD(DUK_DDDPRINT("duk__enc_array: array=%!T",
30772 (duk_tval *) duk_get_tval(ctx, -1)));
30773
30774 duk__enc_objarr_entry(js_ctx, &entry_top);
30775
30776 idx_arr = entry_top - 1;
30777
30778 /* Steps 8-10 have been merged to avoid a "partial" variable. */
30779
30781
30782 arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_arr);
30783 emitted = 0;
30784 for (i = 0; i < arr_len; i++) {
30785 DUK_DDD(DUK_DDDPRINT("array entry loop: array=%!T, index=%ld, arr_len=%ld",
30786 (duk_tval *) duk_get_tval(ctx, idx_arr),
30787 (long) i, (long) arr_len));
30788
30789 if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) {
30790 DUK_ASSERT(js_ctx->recursion_depth >= 1);
30792 }
30793
30794 /* XXX: duk_push_uint_string() */
30795 duk_push_uint(ctx, (duk_uint_t) i);
30796 duk_to_string(ctx, -1); /* -> [ ... key ] */
30797
30798 /* [ ... key ] */
30799
30800 if (DUK_UNLIKELY(duk__enc_value(js_ctx, idx_arr) == 0)) {
30801 /* Value would normally be omitted, replace with 'null'. */
30803 } else {
30804 ;
30805 }
30806
30807 /* [ ... ] */
30808
30809 DUK__EMIT_1(js_ctx, DUK_ASC_COMMA);
DUK_LOCAL_DECL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top)
#define DUK__EMIT_STRIDX(js_ctx, i)
DUK_LOCAL_DECL void duk__enc_newline_indent(duk_json_enc_ctx *js_ctx, duk_int_t depth)
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)
#define DUK_STRIDX_LC_NULL
#define DUK_ASC_LBRACKET
DUK_LOCAL_DECL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top)
#define DUK__EMIT_1(js_ctx, ch)

◆ duk__enc_buffer()

DUK_LOCAL_DECL void duk__enc_buffer ( duk_json_enc_ctx * js_ctx,
duk_hbuffer * h )

Definition at line 30441 of file duktape-1.5.2/src/duktape.c.

30445 {

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 30387 of file duktape-1.5.2/src/duktape.c.

30394 {
30395 x = *p++;
30396 *q++ = duk_lc_digits[x >> 4];
30397 *q++ = duk_lc_digits[x & 0x0f];
30398 }
30399
30400 return q;
30401}
30402#endif /* DUK_USE_HEX_FASTPATH */
30403
30404DUK_LOCAL void duk__enc_buffer_data(duk_json_enc_ctx *js_ctx, duk_uint8_t *buf_data, duk_size_t buf_len) {
30405 duk_hthread *thr;
30406 duk_uint8_t *q;
30407 duk_size_t space;
30408
30409 thr = js_ctx->thr;
30410
30411 DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible); /* caller checks */
30413
30414 /* Buffer values are encoded in (lowercase) hex to make the
30415 * binary data readable. Base64 or similar would be more
30416 * compact but less readable, and the point of JX/JC
30417 * variants is to be as useful to a programmer as possible.
30418 */
30419
30420 /* The #ifdef clutter here needs to handle the three cases:
30421 * (1) JX+JC, (2) JX only, (3) JC only.
30422 */
30423
30424 /* Note: space must cater for both JX and JC. */
30425 space = 9 + buf_len * 2 + 2;
30426 DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7ffffffeUL);
30427 DUK_ASSERT((space - 2) / 2 >= buf_len); /* overflow not possible, buffer limits */
30428 q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space);
30429
30430#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
30431 if (js_ctx->flag_ext_custom)
30432#endif
30433#if defined(DUK_USE_JX)
30434 {
30435 *q++ = DUK_ASC_PIPE;
30436 q = duk__enc_buffer_data_hex(buf_data, buf_len, q);
30437 *q++ = DUK_ASC_PIPE;
30438
30439 }
DUK_LOCAL void duk__enc_buffer_data(duk_json_enc_ctx *js_ctx, duk_uint8_t *buf_data, duk_size_t buf_len)
DUK_INTERNAL const duk_uint8_t duk_lc_digits[36]
DUK_LOCAL duk_uint8_t * duk__enc_buffer_data_hex(const duk_uint8_t *src, duk_size_t src_len, duk_uint8_t *dst)

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 30310 of file duktape-1.5.2/src/duktape.c.

30327 {
30328 duk_uint8_t *q;
30329 duk_uint16_t *q16;
30331 duk_size_t i, len_safe;
30332#if !defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
30333 duk_bool_t shift_dst;
30334#endif
30335
30336 /* Unlike in duk_hex_encode() 'dst' is not necessarily aligned by 2.
30337 * For platforms where unaligned accesses are not allowed, shift 'dst'
30338 * ahead by 1 byte to get alignment and then DUK_MEMMOVE() the result
30339 * in place. The faster encoding loop makes up the difference.
30340 * There's always space for one extra byte because a terminator always
30341 * follows the hex data and that's been accounted for by the caller.
30342 */
30343
30344#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
30345 q16 = (duk_uint16_t *) (void *) dst;
30346#else
30347 shift_dst = (duk_bool_t) (((duk_size_t) dst) & 0x01U);
30348 if (shift_dst) {
30349 DUK_DD(DUK_DDPRINT("unaligned accesses not possible, dst not aligned -> step to dst + 1"));
30350 q16 = (duk_uint16_t *) (void *) (dst + 1);
30351 } else {
30352 DUK_DD(DUK_DDPRINT("unaligned accesses not possible, dst is aligned"));
30353 q16 = (duk_uint16_t *) (void *) dst;
30354 }
30355 DUK_ASSERT((((duk_size_t) q16) & 0x01U) == 0);
30356#endif
30357
30358 len_safe = src_len & ~0x03U;
30359 for (i = 0; i < len_safe; i += 4) {
30360 q16[0] = duk_hex_enctab[src[i]];
30361 q16[1] = duk_hex_enctab[src[i + 1]];
30362 q16[2] = duk_hex_enctab[src[i + 2]];
30363 q16[3] = duk_hex_enctab[src[i + 3]];
30364 q16 += 4;
30365 }
30366 q = (duk_uint8_t *) q16;
DUK_INTERNAL const duk_uint16_t duk_hex_enctab[256]

◆ duk__enc_bufferobject()

DUK_LOCAL_DECL void duk__enc_bufferobject ( duk_json_enc_ctx * js_ctx,
duk_hbufferobject * h_bufobj )

Definition at line 30486 of file duktape-1.5.2/src/duktape.c.

30490 {
30492 fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}";
30493 }
30494#endif
30495
30496 /* When ptr == NULL, the format argument is unused. */
30497 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 30218 of file duktape-1.5.2/src/duktape.c.

30219 {
30220 /* as is */
30221 DUK_RAW_WRITE_XUTF8(q, cp);
30222 }
30223 }
30224 }
30225
30226 DUK_BW_SET_PTR(thr, &js_ctx->bw, q);
30227 }
30228
30230}
30231
30232/* Encode a double (checked by caller) from stack top. Stack top may be
30233 * replaced by serialized string but is not popped (caller does that).
30234 */
30236 duk_hthread *thr;
30237 duk_context *ctx;
30238 duk_tval *tv;
30239 duk_double_t d;
30242 duk_small_uint_t stridx;
30243 duk_small_uint_t n2s_flags;
30244 duk_hstring *h_str;
30245
30246 DUK_ASSERT(js_ctx != NULL);
30247 thr = js_ctx->thr;
30248 DUK_ASSERT(thr != NULL);
30249 ctx = (duk_context *) thr;
30250
30251 /* Caller must ensure 'tv' is indeed a double and not a fastint! */
30252 tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
30254 d = DUK_TVAL_GET_DOUBLE(tv);
30255
30258 DUK_UNREF(s);
30259
30260 if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) {
30262
30263#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
30264 /* Negative zero needs special handling in JX/JC because
30265 * it would otherwise serialize to '0', not '-0'.
30266 */
30267 if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 &&
30268 (js_ctx->flag_ext_custom_or_compatible))) {
30270 } else
30271#endif /* DUK_USE_JX || DUK_USE_JC */
30272 {
30273 n2s_flags = 0;
30274 /* [ ... number ] -> [ ... string ] */
30275 duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags);
30276 }
30277 h_str = duk_to_hstring(ctx, -1);
30278 DUK_ASSERT(h_str != NULL);
30279 DUK__EMIT_HSTR(js_ctx, h_str);
30280 return;
30281 }
#define DUK_BW_SET_PTR(thr, bw_ctx, ptr)
#define DUK_TVAL_IS_DOUBLE(v)
#define DUK_GET_TVAL_NEGIDX(ctx, idx)
#define DUK__EMIT_HSTR(js_ctx, h)
#define DUK_STRIDX_MINUS_ZERO
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)
#define DUK_TVAL_GET_DOUBLE(tv)
DUK_LOCAL_DECL void duk__enc_double(duk_json_enc_ctx *js_ctx)

◆ duk__enc_key_autoquote()

DUK_LOCAL_DECL void duk__enc_key_autoquote ( duk_json_enc_ctx * js_ctx,
duk_hstring * k )

Definition at line 30030 of file duktape-1.5.2/src/duktape.c.

30038 {
30039 tmp--;
30040 dig = (duk_small_uint_t) ((cp >> (4 * tmp)) & 0x0f);
30041 *q++ = duk_lc_digits[dig];
30042 }
30043
30044 return q;
30045}
30046
30048 const duk_int8_t *p, *p_start, *p_end; /* Note: intentionally signed. */
30049 duk_size_t k_len;
30050 duk_codepoint_t cp;
30051
30052 DUK_ASSERT(k != NULL);
30053
30054 /* Accept ASCII strings which conform to identifier requirements
30055 * as being emitted without key quotes. Since we only accept ASCII
30056 * there's no need for actual decoding: 'p' is intentionally signed
30057 * so that bytes >= 0x80 extend to negative values and are rejected
30058 * as invalid identifier codepoints.
30059 */
30060
30061 if (js_ctx->flag_avoid_key_quotes) {
30062 k_len = DUK_HSTRING_GET_BYTELEN(k);
30063 p_start = (const duk_int8_t *) DUK_HSTRING_GET_DATA(k);
30064 p_end = p_start + k_len;
30065 p = p_start;
30066
30067 if (p == p_end) {
30068 /* Zero length string is not accepted without quotes */
30069 goto quote_normally;
30070 }
30071 cp = (duk_codepoint_t) (*p++);
30073 goto quote_normally;
30074 }
DUK_LOCAL_DECL void duk__enc_key_autoquote(duk_json_enc_ctx *js_ctx, duk_hstring *k)

◆ 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 30514 of file duktape-1.5.2/src/duktape.c.

30521 {
30522 DUK_ASSERT(js_ctx->h_gap != NULL);
30523 DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap) > 0); /* caller guarantees */
30524
30525 DUK__EMIT_1(js_ctx, 0x0a);
30526 while (depth-- > 0) {
30527 DUK__EMIT_HSTR(js_ctx, js_ctx->h_gap);
30528 }
30529}
30530#else /* DUK_USE_PREFER_SIZE */
30532 const duk_uint8_t *gap_data;
30533 duk_size_t gap_len;
30534 duk_size_t avail_bytes; /* bytes of indent available for copying */
30535 duk_size_t need_bytes; /* bytes of indent still needed */
30536 duk_uint8_t *p_start;
30537 duk_uint8_t *p;
30538
30539 DUK_ASSERT(js_ctx->h_gap != NULL);
30540 DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap) > 0); /* caller guarantees */
30541
30542 DUK__EMIT_1(js_ctx, 0x0a);
30543 if (DUK_UNLIKELY(depth == 0)) {
30544 return;
30545 }
30546
30547 /* To handle deeper indents efficiently, make use of copies we've
30548 * already emitted. In effect we can emit a sequence of 1, 2, 4,
30549 * 8, etc copies, and then finish the last run. Byte counters
30550 * avoid multiply with gap_len on every loop.
30551 */
30552
30553 gap_data = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(js_ctx->h_gap);
30554 gap_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap);
30555 DUK_ASSERT(gap_len > 0);
30556
30557 need_bytes = gap_len * depth;
30558 p = DUK_BW_ENSURE_GETPTR(js_ctx->thr, &js_ctx->bw, need_bytes);
30559 p_start = p;
30560
30561 DUK_MEMCPY((void *) p, (const void *) gap_data, (size_t) gap_len);
30562 p += gap_len;
30563 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 30567 of file duktape-1.5.2/src/duktape.c.

30567 {
30568 DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) avail_bytes);
30569 p += avail_bytes;
30570 need_bytes -= avail_bytes;
30571 avail_bytes <<= 1;
30572 }
30573
30574 DUK_ASSERT(need_bytes < avail_bytes); /* need_bytes may be zero */
30575 DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) need_bytes);
30576 p += need_bytes;
30577 /*avail_bytes += need_bytes*/
30578
30579 DUK_BW_SET_PTR(js_ctx->thr, &js_ctx->bw, p);
30580}
30581#endif /* DUK_USE_PREFER_SIZE */
30582
30583/* Shared entry handling for object/array serialization. */
30585 duk_context *ctx = (duk_context *) js_ctx->thr;
30586 duk_hobject *h_target;
30587 duk_uint_fast32_t i, n;
30588
30589 *entry_top = duk_get_top(ctx);
30590
30592
30593 /* Loop check using a hybrid approach: a fixed-size visited[] array
30594 * with overflow in a loop check object.
30595 */
30596
30597 h_target = duk_get_hobject(ctx, -1); /* object or array */
30598 DUK_ASSERT(h_target != NULL);
30599
30600 n = js_ctx->recursion_depth;
30603 }
30604 for (i = 0; i < n; i++) {
30605 if (DUK_UNLIKELY(js_ctx->visiting[i] == h_target)) {
30606 DUK_DD(DUK_DDPRINT("slow path loop detect"));
30608 }
30609 }
30611 js_ctx->visiting[js_ctx->recursion_depth] = h_target;
30612 } else {
30613 duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
30614 duk_dup_top(ctx); /* -> [ ... voidp voidp ] */
30615 if (duk_has_prop(ctx, js_ctx->idx_loop)) {
#define DUK_JSON_ENC_LOOPARRAY
#define DUK_STR_FMT_PTR
#define DUK_JSON_ENC_REQSTACK
#define DUK_STR_CYCLIC_INPUT
DUK_EXTERNAL const char * duk_push_sprintf(duk_context *ctx, const char *fmt,...)
duk_hobject * visiting[DUK_JSON_ENC_LOOPARRAY]

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 30619 of file duktape-1.5.2/src/duktape.c.

30626 {
30628 }
30629 js_ctx->recursion_depth++;
30630
30631 DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
30632 (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
30633}
30634
30635/* Shared exit handling for object/array serialization. */
30636DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top) {
30637 duk_context *ctx = (duk_context *) js_ctx->thr;
30638 duk_hobject *h_target;
30639
30640 /* C recursion check. */
30641
30642 DUK_ASSERT(js_ctx->recursion_depth > 0);
30643 DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
30644 js_ctx->recursion_depth--;
30645
30646 /* Loop check. */
#define DUK_STR_JSONENC_RECLIMIT

◆ duk__enc_object()

DUK_LOCAL_DECL void duk__enc_object ( duk_json_enc_ctx * js_ctx)

Definition at line 30652 of file duktape-1.5.2/src/duktape.c.

30653 {
30654 duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
30655 duk_del_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */
30656 }
30657
30658 /* Restore stack top after unbalanced code paths. */
30659 duk_set_top(ctx, *entry_top);
30660
30661 DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
30662 (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
30663}
30664
30665/* The JO(value) operation: encode object.
30666 *
30667 * Stack policy: [ object ] -> [ object ].
30668 */
30670 duk_context *ctx = (duk_context *) js_ctx->thr;
30671 duk_hstring *h_key;
30672 duk_idx_t entry_top;
30673 duk_idx_t idx_obj;
30674 duk_idx_t idx_keys;
30675 duk_bool_t emitted;
30676 duk_uarridx_t arr_len, i;
30677 duk_size_t prev_size;
30678
30679 DUK_DDD(DUK_DDDPRINT("duk__enc_object: obj=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
30680
30681 duk__enc_objarr_entry(js_ctx, &entry_top);
30682
30683 idx_obj = entry_top - 1;
30684
30685 if (js_ctx->idx_proplist >= 0) {
30686 idx_keys = js_ctx->idx_proplist;
30687 } else {
30688 /* XXX: would be nice to enumerate an object at specified index */
30689 duk_dup(ctx, idx_obj);
30690 (void) duk_hobject_get_enumerated_keys(ctx, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/); /* [ ... target ] -> [ ... target keys ] */
30691 idx_keys = duk_require_normalize_index(ctx, -1);
30692 /* leave stack unbalanced on purpose */
30693 }
30694
30695 DUK_DDD(DUK_DDDPRINT("idx_keys=%ld, h_keys=%!T",
30696 (long) idx_keys, (duk_tval *) duk_get_tval(ctx, idx_keys)));
30697
30698 /* Steps 8-10 have been merged to avoid a "partial" variable. */
30699
30700 DUK__EMIT_1(js_ctx, DUK_ASC_LCURLY);
30701
30702 /* XXX: keys is an internal object with all keys to be processed
30703 * in its (gapless) array part. Because nobody can touch the keys
30704 * object, we could iterate its array part directly (keeping in mind
30705 * that it can be reallocated).
30706 */
30707
30708 arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_keys);
30709 emitted = 0;
30710 for (i = 0; i < arr_len; i++) {
30711 duk_get_prop_index(ctx, idx_keys, i); /* -> [ ... key ] */
30712
30713 DUK_DDD(DUK_DDDPRINT("object property loop: holder=%!T, key=%!T",
30714 (duk_tval *) duk_get_tval(ctx, idx_obj),
30715 (duk_tval *) duk_get_tval(ctx, -1)));
30716
30717 h_key = duk_get_hstring(ctx, -1);
30718 DUK_ASSERT(h_key != NULL);
30719
30720 prev_size = DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw);
30721 if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) {
30723 duk__enc_key_autoquote(js_ctx, h_key);
30725 } else {
30726 duk__enc_key_autoquote(js_ctx, h_key);
30727 DUK__EMIT_1(js_ctx, DUK_ASC_COLON);
30728 }
30729
30730 /* [ ... key ] */
30731
30732 if (DUK_UNLIKELY(duk__enc_value(js_ctx, idx_obj) == 0)) {
30733 /* Value would yield 'undefined', so skip key altogether.
30734 * Side effects have already happened.
30735 */
30736 DUK_BW_SET_SIZE(js_ctx->thr, &js_ctx->bw, prev_size);
30737 } else {
30738 DUK__EMIT_1(js_ctx, DUK_ASC_COMMA);
30739 emitted = 1;
30740 }
30741
DUK_EXTERNAL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index)
#define DUK__EMIT_2(js_ctx, ch1, ch2)
#define DUK_BW_SET_SIZE(thr, bw_ctx, sz)
DUK_INTERNAL_DECL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_small_uint_t enum_flags)
#define DUK_ASC_LCURLY
#define DUK_ASC_SPACE
DUK_LOCAL_DECL void duk__enc_object(duk_json_enc_ctx *js_ctx)

◆ duk__enc_pointer()

DUK_LOCAL_DECL void duk__enc_pointer ( duk_json_enc_ctx * js_ctx,
void * ptr )

Definition at line 30449 of file duktape-1.5.2/src/duktape.c.

30458 {
30459 duk__enc_buffer_data(js_ctx,
30460 (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(js_ctx->thr->heap, h),
30462}
30463#endif /* DUK_USE_JX || DUK_USE_JC */
30464
30465#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
30466DUK_LOCAL void duk__enc_pointer(duk_json_enc_ctx *js_ctx, void *ptr) {
30467 char buf[64]; /* XXX: how to figure correct size? */
30468 const char *fmt;
30469
30470 DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible); /* caller checks */
30472
30473 DUK_MEMZERO(buf, sizeof(buf));
30474
30475 /* The #ifdef clutter here needs to handle the three cases:
30476 * (1) JX+JC, (2) JX only, (3) JC only.
30477 */
30478#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
30479 if (js_ctx->flag_ext_custom)
30480#endif
30481#if defined(DUK_USE_JX)
30482 {
DUK_LOCAL_DECL void duk__enc_pointer(duk_json_enc_ctx *js_ctx, void *ptr)

◆ 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 30081 of file duktape-1.5.2/src/duktape.c.

30089 :
30090 duk__enc_quote_string(js_ctx, k);
30091}
30092
30093/* The Quote(value) operation: quote a string.
30094 *
30095 * Stack policy: [ ] -> [ ].
30096 */
30097
30099 duk_hthread *thr = js_ctx->thr;
30100 const duk_uint8_t *p, *p_start, *p_end, *p_now, *p_tmp;
30101 duk_uint8_t *q;
30102 duk_ucodepoint_t cp; /* typed for duk_unicode_decode_xutf8() */
30103
30104 DUK_DDD(DUK_DDDPRINT("duk__enc_quote_string: h_str=%!O", (duk_heaphdr *) h_str));
30105
30106 DUK_ASSERT(h_str != NULL);
30107 p_start = DUK_HSTRING_GET_DATA(h_str);
30108 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_str);
30109 p = p_start;
30110
30112
30113 /* Encode string in small chunks, estimating the maximum expansion so that
30114 * there's no need to ensure space while processing the chunk.
30115 */
30116
30117 while (p < p_end) {
30118 duk_size_t left, now, space;
30119
30120 left = (duk_size_t) (p_end - p);
30123
30124 /* Maximum expansion per input byte is 6:
30125 * - invalid UTF-8 byte causes "\uXXXX" to be emitted (6/1 = 6).
30126 * - 2-byte UTF-8 encodes as "\uXXXX" (6/2 = 3).
30127 * - 4-byte UTF-8 encodes as "\Uxxxxxxxx" (10/4 = 2.5).
30128 */
30129 space = now * 6;
30130 q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space);
30131
30132 p_now = p + now;
30133
30134 while (p < p_now) {
30135#if defined(DUK_USE_JSON_QUOTESTRING_FASTPATH)
30136 duk_uint8_t b;
30137
30138 b = duk__json_quotestr_lookup[*p++];
30139 if (DUK_LIKELY(b < 0x80)) {
30140 /* Most input bytes go through here. */
30141 *q++ = b;
30142 } else if (b >= 0xa0) {
30143 *q++ = DUK_ASC_BACKSLASH;
30144 *q++ = (duk_uint8_t) (b - 0x80);
30145 } else if (b == 0x80) {
30146 cp = (duk_ucodepoint_t) (*(p - 1));
30147 q = duk__emit_esc_auto_fast(js_ctx, cp, q);
30148 } else if (b == 0x7f && js_ctx->flag_ascii_only) {
30149 /* 0x7F is special */
30150 DUK_ASSERT(b == 0x81);
30151 cp = (duk_ucodepoint_t) 0x7f;
30152 q = duk__emit_esc_auto_fast(js_ctx, cp, q);
30153 } else {
30154 DUK_ASSERT(b == 0x81);
30155 p--;
30156
30157 /* slow path is shared */
30158#else /* DUK_USE_JSON_QUOTESTRING_FASTPATH */
30159 cp = *p;
30160
30161 if (DUK_LIKELY(cp <= 0x7f)) {
30162 /* ascii fast path: avoid decoding utf-8 */
30163 p++;
30164 if (cp == 0x22 || cp == 0x5c) {
30165 /* double quote or backslash */
30166 *q++ = DUK_ASC_BACKSLASH;
30167 *q++ = (duk_uint8_t) cp;
30168 } else if (cp < 0x20) {
30169 duk_uint_fast8_t esc_char;
30170
30171 /* This approach is a bit shorter than a straight
30172 * if-else-ladder and also a bit faster.
30173 */
30174 if (cp < (sizeof(duk__json_quotestr_esc) / sizeof(duk_uint8_t)) &&
30175 (esc_char = duk__json_quotestr_esc[cp]) != 0) {
30176 *q++ = DUK_ASC_BACKSLASH;
30177 *q++ = (duk_uint8_t) esc_char;
30178 } else {
30179 q = duk__emit_esc_auto_fast(js_ctx, cp, q);
30180 }
30181 } else if (cp == 0x7f && js_ctx->flag_ascii_only) {
30182 q = duk__emit_esc_auto_fast(js_ctx, cp, q);
30183 } else {
30184 /* any other printable -> as is */
30185 *q++ = (duk_uint8_t) cp;
30186 }
30187 } else {
30188 /* slow path is shared */
30189#endif /* DUK_USE_JSON_QUOTESTRING_FASTPATH */
30190
30191 /* slow path decode */
30192
30193 /* If XUTF-8 decoding fails, treat the offending byte as a codepoint directly
30194 * and go forward one byte. This is of course very lossy, but allows some kind
30195 * of output to be produced even for internal strings which don't conform to
30196 * XUTF-8. All standard Ecmascript strings are always CESU-8, so this behavior
30197 * does not violate the Ecmascript specification. The behavior is applied to
30198 * all modes, including Ecmascript standard JSON. Because the current XUTF-8
30199 * decoding is not very strict, this behavior only really affects initial bytes
30200 * and truncated codepoints.
30201 *
30202 * Another alternative would be to scan forwards to start of next codepoint
30203 * (or end of input) and emit just one replacement codepoint.
30204 */
30205
30206 p_tmp = p;
30207 if (!duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) {
30208 /* Decode failed. */
30209 cp = *p_tmp;
30210 p = p_tmp + 1;
30211 }
30212
30213#ifdef DUK_USE_NONSTD_JSON_ESC_U2028_U2029
DUK_LOCAL_DECL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str)
DUK_LOCAL const duk_uint8_t duk__json_quotestr_lookup[256]
#define DUK__JSON_ENCSTR_CHUNKSIZE
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)
lu_byte left

◆ 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 30815 of file duktape-1.5.2/src/duktape.c.

30816 {
30817 DUK_ASSERT(js_ctx->recursion_depth >= 1);
30818 duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1);
30819 }
30820 }
30822
30823 duk__enc_objarr_exit(js_ctx, &entry_top);
30824
30825 DUK_ASSERT_TOP(ctx, entry_top);
30826}
30827
30828/* The Str(key, holder) operation.
30829 *
30830 * Stack policy: [ ... key ] -> [ ... ]
30831 */
30833 duk_context *ctx = (duk_context *) js_ctx->thr;
30834 duk_hthread *thr = (duk_hthread *) ctx;
30835 duk_hobject *h_tmp;
30836 duk_tval *tv;
30837 duk_tval *tv_holder;
30838 duk_tval *tv_key;
30840
30841 DUK_DDD(DUK_DDDPRINT("duk__enc_value: idx_holder=%ld, holder=%!T, key=%!T",
30842 (long) idx_holder, (duk_tval *) duk_get_tval(ctx, idx_holder),
30843 (duk_tval *) duk_get_tval(ctx, -1)));
30844
30845 DUK_UNREF(thr);
30846
30847 tv_holder = DUK_GET_TVAL_POSIDX(ctx, idx_holder);
30848 DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_holder));
30849 tv_key = DUK_GET_TVAL_NEGIDX(ctx, -1);
30851 (void) duk_hobject_getprop(thr, tv_holder, tv_key);
30852
30853 /* -> [ ... key val ] */
30854
30855 DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
30856
30857 h_tmp = duk_get_hobject_or_lfunc_coerce(ctx, -1);
30858 if (h_tmp != NULL) {
30860 h_tmp = duk_get_hobject_or_lfunc_coerce(ctx, -1); /* toJSON() can also be a lightfunc */
30861
30862 if (h_tmp != NULL && DUK_HOBJECT_IS_CALLABLE(h_tmp)) {
30863 DUK_DDD(DUK_DDDPRINT("value is object, has callable toJSON() -> call it"));
30864 /* XXX: duk_dup_unvalidated(ctx, -2) etc. */
30865 duk_dup(ctx, -2); /* -> [ ... key val toJSON val ] */
30866 duk_dup(ctx, -4); /* -> [ ... key val toJSON val key ] */
30867 duk_call_method(ctx, 1); /* -> [ ... key val val' ] */
30868 duk_remove(ctx, -2); /* -> [ ... key val' ] */
30869 } else {
30870 duk_pop(ctx); /* -> [ ... key val ] */
30871 }
30872 }
30873
30874 /* [ ... key val ] */
30875
30876 DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
30877
30878 if (js_ctx->h_replacer) {
30879 /* XXX: Here a "slice copy" would be useful. */
30880 DUK_DDD(DUK_DDDPRINT("replacer is set, call replacer"));
30881 duk_push_hobject(ctx, js_ctx->h_replacer); /* -> [ ... key val replacer ] */
30882 duk_dup(ctx, idx_holder); /* -> [ ... key val replacer holder ] */
30883 duk_dup(ctx, -4); /* -> [ ... key val replacer holder key ] */
30884 duk_dup(ctx, -4); /* -> [ ... key val replacer holder key val ] */
30885 duk_call_method(ctx, 2); /* -> [ ... key val val' ] */
30886 duk_remove(ctx, -2); /* -> [ ... key val' ] */
30887 }
30888
30889 /* [ ... key val ] */
30890
30891 DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
30892
30893 tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
30894 if (DUK_TVAL_IS_OBJECT(tv)) {
30895 duk_hobject *h;
30896
30897 h = DUK_TVAL_GET_OBJECT(tv);
30898 DUK_ASSERT(h != NULL);
30899
30901#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
30902 duk_hbufferobject *h_bufobj;
30903 h_bufobj = (duk_hbufferobject *) h;
30905
30906 /* Conceptually we'd extract the plain underlying buffer
30907 * or its slice and then do a type mask check below to
30908 * see if we should reject it. Do the mask check here
30909 * instead to avoid making a copy of the buffer slice.
30910 */
30911
30913 DUK_DDD(DUK_DDDPRINT("-> bufferobject (-> plain buffer) will result in undefined (type mask check)"));
30914 goto pop2_undef;
30915 }
30916 DUK_DDD(DUK_DDDPRINT("-> bufferobject won't result in undefined, encode directly"));
30917 duk__enc_bufferobject(js_ctx, h_bufobj);
30918 goto pop2_emitted;
30919#else
30920 DUK_DDD(DUK_DDDPRINT("no JX/JC support, bufferobject/buffer will always result in undefined"));
30921 goto pop2_undef;
30922#endif
30923 } else {
30925 switch ((int) c) {
30927 DUK_DDD(DUK_DDDPRINT("value is a Number object -> coerce with ToNumber()"));
30928 duk_to_number(ctx, -1);
30929 /* The coercion potentially invokes user .valueOf() and .toString()
30930 * but can't result in a function value because [[DefaultValue]] would
30931 * reject such a result: test-dev-json-stringify-coercion-1.js.
30932 */
30933 DUK_ASSERT(!duk_is_callable(ctx, -1));
30934 break;
30935 }
30937 DUK_DDD(DUK_DDDPRINT("value is a String object -> coerce with ToString()"));
30938 duk_to_string(ctx, -1);
30939 /* Same coercion behavior as for Number. */
30940 DUK_ASSERT(!duk_is_callable(ctx, -1));
30941 break;
30942 }
30943#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
30945#endif
30947 DUK_DDD(DUK_DDDPRINT("value is a Boolean/Buffer/Pointer object -> get internal value"));
30949 duk_remove(ctx, -2);
30950 break;
30951 }
30952 default: {
30953 /* Normal object which doesn't get automatically coerced to a
30954 * primitive value. Functions are checked for specially. The
30955 * primitive value coercions for Number, String, Pointer, and
30956 * Boolean can't result in functions so suffices to check here.
30957 */
30958 DUK_ASSERT(h != NULL);
30959 if (DUK_HOBJECT_IS_CALLABLE(h)) {
30960#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
30961 if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
30963 /* We only get here when doing non-standard JSON encoding */
30964 DUK_DDD(DUK_DDDPRINT("-> function allowed, serialize to custom format"));
30967 goto pop2_emitted;
30968 } else {
30969 DUK_DDD(DUK_DDDPRINT("-> will result in undefined (function)"));
30970 goto pop2_undef;
30971 }
30972#else /* DUK_USE_JX || DUK_USE_JC */
30973 DUK_DDD(DUK_DDDPRINT("-> will result in undefined (function)"));
30974 goto pop2_undef;
30975#endif /* DUK_USE_JX || DUK_USE_JC */
30976 }
30977 }
30978 } /* end switch */
30979 }
30980 }
30981
30982 /* [ ... key val ] */
30983
30984 DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
30985
30986 if (duk_check_type_mask(ctx, -1, js_ctx->mask_for_undefined)) {
30987 /* will result in undefined */
30988 DUK_DDD(DUK_DDDPRINT("-> will result in undefined (type mask check)"));
30989 goto pop2_undef;
30990 }
30991 tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
30992
30993 switch (DUK_TVAL_GET_TAG(tv)) {
30994#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
30995 /* When JX/JC not in use, the type mask above will avoid this case if needed. */
30996 case DUK_TAG_UNDEFINED: {
30998 break;
30999 }
31000#endif
31001 case DUK_TAG_NULL: {
31003 break;
31004 }
31005 case DUK_TAG_BOOLEAN: {
31008 break;
31009 }
31010#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31011 /* When JX/JC not in use, the type mask above will avoid this case if needed. */
31012 case DUK_TAG_POINTER: {
31014 break;
31015 }
31016#endif /* DUK_USE_JX || DUK_USE_JC */
31017 case DUK_TAG_STRING: {
31019 DUK_ASSERT(h != NULL);
31020
31021 duk__enc_quote_string(js_ctx, h);
31022 break;
31023 }
31024 case DUK_TAG_OBJECT: {
31026 DUK_ASSERT(h != NULL);
31027
31028 /* Function values are handled completely above (including
31029 * coercion results):
31030 */
31032
31034 duk__enc_array(js_ctx);
31035 } else {
31036 duk__enc_object(js_ctx);
31037 }
31038 break;
31039 }
31040#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31041 /* When JX/JC not in use, the type mask above will avoid this case if needed. */
31042 case DUK_TAG_BUFFER: {
31044 break;
31045 }
31046#endif /* DUK_USE_JX || DUK_USE_JC */
31047 case DUK_TAG_LIGHTFUNC: {
31048#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31049 /* We only get here when doing non-standard JSON encoding */
31052#else
31053 /* Standard JSON omits functions */
31055#endif
31056 break;
31057 }
31058#if defined(DUK_USE_FASTINT)
31059 case DUK_TAG_FASTINT:
31060 /* Number serialization has a significant impact relative to
31061 * other fast path code, so careful fast path for fastints.
31062 */
31063 duk__enc_fastint_tval(js_ctx, tv);
31064 break;
31065#endif
31066 default: {
31067 /* number */
#define DUK_TYPE_MASK_BUFFER
#define duk_is_callable(ctx, index)
#define DUK_HOBJECT_CLASS_BOOLEAN
#define DUK_HOBJECT_CLASS_POINTER
#define DUK_STRIDX_TRUE
DUK_EXTERNAL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask)
#define DUK_ASC_RBRACKET
#define DUK_ASSERT_HBUFFEROBJECT_VALID(h)
#define DUK_TVAL_IS_UNUSED(tv)
#define DUK_HOBJECT_CLASS_NUMBER
#define DUK_STRIDX_FALSE
#define DUK_JSON_FLAG_EXT_CUSTOM
#define DUK_STRIDX_INT_VALUE
DUK_INTERNAL_DECL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key)
#define DUK_TVAL_GET_POINTER(tv)
DUK_INTERNAL_DECL duk_hobject * duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index)
DUK_LOCAL_DECL void duk__enc_buffer(duk_json_enc_ctx *js_ctx, duk_hbuffer *h)
#define DUK_TVAL_GET_BOOLEAN(tv)
#define DUK_GET_TVAL_POSIDX(ctx, idx)
DUK_LOCAL_DECL void duk__enc_bufferobject(duk_json_enc_ctx *js_ctx, duk_hbufferobject *h_bufobj)
#define DUK_STRIDX_TO_JSON
#define DUK_JSON_FLAG_EXT_COMPATIBLE
#define DUK_HOBJECT_CLASS_STRING

◆ duk__encode_i32()

DUK_LOCAL duk_uint32_t duk__encode_i32 ( duk_int32_t x)

Definition at line 77440 of file duktape-1.5.2/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 40071 of file duktape-1.5.2/src/duktape.c.

40074 {
40075 duk_pop(ctx);
40076 }
40077
40078 DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T",
40079 (duk_tval *) duk_get_tval(ctx, -1)));
40080}
40081
40082/*
40083 * Augment an error being created using Duktape specific properties
40084 * like _Tracedata or .fileName/.lineNumber.
40085 */
40086
40087#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
40088DUK_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) {
40089 duk_context *ctx = (duk_context *) thr;
40090#if defined(DUK_USE_ASSERTIONS)
40091 duk_int_t entry_top;
40092#endif
40093
40094#if defined(DUK_USE_ASSERTIONS)
40095 entry_top = duk_get_top(ctx);
40096#endif
40097 DUK_ASSERT(obj != NULL);
40098
40099 DUK_UNREF(obj); /* unreferenced w/o tracebacks */
40100 DUK_UNREF(ctx); /* unreferenced w/o asserts */
40101
40103
40104#if defined(DUK_USE_TRACEBACKS)
40105 /* If tracebacks are enabled, the '_Tracedata' property is the only
40106 * thing we need: 'fileName' and 'lineNumber' are virtual properties
40107 * which use '_Tracedata'.
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)

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 39685 of file duktape-1.5.2/src/duktape.c.

39693 : since further longjmp()s may occur while calling the error handler
39694 * (for many reasons, e.g. a labeled 'break' inside the handler), the
39695 * caller can make no assumptions on the thr->heap->lj state after the
39696 * call (this affects especially duk_error_throw.c). This is not an issue
39697 * as long as the caller writes to the lj state only after the error handler
39698 * finishes.
39699 */
39700
39701#if defined(DUK_USE_ERRTHROW) || defined(DUK_USE_ERRCREATE)
39703 duk_context *ctx = (duk_context *) thr;
39704 duk_tval *tv_hnd;
39705 duk_small_uint_t call_flags;
39706 duk_int_t rc;
39707
39708 DUK_ASSERT(thr != NULL);
39709 DUK_ASSERT(thr->heap != NULL);
39710 DUK_ASSERT_DISABLE(stridx_cb >= 0); /* unsigned */
39711 DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS);
39712
39714 DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore"));
39715 return;
39716 }
39717
39718 /*
39719 * Check whether or not we have an error handler.
39720 *
39721 * We must be careful of not triggering an error when looking up the
39722 * property. For instance, if the property is a getter, we don't want
39723 * to call it, only plain values are allowed. The value, if it exists,
39724 * is not checked. If the value is not a function, a TypeError happens
39725 * when it is called and that error replaces the original one.
39726 */
39727
39728 DUK_ASSERT_VALSTACK_SPACE(thr, 4); /* 3 entries actually needed below */
39729
39730 /* [ ... errval ] */
39731
39732 if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) {
39733 /* When creating built-ins, some of the built-ins may not be set
39734 * and we want to tolerate that when throwing errors.
39735 */
39736 DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring"));
39737 return;
39738 }
39741 DUK_HTHREAD_GET_STRING(thr, stridx_cb));
39742 if (tv_hnd == NULL) {
39743 DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T",
39744 (duk_tval *) tv_hnd));
39745 return;
39746 }
39747 DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T",
39748 (duk_tval *) tv_hnd));
39749 duk_push_tval(ctx, tv_hnd);
39750
39751 /* [ ... errval errhandler ] */
39752
39753 duk_insert(ctx, -2); /* -> [ ... errhandler errval ] */
39754 duk_push_undefined(ctx);
39755 duk_insert(ctx, -2); /* -> [ ... errhandler undefined(= this) errval ] */
39756
39757 /* [ ... errhandler undefined errval ] */
39758
39759 /*
39760 * DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C
39761 * recursion depth limit (and won't increase it either). This is
39762 * dangerous, but useful because it allows the error handler to run
39763 * even if the original error is caused by C recursion depth limit.
39764 *
39765 * The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the
39766 * duration of the error handler and cleared afterwards. This flag
39767 * prevents the error handler from running recursively. The flag is
39768 * heap level so that the flag properly controls even coroutines
39769 * launched by an error handler. Since the flag is heap level, it is
39770 * critical to restore it correctly.
39771 *
39772 * We ignore errors now: a success return and an error value both
39773 * replace the original error value. (This would be easy to change.)
#define DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap)
DUK_EXTERNAL void duk_push_undefined(duk_context *ctx)
#define DUK_BIDX_DUKTAPE
DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb)
duk_hobject * builtins[DUK_NUM_BUILTINS]

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 26981 of file duktape-1.5.2/src/duktape.c.

26987 : although _Tracedata is an internal property, user code can currently
26988 * write to the array (or replace it with something other than an array).
26989 * The code below must tolerate arbitrary _Tracedata. It can throw errors
26990 * etc, but cannot cause a segfault or memory unsafe behavior.
26991 */
26992
26993/* constants arbitrary, chosen for small loads */
26994#define DUK__OUTPUT_TYPE_TRACEBACK (-1)
26995#define DUK__OUTPUT_TYPE_FILENAME 0
26996#define DUK__OUTPUT_TYPE_LINENUMBER 1
26997
26999 duk_hthread *thr = (duk_hthread *) ctx;
27000 duk_idx_t idx_td;
27001 duk_small_int_t i; /* traceback depth fits into 16 bits */
27002 duk_small_int_t t; /* stack type fits into 16 bits */
27003 duk_small_int_t count_func = 0; /* traceback depth ensures fits into 16 bits */
27004 const char *str_tailcall = " tailcall";
27005 const char *str_strict = " strict";
27006 const char *str_construct = " construct";
27007 const char *str_prevyield = " preventsyield";
27008 const char *str_directeval = " directeval";
27009 const char *str_empty = "";
27010
27011 DUK_ASSERT_TOP(ctx, 0); /* fixed arg count */
27012 DUK_UNREF(thr);
27013
27014 duk_push_this(ctx);
27016 idx_td = duk_get_top_index(ctx);
27017
27019 duk_push_this(ctx);
27020
27021 /* [ ... this tracedata sep this ] */
27022
27023 /* XXX: skip null filename? */
27024
27025 if (duk_check_type(ctx, idx_td, DUK_TYPE_OBJECT)) {
27026 /* Current tracedata contains 2 entries per callstack entry. */
27027 for (i = 0; ; i += 2) {
27028 duk_int_t pc;
27029 duk_int_t line;
27030 duk_int_t flags;
27031 duk_double_t d;
27032 const char *funcname;
27033 const char *filename;
27034 duk_hobject *h_func;
27035 duk_hstring *h_name;
27036
27037 duk_require_stack(ctx, 5);
27038 duk_get_prop_index(ctx, idx_td, i);
27039 duk_get_prop_index(ctx, idx_td, i + 1);
27040 d = duk_to_number(ctx, -1);
27042 flags = (duk_int_t) DUK_FLOOR(d / DUK_DOUBLE_2TO32);
27043 t = (duk_small_int_t) duk_get_type(ctx, -2);
27044
27045 if (t == DUK_TYPE_OBJECT || t == DUK_TYPE_LIGHTFUNC) {
27046 /*
27047 * Ecmascript/native function call or lightfunc call
27048 */
27049
27050 count_func++;
27051
27052 /* [ ... v1(func) v2(pc+flags) ] */
27053
27054 h_func = duk_get_hobject(ctx, -2); /* NULL for lightfunc */
27055
27058
27059#if defined(DUK_USE_PC2LINE)
27060 line = duk_hobject_pc2line_query(ctx, -4, (duk_uint_fast32_t) pc);
27061#else
27062 line = 0;
27063#endif
27064
27065 /* [ ... v1 v2 name filename ] */
27066
27067 /* When looking for .fileName/.lineNumber, blame first
27068 * function which has a .fileName.
27069 */
27070 if (duk_is_string(ctx, -1)) {
27071 if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
27072 return 1;
27073 } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
27074 duk_push_int(ctx, line);
27075 return 1;
27076 }
27077 }
27078
27079 /* XXX: Change 'anon' handling here too, to use empty string for anonymous functions? */
27080 /* XXX: Could be improved by coercing to a readable duk_tval (especially string escaping) */
27081 h_name = duk_get_hstring(ctx, -2); /* may be NULL */
27082 funcname = (h_name == NULL || h_name == DUK_HTHREAD_STRING_EMPTY_STRING(thr)) ?
27083 "[anon]" : (const char *) DUK_HSTRING_GET_DATA(h_name);
27084 filename = duk_get_string(ctx, -1);
27085 filename = filename ? filename : "";
27087 DUK_ASSERT(filename != NULL);
27088
27089 if (h_func == NULL) {
27090 duk_push_sprintf(ctx, "at %s light%s%s%s%s%s",
27091 (const char *) funcname,
27092 (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
27093 (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
27094 (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
27095 (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
27096 (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
27097 } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h_func)) {
27098 duk_push_sprintf(ctx, "at %s (%s) native%s%s%s%s%s",
27099 (const char *) funcname,
27100 (const char *) filename,
27101 (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
27102 (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
27103 (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
27104 (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
27105 (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
27106 } else {
27107 duk_push_sprintf(ctx, "at %s (%s:%ld)%s%s%s%s%s",
27108 (const char *) funcname,
27109 (const char *) filename,
27110 (long) line,
27111 (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
27112 (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
27113 (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
27114 (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
27115 (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
27116 }
27117 duk_replace(ctx, -5); /* [ ... v1 v2 name filename str ] -> [ ... str v2 name filename ] */
27118 duk_pop_n(ctx, 3); /* -> [ ... str ] */
27119 } else if (t == DUK_TYPE_STRING) {
27120 /*
27121 * __FILE__ / __LINE__ entry, here 'pc' is line number directly.
27122 * Sometimes __FILE__ / __LINE__ is reported as the source for
27123 * the error (fileName, lineNumber), sometimes not.
27124 */
27125
27126 /* [ ... v1(filename) v2(line+flags) ] */
27127
27128 /* When looking for .fileName/.lineNumber, blame compilation
27129 * or C call site unless flagged not to do so.
27130 */
27131 if (!(flags & DUK_TB_FLAG_NOBLAME_FILELINE)) {
27132 if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
27133 duk_pop(ctx);
27134 return 1;
27135 } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
27136 duk_push_int(ctx, pc);
27137 return 1;
27138 }
27139 }
27140
27141 duk_push_sprintf(ctx, "at [anon] (%s:%ld) internal",
27142 (const char *) duk_get_string(ctx, -2), (long) pc);
27143 duk_replace(ctx, -3); /* [ ... v1 v2 str ] -> [ ... str v2 ] */
27144 duk_pop(ctx); /* -> [ ... str ] */
27145 } else {
27146 /* unknown, ignore */
27147 duk_pop_2(ctx);
27148 break;
27149 }
27150 }
27151
27152 if (count_func >= DUK_USE_TRACEBACK_DEPTH) {
27153 /* Possibly truncated; there is no explicit truncation
27154 * marker so this is the best we can do.
27155 */
27156
#define DUK_ACT_FLAG_TAILCALLED
#define DUK_ACT_FLAG_PREVENT_YIELD
DUK_EXTERNAL void duk_push_this(duk_context *ctx)
DUK_EXTERNAL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type)
#define DUK_ACT_FLAG_STRICT
#define DUK__OUTPUT_TYPE_LINENUMBER
#define DUK_ACT_FLAG_DIRECT_EVAL
DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index)
#define DUK_ACT_FLAG_CONSTRUCT
DUK_EXTERNAL duk_idx_t duk_get_top_index(duk_context *ctx)
#define DUK_HOBJECT_HAS_NATIVEFUNCTION(h)
#define DUK_STRIDX_INT_TRACEDATA
DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count)
DUK_LOCAL duk_ret_t duk__error_getter_helper(duk_context *ctx, duk_small_int_t output_type)
DUK_INTERNAL_DECL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc)
#define DUK_STRIDX_NEWLINE_4SPACE
#define DUK__OUTPUT_TYPE_FILENAME
static int funcname(LexState *ls, expdesc *v)
static void cannot(const char *what)

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 27211 of file duktape-1.5.2/src/duktape.c.

27216 {
27217 DUK_UNREF(ctx);
27218 return 0;
27219}
27220
27222 DUK_UNREF(ctx);
27223 return 0;
27224}
27225
27226#endif /* DUK_USE_TRACEBACKS */
27227
27229 /* Attempt to write 'stack', 'fileName', 'lineNumber' works as if
27230 * user code called Object.defineProperty() to create an overriding
27231 * own property. This allows user code to overwrite .fileName etc
27232 * intuitively as e.g. "err.fileName = 'dummy'" as one might expect.
27233 * See https://github.com/svaarala/duktape/issues/387.
27234 */
27235
DUK_LOCAL duk_ret_t duk__error_setter_helper(duk_context *ctx, duk_small_uint_t stridx_key)
DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx)

◆ duk__exp()

DUK_LOCAL double duk__exp ( double x)

Definition at line 32546 of file duktape-1.5.2/src/duktape.c.

32548 {

◆ 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 62229 of file duktape-1.5.2/src/duktape.c.

62246 {
62247 duk_hthread *thr = comp_ctx->thr;
62248 duk_context *ctx = (duk_context *) thr;
62249 duk_ivalue tmp_alloc; /* 'res' is used for "left", and 'tmp' for "right" */
62250 duk_ivalue *tmp = &tmp_alloc;
62251 duk_small_uint_t rbp;
62252
62253 DUK__RECURSION_INCREASE(comp_ctx, thr);
62254
62256
62257 /* filter out flags from exprtop rbp_flags here to save space */
62258 rbp = rbp_flags & DUK__EXPR_RBP_MASK;
62259
62260 DUK_DDD(DUK_DDDPRINT("duk__expr(), rbp_flags=%ld, rbp=%ld, allow_in=%ld, paren_level=%ld",
62261 (long) rbp_flags, (long) rbp, (long) comp_ctx->curr_func.allow_in,
62262 (long) comp_ctx->curr_func.paren_level));
62263
62264 DUK_MEMZERO(&tmp_alloc, sizeof(tmp_alloc));
62265 tmp->x1.valstack_idx = duk_get_top(ctx);
62266 tmp->x2.valstack_idx = tmp->x1.valstack_idx + 1;
62267 duk_push_undefined(ctx);
62268 duk_push_undefined(ctx);
62269
62270 /* XXX: where to release temp regs in intermediate expressions?
62271 * e.g. 1+2+3 -> don't inflate temp register count when parsing this.
62272 * that particular expression temp regs can be forced here.
62273 */
62274
62275 /* XXX: increase ctx->expr_tokens here for every consumed token
62276 * (this would be a nice statistic)?
62277 */
62278
62279 if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
62280 /* XXX: possibly incorrect handling of empty expression */
62281 DUK_DDD(DUK_DDDPRINT("empty expression"));
62282 if (!(rbp_flags & DUK__EXPR_FLAG_ALLOW_EMPTY)) {
62284 }
62285 res->t = DUK_IVAL_PLAIN;
62286 res->x1.t = DUK_ISPEC_VALUE;
62287 duk_push_undefined(ctx);
62288 duk_replace(ctx, res->x1.valstack_idx);
62289 goto cleanup;
#define DUK__EXPR_FLAG_ALLOW_EMPTY
#define DUK__EXPR_RBP_MASK
#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED
#define DUK_IVAL_PLAIN
#define DUK_TOK_SEMICOLON
#define DUK__RECURSION_INCREASE(comp_ctx, thr)
#define DUK_ISPEC_VALUE
#define DUK__PARSE_EXPR_SLOTS
#define DUK_TOK_RPAREN

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 60702 of file duktape-1.5.2/src/duktape.c.

◆ duk__expr_lbp()

DUK_LOCAL_DECL duk_small_uint_t duk__expr_lbp ( duk_compiler_ctx * comp_ctx)

Definition at line 62185 of file duktape-1.5.2/src/duktape.c.

62193 :
62195 return;
62196
62197 syntax_error_lvalue:
62199 return;
62200}
62201
62203 duk_small_int_t tok = comp_ctx->curr_token.t;
62204
62205 DUK_ASSERT(tok >= DUK_TOK_MINVAL && tok <= DUK_TOK_MAXVAL);
62207
62208 /* XXX: integrate support for this into led() instead?
62209 * Similar issue as post-increment/post-decrement.
62210 */
62211
62212 /* prevent duk__expr_led() by using a binding power less than anything valid */
DUK_LOCAL_DECL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx)
#define DUK_STR_INVALID_EXPRESSION
#define DUK_TOK_MINVAL
#define DUK_STR_INVALID_LVALUE

◆ duk__expr_led()

DUK_LOCAL_DECL void duk__expr_led ( duk_compiler_ctx * comp_ctx,
duk_ivalue * left,
duk_ivalue * res )

Definition at line 61232 of file duktape-1.5.2/src/duktape.c.

61232 :
61233 {
61234 /* Stack top contains plain value */
61235 res->t = DUK_IVAL_PLAIN;
61236 res->x1.t = DUK_ISPEC_VALUE;
61237 duk_replace(ctx, res->x1.valstack_idx);
61238 return;
61239 }
61240
61241 syntax_error:
61243}
61244
61245/* XXX: add flag to indicate whether caller cares about return value; this
61246 * affects e.g. handling of assignment expressions. This change needs API
61247 * changes elsewhere too.
61248 */
61250 duk_hthread *thr = comp_ctx->thr;
61251 duk_context *ctx = (duk_context *) thr;
61252 duk_token *tk;
61253 duk_small_int_t tok;
61254 duk_uint32_t args; /* temp variable to pass constants and flags to shared code */
61255
61256 /*
61257 * ctx->prev_token token to process with duk__expr_led()
61258 * ctx->curr_token updated by caller
61259 */
61260
61261 comp_ctx->curr_func.led_count++;
61262
61263 /* The token in the switch has already been eaten here */
61264 tk = &comp_ctx->prev_token;
61265 tok = tk->t;
61266
61267 DUK_DDD(DUK_DDDPRINT("duk__expr_led(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld",
61268 (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level));
61269
61270 /* XXX: default priority for infix operators is duk__expr_lbp(tok) -> get it here? */
61271
61272 switch (tok) {
61273
61274 /* PRIMARY EXPRESSIONS */
61275
61276 case DUK_TOK_PERIOD: {
61277 /* Property access expressions are critical for correct LHS ordering,
61278 * see comments in duk__expr()!
61279 *
61280 * A conservative approach would be to use duk__ivalue_totempconst()
61281 * for 'left'. However, allowing a reg-bound variable seems safe here
61282 * and is nice because "foo.bar" is a common expression. If the ivalue
61283 * is used in an expression a GETPROP will occur before any changes to
61284 * the base value can occur. If the ivalue is used as an assignment
61285 * LHS, the assignment code will ensure the base value is safe from
61286 * RHS mutation.
61287 */
61288
61289 /* XXX: This now coerces an identifier into a GETVAR to a temp, which
61290 * causes an extra LDREG in call setup. It's sufficient to coerce to a
61291 * unary ivalue?
61292 */
61293 duk__ivalue_toplain(comp_ctx, left);
61294
61295 /* NB: must accept reserved words as property name */
61296 if (comp_ctx->curr_token.t_nores != DUK_TOK_IDENTIFIER) {
61298 }
61299
61300 res->t = DUK_IVAL_PROP;
61301 duk__copy_ispec(comp_ctx, &left->x1, &res->x1); /* left.x1 -> res.x1 */
61302 DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
61303 duk_push_hstring(ctx, comp_ctx->curr_token.str1);
61304 duk_replace(ctx, res->x2.valstack_idx);
61305 res->x2.t = DUK_ISPEC_VALUE;
61306
61307 /* special RegExp literal handling after IdentifierName */
61308 comp_ctx->curr_func.reject_regexp_in_adv = 1;
61309
61310 duk__advance(comp_ctx);
61311 return;
61312 }
61313 case DUK_TOK_LBRACKET: {
61314 /* Property access expressions are critical for correct LHS ordering,
61315 * see comments in duk__expr()!
61316 */
61317
61318 /* XXX: optimize temp reg use */
61319 /* XXX: similar coercion issue as in DUK_TOK_PERIOD */
61320 /* XXX: coerce to regs? it might be better for enumeration use, where the
61321 * same PROP ivalue is used multiple times. Or perhaps coerce PROP further
61322 * there?
61323 */
61324 /* XXX: for simple cases like x['y'] an unnecessary LDREG is
61325 * emitted for the base value; could avoid it if we knew that
61326 * the key expression is safe (e.g. just a single literal).
61327 */
61328
61329 /* The 'left' value must not be a register bound variable
61330 * because it may be mutated during the rest of the expression
61331 * and E5.1 Section 11.2.1 specifies the order of evaluation
61332 * so that the base value is evaluated first.
61333 * See: test-bug-nested-prop-mutate.js.
61334 */
61335 duk__ivalue_totempconst(comp_ctx, left);
61336 duk__expr_toplain(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression, ']' terminates */
61338
61339 res->t = DUK_IVAL_PROP;
61340 duk__copy_ispec(comp_ctx, &res->x1, &res->x2); /* res.x1 -> res.x2 */
61341 duk__copy_ispec(comp_ctx, &left->x1, &res->x1); /* left.x1 -> res.x1 */
61342 return;
61343 }
61344 case DUK_TOK_LPAREN: {
61345 /* function call */
61346 duk_reg_t reg_cs = DUK__ALLOCTEMPS(comp_ctx, 2);
61347 duk_int_t nargs;
61348 duk_small_uint_t call_flags = 0;
61349
61350 /*
61351 * XXX: attempt to get the call result to "next temp" whenever
61352 * possible to avoid unnecessary register shuffles.
61353 *
61354 * XXX: CSPROP (and CSREG) can overwrite the call target register, and save one temp,
61355 * if the call target is a temporary register and at the top of the temp reg "stack".
61356 */
61357
61358 /*
61359 * Setup call: target and 'this' binding. Three cases:
61360 *
61361 * 1. Identifier base (e.g. "foo()")
61362 * 2. Property base (e.g. "foo.bar()")
61363 * 3. Register base (e.g. "foo()()"; i.e. when a return value is a function)
61364 */
61365
61366 if (left->t == DUK_IVAL_VAR) {
61367 duk_hstring *h_varname;
61368 duk_reg_t reg_varbind;
61369 duk_regconst_t rc_varname;
61370
61371 DUK_DDD(DUK_DDDPRINT("function call with identifier base"));
61372
61373 h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
61374 DUK_ASSERT(h_varname != NULL);
61375 if (h_varname == DUK_HTHREAD_STRING_EVAL(thr)) {
61376 /* Potential direct eval call detected, flag the CALL
61377 * so that a run-time "direct eval" check is made and
61378 * special behavior may be triggered. Note that this
61379 * does not prevent 'eval' from being register bound.
61380 */
61381 DUK_DDD(DUK_DDDPRINT("function call with identifier 'eval' "
61382 "-> enabling EVALCALL flag, marking function "
61383 "as may_direct_eval"));
61384 call_flags |= DUK_BC_CALL_FLAG_EVALCALL;
61385
61386 comp_ctx->curr_func.may_direct_eval = 1;
61387 }
61388
61389 duk_dup(ctx, left->x1.valstack_idx);
61390 if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
61391 duk__emit_a_b(comp_ctx,
61393 (duk_regconst_t) (reg_cs + 0),
61394 (duk_regconst_t) reg_varbind);
61395 } else {
61396 duk__emit_a_b(comp_ctx,
61398 (duk_regconst_t) (reg_cs + 0),
61399 rc_varname);
61400 }
61401 } else if (left->t == DUK_IVAL_PROP) {
61402 DUK_DDD(DUK_DDDPRINT("function call with property base"));
61403
61404 duk__ispec_toforcedreg(comp_ctx, &left->x1, reg_cs + 0); /* base */
61405 duk__ispec_toforcedreg(comp_ctx, &left->x2, reg_cs + 1); /* key */
61406 duk__emit_a_b_c(comp_ctx,
61408 (duk_regconst_t) (reg_cs + 0),
61409 (duk_regconst_t) (reg_cs + 0),
61410 (duk_regconst_t) (reg_cs + 1)); /* in-place setup */
61411 } else {
61412 DUK_DDD(DUK_DDDPRINT("function call with register base"));
61413
61414 duk__ivalue_toforcedreg(comp_ctx, left, reg_cs + 0);
61415 duk__emit_a_b(comp_ctx,
61417 (duk_regconst_t) (reg_cs + 0),
61418 (duk_regconst_t) (reg_cs + 0)); /* in-place setup */
61419 }
61420
61421 DUK__SETTEMP(comp_ctx, reg_cs + 2);
61422 nargs = duk__parse_arguments(comp_ctx, res); /* parse args starting from "next temp" */
61423
61424 /* Tailcalls are handled by back-patching the TAILCALL flag to the
61425 * already emitted instruction later (in return statement parser).
61426 * Since A and C have a special meaning here, they cannot be "shuffled".
61427 */
61428
61429 duk__emit_a_b_c(comp_ctx,
61431 (duk_regconst_t) call_flags /*flags*/,
61432 (duk_regconst_t) reg_cs /*basereg*/,
61433 (duk_regconst_t) nargs /*numargs*/);
61434 DUK__SETTEMP(comp_ctx, reg_cs + 1); /* result in csreg */
61435
61436 res->t = DUK_IVAL_PLAIN;
61437 res->x1.t = DUK_ISPEC_REGCONST;
61438 res->x1.regconst = (duk_regconst_t) reg_cs;
61439 return;
61440 }
61441
61442 /* POSTFIX EXPRESSION */
61443
61444 case DUK_TOK_INCREMENT: {
61445 args = (DUK_OP_POSTINCR << 8) + 0;
61446 goto postincdec;
61447 }
61448 case DUK_TOK_DECREMENT: {
61449 args = (DUK_OP_POSTDECR << 8) + 0;
61450 goto postincdec;
61451 }
61452
61453 /* MULTIPLICATIVE EXPRESSION */
61454
61455 case DUK_TOK_MUL: {
61456 args = (DUK_OP_MUL << 8) + DUK__BP_MULTIPLICATIVE; /* UnaryExpression */
61457 goto binary;
61458 }
61459 case DUK_TOK_DIV: {
61460 args = (DUK_OP_DIV << 8) + DUK__BP_MULTIPLICATIVE; /* UnaryExpression */
61461 goto binary;
61462 }
61463 case DUK_TOK_MOD: {
61464 args = (DUK_OP_MOD << 8) + DUK__BP_MULTIPLICATIVE; /* UnaryExpression */
61465 goto binary;
61466 }
61467
61468 /* ADDITIVE EXPRESSION */
61469
61470 case DUK_TOK_ADD: {
61471 args = (DUK_OP_ADD << 8) + DUK__BP_ADDITIVE; /* MultiplicativeExpression */
61472 goto binary;
61473 }
61474 case DUK_TOK_SUB: {
61475 args = (DUK_OP_SUB << 8) + DUK__BP_ADDITIVE; /* MultiplicativeExpression */
61476 goto binary;
61477 }
61478
61479 /* SHIFT EXPRESSION */
61480
61481 case DUK_TOK_ALSHIFT: {
61482 /* << */
61483 args = (DUK_OP_BASL << 8) + DUK__BP_SHIFT;
61484 goto binary;
61485 }
61486 case DUK_TOK_ARSHIFT: {
61487 /* >> */
61488 args = (DUK_OP_BASR << 8) + DUK__BP_SHIFT;
61489 goto binary;
61490 }
61491 case DUK_TOK_RSHIFT: {
61492 /* >>> */
61493 args = (DUK_OP_BLSR << 8) + DUK__BP_SHIFT;
61494 goto binary;
61495 }
61496
61497 /* RELATIONAL EXPRESSION */
61498
61499 case DUK_TOK_LT: {
61500 /* < */
61501 args = (DUK_OP_LT << 8) + DUK__BP_RELATIONAL;
61502 goto binary;
61503 }
61504 case DUK_TOK_GT: {
61505 args = (DUK_OP_GT << 8) + DUK__BP_RELATIONAL;
61506 goto binary;
61507 }
61508 case DUK_TOK_LE: {
61509 args = (DUK_OP_LE << 8) + DUK__BP_RELATIONAL;
61510 goto binary;
61511 }
61512 case DUK_TOK_GE: {
61513 args = (DUK_OP_GE << 8) + DUK__BP_RELATIONAL;
61514 goto binary;
61515 }
61516 case DUK_TOK_INSTANCEOF: {
61517 args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_INSTOF << 8) + DUK__BP_RELATIONAL;
61518 goto binary;
61519 }
61520 case DUK_TOK_IN: {
61521 args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_IN << 8) + DUK__BP_RELATIONAL;
61522 goto binary;
61523 }
61524
61525 /* EQUALITY EXPRESSION */
61526
61527 case DUK_TOK_EQ: {
61528 args = (DUK_OP_EQ << 8) + DUK__BP_EQUALITY;
61529 goto binary;
61530 }
61531 case DUK_TOK_NEQ: {
61532 args = (DUK_OP_NEQ << 8) + DUK__BP_EQUALITY;
61533 goto binary;
61534 }
61535 case DUK_TOK_SEQ: {
61536 args = (DUK_OP_SEQ << 8) + DUK__BP_EQUALITY;
61537 goto binary;
61538 }
61539 case DUK_TOK_SNEQ: {
61540 args = (DUK_OP_SNEQ << 8) + DUK__BP_EQUALITY;
61541 goto binary;
61542 }
61543
61544 /* BITWISE EXPRESSIONS */
61545
61546 case DUK_TOK_BAND: {
61547 args = (DUK_OP_BAND << 8) + DUK__BP_BAND;
61548 goto binary;
61549 }
61550 case DUK_TOK_BXOR: {
61551 args = (DUK_OP_BXOR << 8) + DUK__BP_BXOR;
61552 goto binary;
61553 }
61554 case DUK_TOK_BOR: {
61555 args = (DUK_OP_BOR << 8) + DUK__BP_BOR;
61556 goto binary;
61557 }
61558
61559 /* LOGICAL EXPRESSIONS */
61560
61561 case DUK_TOK_LAND: {
61562 /* syntactically left-associative but parsed as right-associative */
61563 args = (1 << 8) + DUK__BP_LAND - 1;
61564 goto binary_logical;
61565 }
61566 case DUK_TOK_LOR: {
61567 /* syntactically left-associative but parsed as right-associative */
61568 args = (0 << 8) + DUK__BP_LOR - 1;
61569 goto binary_logical;
61570 }
61571
61572 /* CONDITIONAL EXPRESSION */
61573
61574 case DUK_TOK_QUESTION: {
61575 /* XXX: common reg allocation need is to reuse a sub-expression's temp reg,
61576 * but only if it really is a temp. Nothing fancy here now.
61577 */
61578 duk_reg_t reg_temp;
61579 duk_int_t pc_jump1;
61580 duk_int_t pc_jump2;
61581
61582 reg_temp = DUK__ALLOCTEMP(comp_ctx);
61583 duk__ivalue_toforcedreg(comp_ctx, left, reg_temp);
61584 duk__emit_if_true_skip(comp_ctx, reg_temp);
61585 pc_jump1 = duk__emit_jump_empty(comp_ctx); /* jump to false */
61586 duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/); /* AssignmentExpression */
61588 pc_jump2 = duk__emit_jump_empty(comp_ctx); /* jump to end */
61589 duk__patch_jump_here(comp_ctx, pc_jump1);
61590 duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/); /* AssignmentExpression */
61591 duk__patch_jump_here(comp_ctx, pc_jump2);
61592
61593 DUK__SETTEMP(comp_ctx, reg_temp + 1);
61594 res->t = DUK_IVAL_PLAIN;
61595 res->x1.t = DUK_ISPEC_REGCONST;
61596 res->x1.regconst = (duk_regconst_t) reg_temp;
61597 return;
61598 }
61599
61600 /* ASSIGNMENT EXPRESSION */
61601
61602 case DUK_TOK_EQUALSIGN: {
61603 /*
61604 * Assignments are right associative, allows e.g.
61605 * a = 5;
61606 * a += b = 9; // same as a += (b = 9)
61607 * -> expression value 14, a = 14, b = 9
61608 *
61609 * Right associativiness is reflected in the BP for recursion,
61610 * "-1" ensures assignment operations are allowed.
61611 *
61612 * XXX: just use DUK__BP_COMMA (i.e. no need for 2-step bp levels)?
61613 */
61614 args = (DUK_OP_NONE << 8) + DUK__BP_ASSIGNMENT - 1; /* DUK_OP_NONE marks a 'plain' assignment */
61615 goto assign;
61616 }
61617 case DUK_TOK_ADD_EQ: {
61618 /* right associative */
61619 args = (DUK_OP_ADD << 8) + DUK__BP_ASSIGNMENT - 1;
61620 goto assign;
61621 }
61622 case DUK_TOK_SUB_EQ: {
61623 /* right associative */
61624 args = (DUK_OP_SUB << 8) + DUK__BP_ASSIGNMENT - 1;
61625 goto assign;
61626 }
61627 case DUK_TOK_MUL_EQ: {
61628 /* right associative */
61629 args = (DUK_OP_MUL << 8) + DUK__BP_ASSIGNMENT - 1;
61630 goto assign;
61631 }
61632 case DUK_TOK_DIV_EQ: {
61633 /* right associative */
61634 args = (DUK_OP_DIV << 8) + DUK__BP_ASSIGNMENT - 1;
61635 goto assign;
61636 }
61637 case DUK_TOK_MOD_EQ: {
61638 /* right associative */
61639 args = (DUK_OP_MOD << 8) + DUK__BP_ASSIGNMENT - 1;
61640 goto assign;
61641 }
61642 case DUK_TOK_ALSHIFT_EQ: {
61643 /* right associative */
61644 args = (DUK_OP_BASL << 8) + DUK__BP_ASSIGNMENT - 1;
61645 goto assign;
61646 }
61647 case DUK_TOK_ARSHIFT_EQ: {
61648 /* right associative */
61649 args = (DUK_OP_BASR << 8) + DUK__BP_ASSIGNMENT - 1;
61650 goto assign;
61651 }
61652 case DUK_TOK_RSHIFT_EQ: {
61653 /* right associative */
61654 args = (DUK_OP_BLSR << 8) + DUK__BP_ASSIGNMENT - 1;
61655 goto assign;
61656 }
61657 case DUK_TOK_BAND_EQ: {
61658 /* right associative */
61659 args = (DUK_OP_BAND << 8) + DUK__BP_ASSIGNMENT - 1;
61660 goto assign;
61661 }
61662 case DUK_TOK_BOR_EQ: {
61663 /* right associative */
61664 args = (DUK_OP_BOR << 8) + DUK__BP_ASSIGNMENT - 1;
61665 goto assign;
61666 }
61667 case DUK_TOK_BXOR_EQ: {
61668 /* right associative */
61669 args = (DUK_OP_BXOR << 8) + DUK__BP_ASSIGNMENT - 1;
61670 goto assign;
61671 }
61672
61673 /* COMMA */
61674
61675 case DUK_TOK_COMMA: {
61676 /* right associative */
61677
61678 duk__ivalue_toplain_ignore(comp_ctx, left); /* need side effects, not value */
61679 duk__expr_toplain(comp_ctx, res, DUK__BP_COMMA - 1 /*rbp_flags*/);
61680
61681 /* return 'res' (of right part) as our result */
61682 return;
61683 }
61684
61685 default: {
61686 break;
61687 }
61688 }
61689
61690 DUK_D(DUK_DPRINT("parse error: unexpected token: %ld", (long) tok));
61692 return;
61693
61694#if 0
61695 /* XXX: shared handling for 'duk__expr_lhs'? */
61696 if (comp_ctx->curr_func.paren_level == 0 && XXX) {
61697 comp_ctx->curr_func.duk__expr_lhs = 0;
61698 }
61699#endif
61700
61701 binary:
61702 /*
61703 * Shared handling of binary operations
61704 *
61705 * args = (is_extraop << 16) + (opcode << 8) + rbp
61706 */
61707 {
61708 duk__ivalue_toplain(comp_ctx, left);
61709 duk__expr_toplain(comp_ctx, res, args & 0xff /*rbp_flags*/);
61710
61711 /* combine left->x1 and res->x1 (right->x1, really) -> (left->x1 OP res->x1) */
61713 DUK_ASSERT(res->t == DUK_IVAL_PLAIN);
61714
61715 res->t = (args >> 16) ? DUK_IVAL_ARITH_EXTRAOP : DUK_IVAL_ARITH;
61716 res->op = (args >> 8) & 0xff;
61717
61718 res->x2.t = res->x1.t;
61719 res->x2.regconst = res->x1.regconst;
61720 duk_copy(ctx, res->x1.valstack_idx, res->x2.valstack_idx);
61721
61722 res->x1.t = left->x1.t;
61723 res->x1.regconst = left->x1.regconst;
61724 duk_copy(ctx, left->x1.valstack_idx, res->x1.valstack_idx);
61725
61726 DUK_DDD(DUK_DDDPRINT("binary op, res: t=%ld, x1.t=%ld, x1.regconst=0x%08lx, x2.t=%ld, x2.regconst=0x%08lx",
61727 (long) res->t, (long) res->x1.t, (unsigned long) res->x1.regconst, (long) res->x2.t, (unsigned long) res->x2.regconst));
61728 return;
61729 }
61730
61731 binary_logical:
61732 /*
61733 * Shared handling for logical AND and logical OR.
61734 *
61735 * args = (truthval << 8) + rbp
61736 *
61737 * Truthval determines when to skip right-hand-side.
61738 * For logical AND truthval=1, for logical OR truthval=0.
61739 *
61740 * See doc/compiler.rst for discussion on compiling logical
61741 * AND and OR expressions. The approach here is very simplistic,
61742 * generating extra jumps and multiple evaluations of truth values,
61743 * but generates code on-the-fly with only local back-patching.
61744 *
61745 * Both logical AND and OR are syntactically left-associated.
61746 * However, logical ANDs are compiled as right associative
61747 * expressions, i.e. "A && B && C" as "A && (B && C)", to allow
61748 * skip jumps to skip over the entire tail. Similarly for logical OR.
61749 */
61750
61751 {
61752 duk_reg_t reg_temp;
61753 duk_int_t pc_jump;
61754 duk_small_uint_t args_truthval = args >> 8;
61755 duk_small_uint_t args_rbp = args & 0xff;
61756
61757 /* XXX: unoptimal use of temps, resetting */
61758
61759 reg_temp = DUK__ALLOCTEMP(comp_ctx);
61760
61761 duk__ivalue_toforcedreg(comp_ctx, left, reg_temp);
61762 duk__emit_a_b(comp_ctx,
61764 (duk_regconst_t) args_truthval,
61765 (duk_regconst_t) reg_temp); /* skip jump conditionally */
61766 pc_jump = duk__emit_jump_empty(comp_ctx);
61767 duk__expr_toforcedreg(comp_ctx, res, args_rbp /*rbp_flags*/, reg_temp /*forced_reg*/);
61768 duk__patch_jump_here(comp_ctx, pc_jump);
61769
61770 res->t = DUK_IVAL_PLAIN;
61771 res->x1.t = DUK_ISPEC_REGCONST;
61772 res->x1.regconst = (duk_regconst_t) reg_temp;
61773 return;
61774 }
61775
61776 assign:
61777 /*
61778 * Shared assignment expression handling
61779 *
61780 * args = (opcode << 8) + rbp
61781 *
61782 * If 'opcode' is DUK_OP_NONE, plain assignment without arithmetic.
61783 * Syntactically valid left-hand-side forms which are not accepted as
61784 * left-hand-side values (e.g. as in "f() = 1") must NOT cause a
61785 * SyntaxError, but rather a run-time ReferenceError.
61786 *
61787 * When evaluating X <op>= Y, the LHS (X) is conceptually evaluated
61788 * to a temporary first. The RHS is then evaluated. Finally, the
61789 * <op> is applied to the initial value of RHS (not the value after
61790 * RHS evaluation), and written to X. Doing so concretely generates
61791 * inefficient code so we'd like to avoid the temporary when possible.
61792 * See: https://github.com/svaarala/duktape/pull/992.
61793 *
61794 * The expression value (final LHS value, written to RHS) is
61795 * conceptually copied into a fresh temporary so that it won't
61796 * change even if the LHS/RHS values change in outer expressions.
61797 * For example, it'd be generally incorrect for the expression value
61798 * to be the RHS register binding, unless there's a guarantee that it
61799 * won't change during further expression evaluation. Using the
61800 * temporary concretely produces inefficient bytecode, so we try to
61801 * avoid the extra temporary for some known-to-be-safe cases.
61802 * Currently the only safe case we detect is a "top level assignment",
61803 * for example "x = y + z;", where the assignment expression value is
61804 * ignored.
61805 * See: test-dev-assign-expr.js and test-bug-assign-mutate-gh381.js.
61806 */
61807
61808 {
61809 duk_small_uint_t args_op = args >> 8;
61810 duk_small_uint_t args_rbp = args & 0xff;
61811 duk_bool_t toplevel_assign;
61812
61813 /* XXX: here we need to know if 'left' is left-hand-side compatible.
61814 * That information is no longer available from current expr parsing
61815 * state; it would need to be carried into the 'left' ivalue or by
61816 * some other means.
61817 */
61818
61819 /* A top-level assignment is e.g. "x = y;". For these it's safe
61820 * to use the RHS as-is as the expression value, even if the RHS
61821 * is a reg-bound identifier. The RHS ('res') is right associative
61822 * so it has consumed all other assignment level operations; the
61823 * only relevant lower binding power construct is comma operator
61824 * which will ignore the expression value provided here. Usually
61825 * the top level assignment expression value is ignored, but it
61826 * is relevant for e.g. eval code.
61827 */
61828 toplevel_assign = (comp_ctx->curr_func.nud_count == 1 && /* one token before */
61829 comp_ctx->curr_func.led_count == 1); /* one operator (= assign) */
61830 DUK_DDD(DUK_DDDPRINT("assignment: nud_count=%ld, led_count=%ld, toplevel_assign=%ld",
61831 (long) comp_ctx->curr_func.nud_count,
61832 (long) comp_ctx->curr_func.led_count,
61833 (long) toplevel_assign));
61834
61835 if (left->t == DUK_IVAL_VAR) {
61836 duk_hstring *h_varname;
61837 duk_reg_t reg_varbind;
61838 duk_regconst_t rc_varname;
61839
61840 DUK_ASSERT(left->x1.t == DUK_ISPEC_VALUE); /* LHS is already side effect free */
61841
61842 h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
61843 DUK_ASSERT(h_varname != NULL);
61844 if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
61845 /* E5 Section 11.13.1 (and others for other assignments), step 4. */
61846 goto syntax_error_lvalue;
61847 }
61848 duk_dup(ctx, left->x1.valstack_idx);
61849 (void) duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname);
61850
61851 if (args_op == DUK_OP_NONE) {
61852 duk__expr(comp_ctx, res, args_rbp /*rbp_flags*/);
61853 if (toplevel_assign) {
61854 /* Any 'res' will do. */
61855 DUK_DDD(DUK_DDDPRINT("plain assignment, toplevel assign, use as is"));
61856 } else {
61857 /* 'res' must be a plain ivalue, and not register-bound variable. */
61858 DUK_DDD(DUK_DDDPRINT("plain assignment, not toplevel assign, ensure not a reg-bound identifier"));
61859 if (res->t != DUK_IVAL_PLAIN || (res->x1.t == DUK_ISPEC_REGCONST &&
61860 (res->x1.regconst & DUK__CONST_MARKER) == 0 &&
61861 !DUK__ISTEMP(comp_ctx, res->x1.regconst))) {
61862 duk__ivalue_totempconst(comp_ctx, res);
61863 }
61864 }
61865 } else {
61866 /* For X <op>= Y we need to evaluate the pre-op
61867 * value of X before evaluating the RHS: the RHS
61868 * can change X, but when we do <op> we must use
61869 * the pre-op value.
61870 */
61871 duk_reg_t reg_temp;
61872
61873 reg_temp = DUK__ALLOCTEMP(comp_ctx);
61874
61875 if (reg_varbind >= 0) {
61876 duk_reg_t reg_res;
61877 duk_reg_t reg_src;
61878 duk_int_t pc_temp_load;
61879 duk_int_t pc_before_rhs;
61880 duk_int_t pc_after_rhs;
61881
61882 if (toplevel_assign) {
61883 /* 'reg_varbind' is the operation result and can also
61884 * become the expression value for top level assignments
61885 * such as: "var x; x += y;".
61886 */
61887 DUK_DD(DUK_DDPRINT("<op>= expression is top level, write directly to reg_varbind"));
61888 reg_res = reg_varbind;
61889 } else {
61890 /* Not safe to use 'reg_varbind' as assignment expression
61891 * value, so go through a temp.
61892 */
61893 DUK_DD(DUK_DDPRINT("<op>= expression is not top level, write to reg_temp"));
61894 reg_res = reg_temp; /* reg_res should be smallest possible */
61895 reg_temp = DUK__ALLOCTEMP(comp_ctx);
61896 }
61897
61898 /* Try to optimize X <op>= Y for reg-bound
61899 * variables. Detect side-effect free RHS
61900 * narrowly by seeing whether it emits code.
61901 * If not, rewind the code emitter and overwrite
61902 * the unnecessary temp reg load.
61903 */
61904
61905 pc_temp_load = duk__get_current_pc(comp_ctx);
61906 duk__emit_a_bc(comp_ctx,
61908 (duk_regconst_t) reg_temp,
61909 reg_varbind);
61910
61911 pc_before_rhs = duk__get_current_pc(comp_ctx);
61912 duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
61913 DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
61914 pc_after_rhs = duk__get_current_pc(comp_ctx);
61915
61916 DUK_DD(DUK_DDPRINT("pc_temp_load=%ld, pc_before_rhs=%ld, pc_after_rhs=%ld",
61917 (long) pc_temp_load, (long) pc_before_rhs,
61918 (long) pc_after_rhs));
61919
61920 if (pc_after_rhs == pc_before_rhs) {
61921 /* Note: if the reg_temp load generated shuffling
61922 * instructions, we may need to rewind more than
61923 * one instruction, so use explicit PC computation.
61924 */
61925 DUK_DD(DUK_DDPRINT("rhs is side effect free, rewind and avoid unnecessary temp for reg-based <op>="));
61926 DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, (pc_temp_load - pc_before_rhs) * sizeof(duk_compiler_instr));
61927 reg_src = reg_varbind;
61928 } else {
61929 DUK_DD(DUK_DDPRINT("rhs evaluation emitted code, not sure if rhs is side effect free; use temp reg for LHS"));
61930 reg_src = reg_temp;
61931 }
61932
61933 duk__emit_a_b_c(comp_ctx,
61934 args_op,
61935 (duk_regconst_t) reg_res,
61936 (duk_regconst_t) reg_src,
61937 res->x1.regconst);
61938
61939 res->x1.regconst = (duk_regconst_t) reg_res;
61940
61941 /* Ensure compact use of temps. */
61942 if (DUK__ISTEMP(comp_ctx, reg_res)) {
61943 DUK__SETTEMP(comp_ctx, reg_res + 1);
61944 }
61945 } else {
61946 /* When LHS is not register bound, always go through a
61947 * temporary. No optimization for top level assignment.
61948 */
61949
61950 duk__emit_a_bc(comp_ctx,
61952 (duk_regconst_t) reg_temp,
61953 rc_varname);
61954
61955 duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
61956 DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
61957
61958 duk__emit_a_b_c(comp_ctx,
61959 args_op,
61960 (duk_regconst_t) reg_temp,
61961 (duk_regconst_t) reg_temp,
61962 res->x1.regconst);
61963 res->x1.regconst = (duk_regconst_t) reg_temp;
61964 }
61965
61966 DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
61967 }
61968
61969 /* At this point 'res' holds the potential expression value.
61970 * It can be basically any ivalue here, including a reg-bound
61971 * identifier (if code above deems it safe) or a unary/binary
61972 * operation. Operations must be resolved to a side effect free
61973 * plain value, and the side effects must happen exactly once.
61974 */
61975
61976 if (reg_varbind >= 0) {
61977 if (res->t != DUK_IVAL_PLAIN) {
61978 /* Resolve 'res' directly into the LHS binding, and use
61979 * that as the expression value if safe. If not safe,
61980 * resolve to a temp/const and copy to LHS.
61981 */
61982 if (toplevel_assign) {
61983 duk__ivalue_toforcedreg(comp_ctx, res, (duk_int_t) reg_varbind);
61984 } else {
61985 duk__ivalue_totempconst(comp_ctx, res);
61986 duk__copy_ivalue(comp_ctx, res, left); /* use 'left' as a temp */
61987 duk__ivalue_toforcedreg(comp_ctx, left, (duk_int_t) reg_varbind);
61988 }
61989 } else {
61990 /* Use 'res' as the expression value (it's side effect
61991 * free and may be a plain value, a register, or a
61992 * constant) and write it to the LHS binding too.
61993 */
61994 duk__copy_ivalue(comp_ctx, res, left); /* use 'left' as a temp */
61995 duk__ivalue_toforcedreg(comp_ctx, left, (duk_int_t) reg_varbind);
61996 }
61997 } else {
61998 /* Only a reg fits into 'A' so coerce 'res' into a register
61999 * for PUTVAR.
62000 *
62001 * XXX: here the current A/B/C split is suboptimal: we could
62002 * just use 9 bits for reg_res (and support constants) and 17
62003 * instead of 18 bits for the varname const index.
62004 */
62005
62006 duk__ivalue_toreg(comp_ctx, res);
62007 duk__emit_a_bc(comp_ctx,
62009 res->x1.regconst,
62010 rc_varname);
62011 }
62012
62013 /* 'res' contains expression value */
62014 } else if (left->t == DUK_IVAL_PROP) {
62015 /* E5 Section 11.13.1 (and others) step 4 never matches for prop writes -> no check */
62016 duk_reg_t reg_obj;
62017 duk_regconst_t rc_key;
62018 duk_regconst_t rc_res;
62019 duk_reg_t reg_temp;
62020
62021 /* Property access expressions ('a[b]') are critical to correct
62022 * LHS evaluation ordering, see test-dev-assign-eval-order*.js.
62023 * We must make sure that the LHS target slot (base object and
62024 * key) don't change during RHS evaluation. The only concrete
62025 * problem is a register reference to a variable-bound register
62026 * (i.e., non-temp). Require temp regs for both key and base.
62027 *
62028 * Don't allow a constant for the object (even for a number
62029 * etc), as it goes into the 'A' field of the opcode.
62030 */
62031
62032 reg_obj = duk__ispec_toregconst_raw(comp_ctx,
62033 &left->x1,
62034 -1 /*forced_reg*/,
62035 DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
62036
62037 rc_key = duk__ispec_toregconst_raw(comp_ctx,
62038 &left->x2,
62039 -1 /*forced_reg*/,
62041
62042 /* Evaluate RHS only when LHS is safe. */
62043
62044 if (args_op == DUK_OP_NONE) {
62045 duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
62046 DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
62047 rc_res = res->x1.regconst;
62048 } else {
62049 reg_temp = DUK__ALLOCTEMP(comp_ctx);
62050 duk__emit_a_b_c(comp_ctx,
62052 (duk_regconst_t) reg_temp,
62053 (duk_regconst_t) reg_obj,
62054 rc_key);
62055
62056 duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
62057 DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
62058
62059 duk__emit_a_b_c(comp_ctx,
62060 args_op,
62061 (duk_regconst_t) reg_temp,
62062 (duk_regconst_t) reg_temp,
62063 res->x1.regconst);
62064 rc_res = (duk_regconst_t) reg_temp;
62065 }
62066
62067 duk__emit_a_b_c(comp_ctx,
62069 (duk_regconst_t) reg_obj,
62070 rc_key,
62071 rc_res);
62072
62073 res->t = DUK_IVAL_PLAIN;
62074 res->x1.t = DUK_ISPEC_REGCONST;
62075 res->x1.regconst = rc_res;
62076 } else {
62077 /* No support for lvalues returned from new or function call expressions.
62078 * However, these must NOT cause compile-time SyntaxErrors, but run-time
62079 * ReferenceErrors. Both left and right sides of the assignment must be
62080 * evaluated before throwing a ReferenceError. For instance:
62081 *
62082 * f() = g();
62083 *
62084 * must result in f() being evaluated, then g() being evaluated, and
62085 * finally, a ReferenceError being thrown. See E5 Section 11.13.1.
62086 */
62087
62088 duk_regconst_t rc_res;
62089
62090 /* First evaluate LHS fully to ensure all side effects are out. */
62092
62093 /* Then evaluate RHS fully (its value becomes the expression value too).
62094 * Technically we'd need the side effect safety check here too, but because
62095 * we always throw using INVLHS the result doesn't matter.
62096 */
62097 rc_res = duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
62098
62099 duk__emit_extraop_only(comp_ctx,
62101
62102 res->t = DUK_IVAL_PLAIN;
62103 res->x1.t = DUK_ISPEC_REGCONST;
62104 res->x1.regconst = rc_res;
62105 }
62106
62107 return;
62108 }
62109
62110 postincdec:
62111 {
62112 /*
62113 * Post-increment/decrement will return the original value as its
62114 * result value. However, even that value will be coerced using
62115 * ToNumber() which is quite awkward. Specific bytecode opcodes
62116 * are used to handle these semantics.
62117 *
62118 * Note that post increment/decrement has a "no LineTerminator here"
62119 * restriction. This is handled by duk__expr_lbp(), which forcibly terminates
62120 * the previous expression if a LineTerminator occurs before '++'/'--'.
62121 */
62122
62123 duk_reg_t reg_res;
62124 duk_small_uint_t args_op = args >> 8;
62125
62126 /* Specific assumptions for opcode numbering. */
62131
62132 reg_res = DUK__ALLOCTEMP(comp_ctx);
62133
62134 if (left->t == DUK_IVAL_VAR) {
62135 duk_hstring *h_varname;
62136 duk_reg_t reg_varbind;
62137 duk_regconst_t rc_varname;
62138
62139 h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
62140 DUK_ASSERT(h_varname != NULL);
62141
62142 if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
62143 goto syntax_error;
62144 }
62145
62146 duk_dup(ctx, left->x1.valstack_idx);
62147 if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
62148 duk__emit_a_bc(comp_ctx,
62149 args_op, /* e.g. DUK_OP_POSTINCR */
62150 (duk_regconst_t) reg_res,
62151 (duk_regconst_t) reg_varbind);
62152 } else {
62153 duk__emit_a_bc(comp_ctx,
62154 args_op + 4, /* e.g. DUK_OP_POSTINCV */
62155 (duk_regconst_t) reg_res,
62156 rc_varname);
62157 }
62158
62159 DUK_DDD(DUK_DDDPRINT("postincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
62160 (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
62161 } else if (left->t == DUK_IVAL_PROP) {
62162 duk_reg_t reg_obj; /* allocate to reg only (not const) */
62163 duk_regconst_t rc_key;
62164
62165 reg_obj = duk__ispec_toregconst_raw(comp_ctx, &left->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */
62166 rc_key = duk__ispec_toregconst_raw(comp_ctx, &left->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
62167 duk__emit_a_b_c(comp_ctx,
62168 args_op + 8, /* e.g. DUK_OP_POSTINCP */
62169 (duk_regconst_t) reg_res,
62170 (duk_regconst_t) reg_obj,
62171 rc_key);
62172 } else {
62173 /* Technically return value is not needed because INVLHS will
62174 * unconditially throw a ReferenceError. Coercion is necessary
62175 * for proper semantics (consider ToNumber() called for an object).
62176 * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber().
62177 */
62178 duk__ivalue_toforcedreg(comp_ctx, left, reg_res);
62179 duk__emit_extraop_bc(comp_ctx,
62181 reg_res); /* for side effects, result ignored */
62182 duk__emit_extraop_only(comp_ctx,
#define DUK_OP_POSTINCR
#define DUK_TOK_SUB
#define DUK__BP_ASSIGNMENT
#define DUK_TOK_ARSHIFT_EQ
#define DUK__BP_BAND
#define DUK_EXTRAOP_INVLHS
#define DUK_TOK_INCREMENT
#define DUK_OP_SNEQ
DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x)
#define DUK_OP_NONE
#define DUK_TOK_MUL
#define DUK_IVAL_VAR
#define DUK_TOK_EQUALSIGN
#define DUK_IVAL_ARITH_EXTRAOP
#define DUK_OP_SUB
#define DUK__BP_SHIFT
#define DUK_EXTRAOP_UNP
#define DUK_TOK_ADD
DUK_LOCAL_DECL void duk__advance(duk_compiler_ctx *ctx)
#define DUK_TOK_IDENTIFIER
#define DUK_TOK_BXOR
#define DUK_TOK_GT
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)
#define DUK_OP_MOD
#define DUK_OP_POSTINCP
#define DUK__BP_BXOR
#define DUK__IVAL_FLAG_ALLOW_CONST
#define DUK__SETTEMP(comp_ctx, x)
DUK_LOCAL_DECL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags)
#define DUK_OP_PUTVAR
#define DUK_TOK_LT
#define DUK_TOK_BAND
#define DUK_OP_IF
#define DUK_OP_BOR
DUK_LOCAL_DECL duk_regconst_t duk__ivalue_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x)
#define DUK_TOK_DIV_EQ
#define DUK_TOK_EQ
#define DUK__BP_RELATIONAL
#define DUK__BP_BOR
DUK_LOCAL_DECL void duk__ivalue_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *x)
#define DUK__BP_COMMA
#define DUK_OP_BXOR
#define DUK_TOK_GE
#define DUK__IVAL_FLAG_REQUIRE_TEMP
#define DUK_TOK_ALSHIFT_EQ
#define DUK_TOK_MUL_EQ
#define DUK_TOK_LE
#define DUK_TOK_LAND
#define DUK_TOK_BXOR_EQ
#define DUK_OP_PUTPROP
DUK_LOCAL_DECL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect)
#define DUK_OP_LT
#define DUK_OP_BASL
duk_uint32_t duk_regconst_t
#define DUK_TOK_COLON
#define DUK__ALLOCTEMP(comp_ctx)
#define DUK_OP_SEQ
#define DUK_STR_EXPECTED_IDENTIFIER
#define DUK_TOK_BOR_EQ
#define DUK_TOK_SNEQ
#define DUK_TOK_ALSHIFT
#define DUK_OP_POSTDECP
#define DUK_TOK_DECREMENT
#define DUK_OP_DIV
DUK_LOCAL_DECL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc)
#define DUK_TOK_LPAREN
#define DUK_EXTRAOP_INSTOF
#define DUK__BP_LOR
#define DUK_TOK_MOD
#define DUK_OP_POSTDECR
#define DUK__BP_ADDITIVE
#define DUK_OP_BAND
#define DUK_OP_ADD
#define DUK__BP_FOR_EXPR
#define DUK_TOK_QUESTION
#define DUK_TOK_RBRACKET
DUK_LOCAL_DECL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx)
#define DUK_HTHREAD_STRING_EVAL(thr)
#define DUK__BP_LAND
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__ivalue_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *x)
#define DUK_TOK_RSHIFT_EQ
#define DUK_IVAL_ARITH
#define DUK_TOK_COMMA
#define DUK__ISTEMP(comp_ctx, x)
#define DUK_OP_BASR
#define DUK_OP_BLSR
#define DUK_OP_LE
#define DUK_OP_MUL
DUK_LOCAL_DECL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res)
#define DUK__ALLOCTEMPS(comp_ctx, count)
#define DUK_ISPEC_REGCONST
#define DUK_TOK_LOR
#define DUK_OP_GETPROP
#define DUK_OP_NEQ
#define DUK_TOK_ADD_EQ
#define DUK_TOK_LBRACKET
#define DUK_EXTRAOP_IN
DUK_LOCAL_DECL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg)
#define DUK_BC_CALL_FLAG_EVALCALL
#define DUK__BP_MULTIPLICATIVE
#define DUK_TOK_RSHIFT
#define DUK_TOK_DIV
#define DUK_TOK_BAND_EQ
#define DUK_OP_GT
DUK_LOCAL_DECL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags)
#define DUK_TOK_INSTANCEOF
DUK_LOCAL_DECL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst)
#define DUK_TOK_SUB_EQ
#define DUK_TOK_BOR
#define DUK_TOK_NEQ
#define DUK_TOK_ARSHIFT
DUK_LOCAL_DECL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst)
#define DUK_TOK_PERIOD
DUK_LOCAL_DECL void duk__ispec_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ispec *x, duk_reg_t forced_reg)
#define DUK_TOK_MOD_EQ
#define DUK_TOK_IN
#define DUK_IVAL_PROP
#define DUK_OP_POSTDECV
DUK_LOCAL_DECL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc)
#define DUK_OP_POSTINCV
DUK_LOCAL_DECL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments_in_strict_mode(duk_compiler_ctx *comp_ctx, duk_hstring *h)
#define DUK_OP_EQ
#define DUK_OP_GETVAR
#define DUK_OP_GE
#define DUK__BP_EQUALITY
#define DUK_TOK_SEQ
DUK_LOCAL_DECL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_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)

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 60708 of file duktape-1.5.2/src/duktape.c.

60719 {
60720 /* empty expressions can be detected conveniently with nud/led counts */
60721 return (comp_ctx->curr_func.nud_count == 0) &&
60722 (comp_ctx->curr_func.led_count == 0);
60723}
60724
60725DUK_LOCAL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
60726 duk_hthread *thr = comp_ctx->thr;
60727 duk_context *ctx = (duk_context *) thr;
60728 duk_token *tk;
60729 duk_reg_t temp_at_entry;
60730 duk_small_int_t tok;
60731 duk_uint32_t args; /* temp variable to pass constants and flags to shared code */
60732
60733 /*
60734 * ctx->prev_token token to process with duk__expr_nud()
60735 * ctx->curr_token updated by caller
60736 *
60737 * Note: the token in the switch below has already been eaten.
60738 */
60739
60740 temp_at_entry = DUK__GETTEMP(comp_ctx);
60741
60742 comp_ctx->curr_func.nud_count++;
60743
60744 tk = &comp_ctx->prev_token;
60745 tok = tk->t;
60746 res->t = DUK_IVAL_NONE;
60747
60748 DUK_DDD(DUK_DDDPRINT("duk__expr_nud(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld",
60749 (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level));
60750
60751 switch (tok) {
60752
60753 /* PRIMARY EXPRESSIONS */
60754
60755 case DUK_TOK_THIS: {
60756 duk_reg_t reg_temp;
60757 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60758 duk__emit_extraop_bc(comp_ctx,
60760 (duk_regconst_t) reg_temp);
60761 res->t = DUK_IVAL_PLAIN;
60762 res->x1.t = DUK_ISPEC_REGCONST;
60763 res->x1.regconst = (duk_regconst_t) reg_temp;
60764 return;
60765 }
60766 case DUK_TOK_IDENTIFIER: {
60767 res->t = DUK_IVAL_VAR;
60768 res->x1.t = DUK_ISPEC_VALUE;
60769 duk_push_hstring(ctx, tk->str1);
60770 duk_replace(ctx, res->x1.valstack_idx);
60771 return;
60772 }
60773 case DUK_TOK_NULL: {
60774 duk_push_null(ctx);
60775 goto plain_value;
60776 }
60777 case DUK_TOK_TRUE: {
60778 duk_push_true(ctx);
60779 goto plain_value;
60780 }
60781 case DUK_TOK_FALSE: {
60782 duk_push_false(ctx);
60783 goto plain_value;
60784 }
60785 case DUK_TOK_NUMBER: {
60786 duk_push_number(ctx, tk->num);
60787 goto plain_value;
60788 }
60789 case DUK_TOK_STRING: {
60790 DUK_ASSERT(tk->str1 != NULL);
60791 duk_push_hstring(ctx, tk->str1);
60792 goto plain_value;
60793 }
60794 case DUK_TOK_REGEXP: {
60795#ifdef DUK_USE_REGEXP_SUPPORT
60796 duk_reg_t reg_temp;
60797 duk_regconst_t rc_re_bytecode; /* const */
60798 duk_regconst_t rc_re_source; /* const */
60799
60800 DUK_ASSERT(tk->str1 != NULL);
60801 DUK_ASSERT(tk->str2 != NULL);
60802
60803 DUK_DDD(DUK_DDDPRINT("emitting regexp op, str1=%!O, str2=%!O",
60804 (duk_heaphdr *) tk->str1,
60805 (duk_heaphdr *) tk->str2));
60806
60807 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60808 duk_push_hstring(ctx, tk->str1);
60809 duk_push_hstring(ctx, tk->str2);
60810
60811 /* [ ... pattern flags ] */
60812
60813 duk_regexp_compile(thr);
60814
60815 /* [ ... escaped_source bytecode ] */
60816
60817 rc_re_bytecode = duk__getconst(comp_ctx);
60818 rc_re_source = duk__getconst(comp_ctx);
60819
60820 duk__emit_a_b_c(comp_ctx,
60822 (duk_regconst_t) reg_temp /*a*/,
60823 rc_re_bytecode /*b*/,
60824 rc_re_source /*c*/);
60825
60826 res->t = DUK_IVAL_PLAIN;
60827 res->x1.t = DUK_ISPEC_REGCONST;
60828 res->x1.regconst = (duk_regconst_t) reg_temp;
60829 return;
60830#else /* DUK_USE_REGEXP_SUPPORT */
60831 goto syntax_error;
60832#endif /* DUK_USE_REGEXP_SUPPORT */
60833 }
60834 case DUK_TOK_LBRACKET: {
60835 DUK_DDD(DUK_DDDPRINT("parsing array literal"));
60836 duk__nud_array_literal(comp_ctx, res);
60837 return;
60838 }
60839 case DUK_TOK_LCURLY: {
60840 DUK_DDD(DUK_DDDPRINT("parsing object literal"));
60841 duk__nud_object_literal(comp_ctx, res);
60842 return;
60843 }
60844 case DUK_TOK_LPAREN: {
60845 duk_bool_t prev_allow_in;
60846
60847 comp_ctx->curr_func.paren_level++;
60848 prev_allow_in = comp_ctx->curr_func.allow_in;
60849 comp_ctx->curr_func.allow_in = 1; /* reset 'allow_in' for parenthesized expression */
60850
60851 duk__expr(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression, terminates at a ')' */
60852
60854 comp_ctx->curr_func.allow_in = prev_allow_in;
60855 comp_ctx->curr_func.paren_level--;
60856 return;
60857 }
60858
60859 /* MEMBER/NEW/CALL EXPRESSIONS */
60860
60861 case DUK_TOK_NEW: {
60862 /*
60863 * Parsing an expression starting with 'new' is tricky because
60864 * there are multiple possible productions deriving from
60865 * LeftHandSideExpression which begin with 'new'.
60866 *
60867 * We currently resort to one-token lookahead to distinguish the
60868 * cases. Hopefully this is correct. The binding power must be
60869 * such that parsing ends at an LPAREN (CallExpression) but not at
60870 * a PERIOD or LBRACKET (MemberExpression).
60871 *
60872 * See doc/compiler.rst for discussion on the parsing approach,
60873 * and testcases/test-dev-new.js for a bunch of documented tests.
60874 */
60875
60876 duk_reg_t reg_target;
60877 duk_int_t nargs;
60878
60879 DUK_DDD(DUK_DDDPRINT("begin parsing new expression"));
60880
60881 reg_target = DUK__ALLOCTEMP(comp_ctx);
60882 duk__expr_toforcedreg(comp_ctx, res, DUK__BP_CALL /*rbp_flags*/, reg_target /*forced_reg*/);
60883 DUK__SETTEMP(comp_ctx, reg_target + 1);
60884
60885 if (comp_ctx->curr_token.t == DUK_TOK_LPAREN) {
60886 /* 'new' MemberExpression Arguments */
60887 DUK_DDD(DUK_DDDPRINT("new expression has argument list"));
60888 duk__advance(comp_ctx);
60889 nargs = duk__parse_arguments(comp_ctx, res); /* parse args starting from "next temp", reg_target + 1 */
60890 /* right paren eaten */
60891 } else {
60892 /* 'new' MemberExpression */
60893 DUK_DDD(DUK_DDDPRINT("new expression has no argument list"));
60894 nargs = 0;
60895 }
60896
60897 /* Opcode slot C is used in a non-standard way, so shuffling
60898 * is not allowed.
60899 */
60900 duk__emit_a_b_c(comp_ctx,
60902 0 /*unused*/,
60903 reg_target /*target*/,
60904 nargs /*num_args*/);
60905
60906 DUK_DDD(DUK_DDDPRINT("end parsing new expression"));
60907
60908 res->t = DUK_IVAL_PLAIN;
60909 res->x1.t = DUK_ISPEC_REGCONST;
60910 res->x1.regconst = (duk_regconst_t) reg_target;
60911 return;
60912 }
60913
60914 /* FUNCTION EXPRESSIONS */
60915
60916 case DUK_TOK_FUNCTION: {
60917 /* Function expression. Note that any statement beginning with 'function'
60918 * is handled by the statement parser as a function declaration, or a
60919 * non-standard function expression/statement (or a SyntaxError). We only
60920 * handle actual function expressions (occurring inside an expression) here.
60921 *
60922 * O(depth^2) parse count for inner functions is handled by recording a
60923 * lexer offset on the first compilation pass, so that the function can
60924 * be efficiently skipped on the second pass. This is encapsulated into
60925 * duk__parse_func_like_fnum().
60926 */
60927
60928 duk_reg_t reg_temp;
60929 duk_int_t fnum;
60930
60931 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60932
60933 /* curr_token follows 'function' */
60934 fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 0 /*is_setget*/);
60935 DUK_DDD(DUK_DDDPRINT("parsed inner function -> fnum %ld", (long) fnum));
60936
60937 duk__emit_a_bc(comp_ctx,
60939 (duk_regconst_t) reg_temp /*a*/,
60940 (duk_regconst_t) fnum /*bc*/);
60941
60942 res->t = DUK_IVAL_PLAIN;
60943 res->x1.t = DUK_ISPEC_REGCONST;
60944 res->x1.regconst = (duk_regconst_t) reg_temp;
60945 return;
60946 }
60947
60948 /* UNARY EXPRESSIONS */
60949
60950 case DUK_TOK_DELETE: {
60951 /* Delete semantics are a bit tricky. The description in E5 specification
60952 * is kind of confusing, because it distinguishes between resolvability of
60953 * a reference (which is only known at runtime) seemingly at compile time
60954 * (= SyntaxError throwing).
60955 */
60956 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
60957 if (res->t == DUK_IVAL_VAR) {
60958 /* not allowed in strict mode, regardless of whether resolves;
60959 * in non-strict mode DELVAR handles both non-resolving and
60960 * resolving cases (the specification description is a bit confusing).
60961 */
60962
60963 duk_reg_t reg_temp;
60964 duk_reg_t reg_varbind;
60965 duk_regconst_t rc_varname;
60966
60967 if (comp_ctx->curr_func.is_strict) {
60969 }
60970
60971 DUK__SETTEMP(comp_ctx, temp_at_entry);
60972 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60973
60974 duk_dup(ctx, res->x1.valstack_idx);
60975 if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
60976 /* register bound variables are non-configurable -> always false */
60977 duk__emit_extraop_bc(comp_ctx,
60979 (duk_regconst_t) reg_temp);
60980 } else {
60981 duk_dup(ctx, res->x1.valstack_idx);
60982 rc_varname = duk__getconst(comp_ctx);
60983 duk__emit_a_b(comp_ctx,
60985 (duk_regconst_t) reg_temp,
60986 (duk_regconst_t) rc_varname);
60987 }
60988 res->t = DUK_IVAL_PLAIN;
60989 res->x1.t = DUK_ISPEC_REGCONST;
60990 res->x1.regconst = (duk_regconst_t) reg_temp;
60991 } else if (res->t == DUK_IVAL_PROP) {
60992 duk_reg_t reg_temp;
60993 duk_reg_t reg_obj;
60994 duk_regconst_t rc_key;
60995
60996 DUK__SETTEMP(comp_ctx, temp_at_entry);
60997 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60998 reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */
60999 rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
61000 duk__emit_a_b_c(comp_ctx,
61002 (duk_regconst_t) reg_temp,
61003 (duk_regconst_t) reg_obj,
61004 rc_key);
61005
61006 res->t = DUK_IVAL_PLAIN;
61007 res->x1.t = DUK_ISPEC_REGCONST;
61008 res->x1.regconst = (duk_regconst_t) reg_temp;
61009 } else {
61010 /* non-Reference deletion is always 'true', even in strict mode */
61011 duk_push_true(ctx);
61012 goto plain_value;
61013 }
61014 return;
61015 }
61016 case DUK_TOK_VOID: {
61017 duk__expr_toplain_ignore(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61018 duk_push_undefined(ctx);
61019 goto plain_value;
61020 }
61021 case DUK_TOK_TYPEOF: {
61022 /* 'typeof' must handle unresolvable references without throwing
61023 * a ReferenceError (E5 Section 11.4.3). Register mapped values
61024 * will never be unresolvable so special handling is only required
61025 * when an identifier is a "slow path" one.
61026 */
61027 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61028
61029 if (res->t == DUK_IVAL_VAR) {
61030 duk_reg_t reg_varbind;
61031 duk_regconst_t rc_varname;
61032 duk_reg_t reg_temp;
61033
61034 duk_dup(ctx, res->x1.valstack_idx);
61035 if (!duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
61036 DUK_DDD(DUK_DDDPRINT("typeof for an identifier name which could not be resolved "
61037 "at compile time, need to use special run-time handling"));
61038 reg_temp = DUK__ALLOCTEMP(comp_ctx);
61039 duk__emit_extraop_b_c(comp_ctx,
61041 reg_temp,
61042 rc_varname);
61043 res->t = DUK_IVAL_PLAIN;
61044 res->x1.t = DUK_ISPEC_REGCONST;
61045 res->x1.regconst = (duk_regconst_t) reg_temp;
61046 return;
61047 }
61048 }
61049
61050 args = (DUK_EXTRAOP_TYPEOF << 8) + 0;
61051 goto unary_extraop;
61052 }
61053 case DUK_TOK_INCREMENT: {
61054 args = (DUK_OP_PREINCR << 8) + 0;
61055 goto preincdec;
61056 }
61057 case DUK_TOK_DECREMENT: {
61058 args = (DUK_OP_PREDECR << 8) + 0;
61059 goto preincdec;
61060 }
61061 case DUK_TOK_ADD: {
61062 /* unary plus */
61063 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61064 if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE &&
61065 duk_is_number(ctx, res->x1.valstack_idx)) {
61066 /* unary plus of a number is identity */
61067 ;
61068 return;
61069 }
61070 args = (DUK_EXTRAOP_UNP << 8) + 0;
61071 goto unary_extraop;
61072 }
61073 case DUK_TOK_SUB: {
61074 /* unary minus */
61075 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61076 if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE &&
61077 duk_is_number(ctx, res->x1.valstack_idx)) {
61078 /* this optimization is important to handle negative literals
61079 * (which are not directly provided by the lexical grammar)
61080 */
61081 duk_tval *tv_num;
61083
61084 tv_num = DUK_GET_TVAL_POSIDX(ctx, res->x1.valstack_idx);
61085 DUK_ASSERT(tv_num != NULL);
61087 du.d = DUK_TVAL_GET_NUMBER(tv_num);
61088 du.d = -du.d;
61090 DUK_TVAL_SET_NUMBER(tv_num, du.d);
61091 return;
61092 }
61093 args = (DUK_EXTRAOP_UNM << 8) + 0;
61094 goto unary_extraop;
61095 }
61096 case DUK_TOK_BNOT: {
61097 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61098 args = (DUK_EXTRAOP_BNOT << 8) + 0;
61099 goto unary_extraop;
61100 }
61101 case DUK_TOK_LNOT: {
61102 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61103 if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE) {
61104 /* Very minimal inlining to handle common idioms '!0' and '!1',
61105 * and also boolean arguments like '!false' and '!true'.
61106 */
61107 duk_tval *tv_val;
61108
61109 tv_val = DUK_GET_TVAL_POSIDX(ctx, res->x1.valstack_idx);
61110 DUK_ASSERT(tv_val != NULL);
61111 if (DUK_TVAL_IS_NUMBER(tv_val)) {
61112 duk_double_t d;
61113 d = DUK_TVAL_GET_NUMBER(tv_val);
61114 if (d == 0.0) {
61115 /* Matches both +0 and -0 on purpose. */
61116 DUK_DDD(DUK_DDDPRINT("inlined lnot: !0 -> true"));
61118 return;
61119 } else if (d == 1.0) {
61120 DUK_DDD(DUK_DDDPRINT("inlined lnot: !1 -> false"));
61122 return;
61123 }
61124 } else if (DUK_TVAL_IS_BOOLEAN(tv_val)) {
61126 v = DUK_TVAL_GET_BOOLEAN(tv_val);
61127 DUK_DDD(DUK_DDDPRINT("inlined lnot boolean: %ld", (long) v));
61128 DUK_ASSERT(v == 0 || v == 1);
61129 DUK_TVAL_SET_BOOLEAN(tv_val, v ^ 0x01);
61130 return;
61131 }
61132 }
61133 args = (DUK_EXTRAOP_LNOT << 8) + 0;
61134 goto unary_extraop;
61135 }
61136
61137 } /* end switch */
61138
61140 return;
61141
61142 unary_extraop:
61143 {
61144 /* Note: must coerce to a (writable) temp register, so that e.g. "!x" where x
61145 * is a reg-mapped variable works correctly (does not mutate the variable register).
61146 */
61147
61148 duk_reg_t reg_temp;
61149 reg_temp = duk__ivalue_toregconst_raw(comp_ctx, res, -1 /*forced_reg*/, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
61150 duk__emit_extraop_bc(comp_ctx,
61151 (args >> 8),
61152 (duk_regconst_t) reg_temp);
61153 res->t = DUK_IVAL_PLAIN;
61154 res->x1.t = DUK_ISPEC_REGCONST;
61155 res->x1.regconst = (duk_regconst_t) reg_temp;
61156 return;
61157 }
61158
61159 preincdec:
61160 {
61161 /* preincrement and predecrement */
61162 duk_reg_t reg_res;
61163 duk_small_uint_t args_op = args >> 8;
61164
61165 /* Specific assumptions for opcode numbering. */
61170
61171 reg_res = DUK__ALLOCTEMP(comp_ctx);
61172
61173 duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */
61174 if (res->t == DUK_IVAL_VAR) {
61175 duk_hstring *h_varname;
61176 duk_reg_t reg_varbind;
61177 duk_regconst_t rc_varname;
61178
61179 h_varname = duk_get_hstring(ctx, res->x1.valstack_idx);
61180 DUK_ASSERT(h_varname != NULL);
61181
61182 if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
61183 goto syntax_error;
61184 }
61185
61186 duk_dup(ctx, res->x1.valstack_idx);
61187 if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
61188 duk__emit_a_bc(comp_ctx,
61189 args_op, /* e.g. DUK_OP_PREINCR */
61190 (duk_regconst_t) reg_res,
61191 (duk_regconst_t) reg_varbind);
61192 } else {
61193 duk__emit_a_bc(comp_ctx,
61194 args_op + 4, /* e.g. DUK_OP_PREINCV */
61195 (duk_regconst_t) reg_res,
61196 rc_varname);
61197 }
61198
61199 DUK_DDD(DUK_DDDPRINT("preincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
61200 (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
61201 } else if (res->t == DUK_IVAL_PROP) {
61202 duk_reg_t reg_obj; /* allocate to reg only (not const) */
61203 duk_regconst_t rc_key;
61204 reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */
61205 rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
61206 duk__emit_a_b_c(comp_ctx,
61207 args_op + 8, /* e.g. DUK_OP_PREINCP */
61208 (duk_regconst_t) reg_res,
61209 (duk_regconst_t) reg_obj,
61210 rc_key);
61211 } else {
61212 /* Technically return value is not needed because INVLHS will
61213 * unconditially throw a ReferenceError. Coercion is necessary
61214 * for proper semantics (consider ToNumber() called for an object).
61215 * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber().
61216 */
61217
61218 duk__ivalue_toforcedreg(comp_ctx, res, reg_res);
61219 duk__emit_extraop_bc(comp_ctx,
61221 reg_res); /* for side effects, result ignored */
61222 duk__emit_extraop_only(comp_ctx,
61224 }
61225 res->t = DUK_IVAL_PLAIN;
61226 res->x1.t = DUK_ISPEC_REGCONST;
#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u)
#define DUK_OP_PREDECP
#define DUK_OP_DELPROP
DUK_EXTERNAL void duk_push_true(duk_context *ctx)
#define DUK_TOK_THIS
#define DUK_TOK_LNOT
#define DUK_TOK_BNOT
#define DUK__GETTEMP(comp_ctx)
#define DUK_OP_PREDECR
#define DUK_OP_PREINCP
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)
#define DUK_TOK_NUMBER
DUK_LOCAL_DECL void duk__nud_array_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
DUK_LOCAL_DECL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags)
#define DUK_STR_CANNOT_DELETE_IDENTIFIER
#define DUK__BP_CALL
#define DUK_TOK_TRUE
#define DUK_EXTRAOP_UNM
#define DUK_EXTRAOP_TYPEOFID
DUK_EXTERNAL void duk_push_null(duk_context *ctx)
#define DUK_EXTRAOP_LNOT
DUK_EXTERNAL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index)
#define DUK_TOK_NEW
#define DUK_TOK_REGEXP
#define DUK_OP_CLOSURE
#define DUK_TOK_NULL
DUK_LOCAL_DECL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
#define DUK_TOK_FALSE
#define DUK_OP_PREINCR
#define DUK_TVAL_SET_BOOLEAN_TRUE(v)
#define DUK_TOK_STRING
#define DUK_EXTRAOP_LDFALSE
#define DUK_OP_DELVAR
#define DUK_OP_PREDECV
#define DUK_EXTRAOP_LDTHIS
#define DUK_TOK_DELETE
DUK_EXTERNAL void duk_push_false(duk_context *ctx)
DUK_INTERNAL_DECL void duk_regexp_compile(duk_hthread *thr)
DUK_LOCAL_DECL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
#define DUK_TVAL_SET_BOOLEAN_FALSE(v)
#define DUK_TVAL_SET_BOOLEAN(tv, val)
#define DUK_EXTRAOP_BNOT
#define DUK_TOK_TYPEOF
#define DUK_OP_REGEXP
#define DUK_TOK_LCURLY
#define DUK_OP_PREINCV
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)
#define DUK_EXTRAOP_TYPEOF
#define DUK_IVAL_NONE
#define DUK_TOK_FUNCTION
#define DUK_TVAL_IS_BOOLEAN(tv)
#define DUK_TVAL_SET_NUMBER(tv, val)
#define DUK_TOK_VOID

◆ 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 62330 of file duktape-1.5.2/src/duktape.c.

62334 {

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 62348 of file duktape-1.5.2/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 62353 of file duktape-1.5.2/src/duktape.c.

62353 {
62354 duk__expr(comp_ctx, res, rbp_flags);
62355 return duk__ivalue_toregconst(comp_ctx, res);
62356}
DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x)

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 62336 of file duktape-1.5.2/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 62291 of file duktape-1.5.2/src/duktape.c.

62294 {
62295 duk__advance(comp_ctx);
62296 duk__expr_led(comp_ctx, res, tmp);
62297 duk__copy_ivalue(comp_ctx, tmp, res); /* tmp -> res */
62298 }
62299
62300 cleanup:
62301 /* final result is already in 'res' */
62302
62303 duk_pop_2(ctx);
62304
62305 DUK__RECURSION_DECREASE(comp_ctx, thr);
62306}
62307
62308DUK_LOCAL void duk__exprtop(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)
#define DUK__RECURSION_DECREASE(comp_ctx, thr)

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 62370 of file duktape-1.5.2/src/duktape.c.

62370 {
62371 duk__expr(comp_ctx, res, rbp_flags);
62372 duk__ivalue_toplain_ignore(comp_ctx, res);
62373}
62374

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 62358 of file duktape-1.5.2/src/duktape.c.

62359 {
62360 duk__expr(comp_ctx, res, rbp_flags);
62361 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 62376 of file duktape-1.5.2/src/duktape.c.

◆ duk__fabs()

DUK_LOCAL double duk__fabs ( double x)

Definition at line 32528 of file duktape-1.5.2/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 73208 of file duktape-1.5.2/src/duktape.c.

73209 :
73210 *
73211 * * Reject other invalid Unicode sequences (see Wikipedia entry for examples)
73212 * in strict UTF-8 mode.
73213 *
73214 * * Size optimize. An attempt to use a 16-byte lookup table for the first
73215 * byte resulted in a code increase though.
73216 *
73217 * * Is checking against maximum 0x10ffff really useful? 4-byte encoding
73218 * imposes a certain limit anyway.
73219 *
73220 * * Support chunked streaming of source code. Can be implemented either
73221 * by streaming chunks of bytes or chunks of codepoints.
73222 */
73223
73224#if defined(DUK_USE_LEXER_SLIDING_WINDOW)
73225DUK_LOCAL void duk__fill_lexer_buffer(duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes) {
73226 duk_lexer_codepoint *cp, *cp_end;
73228 duk_small_uint_t contlen;
73229 const duk_uint8_t *p, *p_end;
73230#if defined(DUK_USE_STRICT_UTF8_SOURCE)
73231 duk_ucodepoint_t mincp;
73232#endif
73233 duk_int_t input_line;
73234
73235 /* Use temporaries and update lex_ctx only when finished. */
73236 input_line = lex_ctx->input_line;
73237 p = lex_ctx->input + lex_ctx->input_offset;
73238 p_end = lex_ctx->input + lex_ctx->input_length;
73239
73240 cp = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->buffer + start_offset_bytes);
73241 cp_end = lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE;
73242
73243 for (; cp != cp_end; cp++) {
73244 cp->offset = (duk_size_t) (p - lex_ctx->input);
73245 cp->line = input_line;
73246
73247 /* XXX: potential issue with signed pointers, p_end < p. */
73248 if (DUK_UNLIKELY(p >= p_end)) {
73249 /* If input_offset were assigned a negative value, it would
73250 * result in a large positive value. Most likely it would be
73251 * larger than input_length and be caught here. In any case
73252 * no memory unsafe behavior would happen.
73253 */
73254 cp->codepoint = -1;
73255 continue;
73256 }
73257
73258 x = (duk_ucodepoint_t) (*p++);
73259
73260 /* Fast path. */
73261
73262 if (DUK_LIKELY(x < 0x80UL)) {
73263 DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */
73264 if (DUK_UNLIKELY(x <= 0x000dUL)) {
73265 if ((x == 0x000aUL) ||
73266 ((x == 0x000dUL) && (p >= p_end || *p != 0x000aUL))) {
73267 /* lookup for 0x000a above assumes shortest encoding now */
73268
73269 /* E5 Section 7.3, treat the following as newlines:
73270 * LF
73271 * CR [not followed by LF]
73272 * LS
73273 * PS
73274 *
73275 * For CR LF, CR is ignored if it is followed by LF, and the LF will bump
73276 * the line number.
73277 */
73278 input_line++;
73279 }
73280 }
73281
73282 cp->codepoint = (duk_codepoint_t) x;
73283 continue;
73284 }
73285
73286 /* Slow path. */
73287
73288 if (x < 0xc0UL) {
73289 /* 10xx xxxx -> invalid */
73290 goto error_encoding;
73291 } else if (x < 0xe0UL) {
73292 /* 110x xxxx 10xx xxxx */
73293 contlen = 1;
73294#if defined(DUK_USE_STRICT_UTF8_SOURCE)
73295 mincp = 0x80UL;
73296#endif
73297 x = x & 0x1fUL;
73298 } else if (x < 0xf0UL) {
73299 /* 1110 xxxx 10xx xxxx 10xx xxxx */
73300 contlen = 2;
73301#if defined(DUK_USE_STRICT_UTF8_SOURCE)
73302 mincp = 0x800UL;
73303#endif
73304 x = x & 0x0fUL;
73305 } else if (x < 0xf8UL) {
73306 /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */
73307 contlen = 3;
73308#if defined(DUK_USE_STRICT_UTF8_SOURCE)
73309 mincp = 0x10000UL;
73310#endif
73311 x = x & 0x07UL;
73312 } else {
73313 /* no point in supporting encodings of 5 or more bytes */
73314 goto error_encoding;
73315 }
73316
73317 DUK_ASSERT(p_end >= p);
73318 if ((duk_size_t) contlen > (duk_size_t) (p_end - p)) {
73319 goto error_clipped;
73320 }
73321
73322 while (contlen > 0) {
73324 y = *p++;
73325 if ((y & 0xc0U) != 0x80U) {
73326 /* check that byte has the form 10xx xxxx */
73327 goto error_encoding;
73328 }
73329 x = x << 6;
73330 x += y & 0x3fUL;
73331 contlen--;
73332 }
73333
73334 /* check final character validity */
73335
73336 if (x > 0x10ffffUL) {
73337 goto error_encoding;
73338 }
73339#if defined(DUK_USE_STRICT_UTF8_SOURCE)
73340 if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) {
73341 goto error_encoding;
73342 }
73343#endif
73344
73345 DUK_ASSERT(x != 0x000aUL && x != 0x000dUL);
73346 if ((x == 0x2028UL) || (x == 0x2029UL)) {
DUK_LOCAL void duk__fill_lexer_buffer(duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes)

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 46776 of file duktape-1.5.2/src/duktape.c.

46781 :
46782 *
46783 * - The thread used for calling the finalizer is the same as the
46784 * 'thr' argument. This may need to change later.
46785 *
46786 * - The finalizer thread 'top' assertions are there because it is
46787 * critical that strict stack policy is observed (i.e. no cruft
46788 * left on the finalizer stack).
46789 */
46790
46791/* include removed: duk_internal.h */
46792
46794 duk_hthread *thr;
46795
46796 DUK_ASSERT(ctx != NULL);
46797 thr = (duk_hthread *) ctx;
46798
46799 DUK_DDD(DUK_DDDPRINT("protected finalization helper running"));
46800
46801 /* [... obj] */
46802
46803 /* XXX: Finalizer lookup should traverse the prototype chain (to allow
46804 * inherited finalizers) but should not invoke accessors or proxy object
46805 * behavior. At the moment this lookup will invoke proxy behavior, so
46806 * caller must ensure that this function is not called if the target is
46807 * a Proxy.
46808 */
46809
DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx)

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 42398 of file duktape-1.5.2/src/duktape.c.

42415 {
42416 duk_hthread *thr;
42417 duk_heaphdr *hdr;
42418
42419 thr = duk__get_temp_hthread(heap);
42420 DUK_ASSERT(thr != NULL);
42421
42422 DUK_DD(DUK_DDPRINT("duk__finalize_refcounts: heap=%p, hthread=%p",
42423 (void *) heap, (void *) thr));
42424
42425 hdr = heap->heap_allocated;
42426 while (hdr) {
42427 if (!DUK_HEAPHDR_HAS_REACHABLE(hdr)) {
#define DUK_HEAPHDR_HAS_REACHABLE(h)

◆ 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 45308 of file duktape-1.5.2/src/duktape.c.

45314 : %ld", (long) i));
45315 i = (i + step) % size;
45316
45317 /* looping should never happen */
45318 DUK_ASSERT(i != DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size));
45319 }
45320}
45321
45322#if defined(DUK_USE_HEAPPTR16)
45323DUK_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) {
45324#else
45325DUK_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) {
45326#endif
45327 duk_uint32_t i;
45328 duk_uint32_t step;
45329
45330 DUK_ASSERT(size > 0);
45331
45332 i = DUK__HASH_INITIAL(strhash, size);
45333 step = DUK__HASH_PROBE_STEP(strhash);
45334 for (;;) {
45335 duk_hstring *e;
45336#if defined(DUK_USE_HEAPPTR16)
45337 e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, entries16[i]);
45338#else
45339 e = entries[i];
45340#endif
45341
45342 if (!e) {
45343 return NULL;

◆ duk__floor()

DUK_LOCAL double duk__floor ( double x)

Definition at line 32549 of file duktape-1.5.2/src/duktape.c.

32551 {

◆ duk__fmax_fixed()

DUK_LOCAL double duk__fmax_fixed ( double x,
double y )

Definition at line 32400 of file duktape-1.5.2/src/duktape.c.

32402 {
32403 /* XXX: what's the safest way of creating a negative zero? */
32404 if (DUK_SIGNBIT(x) != 0 || DUK_SIGNBIT(y) != 0) {
32405 return -0.0;
32406 } else {
32407 return +0.0;
32408 }
32409 }
32410#ifdef DUK_USE_MATH_FMIN
32411 return DUK_FMIN(x, y);
32412#else
32413 return (x < y ? x : y);
32414#endif
32415}
32416

References DUK_SIGNBIT.

◆ duk__fmin_fixed()

DUK_LOCAL double duk__fmin_fixed ( double x,
double y )

Definition at line 32381 of file duktape-1.5.2/src/duktape.c.

32384 {
32385 t = duk_to_number(ctx, i);
32386 if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) {
32387 /* Note: not normalized, but duk_push_number() will normalize */
32389 } else {
32390 res = (duk_double_t) min_max(res, (double) t);
32391 }
32392 }
32393
32394 duk_push_number(ctx, res);
32395 return 1;
32396}
32397
32398DUK_LOCAL double duk__fmin_fixed(double x, double y) {
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 25358 of file duktape-1.5.2/src/duktape.c.

25360 {
25361 duk_double_t d;
25362
25363 /* [ ... this ] */
25364
25365 d = duk_bi_date_get_timeval_from_dparts(dparts, flags);
25366 duk_push_number(ctx, d); /* -> [ ... this timeval_new ] */
25367 duk_dup_top(ctx); /* -> [ ... this timeval_new timeval_new ] */
25369
25370 /* stack top: new time value, return 1 to allow tail calls */
25371 return 1;
25372}
25373
25374/* 'out_buf' must be at least DUK_BI_DATE_ISO8601_BUFSIZE long. */
25375DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags, duk_uint8_t *out_buf) {
25376 char yearstr[8]; /* "-123456\0" */
25377 char tzstr[8]; /* "+11:22\0" */
25378 char sep = (flags & DUK_DATE_FLAG_SEP_T) ? DUK_ASC_UC_T : DUK_ASC_SPACE;
25379
25380 DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12);
25381 DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31);
25382 DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= -999999 && parts[DUK_DATE_IDX_YEAR] <= 999999);
25383
25384 /* Note: %06d for positive value, %07d for negative value to include
25385 * sign and 6 digits.
25386 */
25387 DUK_SNPRINTF(yearstr,
25388 sizeof(yearstr),
25389 (parts[DUK_DATE_IDX_YEAR] >= 0 && parts[DUK_DATE_IDX_YEAR] <= 9999) ? "%04ld" :
25390 ((parts[DUK_DATE_IDX_YEAR] >= 0) ? "+%06ld" : "%07ld"),
25391 (long) parts[DUK_DATE_IDX_YEAR]);
25392 yearstr[sizeof(yearstr) - 1] = (char) 0;
25393
25394 if (flags & DUK_DATE_FLAG_LOCALTIME) {
25395 /* tzoffset seconds are dropped; 16 bits suffice for
25396 * time offset in minutes
25397 */
25398 if (tzoffset >= 0) {
25399 duk_small_int_t tmp = tzoffset / 60;
25400 DUK_SNPRINTF(tzstr, sizeof(tzstr), "+%02d:%02d", (int) (tmp / 60), (int) (tmp % 60));
25401 } else {
25402 duk_small_int_t tmp = -tzoffset / 60;
25403 DUK_SNPRINTF(tzstr, sizeof(tzstr), "-%02d:%02d", (int) (tmp / 60), (int) (tmp % 60));
25404 }
25405 tzstr[sizeof(tzstr) - 1] = (char) 0;
25406 } else {
25407 tzstr[0] = DUK_ASC_UC_Z;
25408 tzstr[1] = (char) 0;
25409 }
25410
25411 /* Unlike year, the other parts fit into 16 bits so %d format
25412 * is portable.
#define DUK_DATE_FLAG_LOCALTIME
#define DUK_ASC_UC_T
DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags)
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)
#define DUK_ASC_UC_Z
DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)

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 40912 of file duktape-1.5.2/src/duktape.c.

◆ duk__free_markandsweep_finalize_list()

DUK_LOCAL void duk__free_markandsweep_finalize_list ( duk_heap * heap)

Definition at line 40947 of file duktape-1.5.2/src/duktape.c.

40948 {
40949 duk_heaphdr *curr;
40951
40952 curr = heap->refzero_list;
40953 while (curr) {
40954 DUK_DDD(DUK_DDDPRINT("FINALFREE (refzero_list): %!iO",
40955 (duk_heaphdr *) curr));
40956 next = DUK_HEAPHDR_GET_NEXT(heap, curr);
40957 duk_heap_free_heaphdr_raw(heap, curr);
40958 curr = next;
40959 }
DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr)

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 40931 of file duktape-1.5.2/src/duktape.c.

40934 {
40935 /* We don't log or warn about freeing zero refcount objects
40936 * because they may happen with finalizer processing.
40937 */
40938
40939 DUK_DDD(DUK_DDDPRINT("FINALFREE (allocated): %!iO",
40940 (duk_heaphdr *) curr));
40941 next = DUK_HEAPHDR_GET_NEXT(heap, curr);
40942 duk_heap_free_heaphdr_raw(heap, curr);
40943 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 40967 of file duktape-1.5.2/src/duktape.c.

40969 {
40970 DUK_DDD(DUK_DDDPRINT("FINALFREE (finalize_list): %!iO",
40971 (duk_heaphdr *) curr));
40972 next = DUK_HEAPHDR_GET_NEXT(heap, curr);
40973 duk_heap_free_heaphdr_raw(heap, curr);
40974 curr = next;
40975 }
40976}
40977#endif
40978
40980 /* strings are only tracked by stringtable */
40982}
40983
40985 duk_hthread *thr;
40986 duk_heaphdr *curr;
40987 duk_uint_t round_no;
40988 duk_size_t count_all;
40989 duk_size_t count_finalized;
40990 duk_size_t curr_limit;
40991
40992 DUK_ASSERT(heap != NULL);
40993 DUK_ASSERT(heap->heap_thread != NULL);
40994
40995#if defined(DUK_USE_REFERENCE_COUNTING)
40996 DUK_ASSERT(heap->refzero_list == NULL); /* refzero not running -> must be empty */
40997#endif
40998#if defined(DUK_USE_MARK_AND_SWEEP)
40999 DUK_ASSERT(heap->finalize_list == NULL); /* mark-and-sweep not running -> must be empty */
41000#endif
41001
41002 /* XXX: here again finalizer thread is the heap_thread which needs
41003 * to be coordinated with finalizer thread fixes.
41004 */
41005 thr = heap->heap_thread;
41006 DUK_ASSERT(thr != NULL);
41007
41008 /* Prevent mark-and-sweep for the pending finalizers, also prevents
41009 * refzero handling from moving objects away from the heap_allocated
41010 * list. (The flag meaning is slightly abused here.)
41011 */
41014
41015 curr_limit = 0; /* suppress warning, not used */
41016 for (round_no = 0; ; round_no++) {
41017 curr = heap->heap_allocated;
41018 count_all = 0;
41019 count_finalized = 0;
41020 while (curr) {
41021 count_all++;
41023 /* Only objects in heap_allocated may have finalizers. Check that
41024 * the object itself has a _Finalizer property (own or inherited)
41025 * so that we don't execute finalizers for e.g. Proxy objects.
41026 */
41027 DUK_ASSERT(thr != NULL);
41028 DUK_ASSERT(curr != NULL);
41029
41031 if (!DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) curr)) {
41032 DUK_ASSERT(DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)); /* maps to finalizer 2nd argument */
41034 count_finalized++;
41035 }
41036 }
41037 }
41038 curr = DUK_HEAPHDR_GET_NEXT(heap, curr);
41039 }
41040
41041 /* Each round of finalizer execution may spawn new finalizable objects
41042 * which is normal behavior for some applications. Allow multiple
41043 * rounds of finalization, but use a shrinking limit based on the
41044 * first round to detect the case where a runaway finalizer creates
41045 * an unbounded amount of new finalizable objects. Finalizer rescue
41046 * is not supported: the semantics are unclear because most of the
41047 * objects being finalized here are already reachable. The finalizer
41048 * is given a boolean to indicate that rescue is not possible.
41049 *
41050 * See discussion in: https://github.com/svaarala/duktape/pull/473
41051 */
41052
41053 if (round_no == 0) {
41054 /* Cannot wrap: each object is at least 8 bytes so count is
41055 * at most 1/8 of that.
41056 */
41057 curr_limit = count_all * 2;
41058 } else {
41059 curr_limit = (curr_limit * 3) / 4; /* Decrease by 25% every round */
#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)
DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap)
#define DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap)
DUK_LOCAL void duk__free_stringtable(duk_heap *heap)
#define DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)
#define DUK_HEAPHDR_HAS_FINALIZED(h)
DUK_INTERNAL_DECL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj)
DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap)
#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)
DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key)

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 40962 of file duktape-1.5.2/src/duktape.c.

40964 {
40965 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 77551 of file duktape-1.5.2/src/duktape.c.

77558 {] is
77559 * continuous but [X-{] is not). The current algorithm creates the
77560 * canonicalized range(s) space efficiently at the cost of compile
77561 * time execution time (see doc/regexp.rst for discussion).
77562 *
77563 * Note that the ctx->nranges is a context-wide temporary value
77564 * (this is OK because there cannot be multiple character classes
77565 * being parsed simultaneously).
77566 */
77567
77568DUK_LOCAL void duk__generate_ranges(void *userdata, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct) {
77569 duk_re_compiler_ctx *re_ctx = (duk_re_compiler_ctx *) userdata;
77570
77571 DUK_DD(DUK_DDPRINT("duk__generate_ranges(): re_ctx=%p, range=[%ld,%ld] direct=%ld",
77572 (void *) re_ctx, (long) r1, (long) r2, (long) direct));
77573
77574 if (!direct && (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE)) {
77575 /*
77576 * Canonicalize a range, generating result ranges as necessary.
77577 * Needs to exhaustively scan the entire range (at most 65536
77578 * code points). If 'direct' is set, caller (lexer) has ensured
77579 * that the range is already canonicalization compatible (this
77580 * is used to avoid unnecessary canonicalization of built-in
77581 * ranges like \W, which are not affected by canonicalization).
77582 *
77583 * NOTE: here is one place where we don't want to support chars
77584 * outside the BMP, because the exhaustive search would be
77585 * massively larger.
77586 */
77587
77590 duk_codepoint_t r_start, r_end;
77591
77592 r_start = duk_unicode_re_canonicalize_char(re_ctx->thr, r1);
77593 r_end = r_start;
77594 for (i = r1 + 1; i <= r2; i++) {
77595 t = duk_unicode_re_canonicalize_char(re_ctx->thr, i);
77596 if (t == r_end + 1) {
77597 r_end = t;
77598 } else {
77599 DUK_DD(DUK_DDPRINT("canonicalized, emit range: [%ld,%ld]", (long) r_start, (long) r_end));
77600 duk__append_u32(re_ctx, (duk_uint32_t) r_start);
DUK_LOCAL void duk__generate_ranges(void *userdata, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct)
DUK_INTERNAL_DECL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, duk_codepoint_t cp)
#define DUK_RE_FLAG_IGNORE_CASE
DUK_LOCAL duk_uint32_t duk__append_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t x)

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 16260 of file duktape-1.5.2/src/duktape.c.

16263 {
16265 }
16266 return NULL;
16267}
16268
16270 return duk__get_buffer_helper(ctx, index, out_size, 0 /*throw_flag*/);
16271}
16272
16274 return duk__get_buffer_helper(ctx, index, out_size, 1 /*throw_flag*/);
16275}
16276
16278 duk_hthread *thr = (duk_hthread *) ctx;
16279 duk_tval *tv;
16280
16282 DUK_UNREF(thr);
16283
16284 if (out_size != NULL) {
16285 *out_size = 0;
16286 }
16287
16288 tv = duk_get_tval(ctx, index);
16289 if (tv == NULL) {
16290 goto fail;
16291 }
16292
16293 if (DUK_TVAL_IS_BUFFER(tv)) {
16295 DUK_ASSERT(h != NULL);
16296 if (out_size) {
16297 *out_size = DUK_HBUFFER_GET_SIZE(h);
16298 }
16299 return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); /* may be NULL (but only if size is 0) */
16300 } else if (DUK_TVAL_IS_OBJECT(tv)) {
16302 DUK_ASSERT(h != NULL);
16304 /* XXX: this is probably a useful shared helper: for a
16305 * duk_hbufferobject, get a validated buffer pointer/length.
16306 */
16307 duk_hbufferobject *h_bufobj = (duk_hbufferobject *) h;
16309
16310 if (h_bufobj->buf != NULL &&
16312 duk_uint8_t *p;
#define DUK_TVAL_IS_BUFFER(tv)
#define DUK_HBUFFEROBJECT_VALID_SLICE(h)
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)
#define DUK_STR_NOT_BUFFER
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__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 16225 of file duktape-1.5.2/src/duktape.c.

16226 {
16227 duk_tval *tv;
16228
16230
16231 tv = duk_get_tval(ctx, index);
16232 if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
16234 DUK_ASSERT(h != NULL);
16235 return (void *) h;
16236 }
16237
16238 return NULL;
16239}
16240#endif
16241
16243 duk_hthread *thr = (duk_hthread *) ctx;
16244 duk_tval *tv;
16245
16247 DUK_UNREF(thr);
16248
16249 if (out_size != NULL) {
16250 *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 21657 of file duktape-1.5.2/src/duktape.c.

21659 {

◆ duk__get_current_pc()

DUK_LOCAL_DECL duk_int_t duk__get_current_pc ( duk_compiler_ctx * comp_ctx)

Definition at line 58481 of file duktape-1.5.2/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 47345 of file duktape-1.5.2/src/duktape.c.

47350 {
47351 DUK_UNREF(thr);
47352 return (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
47353 key == DUK_HTHREAD_STRING_NAME(thr));
47354}
47355
47356/*
47357 * Helpers for managing property storage size
47358 */
47359
47360/* Get default hash part size for a certain entry part size. */
#define DUK_HTHREAD_STRING_NAME(thr)
#define DUK_HTHREAD_STRING_LENGTH(thr)

◆ 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 72100 of file duktape-1.5.2/src/duktape.c.

72122 {
72123 duk_tval *tv;
72124 duk_tval *tv_target;
72125 duk_tval tv_name;
72126 duk_uint_t sanity;
72127
72128 DUK_ASSERT(thr != NULL);
72129 DUK_ASSERT(env != NULL || act != NULL);
72130 DUK_ASSERT(name != NULL);
72131 DUK_ASSERT(out != NULL);
72132
72133 DUK_ASSERT(!env || DUK_HOBJECT_IS_ENV(env));
72135
72136 /*
72137 * Conceptually, we look for the identifier binding by starting from
72138 * 'env' and following to chain of environment records (represented
72139 * by the prototype chain).
72140 *
72141 * If 'env' is NULL, the current activation does not yet have an
72142 * allocated declarative environment record; this should be treated
72143 * exactly as if the environment record existed but had no bindings
72144 * other than register bindings.
72145 *
72146 * Note: we assume that with the DUK_HOBJECT_FLAG_NEWENV cleared
72147 * the environment will always be initialized immediately; hence
72148 * a NULL 'env' should only happen with the flag set. This is the
72149 * case for: (1) function calls, and (2) strict, direct eval calls.
72150 */
72151
72152 if (env == NULL && act != NULL) {
72153 duk_hobject *func;
72154
72155 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference: env is NULL, activation is non-NULL -> "
72156 "delayed env case, look up activation regs first"));
72157
72158 /*
72159 * Try registers
72160 */
72161
72162 if (duk__getid_activation_regs(thr, name, act, out)) {
72163 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
72164 "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
72165 "(found from register bindings when env=NULL)",
72166 (duk_heaphdr *) name, (duk_tval *) out->value,
72167 (long) out->attrs, (duk_tval *) out->this_binding,
72168 (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
72169 return 1;
72170 }
72171
72172 DUK_DDD(DUK_DDDPRINT("not found in current activation regs"));
72173
72174 /*
72175 * Not found in registers, proceed to the parent record.
72176 * Here we need to determine what the parent would be,
72177 * if 'env' was not NULL (i.e. same logic as when initializing
72178 * the record).
72179 *
72180 * Note that environment initialization is only deferred when
72181 * DUK_HOBJECT_HAS_NEWENV is set, and this only happens for:
72182 * - Function code
72183 * - Strict eval code
72184 *
72185 * We only need to check _Lexenv here; _Varenv exists only if it
72186 * differs from _Lexenv (and thus _Lexenv will also be present).
72187 */
72188
72189 if (!parents) {
72190 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal "
72191 "(not found from register bindings when env=NULL)"));
72192 goto fail_not_found;
72193 }
72194
72195 func = DUK_ACT_GET_FUNC(act);
72196 DUK_ASSERT(func != NULL);
72198
72200 if (tv) {
72202 env = DUK_TVAL_GET_OBJECT(tv);
72203 } else {
72205 env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
72206 }
72207
72208 DUK_DDD(DUK_DDDPRINT("continue lookup from env: %!iO",
72209 (duk_heaphdr *) env));
72210 }
72211
72212 /*
72213 * Prototype walking starting from 'env'.
72214 *
72215 * ('act' is not needed anywhere here.)
72216 */
72217
72219 while (env != NULL) {
72220 duk_small_int_t cl;
72221 duk_int_t attrs;
72222
72223 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference, name=%!O, considering env=%p -> %!iO",
72224 (duk_heaphdr *) name,
72225 (void *) env,
72226 (duk_heaphdr *) env));
72227
72228 DUK_ASSERT(env != NULL);
72231
72234 if (cl == DUK_HOBJECT_CLASS_DECENV) {
72235 /*
72236 * Declarative environment record.
72237 *
72238 * Identifiers can never be stored in ancestors and are
72239 * always plain values, so we can use an internal helper
72240 * and access the value directly with an duk_tval ptr.
72241 *
72242 * A closed environment is only indicated by it missing
72243 * the "book-keeping" properties required for accessing
72244 * register-bound variables.
72245 */
72246
72248 /* already closed */
72249 goto skip_regs;
72250 }
72251
72252 if (duk__getid_open_decl_env_regs(thr, name, env, out)) {
72253 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
72254 "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
72255 "(declarative environment record, scope open, found in regs)",
72256 (duk_heaphdr *) name, (duk_tval *) out->value,
72257 (long) out->attrs, (duk_tval *) out->this_binding,
72258 (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
72259 return 1;
72260 }
72261 skip_regs:
72262
72264 if (tv) {
72265 out->value = tv;
72266 out->attrs = attrs;
72267 out->this_binding = NULL; /* implicit this value always undefined for
72268 * declarative environment records.
72269 */
72270 out->env = env;
72271 out->holder = env;
72272
72273 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
72274 "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
72275 "(declarative environment record, found in properties)",
72276 (duk_heaphdr *) name, (duk_tval *) out->value,
72277 (long) out->attrs, (duk_tval *) out->this_binding,
72278 (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
72279 return 1;
72280 }
72281 } else {
72282 /*
72283 * Object environment record.
72284 *
72285 * Binding (target) object is an external, uncontrolled object.
72286 * Identifier may be bound in an ancestor property, and may be
72287 * an accessor. Target can also be a Proxy which we must support
72288 * here.
72289 */
72290
72291 /* XXX: we could save space by using _Target OR _This. If _Target, assume
72292 * this binding is undefined. If _This, assumes this binding is _This, and
72293 * target is also _This. One property would then be enough.
72294 */
72295
72296 duk_hobject *target;
72297 duk_bool_t found;
72298
72300
72302 DUK_ASSERT(tv_target != NULL);
72303 DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_target));
72304 target = DUK_TVAL_GET_OBJECT(tv_target);
72305 DUK_ASSERT(target != NULL);
72306
72307 /* Target may be a Proxy or property may be an accessor, so we must
72308 * use an actual, Proxy-aware hasprop check here.
72309 *
72310 * out->holder is NOT set to the actual duk_hobject where the
72311 * property is found, but rather the object binding target object.
72312 */
72313
72314 if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(target)) {
72315 DUK_ASSERT(name != NULL);
72316 DUK_TVAL_SET_STRING(&tv_name, name);
72317
72318 found = duk_hobject_hasprop(thr, tv_target, &tv_name);
72319 } else {
72320 /* XXX: duk_hobject_hasprop() would be correct for
72321 * non-Proxy objects too, but it is about ~20-25%
72322 * slower at present so separate code paths for
72323 * Proxy and non-Proxy now.
72324 */
72325 found = duk_hobject_hasprop_raw(thr, target, name);
72326 }
72327
72328 if (found) {
72329 out->value = NULL; /* can't get value, may be accessor */
72330 out->attrs = 0; /* irrelevant when out->value == NULL */
72332 out->this_binding = tv; /* may be NULL */
72333 out->env = env;
72334 out->holder = target;
72335
72336 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
72337 "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
72338 "(object environment record)",
72339 (duk_heaphdr *) name, (duk_tval *) out->value,
72340 (long) out->attrs, (duk_tval *) out->this_binding,
72341 (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
72342 return 1;
72343 }
72344 }
72345
72346 if (!parents) {
72347 DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal "
DUK_LOCAL duk_bool_t duk__getid_activation_regs(duk_hthread *thr, duk_hstring *name, duk_activation *act, duk__id_lookup_result *out)
#define DUK_HTHREAD_STRING_INT_VARENV(thr)
#define DUK_HTHREAD_STRING_INT_LEXENV(thr)
#define DUK_HOBJECT_IS_ENV(h)
#define DUK_HOBJECT_HAS_ARRAY_PART(h)
#define DUK_HOBJECT_CLASS_OBJENV
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)
#define DUK_HTHREAD_STRING_INT_THIS(thr)
#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY
#define DUK_HOBJECT_CLASS_DECENV
#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)
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)
#define DUK_ACT_GET_FUNC(act)
DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key)
#define DUK_HOBJECT_HAS_ENVRECCLOSED(h)
#define DUK_TVAL_SET_STRING(tv, hptr)

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 55658 of file duktape-1.5.2/src/duktape.c.

55662 {
55663 /* XXX: inefficient; block insert primitive */
55664 duk_push_undefined(ctx);
55665 duk_insert(ctx, idx_rcbase);
55666 }
55667 }
55668}
55669
55670/*
55671 * Misc shared helpers.
55672 */
55673
55674/* Get valstack index for the func argument or throw if insane stack. */
55676 duk_size_t off_stack_top;
55677 duk_size_t off_stack_args;
55678 duk_size_t off_stack_all;
DUK_LOCAL duk_idx_t duk__get_idx_func(duk_hthread *thr, duk_idx_t num_stack_args)

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 58487 of file duktape-1.5.2/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 47375 of file duktape-1.5.2/src/duktape.c.

47381 {
47382 duk_uint32_t res;
47383

◆ duk__get_min_grow_e()

DUK_LOCAL duk_uint32_t duk__get_min_grow_e ( duk_uint32_t e_size)

Definition at line 47364 of file duktape-1.5.2/src/duktape.c.

47365 {
47366 duk_uint32_t res;
47367
47368 /* result: hash_prime(floor(1.2 * e_size)) */
47369 res = duk_util_get_hash_prime(e_size + e_size / DUK_HOBJECT_H_SIZE_DIVISOR);
47370
47371 /* if fails, e_size will be zero = not an issue, except performance-wise */
47372 DUK_ASSERT(res == 0 || res > e_size);
#define DUK_HOBJECT_H_SIZE_DIVISOR
DUK_INTERNAL_DECL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t 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 50040 of file duktape-1.5.2/src/duktape.c.

50057 {
50058 duk_bool_t rc;
50059 duk_tval *tv;
50060 duk_uint32_t res;
50061
50063
50064 /* This function is only called for objects with array exotic behavior.
50065 * The [[DefineOwnProperty]] algorithm for arrays requires that
50066 * 'length' can never have a value outside the unsigned 32-bit range,
50067 * attempt to write such a value is a RangeError. Here we can thus
50068 * assert for this. When Duktape internals go around the official
50069 * property write interface (doesn't happen often) this assumption is
50070 * easy to accidentally break, so such code must be written carefully.
50071 * See test-bi-array-push-maxlen.js.
50072 */
50073
50074 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 */
50075 DUK_UNREF(rc);
50076 DUK_ASSERT(rc != 0); /* arrays MUST have a 'length' property */
50077 DUK_ASSERT(temp_desc->e_idx >= 0);
50078
50079 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, temp_desc->e_idx);
50080 DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); /* array 'length' is always a number, as we coerce it */
50081 DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) >= 0.0);
50082 DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) <= (double) 0xffffffffUL);
#define DUK__NO_ARRAY_INDEX
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)

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 48763 of file duktape-1.5.2/src/duktape.c.

48780 {
48781 duk_context *ctx = (duk_context *) thr;
48782 duk_tval *tv;
48783
48784 DUK_DDD(DUK_DDDPRINT("duk_hobject_get_own_propdesc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, "
48785 "arr_idx=%ld (obj -> %!O, key -> %!O)",
48786 (void *) thr, (void *) obj, (void *) key, (void *) out_desc,
48787 (long) flags, (long) arr_idx,
48788 (duk_heaphdr *) obj, (duk_heaphdr *) key));
48789
48790 DUK_ASSERT(ctx != NULL);
48791 DUK_ASSERT(thr != NULL);
48792 DUK_ASSERT(thr->heap != NULL);
48793 DUK_ASSERT(obj != NULL);
48794 DUK_ASSERT(key != NULL);
48795 DUK_ASSERT(out_desc != NULL);
48797
48798 /* XXX: optimize this filling behavior later */
48799 out_desc->flags = 0;
48800 out_desc->get = NULL;
48801 out_desc->set = NULL;
48802 out_desc->e_idx = -1;
48803 out_desc->h_idx = -1;
48804 out_desc->a_idx = -1;
48805
48806 /*
48807 * Array part
48808 */
48809
48810 if (DUK_HOBJECT_HAS_ARRAY_PART(obj) && arr_idx != DUK__NO_ARRAY_INDEX) {
48811 if (arr_idx < DUK_HOBJECT_GET_ASIZE(obj)) {
48812 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
48813 if (!DUK_TVAL_IS_UNUSED(tv)) {
48814 DUK_DDD(DUK_DDDPRINT("-> found in array part"));
48815 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48816 duk_push_tval(ctx, tv);
48817 }
48818 /* implicit attributes */
48819 out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE |
48822 out_desc->a_idx = arr_idx;
48823 goto prop_found;
48824 }
48825 }
48826 /* assume array part is comprehensive (contains all array indexed elements
48827 * or none of them); hence no need to check the entries part here.
48828 */
48829 DUK_DDD(DUK_DDDPRINT("-> not found as a concrete property (has array part, "
48830 "should be there if present)"));
48831 goto prop_not_found_concrete;
48832 }
48833
48834 /*
48835 * Entries part
48836 */
48837
48838 duk_hobject_find_existing_entry(thr->heap, obj, key, &out_desc->e_idx, &out_desc->h_idx);
48839 if (out_desc->e_idx >= 0) {
48840 duk_int_t e_idx = out_desc->e_idx;
48841 out_desc->flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, e_idx);
48842 if (out_desc->flags & DUK_PROPDESC_FLAG_ACCESSOR) {
48843 DUK_DDD(DUK_DDDPRINT("-> found accessor property in entry part"));
48844 out_desc->get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, e_idx);
48845 out_desc->set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, e_idx);
48846 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48847 /* a dummy undefined value is pushed to make valstack
48848 * behavior uniform for caller
48849 */
48850 duk_push_undefined(ctx);
48851 }
48852 } else {
48853 DUK_DDD(DUK_DDDPRINT("-> found plain property in entry part"));
48854 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
48855 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48856 duk_push_tval(ctx, tv);
48857 }
48858 }
48859 goto prop_found;
48860 }
48861
48862 /*
48863 * Not found as a concrete property, check whether a String object
48864 * virtual property matches.
48865 */
48866
48867 prop_not_found_concrete:
48868
48870 DUK_DDD(DUK_DDDPRINT("string object exotic property get for key: %!O, arr_idx: %ld",
48871 (duk_heaphdr *) key, (long) arr_idx));
48872
48873 if (arr_idx != DUK__NO_ARRAY_INDEX) {
48874 duk_hstring *h_val;
48875
48876 DUK_DDD(DUK_DDDPRINT("array index exists"));
48877
48878 h_val = duk_hobject_get_internal_value_string(thr->heap, obj);
48879 DUK_ASSERT(h_val);
48880 if (arr_idx < DUK_HSTRING_GET_CHARLEN(h_val)) {
48881 DUK_DDD(DUK_DDDPRINT("-> found, array index inside string"));
48882 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48883 duk_push_hstring(ctx, h_val);
48884 duk_substring(ctx, -1, arr_idx, arr_idx + 1); /* [str] -> [substr] */
48885 }
48886 out_desc->flags = DUK_PROPDESC_FLAG_ENUMERABLE | /* E5 Section 15.5.5.2 */
48888
48890 return 1; /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */
48891 } else {
48892 /* index is above internal string length -> property is fully normal */
48893 DUK_DDD(DUK_DDDPRINT("array index outside string -> normal property"));
48894 }
48895 } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
48896 duk_hstring *h_val;
48897
48898 DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
48899
48900 h_val = duk_hobject_get_internal_value_string(thr->heap, obj);
48901 DUK_ASSERT(h_val != NULL);
48902 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48904 }
48905 out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; /* E5 Section 15.5.5.1 */
48906
48908 return 1; /* cannot be arguments exotic */
48909 }
48910 } else if (DUK_HOBJECT_IS_BUFFEROBJECT(obj)) {
48911 duk_hbufferobject *h_bufobj;
48912 duk_uint_t byte_off;
48913 duk_small_uint_t elem_size;
48914
48915 h_bufobj = (duk_hbufferobject *) obj;
48917 DUK_DDD(DUK_DDDPRINT("bufferobject property get for key: %!O, arr_idx: %ld",
48918 (duk_heaphdr *) key, (long) arr_idx));
48919
48920 if (arr_idx != DUK__NO_ARRAY_INDEX) {
48921 DUK_DDD(DUK_DDDPRINT("array index exists"));
48922
48923 /* Careful with wrapping: arr_idx upshift may easily wrap, whereas
48924 * length downshift won't.
48925 */
48926 if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) {
48927 byte_off = arr_idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */
48928 elem_size = 1 << h_bufobj->shift;
48929 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48930 duk_uint8_t *data;
48931
48932 if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) {
48933 data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
48934 duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size);
48935 } else {
48936 DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)"));
48937 duk_push_uint(ctx, 0);
48938 }
48939 }
48940 out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE |
48943
48945 return 1; /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */
48946 } else {
48947 /* index is above internal buffer length -> property is fully normal */
48948 DUK_DDD(DUK_DDDPRINT("array index outside buffer -> normal property"));
48949 }
48950 } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
48951 DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
48952
48953 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48954 /* Length in elements: take into account shift, but
48955 * intentionally don't check the underlying buffer here.
48956 */
48957 duk_push_uint(ctx, h_bufobj->length >> h_bufobj->shift);
48958 }
48959 out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
48960
48962 return 1; /* cannot be arguments exotic */
48963 } else if (key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) {
48964 /* If neutered must return 0; length is zeroed during
48965 * neutering.
48966 */
48967 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48968 duk_push_uint(ctx, h_bufobj->length);
48969 }
48970 out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
48971 return 1; /* cannot be arguments exotic */
48972 } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) {
48973 /* If neutered must return 0; offset is zeroed during
48974 * neutering.
48975 */
48976 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48977 duk_push_uint(ctx, h_bufobj->offset);
48978 }
48979 out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
48980 return 1; /* cannot be arguments exotic */
48981 } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) {
48982 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48983 duk_push_uint(ctx, 1 << h_bufobj->shift);
48984 }
48985 out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
48986 return 1; /* cannot be arguments exotic */
48987 }
48988 } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj)) {
48989 DUK_DDD(DUK_DDDPRINT("duktape/c object exotic property get for key: %!O, arr_idx: %ld",
48990 (duk_heaphdr *) key, (long) arr_idx));
48991
48992 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
48993 DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
48994
48995 if (flags & DUK_GETDESC_FLAG_PUSH_VALUE) {
48996 duk_int16_t func_nargs = ((duk_hnativefunction *) obj)->nargs;
48997 duk_push_int(ctx, func_nargs == DUK_HNATIVEFUNCTION_NARGS_VARARGS ? 0 : func_nargs);
48998 }
48999 out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; /* not enumerable */
49000
49002 return 1; /* cannot be arguments exotic */
49003 }
49004 }
49005
49006 /* Array properties have exotic behavior but they are concrete,
49007 * so no special handling here.
49008 *
49009 * Arguments exotic behavior (E5 Section 10.6, [[GetOwnProperty]]
49010 * is only relevant as a post-check implemented below; hence no
49011 * check here.
49012 */
49013
49014 /*
49015 * Not found as concrete or virtual
49016 */
49017
49018 DUK_DDD(DUK_DDDPRINT("-> not found (virtual, entry part, or array part)"));
49019 return 0;
49020
49021 /*
49022 * Found
49023 *
49024 * Arguments object has exotic post-processing, see E5 Section 10.6,
49025 * description of [[GetOwnProperty]] variant for arguments.
49026 */
49027
49028 prop_found:
49029 DUK_DDD(DUK_DDDPRINT("-> property found, checking for arguments exotic post-behavior"));
49030
49031 /* Notes:
49032 * - only numbered indices are relevant, so arr_idx fast reject is good
49033 * (this is valid unless there are more than 4**32-1 arguments).
49034 * - since variable lookup has no side effects, this can be skipped if
49035 * DUK_GETDESC_FLAG_PUSH_VALUE is not set.
49036 */
49037
49039 arr_idx != DUK__NO_ARRAY_INDEX &&
49040 (flags & DUK_GETDESC_FLAG_PUSH_VALUE)) {
49041 duk_propdesc temp_desc;
49042
49043 /* Magically bound variable cannot be an accessor. However,
49044 * there may be an accessor property (or a plain property) in
49045 * place with magic behavior removed. This happens e.g. when
49046 * a magic property is redefined with defineProperty().
#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)
#define DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h)
#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h, off)
#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)
#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr)
#define DUK_PROPDESC_FLAG_VIRTUAL
#define DUK_HSTRING_GET_CHARLEN(x)
#define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)
DUK_INTERNAL_DECL duk_hstring * duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj)
#define DUK_HNATIVEFUNCTION_NARGS_VARARGS
#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr)
DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset)
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)

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 25474 of file duktape-1.5.2/src/duktape.c.

25491 {
25492 duk_double_t d;
25494 duk_small_uint_t idx_part = (duk_small_uint_t) (flags_and_idx >> DUK_DATE_FLAG_VALUE_SHIFT); /* unpack args */
25495
25496 DUK_ASSERT_DISABLE(idx_part >= 0); /* unsigned */
#define DUK_DATE_IDX_NUM_PARTS
#define DUK_DATE_FLAG_VALUE_SHIFT

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 49077 of file duktape-1.5.2/src/duktape.c.

49078 :
49079 * - Fills descriptor fields to 'out_desc'
49080 * - If DUK_GETDESC_FLAG_PUSH_VALUE is set, pushes a value related to the
49081 * property onto the stack ('undefined' for accessor properties).
49082 * - Returns non-zero
49083 *
49084 * If property is not found:
49085 * - 'out_desc' is left in untouched state (possibly garbage)
49086 * - Nothing is pushed onto the stack (not even with DUK_GETDESC_FLAG_PUSH_VALUE
49087 * set)
49088 * - Returns zero
49089 *
49090 * May cause arbitrary side effects and invalidate (most) duk_tval
49091 * pointers.
49092 */
49093
49095 duk_hobject *curr;
49096 duk_uint32_t arr_idx;
49097 duk_uint_t sanity;
49098
49099 DUK_ASSERT(thr != NULL);
49100 DUK_ASSERT(thr->heap != NULL);
49101 DUK_ASSERT(obj != NULL);
49102 DUK_ASSERT(key != NULL);
49103 DUK_ASSERT(out_desc != NULL);
49105
49106 arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
49107
49108 DUK_DDD(DUK_DDDPRINT("duk__get_propdesc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, "
49109 "arr_idx=%ld (obj -> %!O, key -> %!O)",
49110 (void *) thr, (void *) obj, (void *) key, (void *) out_desc,
49111 (long) flags, (long) arr_idx,
49112 (duk_heaphdr *) obj, (duk_heaphdr *) key));
49113
49114 curr = obj;
49115 DUK_ASSERT(curr != NULL);
49117 do {
49118 if (duk__get_own_propdesc_raw(thr, curr, key, arr_idx, out_desc, flags)) {
49119 /* stack contains value (if requested), 'out_desc' is set */
49120 return 1;
49121 }
49122
49123 /* not found in 'curr', next in prototype chain; impose max depth */
#define DUK_HSTRING_GET_ARRIDX_FAST(h)
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)

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 16327 of file duktape-1.5.2/src/duktape.c.

16331 {
16332 return duk__get_buffer_data_helper(ctx, index, out_size, 0 /*throw_flag*/);
16333}
16334
16336 return duk__get_buffer_data_helper(ctx, index, out_size, 1 /*throw_flag*/);
16337}
16338
16339/* Raw helper for getting a value from the stack, checking its tag.
16340 * The tag cannot be a number because numbers don't have an internal
16341 * tag in the packed representation.
DUK_EXTERNAL void * duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size)

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 41973 of file duktape-1.5.2/src/duktape.c.

◆ duk__get_this_regexp()

DUK_LOCAL void duk__get_this_regexp ( duk_context * ctx)

Definition at line 33648 of file duktape-1.5.2/src/duktape.c.

33651 {
33652 DUK_UNREF(ctx);
33654}
33655#endif /* DUK_USE_ES6_PROXY */
33656#line 1 "duk_bi_regexp.c"

◆ duk__getconst()

DUK_LOCAL_DECL duk_regconst_t duk__getconst ( duk_compiler_ctx * comp_ctx)

Definition at line 59350 of file duktape-1.5.2/src/duktape.c.

59355 {
59356 return duk__alloctemps(comp_ctx, 1);
59357}
59358
59359DUK_LOCAL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next) {
59360 comp_ctx->curr_func.temp_next = temp_next;
59361 if (temp_next > comp_ctx->curr_func.temp_max) {
59362 comp_ctx->curr_func.temp_max = temp_next;
59363 }
59364}
59365
59366/* get const for value at valstack top */
59368 duk_hthread *thr = comp_ctx->thr;
59369 duk_context *ctx = (duk_context *) thr;
59370 duk_compiler_func *f = &comp_ctx->curr_func;
59371 duk_tval *tv1;
59372 duk_int_t i, n, n_check;
59373
59374 n = (duk_int_t) duk_get_length(ctx, f->consts_idx);
59375
59376 tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
59377 DUK_ASSERT(tv1 != NULL);
59378
59379#if defined(DUK_USE_FASTINT)
59380 /* Explicit check for fastint downgrade. */
59382#endif
59383
59384 /* Sanity workaround for handling functions with a large number of
59385 * constants at least somewhat reasonably. Otherwise checking whether
59386 * we already have the constant would grow very slow (as it is O(N^2)).
59387 */
59389 for (i = 0; i < n_check; i++) {
59391
59392 /* Strict equality is NOT enough, because we cannot use the same
59393 * constant for e.g. +0 and -0.
59394 */
#define DUK__GETCONST_MAX_CONSTS_CHECK
DUK_LOCAL_DECL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next)
#define DUK_TVAL_CHKFAST_INPLACE(v)
DUK_LOCAL_DECL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num)

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 72044 of file duktape-1.5.2/src/duktape.c.

72064 {
72065 duk_tval *tv;
72066 duk_hobject *func;
72067 duk_hobject *varmap;
72068 duk_size_t reg_rel;
72069 duk_size_t idx;
72070
72071 DUK_ASSERT(thr != NULL);
72072 DUK_ASSERT(name != NULL);
72073 DUK_ASSERT(act != NULL);
72074 DUK_ASSERT(out != NULL);
72075
72076 func = DUK_ACT_GET_FUNC(act);
72077 DUK_ASSERT(func != NULL);
72079
72081 return 0;
72082 }
72083
72085 if (!tv) {
72086 return 0;
72087 }
72089 varmap = DUK_TVAL_GET_OBJECT(tv);
72090 DUK_ASSERT(varmap != NULL);
72091
72093 if (!tv) {
72094 return 0;
72095 }
72097 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 71959 of file duktape-1.5.2/src/duktape.c.

71979 {
71980 duk_hthread *env_thr;
71981 duk_hobject *env_func;
71982 duk_size_t env_regbase;
71983 duk_hobject *varmap;
71984 duk_tval *tv;
71985 duk_size_t reg_rel;
71986 duk_size_t idx;
71987
71988 DUK_ASSERT(thr != NULL);
71989 DUK_ASSERT(name != NULL);
71990 DUK_ASSERT(env != NULL);
71991 DUK_ASSERT(out != NULL);
71992
71994
71996 if (!tv) {
71997 /* env is closed, should be missing _Callee, _Thread, _Regbase */
72001 return 0;
72002 }
72003
72007 env_func = DUK_TVAL_GET_OBJECT(tv);
72008 DUK_ASSERT(env_func != NULL);
72009
72011 if (!tv) {
72012 return 0;
72013 }
72015 varmap = DUK_TVAL_GET_OBJECT(tv);
72016 DUK_ASSERT(varmap != NULL);
72017
72019 if (!tv) {
72020 return 0;
72021 }
72023 reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv);
72024 DUK_ASSERT_DISABLE(reg_rel >= 0); /* unsigned */
72025 DUK_ASSERT(reg_rel < ((duk_hcompiledfunction *) env_func)->nregs);
72026
72028 DUK_ASSERT(tv != NULL);
72032 env_thr = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv);
72033 DUK_ASSERT(env_thr != NULL);
72034
72035 /* Note: env_thr != thr is quite possible and normal, so careful
72036 * with what thread is used for valstack lookup.
72037 */
72038
72040 DUK_ASSERT(tv != NULL);
#define DUK_HTHREAD_STRING_INT_REGBASE(thr)
#define DUK_HTHREAD_STRING_INT_THREAD(thr)
#define DUK_HTHREAD_STRING_INT_CALLEE(thr)

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 49273 of file duktape-1.5.2/src/duktape.c.

49275 {
49276 ;
49277 }
49278
49279 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx);
49280 DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val); /* side effects */
49281
49282 DUK_DDD(DUK_DDDPRINT("array fast path success for index %ld", (long) idx));
49283 return 1;
49284}
49285
49286/*
49287 * Fast path for bufferobject getprop/putprop
49288 */
49289
49291 duk_context *ctx;
49292 duk_uint32_t idx;
49293 duk_hbufferobject *h_bufobj;
49294 duk_uint_t byte_off;
49295 duk_small_uint_t elem_size;
49296 duk_uint8_t *data;
49297
49298 ctx = (duk_context *) thr;
49299
49300 if (!DUK_HOBJECT_IS_BUFFEROBJECT(obj)) {
49301 return 0;
49302 }
49303 h_bufobj = (duk_hbufferobject *) obj;
49304
49305#if defined(DUK_USE_FASTINT)
49306 if (DUK_TVAL_IS_FASTINT(tv_key)) {
49307 idx = duk__tval_fastint_to_arr_idx(tv_key);
49308 } else
49309#endif
49310 if (DUK_TVAL_IS_DOUBLE(tv_key)) {
49311 idx = duk__tval_number_to_arr_idx(tv_key);
49312 } else {
49313 return 0;
49314 }
49315
49316 /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
49317 * is 0xffffffffUL. We don't need to check for that explicitly
49318 * because 0xffffffffUL will never be inside bufferobject length.
49319 */
49320
49321 /* Careful with wrapping (left shifting idx would be unsafe). */
49322 if (idx >= (h_bufobj->length >> h_bufobj->shift)) {
DUK_LOCAL duk_bool_t duk__getprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key)
#define DUK_TVAL_SET_TVAL_UPDREF
DUK_LOCAL duk_uint32_t duk__tval_number_to_arr_idx(duk_tval *tv)

◆ 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 49145 of file duktape-1.5.2/src/duktape.c.

49148 :
49149 * - Object has array part, index is within array allocation, and
49150 * value is not unused (= key exists)
49151 * - Object has no interfering exotic behavior (e.g. arguments or
49152 * string object exotic behaviors interfere, array exotic
49153 * behavior does not).
49154 *
49155 * Current shortcoming: if key does not exist (even if it is within
49156 * the array allocation range) a slow path lookup with interning is
49157 * always required. This can probably be fixed so that there is a
49158 * quick fast path for non-existent elements as well, at least for
49159 * standard Array objects.
49160 */
49161
49163 duk_tval *tv;
49164 duk_uint32_t idx;
49165
49166 DUK_UNREF(thr);
49167
49168 if (!(DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
49173 /* Must have array part and no conflicting exotic behaviors.
49174 * Doesn't need to have array special behavior, e.g. Arguments
49175 * object has array part.
49176 */
49177 return NULL;
49178 }
49179
49180 /* Arrays never have other exotic behaviors. */
49181
49182 DUK_DDD(DUK_DDDPRINT("fast path attempt (no exotic string/arguments/buffer "
49183 "behavior, object has array part)"));
49184
49185#if defined(DUK_USE_FASTINT)
49186 if (DUK_TVAL_IS_FASTINT(tv_key)) {
49187 idx = duk__tval_fastint_to_arr_idx(tv_key);
49188 } else
49189#endif
49190 if (DUK_TVAL_IS_DOUBLE(tv_key)) {
49191 idx = duk__tval_number_to_arr_idx(tv_key);
49192 } else {
49193 DUK_DDD(DUK_DDDPRINT("key is not a number"));
49194 return NULL;
49195 }
49196
49197 /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
49198 * is 0xffffffffUL. We don't need to check for that explicitly
49199 * because 0xffffffffUL will never be inside object 'a_size'.
49200 */
49201
49202 if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
49203 DUK_DDD(DUK_DDDPRINT("key is not an array index or outside array part"));
49204 return NULL;
49205 }
union @139 unused
DUK_LOCAL duk_tval * duk__getprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key)

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 21629 of file duktape-1.5.2/src/duktape.c.

21646 {
21647 duk_hthread *thr;
21648 duk_tval *tv;
21649 duk_hbufferobject *h_this;
21650
21651 DUK_ASSERT(ctx != NULL);
21652 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 72420 of file duktape-1.5.2/src/duktape.c.

72422 : [val this].
72423 *
72424 * If 'throw' is false, returns 0 if identifier cannot be resolved, and the
72425 * stack will be unaffected in this case. If identifier is resolved, returns
72426 * 1 and leaves [val this] on top of stack.
72427 *
72428 * Note: the 'strict' flag of a reference returned by GetIdentifierReference
72429 * is ignored by GetValue. Hence we don't take a 'strict' parameter.
72430 *
72431 * The 'throw' flag is needed for implementing 'typeof' for an unreferenced
72432 * identifier. An unreference identifier in other contexts generates a
72433 * ReferenceError.
72434 */
72435
72436DUK_LOCAL
72437duk_bool_t duk__getvar_helper(duk_hthread *thr,
72438 duk_hobject *env,
72439 duk_activation *act,
72440 duk_hstring *name,
72441 duk_bool_t throw_flag) {
72442 duk_context *ctx = (duk_context *) thr;
72443 duk__id_lookup_result ref;
72444 duk_tval tv_tmp_obj;
72445 duk_tval tv_tmp_key;
72446 duk_bool_t parents;
72447
72448 DUK_DDD(DUK_DDDPRINT("getvar: thr=%p, env=%p, act=%p, name=%!O "
72449 "(env -> %!dO)",
72450 (void *) thr, (void *) env, (void *) act,
72451 (duk_heaphdr *) name, (duk_heaphdr *) env));
72452
72453 DUK_ASSERT(thr != NULL);
72454 DUK_ASSERT(name != NULL);
72455 /* env and act may be NULL */
72456
72457 DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env);
72458 DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
72459
72460 parents = 1; /* follow parent chain */
72461 if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
72462 if (ref.value) {
72463 DUK_ASSERT(ref.this_binding == NULL); /* always for register bindings */
72464 duk_push_tval(ctx, ref.value);
72465 duk_push_undefined(ctx);
72466 } else {
72467 DUK_ASSERT(ref.holder != NULL);
72468
72469 /* Note: getprop may invoke any getter and invalidate any
72470 * duk_tval pointers, so this must be done first.
72471 */
72472
72473 if (ref.this_binding) {
72474 duk_push_tval(ctx, ref.this_binding);
72475 } else {
72476 duk_push_undefined(ctx);
72477 }
72478
72479 DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder);
72480 DUK_TVAL_SET_STRING(&tv_tmp_key, name);
72481 (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 48145 of file duktape-1.5.2/src/duktape.c.

48162 {

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 48115 of file duktape-1.5.2/src/duktape.c.

48132 {
48133 duk_uint32_t old_e_used; /* actually used, non-NULL entries */
48134 duk_uint32_t new_e_size;
48135 duk_uint32_t new_a_size;
48136 duk_uint32_t new_h_size;
48137
48138 DUK_ASSERT(thr != NULL);
48139 DUK_ASSERT(obj != NULL);
48140
48141 /* Duktape 0.11.0 and prior tried to optimize the resize by not
48142 * 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 55142 of file duktape-1.5.2/src/duktape.c.

55162 {
55163 duk_context *ctx = (duk_context *) thr;
55164 duk_idx_t num_stack_args;
55165 duk_tval *tv_func;
55166 duk_hobject *func;
55167 duk_uint_t sanity;
55168
55169 DUK_ASSERT(thr != NULL);
55170 DUK_ASSERT(p_num_stack_args != NULL);
55171
55172 /* On entry, item at idx_func is a bound, non-lightweight function,
55173 * but we don't rely on that below.
55174 */
55175
55176 num_stack_args = *p_num_stack_args;
55177
55179 do {
55180 duk_idx_t i, len;
55181
55182 tv_func = duk_require_tval(ctx, idx_func);
55183 DUK_ASSERT(tv_func != NULL);
55184
55185 if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
55186 /* Lightweight function: never bound, so terminate. */
55187 break;
55188 } else if (DUK_TVAL_IS_OBJECT(tv_func)) {
55189 func = DUK_TVAL_GET_OBJECT(tv_func);
55190 if (!DUK_HOBJECT_HAS_BOUND(func)) {
55191 /* Normal non-bound function. */
55192 break;
55193 }
55194 } else {
55195 /* Function.prototype.bind() should never let this happen,
55196 * ugly error message is enough.
55197 */
55199 }
55200 DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv_func) != NULL);
55201
55202 /* XXX: this could be more compact by accessing the internal properties
55203 * directly as own properties (they cannot be inherited, and are not
55204 * externally visible).
55205 */
55206
55207 DUK_DDD(DUK_DDDPRINT("bound function encountered, ptr=%p, num_stack_args=%ld: %!T",
55208 (void *) DUK_TVAL_GET_OBJECT(tv_func), (long) num_stack_args, tv_func));
55209
55210 /* [ ... func this arg1 ... argN ] */
55211
55212 if (is_constructor_call) {
55213 /* See: tests/ecmascript/test-spec-bound-constructor.js */
55214 DUK_DDD(DUK_DDDPRINT("constructor call: don't update this binding"));
55215 } else {
55217 duk_replace(ctx, idx_func + 1); /* idx_this = idx_func + 1 */
55218 }
55219
55220 /* [ ... func this arg1 ... argN ] */
55221
55222 /* XXX: duk_get_length? */
55223 duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_ARGS); /* -> [ ... func this arg1 ... argN _Args ] */
55224 duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH); /* -> [ ... func this arg1 ... argN _Args length ] */
55225 len = (duk_idx_t) duk_require_int(ctx, -1);
55226 duk_pop(ctx);
55227 for (i = 0; i < len; i++) {
55228 /* XXX: very slow - better to bulk allocate a gap, and copy
55229 * from args_array directly (we know it has a compact array
55230 * part, etc).
55231 */
55232
55233 /* [ ... func this <some bound args> arg1 ... argN _Args ] */
55234 duk_get_prop_index(ctx, -1, i);
55235 duk_insert(ctx, idx_func + 2 + i); /* idx_args = idx_func + 2 */
55236 }
55237 num_stack_args += len; /* must be updated to work properly (e.g. creation of 'arguments') */
55238 duk_pop(ctx);
55239
55240 /* [ ... func this <bound args> arg1 ... argN ] */
55241
55243 duk_replace(ctx, idx_func); /* replace in stack */
55244
55245 DUK_DDD(DUK_DDDPRINT("bound function handled, num_stack_args=%ld, idx_func=%ld, curr func=%!T",
55246 (long) num_stack_args, (long) idx_func, duk_get_tval(ctx, idx_func)));
55247 } while (--sanity > 0);
55248
55249 if (sanity == 0) {
55251 }
55252
#define DUK_STRIDX_INT_ARGS
#define DUK_STRIDX_INT_THIS
#define DUK_HOBJECT_HAS_BOUND(h)
#define DUK_TVAL_IS_LIGHTFUNC(tv)
#define DUK_STRIDX_INT_TARGET
#define DUK_HOBJECT_BOUND_CHAIN_SANITY
DUK_INTERNAL_DECL duk_tval * duk_require_tval(duk_context *ctx, duk_idx_t index)
#define 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 66552 of file duktape-1.5.2/src/duktape.c.

66552 :
66553 return retval;
66554
66555 convert_to_internal_error:
66556 /* This could also be thrown internally (set the error, goto check_longjmp),
66557 * but it's better for internal errors to bubble outwards so that we won't
66558 * infinite loop in this catchpoint.
66559 */
66562 return retval;
66563}
66564
66565/* Handle a BREAK/CONTINUE opcode. Avoid using longjmp() for BREAK/CONTINUE
66566 * handling because it has a measurable performance impact in ordinary
66567 * environments and an extreme impact in Emscripten (GH-342).
66568 */
66570 duk_uint_t label_id,
66571 duk_small_uint_t lj_type) {
66572 duk_catcher *cat;
66573 duk_size_t orig_callstack_index;
66574
66575 DUK_ASSERT(thr != NULL);
66576
66577 /*
66578 * Find a matching label catcher or 'finally' catcher in
66579 * the same function.
66580 *
66581 * A label catcher must always exist and will match unless
66582 * a 'finally' captures the break/continue first. It is the
66583 * compiler's responsibility to ensure that labels are used
66584 * correctly.
66585 */
66586
66587 /* Note: thr->catchstack_top may be 0, so that cat < thr->catchstack
66588 * initially. This is OK and intended.
66589 */
66590 cat = thr->catchstack + thr->catchstack_top - 1;
66591 DUK_ASSERT(thr->callstack_top > 0);
66592 orig_callstack_index = thr->callstack_top - 1;
66593
66594 DUK_DDD(DUK_DDDPRINT("handling break/continue with label=%ld, callstack index=%ld",
66595 (long) label_id, (long) cat->callstack_index));
66596
66597 while (cat >= thr->catchstack) {
66598 if (cat->callstack_index != orig_callstack_index) {
66599 break;
66600 }
66601 DUK_DDD(DUK_DDDPRINT("considering catcher %ld: type=%ld label=%ld",
66602 (long) (cat - thr->catchstack),
66603 (long) DUK_CAT_GET_TYPE(cat),
66604 (long) DUK_CAT_GET_LABEL(cat)));
66605
66606 if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF &&
66608 duk_size_t cat_idx;
66609 duk_tval tv_tmp;
66610
66611 cat_idx = (duk_size_t) (cat - thr->catchstack); /* get before side effects */
66612
66613 DUK_TVAL_SET_FASTINT_U32(&tv_tmp, (duk_uint32_t) label_id);
66614 duk__handle_finally(thr, cat_idx, &tv_tmp, lj_type);
66615
66616 DUK_DD(DUK_DDPRINT("-> break/continue caught by 'finally', restart execution"));
66617 return;
66618 }
#define DUK_TVAL_SET_FASTINT_U32(tv, val)
#define DUK_CAT_GET_TYPE(c)
#define DUK_CAT_HAS_FINALLY_ENABLED(c)
#define DUK_CAT_GET_LABEL(c)
#define DUK_CAT_TYPE_TCF
#define DUK_CAT_TYPE_LABEL
DUK_LOCAL void duk__handle_break_or_continue(duk_hthread *thr, duk_uint_t label_id, 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__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 56469 of file duktape-1.5.2/src/duktape.c.

56480 :
56481 DUK_ERROR_FMT1(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for call (%ld)", (long) thr->state);
56483 return; /* never executed */
56484}
56485
56487 duk_size_t entry_valstack_bottom_index,
56488 duk_size_t entry_valstack_end,
56489 duk_size_t entry_catchstack_top,
56490 duk_size_t entry_callstack_top,
56491 duk_int_t entry_call_recursion_depth,
56492 duk_hthread *entry_curr_thread,
56493 duk_uint_fast8_t entry_thread_state,
56494 duk_instr_t **entry_ptr_curr_pc,
56495 duk_idx_t idx_func,
56496 duk_jmpbuf *old_jmpbuf_ptr) {
56497 duk_context *ctx;
56498 duk_tval *tv_ret;
56499
56500 ctx = (duk_context *) thr;
56501
56502 DUK_DDD(DUK_DDDPRINT("error caught during duk__handle_call_inner(): %!T",
56503 (duk_tval *) &thr->heap->lj.value1));
56504
56505 /* Other longjmp types are handled by executor before propagating
56506 * the error here.
56507 */
56509 DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
56510 DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
56511
56512 /* We don't need to sync back thr->ptr_curr_pc here because
56513 * the bytecode executor always has a setjmp catchpoint which
56514 * does that before errors propagate to here.
56515 */
56516 DUK_ASSERT(thr->ptr_curr_pc == NULL);
56517
56518 /* Restore the previous setjmp catcher so that any error in
56519 * error handling will propagate outwards rather than re-enter
56520 * the same handler. However, the error handling path must be
56521 * designed to be error free so that sandboxing guarantees are
56522 * reliable, see e.g. https://github.com/svaarala/duktape/issues/476.
56523 */
56524 thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
56525
56526 /* XXX: callstack unwind may now throw an error when closing
56527 * scopes; this is a sandboxing issue, described in:
56528 * https://github.com/svaarala/duktape/issues/476
56529 */
56530 duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
56532 duk_hthread_callstack_unwind(thr, entry_callstack_top);
56534
56535 thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
56536 tv_ret = thr->valstack_bottom + idx_func; /* XXX: byte offset? */
56537 DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, &thr->heap->lj.value1); /* side effects */
56538#if defined(DUK_USE_FASTINT)
56539 /* Explicit check for fastint downgrade. */
56541#endif
56542 duk_set_top(ctx, idx_func + 1); /* XXX: could be eliminated with valstack adjust */
56543
56544 /* [ ... errobj ] */
56545
56546 /* Ensure there is internal valstack spare before we exit; this may
56547 * throw an alloc error. The same guaranteed size must be available
56548 * as before the call. This is not optimal now: we store the valstack
56549 * allocated size during entry; this value may be higher than the
56550 * minimal guarantee for an application.
56551 */
56552
56553 /* XXX: this needs to be reworked so that we never shrink the value
56554 * stack on function entry so that we never need to grow it here.
56555 * Needing to grow here is a sandboxing issue because we need to
56556 * allocate which may cause an error in the error handling path
56557 * and thus propagate an error out of a protected call.
56558 */
56559
56560 (void) duk_valstack_resize_raw((duk_context *) thr,
56561 entry_valstack_end, /* same as during entry */
56562 DUK_VSRESIZE_FLAG_SHRINK | /* flags */
56565
56566
56567 /* These are just convenience "wiping" of state. Side effects should
56568 * not be an issue here: thr->heap and thr->heap->lj have a stable
56569 * pointer. Finalizer runs etc capture even out-of-memory errors so
56570 * nothing should throw here.
56571 */
56573 thr->heap->lj.iserror = 0;
56574 DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value1); /* side effects */
56575 DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value2); /* side effects */
56576
56577 /* Restore entry thread executor curr_pc stack frame pointer. */
56578 thr->ptr_curr_pc = entry_ptr_curr_pc;
56579
56580 DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */
56581 thr->state = (duk_uint8_t) entry_thread_state;
56582
56583 DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */
56584 (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */
56585 (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */
56586
56587 thr->heap->call_recursion_depth = entry_call_recursion_depth;
56588
56589 /* If the debugger is active we need to force an interrupt so that
56590 * debugger breakpoints are rechecked. This is important for function
56591 * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see
56592 * GH-303. Only needed for success path, error path always causes a
56593 * breakpoint recheck in the executor. It would be enough to set this
#define DUK_LJ_TYPE_THROW
DUK_INTERNAL_DECL duk_bool_t duk_valstack_resize_raw(duk_context *ctx, duk_size_t min_new_size, duk_small_uint_t flags)
#define DUK_VSRESIZE_FLAG_THROW
DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top)
#define DUK_VSRESIZE_FLAG_SHRINK
#define DUK_HTHREAD_STATE_INACTIVE
#define DUK_LJ_TYPE_UNKNOWN
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)
#define DUK_VSRESIZE_FLAG_COMPACT
DUK_INTERNAL_DECL void duk_hthread_callstack_shrink_check(duk_hthread *thr)
#define DUK_HTHREAD_STATE_RUNNING
DUK_INTERNAL_DECL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top)
DUK_INTERNAL_DECL void duk_hthread_catchstack_shrink_check(duk_hthread *thr)
#define DUK_HEAP_SWITCH_THREAD(heap, newthr)

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 55894 of file duktape-1.5.2/src/duktape.c.

55902 {
55903 duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
55904
55905 /* Argument validation and func/args offset. */
55906 idx_func = duk__get_idx_func(thr, num_stack_args);
55907
55908 duk__handle_call_inner(thr, num_stack_args, call_flags, idx_func);
55909}
55910
55912 duk_idx_t num_stack_args,
55913 duk_small_uint_t call_flags,
55914 duk_idx_t idx_func) {
55915 duk_context *ctx;
55916 duk_size_t entry_valstack_bottom_index;
55917 duk_size_t entry_valstack_end;
55918 duk_size_t entry_callstack_top;
55919 duk_size_t entry_catchstack_top;
55920 duk_int_t entry_call_recursion_depth;
55921 duk_hthread *entry_curr_thread;
55922 duk_uint_fast8_t entry_thread_state;
55923 duk_instr_t **entry_ptr_curr_pc;
55924 duk_idx_t nargs; /* # argument registers target function wants (< 0 => "as is") */
55925 duk_idx_t nregs; /* # total registers target function wants on entry (< 0 => "as is") */
55926 duk_hobject *func; /* 'func' on stack (borrowed reference) */
55927 duk_tval *tv_func; /* duk_tval ptr for 'func' on stack (borrowed reference) or tv_func_copy */
55928 duk_tval tv_func_copy; /* to avoid relookups */
55929 duk_activation *act;
55930 duk_hobject *env;
55931 duk_ret_t rc;
55932
55933 ctx = (duk_context *) thr;
55934 DUK_ASSERT(thr != NULL);
55936 DUK_ASSERT(ctx != NULL);
55937 DUK_ASSERT(num_stack_args >= 0);
55938 /* XXX: currently NULL allocations are not supported; remove if later allowed */
55939 DUK_ASSERT(thr->valstack != NULL);
55940 DUK_ASSERT(thr->callstack != NULL);
55941 DUK_ASSERT(thr->catchstack != NULL);
55942
55943 DUK_DD(DUK_DDPRINT("duk__handle_call_inner: num_stack_args=%ld, call_flags=0x%08lx, top=%ld",
55944 (long) num_stack_args, (long) call_flags, (long) duk_get_top(ctx)));
55945
55946 /*
55947 * Store entry state.
55948 */
55949
55950 entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
55951#if defined(DUK_USE_PREFER_SIZE)
55952 entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack);
55953#else
55954 DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
55955 entry_valstack_end = thr->valstack_size;
55956#endif
55957 entry_callstack_top = thr->callstack_top;
55958 entry_catchstack_top = thr->catchstack_top;
55959 entry_call_recursion_depth = thr->heap->call_recursion_depth;
55960 entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */
55961 entry_thread_state = thr->state;
55962 entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */
55963
55964 /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc. Then NULL
55965 * thr->ptr_curr_pc so that it's not accidentally used with an incorrect
55966 * activation when side effects occur.
55967 */
55969
55970 DUK_DD(DUK_DDPRINT("duk__handle_call_inner: thr=%p, num_stack_args=%ld, "
55971 "call_flags=0x%08lx (ignorerec=%ld, constructor=%ld), "
55972 "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, "
55973 "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
55974 "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
55975 (void *) thr,
55976 (long) num_stack_args,
55977 (unsigned long) call_flags,
55978 (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0),
55979 (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0),
55980 (long) duk_get_top(ctx),
55981 (long) idx_func,
55982 (long) (idx_func + 2),
55983 (long) thr->heap->call_recursion_depth,
55984 (long) thr->heap->call_recursion_limit,
55985 (long) entry_valstack_bottom_index,
55986 (long) entry_callstack_top,
55987 (long) entry_catchstack_top,
55988 (long) entry_call_recursion_depth,
55989 (void *) entry_curr_thread,
55990 (long) entry_thread_state));
55991
55992
55993 /*
55994 * Thread state check and book-keeping.
55995 */
55996
55997 if (thr == thr->heap->curr_thread) {
55998 /* same thread */
55999 if (thr->state != DUK_HTHREAD_STATE_RUNNING) {
56000 /* should actually never happen, but check anyway */
56001 goto thread_state_error;
56002 }
56003 } else {
56004 /* different thread */
56005 DUK_ASSERT(thr->heap->curr_thread == NULL ||
56006 thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING);
56007 if (thr->state != DUK_HTHREAD_STATE_INACTIVE) {
56008 goto thread_state_error;
56009 }
56010 DUK_HEAP_SWITCH_THREAD(thr->heap, thr);
56011 thr->state = DUK_HTHREAD_STATE_RUNNING;
56012
56013 /* Note: multiple threads may be simultaneously in the RUNNING
56014 * state, but not in the same "resume chain".
56015 */
56016 }
56017 DUK_ASSERT(thr->heap->curr_thread == thr);
56019
56020 /*
56021 * C call recursion depth check, which provides a reasonable upper
56022 * bound on maximum C stack size (arbitrary C stack growth is only
56023 * possible by recursive handle_call / handle_safe_call calls).
56024 */
56025
56026 /* XXX: remove DUK_CALL_FLAG_IGNORE_RECLIMIT flag: there's now the
56027 * reclimit bump?
56028 */
56029
56030 DUK_ASSERT(thr->heap->call_recursion_depth >= 0);
56031 DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit);
56032 if (call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) {
56033 DUK_DD(DUK_DDPRINT("ignoring reclimit for this call (probably an errhandler call)"));
56034 } else {
56035 if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) {
56036 /* XXX: error message is a bit misleading: we reached a recursion
56037 * limit which is also essentially the same as a C callstack limit
56038 * (except perhaps with some relaxed threading assumptions).
56039 */
56041 }
56042 thr->heap->call_recursion_depth++;
56043 }
56044
56045 /*
56046 * Check the function type, handle bound function chains, and prepare
56047 * parameters for the rest of the call handling. Also figure out the
56048 * effective 'this' binding, which replaces the current value at
56049 * idx_func + 1.
56050 *
56051 * If the target function is a 'bound' one, follow the chain of 'bound'
56052 * functions until a non-bound function is found. During this process,
56053 * bound arguments are 'prepended' to existing ones, and the "this"
56054 * binding is overridden. See E5 Section 15.3.4.5.1.
56055 *
56056 * Lightfunc detection happens here too. Note that lightweight functions
56057 * can be wrapped by (non-lightweight) bound functions so we must resolve
56058 * the bound function chain first.
56059 */
56060
56061 func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags);
56062 DUK_TVAL_SET_TVAL(&tv_func_copy, tv_func);
56063 tv_func = &tv_func_copy; /* local copy to avoid relookups */
56064
56065 DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
56068
56069 duk__coerce_effective_this_binding(thr, func, idx_func + 1);
56070 DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T",
56071 (duk_tval *) duk_get_tval(ctx, idx_func + 1)));
56072
56073 /* [ ... func this arg1 ... argN ] */
56074
56075 /*
56076 * Setup a preliminary activation and figure out nargs/nregs.
56077 *
56078 * Don't touch valstack_bottom or valstack_top yet so that Duktape API
56079 * calls work normally.
56080 */
56081
56083
56084 if (thr->callstack_top > 0) {
56085 /*
56086 * Update idx_retval of current activation.
56087 *
56088 * Although it might seem this is not necessary (bytecode executor
56089 * does this for Ecmascript-to-Ecmascript calls; other calls are
56090 * handled here), this turns out to be necessary for handling yield
56091 * and resume. For them, an Ecmascript-to-native call happens, and
56092 * the Ecmascript call's idx_retval must be set for things to work.
56093 */
56094
56095 (thr->callstack + thr->callstack_top - 1)->idx_retval = entry_valstack_bottom_index + idx_func;
56096 }
56097
56098 DUK_ASSERT(thr->callstack_top < thr->callstack_size);
56099 act = thr->callstack + thr->callstack_top;
56100 thr->callstack_top++;
56101 DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
56102 DUK_ASSERT(thr->valstack_top > thr->valstack_bottom); /* at least effective 'this' */
56103 DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
56104
56105 act->flags = 0;
56106
56107 /* For now all calls except Ecma-to-Ecma calls prevent a yield. */
56109 if (call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) {
56111 }
56112 if (call_flags & DUK_CALL_FLAG_DIRECT_EVAL) {
56114 }
56115
56116 /* These base values are never used, but if the compiler doesn't know
56117 * that DUK_ERROR() won't return, these are needed to silence warnings.
56118 * On the other hand, scan-build will warn about the values not being
56119 * used, so add a DUK_UNREF.
56120 */
56121 nargs = 0; DUK_UNREF(nargs);
56122 nregs = 0; DUK_UNREF(nregs);
56123
56124 if (DUK_LIKELY(func != NULL)) {
56125 if (DUK_HOBJECT_HAS_STRICT(func)) {
56126 act->flags |= DUK_ACT_FLAG_STRICT;
56127 }
56129 nargs = ((duk_hcompiledfunction *) func)->nargs;
56130 nregs = ((duk_hcompiledfunction *) func)->nregs;
56131 DUK_ASSERT(nregs >= nargs);
56132 } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
56133 /* Note: nargs (and nregs) may be negative for a native,
56134 * function, which indicates that the function wants the
56135 * input stack "as is" (i.e. handles "vararg" arguments).
56136 */
56137 nargs = ((duk_hnativefunction *) func)->nargs;
56138 nregs = nargs;
56139 } else {
56140 /* XXX: this should be an assert */
56142 }
56143 } else {
56144 duk_small_uint_t lf_flags;
56145
56147 lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_func);
56148 nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
56149 if (nargs == DUK_LFUNC_NARGS_VARARGS) {
56150 nargs = -1; /* vararg */
56151 }
56152 nregs = nargs;
56153
56154 act->flags |= DUK_ACT_FLAG_STRICT;
56155 }
56156
56157 act->func = func; /* NULL for lightfunc */
56158 act->var_env = NULL;
56159 act->lex_env = NULL;
56160#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
56161 act->prev_caller = NULL;
56162#endif
56163 act->curr_pc = NULL;
56164#if defined(DUK_USE_DEBUGGER_SUPPORT)
56165 act->prev_line = 0;
56166#endif
56167 act->idx_bottom = entry_valstack_bottom_index + idx_func + 2;
56168#if 0 /* topmost activation idx_retval is considered garbage, no need to init */
56169 act->idx_retval = 0;
56170#endif
56171 DUK_TVAL_SET_TVAL(&act->tv_func, tv_func); /* borrowed, no refcount */
56172
56173 /* XXX: remove the preventcount and make yield walk the callstack?
56174 * Or perhaps just use a single flag, not a counter, faster to just
56175 * set and restore?
56176 */
56177 if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
56178 /* duk_hthread_callstack_unwind() will decrease this on unwind */
56179 thr->callstack_preventcount++;
56180 }
56181
56182 /* XXX: Is this INCREF necessary? 'func' is always a borrowed
56183 * reference reachable through the value stack? If changed, stack
56184 * unwind code also needs to be fixed to match.
56185 */
56186 DUK_HOBJECT_INCREF_ALLOWNULL(thr, func); /* act->func */
56187
56188#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
56189 if (func) {
56190 duk__update_func_caller_prop(thr, func);
56191 }
56192 act = thr->callstack + thr->callstack_top - 1;
56193#endif
56194
56195 /* [ ... func this arg1 ... argN ] */
56196
56197 /*
56198 * Environment record creation and 'arguments' object creation.
56199 * Named function expression name binding is handled by the
56200 * compiler; the compiled function's parent env will contain
56201 * the (immutable) binding already.
56202 *
56203 * This handling is now identical for C and Ecmascript functions.
56204 * C functions always have the 'NEWENV' flag set, so their
56205 * environment record initialization is delayed (which is good).
56206 *
56207 * Delayed creation (on demand) is handled in duk_js_var.c.
56208 */
56209
56210 DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */
56211
56212 if (DUK_LIKELY(func != NULL)) {
56215 /* Use a new environment but there's no 'arguments' object;
56216 * delayed environment initialization. This is the most
56217 * common case.
56218 */
56219 DUK_ASSERT(act->lex_env == NULL);
56220 DUK_ASSERT(act->var_env == NULL);
56221 } else {
56222 /* Use a new environment and there's an 'arguments' object.
56223 * We need to initialize it right now.
56224 */
56225
56226 /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */
56228 DUK_ASSERT(env != NULL);
56229
56230 /* [ ... func this arg1 ... argN envobj ] */
56231
56233 duk__handle_createargs_for_call(thr, func, env, num_stack_args);
56234
56235 /* [ ... func this arg1 ... argN envobj ] */
56236
56237 act = thr->callstack + thr->callstack_top - 1;
56238 act->lex_env = env;
56239 act->var_env = env;
56240 DUK_HOBJECT_INCREF(thr, env);
56241 DUK_HOBJECT_INCREF(thr, env); /* XXX: incref by count (2) directly */
56242 duk_pop(ctx);
56243 }
56244 } else {
56245 /* Use existing env (e.g. for non-strict eval); cannot have
56246 * an own 'arguments' object (but can refer to an existing one).
56247 */
56248
56250
56251 duk__handle_oldenv_for_call(thr, func, act);
56252
56253 DUK_ASSERT(act->lex_env != NULL);
56254 DUK_ASSERT(act->var_env != NULL);
56255 }
56256 } else {
56257 /* Lightfuncs are always native functions and have "newenv". */
56258 DUK_ASSERT(act->lex_env == NULL);
56259 DUK_ASSERT(act->var_env == NULL);
56260 }
56261
56262 /* [ ... func this arg1 ... argN ] */
56263
56264 /*
56265 * Setup value stack: clamp to 'nargs', fill up to 'nregs'
56266 *
56267 * Value stack may either grow or shrink, depending on the
56268 * number of func registers and the number of actual arguments.
56269 * If nregs >= 0, func wants args clamped to 'nargs'; else it
56270 * wants all args (= 'num_stack_args').
56271 */
56272
56273 /* XXX: optimize value stack operation */
56274 /* XXX: don't want to shrink allocation here */
56275
56277 num_stack_args,
56278 idx_func + 2,
56279 nregs,
56280 nargs,
56281 func);
56282
56283 /*
56284 * Determine call type, then finalize activation, shift to
56285 * new value stack bottom, and call the target.
56286 */
56287
56288 if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
56289 /*
56290 * Ecmascript call
56291 */
56292
56293 duk_tval *tv_ret;
56294 duk_tval *tv_funret;
56295
56296 DUK_ASSERT(func != NULL);
56299
56300 thr->valstack_bottom = thr->valstack_bottom + idx_func + 2;
56301 /* keep current valstack_top */
56302 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
56303 DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
56304 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
56305
56306 /* [ ... func this | arg1 ... argN ] ('this' must precede new bottom) */
56307
56308 /*
56309 * Bytecode executor call.
56310 *
56311 * Execute bytecode, handling any recursive function calls and
56312 * thread resumptions. Returns when execution would return from
56313 * the entry level activation. When the executor returns, a
56314 * single return value is left on the stack top.
56315 *
56316 * The only possible longjmp() is an error (DUK_LJ_TYPE_THROW),
56317 * other types are handled internally by the executor.
56318 */
56319
56320 /* thr->ptr_curr_pc is set by bytecode executor early on entry */
56321 DUK_ASSERT(thr->ptr_curr_pc == NULL);
56322 DUK_DDD(DUK_DDDPRINT("entering bytecode execution"));
56324 DUK_DDD(DUK_DDDPRINT("returned from bytecode execution"));
56325
56326 /* Unwind. */
56327
56328 DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); /* may need unwind */
56329 DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
56330 DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
56331 duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
56333 duk_hthread_callstack_unwind(thr, entry_callstack_top);
56335
56336 thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
56337 /* keep current valstack_top */
56338 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
56339 DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
56340 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
56341 DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1);
56342
56343 /* Return value handling. */
56344
56345 /* [ ... func this (crud) retval ] */
56346
56347 tv_ret = thr->valstack_bottom + idx_func;
56348 tv_funret = thr->valstack_top - 1;
56349#if defined(DUK_USE_FASTINT)
56350 /* Explicit check for fastint downgrade. */
56351 DUK_TVAL_CHKFAST_INPLACE(tv_funret);
56352#endif
56353 DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, tv_funret); /* side effects */
56354 } else {
56355 /*
56356 * Native call.
56357 */
56358
56359 duk_tval *tv_ret;
56360 duk_tval *tv_funret;
56361
56362 thr->valstack_bottom = thr->valstack_bottom + idx_func + 2;
56363 /* keep current valstack_top */
56364 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
56365 DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
56366 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
56367 DUK_ASSERT(func == NULL || ((duk_hnativefunction *) func)->func != NULL);
56368
56369 /* [ ... func this | arg1 ... argN ] ('this' must precede new bottom) */
56370
56371 /* For native calls must be NULL so we don't sync back */
56372 DUK_ASSERT(thr->ptr_curr_pc == NULL);
56373
56374 if (func) {
56375 rc = ((duk_hnativefunction *) func)->func((duk_context *) thr);
56376 } else {
56378 rc = funcptr((duk_context *) thr);
56379 }
56380
56381 /* Automatic error throwing, retval check. */
56382
56383 if (rc < 0) {
56386 } else if (rc > 1) {
56387 DUK_ERROR_API(thr, "c function returned invalid rc");
56388 }
56389 DUK_ASSERT(rc == 0 || rc == 1);
56390
56391 /* Unwind. */
56392
56393 DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); /* no need to unwind */
56394 DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
56395 duk_hthread_callstack_unwind(thr, entry_callstack_top);
56397
56398 thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
56399 /* keep current valstack_top */
56400 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
56401 DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
56402 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
56403 DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1);
56404
56405 /* Return value handling. */
56406
56407 /* XXX: should this happen in the callee's activation or after unwinding? */
56408 tv_ret = thr->valstack_bottom + idx_func;
56409 if (rc == 0) {
56410 DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv_ret); /* side effects */
56411 } else {
56412 /* [ ... func this (crud) retval ] */
56413 tv_funret = thr->valstack_top - 1;
56414#if defined(DUK_USE_FASTINT)
56415 /* Explicit check for fastint downgrade. */
56416 DUK_TVAL_CHKFAST_INPLACE(tv_funret);
56417#endif
56418 DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, tv_funret); /* side effects */
56419 }
56420 }
56421
56422 duk_set_top(ctx, idx_func + 1); /* XXX: unnecessary, handle in adjust */
56423
56424 /* [ ... retval ] */
56425
56426 /* Ensure there is internal valstack spare before we exit; this may
56427 * throw an alloc error. The same guaranteed size must be available
56428 * as before the call. This is not optimal now: we store the valstack
56429 * allocated size during entry; this value may be higher than the
56430 * minimal guarantee for an application.
56431 */
56432
56433 /* XXX: we should never shrink here; when we error out later, we'd
56434 * need to potentially grow the value stack in error unwind which could
56435 * cause another error.
56436 */
56437
56438 (void) duk_valstack_resize_raw((duk_context *) thr,
56439 entry_valstack_end, /* same as during entry */
56440 DUK_VSRESIZE_FLAG_SHRINK | /* flags */
56443
56444 /* Restore entry thread executor curr_pc stack frame pointer. */
56445 thr->ptr_curr_pc = entry_ptr_curr_pc;
56446
56447 DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */
56448 thr->state = (duk_uint8_t) entry_thread_state;
56449
56450 DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */
56451 (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */
56452 (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */
56453
56454 thr->heap->call_recursion_depth = entry_call_recursion_depth;
56455
56456 /* If the debugger is active we need to force an interrupt so that
56457 * debugger breakpoints are rechecked. This is important for function
56458 * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see
56459 * GH-303. Only needed for success path, error path always causes a
56460 * breakpoint recheck in the executor. It would be enough to set this
56461 * only when returning to an Ecmascript activation, but setting the flag
56462 * on every return should have no ill effect.
56463 */
56464#if defined(DUK_USE_DEBUGGER_SUPPORT)
56465 if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
56466 DUK_DD(DUK_DDPRINT("returning with debugger enabled, force interrupt"));
56467 DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init);
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_INTERNAL_DECL void duk_hthread_sync_and_null_currpc(duk_hthread *thr)
#define DUK_CALL_FLAG_CONSTRUCTOR_CALL
DUK_LOCAL void duk__handle_oldenv_for_call(duk_hthread *thr, duk_hobject *func, duk_activation *act)
#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv)
#define DUK_HOBJECT_HAS_CREATEARGS(h)
DUK_INTERNAL_DECL void duk_hthread_callstack_grow(duk_hthread *thr)
#define DUK_LFUNC_NARGS_VARARGS
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_INTERNAL_DECL void duk_js_execute_bytecode(duk_hthread *exec_thr)
DUK_INTERNAL_DECL duk_hobject * duk_create_activation_environment_record(duk_hthread *thr, duk_hobject *func, duk_size_t idx_bottom)
DUK_LOCAL void duk__handle_createargs_for_call(duk_hthread *thr, duk_hobject *func, duk_hobject *env, duk_idx_t num_stack_args)
#define DUK_STR_C_CALLSTACK_LIMIT
DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc)
#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags)
#define DUK_CALL_FLAG_DIRECT_EVAL
#define DUK_HOBJECT_INCREF_ALLOWNULL(thr, h)
#define DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)
#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)
#define DUK_CALL_FLAG_IGNORE_RECLIMIT

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 65990 of file duktape-1.5.2/src/duktape.c.

65991 {
65992 duk_tval *tv1;
65993
65994 DUK_ASSERT(thr != NULL);
65995 DUK_ASSERT(tv_val_unstable != NULL);
65996
65997 tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base;
65998 DUK_ASSERT(tv1 < thr->valstack_top);
65999 DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv_val_unstable); /* side effects */
66000
66001 tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base + 1;
66002 DUK_ASSERT(tv1 < thr->valstack_top);
66003
66004 DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) lj_type); /* side effects */
66005}
66006
66007DUK_LOCAL void duk__handle_catch(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) {
66008 duk_context *ctx;
66009 duk_activation *act;
66010
66011 DUK_ASSERT(thr != NULL);
66012 DUK_ASSERT(tv_val_unstable != NULL);
66013 ctx = (duk_context *) thr;
66014
66015 duk__set_catcher_regs(thr, cat_idx, tv_val_unstable, lj_type);
66016
66017 duk_hthread_catchstack_unwind(thr, cat_idx + 1);
66019
66020 DUK_ASSERT(thr->callstack_top >= 1);
66023
66024 duk__reconfig_valstack_ecma_catcher(thr, thr->callstack_top - 1, cat_idx);
66025
66026 DUK_ASSERT(thr->callstack_top >= 1);
66027 act = thr->callstack + thr->callstack_top - 1;
66028 act->curr_pc = thr->catchstack[cat_idx].pc_base + 0; /* +0 = catch */
66029 act = NULL;
66030
66031 /*
66032 * If entering a 'catch' block which requires an automatic
66033 * catch variable binding, create the lexical environment.
66034 *
66035 * The binding is mutable (= writable) but not deletable.
66036 * Step 4 for the catch production in E5 Section 12.14;
66037 * no value is given for CreateMutableBinding 'D' argument,
66038 * which implies the binding is not deletable.
66039 */
66040
66041 if (DUK_CAT_HAS_CATCH_BINDING_ENABLED(&thr->catchstack[cat_idx])) {
66042 duk_hobject *new_env;
66043 duk_hobject *act_lex_env;
66044
66045 DUK_DDD(DUK_DDDPRINT("catcher has an automatic catch binding"));
66046
66047 /* Note: 'act' is dangerous here because it may get invalidate at many
66048 * points, so we re-lookup it multiple times.
66049 */
66050 DUK_ASSERT(thr->callstack_top >= 1);
66051 act = thr->callstack + thr->callstack_top - 1;
66052
66053 if (act->lex_env == NULL) {
66054 DUK_ASSERT(act->var_env == NULL);
66055 DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
66056
66057 /* this may have side effects, so re-lookup act */
66059 act = thr->callstack + thr->callstack_top - 1;
66060 }
66061 DUK_ASSERT(act->lex_env != NULL);
66062 DUK_ASSERT(act->var_env != NULL);
66064 DUK_UNREF(act); /* unreferenced without assertions */
66065
66066 act = thr->callstack + thr->callstack_top - 1;
66067 act_lex_env = act->lex_env;
66068 act = NULL; /* invalidated */
66069
66073 act_lex_env);
66074 new_env = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
66075 DUK_ASSERT(new_env != NULL);
66076 DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO", (duk_heaphdr *) new_env));
66077
66078 /* Note: currently the catch binding is handled without a register
66079 * binding because we don't support dynamic register bindings (they
66080 * must be fixed for an entire function). So, there is no need to
66081 * record regbases etc.
66082 */
66083
66084 DUK_ASSERT(thr->catchstack[cat_idx].h_varname != NULL);
#define DUK_TVAL_SET_FASTINT_U32_UPDREF
DUK_LOCAL void duk__reconfig_valstack_ecma_catcher(duk_hthread *thr, duk_size_t act_idx, duk_size_t cat_idx)
DUK_INTERNAL_DECL void duk_js_init_activation_environment_records_delayed(duk_hthread *thr, duk_activation *act)
#define DUK_CAT_HAS_CATCH_BINDING_ENABLED(c)
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_INTERNAL_DECL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto)

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 55096 of file duktape-1.5.2/src/duktape.c.

55116 {
55117 duk_context *ctx = (duk_context *) thr;
55118
55119 DUK_DDD(DUK_DDDPRINT("creating arguments object for function call"));
55120
55121 DUK_ASSERT(thr != NULL);
55122 DUK_ASSERT(func != NULL);
55123 DUK_ASSERT(env != NULL);
55125 DUK_ASSERT(duk_get_top(ctx) >= num_stack_args + 1);
55126

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 67312 of file duktape-1.5.2/src/duktape.c.

67312 { \
67313 goto internal_error; \
67314 } while (0)
67315#endif
67316
67317#define DUK__SYNC_CURR_PC() do { \
67318 duk_activation *act; \
67319 act = thr->callstack + thr->callstack_top - 1; \
67320 act->curr_pc = curr_pc; \
67321 } while (0)
67322#define DUK__SYNC_AND_NULL_CURR_PC() do { \
67323 duk_activation *act; \
67324 act = thr->callstack + thr->callstack_top - 1; \
67325 act->curr_pc = curr_pc; \
67326 thr->ptr_curr_pc = NULL; \
67327 } while (0)
67328
67330 duk_hthread *entry_thread,
67331 duk_size_t entry_callstack_top,
67332 duk_int_t entry_call_recursion_depth,
67333 duk_jmpbuf *entry_jmpbuf_ptr) {
67334 duk_small_uint_t lj_ret;
67335
67336 /* Longjmp callers are required to sync-and-null thr->ptr_curr_pc
67337 * before longjmp.
67338 */
67339 DUK_ASSERT(heap->curr_thread != NULL);
67341
67342 /* XXX: signalling the need to shrink check (only if unwound) */
67343
67344 /* Must be restored here to handle e.g. yields properly. */
67345 heap->call_recursion_depth = entry_call_recursion_depth;
67346
67347 /* Switch to caller's setjmp() catcher so that if an error occurs
67348 * during error handling, it is always propagated outwards instead
67349 * of causing an infinite loop in our own handler.
67350 */
67351 heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr;
67352
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)

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 66086 of file duktape-1.5.2/src/duktape.c.

66097 : %!iO", (duk_heaphdr *) new_env));
66098 }
66099
66100 DUK_CAT_CLEAR_CATCH_ENABLED(&thr->catchstack[cat_idx]);
66101}
66102
66103DUK_LOCAL void duk__handle_finally(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) {
66104 duk_activation *act;
66105
66106 DUK_ASSERT(thr != NULL);
66107 DUK_ASSERT(tv_val_unstable != NULL);
66108
66109 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 66111 of file duktape-1.5.2/src/duktape.c.

66128 {
66129 duk_activation *act;
66130
66131 DUK_ASSERT(thr != NULL);
66132
66133 DUK_ASSERT(thr->callstack_top >= 1);
66134 act = thr->callstack + thr->callstack_top - 1;
66135

◆ 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 66162 of file duktape-1.5.2/src/duktape.c.

66181 {
66182 duk_size_t entry_callstack_index;
66184
66185 DUK_ASSERT(thr != NULL);
66186 DUK_ASSERT(entry_thread != NULL);
66187 DUK_ASSERT(entry_callstack_top > 0); /* guarantees entry_callstack_top - 1 >= 0 */
66188
66189 entry_callstack_index = entry_callstack_top - 1;
66190
66191 /* 'thr' is the current thread, as no-one resumes except us and we
66192 * switch 'thr' in that case.
66193 */
66194 DUK_ASSERT(thr == thr->heap->curr_thread);
66195
66196 /*
66197 * (Re)try handling the longjmp.
66198 *
66199 * A longjmp handler may convert the longjmp to a different type and
66200 * "virtually" rethrow by goto'ing to 'check_longjmp'. Before the goto,
66201 * the following must be updated:
66202 * - the heap 'lj' state
66203 * - 'thr' must reflect the "throwing" thread
66204 */
66205
66206 check_longjmp:
66207
66208 DUK_DD(DUK_DDPRINT("handling longjmp: type=%ld, value1=%!T, value2=%!T, iserror=%ld",
66209 (long) thr->heap->lj.type,
66210 (duk_tval *) &thr->heap->lj.value1,
66211 (duk_tval *) &thr->heap->lj.value2,
66212 (long) thr->heap->lj.iserror));
66213
66214 switch (thr->heap->lj.type) {
66215
66216 case DUK_LJ_TYPE_RESUME: {
66217 /*
66218 * Note: lj.value1 is 'value', lj.value2 is 'resumee'.
66219 * This differs from YIELD.
66220 */
66221
66222 duk_tval *tv;
66223 duk_tval *tv2;
66224 duk_size_t act_idx;
66225 duk_hthread *resumee;
66226
66227 /* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */
66228
66229 DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); /* unchanged by Duktape.Thread.resume() */
66230 DUK_ASSERT(thr->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */
66235 DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* an Ecmascript function */
66236 DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0); /* unsigned */
66237
66238 tv = &thr->heap->lj.value2; /* resumee */
66242 resumee = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv);
66243
66244 DUK_ASSERT(resumee != NULL);
66245 DUK_ASSERT(resumee->resumer == NULL);
66247 resumee->state == DUK_HTHREAD_STATE_YIELDED); /* checked by Duktape.Thread.resume() */
66249 resumee->callstack_top >= 2); /* YIELDED: Ecmascript activation + Duktape.Thread.yield() activation */
66251 (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1) != NULL &&
66253 ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1))->func == duk_bi_thread_yield));
66255 (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2) != NULL &&
66256 DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2)))); /* an Ecmascript function */
66258 (resumee->callstack + resumee->callstack_top - 2)->idx_retval >= 0); /* idx_retval unsigned */
66260 resumee->callstack_top == 0); /* INACTIVE: no activation, single function value on valstack */
66262 (resumee->valstack_top == resumee->valstack + 1 &&
66263 DUK_TVAL_IS_OBJECT(resumee->valstack_top - 1) &&
66265
66266 if (thr->heap->lj.iserror) {
66267 /*
66268 * Throw the error in the resumed thread's context; the
66269 * error value is pushed onto the resumee valstack.
66270 *
66271 * Note: the callstack of the target may empty in this case
66272 * too (i.e. the target thread has never been resumed). The
66273 * value stack will contain the initial function in that case,
66274 * which we simply ignore.
66275 */
66276
66277 resumee->resumer = thr;
66280 DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
66281 thr = resumee;
66282
66283 thr->heap->lj.type = DUK_LJ_TYPE_THROW;
66284
66285 /* thr->heap->lj.value1 is already the value to throw */
66286 /* thr->heap->lj.value2 is 'thread', will be wiped out at the end */
66287
66288 DUK_ASSERT(thr->heap->lj.iserror); /* already set */
66289
66290 DUK_DD(DUK_DDPRINT("-> resume with an error, converted to a throw in the resumee, propagate"));
66291 goto check_longjmp;
66292 } else if (resumee->state == DUK_HTHREAD_STATE_YIELDED) {
66293 act_idx = resumee->callstack_top - 2; /* Ecmascript function */
66294 DUK_ASSERT_DISABLE(resumee->callstack[act_idx].idx_retval >= 0); /* unsigned */
66295
66296 tv = resumee->valstack + resumee->callstack[act_idx].idx_retval; /* return value from Duktape.Thread.yield() */
66297 DUK_ASSERT(tv >= resumee->valstack && tv < resumee->valstack_top);
66298 tv2 = &thr->heap->lj.value1;
66299 DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv2); /* side effects */
66300
66301 duk_hthread_callstack_unwind(resumee, act_idx + 1); /* unwind to 'yield' caller */
66302
66303 /* no need to unwind catchstack */
66304
66305 duk__reconfig_valstack_ecma_return(resumee, act_idx);
66306
66307 resumee->resumer = thr;
66310 DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
66311#if 0
66312 thr = resumee; /* not needed, as we exit right away */
66313#endif
66314 DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee"));
66315 retval = DUK__LONGJMP_RESTART;
66316 goto wipe_and_return;
66317 } else {
66318 duk_small_uint_t call_flags;
66319 duk_bool_t setup_rc;
66320
66321 /* resumee: [... initial_func] (currently actually: [initial_func]) */
66322
66323 duk_push_undefined((duk_context *) resumee);
66324 tv = &thr->heap->lj.value1;
66325 duk_push_tval((duk_context *) resumee, tv);
66326
66327 /* resumee: [... initial_func undefined(= this) resume_value ] */
66328
66329 call_flags = DUK_CALL_FLAG_IS_RESUME; /* is resume, not a tail call */
66330
66331 setup_rc = duk_handle_ecma_call_setup(resumee,
66332 1, /* num_stack_args */
66333 call_flags); /* call_flags */
66334 if (setup_rc == 0) {
66335 /* Shouldn't happen but check anyway. */
66337 }
66338
66339 resumee->resumer = thr;
66342 DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
66343#if 0
66344 thr = resumee; /* not needed, as we exit right away */
66345#endif
66346 DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee"));
66347 retval = DUK__LONGJMP_RESTART;
66348 goto wipe_and_return;
66349 }
66351 break; /* never here */
66352 }
66353
66354 case DUK_LJ_TYPE_YIELD: {
66355 /*
66356 * Currently only allowed only if yielding thread has only
66357 * Ecmascript activations (except for the Duktape.Thread.yield()
66358 * call at the callstack top) and none of them constructor
66359 * calls.
66360 *
66361 * This excludes the 'entry' thread which will always have
66362 * a preventcount > 0.
66363 */
66364
66365 duk_hthread *resumer;
66366
66367 /* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */
66368
66369 DUK_ASSERT(thr != entry_thread); /* Duktape.Thread.yield() should prevent */
66370 DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); /* unchanged from Duktape.Thread.yield() */
66371 DUK_ASSERT(thr->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.yield() activation */
66376 DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* an Ecmascript function */
66377 DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0); /* unsigned */
66378
66379 resumer = thr->resumer;
66380
66381 DUK_ASSERT(resumer != NULL);
66382 DUK_ASSERT(resumer->state == DUK_HTHREAD_STATE_RESUMED); /* written by a previous RESUME handling */
66383 DUK_ASSERT(resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */
66384 DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1) != NULL &&
66386 ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1))->func == duk_bi_thread_resume);
66387 DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2) != NULL &&
66388 DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2))); /* an Ecmascript function */
66389 DUK_ASSERT_DISABLE((resumer->callstack + resumer->callstack_top - 2)->idx_retval >= 0); /* unsigned */
66390
66391 if (thr->heap->lj.iserror) {
66393 thr->resumer = NULL;
66395 DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
66396 thr = resumer;
66397
66398 thr->heap->lj.type = DUK_LJ_TYPE_THROW;
66399 /* lj.value1 is already set */
66400 DUK_ASSERT(thr->heap->lj.iserror); /* already set */
66401
66402 DUK_DD(DUK_DDPRINT("-> yield an error, converted to a throw in the resumer, propagate"));
66403 goto check_longjmp;
66404 } else {
66405 duk__handle_yield(thr, resumer, resumer->callstack_top - 2, &thr->heap->lj.value1);
66406
66408 thr->resumer = NULL;
66410 DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
66411#if 0
66412 thr = resumer; /* not needed, as we exit right away */
66413#endif
66414
66415 DUK_DD(DUK_DDPRINT("-> yield a value, restart execution in resumer"));
66416 retval = DUK__LONGJMP_RESTART;
66417 goto wipe_and_return;
66418 }
66420 break; /* never here */
66421 }
66422
66423 case DUK_LJ_TYPE_THROW: {
66424 /*
66425 * Three possible outcomes:
66426 * * A try or finally catcher is found => resume there.
66427 * (or)
66428 * * The error propagates to the bytecode executor entry
66429 * level (and we're in the entry thread) => rethrow
66430 * with a new longjmp(), after restoring the previous
66431 * catchpoint.
66432 * * The error is not caught in the current thread, so
66433 * the thread finishes with an error. This works like
66434 * a yielded error, except that the thread is finished
66435 * and can no longer be resumed. (There is always a
66436 * resumer in this case.)
66437 *
66438 * Note: until we hit the entry level, there can only be
66439 * Ecmascript activations.
66440 */
66441
66442 duk_catcher *cat;
66443 duk_hthread *resumer;
66444
66445 cat = thr->catchstack + thr->catchstack_top - 1;
66446 while (cat >= thr->catchstack) {
66447 if (thr == entry_thread &&
66448 cat->callstack_index < entry_callstack_index) {
66449 /* entry level reached */
66450 break;
66451 }
66452
66453 if (DUK_CAT_HAS_CATCH_ENABLED(cat)) {
66455
66457 cat - thr->catchstack,
66458 &thr->heap->lj.value1,
66460
66461 DUK_DD(DUK_DDPRINT("-> throw caught by a 'catch' clause, restart execution"));
66462 retval = DUK__LONGJMP_RESTART;
66463 goto wipe_and_return;
66464 }
66465
66466 if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
66469
66471 cat - thr->catchstack,
66472 &thr->heap->lj.value1,
66474
66475 DUK_DD(DUK_DDPRINT("-> throw caught by a 'finally' clause, restart execution"));
66476 retval = DUK__LONGJMP_RESTART;
66477 goto wipe_and_return;
66478 }
66479
66480 cat--;
66481 }
66482
66483 if (thr == entry_thread) {
66484 /* not caught by anything before entry level; rethrow and let the
66485 * final catcher unwind everything
66486 */
66487#if 0
66488 duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1); /* leave 'cat' as top catcher (also works if catchstack exhausted) */
66489 duk_hthread_callstack_unwind(thr, entry_callstack_index + 1);
66490
66491#endif
66492 DUK_D(DUK_DPRINT("-> throw propagated up to entry level, rethrow and exit bytecode executor"));
66493 retval = DUK__LONGJMP_RETHROW;
66494 goto just_return;
66495 /* Note: MUST NOT wipe_and_return here, as heap->lj must remain intact */
66496 }
66497
66498 DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
66499
66500 /* not caught by current thread, thread terminates (yield error to resumer);
66501 * note that this may cause a cascade if the resumer terminates with an uncaught
66502 * exception etc (this is OK, but needs careful testing)
66503 */
66504
66505 DUK_ASSERT(thr->resumer != NULL);
66506 DUK_ASSERT(thr->resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */
66509 ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume); /* Duktape.Thread.resume() */
66511 DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2))); /* an Ecmascript function */
66512
66513 resumer = thr->resumer;
66514
66515 /* reset longjmp */
66516
66517 DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); /* already set */
66518 /* lj.value1 already set */
66519
66520 duk_hthread_terminate(thr); /* updates thread state, minimizes its allocations */
66522
66523 thr->resumer = NULL;
66525 DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
66526 thr = resumer;
66527 goto check_longjmp;
66528 }
66529
66530 case DUK_LJ_TYPE_BREAK: /* pseudotypes, not used in actual longjmps */
66532 case DUK_LJ_TYPE_RETURN:
66533 case DUK_LJ_TYPE_NORMAL:
66534 default: {
66535 /* should never happen, but be robust */
66536 DUK_D(DUK_DPRINT("caught unknown longjmp type %ld, treat as internal error", (long) thr->heap->lj.type));
66537 goto convert_to_internal_error;
66538 }
66539
66540 } /* end switch */
66541
66543
66544 wipe_and_return:
66545 /* this is not strictly necessary, but helps debugging */
#define DUK_LJ_TYPE_CONTINUE
#define DUK_LJ_TYPE_YIELD
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)
#define DUK_LJ_TYPE_RETURN
#define DUK_CALL_FLAG_IS_RESUME
DUK_LOCAL void duk__reconfig_valstack_ecma_return(duk_hthread *thr, duk_size_t act_idx)
#define DUK_HTHREAD_STATE_RESUMED
#define DUK__LONGJMP_RETHROW
DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_resume(duk_context *ctx)
#define DUK__LONGJMP_RESTART
#define DUK_LJ_TYPE_RESUME
#define DUK_LJ_TYPE_BREAK
DUK_LOCAL void duk__handle_yield(duk_hthread *thr, duk_hthread *resumer, duk_size_t act_idx, duk_tval *tv_val_unstable)
DUK_INTERNAL_DECL void duk_hthread_terminate(duk_hthread *thr)
#define DUK_CAT_HAS_CATCH_ENABLED(c)
#define DUK_HTHREAD_STATE_YIELDED
#define DUK_LJ_TYPE_NORMAL
#define DUK_HTHREAD_STATE_TERMINATED
DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_yield(duk_context *ctx)

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 55259 of file duktape-1.5.2/src/duktape.c.

55278 {
55279 duk_tval *tv;
55280
55281 DUK_ASSERT(thr != NULL);
55282 DUK_ASSERT(func != NULL);
55283 DUK_ASSERT(act != NULL);
55286
55288 if (tv) {
55291 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 50297 of file duktape-1.5.2/src/duktape.c.

50297 : update length (done by caller)"));
50298
50299 *out_result_len = target_len;
50300
50301 if (target_len == new_len) {
50302 DUK_DDD(DUK_DDDPRINT("target_len matches new_len, return success"));
50303 return 1;
50304 }
50305 DUK_DDD(DUK_DDDPRINT("target_len does not match new_len (some entry prevented "
50306 "full length adjustment), return error"));
50307 return 0;
50308 }
50309
50310 DUK_UNREACHABLE();
50311}
50312
50313/* XXX: is valstack top best place for argument? */
50314DUK_LOCAL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj) {
50315 duk_context *ctx = (duk_context *) thr;
50316 duk_propdesc desc;
50317 duk_uint32_t old_len;
50318 duk_uint32_t new_len;
50319 duk_uint32_t result_len;
50320 duk_tval *tv;
50321 duk_bool_t rc;
50322
50323 DUK_DDD(DUK_DDDPRINT("handling a put operation to array 'length' exotic property, "
50324 "new val: %!T",
50325 (duk_tval *) duk_get_tval(ctx, -1)));
50326
50327 DUK_ASSERT(thr != NULL);
50328 DUK_ASSERT(ctx != NULL);
50329 DUK_ASSERT(obj != NULL);
50330
50331 DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
50332
50333 DUK_ASSERT(duk_is_valid_index(ctx, -1));
50334
50335 /*
50336 * Get old and new length
50337 */
50338
50339 old_len = duk__get_old_array_length(thr, obj, &desc);
50340 duk_dup(ctx, -1); /* [in_val in_val] */
50341 new_len = duk__to_new_array_length_checked(thr); /* -> [in_val] */
50342 DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) old_len, (long) new_len));
50343
50344 /*
50345 * Writability check
50346 */
50347
50348 if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
50349 DUK_DDD(DUK_DDDPRINT("length is not writable, fail"));
50350 return 0;
50351 }
50352
50353 /*
50354 * New length not lower than old length => no changes needed
50355 * (not even array allocation).
50356 */
50357
50358 if (new_len >= old_len) {
50359 DUK_DDD(DUK_DDDPRINT("new length is higher than old length, just update length, no deletions"));
50360
50361 DUK_ASSERT(desc.e_idx >= 0);
50362 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx));
50363 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
50364 DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
50365 /* no decref needed for a number */
50366 DUK_TVAL_SET_FASTINT_U32(tv, new_len);
50367 DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
50368 return 1;
50369 }
50370
50371 DUK_DDD(DUK_DDDPRINT("new length is lower than old length, probably must delete entries"));
50372
50373 /*
50374 * New length lower than old length => delete elements, then
50375 * update length.
50376 *
50377 * Note: even though a bunch of elements have been deleted, the 'desc' is
50378 * still valid as properties haven't been resized (and entries compacted).
static const char * match(MatchState *ms, const char *s, const char *p)

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 50114 of file duktape-1.5.2/src/duktape.c.

50116 {
50118 }
50119 duk_pop(ctx);
50120 return res;
50121}
50122
50123/* Delete elements required by a smaller length, taking into account
50124 * potentially non-configurable elements. Returns non-zero if all
50125 * elements could be deleted, and zero if all or some elements could
50126 * not be deleted. Also writes final "target length" to 'out_result_len'.
50127 * This is the length value that should go into the 'length' property
50128 * (must be set by the caller). Never throws an error.
50129 */
50132 duk_hobject *obj,
50133 duk_uint32_t old_len,
50134 duk_uint32_t new_len,
50135 duk_bool_t force_flag,
50136 duk_uint32_t *out_result_len) {
50137 duk_uint32_t target_len;
50139 duk_uint32_t arr_idx;
50140 duk_hstring *key;
50141 duk_tval *tv;
50142 duk_bool_t rc;
50143
50144 DUK_DDD(DUK_DDDPRINT("new array length smaller than old (%ld -> %ld), "
50145 "probably need to remove elements",
50146 (long) old_len, (long) new_len));
50147
50148 /*
50149 * New length is smaller than old length, need to delete properties above
50150 * the new length.
50151 *
50152 * If array part exists, this is straightforward: array entries cannot
50153 * be non-configurable so this is guaranteed to work.
50154 *
50155 * If array part does not exist, array-indexed values are scattered
50156 * in the entry part, and some may not be configurable (preventing length
50157 * from becoming lower than their index + 1). To handle the algorithm
50158 * in E5 Section 15.4.5.1, step l correctly, we scan the entire property
50159 * set twice.
50160 */
50161
50162 DUK_ASSERT(thr != NULL);
50163 DUK_ASSERT(obj != NULL);
50164 DUK_ASSERT(new_len < old_len);
50165 DUK_ASSERT(out_result_len != NULL);
50167
50168 if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
50169 /*
50170 * All defined array-indexed properties are in the array part
50171 * (we assume the array part is comprehensive), and all array
50172 * entries are writable, configurable, and enumerable. Thus,
50173 * nothing can prevent array entries from being deleted.
50174 */
50175
50176 DUK_DDD(DUK_DDDPRINT("have array part, easy case"));
50177
50178 if (old_len < DUK_HOBJECT_GET_ASIZE(obj)) {
50179 /* XXX: assertion that entries >= old_len are already unused */
50180 i = old_len;
50181 } else {
50182 i = DUK_HOBJECT_GET_ASIZE(obj);
50183 }
50185
50186 while (i > new_len) {
50187 i--;
50188 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
50189 DUK_TVAL_SET_UNUSED_UPDREF(thr, tv); /* side effects */
50190 }
50191
50192 *out_result_len = new_len;
50193 return 1;
50194 } else {
50195 /*
50196 * Entries part is a bit more complex
50197 */
50198
50199 /* Stage 1: find highest preventing non-configurable entry (if any).
50200 * When forcing, ignore non-configurability.
50201 */
50202
50203 DUK_DDD(DUK_DDDPRINT("no array part, slow case"));
50204
50205 DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 1: find target_len "
50206 "(highest preventing non-configurable entry (if any))"));
50207
50208 target_len = new_len;
50209 if (force_flag) {
50210 DUK_DDD(DUK_DDDPRINT("array length write, no array part; force flag -> skip stage 1"));
50211 goto skip_stage1;
50212 }
50213 for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
50214 key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
50215 if (!key) {
50216 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i));
50217 continue;
50218 }
50219 if (!DUK_HSTRING_HAS_ARRIDX(key)) {
50220 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i));
50221 continue;
50222 }
50223
50224 DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key)); /* XXX: macro checks for array index flag, which is unnecessary here */
50225 arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
50226 DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);
50227 DUK_ASSERT(arr_idx < old_len); /* consistency requires this */
50228
50229 if (arr_idx < new_len) {
50230 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below new_len",
50231 (long) i, (long) arr_idx));
50232 continue;
50233 }
50234 if (DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i)) {
50235 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is a relevant array index %ld, but configurable",
50236 (long) i, (long) arr_idx));
50237 continue;
50238 }
50239
50240 /* relevant array index is non-configurable, blocks write */
50241 if (arr_idx >= target_len) {
50242 DUK_DDD(DUK_DDDPRINT("entry at index %ld has arr_idx %ld, is not configurable, "
50243 "update target_len %ld -> %ld",
50244 (long) i, (long) arr_idx, (long) target_len,
50245 (long) (arr_idx + 1)));
50246 target_len = arr_idx + 1;
50247 }
50248 }
50249 skip_stage1:
50250
50251 /* stage 2: delete configurable entries above target length */
50252
50253 DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld, target_len=%ld",
50254 (long) old_len, (long) new_len, (long) target_len));
50255
50256 DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 2: remove "
50257 "entries >= target_len"));
50258
50259 for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
50260 key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
50261 if (!key) {
50262 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i));
50263 continue;
50264 }
50265 if (!DUK_HSTRING_HAS_ARRIDX(key)) {
50266 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i));
50267 continue;
50268 }
50269
50270 DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key)); /* XXX: macro checks for array index flag, which is unnecessary here */
50271 arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
50272 DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);
50273 DUK_ASSERT(arr_idx < old_len); /* consistency requires this */
50274
50275 if (arr_idx < target_len) {
50276 DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below target_len",
50277 (long) i, (long) arr_idx));
50278 continue;
50279 }
50280 DUK_ASSERT(force_flag || DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i)); /* stage 1 guarantees */
50281
50282 DUK_DDD(DUK_DDDPRINT("delete entry index %ld: key is array index %ld",
50283 (long) i, (long) arr_idx));
50284
50285 /*
50286 * Slow delete, but we don't care as we're already in a very slow path.
50287 * The delete always succeeds: key has no exotic behavior, property
50288 * is configurable, and no resize occurs.
50289 */
50290 rc = duk_hobject_delprop_raw(thr, obj, key, force_flag ? DUK_DELPROP_FLAG_FORCE : 0);
50291 DUK_UNREF(rc);
50292 DUK_ASSERT(rc != 0);
50293 }
50294
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)
#define DUK_STR_INVALID_ARRAY_LENGTH
#define DUK_TVAL_SET_UNUSED_UPDREF
#define DUK_DELPROP_FLAG_FORCE
DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags)
#define DUK_HSTRING_GET_ARRIDX_SLOW(h)
#define DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(heap, h, i)

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 66625 of file duktape-1.5.2/src/duktape.c.

66644 {
66645 duk_tval *tv1;
66646 duk_tval *tv2;
66647 duk_hthread *resumer;
66648 duk_catcher *cat;
66649 duk_size_t new_cat_top;
66650 duk_size_t orig_callstack_index;
66651
66652 /* We can directly access value stack here. */
66653
66654 DUK_ASSERT(thr != NULL);
66655 DUK_ASSERT(entry_thread != NULL);
66656 DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom);
66657 tv1 = thr->valstack_top - 1;
66658 DUK_TVAL_CHKFAST_INPLACE(tv1); /* fastint downgrade check for return values */
66659
66660 /*
66661 * Four possible outcomes:
66662 *
66663 * 1. A 'finally' in the same function catches the 'return'.
66664 * It may continue to propagate when 'finally' is finished,
66665 * or it may be neutralized by 'finally' (both handled by
66666 * ENDFIN).
66667 *
66668 * 2. The return happens at the entry level of the bytecode
66669 * executor, so return from the executor (in C stack).
66670 *
66671 * 3. There is a calling (Ecmascript) activation in the call
66672 * stack => return to it, in the same executor instance.
66673 *
66674 * 4. There is no calling activation, and the thread is
66675 * terminated. There is always a resumer in this case,
66676 * which gets the return value similarly to a 'yield'
66677 * (except that the current thread can no longer be
66678 * resumed).
66679 */
66680
66681 DUK_ASSERT(thr != NULL);
66682 DUK_ASSERT(thr->callstack_top >= 1);
66683 DUK_ASSERT(thr->catchstack != NULL);
66684
66685 /* XXX: does not work if thr->catchstack is NULL */
66686 /* XXX: does not work if thr->catchstack is allocated but lowest pointer */
66687
66688 cat = thr->catchstack + thr->catchstack_top - 1; /* may be < thr->catchstack initially */
66689 DUK_ASSERT(thr->callstack_top > 0); /* ensures callstack_top - 1 >= 0 */
66690 orig_callstack_index = thr->callstack_top - 1;
66691
66692 while (cat >= thr->catchstack) {
66693 if (cat->callstack_index != orig_callstack_index) {
66694 break;
66695 }
66696 if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF &&
66698 duk_size_t cat_idx;
66699
66700 cat_idx = (duk_size_t) (cat - thr->catchstack); /* get before side effects */
66701
66702 DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom);
66703 duk__handle_finally(thr, cat_idx, thr->valstack_top - 1, DUK_LJ_TYPE_RETURN);
66704
66705 DUK_DD(DUK_DDPRINT("-> return caught by 'finally', restart execution"));
66706 return DUK__RETHAND_RESTART;
66707 }
66708 cat--;
66709 }
66710 /* If out of catchstack, cat = thr->catchstack - 1;
66711 * new_cat_top will be 0 in that case.
66712 */
66713 new_cat_top = (duk_size_t) ((cat + 1) - thr->catchstack);
66714 cat = NULL; /* avoid referencing, invalidated */
66715
66716 DUK_DDD(DUK_DDDPRINT("no catcher in catch stack, return to calling activation / yield"));
66717
66718 if (thr == entry_thread &&
66719 thr->callstack_top == entry_callstack_top) {
66720 /* Return to the bytecode executor caller which will unwind stacks.
66721 * Return value is already on the stack top: [ ... retval ].
66722 */
66723
66724 /* XXX: could unwind catchstack here, so that call handling
66725 * didn't need to do that?
66726 */
66727 DUK_DDD(DUK_DDDPRINT("-> return propagated up to entry level, exit bytecode executor"));
66728 return DUK__RETHAND_FINISHED;
66729 }
66730
66731 if (thr->callstack_top >= 2) {
66732 /* There is a caller; it MUST be an Ecmascript caller (otherwise it would
66733 * match entry level check)
66734 */
66735
66736 DUK_DDD(DUK_DDDPRINT("return to Ecmascript caller, idx_retval=%ld, lj_value1=%!T",
66737 (long) (thr->callstack + thr->callstack_top - 2)->idx_retval,
66738 (duk_tval *) &thr->heap->lj.value1));
66739
66740 DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* must be ecmascript */
66741
66742 tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval;
66743 DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom);
66744 tv2 = thr->valstack_top - 1;
66745 DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */
66746
66747 DUK_DDD(DUK_DDDPRINT("return value at idx_retval=%ld is %!T",
66748 (long) (thr->callstack + thr->callstack_top - 2)->idx_retval,
66749 (duk_tval *) (thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval)));
66750
66751 duk_hthread_catchstack_unwind(thr, new_cat_top); /* leave 'cat' as top catcher (also works if catchstack exhausted) */
66754
66755 DUK_DD(DUK_DDPRINT("-> return not intercepted, restart execution in caller"));
66756 return DUK__RETHAND_RESTART;
66757 }
66758
66759 DUK_DD(DUK_DDPRINT("no calling activation, thread finishes (similar to yield)"));
66760
66761 DUK_ASSERT(thr->resumer != NULL);
66762 DUK_ASSERT(thr->resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */
66765 ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume); /* Duktape.Thread.resume() */
66767 DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2))); /* an Ecmascript function */
66768 DUK_ASSERT_DISABLE((thr->resumer->callstack + thr->resumer->callstack_top - 2)->idx_retval >= 0); /* unsigned */
66771
66772 resumer = thr->resumer;
66773
#define DUK__RETHAND_FINISHED
#define DUK__RETHAND_RESTART

◆ 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 56883 of file duktape-1.5.2/src/duktape.c.

56885 {
56886 DUK_ERROR_API(thr, "not enough stack values for safe_call rc");
56887 }
56888
56889 DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); /* no need to unwind */
56890 DUK_ASSERT(thr->callstack_top == entry_callstack_top);
56891
56892 duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, rc);
56893 return;
56894
56895 thread_state_error:
56896 DUK_ERROR_FMT1(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for safe_call (%ld)", (long) thr->state);
56898}
56899
56901 duk_idx_t idx_retbase,
56902 duk_idx_t num_stack_rets,
56903 duk_size_t entry_valstack_bottom_index,
56904 duk_size_t entry_callstack_top,
56905 duk_size_t entry_catchstack_top,
56906 duk_jmpbuf *old_jmpbuf_ptr) {
56907 duk_context *ctx;
56908
56909 DUK_ASSERT(thr != NULL);
56910 ctx = (duk_context *) thr;
56912
56913 /*
56914 * Error during call. The error value is at heap->lj.value1.
56915 *
56916 * The very first thing we do is restore the previous setjmp catcher.
56917 * This means that any error in error handling will propagate outwards
56918 * instead of causing a setjmp() re-entry above.
56919 */
56920
56921 DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_safe_call()"));
56922
56923 /* Other longjmp types are handled by executor before propagating
56924 * the error here.
56925 */
56927 DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
56928 DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
56929
56930 /* Note: either pointer may be NULL (at entry), so don't assert. */
56931 thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
56932
56933 DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
56934 DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
56935 duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
56937 duk_hthread_callstack_unwind(thr, entry_callstack_top);
56939 thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
56940
56941 /* [ ... | (crud) ] */
56942
56943 /* XXX: space in valstack? see discussion in duk_handle_call_xxx(). */
56944 duk_push_tval(ctx, &thr->heap->lj.value1);
56945
56946 /* [ ... | (crud) errobj ] */
56947
56948 DUK_ASSERT(duk_get_top(ctx) >= 1); /* at least errobj must be on stack */
56949
56950 /* check that the valstack has space for the final amount and any
56951 * intermediate space needed; this is unoptimal but should be safe
56952 */
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 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__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 56774 of file duktape-1.5.2/src/duktape.c.

56797 {
56798 duk_context *ctx;
56799 duk_ret_t rc;
56800
56801 DUK_ASSERT(thr != NULL);
56802 ctx = (duk_context *) thr;
56804 DUK_UNREF(entry_valstack_bottom_index);
56805 DUK_UNREF(entry_callstack_top);
56806 DUK_UNREF(entry_catchstack_top);
56807
56808 /*
56809 * Thread state check and book-keeping.
56810 */
56811
56812 if (thr == thr->heap->curr_thread) {
56813 /* same thread */
56814 if (thr->state != DUK_HTHREAD_STATE_RUNNING) {
56815 /* should actually never happen, but check anyway */
56816 goto thread_state_error;
56817 }
56818 } else {
56819 /* different thread */
56820 DUK_ASSERT(thr->heap->curr_thread == NULL ||
56822 if (thr->state != DUK_HTHREAD_STATE_INACTIVE) {
56823 goto thread_state_error;
56824 }
56825 DUK_HEAP_SWITCH_THREAD(thr->heap, thr);
56827
56828 /* Note: multiple threads may be simultaneously in the RUNNING
56829 * state, but not in the same "resume chain".
56830 */
56831 }
56832
56833 DUK_ASSERT(thr->heap->curr_thread == thr);
56835
56836 /*
56837 * Recursion limit check.
56838 *
56839 * Note: there is no need for an "ignore recursion limit" flag
56840 * for duk_handle_safe_call now.
56841 */
56842
56846 /* XXX: error message is a bit misleading: we reached a recursion
56847 * limit which is also essentially the same as a C callstack limit
56848 * (except perhaps with some relaxed threading assumptions).
56849 */
56851 }
56852 thr->heap->call_recursion_depth++;
56853
56854 /*
56855 * Valstack spare check
56856 */
56857
56858 duk_require_stack(ctx, 0); /* internal spare */
56859
56860 /*
56861 * Make the C call
56862 */
56863
56864 rc = func(ctx);
56865
56866 DUK_DDD(DUK_DDDPRINT("safe_call, func rc=%ld", (long) rc));
56867
56868 /*
56869 * Valstack manipulation for results.
56870 */
56871
56872 /* we're running inside the caller's activation, so no change in call/catch stack or valstack bottom */
56873 DUK_ASSERT(thr->callstack_top == entry_callstack_top);
56874 DUK_ASSERT(thr->catchstack_top == entry_catchstack_top);
56875 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
56876 DUK_ASSERT((duk_size_t) (thr->valstack_bottom - thr->valstack) == entry_valstack_bottom_index);
56878 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
56879
56880 if (rc < 0) {

◆ 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 56954 of file duktape-1.5.2/src/duktape.c.

56977 {
56978 duk_context *ctx;
56979
56980 DUK_ASSERT(thr != NULL);
56981 ctx = (duk_context *) thr;
56983 DUK_UNREF(ctx);
56984 DUK_UNREF(idx_retbase);
56985 DUK_UNREF(num_stack_rets);
56986
56987 /* Restore entry thread executor curr_pc stack frame pointer. */
56988 thr->ptr_curr_pc = entry_ptr_curr_pc;
56989
56990 /* XXX: because we unwind stacks above, thr->heap->curr_thread is at
56991 * risk of pointing to an already freed thread. This was indeed the
56992 * case in test-bug-multithread-valgrind.c, until duk_handle_call()
56993 * was fixed to restore thr->heap->curr_thread before rethrowing an
56994 * uncaught error.
56995 */
56996 DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */
56997 thr->state = (duk_uint8_t) entry_thread_state;
56998

◆ duk__handle_temproot()

DUK_LOCAL void duk__handle_temproot ( duk_heap * heap,
duk_heaphdr * hdr )

Definition at line 42326 of file duktape-1.5.2/src/duktape.c.

42341 {

◆ 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 66141 of file duktape-1.5.2/src/duktape.c.

66158 {
66159 duk_tval *tv1;

◆ duk__hexval()

DUK_LOCAL duk_codepoint_t duk__hexval ( duk_lexer_ctx * lex_ctx,
duk_codepoint_t x )

Definition at line 73627 of file duktape-1.5.2/src/duktape.c.

73631 {
73632 DUK_ASSERT_DISABLE(pt->offset >= 0); /* unsigned */
73633 DUK_ASSERT(pt->line >= 1);
73634 lex_ctx->input_offset = pt->offset;
73635 lex_ctx->input_line = pt->line;
73636 duk__init_lexer_window(lex_ctx);
73637}
73638
73639/*
73640 * Lexing helpers
73641 */
73642
73643/* numeric value of a hex digit (also covers octal and decimal digits) */
DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx)

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 47049 of file duktape-1.5.2/src/duktape.c.

47057 : pc_limit=%ld, length=%ld, %lf bits/opcode --> %!ixT",
47058 (long) length, (long) new_size, (double) new_size * 8.0 / (double) length,
47059 (duk_tval *) duk_get_tval(ctx, -1)));
47060}
47061
47062/* PC is unsigned. If caller does PC arithmetic and gets a negative result,
47063 * it will map to a large PC which is out of bounds and causes a zero to be
47064 * returned.
47065 */
47066DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw(duk_hthread *thr, duk_hbuffer_fixed *buf, duk_uint_fast32_t pc) {
47067 duk_bitdecoder_ctx bd_ctx_alloc;
47068 duk_bitdecoder_ctx *bd_ctx = &bd_ctx_alloc;
47069 duk_uint32_t *hdr;
47070 duk_uint_fast32_t start_offset;
47071 duk_uint_fast32_t pc_limit;
47072 duk_uint_fast32_t hdr_index;
47073 duk_uint_fast32_t pc_base;
47074 duk_uint_fast32_t n;
47075 duk_uint_fast32_t curr_line;
47076
47077 DUK_ASSERT(buf != NULL);
47078 DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) buf));
47079 DUK_UNREF(thr);
47080
47081 /*
47082 * Use the index in the header to find the right starting point
47083 */
47084
47085 hdr_index = pc / DUK_PC2LINE_SKIP;
47086 pc_base = hdr_index * DUK_PC2LINE_SKIP;
47087 n = pc - pc_base;
47088
47089 if (DUK_HBUFFER_FIXED_GET_SIZE(buf) <= sizeof(duk_uint32_t)) {
47090 DUK_DD(DUK_DDPRINT("pc2line lookup failed: buffer is smaller than minimal header"));
47091 goto error;
47092 }
47093
47094 hdr = (duk_uint32_t *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf);
47095 pc_limit = hdr[0];
47096 if (pc >= pc_limit) {
47097 /* Note: pc is unsigned and cannot be negative */
47098 DUK_DD(DUK_DDPRINT("pc2line lookup failed: pc out of bounds (pc=%ld, limit=%ld)",
47099 (long) pc, (long) pc_limit));
47100 goto error;
47101 }
47102
47103 curr_line = hdr[1 + hdr_index * 2];
47104 start_offset = hdr[1 + hdr_index * 2 + 1];
47105 if ((duk_size_t) start_offset > DUK_HBUFFER_FIXED_GET_SIZE(buf)) {
47106 DUK_DD(DUK_DDPRINT("pc2line lookup failed: start_offset out of bounds (start_offset=%ld, buffer_size=%ld)",
47107 (long) start_offset, (long) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) buf)));
47108 goto error;
47109 }
47110
47111 /*
47112 * Iterate the bitstream (line diffs) until PC is reached
47113 */
47114
47115 DUK_MEMZERO(bd_ctx, sizeof(*bd_ctx));
47116 bd_ctx->data = ((duk_uint8_t *) hdr) + start_offset;
47117 bd_ctx->length = (duk_size_t) (DUK_HBUFFER_FIXED_GET_SIZE(buf) - start_offset);
47118
47119#if 0
47120 DUK_DDD(DUK_DDDPRINT("pc2line lookup: pc=%ld -> hdr_index=%ld, pc_base=%ld, n=%ld, start_offset=%ld",
47121 (long) pc, (long) hdr_index, (long) pc_base, (long) n, (long) start_offset));
47122#endif
47123
47124 while (n > 0) {
47125#if 0
47126 DUK_DDD(DUK_DDDPRINT("lookup: n=%ld, curr_line=%ld", (long) n, (long) curr_line));
47127#endif
47128
47129 if (duk_bd_decode_flag(bd_ctx)) {
47130 if (duk_bd_decode_flag(bd_ctx)) {
47131 if (duk_bd_decode_flag(bd_ctx)) {
47132 /* 1 1 1 <32 bits> */
47133 duk_uint_fast32_t t;
47134 t = duk_bd_decode(bd_ctx, 16); /* workaround: max nbits = 24 now */
47135 t = (t << 16) + duk_bd_decode(bd_ctx, 16);
47136 curr_line = t;
47137 } else {
47138 /* 1 1 0 <8 bits> */
47139 duk_uint_fast32_t t;
47140 t = duk_bd_decode(bd_ctx, 8);
47141 curr_line = curr_line + t - 0x80;
47142 }
47143 } else {
47144 /* 1 0 <2 bits> */
47145 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 )

◆ 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 57865 of file duktape-1.5.2/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 71282 of file duktape-1.5.2/src/duktape.c.

71288 :
71289 *
71290 * * Order of internal properties should match frequency of use, since the
71291 * properties will be linearly scanned on lookup (functions usually don't
71292 * have enough properties to warrant a hash part).
71293 *
71294 * * The created closure is independent of its template; they do share the
71295 * same 'data' buffer object, but the template object itself can be freed
71296 * even if the closure object remains reachable.
71297 */
71298
71299DUK_LOCAL void duk__inc_data_inner_refcounts(duk_hthread *thr, duk_hcompiledfunction *f) {
71300 duk_tval *tv, *tv_end;
71301 duk_hobject **funcs, **funcs_end;
71302
71303 /* If function creation fails due to out-of-memory, the data buffer
71304 * pointer may be NULL in some cases. That's actually possible for
71305 * GC code, but shouldn't be possible here because the incomplete
71306 * function will be unwound from the value stack and never instantiated.
71307 */

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 57952 of file duktape-1.5.2/src/duktape.c.

57955 {
57956 duk__advance_helper(comp_ctx, expect);
57957}
57958
57959/* advance, whatever the current token is; parse next token in regexp context */
57960DUK_LOCAL void duk__advance(duk_compiler_ctx *comp_ctx) {
57961 duk__advance_helper(comp_ctx, -1);
57962}
57963
57964/*
57965 * Helpers for duk_compiler_func.
57966 */
57967
57968/* init function state: inits valstack allocations */
57970 duk_compiler_func *func = &comp_ctx->curr_func;
57971 duk_hthread *thr = comp_ctx->thr;
57972 duk_context *ctx = (duk_context *) thr;
57973 duk_idx_t entry_top;
57974
57975 entry_top = duk_get_top(ctx);
57976
57977 DUK_MEMZERO(func, sizeof(*func)); /* intentional overlap with earlier memzero */
57978#ifdef DUK_USE_EXPLICIT_NULL_INIT
57979 func->h_name = NULL;
57980 func->h_consts = NULL;
57981 func->h_funcs = NULL;
57982 func->h_decls = NULL;
57983 func->h_labelnames = NULL;
57984 func->h_labelinfos = NULL;
57985 func->h_argnames = NULL;
57986 func->h_varmap = NULL;
57987#endif
57988
57990
57992 /* code_idx = entry_top + 0 */
57993
57994 duk_push_array(ctx);
57995 func->consts_idx = entry_top + 1;
57996 func->h_consts = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 1);
57997 DUK_ASSERT(func->h_consts != NULL);
57998
57999 duk_push_array(ctx);
58000 func->funcs_idx = entry_top + 2;
58001 func->h_funcs = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 2);
58002 DUK_ASSERT(func->h_funcs != NULL);
58003 DUK_ASSERT(func->fnum_next == 0);
58004
58005 duk_push_array(ctx);
58006 func->decls_idx = entry_top + 3;
58007 func->h_decls = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 3);
58008 DUK_ASSERT(func->h_decls != NULL);
58009
58010 duk_push_array(ctx);
58011 func->labelnames_idx = entry_top + 4;
58012 func->h_labelnames = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 4);
58013 DUK_ASSERT(func->h_labelnames != NULL);
#define DUK__FUNCTION_INIT_REQUIRE_SLOTS
#define DUK_GET_HOBJECT_POSIDX(ctx, idx)
DUK_LOCAL_DECL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx)
#define DUK__BC_INITIAL_INSTS

◆ duk__init_heap_strings()

DUK_LOCAL duk_bool_t duk__init_heap_strings ( duk_heap * heap)

Definition at line 41164 of file duktape-1.5.2/src/duktape.c.

41167 {
41168 duk_uint32_t hash;
41169 const duk_hstring *h;
41170 h = duk_rom_strings[i];
41171 DUK_ASSERT(h != NULL);
41172 hash = duk_heap_hashstring(heap, (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
41173 DUK_DD(DUK_DDPRINT("duk_rom_strings[%d] -> hash 0x%08lx, computed 0x%08lx",
41174 (int) i, (unsigned long) DUK_HSTRING_GET_HASH(h), (unsigned long) hash));
41175 DUK_ASSERT(hash == (duk_uint32_t) DUK_HSTRING_GET_HASH(h));
41176 }
41177#endif
41178 return 1;
41179}
41180#else /* DUK_USE_ROM_STRINGS */
41182 duk_bitdecoder_ctx bd_ctx;
41183 duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
41184 duk_small_uint_t i, j;
41185
41186 DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
41187 bd->data = (const duk_uint8_t *) duk_strings_data;
41189
41190 for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
41191 duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN];
41192 duk_hstring *h;
41193 duk_small_uint_t len;
41194 duk_small_uint_t mode;
41196
41197 len = duk_bd_decode(bd, 5);
41198 mode = 32; /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */
41199 for (j = 0; j < len; j++) {
41200 t = duk_bd_decode(bd, 5);
41201 if (t < DUK__BITPACK_LETTER_LIMIT) {
41202 t = t + DUK_ASC_UC_A + mode;
41203 } else if (t == DUK__BITPACK_UNDERSCORE) {
41205 } else if (t == DUK__BITPACK_FF) {
41206 /* Internal keys are prefixed with 0xFF in the stringtable
41207 * (which makes them invalid UTF-8 on purpose).
41208 */
41209 t = 0xff;
41210 } else if (t == DUK__BITPACK_SWITCH1) {
41211 t = duk_bd_decode(bd, 5);
41212 DUK_ASSERT_DISABLE(t >= 0); /* unsigned */
41213 DUK_ASSERT(t <= 25);
41214 t = t + DUK_ASC_UC_A + (mode ^ 32);
41215 } else if (t == DUK__BITPACK_SWITCH) {
41216 mode = mode ^ 32;
41217 t = duk_bd_decode(bd, 5);
41218 DUK_ASSERT_DISABLE(t >= 0);
41219 DUK_ASSERT(t <= 25);
41220 t = t + DUK_ASC_UC_A + mode;
41221 } else if (t == DUK__BITPACK_SEVENBIT) {
41222 t = duk_bd_decode(bd, 7);
41223 }
41224 tmp[j] = (duk_uint8_t) t;
41225 }
41226
41227 /* No need to length check string: it will never exceed even
41228 * the 16-bit length maximum.
41229 */
41230 DUK_ASSERT(len <= 0xffffUL);
41231 DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i));
41232 h = duk_heap_string_intern(heap, tmp, len);
41233 if (!h) {
41234 goto error;
41235 }
41237
41238 /* Special flags checks. Since these strings are always
41239 * reachable and a string cannot appear twice in the string
41240 * table, there's no need to check/set these flags elsewhere.
41241 * The 'internal' flag is set by string intern code.
41242 */
41243 if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) {
41245 }
41250 }
41251 }
41252
41253 DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h));
41254
#define DUK_STRIDX_LC_ARGUMENTS
#define DUK_STRDATA_MAX_STRLEN
DUK_INTERNAL const duk_uint8_t duk_strings_data[1049]
#define DUK_STRIDX_START_RESERVED
#define DUK_STRDATA_DATA_LENGTH
DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen)
#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(x)
#define DUK__BITPACK_FF
#define DUK__BITPACK_UNDERSCORE
#define DUK_HEAPHDR_HAS_READONLY(h)
#define DUK__BITPACK_SWITCH
#define DUK_STRIDX_START_STRICT_RESERVED
#define DUK_HSTRING_SET_STRICT_RESERVED_WORD(x)
#define DUK_HSTRING_SET_RESERVED_WORD(x)
#define DUK__BITPACK_SEVENBIT
#define DUK__BITPACK_LETTER_LIMIT
#define DUK_STRIDX_END_RESERVED
#define DUK_ASC_UNDERSCORE
#define DUK_ASC_UC_A
#define DUK__BITPACK_SWITCH1
DUK_INTERNAL_DECL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits)
DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap)

◆ duk__init_heap_thread()

DUK_LOCAL duk_bool_t duk__init_heap_thread ( duk_heap * heap)

Definition at line 41257 of file duktape-1.5.2/src/duktape.c.

41269 :
41270 return 0;
41271}
41272#endif /* DUK_USE_ROM_STRINGS */
41273
41275 duk_hthread *thr;
41276
41277 DUK_DD(DUK_DDPRINT("heap init: alloc heap thread"));
41278 thr = duk_hthread_alloc(heap,
41282 if (!thr) {
41283 DUK_D(DUK_DPRINT("failed to alloc heap_thread"));
41284 return 0;
41285 }
41287#if defined(DUK_USE_ROM_STRINGS)
41288 /* No strs[] pointer. */
41289#else /* DUK_USE_ROM_STRINGS */
41290#if defined(DUK_USE_HEAPPTR16)
41291 thr->strs16 = heap->strs16;
41292#else
41293 thr->strs = heap->strs;
41294#endif
41295#endif /* DUK_USE_ROM_STRINGS */
41296
DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap)
#define DUK_HOBJECT_CLASS_THREAD
#define DUK_HOBJECT_FLAG_THREAD
DUK_INTERNAL_DECL duk_hthread * duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags)
duk_hstring * strs[DUK_HEAP_NUM_STRINGS]

◆ duk__init_lexer_window()

DUK_LOCAL void duk__init_lexer_window ( duk_lexer_ctx * lex_ctx)

◆ 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 45947 of file duktape-1.5.2/src/duktape.c.

45964 {
45965#ifdef DUK_USE_EXPLICIT_NULL_INIT
45966 DUK_HOBJECT_SET_PROPS(heap, obj, NULL);
45967#endif
45968
45969 /* XXX: macro? sets both heaphdr and object flags */
45970 obj->hdr.h_flags = hobject_flags;
45971 DUK_HEAPHDR_SET_TYPE(&obj->hdr, DUK_HTYPE_OBJECT); /* also goes into flags */
45972
#define DUK_HOBJECT_SET_PROPS(heap, h, x)
#define DUK_HEAPHDR_SET_TYPE(h, val)

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 64270 of file duktape-1.5.2/src/duktape.c.

64273 :
64274 *
64275 * - The 'arguments' binding, established only if no shadowing argument
64276 * or function declaration exists. We handle 'arguments' creation
64277 * and binding through an explicit slow path environment record.
64278 *
64279 * - The "name" binding for a named function expression. This is also
64280 * handled through an explicit slow path environment record.
64281 */
64282
64283/* XXX: add support for variables to not be register bound always, to
64284 * handle cases with a very large number of variables?
64285 */
64286
64288 duk_hthread *thr = comp_ctx->thr;
64289 duk_context *ctx = (duk_context *) thr;
64290 duk_hstring *h_name;
64291 duk_bool_t configurable_bindings;
64292 duk_uarridx_t num_args;
64293 duk_uarridx_t num_decls;
64294 duk_regconst_t rc_name;
64295 duk_small_uint_t declvar_flags;
64296 duk_uarridx_t i;
64297#ifdef DUK_USE_ASSERTIONS
64298 duk_idx_t entry_top;
64299#endif
64300
64301#ifdef DUK_USE_ASSERTIONS
64302 entry_top = duk_get_top(ctx);
64303#endif
64304
64305 /*
64306 * Preliminaries
64307 */
64308
64309 configurable_bindings = comp_ctx->curr_func.is_eval;
64310 DUK_DDD(DUK_DDDPRINT("configurable_bindings=%ld", (long) configurable_bindings));
64311
64312 /* varmap is already in comp_ctx->curr_func.varmap_idx */
64313
64314 /*
64315 * Function formal arguments, always bound to registers
64316 * (there's no support for shuffling them now).
64317 */
64318
64319 num_args = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx);
64320 DUK_DDD(DUK_DDDPRINT("num_args=%ld", (long) num_args));
64321 /* XXX: check num_args */
64322
64323 for (i = 0; i < num_args; i++) {
64324 duk_get_prop_index(ctx, comp_ctx->curr_func.argnames_idx, i);
64325 h_name = duk_get_hstring(ctx, -1);
64326 DUK_ASSERT(h_name != NULL);
64327
64328 if (comp_ctx->curr_func.is_strict) {
64329 if (duk__hstring_is_eval_or_arguments(comp_ctx, h_name)) {
64330 DUK_DDD(DUK_DDDPRINT("arg named 'eval' or 'arguments' in strict mode -> SyntaxError"));
64331 goto error_argname;
64332 }
64333 duk_dup_top(ctx);
64334 if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
64335 DUK_DDD(DUK_DDDPRINT("duplicate arg name in strict mode -> SyntaxError"));
64336 goto error_argname;
64337 }
64338
64339 /* Ensure argument name is not a reserved word in current
64340 * (final) strictness. Formal argument parsing may not
64341 * catch reserved names if strictness changes during
64342 * parsing.
64343 *
64344 * We only need to do this in strict mode because non-strict
64345 * keyword are always detected in formal argument parsing.
64346 */
64347
64349 goto error_argname;
64350 }
64351 }
64352
64353 /* overwrite any previous binding of the same name; the effect is
64354 * that last argument of a certain name wins.
64355 */
64356
64357 /* only functions can have arguments */
64358 DUK_ASSERT(comp_ctx->curr_func.is_function);
64359 duk_push_uarridx(ctx, i); /* -> [ ... name index ] */
64360 duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* -> [ ... ] */
64361
64362 /* no code needs to be emitted, the regs already have values */
64363 }
64364
64365 /* use temp_next for tracking register allocations */
64366 DUK__SETTEMP_CHECKMAX(comp_ctx, (duk_reg_t) num_args);
64367
64368 /*
64369 * After arguments, allocate special registers (like shuffling temps)
64370 */
64371
64372 if (out_stmt_value_reg) {
64373 *out_stmt_value_reg = DUK__ALLOCTEMP(comp_ctx);
64374 }
64375 if (comp_ctx->curr_func.needs_shuffle) {
64376 duk_reg_t shuffle_base = DUK__ALLOCTEMPS(comp_ctx, 3);
64377 comp_ctx->curr_func.shuffle1 = shuffle_base;
64378 comp_ctx->curr_func.shuffle2 = shuffle_base + 1;
64379 comp_ctx->curr_func.shuffle3 = shuffle_base + 2;
64380 DUK_D(DUK_DPRINT("shuffle registers needed by function, allocated: %ld %ld %ld",
64381 (long) comp_ctx->curr_func.shuffle1,
64382 (long) comp_ctx->curr_func.shuffle2,
64383 (long) comp_ctx->curr_func.shuffle3));
64384 }
64385 if (comp_ctx->curr_func.temp_next > 0x100) {
64386 DUK_D(DUK_DPRINT("not enough 8-bit regs: temp_next=%ld", (long) comp_ctx->curr_func.temp_next));
64387 goto error_outofregs;
64388 }
64389
64390 /*
64391 * Function declarations
64392 */
64393
64394 num_decls = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
64395 DUK_DDD(DUK_DDDPRINT("num_decls=%ld -> %!T",
64396 (long) num_decls,
64397 (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.decls_idx)));
64398 for (i = 0; i < num_decls; i += 2) {
64399 duk_int_t decl_type;
64400 duk_int_t fnum;
64401
64402 duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1); /* decl type */
64403 decl_type = duk_to_int(ctx, -1);
64404 fnum = decl_type >> 8; /* XXX: macros */
64405 decl_type = decl_type & 0xff;
64406 duk_pop(ctx);
64407
64408 if (decl_type != DUK_DECL_TYPE_FUNC) {
64409 continue;
64410 }
64411
64412 duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i); /* decl name */
64413
64414 /* XXX: spilling */
64415 if (comp_ctx->curr_func.is_function) {
64416 duk_reg_t reg_bind;
64417 duk_dup_top(ctx);
64418 if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
64419 /* shadowed; update value */
64420 duk_dup_top(ctx);
64421 duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
64422 reg_bind = duk_to_int(ctx, -1); /* [ ... name reg_bind ] */
64423 duk__emit_a_bc(comp_ctx,
64425 (duk_regconst_t) reg_bind,
64426 (duk_regconst_t) fnum);
64427 } else {
64428 /* function: always register bound */
64429 reg_bind = DUK__ALLOCTEMP(comp_ctx);
64430 duk__emit_a_bc(comp_ctx,
64432 (duk_regconst_t) reg_bind,
64433 (duk_regconst_t) fnum);
64434 duk_push_int(ctx, (duk_int_t) reg_bind);
64435 }
64436 } else {
64437 /* Function declaration for global/eval code is emitted even
64438 * for duplicates, because of E5 Section 10.5, step 5.e of
64439 * E5.1 (special behavior for variable bound to global object).
64440 *
64441 * DECLVAR will not re-declare a variable as such, but will
64442 * update the binding value.
64443 */
64444
64445 duk_reg_t reg_temp = DUK__ALLOCTEMP(comp_ctx);
64446 duk_dup_top(ctx);
64447 rc_name = duk__getconst(comp_ctx);
64448 duk_push_null(ctx);
64449
64450 duk__emit_a_bc(comp_ctx,
64452 (duk_regconst_t) reg_temp,
64453 (duk_regconst_t) fnum);
64454
64455 declvar_flags = DUK_PROPDESC_FLAG_WRITABLE |
64458
64459 if (configurable_bindings) {
64460 declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
64461 }
64462
64463 duk__emit_a_b_c(comp_ctx,
64465 (duk_regconst_t) declvar_flags /*flags*/,
64466 rc_name /*name*/,
64467 (duk_regconst_t) reg_temp /*value*/);
64468
64469 DUK__SETTEMP(comp_ctx, reg_temp); /* forget temp */
64470 }
64471
64472 DUK_DDD(DUK_DDDPRINT("function declaration to varmap: %!T -> %!T",
64473 (duk_tval *) duk_get_tval(ctx, -2),
64474 (duk_tval *) duk_get_tval(ctx, -1)));
64475
64476 duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* [ ... name reg/null ] -> [ ... ] */
64477 }
64478
64479 /*
64480 * 'arguments' binding is special; if a shadowing argument or
64481 * function declaration exists, an arguments object will
64482 * definitely not be needed, regardless of whether the identifier
64483 * 'arguments' is referenced inside the function body.
64484 */
64485
64487 DUK_DDD(DUK_DDDPRINT("'arguments' is shadowed by argument or function declaration "
64488 "-> arguments object creation can be skipped"));
64489 comp_ctx->curr_func.is_arguments_shadowed = 1;
64490 }
64491
64492 /*
64493 * Variable declarations.
64494 *
64495 * Unlike function declarations, variable declaration values don't get
64496 * assigned on entry. If a binding of the same name already exists, just
64497 * ignore it silently.
64498 */
64499
64500 for (i = 0; i < num_decls; i += 2) {
64501 duk_int_t decl_type;
64502
64503 duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1); /* decl type */
64504 decl_type = duk_to_int(ctx, -1);
64505 decl_type = decl_type & 0xff;
64506 duk_pop(ctx);
64507
64508 if (decl_type != DUK_DECL_TYPE_VAR) {
64509 continue;
64510 }
64511
64512 duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i); /* decl name */
64513
64514 if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
64515 /* shadowed, ignore */
64516 } else {
64517 duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i); /* decl name */
64518 h_name = duk_get_hstring(ctx, -1);
64519 DUK_ASSERT(h_name != NULL);
64520
64521 if (h_name == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) &&
64522 !comp_ctx->curr_func.is_arguments_shadowed) {
64523 /* E5 Section steps 7-8 */
64524 DUK_DDD(DUK_DDDPRINT("'arguments' not shadowed by a function declaration, "
64525 "but appears as a variable declaration -> treat as "
64526 "a no-op for variable declaration purposes"));
64527 duk_pop(ctx);
64528 continue;
64529 }
64530
64531 /* XXX: spilling */
64532 if (comp_ctx->curr_func.is_function) {
64533 duk_reg_t reg_bind = DUK__ALLOCTEMP(comp_ctx);
64534 /* no need to init reg, it will be undefined on entry */
64535 duk_push_int(ctx, (duk_int_t) reg_bind);
64536 } else {
64537 duk_dup_top(ctx);
64538 rc_name = duk__getconst(comp_ctx);
64539 duk_push_null(ctx);
64540
64541 declvar_flags = DUK_PROPDESC_FLAG_WRITABLE |
64544 if (configurable_bindings) {
64545 declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
64546 }
64547
64548 duk__emit_a_b_c(comp_ctx,
64550 (duk_regconst_t) declvar_flags /*flags*/,
64551 rc_name /*name*/,
64552 (duk_regconst_t) 0 /*value*/);
64553 }
64554
64555 duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* [ ... name reg/null ] -> [ ... ] */
64556 }
64557 }
64558
64559 /*
64560 * Wrap up
64561 */
64562
#define DUK_DECL_TYPE_VAR
#define DUK__SETTEMP_CHECKMAX(comp_ctx, x)
DUK_LOCAL_DECL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg)
#define DUK_DECL_TYPE_FUNC
#define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE
#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)
#define DUK_OP_DECLVAR
DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments(duk_compiler_ctx *comp_ctx, duk_hstring *h)
#define duk_push_uarridx(ctx, val)
#define DUK_BC_DECLVAR_FLAG_FUNC_DECL
#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD(x)
DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx)
DUK_EXTERNAL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_idx)

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 73543 of file duktape-1.5.2/src/duktape.c.

73549 {
73550 /* Call with count == DUK_LEXER_WINDOW_SIZE to fill buffer initially. */
73551 duk__advance_bytes(lex_ctx, DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint)); /* fill window */
73552}

◆ 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 78560 of file duktape-1.5.2/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 78552 of file duktape-1.5.2/src/duktape.c.

78556 :
78558 return NULL; /* never here */

Referenced by duk__match_regexp().

◆ duk__inp_get_prev_cp()

◆ 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 45247 of file duktape-1.5.2/src/duktape.c.

45249 {
45250#if defined(DUK_USE_HEAPPTR16)
45251 if (heap->strtable16[i] != null16 && heap->strtable16[i] != deleted16) {
45252#else
45253 if (heap->strtable[i] != NULL && heap->strtable[i] != DUK__DELETED_MARKER(heap)) {
45254#endif
45255 res++;
45256 }
45257 }
45258 return res;
45259}
45260
45261#if defined(DUK_USE_HEAPPTR16)
45262DUK_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) {
45263#else
45264DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
45265#endif
45266 duk_uint32_t i;
45267 duk_uint32_t step;
45268#if defined(DUK_USE_HEAPPTR16)
45269 duk_uint16_t null16 = heap->heapptr_null16;
45270 duk_uint16_t deleted16 = heap->heapptr_deleted16;
45271#endif
45272
45273 DUK_ASSERT(size > 0);
45274
45277 for (;;) {
45278#if defined(DUK_USE_HEAPPTR16)
45279 duk_uint16_t e16 = entries16[i];
45280#else
45281 duk_hstring *e = entries[i];
45282#endif
45283
45284#if defined(DUK_USE_HEAPPTR16)
45285 /* XXX: could check for e16 == 0 because NULL is guaranteed to
45286 * encode to zero.
45287 */
45288 if (e16 == null16) {
45289#else
45290 if (e == NULL) {
45291#endif
45292 DUK_DDD(DUK_DDDPRINT("insert hit (null): %ld", (long) i));
45293#if defined(DUK_USE_HEAPPTR16)
45294 entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
45295#else
45296 entries[i] = h;
45297#endif
45298 (*p_used)++;
45299 break;
45300#if defined(DUK_USE_HEAPPTR16)
45301 } else if (e16 == deleted16) {
45302#else
45303 } else if (e == DUK__DELETED_MARKER(heap)) {
#define 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 77469 of file duktape-1.5.2/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 59044 of file duktape-1.5.2/src/duktape.c.

59050 {
59051 duk_int_t ret;
59052
59053 ret = duk__get_current_pc(comp_ctx); /* useful for patching jumps later */
59054 duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
59055 return ret;
59056}
59057
59058/* Insert an empty jump in the middle of code emitted earlier. This is
59059 * currently needed for compiling for-in.
59060 */
59062#if defined(DUK_USE_PC2LINE)
59063 duk_int_t line;
59064#endif
59065 duk_compiler_instr *instr;
59066 duk_size_t offset;
59067
59068 offset = jump_pc * sizeof(duk_compiler_instr),
59069 instr = (duk_compiler_instr *) (void *)
59071 &comp_ctx->curr_func.bw_code,
59072 offset,
59073 sizeof(duk_compiler_instr));
59074
DUK_LOCAL_DECL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc)
#define DUK_BW_INSERT_ENSURE_AREA(thr, bw, off, len)

◆ 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 77513 of file duktape-1.5.2/src/duktape.c.

77513 {
77514 DUK_BW_REMOVE_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, data_offset, data_length);
77515}
77516
77517/*
77518 * Insert a jump offset at 'offset' to complete an instruction
77519 * (the jump offset is always the last component of an instruction).
77520 * The 'skip' argument must be computed relative to 'offset',
77521 * -without- taking into account the skip field being inserted.
77522 *
77523 * ... A B C ins X Y Z ... (ins may be a JUMP, SPLIT1/SPLIT2, etc)
77524 * => ... A B C ins SKIP X Y Z
77525 *
77526 * Computing the final (adjusted) skip value, which is relative to the
#define DUK_BW_REMOVE_ENSURE_SLICE(thr, bw, off, len)

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 77488 of file duktape-1.5.2/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 77451 of file duktape-1.5.2/src/duktape.c.

77457 {
77458 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 73581 of file duktape-1.5.2/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 73646 of file duktape-1.5.2/src/duktape.c.

73648 {
73649 t = duk_hex_dectab[x];
73650 if (DUK_LIKELY(t >= 0)) {
73651 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 59301 of file duktape-1.5.2/src/duktape.c.

59304 {
59305 duk_context *ctx = (duk_context *) comp_ctx->thr;
59306
59307 dst->t = src->t;
59308 dst->op = src->op;
59309 dst->x1.t = src->x1.t;
59310 dst->x1.regconst = src->x1.regconst;
59311 dst->x2.t = src->x2.t;
59312 dst->x2.regconst = src->x2.regconst;
59313 duk_copy(ctx, src->x1.valstack_idx, dst->x1.valstack_idx);
59314 duk_copy(ctx, src->x2.valstack_idx, dst->x2.valstack_idx);
59315}
59316
59317/* XXX: to util */
DUK_LOCAL_DECL 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 59584 of file duktape-1.5.2/src/duktape.c.

59585 {
59586 duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
59587 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 59413 of file duktape-1.5.2/src/duktape.c.

59433 {
59434 duk_hthread *thr = comp_ctx->thr;
59435 duk_context *ctx = (duk_context *) thr;
59436
59437 DUK_DDD(DUK_DDDPRINT("duk__ispec_toregconst_raw(): x={%ld:%ld:%!T}, "
59438 "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
59439 (long) x->t,
59440 (long) x->regconst,
59441 (duk_tval *) duk_get_tval(ctx, x->valstack_idx),
59442 (long) forced_reg,
59443 (unsigned long) flags,
59444 (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0),
59445 (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0),
59446 (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0)));
59447
59448 switch (x->t) {
59449 case DUK_ISPEC_VALUE: {
59450 duk_tval *tv;
59451
59452 tv = DUK_GET_TVAL_POSIDX(ctx, x->valstack_idx);
59453 DUK_ASSERT(tv != NULL);
59454
59455 switch (DUK_TVAL_GET_TAG(tv)) {
59456 case DUK_TAG_UNDEFINED: {
59457 /* Note: although there is no 'undefined' literal, undefined
59458 * values can occur during compilation as a result of e.g.
59459 * the 'void' operator.
59460 */
59461 duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
59463 return (duk_regconst_t) dest;
59464 }
59465 case DUK_TAG_NULL: {
59466 duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
59468 return (duk_regconst_t) dest;
59469 }
59470 case DUK_TAG_BOOLEAN: {
59471 duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
59472 duk__emit_extraop_bc(comp_ctx,
59474 (duk_regconst_t) dest);
59475 return (duk_regconst_t) dest;
59476 }
59477 case DUK_TAG_POINTER: {
59479 break;
59480 }
59481 case DUK_TAG_STRING: {
59482 duk_hstring *h;
59483 duk_reg_t dest;
59484 duk_regconst_t constidx;
59485
59486 h = DUK_TVAL_GET_STRING(tv);
59487 DUK_UNREF(h);
59488 DUK_ASSERT(h != NULL);
59489
59490#if 0 /* XXX: to be implemented? */
59491 /* Use special opcodes to load short strings */
59492 if (DUK_HSTRING_GET_BYTELEN(h) <= 2) {
59493 /* Encode into a single opcode (18 bits can encode 1-2 bytes + length indicator) */
59494 } else if (DUK_HSTRING_GET_BYTELEN(h) <= 6) {
59495 /* Encode into a double constant (53 bits can encode 6*8 = 48 bits + 3-bit length */
59496 }
59497#endif
59498 duk_dup(ctx, x->valstack_idx);
59499 constidx = duk__getconst(comp_ctx);
59500
59501 if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
59502 return constidx;
59503 }
59504
59505 dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
59506 duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
59507 return (duk_regconst_t) dest;
59508 }
59509 case DUK_TAG_OBJECT: {
59511 break;
59512 }
59513 case DUK_TAG_BUFFER: {
59515 break;
59516 }
59517 case DUK_TAG_LIGHTFUNC: {
59519 break;
59520 }
59521#if defined(DUK_USE_FASTINT)
59522 case DUK_TAG_FASTINT:
59523#endif
59524 default: {
59525 /* number */
59526 duk_reg_t dest;
59527 duk_regconst_t constidx;
59528 duk_double_t dval;
59529 duk_int32_t ival;
59530
59533 dval = DUK_TVAL_GET_NUMBER(tv);
59534
59535 if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
59536 /* A number can be loaded either through a constant, using
59537 * LDINT, or using LDINT+LDINTX. LDINT is always a size win,
59538 * LDINT+LDINTX is not if the constant is used multiple times.
59539 * Currently always prefer LDINT+LDINTX over a double constant.
59540 */
59541
59542 if (duk__is_whole_get_int32(dval, &ival)) {
59543 dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
59544 duk__emit_load_int32(comp_ctx, dest, ival);
59545 return (duk_regconst_t) dest;
59546 }
59547 }
59548
59549 duk_dup(ctx, x->valstack_idx);
59550 constidx = duk__getconst(comp_ctx);
59551
59552 if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
59553 return constidx;
59554 } else {
59555 dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
59556 duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
59557 return (duk_regconst_t) dest;
59558 }
59559 }
59560 } /* end switch */
59561 }
59562 case DUK_ISPEC_REGCONST: {
59563 if (forced_reg >= 0) {
59564 if (x->regconst & DUK__CONST_MARKER) {
59565 duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, forced_reg, x->regconst);
59566 } else if (x->regconst != (duk_regconst_t) forced_reg) {
59567 duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst);
59568 } else {
59569 ; /* already in correct reg */
59570 }
59571 return (duk_regconst_t) forced_reg;
59572 }
59573
59574 DUK_ASSERT(forced_reg < 0);
59575 if (x->regconst & DUK__CONST_MARKER) {
59576 if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
59577 duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
59579 return (duk_regconst_t) dest;
59580 }
59581 return x->regconst;
59582 }
DUK_LOCAL_DECL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val)
#define DUK_EXTRAOP_LDNULL
#define DUK__IVAL_FLAG_REQUIRE_SHORT
#define DUK_EXTRAOP_LDTRUE
#define DUK_EXTRAOP_LDUNDEF

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 59878 of file duktape-1.5.2/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 59810 of file duktape-1.5.2/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 59815 of file duktape-1.5.2/src/duktape.c.

59815 :
59816 default: {
59817 DUK_D(DUK_DPRINT("invalid ivalue type: %ld", (long) x->t));
59818 break;
59819 }
59820 }
59821
59823 return;
59824}

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 59594 of file duktape-1.5.2/src/duktape.c.

59601 {
59602 DUK_ASSERT(forced_reg >= 0);
59603 (void) duk__ispec_toregconst_raw(comp_ctx, x, forced_reg, 0 /*flags*/);
59604}
59605
59606/* Coerce an duk_ivalue to a 'plain' value by generating the necessary
59607 * arithmetic operations, property access, or variable access bytecode.
59608 * The duk_ivalue argument ('x') is converted into a plain value as a
59609 * side effect.
59610 */
59612 duk_hthread *thr = comp_ctx->thr;
59613 duk_context *ctx = (duk_context *) thr;
59614
59615 DUK_DDD(DUK_DDDPRINT("duk__ivalue_toplain_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, "
59616 "forced_reg=%ld",
59617 (long) x->t, (long) x->op,
59618 (long) x->x1.t, (long) x->x1.regconst,
59619 (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx),
59620 (long) x->x2.t, (long) x->x2.regconst,
59621 (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx),
59622 (long) forced_reg));
59623
59624 switch (x->t) {
59625 case DUK_IVAL_PLAIN: {
59626 return;
59627 }
59628 /* XXX: support unary arithmetic ivalues (useful?) */
59629 case DUK_IVAL_ARITH:
59631 duk_regconst_t arg1;
59632 duk_regconst_t arg2;
59633 duk_reg_t dest;
59634 duk_tval *tv1;
59635 duk_tval *tv2;
59636
59637 DUK_DDD(DUK_DDDPRINT("arith to plain conversion"));
59638
59639 /* inline arithmetic check for constant values */
59640 /* XXX: use the exactly same arithmetic function here as in executor */
59641 if (x->x1.t == DUK_ISPEC_VALUE && x->x2.t == DUK_ISPEC_VALUE && x->t == DUK_IVAL_ARITH) {
59642 tv1 = DUK_GET_TVAL_POSIDX(ctx, x->x1.valstack_idx);
59643 tv2 = DUK_GET_TVAL_POSIDX(ctx, x->x2.valstack_idx);
59644 DUK_ASSERT(tv1 != NULL);
59645 DUK_ASSERT(tv2 != NULL);
59646
59647 DUK_DDD(DUK_DDDPRINT("arith: tv1=%!T, tv2=%!T",
59648 (duk_tval *) tv1,
59649 (duk_tval *) tv2));
59650
59651 if (DUK_TVAL_IS_NUMBER(tv1) && DUK_TVAL_IS_NUMBER(tv2)) {
59654 duk_double_t d3;
59655 duk_bool_t accept = 1;
59656
59657 DUK_DDD(DUK_DDDPRINT("arith inline check: d1=%lf, d2=%lf, op=%ld",
59658 (double) d1, (double) d2, (long) x->op));
59659 switch (x->op) {
59660 case DUK_OP_ADD: d3 = d1 + d2; break;
59661 case DUK_OP_SUB: d3 = d1 - d2; break;
59662 case DUK_OP_MUL: d3 = d1 * d2; break;
59663 case DUK_OP_DIV: d3 = d1 / d2; break;
59664 default: accept = 0; break;
59665 }
59666
59667 if (accept) {
59669 du.d = d3;
59671 d3 = du.d;
59672
59673 x->t = DUK_IVAL_PLAIN;
59675 DUK_TVAL_SET_NUMBER(tv1, d3); /* old value is number: no refcount */
59676 return;
59677 }
59678 } else if (x->op == DUK_OP_ADD && DUK_TVAL_IS_STRING(tv1) && DUK_TVAL_IS_STRING(tv2)) {
59679 /* inline string concatenation */
59680 duk_dup(ctx, x->x1.valstack_idx);
59681 duk_dup(ctx, x->x2.valstack_idx);
59682 duk_concat(ctx, 2);
59683 duk_replace(ctx, x->x1.valstack_idx);
59684 x->t = DUK_IVAL_PLAIN;
59686 return;
59687 }
59688 }
59689
59692
59693 /* If forced reg, use it as destination. Otherwise try to
59694 * use either coerced ispec if it is a temporary.
59695 *
59696 * When using extraops, avoid reusing arg2 as dest because that
59697 * would lead to an LDREG shuffle below. We still can't guarantee
59698 * dest != arg2 because we may have a forced_reg.
59699 */
59700 if (forced_reg >= 0) {
59701 dest = forced_reg;
59702 } else if (DUK__ISTEMP(comp_ctx, arg1)) {
59703 dest = (duk_reg_t) arg1;
59704 } else if (DUK__ISTEMP(comp_ctx, arg2) && x->t != DUK_IVAL_ARITH_EXTRAOP) {
59705 dest = (duk_reg_t) arg2;
59706 } else {
59707 dest = DUK__ALLOCTEMP(comp_ctx);
59708 }
59709
59710 /* Extraop arithmetic opcodes must have destination same as
59711 * first source. If second source matches destination we need
59712 * a temporary register to avoid clobbering the second source.
59713 *
59714 * XXX: change calling code to avoid this situation in most cases.
59715 */
59716
59717 if (x->t == DUK_IVAL_ARITH_EXTRAOP) {
59718 if (!(DUK__ISREG(comp_ctx, arg1) && (duk_reg_t) arg1 == dest)) {
59719 if (DUK__ISREG(comp_ctx, arg2) && (duk_reg_t) arg2 == dest) {
59720 /* arg2 would be clobbered so reassign it to a temp. */
59721 duk_reg_t tempreg;
59722 tempreg = DUK__ALLOCTEMP(comp_ctx);
59723 duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, tempreg, arg2);
59724 arg2 = tempreg;
59725 }
59726
59727 if (DUK__ISREG(comp_ctx, arg1)) {
59728 duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, dest, arg1);
59729 } else {
59730 DUK_ASSERT(DUK__ISCONST(comp_ctx, arg1));
59731 duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, dest, arg1);
59732 }
59733 }
59734
59735 /* Note: special DUK__EMIT_FLAG_B_IS_TARGETSOURCE
59736 * used to indicate that B is both a source and a
59737 * target register. When shuffled, it needs to be
59738 * both input and output shuffled.
59739 */
59740 DUK_ASSERT(DUK__ISREG(comp_ctx, dest));
59741 duk__emit_extraop_b_c(comp_ctx,
59744 (duk_regconst_t) dest,
59745 (duk_regconst_t) arg2);
59746
59747 } else {
59748 DUK_ASSERT(DUK__ISREG(comp_ctx, dest));
59749 duk__emit_a_b_c(comp_ctx, x->op, (duk_regconst_t) dest, arg1, arg2);
59750 }
59751
59752 x->t = DUK_IVAL_PLAIN;
59753 x->x1.t = DUK_ISPEC_REGCONST;
59754 x->x1.regconst = (duk_regconst_t) dest;
59755 return;
59756 }
59757 case DUK_IVAL_PROP: {
59758 /* XXX: very similar to DUK_IVAL_ARITH - merge? */
59759 duk_regconst_t arg1;
59760 duk_regconst_t arg2;
59761 duk_reg_t dest;
59762
59763 /* Need a short reg/const, does not have to be a mutable temp. */
59766
59767 /* Pick a destination register. If either base value or key
59768 * happens to be a temp value, reuse it as the destination.
59769 *
59770 * XXX: The temp must be a "mutable" one, i.e. such that no
59771 * other expression is using it anymore. Here this should be
59772 * the case because the value of a property access expression
59773 * is neither the base nor the key, but the lookup result.
59774 */
59775
59776 if (forced_reg >= 0) {
59777 dest = forced_reg;
59778 } else if (DUK__ISTEMP(comp_ctx, arg1)) {
59779 dest = (duk_reg_t) arg1;
59780 } else if (DUK__ISTEMP(comp_ctx, arg2)) {
59781 dest = (duk_reg_t) arg2;
59782 } else {
59783 dest = DUK__ALLOCTEMP(comp_ctx);
59784 }
59785
59786 duk__emit_a_b_c(comp_ctx, DUK_OP_GETPROP, (duk_regconst_t) dest, arg1, arg2);
59787
59788 x->t = DUK_IVAL_PLAIN;
59789 x->x1.t = DUK_ISPEC_REGCONST;
59790 x->x1.regconst = (duk_regconst_t) dest;
59791 return;
59792 }
59793 case DUK_IVAL_VAR: {
59794 /* x1 must be a string */
59795 duk_reg_t dest;
59796 duk_reg_t reg_varbind;
59797 duk_regconst_t rc_varname;
59798
59800
59801 duk_dup(ctx, x->x1.valstack_idx);
59802 if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
59803 x->t = DUK_IVAL_PLAIN;
59804 x->x1.t = DUK_ISPEC_REGCONST;
59805 x->x1.regconst = (duk_regconst_t) reg_varbind;
59806 } else {
59807 dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
DUK_EXTERNAL void duk_concat(duk_context *ctx, duk_idx_t count)
duk_int32_t duk_reg_t
#define DUK__ISREG(comp_ctx, x)
DUK_LOCAL_DECL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg)
#define DUK__ISCONST(comp_ctx, x)

◆ duk__ivalue_toreg()

DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg ( duk_compiler_ctx * comp_ctx,
duk_ivalue * x )

Definition at line 59868 of file duktape-1.5.2/src/duktape.c.

59869 : 0),
59870 (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 59883 of file duktape-1.5.2/src/duktape.c.

59885 {

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 59833 of file duktape-1.5.2/src/duktape.c.

59853 {
59854 duk_hthread *thr = comp_ctx->thr;
59855 duk_context *ctx = (duk_context *) thr;
59856 duk_regconst_t reg;
59857 DUK_UNREF(thr);
59858 DUK_UNREF(ctx);
59859
59860 DUK_DDD(DUK_DDDPRINT("duk__ivalue_toregconst_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, "
59861 "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
59862 (long) x->t, (long) x->op,
59863 (long) x->x1.t, (long) x->x1.regconst,
59864 (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx),
59865 (long) x->x2.t, (long) x->x2.regconst,
59866 (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 59887 of file duktape-1.5.2/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 65147 of file duktape-1.5.2/src/duktape.c.

65164 {
65165 duk_hthread *thr = (duk_hthread *) ctx;
65166 duk_hstring *h_filename;
65167 duk__compiler_stkstate *comp_stk;
65168 duk_compiler_ctx *comp_ctx;
65169 duk_lexer_point *lex_pt;
65170 duk_compiler_func *func;
65171 duk_idx_t entry_top;
65172 duk_bool_t is_strict;
65173 duk_bool_t is_eval;
65174 duk_bool_t is_funcexpr;
65175 duk_small_uint_t flags;
65176
65177 DUK_ASSERT(thr != NULL);
65178
65179 /*
65180 * Arguments check
65181 */
65182
65183 entry_top = duk_get_top(ctx);
65184 DUK_ASSERT(entry_top >= 2);
65185
65186 comp_stk = (duk__compiler_stkstate *) duk_require_pointer(ctx, -1);
65187 comp_ctx = &comp_stk->comp_ctx_alloc;
65188 lex_pt = &comp_stk->lex_pt_alloc;
65189 DUK_ASSERT(comp_ctx != NULL);
65190 DUK_ASSERT(lex_pt != NULL);
65191
65192 flags = comp_stk->flags;
65193 is_eval = (flags & DUK_JS_COMPILE_FLAG_EVAL ? 1 : 0);
65194 is_strict = (flags & DUK_JS_COMPILE_FLAG_STRICT ? 1 : 0);
65195 is_funcexpr = (flags & DUK_JS_COMPILE_FLAG_FUNCEXPR ? 1 : 0);
65196
65197 h_filename = duk_get_hstring(ctx, -2); /* may be undefined */
65198
65199 /*
65200 * Init compiler and lexer contexts
65201 */
65202
65203 func = &comp_ctx->curr_func;
65204#ifdef DUK_USE_EXPLICIT_NULL_INIT
65205 comp_ctx->thr = NULL;
65206 comp_ctx->h_filename = NULL;
65207 comp_ctx->prev_token.str1 = NULL;
65208 comp_ctx->prev_token.str2 = NULL;
65209 comp_ctx->curr_token.str1 = NULL;
65210 comp_ctx->curr_token.str2 = NULL;
65211#endif
65212
65214
65215 duk_push_dynamic_buffer(ctx, 0); /* entry_top + 0 */
65216 duk_push_undefined(ctx); /* entry_top + 1 */
65217 duk_push_undefined(ctx); /* entry_top + 2 */
65218 duk_push_undefined(ctx); /* entry_top + 3 */
65219 duk_push_undefined(ctx); /* entry_top + 4 */
65220
65221 comp_ctx->thr = thr;
65222 comp_ctx->h_filename = h_filename;
65223 comp_ctx->tok11_idx = entry_top + 1;
65224 comp_ctx->tok12_idx = entry_top + 2;
65225 comp_ctx->tok21_idx = entry_top + 3;
65226 comp_ctx->tok22_idx = entry_top + 4;
65228
65229 /* comp_ctx->lex has been pre-initialized by caller: it has been
65230 * zeroed and input/input_length has been set.
65231 */
65232 comp_ctx->lex.thr = thr;
65233 /* comp_ctx->lex.input and comp_ctx->lex.input_length filled by caller */
65234 comp_ctx->lex.slot1_idx = comp_ctx->tok11_idx;
65235 comp_ctx->lex.slot2_idx = comp_ctx->tok12_idx;
65236 comp_ctx->lex.buf_idx = entry_top + 0;
65237 comp_ctx->lex.buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0);
65238 DUK_ASSERT(comp_ctx->lex.buf != NULL);
65241
65242 lex_pt->offset = 0;
65243 lex_pt->line = 1;
65244 DUK_LEXER_SETPOINT(&comp_ctx->lex, lex_pt); /* fills window */
65245 comp_ctx->curr_token.start_line = 0; /* needed for line number tracking (becomes prev_token.start_line) */
65246
65247 /*
65248 * Initialize function state for a zero-argument function
65249 */
65250
65252 DUK_ASSERT(func->num_formals == 0);
65253
65254 if (is_funcexpr) {
65255 /* Name will be filled from function expression, not by caller.
65256 * This case is used by Function constructor and duk_compile()
65257 * API with the DUK_COMPILE_FUNCTION option.
65258 */
65259 DUK_ASSERT(func->h_name == NULL);
65260 } else {
65263 func->h_name = duk_get_hstring(ctx, -1);
65264 }
65265
65266 /*
65267 * Parse a function body or a function-like expression, depending
65268 * on flags.
65269 */
65270
65271 func->is_strict = is_strict;
65272 func->is_setget = 0;
65273 func->is_decl = 0;
65274
65275 if (is_funcexpr) {
65276 func->is_function = 1;
65277 func->is_eval = 0;
65278 func->is_global = 0;
65279
65280 duk__advance(comp_ctx); /* init 'curr_token' */
65282 (void) duk__parse_func_like_raw(comp_ctx,
65283 0, /* is_decl */
65284 0); /* is_setget */
65285 } else {
65286 func->is_function = 0;
65287 func->is_eval = is_eval;
65288 func->is_global = !is_eval;
65289
65290 duk__parse_func_body(comp_ctx,
65291 1, /* expect_eof */
65292 1, /* implicit_return_value */
#define duk_push_dynamic_buffer(ctx, size)
#define DUK_STRIDX_GLOBAL
DUK_LOCAL_DECL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget)
#define DUK_COMPILER_TOKEN_LIMIT
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)
#define DUK_LEXER_SETPOINT(ctx, pt)
#define DUK__COMPILE_ENTRY_SLOTS
#define DUK_HBUFFER_HAS_EXTERNAL(x)
#define DUK_HBUFFER_HAS_DYNAMIC(x)

◆ duk__js_equals_number()

DUK_LOCAL duk_bool_t duk__js_equals_number ( duk_double_t x,
duk_double_t y )

Definition at line 70278 of file duktape-1.5.2/src/duktape.c.

70281 :
70282 *
70283 * - Current implementation (and spec definition) has recursion; this should
70284 * be fixed if possible.
70285 *
70286 * - String-to-number coercion should be possible without going through the
70287 * value stack (and be more compact) if a shared helper is invoked.
70288 */
70289
70290/* Note that this is the same operation for strict and loose equality:
70291 * - E5 Section 11.9.3, step 1.c (loose)
70292 * - E5 Section 11.9.6, step 4 (strict)
70293 */
70294
70296#if defined(DUK_USE_PARANOID_MATH)
70297 /* Straightforward algorithm, makes fewer compiler assumptions. */
70300 if (cx == DUK_FP_NAN || cy == DUK_FP_NAN) {
70301 return 0;
70302 }
70303 if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
70304 return 1;
70305 }
70306 if (x == y) {
70307 return 1;
70308 }
70309 return 0;
70310#else /* DUK_USE_PARANOID_MATH */
70311 /* Better equivalent algorithm. If the compiler is compliant, C and
70312 * Ecmascript semantics are identical for this particular comparison.
70313 * In particular, NaNs must never compare equal and zeroes must compare
70314 * equal regardless of sign. Could also use a macro, but this inlines
DUK_LOCAL duk_bool_t duk__js_equals_number(duk_double_t x, duk_double_t y)

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 67461 of file duktape-1.5.2/src/duktape.c.

67461 {
67462 DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception"));
67463 DUK_UNREF(exc);
67465 entry_thread,
67466 entry_callstack_top,
67467 entry_call_recursion_depth,
67468 entry_jmpbuf_ptr);
67469 }
67470 }
67471#endif
67472 }
67473
67475}
67476
67477/* Inner executor, performance critical. */
67478DUK_LOCAL DUK_NOINLINE void duk__js_execute_bytecode_inner(duk_hthread *entry_thread, duk_size_t entry_callstack_top) {
67479 /* Current PC, accessed by other functions through thr->ptr_to_curr_pc.
67480 * Critical for performance. It would be safest to make this volatile,
67481 * but that eliminates performance benefits; aliasing guarantees
67482 * should be enough though.
67483 */
67484 duk_instr_t *curr_pc; /* bytecode has a stable pointer */
67485
67486 /* Hot variables for interpretation. Critical for performance,
67487 * but must add sparingly to minimize register shuffling.
67488 */
67489 duk_hthread *thr; /* stable */
67490 duk_tval *consts; /* stable */
67491 duk_tval *consts2; /* stable; precalculated for faster lookups */
67493 /* 'funcs' is quite rarely used, so no local for it */
67494#if defined(DUK_USE_EXEC_FUN_LOCAL)
67496#else
67497 /* 'fun' is quite rarely used, so no local for it */
67498#endif
67499
67500#ifdef DUK_USE_INTERRUPT_COUNTER
67501 duk_int_t int_ctr;
67502#endif
67503
67504#ifdef DUK_USE_ASSERTIONS
67505 duk_size_t valstack_top_base; /* valstack top, should match before interpreting each op (no leftovers) */
67506#endif
67507
67508 /*
67509 * Restart execution by reloading thread state.
67510 *
67511 * Note that 'thr' and any thread configuration may have changed,
67512 * so all local variables are suspect and we need to reinitialize.
67513 *
67514 * The number of local variables should be kept to a minimum: if
67515 * the variables are spilled, they will need to be loaded from
67516 * memory anyway.
67517 *
67518 * Any 'goto restart_execution;' code path in opcode dispatch must
67519 * ensure 'curr_pc' is synced back to act->curr_pc before the goto
67520 * takes place.
67521 *
67522 * The interpreter must be very careful with memory pointers, as
67523 * many pointers are not guaranteed to be 'stable' and may be
67524 * reallocated and relocated on-the-fly quite easily (e.g. by a
67525 * memory allocation or a property access).
67526 *
67527 * The following are assumed to have stable pointers:
67528 * - the current thread
67529 * - the current function
67530 * - the bytecode, constant table, inner function table of the
67531 * current function (as they are a part of the function allocation)
67532 *
67533 * The following are assumed to have semi-stable pointers:
67534 * - the current activation entry: stable as long as callstack
67535 * is not changed (reallocated by growing or shrinking), or
67536 * by any garbage collection invocation (through finalizers)
67537 * - Note in particular that ANY DECREF can invalidate the
67538 * activation pointer, so for the most part a fresh lookup
67539 * is required
67540 *
67541 * The following are not assumed to have stable pointers at all:
67542 * - the value stack (registers) of the current thread
67543 * - the catch stack of the current thread
67544 *
67545 * See execution.rst for discussion.
67546 */
67547
67548 restart_execution:
67549
67550 /* Lookup current thread; use the stable 'entry_thread' for this to
67551 * avoid clobber warnings. Any valid, reachable 'thr' value would be
67552 * fine for this, so using 'entry_thread' is just to silence warnings.
67553 */
67554 thr = entry_thread->heap->curr_thread;
67555 DUK_ASSERT(thr != NULL);
67556 DUK_ASSERT(thr->callstack_top >= 1);
67559
67560 thr->ptr_curr_pc = &curr_pc;
67561
67562 /* Relookup and initialize dispatch loop variables. Debugger check. */
67563 {
67564 duk_activation *act;
67565#if !defined(DUK_USE_EXEC_FUN_LOCAL)
67567#endif
67568
67569 /* Assume interrupt init/counter are properly initialized here. */
67570 /* Assume that thr->valstack_bottom has been set-up before getting here. */
67571
67572 act = thr->callstack + thr->callstack_top - 1;
67574 DUK_ASSERT(fun != NULL);
67575 DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs);
67576 consts = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun);
67577 DUK_ASSERT(consts != NULL);
67578 consts2 = consts - DUK_BC_REGLIMIT;
67579
67580#if defined(DUK_USE_DEBUGGER_SUPPORT)
67581 if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && !thr->heap->dbg_processing) {
67582 duk__executor_recheck_debugger(thr, act, fun);
67583 act = thr->callstack + thr->callstack_top - 1; /* relookup after side effects (no side effects currently however) */
67584 }
67585#endif /* DUK_USE_DEBUGGER_SUPPORT */
67586
67587#ifdef DUK_USE_ASSERTIONS
67588 valstack_top_base = (duk_size_t) (thr->valstack_top - thr->valstack);
67589#endif
67590
67591 /* Set up curr_pc for opcode dispatch. */
67592 curr_pc = act->curr_pc;
67593 }
67594
67595 DUK_DD(DUK_DDPRINT("restarting execution, thr %p, act idx %ld, fun %p,"
67596 "consts %p, funcs %p, lev %ld, regbot %ld, regtop %ld, catchstack_top=%ld, "
67597 "preventcount=%ld",
67598 (void *) thr,
67599 (long) (thr->callstack_top - 1),
67600 (void *) DUK__FUN(),
67601 (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, DUK__FUN()),
67602 (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, DUK__FUN()),
67603 (long) (thr->callstack_top - 1),
67604 (long) (thr->valstack_bottom - thr->valstack),
67605 (long) (thr->valstack_top - thr->valstack),
67606 (long) thr->catchstack_top,
67607 (long) thr->callstack_preventcount));
67608
67609 /* Dispatch loop. */
67610
67611 for (;;) {
67612 DUK_ASSERT(thr->callstack_top >= 1);
67613 DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == DUK__FUN()->nregs);
67614 DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) == valstack_top_base);
67615
67616 /* Executor interrupt counter check, used to implement breakpoints,
67617 * debugging interface, execution timeouts, etc. The counter is heap
67618 * specific but is maintained in the current thread to make the check
67619 * as fast as possible. The counter is copied back to the heap struct
67620 * whenever a thread switch occurs by the DUK_HEAP_SWITCH_THREAD() macro.
67621 */
67622#if defined(DUK_USE_INTERRUPT_COUNTER)
67623 int_ctr = thr->interrupt_counter;
67624 if (DUK_LIKELY(int_ctr > 0)) {
67625 thr->interrupt_counter = int_ctr - 1;
67626 } else {
67627 /* Trigger at zero or below */
67628 duk_small_uint_t exec_int_ret;
67629
67630 /* Write curr_pc back for the debugger. */
67631 DUK_ASSERT(thr->callstack_top > 0);
67632 {
67633 duk_activation *act;
67634 act = thr->callstack + thr->callstack_top - 1;
67635 act->curr_pc = (duk_instr_t *) curr_pc;
67636 }
67637
67638 /* Force restart caused by a function return; must recheck
67639 * debugger breakpoints before checking line transitions,
67640 * see GH-303. Restart and then handle interrupt_counter
67641 * zero again.
67642 */
67643#if defined(DUK_USE_DEBUGGER_SUPPORT)
67644 if (thr->heap->dbg_force_restart) {
67645 DUK_DD(DUK_DDPRINT("dbg_force_restart flag forced restart execution")); /* GH-303 */
67646 thr->heap->dbg_force_restart = 0;
67647 goto restart_execution;
67648 }
67649#endif
67650
67651 exec_int_ret = duk__executor_interrupt(thr);
67652 if (exec_int_ret == DUK__INT_RESTART) {
67653 /* curr_pc synced back above */
67654 goto restart_execution;
67655 }
67656 }
67657#endif /* DUK_USE_INTERRUPT_COUNTER */
67658#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG)
67659 /* For cross-checking during development: ensure dispatch count
67660 * matches cumulative interrupt counter init value sums.
67661 */
67662 thr->heap->inst_count_exec++;
67663#endif
67664
67665#if defined(DUK_USE_ASSERTIONS) || defined(DUK_USE_DEBUG)
67666 {
67667 duk_activation *act;
67668 act = thr->callstack + thr->callstack_top - 1;
67671 DUK_UNREF(act); /* if debugging disabled */
67672
67673 DUK_DDD(DUK_DDDPRINT("executing bytecode: pc=%ld, ins=0x%08lx, op=%ld, valstack_top=%ld/%ld, nregs=%ld --> %!I",
67674 (long) (curr_pc - DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, DUK__FUN())),
67675 (unsigned long) *curr_pc,
67676 (long) DUK_DEC_OP(*curr_pc),
67677 (long) (thr->valstack_top - thr->valstack),
67678 (long) (thr->valstack_end - thr->valstack),
67679 (long) (DUK__FUN() ? DUK__FUN()->nregs : -1),
67680 (duk_instr_t) *curr_pc));
67681 }
67682#endif
67683
67684#if defined(DUK_USE_ASSERTIONS)
67685 /* Quite heavy assert: check valstack policy. Improper
67686 * shuffle instructions can write beyond valstack_top/end
67687 * so this check catches them in the act.
67688 */
67689 {
67690 duk_tval *tv;
67691 tv = thr->valstack_top;
67692 while (tv != thr->valstack_end) {
67694 tv++;
67695 }
67696 }
67697#endif
67698
67699 ins = *curr_pc++;
67700
67701 /* Typing: use duk_small_(u)int_fast_t when decoding small
67702 * opcode fields (op, A, B, C) and duk_(u)int_fast_t when
67703 * decoding larger fields (e.g. BC which is 18 bits). Use
67704 * unsigned variant by default, signed when the value is used
67705 * in signed arithmetic. Using variable names such as 'a', 'b',
67706 * 'c', 'bc', etc makes it easier to spot typing mismatches.
67707 */
67708
67709 /* XXX: the best typing needs to be validated by perf measurement:
67710 * e.g. using a small type which is the cast to a larger duk_idx_t
67711 * may be slower than declaring the variable as a duk_idx_t in the
67712 * first place.
67713 */
67714
67715 /* XXX: use macros for the repetitive tval/refcount handling. */
67716
67717 switch ((int) DUK_DEC_OP(ins)) {
67718 /* XXX: switch cast? */
67719
67720 case DUK_OP_LDREG: {
67722 duk_uint_fast_t bc;
67723 duk_tval *tv1, *tv2;
67724
67725 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67726 bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc);
67727 DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2); /* side effects */
67728 break;
67729 }
67730
67731 case DUK_OP_STREG: {
67733 duk_uint_fast_t bc;
67734 duk_tval *tv1, *tv2;
67735
67736 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67737 bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc);
67738 DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv2, tv1); /* side effects */
67739 break;
67740 }
67741
67742 case DUK_OP_LDCONST: {
67744 duk_uint_fast_t bc;
67745 duk_tval *tv1, *tv2;
67746
67747 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67748 bc = DUK_DEC_BC(ins); tv2 = DUK__CONSTP(bc);
67749 DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2); /* side effects */
67750 break;
67751 }
67752
67753 case DUK_OP_LDINT: {
67755 duk_int_fast_t bc;
67756 duk_tval *tv1;
67757#if defined(DUK_USE_FASTINT)
67758 duk_int32_t val;
67759#else
67760 duk_double_t val;
67761#endif
67762
67763#if defined(DUK_USE_FASTINT)
67764 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67765 bc = DUK_DEC_BC(ins); val = (duk_int32_t) (bc - DUK_BC_LDINT_BIAS);
67766 DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv1, val); /* side effects */
67767#else
67768 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67769 bc = DUK_DEC_BC(ins); val = (duk_double_t) (bc - DUK_BC_LDINT_BIAS);
67770 DUK_TVAL_SET_NUMBER_UPDREF(thr, tv1, val); /* side effects */
67771#endif
67772 break;
67773 }
67774
67775 case DUK_OP_LDINTX: {
67777 duk_tval *tv1;
67778 duk_double_t val;
67779
67780 /* LDINTX is not necessarily in FASTINT range, so
67781 * no fast path for now.
67782 *
67783 * XXX: perhaps restrict LDINTX to fastint range, wider
67784 * range very rarely needed.
67785 */
67786
67787 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67789 val = DUK_TVAL_GET_NUMBER(tv1) * ((duk_double_t) (1L << DUK_BC_LDINTX_SHIFT)) +
67790 (duk_double_t) DUK_DEC_BC(ins);
67791#if defined(DUK_USE_FASTINT)
67793#else
67794 DUK_TVAL_SET_NUMBER(tv1, val);
67795#endif
67796 break;
67797 }
67798
67799 case DUK_OP_MPUTOBJ:
67800 case DUK_OP_MPUTOBJI: {
67801 duk_context *ctx = (duk_context *) thr;
67803 duk_tval *tv1;
67804 duk_hobject *obj;
67805 duk_uint_fast_t idx;
67807
67808 /* A -> register of target object
67809 * B -> first register of key/value pair list
67810 * C -> number of key/value pairs
67811 */
67812
67813 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67815 obj = DUK_TVAL_GET_OBJECT(tv1);
67816
67817 idx = (duk_uint_fast_t) DUK_DEC_B(ins);
67818 if (DUK_DEC_OP(ins) == DUK_OP_MPUTOBJI) {
67819 duk_tval *tv_ind = DUK__REGP(idx);
67821 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
67822 }
67823
67824 count = (duk_small_uint_fast_t) DUK_DEC_C(ins);
67825
67826#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
67827 if (DUK_UNLIKELY(idx + count * 2 > (duk_uint_fast_t) duk_get_top(ctx))) {
67828 /* XXX: use duk_is_valid_index() instead? */
67829 /* XXX: improve check; check against nregs, not against top */
67830 DUK__INTERNAL_ERROR("MPUTOBJ out of bounds");
67831 }
67832#endif
67833
67834 duk_push_hobject(ctx, obj);
67835
67836 while (count > 0) {
67837 /* XXX: faster initialization (direct access or better primitives) */
67838
67839 duk_push_tval(ctx, DUK__REGP(idx));
67840 DUK_ASSERT(duk_is_string(ctx, -1));
67841 duk_push_tval(ctx, DUK__REGP(idx + 1)); /* -> [... obj key value] */
67842 duk_xdef_prop_wec(ctx, -3); /* -> [... obj] */
67843
67844 count--;
67845 idx += 2;
67846 }
67847
67848 duk_pop(ctx); /* [... obj] -> [...] */
67849 break;
67850 }
67851
67852 case DUK_OP_MPUTARR:
67853 case DUK_OP_MPUTARRI: {
67854 duk_context *ctx = (duk_context *) thr;
67856 duk_tval *tv1;
67857 duk_hobject *obj;
67858 duk_uint_fast_t idx;
67860 duk_uint32_t arr_idx;
67861
67862 /* A -> register of target object
67863 * B -> first register of value data (start_index, value1, value2, ..., valueN)
67864 * C -> number of key/value pairs (N)
67865 */
67866
67867 a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
67869 obj = DUK_TVAL_GET_OBJECT(tv1);
67870 DUK_ASSERT(obj != NULL);
67871
67872 idx = (duk_uint_fast_t) DUK_DEC_B(ins);
67873 if (DUK_DEC_OP(ins) == DUK_OP_MPUTARRI) {
67874 duk_tval *tv_ind = DUK__REGP(idx);
67876 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
67877 }
67878
67879 count = (duk_small_uint_fast_t) DUK_DEC_C(ins);
67880
67881#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
67882 if (idx + count + 1 > (duk_uint_fast_t) duk_get_top(ctx)) {
67883 /* XXX: use duk_is_valid_index() instead? */
67884 /* XXX: improve check; check against nregs, not against top */
67885 DUK__INTERNAL_ERROR("MPUTARR out of bounds");
67886 }
67887#endif
67888
67889 tv1 = DUK__REGP(idx);
67891 arr_idx = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1);
67892 idx++;
67893
67894 duk_push_hobject(ctx, obj);
67895
67896 while (count > 0) {
67897 /* duk_xdef_prop() will define an own property without any array
67898 * special behaviors. We'll need to set the array length explicitly
67899 * in the end. For arrays with elisions, the compiler will emit an
67900 * explicit SETALEN which will update the length.
67901 */
67902
67903 /* XXX: because we're dealing with 'own' properties of a fresh array,
67904 * the array initializer should just ensure that the array has a large
67905 * enough array part and write the values directly into array part,
67906 * and finally set 'length' manually in the end (as already happens now).
67907 */
67908
67909 duk_push_tval(ctx, DUK__REGP(idx)); /* -> [... obj value] */
67910 duk_xdef_prop_index_wec(ctx, -2, arr_idx); /* -> [... obj] */
67911
67912 /* XXX: could use at least one fewer loop counters */
67913 count--;
67914 idx++;
67915 arr_idx++;
67916 }
67917
67918 /* XXX: E5.1 Section 11.1.4 coerces the final length through
67919 * ToUint32() which is odd but happens now as a side effect of
67920 * 'arr_idx' type.
67921 */
67922 duk_hobject_set_length(thr, obj, (duk_uint32_t) arr_idx);
67923
67924 duk_pop(ctx); /* [... obj] -> [...] */
67925 break;
67926 }
67927
67928 case DUK_OP_NEW:
67929 case DUK_OP_NEWI: {
67930 duk_context *ctx = (duk_context *) thr;
67932 duk_uint_fast_t idx;
67934
67935 /* A -> unused (reserved for flags, for consistency with DUK_OP_CALL)
67936 * B -> target register and start reg: constructor, arg1, ..., argN
67937 * (for DUK_OP_NEWI, 'b' is indirect)
67938 * C -> num args (N)
67939 */
67940
67941 /* duk_new() will call the constuctor using duk_handle_call().
67942 * A constructor call prevents a yield from inside the constructor,
67943 * even if the constructor is an Ecmascript function.
67944 */
67945
67946 /* Don't need to sync curr_pc here; duk_new() will do that
67947 * when it augments the created error.
67948 */
67949
67950 /* XXX: unnecessary copying of values? Just set 'top' to
67951 * b + c, and let the return handling fix up the stack frame?
67952 */
67953
67954 idx = (duk_uint_fast_t) DUK_DEC_B(ins);
67955 if (DUK_DEC_OP(ins) == DUK_OP_NEWI) {
67956 duk_tval *tv_ind = DUK__REGP(idx);
67958 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
67959 }
67960
67961#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
67962 if (idx + c + 1 > (duk_uint_fast_t) duk_get_top(ctx)) {
67963 /* XXX: use duk_is_valid_index() instead? */
67964 /* XXX: improve check; check against nregs, not against top */
67965 DUK__INTERNAL_ERROR("NEW out of bounds");
67966 }
67967#endif
67968
67969 duk_require_stack(ctx, (duk_idx_t) c);
67970 duk_push_tval(ctx, DUK__REGP(idx));
67971 for (i = 0; i < c; i++) {
67972 duk_push_tval(ctx, DUK__REGP(idx + i + 1));
67973 }
67974 duk_new(ctx, (duk_idx_t) c); /* [... constructor arg1 ... argN] -> [retval] */
67975 DUK_DDD(DUK_DDDPRINT("NEW -> %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
67976 duk_replace(ctx, (duk_idx_t) idx);
67977
67978 /* When debugger is enabled, we need to recheck the activation
67979 * status after returning. This is now handled by call handling
67980 * and heap->dbg_force_restart.
67981 */
67982 break;
67983 }
67984
67985 case DUK_OP_REGEXP: {
67986#ifdef DUK_USE_REGEXP_SUPPORT
67987 duk_context *ctx = (duk_context *) thr;
67991
67992 /* A -> target register
67993 * B -> bytecode (also contains flags)
67994 * C -> escaped source
67995 */
67996
67998 duk_push_tval(ctx, DUK__REGCONSTP(b)); /* -> [ ... escaped_source bytecode ] */
67999 duk_regexp_create_instance(thr); /* -> [ ... regexp_instance ] */
68000 DUK_DDD(DUK_DDDPRINT("regexp instance: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
68001 duk_replace(ctx, (duk_idx_t) a);
68002#else
68003 /* The compiler should never emit DUK_OP_REGEXP if there is no
68004 * regexp support.
68005 */
68006 DUK__INTERNAL_ERROR("no regexp support");
68007#endif
68008
68009 break;
68010 }
68011
68012 case DUK_OP_CSREG:
68013 case DUK_OP_CSREGI: {
68014 /*
68015 * Assuming a register binds to a variable declared within this
68016 * function (a declarative binding), the 'this' for the call
68017 * setup is always 'undefined'. E5 Section 10.2.1.1.6.
68018 */
68019
68020 duk_context *ctx = (duk_context *) thr;
68021 duk_small_uint_fast_t b = DUK_DEC_B(ins); /* restricted to regs */
68022 duk_uint_fast_t idx;
68023
68024 /* A -> target register (A, A+1) for call setup
68025 * (for DUK_OP_CSREGI, 'a' is indirect)
68026 * B -> register containing target function (not type checked here)
68027 */
68028
68029 /* XXX: direct manipulation, or duk_replace_tval() */
68030
68031 /* Note: target registers a and a+1 may overlap with DUK__REGP(b).
68032 * Careful here.
68033 */
68034
68035 idx = (duk_uint_fast_t) DUK_DEC_A(ins);
68036 if (DUK_DEC_OP(ins) == DUK_OP_CSREGI) {
68037 duk_tval *tv_ind = DUK__REGP(idx);
68039 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
68040 }
68041
68042#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
68043 if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
68044 /* XXX: use duk_is_valid_index() instead? */
68045 /* XXX: improve check; check against nregs, not against top */
68046 DUK__INTERNAL_ERROR("CSREG out of bounds");
68047 }
68048#endif
68049
68050 duk_push_tval(ctx, DUK__REGP(b));
68051 duk_replace(ctx, (duk_idx_t) idx);
68052 duk_push_undefined(ctx);
68053 duk_replace(ctx, (duk_idx_t) (idx + 1));
68054 break;
68055 }
68056
68057 case DUK_OP_GETVAR: {
68058 duk_context *ctx = (duk_context *) thr;
68059 duk_activation *act;
68061 duk_uint_fast_t bc = DUK_DEC_BC(ins);
68062 duk_tval *tv1;
68064
68065 tv1 = DUK__CONSTP(bc);
68068 DUK_ASSERT(name != NULL);
68069 DUK_DDD(DUK_DDDPRINT("GETVAR: '%!O'", (duk_heaphdr *) name));
68070 act = thr->callstack + thr->callstack_top - 1;
68071 (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */
68072
68073 duk_pop(ctx); /* 'this' binding is not needed here */
68074 duk_replace(ctx, (duk_idx_t) a);
68075 break;
68076 }
68077
68078 case DUK_OP_PUTVAR: {
68079 duk_activation *act;
68081 duk_uint_fast_t bc = DUK_DEC_BC(ins);
68082 duk_tval *tv1;
68084
68085 tv1 = DUK__CONSTP(bc);
68088 DUK_ASSERT(name != NULL);
68089
68090 /* XXX: putvar takes a duk_tval pointer, which is awkward and
68091 * should be reworked.
68092 */
68093
68094 tv1 = DUK__REGP(a); /* val */
68095 act = thr->callstack + thr->callstack_top - 1;
68096 duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
68097 break;
68098 }
68099
68100 case DUK_OP_DECLVAR: {
68101 duk_activation *act;
68102 duk_context *ctx = (duk_context *) thr;
68106 duk_tval *tv1;
68108 duk_small_uint_t prop_flags;
68109 duk_bool_t is_func_decl;
68110 duk_bool_t is_undef_value;
68111
68112 tv1 = DUK__REGCONSTP(b);
68115 DUK_ASSERT(name != NULL);
68116
68117 is_undef_value = ((a & DUK_BC_DECLVAR_FLAG_UNDEF_VALUE) != 0);
68118 is_func_decl = ((a & DUK_BC_DECLVAR_FLAG_FUNC_DECL) != 0);
68119
68120 /* XXX: declvar takes an duk_tval pointer, which is awkward and
68121 * should be reworked.
68122 */
68123
68124 /* Compiler is responsible for selecting property flags (configurability,
68125 * writability, etc).
68126 */
68127 prop_flags = a & DUK_PROPDESC_FLAGS_MASK;
68128
68129 if (is_undef_value) {
68130 duk_push_undefined(ctx);
68131 } else {
68133 }
68134 tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
68135
68136 act = thr->callstack + thr->callstack_top - 1;
68137 if (duk_js_declvar_activation(thr, act, name, tv1, prop_flags, is_func_decl)) {
68138 /* already declared, must update binding value */
68139 tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
68140 duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
68141 }
68142
68143 duk_pop(ctx);
68144 break;
68145 }
68146
68147 case DUK_OP_DELVAR: {
68148 duk_activation *act;
68149 duk_context *ctx = (duk_context *) thr;
68152 duk_tval *tv1;
68154 duk_bool_t rc;
68155
68156 tv1 = DUK__REGCONSTP(b);
68159 DUK_ASSERT(name != NULL);
68160 DUK_DDD(DUK_DDDPRINT("DELVAR '%!O'", (duk_heaphdr *) name));
68161 act = thr->callstack + thr->callstack_top - 1;
68162 rc = duk_js_delvar_activation(thr, act, name);
68163
68164 duk_push_boolean(ctx, rc);
68165 duk_replace(ctx, (duk_idx_t) a);
68166 break;
68167 }
68168
68169 case DUK_OP_CSVAR:
68170 case DUK_OP_CSVARI: {
68171 /* 'this' value:
68172 * E5 Section 6.b.i
68173 *
68174 * The only (standard) case where the 'this' binding is non-null is when
68175 * (1) the variable is found in an object environment record, and
68176 * (2) that object environment record is a 'with' block.
68177 *
68178 */
68179
68180 duk_context *ctx = (duk_context *) thr;
68181 duk_activation *act;
68183 duk_uint_fast_t idx;
68184 duk_tval *tv1;
68186
68187 tv1 = DUK__REGCONSTP(b);
68190 DUK_ASSERT(name != NULL);
68191 act = thr->callstack + thr->callstack_top - 1;
68192 (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */
68193
68194 /* Note: target registers a and a+1 may overlap with DUK__REGCONSTP(b)
68195 * and DUK__REGCONSTP(c). Careful here.
68196 */
68197
68198 idx = (duk_uint_fast_t) DUK_DEC_A(ins);
68199 if (DUK_DEC_OP(ins) == DUK_OP_CSVARI) {
68200 duk_tval *tv_ind = DUK__REGP(idx);
68202 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
68203 }
68204
68205#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
68206 if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
68207 /* XXX: use duk_is_valid_index() instead? */
68208 /* XXX: improve check; check against nregs, not against top */
68209 DUK__INTERNAL_ERROR("CSVAR out of bounds");
68210 }
68211#endif
68212
68213 duk_replace(ctx, (duk_idx_t) (idx + 1)); /* 'this' binding */
68214 duk_replace(ctx, (duk_idx_t) idx); /* variable value (function, we hope, not checked here) */
68215 break;
68216 }
68217
68218 case DUK_OP_CLOSURE: {
68219 duk_context *ctx = (duk_context *) thr;
68220 duk_activation *act;
68223 duk_uint_fast_t bc = DUK_DEC_BC(ins);
68224 duk_hobject *fun_temp;
68225
68226 /* A -> target reg
68227 * BC -> inner function index
68228 */
68229
68230 DUK_DDD(DUK_DDDPRINT("CLOSURE to target register %ld, fnum %ld (count %ld)",
68231 (long) a, (long) bc, (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, DUK__FUN())));
68232
68233 DUK_ASSERT_DISABLE(bc >= 0); /* unsigned */
68235
68236 act = thr->callstack + thr->callstack_top - 1;
68238 fun_temp = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun)[bc];
68239 DUK_ASSERT(fun_temp != NULL);
68241
68242 DUK_DDD(DUK_DDDPRINT("CLOSURE: function template is: %p -> %!O",
68243 (void *) fun_temp, (duk_heaphdr *) fun_temp));
68244
68245 if (act->lex_env == NULL) {
68246 DUK_ASSERT(act->var_env == NULL);
68248 }
68249 DUK_ASSERT(act->lex_env != NULL);
68250 DUK_ASSERT(act->var_env != NULL);
68251
68252 /* functions always have a NEWENV flag, i.e. they get a
68253 * new variable declaration environment, so only lex_env
68254 * matters here.
68255 */
68257 (duk_hcompiledfunction *) fun_temp,
68258 act->var_env,
68259 act->lex_env,
68260 1 /*add_auto_proto*/);
68261 duk_replace(ctx, (duk_idx_t) a);
68262
68263 break;
68264 }
68265
68266 case DUK_OP_GETPROP: {
68267 duk_context *ctx = (duk_context *) thr;
68271 duk_tval *tv_obj;
68272 duk_tval *tv_key;
68273 duk_bool_t rc;
68274
68275 /* A -> target reg
68276 * B -> object reg/const (may be const e.g. in "'foo'[1]")
68277 * C -> key reg/const
68278 */
68279
68280 tv_obj = DUK__REGCONSTP(b);
68281 tv_key = DUK__REGCONSTP(c);
68282 DUK_DDD(DUK_DDDPRINT("GETPROP: a=%ld obj=%!T, key=%!T",
68283 (long) a,
68284 (duk_tval *) DUK__REGCONSTP(b),
68285 (duk_tval *) DUK__REGCONSTP(c)));
68286 rc = duk_hobject_getprop(thr, tv_obj, tv_key); /* -> [val] */
68287 DUK_UNREF(rc); /* ignore */
68288 DUK_DDD(DUK_DDDPRINT("GETPROP --> %!T",
68289 (duk_tval *) duk_get_tval(ctx, -1)));
68290 tv_obj = NULL; /* invalidated */
68291 tv_key = NULL; /* invalidated */
68292
68293 duk_replace(ctx, (duk_idx_t) a); /* val */
68294 break;
68295 }
68296
68297 case DUK_OP_PUTPROP: {
68301 duk_tval *tv_obj;
68302 duk_tval *tv_key;
68303 duk_tval *tv_val;
68304 duk_bool_t rc;
68305
68306 /* A -> object reg
68307 * B -> key reg/const
68308 * C -> value reg/const
68309 *
68310 * Note: intentional difference to register arrangement
68311 * of e.g. GETPROP; 'A' must contain a register-only value.
68312 */
68313
68314 tv_obj = DUK__REGP(a);
68315 tv_key = DUK__REGCONSTP(b);
68316 tv_val = DUK__REGCONSTP(c);
68317 DUK_DDD(DUK_DDDPRINT("PUTPROP: obj=%!T, key=%!T, val=%!T",
68318 (duk_tval *) DUK__REGP(a),
68319 (duk_tval *) DUK__REGCONSTP(b),
68320 (duk_tval *) DUK__REGCONSTP(c)));
68321 rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT());
68322 DUK_UNREF(rc); /* ignore */
68323 DUK_DDD(DUK_DDDPRINT("PUTPROP --> obj=%!T, key=%!T, val=%!T",
68324 (duk_tval *) DUK__REGP(a),
68325 (duk_tval *) DUK__REGCONSTP(b),
68326 (duk_tval *) DUK__REGCONSTP(c)));
68327 tv_obj = NULL; /* invalidated */
68328 tv_key = NULL; /* invalidated */
68329 tv_val = NULL; /* invalidated */
68330
68331 break;
68332 }
68333
68334 case DUK_OP_DELPROP: {
68335 duk_context *ctx = (duk_context *) thr;
68339 duk_tval *tv_obj;
68340 duk_tval *tv_key;
68341 duk_bool_t rc;
68342
68343 /* A -> result reg
68344 * B -> object reg
68345 * C -> key reg/const
68346 */
68347
68348 tv_obj = DUK__REGP(b);
68349 tv_key = DUK__REGCONSTP(c);
68350 rc = duk_hobject_delprop(thr, tv_obj, tv_key, DUK__STRICT());
68351 tv_obj = NULL; /* invalidated */
68352 tv_key = NULL; /* invalidated */
68353
68354 duk_push_boolean(ctx, rc);
68355 duk_replace(ctx, (duk_idx_t) a); /* result */
68356 break;
68357 }
68358
68359 case DUK_OP_CSPROP:
68360 case DUK_OP_CSPROPI: {
68361 duk_context *ctx = (duk_context *) thr;
68364 duk_uint_fast_t idx;
68365 duk_tval *tv_obj;
68366 duk_tval *tv_key;
68367 duk_bool_t rc;
68368
68369 /* E5 Section 11.2.3, step 6.a.i */
68370 /* E5 Section 10.4.3 */
68371
68372 /* XXX: allow object to be a const, e.g. in 'foo'.toString()?
68373 * On the other hand, DUK_REGCONSTP() is slower and generates
68374 * more code.
68375 */
68376
68377 tv_obj = DUK__REGP(b);
68378 tv_key = DUK__REGCONSTP(c);
68379 rc = duk_hobject_getprop(thr, tv_obj, tv_key); /* -> [val] */
68380 DUK_UNREF(rc); /* unused */
68381 tv_obj = NULL; /* invalidated */
68382 tv_key = NULL; /* invalidated */
68383
68384 /* Note: target registers a and a+1 may overlap with DUK__REGP(b)
68385 * and DUK__REGCONSTP(c). Careful here.
68386 */
68387
68388 idx = (duk_uint_fast_t) DUK_DEC_A(ins);
68389 if (DUK_DEC_OP(ins) == DUK_OP_CSPROPI) {
68390 duk_tval *tv_ind = DUK__REGP(idx);
68392 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
68393 }
68394
68395#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
68396 if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
68397 /* XXX: use duk_is_valid_index() instead? */
68398 /* XXX: improve check; check against nregs, not against top */
68399 DUK__INTERNAL_ERROR("CSPROP out of bounds");
68400 }
68401#endif
68402
68403 duk_push_tval(ctx, DUK__REGP(b)); /* [ ... val obj ] */
68404 duk_replace(ctx, (duk_idx_t) (idx + 1)); /* 'this' binding */
68405 duk_replace(ctx, (duk_idx_t) idx); /* val */
68406 break;
68407 }
68408
68409 case DUK_OP_ADD:
68410 case DUK_OP_SUB:
68411 case DUK_OP_MUL:
68412 case DUK_OP_DIV:
68413 case DUK_OP_MOD: {
68418
68419 if (op == DUK_OP_ADD) {
68420 /*
68421 * Handling DUK_OP_ADD this way is more compact (experimentally)
68422 * than a separate case with separate argument decoding.
68423 */
68425 } else {
68427 }
68428 break;
68429 }
68430
68431 case DUK_OP_BAND:
68432 case DUK_OP_BOR:
68433 case DUK_OP_BXOR:
68434 case DUK_OP_BASL:
68435 case DUK_OP_BLSR:
68436 case DUK_OP_BASR: {
68441
68443 break;
68444 }
68445
68446 case DUK_OP_EQ:
68447 case DUK_OP_NEQ: {
68448 duk_context *ctx = (duk_context *) thr;
68452 duk_bool_t tmp;
68453
68454 /* E5 Sections 11.9.1, 11.9.3 */
68455 tmp = duk_js_equals(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c));
68456 if (DUK_DEC_OP(ins) == DUK_OP_NEQ) {
68457 tmp = !tmp;
68458 }
68459 duk_push_boolean(ctx, tmp);
68460 duk_replace(ctx, (duk_idx_t) a);
68461 break;
68462 }
68463
68464 case DUK_OP_SEQ:
68465 case DUK_OP_SNEQ: {
68466 duk_context *ctx = (duk_context *) thr;
68470 duk_bool_t tmp;
68471
68472 /* E5 Sections 11.9.1, 11.9.3 */
68474 if (DUK_DEC_OP(ins) == DUK_OP_SNEQ) {
68475 tmp = !tmp;
68476 }
68477 duk_push_boolean(ctx, tmp);
68478 duk_replace(ctx, (duk_idx_t) a);
68479 break;
68480 }
68481
68482 /* Note: combining comparison ops must be done carefully because
68483 * of uncomparable values (NaN): it's not necessarily true that
68484 * (x >= y) === !(x < y). Also, evaluation order matters, and
68485 * although it would only seem to affect the compiler this is
68486 * actually not the case, because there are also run-time coercions
68487 * of the arguments (with potential side effects).
68488 *
68489 * XXX: can be combined; check code size.
68490 */
68491
68492 case DUK_OP_GT: {
68493 duk_context *ctx = (duk_context *) thr;
68497 duk_bool_t tmp;
68498
68499 /* x > y --> y < x */
68500 tmp = duk_js_compare_helper(thr,
68501 DUK__REGCONSTP(c), /* y */
68502 DUK__REGCONSTP(b), /* x */
68503 0); /* flags */
68504
68505 duk_push_boolean(ctx, tmp);
68506 duk_replace(ctx, (duk_idx_t) a);
68507 break;
68508 }
68509
68510 case DUK_OP_GE: {
68511 duk_context *ctx = (duk_context *) thr;
68515 duk_bool_t tmp;
68516
68517 /* x >= y --> not (x < y) */
68518 tmp = duk_js_compare_helper(thr,
68519 DUK__REGCONSTP(b), /* x */
68520 DUK__REGCONSTP(c), /* y */
68522 DUK_COMPARE_FLAG_NEGATE); /* flags */
68523
68524 duk_push_boolean(ctx, tmp);
68525 duk_replace(ctx, (duk_idx_t) a);
68526 break;
68527 }
68528
68529 case DUK_OP_LT: {
68530 duk_context *ctx = (duk_context *) thr;
68534 duk_bool_t tmp;
68535
68536 /* x < y */
68537 tmp = duk_js_compare_helper(thr,
68538 DUK__REGCONSTP(b), /* x */
68539 DUK__REGCONSTP(c), /* y */
68541
68542 duk_push_boolean(ctx, tmp);
68543 duk_replace(ctx, (duk_idx_t) a);
68544 break;
68545 }
68546
68547 case DUK_OP_LE: {
68548 duk_context *ctx = (duk_context *) thr;
68552 duk_bool_t tmp;
68553
68554 /* x <= y --> not (x > y) --> not (y < x) */
68555 tmp = duk_js_compare_helper(thr,
68556 DUK__REGCONSTP(c), /* y */
68557 DUK__REGCONSTP(b), /* x */
68558 DUK_COMPARE_FLAG_NEGATE); /* flags */
68559
68560 duk_push_boolean(ctx, tmp);
68561 duk_replace(ctx, (duk_idx_t) a);
68562 break;
68563 }
68564
68565 case DUK_OP_IF: {
68568 duk_bool_t tmp;
68569
68571 if (tmp == (duk_bool_t) a) {
68572 /* if boolean matches A, skip next inst */
68573 curr_pc++;
68574 } else {
68575 ;
68576 }
68577 break;
68578 }
68579
68580 case DUK_OP_JUMP: {
68581 duk_int_fast_t abc = DUK_DEC_ABC(ins);
68582
68583 curr_pc += abc - DUK_BC_JUMP_BIAS;
68584 break;
68585 }
68586
68587 case DUK_OP_RETURN: {
68588 duk_context *ctx = (duk_context *) thr;
68591 /* duk_small_uint_fast_t c = DUK_DEC_C(ins); */
68592 duk_small_uint_t ret_result;
68593
68594 /* A -> flags
68595 * B -> return value reg/const
68596 * C -> currently unused
68597 */
68598
68600
68601 /* duk__handle_return() is guaranteed never to throw, except
68602 * for potential out-of-memory situations which will then
68603 * propagate out of the executor longjmp handler.
68604 */
68605
68608 } else {
68609 duk_push_undefined(ctx);
68610 }
68611 ret_result = duk__handle_return(thr,
68612 entry_thread,
68613 entry_callstack_top);
68614 if (ret_result == DUK__RETHAND_RESTART) {
68615 goto restart_execution;
68616 }
68617 DUK_ASSERT(ret_result == DUK__RETHAND_FINISHED);
68618
68619 DUK_DDD(DUK_DDDPRINT("exiting executor after RETURN handling"));
68620 return;
68621 }
68622
68623 case DUK_OP_CALL:
68624 case DUK_OP_CALLI: {
68625 duk_context *ctx = (duk_context *) thr;
68628 duk_uint_fast_t idx;
68629 duk_small_uint_t call_flags;
68630 duk_small_uint_t flag_tailcall;
68631 duk_small_uint_t flag_evalcall;
68632 duk_tval *tv_func;
68633 duk_hobject *obj_func;
68634 duk_bool_t setup_rc;
68635 duk_idx_t num_stack_args;
68636#if !defined(DUK_USE_EXEC_FUN_LOCAL)
68638#endif
68639
68640 /* A -> flags
68641 * B -> base register for call (base -> func, base+1 -> this, base+2 -> arg1 ... base+2+N-1 -> argN)
68642 * (for DUK_OP_CALLI, 'b' is indirect)
68643 * C -> nargs
68644 */
68645
68646 /* these are not necessarily 0 or 1 (may be other non-zero), that's ok */
68647 flag_tailcall = (a & DUK_BC_CALL_FLAG_TAILCALL);
68648 flag_evalcall = (a & DUK_BC_CALL_FLAG_EVALCALL);
68649
68650 idx = (duk_uint_fast_t) DUK_DEC_B(ins);
68651 if (DUK_DEC_OP(ins) == DUK_OP_CALLI) {
68652 duk_tval *tv_ind = DUK__REGP(idx);
68654 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
68655 }
68656
68657#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
68658 if (!duk_is_valid_index(ctx, (duk_idx_t) idx)) {
68659 /* XXX: improve check; check against nregs, not against top */
68660 DUK__INTERNAL_ERROR("CALL out of bounds");
68661 }
68662#endif
68663
68664 /*
68665 * To determine whether to use an optimized Ecmascript-to-Ecmascript
68666 * call, we need to know whether the final, non-bound function is an
68667 * Ecmascript function.
68668 *
68669 * This is now implemented so that we start to do an ecma-to-ecma call
68670 * setup which will resolve the bound chain as the first thing. If the
68671 * final function is not eligible, the return value indicates that the
68672 * ecma-to-ecma call is not possible. The setup will overwrite the call
68673 * target at DUK__REGP(idx) with the final, non-bound function (which
68674 * may be a lightfunc), and fudge arguments if necessary.
68675 *
68676 * XXX: If an ecma-to-ecma call is not possible, this initial call
68677 * setup will do bound function chain resolution but won't do the
68678 * "effective this binding" resolution which is quite confusing.
68679 * Perhaps add a helper for doing bound function and effective this
68680 * binding resolution - and call that explicitly? Ecma-to-ecma call
68681 * setup and normal function handling can then assume this prestep has
68682 * been done by the caller.
68683 */
68684
68685 duk_set_top(ctx, (duk_idx_t) (idx + c + 2)); /* [ ... func this arg1 ... argN ] */
68686
68687 call_flags = 0;
68688 if (flag_tailcall) {
68689 /* We request a tail call, but in some corner cases
68690 * call handling can decide that a tail call is
68691 * actually not possible.
68692 * See: test-bug-tailcall-preventyield-assert.c.
68693 */
68694 call_flags |= DUK_CALL_FLAG_IS_TAILCALL;
68695 }
68696
68697 /* Compared to duk_handle_call():
68698 * - protected call: never
68699 * - ignore recursion limit: never
68700 */
68701 num_stack_args = c;
68702 setup_rc = duk_handle_ecma_call_setup(thr,
68703 num_stack_args,
68704 call_flags);
68705
68706 if (setup_rc) {
68707 /* Ecma-to-ecma call possible, may or may not be a tail call.
68708 * Avoid C recursion by being clever.
68709 */
68710 DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call setup possible, restart execution"));
68711 /* curr_pc synced by duk_handle_ecma_call_setup() */
68712 goto restart_execution;
68713 }
68714 DUK_ASSERT(thr->ptr_curr_pc != NULL); /* restored if ecma-to-ecma setup fails */
68715
68716 DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call not possible, target is native (may be lightfunc)"));
68717
68718 /* Recompute argument count: bound function handling may have shifted. */
68719 num_stack_args = duk_get_top(ctx) - (idx + 2);
68720 DUK_DDD(DUK_DDDPRINT("recomputed arg count: %ld\n", (long) num_stack_args));
68721
68722 tv_func = DUK__REGP(idx); /* Relookup if relocated */
68723 if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
68724
68725 call_flags = 0; /* not protected, respect reclimit, not constructor */
68726
68727 /* There is no eval() special handling here: eval() is never
68728 * automatically converted to a lightfunc.
68729 */
68731
68733 num_stack_args,
68734 call_flags);
68735
68736 /* duk_js_call.c is required to restore the stack reserve
68737 * so we only need to reset the top.
68738 */
68739#if !defined(DUK_USE_EXEC_FUN_LOCAL)
68740 fun = DUK__FUN();
68741#endif
68742 duk_set_top(ctx, (duk_idx_t) fun->nregs);
68743
68744 /* No need to reinit setjmp() catchpoint, as call handling
68745 * will store and restore our state.
68746 */
68747 } else {
68748 /* Call setup checks callability. */
68750 obj_func = DUK_TVAL_GET_OBJECT(tv_func);
68751 DUK_ASSERT(obj_func != NULL);
68753
68754 /*
68755 * Other cases, use C recursion.
68756 *
68757 * If a tail call was requested we ignore it and execute a normal call.
68758 * Since Duktape 0.11.0 the compiler emits a RETURN opcode even after
68759 * a tail call to avoid test-bug-tailcall-thread-yield-resume.js.
68760 *
68761 * Direct eval call: (1) call target (before following bound function
68762 * chain) is the built-in eval() function, and (2) call was made with
68763 * the identifier 'eval'.
68764 */
68765
68766 call_flags = 0; /* not protected, respect reclimit, not constructor */
68767
68768 if (DUK_HOBJECT_IS_NATIVEFUNCTION(obj_func) &&
68769 ((duk_hnativefunction *) obj_func)->func == duk_bi_global_object_eval) {
68770 if (flag_evalcall) {
68771 DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was 'eval' -> direct eval"));
68772 call_flags |= DUK_CALL_FLAG_DIRECT_EVAL;
68773 } else {
68774 DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was not 'eval' -> indirect eval"));
68775 }
68776 }
68777
68779 num_stack_args,
68780 call_flags);
68781
68782 /* duk_js_call.c is required to restore the stack reserve
68783 * so we only need to reset the top.
68784 */
68785#if !defined(DUK_USE_EXEC_FUN_LOCAL)
68786 fun = DUK__FUN();
68787#endif
68788 duk_set_top(ctx, (duk_idx_t) fun->nregs);
68789
68790 /* No need to reinit setjmp() catchpoint, as call handling
68791 * will store and restore our state.
68792 */
68793 }
68794
68795 /* When debugger is enabled, we need to recheck the activation
68796 * status after returning. This is now handled by call handling
68797 * and heap->dbg_force_restart.
68798 */
68799 break;
68800 }
68801
68802 case DUK_OP_TRYCATCH: {
68803 duk_context *ctx = (duk_context *) thr;
68804 duk_activation *act;
68805 duk_catcher *cat;
68806 duk_tval *tv1;
68808 duk_uint_fast_t bc;
68809
68810 /* A -> flags
68811 * BC -> reg_catch; base register for two registers used both during
68812 * trycatch setup and when catch is triggered
68813 *
68814 * If DUK_BC_TRYCATCH_FLAG_CATCH_BINDING set:
68815 * reg_catch + 0: catch binding variable name (string).
68816 * Automatic declarative environment is established for
68817 * the duration of the 'catch' clause.
68818 *
68819 * If DUK_BC_TRYCATCH_FLAG_WITH_BINDING set:
68820 * reg_catch + 0: with 'target value', which is coerced to
68821 * an object and then used as a bindind object for an
68822 * environment record. The binding is initialized here, for
68823 * the 'try' clause.
68824 *
68825 * Note that a TRYCATCH generated for a 'with' statement has no
68826 * catch or finally parts.
68827 */
68828
68829 /* XXX: TRYCATCH handling should be reworked to avoid creating
68830 * an explicit scope unless it is actually needed (e.g. function
68831 * instances or eval is executed inside the catch block). This
68832 * rework is not trivial because the compiler doesn't have an
68833 * intermediate representation. When the rework is done, the
68834 * opcode format can also be made more straightforward.
68835 */
68836
68837 /* XXX: side effect handling is quite awkward here */
68838
68839 DUK_DDD(DUK_DDDPRINT("TRYCATCH: reg_catch=%ld, have_catch=%ld, "
68840 "have_finally=%ld, catch_binding=%ld, with_binding=%ld (flags=0x%02lx)",
68841 (long) DUK_DEC_BC(ins),
68842 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH ? 1 : 0),
68843 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY ? 1 : 0),
68844 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING ? 1 : 0),
68845 (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_WITH_BINDING ? 1 : 0),
68846 (unsigned long) DUK_DEC_A(ins)));
68847
68848 a = DUK_DEC_A(ins);
68849 bc = DUK_DEC_BC(ins);
68850
68851 act = thr->callstack + thr->callstack_top - 1;
68852 DUK_ASSERT(thr->callstack_top >= 1);
68853
68854 /* 'with' target must be created first, in case we run out of memory */
68855 /* XXX: refactor out? */
68856
68858 DUK_DDD(DUK_DDDPRINT("need to initialize a with binding object"));
68859
68860 if (act->lex_env == NULL) {
68861 DUK_ASSERT(act->var_env == NULL);
68862 DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
68863
68864 /* must relookup act in case of side effects */
68866 act = thr->callstack + thr->callstack_top - 1;
68867 DUK_UNREF(act); /* 'act' is no longer accessed, scanbuild fix */
68868 }
68869 DUK_ASSERT(act->lex_env != NULL);
68870 DUK_ASSERT(act->var_env != NULL);
68871
68872 (void) duk_push_object_helper(ctx,
68875 -1); /* no prototype, updated below */
68876
68877 duk_push_tval(ctx, DUK__REGP(bc));
68878 duk_to_object(ctx, -1);
68879 duk_dup(ctx, -1);
68880
68881 /* [ ... env target ] */
68882 /* [ ... env target target ] */
68883
68885 duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE); /* always provideThis=true */
68886
68887 /* [ ... env ] */
68888
68889 DUK_DDD(DUK_DDDPRINT("environment for with binding: %!iT",
68890 (duk_tval *) duk_get_tval(ctx, -1)));
68891 }
68892
68893 /* allocate catcher and populate it (should be atomic) */
68894
68896 cat = thr->catchstack + thr->catchstack_top;
68897 DUK_ASSERT(thr->catchstack_top + 1 <= thr->catchstack_size);
68898 thr->catchstack_top++;
68899
68900 cat->flags = DUK_CAT_TYPE_TCF;
68901 cat->h_varname = NULL;
68902
68905 }
68908 }
68910 DUK_DDD(DUK_DDDPRINT("catch binding flag set to catcher"));
68912 tv1 = DUK__REGP(bc);
68914
68915 /* borrowed reference; although 'tv1' comes from a register,
68916 * its value was loaded using LDCONST so the constant will
68917 * also exist and be reachable.
68918 */
68919 cat->h_varname = DUK_TVAL_GET_STRING(tv1);
68920 } else if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) {
68921 /* env created above to stack top */
68922 duk_hobject *new_env;
68923
68924 DUK_DDD(DUK_DDDPRINT("lexenv active flag set to catcher"));
68926
68927 DUK_DDD(DUK_DDDPRINT("activating object env: %!iT",
68928 (duk_tval *) duk_get_tval(ctx, -1)));
68929 DUK_ASSERT(act->lex_env != NULL);
68930 new_env = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
68931 DUK_ASSERT(new_env != NULL);
68932
68933 act = thr->callstack + thr->callstack_top - 1; /* relookup (side effects) */
68934 DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, new_env, act->lex_env); /* side effects */
68935
68936 act = thr->callstack + thr->callstack_top - 1; /* relookup (side effects) */
68937 act->lex_env = new_env;
68938 DUK_HOBJECT_INCREF(thr, new_env);
68939 duk_pop(ctx);
68940 } else {
68941 ;
68942 }
68943
68944 /* Registers 'bc' and 'bc + 1' are written in longjmp handling
68945 * and if their previous values (which are temporaries) become
68946 * unreachable -and- have a finalizer, there'll be a function
68947 * call during error handling which is not supported now (GH-287).
68948 * Ensure that both 'bc' and 'bc + 1' have primitive values to
68949 * guarantee no finalizer calls in error handling. Scrubbing also
68950 * ensures finalizers for the previous values run here rather than
68951 * later. Error handling related values are also written to 'bc'
68952 * and 'bc + 1' but those values never become unreachable during
68953 * error handling, so there's no side effect problem even if the
68954 * error value has a finalizer.
68955 */
68956 duk_to_undefined(ctx, bc);
68957 duk_to_undefined(ctx, bc + 1);
68958
68959 cat = thr->catchstack + thr->catchstack_top - 1; /* relookup (side effects) */
68960 cat->callstack_index = thr->callstack_top - 1;
68961 cat->pc_base = (duk_instr_t *) curr_pc; /* pre-incremented, points to first jump slot */
68962 cat->idx_base = (duk_size_t) (thr->valstack_bottom - thr->valstack) + bc;
68963
68964 DUK_DDD(DUK_DDDPRINT("TRYCATCH catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, "
68965 "idx_base=%ld, h_varname=%!O",
68966 (unsigned long) cat->flags, (long) cat->callstack_index,
68967 (long) cat->pc_base, (long) cat->idx_base, (duk_heaphdr *) cat->h_varname));
68968
68969 curr_pc += 2; /* skip jump slots */
68970 break;
68971 }
68972
68973 /* Pre/post inc/dec for register variables, important for loops. */
68974 case DUK_OP_PREINCR:
68975 case DUK_OP_PREDECR:
68976 case DUK_OP_POSTINCR:
68977 case DUK_OP_POSTDECR: {
68978 duk_context *ctx = (duk_context *) thr;
68980 duk_uint_fast_t bc = DUK_DEC_BC(ins);
68981 duk_tval *tv1, *tv2;
68982 duk_double_t x, y, z;
68983
68984 /* Two lowest bits of opcode are used to distinguish
68985 * variants. Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
68986 */
68987 DUK_ASSERT((DUK_OP_PREINCR & 0x03) == 0x00);
68988 DUK_ASSERT((DUK_OP_PREDECR & 0x03) == 0x01);
68989 DUK_ASSERT((DUK_OP_POSTINCR & 0x03) == 0x02);
68990 DUK_ASSERT((DUK_OP_POSTDECR & 0x03) == 0x03);
68991
68992 tv1 = DUK__REGP(bc);
68993#if defined(DUK_USE_FASTINT)
68994 if (DUK_TVAL_IS_FASTINT(tv1)) {
68995 duk_int64_t x_fi, y_fi, z_fi;
68996 x_fi = DUK_TVAL_GET_FASTINT(tv1);
68997 if (ins & DUK_ENC_OP(0x01)) {
68998 if (x_fi == DUK_FASTINT_MIN) {
68999 goto skip_fastint;
69000 }
69001 y_fi = x_fi - 1;
69002 } else {
69003 if (x_fi == DUK_FASTINT_MAX) {
69004 goto skip_fastint;
69005 }
69006 y_fi = x_fi + 1;
69007 }
69008
69009 DUK_TVAL_SET_FASTINT(tv1, y_fi); /* no need for refcount update */
69010
69011 tv2 = DUK__REGP(a);
69012 z_fi = (ins & DUK_ENC_OP(0x02)) ? x_fi : y_fi;
69013 DUK_TVAL_SET_FASTINT_UPDREF(thr, tv2, z_fi); /* side effects */
69014 break;
69015 }
69016 skip_fastint:
69017#endif
69018 if (DUK_TVAL_IS_NUMBER(tv1)) {
69019 /* Fast path for the case where the register
69020 * is a number (e.g. loop counter).
69021 */
69022
69023 x = DUK_TVAL_GET_NUMBER(tv1);
69024 if (ins & DUK_ENC_OP(0x01)) {
69025 y = x - 1.0;
69026 } else {
69027 y = x + 1.0;
69028 }
69029
69030 DUK_TVAL_SET_NUMBER(tv1, y); /* no need for refcount update */
69031 } else {
69032 x = duk_to_number(ctx, bc);
69033
69034 if (ins & DUK_ENC_OP(0x01)) {
69035 y = x - 1.0;
69036 } else {
69037 y = x + 1.0;
69038 }
69039
69040 duk_push_number(ctx, y);
69041 duk_replace(ctx, bc);
69042 }
69043
69044 tv2 = DUK__REGP(a);
69045 z = (ins & DUK_ENC_OP(0x02)) ? x : y;
69046 DUK_TVAL_SET_NUMBER_UPDREF(thr, tv2, z); /* side effects */
69047 break;
69048 }
69049
69050 /* Preinc/predec for var-by-name, slow path. */
69051 case DUK_OP_PREINCV:
69052 case DUK_OP_PREDECV:
69053 case DUK_OP_POSTINCV:
69054 case DUK_OP_POSTDECV: {
69055 duk_context *ctx = (duk_context *) thr;
69056 duk_activation *act;
69058 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69059 duk_double_t x, y;
69060 duk_tval *tv1;
69062
69063 /* Two lowest bits of opcode are used to distinguish
69064 * variants. Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
69065 */
69066 DUK_ASSERT((DUK_OP_PREINCV & 0x03) == 0x00);
69067 DUK_ASSERT((DUK_OP_PREDECV & 0x03) == 0x01);
69068 DUK_ASSERT((DUK_OP_POSTINCV & 0x03) == 0x02);
69069 DUK_ASSERT((DUK_OP_POSTDECV & 0x03) == 0x03);
69070
69071 tv1 = DUK__CONSTP(bc);
69074 DUK_ASSERT(name != NULL);
69075 act = thr->callstack + thr->callstack_top - 1;
69076 (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */
69077
69078 /* XXX: fastint fast path would be very useful here */
69079
69080 x = duk_to_number(ctx, -2);
69081 duk_pop_2(ctx);
69082 if (ins & DUK_ENC_OP(0x01)) {
69083 y = x - 1.0;
69084 } else {
69085 y = x + 1.0;
69086 }
69087
69088 duk_push_number(ctx, y);
69089 tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
69090 DUK_ASSERT(tv1 != NULL);
69091 duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
69092 duk_pop(ctx);
69093
69094 duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y);
69095 duk_replace(ctx, (duk_idx_t) a);
69096 break;
69097 }
69098
69099 /* Preinc/predec for object properties. */
69100 case DUK_OP_PREINCP:
69101 case DUK_OP_PREDECP:
69102 case DUK_OP_POSTINCP:
69103 case DUK_OP_POSTDECP: {
69104 duk_context *ctx = (duk_context *) thr;
69108 duk_tval *tv_obj;
69109 duk_tval *tv_key;
69110 duk_tval *tv_val;
69111 duk_bool_t rc;
69112 duk_double_t x, y;
69113
69114 /* A -> target reg
69115 * B -> object reg/const (may be const e.g. in "'foo'[1]")
69116 * C -> key reg/const
69117 */
69118
69119 /* Two lowest bits of opcode are used to distinguish
69120 * variants. Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
69121 */
69122 DUK_ASSERT((DUK_OP_PREINCP & 0x03) == 0x00);
69123 DUK_ASSERT((DUK_OP_PREDECP & 0x03) == 0x01);
69124 DUK_ASSERT((DUK_OP_POSTINCP & 0x03) == 0x02);
69125 DUK_ASSERT((DUK_OP_POSTDECP & 0x03) == 0x03);
69126
69127 tv_obj = DUK__REGCONSTP(b);
69128 tv_key = DUK__REGCONSTP(c);
69129 rc = duk_hobject_getprop(thr, tv_obj, tv_key); /* -> [val] */
69130 DUK_UNREF(rc); /* ignore */
69131 tv_obj = NULL; /* invalidated */
69132 tv_key = NULL; /* invalidated */
69133
69134 x = duk_to_number(ctx, -1);
69135 duk_pop(ctx);
69136 if (ins & DUK_ENC_OP(0x01)) {
69137 y = x - 1.0;
69138 } else {
69139 y = x + 1.0;
69140 }
69141
69142 duk_push_number(ctx, y);
69143 tv_val = DUK_GET_TVAL_NEGIDX(ctx, -1);
69144 DUK_ASSERT(tv_val != NULL);
69145 tv_obj = DUK__REGCONSTP(b);
69146 tv_key = DUK__REGCONSTP(c);
69147 rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT());
69148 DUK_UNREF(rc); /* ignore */
69149 tv_obj = NULL; /* invalidated */
69150 tv_key = NULL; /* invalidated */
69151 duk_pop(ctx);
69152
69153 duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y);
69154 duk_replace(ctx, (duk_idx_t) a);
69155 break;
69156 }
69157
69158 case DUK_OP_EXTRA: {
69159 /* XXX: shared decoding of 'b' and 'c'? */
69160
69161 duk_small_uint_fast_t extraop = DUK_DEC_A(ins);
69162 switch ((int) extraop) {
69163 /* XXX: switch cast? */
69164
69165 case DUK_EXTRAOP_NOP: {
69166 /* nop */
69167 break;
69168 }
69169
69170 case DUK_EXTRAOP_INVALID: {
69171 DUK_ERROR_FMT1(thr, DUK_ERR_INTERNAL_ERROR, "INVALID opcode (%ld)", (long) DUK_DEC_BC(ins));
69172 break;
69173 }
69174
69175 case DUK_EXTRAOP_LDTHIS: {
69176 /* Note: 'this' may be bound to any value, not just an object */
69177 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69178 duk_tval *tv1, *tv2;
69179
69180 tv1 = DUK__REGP(bc);
69181 tv2 = thr->valstack_bottom - 1; /* 'this binding' is just under bottom */
69182 DUK_ASSERT(tv2 >= thr->valstack);
69183
69184 DUK_DDD(DUK_DDDPRINT("LDTHIS: %!T to r%ld", (duk_tval *) tv2, (long) bc));
69185
69186 DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2); /* side effects */
69187 break;
69188 }
69189
69190 case DUK_EXTRAOP_LDUNDEF: {
69191 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69192 duk_tval *tv1;
69193
69194 tv1 = DUK__REGP(bc);
69195 DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */
69196 break;
69197 }
69198
69199 case DUK_EXTRAOP_LDNULL: {
69200 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69201 duk_tval *tv1;
69202
69203 tv1 = DUK__REGP(bc);
69204 DUK_TVAL_SET_NULL_UPDREF(thr, tv1); /* side effects */
69205 break;
69206 }
69207
69208 case DUK_EXTRAOP_LDTRUE:
69209 case DUK_EXTRAOP_LDFALSE: {
69210 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69211 duk_tval *tv1;
69212 duk_small_uint_fast_t bval = (extraop == DUK_EXTRAOP_LDTRUE ? 1 : 0);
69213
69214 tv1 = DUK__REGP(bc);
69215 DUK_TVAL_SET_BOOLEAN_UPDREF(thr, tv1, bval); /* side effects */
69216 break;
69217 }
69218
69219 case DUK_EXTRAOP_NEWOBJ: {
69220 duk_context *ctx = (duk_context *) thr;
69222
69223 duk_push_object(ctx);
69224 duk_replace(ctx, (duk_idx_t) b);
69225 break;
69226 }
69227
69228 case DUK_EXTRAOP_NEWARR: {
69229 duk_context *ctx = (duk_context *) thr;
69231
69232 duk_push_array(ctx);
69233 duk_replace(ctx, (duk_idx_t) b);
69234 break;
69235 }
69236
69237 case DUK_EXTRAOP_SETALEN: {
69240 duk_tval *tv1;
69241 duk_hobject *h;
69242 duk_uint32_t len;
69243
69244 b = DUK_DEC_B(ins); tv1 = DUK__REGP(b);
69246 h = DUK_TVAL_GET_OBJECT(tv1);
69247
69248 c = DUK_DEC_C(ins); tv1 = DUK__REGP(c);
69250 len = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1);
69251
69252 duk_hobject_set_length(thr, h, len);
69253
69254 break;
69255 }
69256
69257 case DUK_EXTRAOP_TYPEOF: {
69258 duk_context *ctx = (duk_context *) thr;
69259 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69261 duk_replace(ctx, (duk_idx_t) bc);
69262 break;
69263 }
69264
69265 case DUK_EXTRAOP_TYPEOFID: {
69266 duk_context *ctx = (duk_context *) thr;
69267 duk_activation *act;
69271 duk_tval *tv;
69272
69273 /* B -> target register
69274 * C -> constant index of identifier name
69275 */
69276
69277 tv = DUK__REGCONSTP(c); /* XXX: this could be a DUK__CONSTP instead */
69280 act = thr->callstack + thr->callstack_top - 1;
69281 if (duk_js_getvar_activation(thr, act, name, 0 /*throw*/)) {
69282 /* -> [... val this] */
69283 tv = DUK_GET_TVAL_NEGIDX(ctx, -2);
69284 duk_push_hstring(ctx, duk_js_typeof(thr, tv));
69285 duk_replace(ctx, (duk_idx_t) b);
69286 duk_pop_2(ctx);
69287 } else {
69288 /* unresolvable, no stack changes */
69290 duk_replace(ctx, (duk_idx_t) b);
69291 }
69292
69293 break;
69294 }
69295
69296 case DUK_EXTRAOP_INITENUM: {
69297 duk_context *ctx = (duk_context *) thr;
69300
69301 /*
69302 * Enumeration semantics come from for-in statement, E5 Section 12.6.4.
69303 * If called with 'null' or 'undefined', this opcode returns 'null' as
69304 * the enumerator, which is special cased in NEXTENUM. This simplifies
69305 * the compiler part
69306 */
69307
69308 /* B -> register for writing enumerator object
69309 * C -> value to be enumerated (register)
69310 */
69311
69312 if (duk_is_null_or_undefined(ctx, (duk_idx_t) c)) {
69313 duk_push_null(ctx);
69314 duk_replace(ctx, (duk_idx_t) b);
69315 } else {
69316 duk_dup(ctx, (duk_idx_t) c);
69317 duk_to_object(ctx, -1);
69318 duk_hobject_enumerator_create(ctx, 0 /*enum_flags*/); /* [ ... val ] --> [ ... enum ] */
69319 duk_replace(ctx, (duk_idx_t) b);
69320 }
69321 break;
69322 }
69323
69324 case DUK_EXTRAOP_NEXTENUM: {
69325 duk_context *ctx = (duk_context *) thr;
69328
69329 /*
69330 * NEXTENUM checks whether the enumerator still has unenumerated
69331 * keys. If so, the next key is loaded to the target register
69332 * and the next instruction is skipped. Otherwise the next instruction
69333 * will be executed, jumping out of the enumeration loop.
69334 */
69335
69336 /* B -> target register for next key
69337 * C -> enum register
69338 */
69339
69340 DUK_DDD(DUK_DDDPRINT("NEXTENUM: b->%!T, c->%!T",
69341 (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b),
69342 (duk_tval *) duk_get_tval(ctx, (duk_idx_t) c)));
69343
69344 if (duk_is_object(ctx, (duk_idx_t) c)) {
69345 /* XXX: assert 'c' is an enumerator */
69346 duk_dup(ctx, (duk_idx_t) c);
69347 if (duk_hobject_enumerator_next(ctx, 0 /*get_value*/)) {
69348 /* [ ... enum ] -> [ ... next_key ] */
69349 DUK_DDD(DUK_DDDPRINT("enum active, next key is %!T, skip jump slot ",
69350 (duk_tval *) duk_get_tval(ctx, -1)));
69351 curr_pc++;
69352 } else {
69353 /* [ ... enum ] -> [ ... ] */
69354 DUK_DDD(DUK_DDDPRINT("enum finished, execute jump slot"));
69355 duk_push_undefined(ctx);
69356 }
69357 duk_replace(ctx, (duk_idx_t) b);
69358 } else {
69359 /* 'null' enumerator case -> behave as with an empty enumerator */
69360 DUK_ASSERT(duk_is_null(ctx, (duk_idx_t) c));
69361 DUK_DDD(DUK_DDDPRINT("enum is null, execute jump slot"));
69362 }
69363 break;
69364 }
69365
69369 case DUK_EXTRAOP_INITGETI: {
69370 duk_context *ctx = (duk_context *) thr;
69371 duk_bool_t is_set = (extraop == DUK_EXTRAOP_INITSET || extraop == DUK_EXTRAOP_INITSETI);
69373 duk_uint_fast_t idx;
69374
69375 /* B -> object register
69376 * C -> C+0 contains key, C+1 closure (value)
69377 */
69378
69379 /*
69380 * INITSET/INITGET are only used to initialize object literal keys.
69381 * The compiler ensures that there cannot be a previous data property
69382 * of the same name. It also ensures that setter and getter can only
69383 * be initialized once (or not at all).
69384 */
69385
69386 idx = (duk_uint_fast_t) DUK_DEC_C(ins);
69387 if (extraop == DUK_EXTRAOP_INITSETI || extraop == DUK_EXTRAOP_INITGETI) {
69388 duk_tval *tv_ind = DUK__REGP(idx);
69390 idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
69391 }
69392
69393#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
69394 if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
69395 /* XXX: use duk_is_valid_index() instead? */
69396 /* XXX: improve check; check against nregs, not against top */
69397 DUK__INTERNAL_ERROR("INITSET/INITGET out of bounds");
69398 }
69399#endif
69400
69401 /* XXX: this is now a very unoptimal implementation -- this can be
69402 * made very simple by direct manipulation of the object internals,
69403 * given the guarantees above.
69404 */
69405
69408 duk_push_undefined(ctx);
69409 duk_dup(ctx, (duk_idx_t) b);
69410 duk_dup(ctx, (duk_idx_t) (idx + 0));
69411 duk_push_object(ctx); /* -> [ Object defineProperty undefined obj key desc ] */
69412
69413 duk_push_true(ctx);
69415 duk_push_true(ctx);
69417 duk_dup(ctx, (duk_idx_t) (idx + 1));
69418 duk_put_prop_stridx(ctx, -2, (is_set ? DUK_STRIDX_SET : DUK_STRIDX_GET));
69419
69420 DUK_DDD(DUK_DDDPRINT("INITGET/INITSET: obj=%!T, key=%!T, desc=%!T",
69421 (duk_tval *) duk_get_tval(ctx, -3),
69422 (duk_tval *) duk_get_tval(ctx, -2),
69423 (duk_tval *) duk_get_tval(ctx, -1)));
69424
69425 duk_call_method(ctx, 3); /* -> [ Object res ] */
69426 duk_pop_2(ctx);
69427
69428 DUK_DDD(DUK_DDDPRINT("INITGET/INITSET AFTER: obj=%!T",
69429 (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b)));
69430 break;
69431 }
69432
69433 case DUK_EXTRAOP_ENDTRY: {
69434 duk_catcher *cat;
69435 duk_tval *tv1;
69436
69437 DUK_ASSERT(thr->catchstack_top >= 1);
69438 DUK_ASSERT(thr->callstack_top >= 1);
69439 DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
69440
69441 cat = thr->catchstack + thr->catchstack_top - 1;
69442
69443 DUK_DDD(DUK_DDDPRINT("ENDTRY: clearing catch active flag (regardless of whether it was set or not)"));
69445
69446 if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
69447 DUK_DDD(DUK_DDDPRINT("ENDTRY: finally part is active, jump through 2nd jump slot with 'normal continuation'"));
69448
69449 tv1 = thr->valstack + cat->idx_base;
69450 DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
69451 DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */
69452 tv1 = NULL;
69453
69454 tv1 = thr->valstack + cat->idx_base + 1;
69455 DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
69456 DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) DUK_LJ_TYPE_NORMAL); /* side effects */
69457 tv1 = NULL;
69458
69460 } else {
69461 DUK_DDD(DUK_DDDPRINT("ENDTRY: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)"));
69462 duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
69463 /* no need to unwind callstack */
69464 }
69465
69466 curr_pc = cat->pc_base + 1;
69467 break;
69468 }
69469
69470 case DUK_EXTRAOP_ENDCATCH: {
69471 duk_activation *act;
69472 duk_catcher *cat;
69473 duk_tval *tv1;
69474
69475 DUK_ASSERT(thr->catchstack_top >= 1);
69476 DUK_ASSERT(thr->callstack_top >= 1);
69477 DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
69478
69479 cat = thr->catchstack + thr->catchstack_top - 1;
69480 DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat)); /* cleared before entering catch part */
69481
69482 act = thr->callstack + thr->callstack_top - 1;
69483
69484 if (DUK_CAT_HAS_LEXENV_ACTIVE(cat)) {
69485 duk_hobject *prev_env;
69486
69487 /* 'with' binding has no catch clause, so can't be here unless a normal try-catch */
69489 DUK_ASSERT(act->lex_env != NULL);
69490
69491 DUK_DDD(DUK_DDDPRINT("ENDCATCH: popping catcher part lexical environment"));
69492
69493 prev_env = act->lex_env;
69494 DUK_ASSERT(prev_env != NULL);
69495 act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, prev_env);
69497 DUK_HOBJECT_DECREF(thr, prev_env); /* side effects */
69498 }
69499
69500 if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
69501 DUK_DDD(DUK_DDDPRINT("ENDCATCH: finally part is active, jump through 2nd jump slot with 'normal continuation'"));
69502
69503 tv1 = thr->valstack + cat->idx_base;
69504 DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
69505 DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */
69506 tv1 = NULL;
69507
69508 tv1 = thr->valstack + cat->idx_base + 1;
69509 DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
69510 DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) DUK_LJ_TYPE_NORMAL); /* side effects */
69511 tv1 = NULL;
69512
69514 } else {
69515 DUK_DDD(DUK_DDDPRINT("ENDCATCH: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)"));
69516 duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
69517 /* no need to unwind callstack */
69518 }
69519
69520 curr_pc = cat->pc_base + 1;
69521 break;
69522 }
69523
69524 case DUK_EXTRAOP_ENDFIN: {
69525 duk_context *ctx = (duk_context *) thr;
69526 duk_catcher *cat;
69527 duk_tval *tv1;
69528 duk_small_uint_t cont_type;
69529 duk_small_uint_t ret_result;
69530
69531 /* Sync and NULL early. */
69533
69534 DUK_ASSERT(thr->catchstack_top >= 1);
69535 DUK_ASSERT(thr->callstack_top >= 1);
69536 DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
69537
69538 cat = thr->catchstack + thr->catchstack_top - 1;
69539
69540 /* CATCH flag may be enabled or disabled here; it may be enabled if
69541 * the statement has a catch block but the try block does not throw
69542 * an error.
69543 */
69544 DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat)); /* cleared before entering finally */
69545 /* XXX: assert idx_base */
69546
69547 DUK_DDD(DUK_DDDPRINT("ENDFIN: completion value=%!T, type=%!T",
69548 (duk_tval *) (thr->valstack + cat->idx_base + 0),
69549 (duk_tval *) (thr->valstack + cat->idx_base + 1)));
69550
69551 tv1 = thr->valstack + cat->idx_base + 1; /* type */
69553 cont_type = (duk_small_uint_t) DUK_TVAL_GET_NUMBER(tv1);
69554
69555 switch (cont_type) {
69556 case DUK_LJ_TYPE_NORMAL: {
69557 DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'normal' (non-abrupt) completion -> "
69558 "dismantle catcher, resume execution after ENDFIN"));
69559 duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
69560 /* no need to unwind callstack */
69561 goto restart_execution;
69562 }
69563 case DUK_LJ_TYPE_RETURN: {
69564 DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'return' complation -> dismantle "
69565 "catcher, handle return, lj.value1=%!T", thr->valstack + cat->idx_base));
69566
69567 /* Not necessary to unwind catchstack: return handling will
69568 * do it. The finally flag of 'cat' is no longer set. The
69569 * catch flag may be set, but it's not checked by return handling.
69570 */
69571 DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat)); /* cleared before entering finally */
69572#if 0
69573 duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
69574#endif
69575
69576 duk_push_tval(ctx, thr->valstack + cat->idx_base);
69577 ret_result = duk__handle_return(thr,
69578 entry_thread,
69579 entry_callstack_top);
69580 if (ret_result == DUK__RETHAND_RESTART) {
69581 goto restart_execution;
69582 }
69583 DUK_ASSERT(ret_result == DUK__RETHAND_FINISHED);
69584
69585 DUK_DDD(DUK_DDDPRINT("exiting executor after ENDFIN and RETURN (pseudo) longjmp type"));
69586 return;
69587 }
69588 case DUK_LJ_TYPE_BREAK:
69589 case DUK_LJ_TYPE_CONTINUE: {
69590 duk_uint_t label_id;
69591 duk_small_uint_t lj_type;
69592
69593 /* Not necessary to unwind catchstack: break/continue
69594 * handling will do it. The finally flag of 'cat' is
69595 * no longer set. The catch flag may be set, but it's
69596 * not checked by break/continue handling.
69597 */
69598#if 0
69599 duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
69600#endif
69601
69602 tv1 = thr->valstack + cat->idx_base;
69604#if defined(DUK_USE_FASTINT)
69605 DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv1));
69606 label_id = (duk_small_uint_t) DUK_TVAL_GET_FASTINT_U32(tv1);
69607#else
69608 label_id = (duk_small_uint_t) DUK_TVAL_GET_NUMBER(tv1);
69609#endif
69610 lj_type = cont_type;
69611 duk__handle_break_or_continue(thr, label_id, lj_type);
69612 goto restart_execution;
69613 }
69614 default: {
69615 DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with abrupt completion, lj_type=%ld -> "
69616 "dismantle catcher, re-throw error",
69617 (long) cont_type));
69618
69619 duk_push_tval(ctx, thr->valstack + cat->idx_base);
69620
69622
69623 DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */
69624 duk_err_longjmp(thr);
69626 }
69627 }
69628
69629 /* Must restart in all cases because we NULLed thr->ptr_curr_pc. */
69631 break;
69632 }
69633
69634 case DUK_EXTRAOP_THROW: {
69635 duk_context *ctx = (duk_context *) thr;
69636 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69637
69638 /* Note: errors are augmented when they are created, not
69639 * when they are thrown. So, don't augment here, it would
69640 * break re-throwing for instance.
69641 */
69642
69643 /* Sync so that augmentation sees up-to-date activations, NULL
69644 * thr->ptr_curr_pc so that it's not used if side effects occur
69645 * in augmentation or longjmp handling.
69646 */
69648
69649 duk_dup(ctx, (duk_idx_t) bc);
69650 DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (before throw augment)",
69651 (duk_tval *) duk_get_tval(ctx, -1)));
69652#if defined(DUK_USE_AUGMENT_ERROR_THROW)
69654 DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (after throw augment)",
69655 (duk_tval *) duk_get_tval(ctx, -1)));
69656#endif
69657
69659
69660 DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */
69661 duk_err_longjmp(thr);
69663 break;
69664 }
69665
69666 case DUK_EXTRAOP_INVLHS: {
69667 DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "invalid lvalue");
69668
69670 break;
69671 }
69672
69673 case DUK_EXTRAOP_UNM:
69674 case DUK_EXTRAOP_UNP: {
69675 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69676 duk__vm_arith_unary_op(thr, DUK__REGP(bc), bc, extraop);
69677 break;
69678 }
69679
69680 case DUK_EXTRAOP_DEBUGGER: {
69681 /* Opcode only emitted by compiler when debugger
69682 * support is enabled. Ignore it silently without
69683 * debugger support, in case it has been loaded
69684 * from precompiled bytecode.
69685 */
69686#if defined(DUK_USE_DEBUGGER_SUPPORT)
69687 if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
69688 DUK_D(DUK_DPRINT("DEBUGGER statement encountered, halt execution"));
69690 duk_debug_halt_execution(thr, 1 /*use_prev_pc*/);
69691 DUK_D(DUK_DPRINT("DEBUGGER statement finished, resume execution"));
69692 goto restart_execution;
69693 } else {
69694 DUK_D(DUK_DPRINT("DEBUGGER statement ignored, debugger not attached"));
69695 }
69696#else
69697 DUK_D(DUK_DPRINT("DEBUGGER statement ignored, no debugger support"));
69698#endif
69699 break;
69700 }
69701
69702 case DUK_EXTRAOP_BREAK: {
69703 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69704
69705 DUK_DDD(DUK_DDDPRINT("BREAK: %ld", (long) bc));
69706
69709 goto restart_execution;
69710 }
69711
69712 case DUK_EXTRAOP_CONTINUE: {
69713 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69714
69715 DUK_DDD(DUK_DDDPRINT("CONTINUE: %ld", (long) bc));
69716
69719 goto restart_execution;
69720 }
69721
69722 case DUK_EXTRAOP_BNOT: {
69723 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69724
69725 duk__vm_bitwise_not(thr, DUK__REGP(bc), bc);
69726 break;
69727 }
69728
69729 case DUK_EXTRAOP_LNOT: {
69730 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69731 duk_tval *tv1;
69732
69733 tv1 = DUK__REGP(bc);
69734 duk__vm_logical_not(thr, tv1, tv1);
69735 break;
69736 }
69737
69738 case DUK_EXTRAOP_INSTOF: {
69739 duk_context *ctx = (duk_context *) thr;
69742 duk_bool_t tmp;
69743
69744 tmp = duk_js_instanceof(thr, DUK__REGP(b), DUK__REGCONSTP(c));
69745 duk_push_boolean(ctx, tmp);
69746 duk_replace(ctx, (duk_idx_t) b);
69747 break;
69748 }
69749
69750 case DUK_EXTRAOP_IN: {
69751 duk_context *ctx = (duk_context *) thr;
69754 duk_bool_t tmp;
69755
69756 tmp = duk_js_in(thr, DUK__REGP(b), DUK__REGCONSTP(c));
69757 duk_push_boolean(ctx, tmp);
69758 duk_replace(ctx, (duk_idx_t) b);
69759 break;
69760 }
69761
69762 case DUK_EXTRAOP_LABEL: {
69763 duk_catcher *cat;
69764 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69765
69766 /* allocate catcher and populate it (should be atomic) */
69767
69769 cat = thr->catchstack + thr->catchstack_top;
69770 thr->catchstack_top++;
69771
69773 cat->callstack_index = thr->callstack_top - 1;
69774 cat->pc_base = (duk_instr_t *) curr_pc; /* pre-incremented, points to first jump slot */
69775 cat->idx_base = 0; /* unused for label */
69776 cat->h_varname = NULL;
69777
69778 DUK_DDD(DUK_DDDPRINT("LABEL catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, "
69779 "idx_base=%ld, h_varname=%!O, label_id=%ld",
69780 (long) cat->flags, (long) cat->callstack_index, (long) cat->pc_base,
69781 (long) cat->idx_base, (duk_heaphdr *) cat->h_varname, (long) DUK_CAT_GET_LABEL(cat)));
69782
69783 curr_pc += 2; /* skip jump slots */
69784 break;
69785 }
69786
69787 case DUK_EXTRAOP_ENDLABEL: {
69788 duk_catcher *cat;
69789#if defined(DUK_USE_DDDPRINT) || defined(DUK_USE_ASSERTIONS)
69790 duk_uint_fast_t bc = DUK_DEC_BC(ins);
69791#endif
69792#if defined(DUK_USE_DDDPRINT)
69793 DUK_DDD(DUK_DDDPRINT("ENDLABEL %ld", (long) bc));
69794#endif
69795
69796 DUK_ASSERT(thr->catchstack_top >= 1);
69797
69798 cat = thr->catchstack + thr->catchstack_top - 1;
69799 DUK_UNREF(cat);
69802
69803 duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
69804 /* no need to unwind callstack */
69805 break;
69806 }
69807
69808 default: {
69809 DUK__INTERNAL_ERROR("invalid extra opcode");
69810 }
69811
69812 } /* end switch */
69813
69814 break;
69815 }
69816
duk_uint_fast32_t duk_uint_fast_t
duk_int_fast32_t duk_int_fast_t
duk_uint_fast16_t duk_small_uint_fast_t
#define DUK_ERR_INTERNAL_ERROR
#define DUK_ERR_REFERENCE_ERROR
#define DUK_OP_LDINT
#define DUK_OP_TRYCATCH
#define DUK_DEC_OP(x)
#define DUK_TVAL_SET_NUMBER_UPDREF
#define DUK_ENC_OP(op)
#define DUK_DEC_B(x)
#define DUK_EXTRAOP_THROW
#define DUK_TVAL_SET_FASTINT_UPDREF
#define DUK_STRIDX_ENUMERABLE
#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY
#define DUK_CAT_LABEL_SHIFT
DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr)
#define DUK_DEC_A(x)
#define DUK__CONSTP(x)
DUK_INTERNAL_DECL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y)
#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING
#define DUK_COMPARE_FLAG_NEGATE
DUK_INTERNAL_DECL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value)
DUK_INTERNAL_DECL void duk_hthread_catchstack_grow(duk_hthread *thr)
DUK_EXTERNAL void duk_push_boolean(duk_context *ctx, duk_bool_t val)
DUK_EXTERNAL void duk_to_undefined(duk_context *ctx, duk_idx_t index)
#define DUK_CAT_CLEAR_CATCH_ENABLED(c)
#define DUK_EXTRAOP_ENDTRY
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_INTERNAL_DECL void duk_js_putvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_tval *val, duk_bool_t strict)
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)
#define DUK_EXTRAOP_SETALEN
#define DUK_TVAL_IS_UNDEFINED(tv)
#define DUK_STRIDX_SET
#define DUK_BC_REGLIMIT
DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs)
#define DUK_EXTRAOP_NEXTENUM
#define DUK_TVAL_SET_TVAL_UPDREF_FAST
#define DUK_TVAL_SET_NULL_UPDREF
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__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_uint_fast_t idx_z)
#define DUK_EXTRAOP_ENDFIN
DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_bool_t throw_flag)
#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, p)
#define DUK_STRIDX_LC_UNDEFINED
#define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST
#define DUK__REGP(x)
#define DUK_STRIDX_DEFINE_PROPERTY
#define DUK_CALL_FLAG_IS_TAILCALL
DUK_INTERNAL_DECL duk_hstring * duk_js_typeof(duk_hthread *thr, duk_tval *tv_x)
#define DUK_EXTRAOP_ENDLABEL
#define DUK_DEC_C(x)
#define DUK__FUN()
#define DUK_EXTRAOP_NEWOBJ
#define DUK_TVAL_SET_BOOLEAN_UPDREF
DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type)
DUK_LOCAL void duk__vm_logical_not(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_z)
#define DUK_EXTRAOP_BREAK
#define DUK_TVAL_SET_FASTINT(tv, val)
DUK_INTERNAL_DECL void duk_regexp_create_instance(duk_hthread *thr)
#define DUK_TVAL_SET_NUMBER_CHKFAST(tv, d)
#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH
#define DUK_BC_JUMP_BIAS
#define DUK_OP_LDINTX
#define DUK_OP_RETURN
#define DUK_EXTRAOP_INITENUM
#define DUK_HOBJECT_DECREF(thr, h)
#define DUK_BC_RETURN_FLAG_HAVE_RETVAL
DUK_EXTERNAL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index)
#define DUK_EXTRAOP_INVALID
DUK_INTERNAL_DECL duk_bool_t duk_js_delvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name)
#define DUK__REGCONSTP(x)
#define DUK_CAT_HAS_LEXENV_ACTIVE(c)
#define DUK_EXTRAOP_ENDCATCH
#define DUK__SYNC_AND_NULL_CURR_PC()
#define DUK__STRICT()
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)
#define DUK_EXTRAOP_DEBUGGER
#define DUK_DEC_BC(x)
#define DUK_BC_LDINTX_SHIFT
#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING
#define duk_js_equals(thr, tv_x, tv_y)
DUK_INTERNAL_DECL duk_bool_t duk_js_toboolean(duk_tval *tv)
#define DUK_EXTRAOP_NEWARR
DUK_INTERNAL_DECL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags)
#define duk_js_strict_equals(tv_x, tv_y)
DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index)
#define DUK_BIDX_OBJECT_CONSTRUCTOR
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_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL void duk_handle_call_unprotected(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags)
#define DUK_STRIDX_CONFIGURABLE
#define DUK_EXTRAOP_LABEL
#define DUK__INTERNAL_ERROR(msg)
DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr)
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)
#define DUK_CAT_CLEAR_LEXENV_ACTIVE(c)
#define DUK_ERROR(thr, err, msg)
#define DUK_EXTRAOP_CONTINUE
DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_eval(duk_context *ctx)
#define DUK_CAT_CLEAR_FINALLY_ENABLED(c)
#define DUK_BC_LDINT_BIAS
#define DUK_EXTRAOP_NOP
DUK_LOCAL_DECL void duk__js_execute_bytecode_inner(duk_hthread *entry_thread, duk_size_t entry_callstack_top)
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)
#define DUK_DEC_ABC(x)
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_INTERNAL_DECL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx)
#define DUK_STRIDX_GET
#define DUK_TVAL_SET_FASTINT_I32_UPDREF
#define DUK_BC_CALL_FLAG_TAILCALL
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__js_samevalue_number()

DUK_LOCAL duk_bool_t duk__js_samevalue_number ( duk_double_t x,
duk_double_t y )

Definition at line 70316 of file duktape-1.5.2/src/duktape.c.

70317 {
70318 /* IEEE requires that NaNs compare false */
70321 return 1;
70322 } else {
70323 /* IEEE requires that zeros compare the same regardless
70324 * of their signed, so if both x and y are zeroes, they
70325 * are caught above.
70326 */
70328 return 0;
70329 }
70330#endif /* DUK_USE_PARANOID_MATH */
70331}
70332
70334#if defined(DUK_USE_PARANOID_MATH)
70337
70338 if (cx == DUK_FP_NAN && cy == DUK_FP_NAN) {
70339 /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
70340 return 1;
70341 }
70342 if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
70343 /* Note: cannot assume that a non-zero return value of signbit() would
70344 * always be the same -- hence cannot (portably) use something like:
70345 *
70346 * signbit(x) == signbit(y)
70347 */
70348 duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
70349 duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
70350 return (sx == sy);
70351 }
70352
70353 /* normal comparison; known:
70354 * - both x and y are not NaNs (but one of them can be)
70355 * - both x and y are not zero (but one of them can be)
70356 * - x and y may be denormal or infinite
70357 */
70358
70359 return (x == y);
70360#else /* DUK_USE_PARANOID_MATH */
70363
70364 if (x == y) {
70365 /* IEEE requires that NaNs compare false */
70368
70369 /* Using classification has smaller footprint than direct comparison. */
70370 if (DUK_UNLIKELY(cx == DUK_FP_ZERO && cy == DUK_FP_ZERO)) {
70371 /* Note: cannot assume that a non-zero return value of signbit() would
70372 * always be the same -- hence cannot (portably) use something like:
70373 *
70374 * signbit(x) == signbit(y)
70375 */
70376 duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
70377 duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
70378 return (sx == sy);
70379 }
70380 return 1;
70381 } else {
DUK_LOCAL duk_bool_t duk__js_samevalue_number(duk_double_t x, duk_double_t y)

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 47333 of file duktape-1.5.2/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 11679 of file duktape-1.5.2/src/duktape.c.

11687 {
11688 duk_uint32_t len;
11689

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 12014 of file duktape-1.5.2/src/duktape.c.

12027 { \
12028 DUK_ASSERT((duk_size_t) (p_end - p) >= (duk_size_t) (n)); \
12029 } while (0)
12030
12031static duk_uint8_t *duk__load_func(duk_context *ctx, duk_uint8_t *p, duk_uint8_t *p_end) {
12032 duk_hthread *thr;
12033 duk_hcompiledfunction *h_fun;
12034 duk_hbuffer *h_data;
12035 duk_size_t data_size;
12036 duk_uint32_t count_instr, count_const, count_funcs;
12037 duk_uint32_t n;
12038 duk_uint32_t tmp32;
12039 duk_small_uint_t const_type;
12040 duk_uint8_t *fun_data;
12041 duk_uint8_t *q;
12042 duk_idx_t idx_base;
12043 duk_tval *tv1;
12044 duk_uarridx_t arr_idx;
12045
12046 /* XXX: There's some overlap with duk_js_closure() here, but
12047 * seems difficult to share code. Ensure that the final function
12048 * looks the same as created by duk_js_closure().
12049 */
12050
12051 DUK_ASSERT(ctx != NULL);
12052 thr = (duk_hthread *) ctx;
12053
12054 DUK_DD(DUK_DDPRINT("loading function, p=%p, p_end=%p", (void *) p, (void *) p_end));
12055
12056 DUK__ASSERT_LEFT(3 * 4);
12057 count_instr = DUK_RAW_READ_U32_BE(p);
12058 count_const = DUK_RAW_READ_U32_BE(p);
12059 count_funcs = DUK_RAW_READ_U32_BE(p);
12060
12061 data_size = sizeof(duk_tval) * count_const +
12062 sizeof(duk_hobject *) * count_funcs +
12063 sizeof(duk_instr_t) * count_instr;
12064
12065 DUK_DD(DUK_DDPRINT("instr=%ld, const=%ld, funcs=%ld, data_size=%ld",
12066 (long) count_instr, (long) count_const,
12067 (long) count_const, (long) data_size));
12068
12069 /* Value stack is used to ensure reachability of constants and
12070 * inner functions being loaded. Require enough space to handle
12071 * large functions correctly.
12072 */
12073 duk_require_stack(ctx, 2 + count_const + count_funcs);
12074 idx_base = duk_get_top(ctx);
12075
12076 /* Push function object, init flags etc. This must match
12077 * duk_js_push_closure() quite carefully.
12078 */
12080 h_fun = duk_get_hcompiledfunction(ctx, -1);
12081 DUK_ASSERT(h_fun != NULL);
12086
12087 h_fun->nregs = DUK_RAW_READ_U16_BE(p);
12088 h_fun->nargs = DUK_RAW_READ_U16_BE(p);
12089#if defined(DUK_USE_DEBUGGER_SUPPORT)
12090 h_fun->start_line = DUK_RAW_READ_U32_BE(p);
12091 h_fun->end_line = DUK_RAW_READ_U32_BE(p);
12092#else
12093 p += 8; /* skip line info */
12094#endif
12095
12096 /* duk_hcompiledfunction flags; quite version specific */
12097 tmp32 = DUK_RAW_READ_U32_BE(p);
12098 DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32);
12099
12100 /* standard prototype */
12102
12103 /* assert just a few critical flags */
12112
12113 /* Create function 'data' buffer but don't attach it yet. */
12114 fun_data = (duk_uint8_t *) duk_push_fixed_buffer(ctx, data_size);
12115 DUK_ASSERT(fun_data != NULL);
12116
12117 /* Load bytecode instructions. */
12118 DUK_ASSERT(sizeof(duk_instr_t) == 4);
12119 DUK__ASSERT_LEFT(count_instr * sizeof(duk_instr_t));
12120#if defined(DUK_USE_INTEGER_BE)
12121 q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
12122 DUK_MEMCPY((void *) q,
12123 (const void *) p,
12124 sizeof(duk_instr_t) * count_instr);
12125 p += sizeof(duk_instr_t) * count_instr;
12126#else
12127 q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
12128 for (n = count_instr; n > 0; n--) {
12129 *((duk_instr_t *) (void *) q) = DUK_RAW_READ_U32_BE(p);
12130 q += sizeof(duk_instr_t);
12131 }
12132#endif
12133
12134 /* Load constants onto value stack but don't yet copy to buffer. */
12135 for (n = count_const; n > 0; n--) {
12137 const_type = DUK_RAW_READ_U8(p);
12138 switch (const_type) {
12139 case DUK__SER_STRING: {
12140 p = duk__load_string_raw(ctx, p);
12141 break;
12142 }
12143 case DUK__SER_NUMBER: {
12144 /* Important to do a fastint check so that constants are
12145 * properly read back as fastints.
12146 */
12147 duk_tval tv_tmp;
12148 duk_double_t val;
12150 val = DUK_RAW_READ_DOUBLE_BE(p);
12151 DUK_TVAL_SET_NUMBER_CHKFAST(&tv_tmp, val);
12152 duk_push_tval(ctx, &tv_tmp);
12153 break;
12154 }
12155 default: {
12156 goto format_error;
12157 }
12158 }
12159 }
12160
12161 /* Load inner functions to value stack, but don't yet copy to buffer. */
12162 for (n = count_funcs; n > 0; n--) {
12163 p = duk__load_func(ctx, p, p_end);
12164 if (p == NULL) {
12165 goto format_error;
12166 }
12167 }
12168
12169 /* With constants and inner functions on value stack, we can now
12170 * atomically finish the function 'data' buffer, bump refcounts,
12171 * etc.
12172 *
12173 * Here we take advantage of the value stack being just a duk_tval
12174 * array: we can just memcpy() the constants as long as we incref
12175 * them afterwards.
12176 */
12177
12178 h_data = (duk_hbuffer *) duk_get_hbuffer(ctx, idx_base + 1);
12179 DUK_ASSERT(h_data != NULL);
12181 DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_fun, h_data);
12182 DUK_HBUFFER_INCREF(thr, h_data);
12183
12184 tv1 = duk_get_tval(ctx, idx_base + 2); /* may be NULL if no constants or inner funcs */
12185 DUK_ASSERT((count_const == 0 && count_funcs == 0) || tv1 != NULL);
12186
12187 q = fun_data;
12188 if (count_const > 0) {
12189 /* Explicit zero size check to avoid NULL 'tv1'. */
12190 DUK_MEMCPY((void *) q, (const void *) tv1, sizeof(duk_tval) * count_const);
12191 for (n = count_const; n > 0; n--) {
12192 DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q); /* no side effects */
12193 q += sizeof(duk_tval);
12194 }
12195 tv1 += count_const;
12196 }
12197
12198 DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_fun, (duk_hobject **) (void *) q);
12199 for (n = count_funcs; n > 0; n--) {
12200 duk_hobject *h_obj;
12201
12203 h_obj = DUK_TVAL_GET_OBJECT(tv1);
12204 DUK_ASSERT(h_obj != NULL);
12205 tv1++;
12206 DUK_HOBJECT_INCREF(thr, h_obj);
12207
12208 *((duk_hobject **) (void *) q) = h_obj;
12209 q += sizeof(duk_hobject *);
12210 }
12211
12212 DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_fun, (duk_instr_t *) (void *) q);
12213
12214 /* The function object is now reachable and refcounts are fine,
12215 * so we can pop off all the temporaries.
12216 */
12217 DUK_DDD(DUK_DDDPRINT("function is reachable, reset top; func: %!iT", duk_get_tval(ctx, idx_base)));
12218 duk_set_top(ctx, idx_base + 1);
12219
12220 /* Setup function properties. */
12221 tmp32 = DUK_RAW_READ_U32_BE(p);
12222 duk_push_u32(ctx, tmp32);
12224
12225 p = duk__load_string_raw(ctx, p);
12227 /* Original function instance/template had NAMEBINDING.
12228 * Must create a lexical environment on loading to allow
12229 * recursive functions like 'function foo() { foo(); }'.
12230 */
12232
12237 proto);
12238 duk_dup(ctx, -2); /* -> [ func funcname env funcname ] */
12239 duk_dup(ctx, idx_base); /* -> [ func funcname env funcname func ] */
12240 duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ func funcname env ] */
12242 /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
12243 * will be ignored anyway
12244 */
12245 }
12247
12248 p = duk__load_string_raw(ctx, p);
12250
12251 duk_push_object(ctx);
12252 duk_dup(ctx, -2);
12253 duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC); /* func.prototype.constructor = func */
12254 duk_compact(ctx, -1);
12256
12257 p = duk__load_buffer_raw(ctx, p);
12259
12260 duk_push_object(ctx); /* _Varmap */
12261 for (;;) {
12262 /* XXX: awkward */
12263 p = duk__load_string_raw(ctx, p);
12264 if (duk_get_length(ctx, -1) == 0) {
12265 duk_pop(ctx);
12266 break;
12267 }
12268 tmp32 = DUK_RAW_READ_U32_BE(p);
12269 duk_push_u32(ctx, tmp32);
12270 duk_put_prop(ctx, -3);
12271 }
12272 duk_compact(ctx, -1);
12274
12275 duk_push_array(ctx); /* _Formals */
12276 for (arr_idx = 0; ; arr_idx++) {
12277 /* XXX: awkward */
12278 p = duk__load_string_raw(ctx, p);
const char * proto
Definition civetweb.c:18378
#define DUK_HBUFFER_INCREF(thr, h)
#define DUK_TVAL_INCREF_FAST(thr, tv)
DUK_INTERNAL_DECL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags)
#define DUK_BIDX_FUNCTION_PROTOTYPE
#define DUK_STRIDX_CONSTRUCTOR
#define DUK__ASSERT_LEFT(n)
DUK_LOCAL duk_uint8_t * duk__load_string_raw(duk_context *ctx, duk_uint8_t *p)
static duk_uint8_t * duk__load_func(duk_context *ctx, duk_uint8_t *p, duk_uint8_t *p_end)
#define DUK_STRIDX_INT_LEXENV
#define DUK_RAW_READ_U8(ptr)
#define DUK_HEAPHDR_SET_FLAGS(h, val)
#define DUK_HOBJECT_HAS_THREAD(h)
DUK_LOCAL duk_uint8_t * duk__load_buffer_raw(duk_context *ctx, duk_uint8_t *p)
#define DUK_RAW_READ_DOUBLE_BE(ptr)
DUK_INTERNAL_DECL duk_hcompiledfunction * duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index)
#define DUK_RAW_READ_U16_BE(ptr)
#define DUK_STRIDX_PROTOTYPE
#define duk_push_u32(ctx, val)
#define DUK_PROPDESC_FLAGS_W
#define DUK_HOBJECT_HAS_NAMEBINDING(h)

◆ duk__load_string_raw()

DUK_LOCAL duk_uint8_t * duk__load_string_raw ( duk_context * ctx,
duk_uint8_t * p )

Definition at line 11670 of file duktape-1.5.2/src/duktape.c.

◆ duk__log()

DUK_LOCAL double duk__log ( double x)

Definition at line 32552 of file duktape-1.5.2/src/duktape.c.

32554 {

◆ 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 60106 of file duktape-1.5.2/src/duktape.c.

60123 {
60124 duk_hthread *thr = comp_ctx->thr;
60125 duk_context *ctx = (duk_context *) thr;
60126 duk_uint8_t *p;
60127 duk_labelinfo *li_start, *li_end, *li;
60128 duk_bool_t match = 0;
60129
60130 DUK_DDD(DUK_DDDPRINT("looking up active label: label='%!O', is_break=%ld",
60131 (duk_heaphdr *) h_label, (long) is_break));
60132
60133 DUK_UNREF(ctx);
60134
60135 p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
60136 li_start = (duk_labelinfo *) (void *) p;
60137 li_end = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
60138 li = li_end;
60139
60140 /* Match labels starting from latest label because there can be duplicate empty
60141 * labels in the label set.
60142 */
60143 while (li > li_start) {
60144 li--;
60145
60146 if (li->h_label != h_label) {
60147 DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] ->'%!O' != %!O",
60148 (long) (li - li_start),
60149 (duk_heaphdr *) li->h_label,
60150 (duk_heaphdr *) h_label));
60151 continue;
60152 }
60153
60154 DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] -> '%!O' label name matches (still need to check type)",
60155 (long) (li - li_start), (duk_heaphdr *) h_label));
60156
60157 /* currently all labels accept a break, so no explicit check for it now */
60159
60160 if (is_break) {
60161 /* break matches always */
60162 match = 1;
60163 break;
60164 } else if (li->flags & DUK_LABEL_FLAG_ALLOW_CONTINUE) {
60165 /* iteration statements allow continue */
60166 match = 1;
60167 break;
60168 } else {
60169 /* continue matched this label -- we can only continue if this is the empty
60170 * label, for which duplication is allowed, and thus there is hope of
60171 * finding a match deeper in the label stack.
60172 */
60173 if (h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) {
60175 } else {
60176 DUK_DDD(DUK_DDDPRINT("continue matched an empty label which does not "
60177 "allow a continue -> continue lookup deeper in label stack"));
#define DUK_LABEL_FLAG_ALLOW_CONTINUE
#define DUK_LABEL_FLAG_ALLOW_BREAK
#define DUK_STR_INVALID_LABEL

◆ duk__lookup_active_register_binding()

DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding ( duk_compiler_ctx * comp_ctx)

Definition at line 59903 of file duktape-1.5.2/src/duktape.c.

59904 {
59906}
59907
59908/* The issues below can be solved with better flags */
59909
59910/* XXX: many operations actually want toforcedtemp() -- brand new temp? */
59911/* XXX: need a toplain_ignore() which will only coerce a value to a temp
59912 * register if it might have a side effect. Side-effect free values do not
59913 * need to be coerced.
59914 */
59915
59916/*
59917 * Identifier handling
59918 */
59919
59921 duk_hthread *thr = comp_ctx->thr;
59922 duk_context *ctx = (duk_context *) thr;
59923 duk_hstring *h_varname;
59924 duk_reg_t ret;
59925
59926 DUK_DDD(DUK_DDDPRINT("resolving identifier reference to '%!T'",
59927 (duk_tval *) duk_get_tval(ctx, -1)));
59928
59929 /*
59930 * Special name handling
59931 */
59932
59933 h_varname = duk_get_hstring(ctx, -1);
59934 DUK_ASSERT(h_varname != NULL);
59935
59936 if (h_varname == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)) {
59937 DUK_DDD(DUK_DDDPRINT("flagging function as accessing 'arguments'"));
59938 comp_ctx->curr_func.id_access_arguments = 1;
59939 }
59940
59941 /*
59942 * Inside one or more 'with' statements fall back to slow path always.
59943 * (See e.g. test-stmt-with.js.)
59944 */
59945
59946 if (comp_ctx->curr_func.with_depth > 0) {
59947 DUK_DDD(DUK_DDDPRINT("identifier lookup inside a 'with' -> fall back to slow path"));
59948 goto slow_path;
59949 }
59950
59951 /*
59952 * Any catch bindings ("catch (e)") also affect identifier binding.
59953 *
59954 * Currently, the varmap is modified for the duration of the catch
59955 * clause to ensure any identifier accesses with the catch variable
59956 * name will use slow path.
59957 */
59958
59959 duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx)

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 48560 of file duktape-1.5.2/src/duktape.c.

48582 {
48583 duk_context *ctx = (duk_context *) thr;
48584 duk_hobject *map;
48585 duk_hobject *varenv;
48586 duk_bool_t rc;
48587
48589
48590 DUK_DDD(DUK_DDDPRINT("arguments map lookup: thr=%p, obj=%p, key=%p, temp_desc=%p "
48591 "(obj -> %!O, key -> %!O)",
48592 (void *) thr, (void *) obj, (void *) key, (void *) temp_desc,
48593 (duk_heaphdr *) obj, (duk_heaphdr *) key));
48594
48596 DUK_DDD(DUK_DDDPRINT("-> no 'map'"));
48597 return 0;
48598 }
48599
48600 map = duk_require_hobject(ctx, -1);
48601 DUK_ASSERT(map != NULL);
48602 duk_pop(ctx); /* map is reachable through obj */
48603
48604 if (!duk_hobject_get_own_propdesc(thr, map, key, temp_desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
48605 DUK_DDD(DUK_DDDPRINT("-> 'map' exists, but key not in map"));
48606 return 0;
48607 }
48608
48609 /* [... varname] */
48610 DUK_DDD(DUK_DDDPRINT("-> 'map' exists, and contains key, key is mapped to argument/variable binding %!T",
48611 (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 59969 of file duktape-1.5.2/src/duktape.c.

59971 :
59972 DUK_DDD(DUK_DDDPRINT("identifier lookup -> slow path"));
59973
59974 comp_ctx->curr_func.id_access_slow = 1;
59975 return (duk_reg_t) -1;
59976}
59977
59978/* Lookup an identifier name in the current varmap, indicating whether the
59979 * identifier is register-bound and if not, allocating a constant for the
59980 * identifier name. Returns 1 if register-bound, 0 otherwise. Caller can
59981 * also check (out_reg_varbind >= 0) to check whether or not identifier is
59982 * register bound. The caller must NOT use out_rc_varname at all unless
59983 * return code is 0 or out_reg_varbind is < 0; this is becuase out_rc_varname
59984 * is unsigned and doesn't have a "unused" / none value.
59985 */
59986DUK_LOCAL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *comp_ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) {
59987 duk_hthread *thr = comp_ctx->thr;
59988 duk_context *ctx = (duk_context *) thr;
59989 duk_reg_t reg_varbind;
59990 duk_regconst_t rc_varname;
59991

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 24948 of file duktape-1.5.2/src/duktape.c.

24951 : 365));
24952 return year;
24953 }
24954
24955 /* Note: this is very tricky; we must never 'overshoot' the
24956 * correction downwards.
24957 */
24958 year -= 1 + (diff_days - 1) / 366; /* conservative */
24959 }
24960}
24961
24962/* Given a (year, month, day-within-month) triple, compute day number.
24963 * The input triple is un-normalized and may contain non-finite values.
24964 */
24966 duk_int_t day_num;
24967 duk_bool_t is_leap;
24968 duk_small_int_t i, n;
24969
24970 /* Assume that year, month, day are all coerced to whole numbers.
24971 * They may also be NaN or infinity, in which case this function
24972 * must return NaN or infinity to ensure time value becomes NaN.
24973 * If 'day' is NaN, the final return will end up returning a NaN,
24974 * so it doesn't need to be checked here.
24975 */
24976
24977 if (!DUK_ISFINITE(year) || !DUK_ISFINITE(month)) {
24978 return DUK_DOUBLE_NAN;
24979 }
24980
24981 year += DUK_FLOOR(month / 12.0);
24982
24983 month = DUK_FMOD(month, 12.0);
24984 if (month < 0.0) {
24985 /* handle negative values */
24986 month += 12.0;
24987 }
24988
24989 /* The algorithm in E5.1 Section 15.9.1.12 normalizes month, but
24990 * does not normalize the day-of-month (nor check whether or not
24991 * it is finite) because it's not necessary for finding the day
24992 * number which matches the (year,month) pair.
24993 *
24994 * We assume that duk__day_from_year() is exact here.
24995 *
24996 * Without an explicit infinity / NaN check in the beginning,
24997 * day_num would be a bogus integer here.
24998 *
24999 * It's possible for 'year' to be out of integer range here.
25000 * If so, we need to return NaN without integer overflow.
25001 * This fixes test-bug-setyear-overflow.js.
25002 */
25003
DUK_INTERNAL_DECL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t year)
DUK_LOCAL duk_double_t duk__make_day(duk_double_t year, duk_double_t month, duk_double_t day)

◆ duk__mark_finalizable()

DUK_LOCAL void duk__mark_finalizable ( duk_heap * heap)

Definition at line 42218 of file duktape-1.5.2/src/duktape.c.

42235 {
42236 duk_hthread *thr;
42237 duk_heaphdr *hdr;
42238 duk_size_t count_finalizable = 0;
42239
42240 DUK_DD(DUK_DDPRINT("duk__mark_finalizable: %p", (void *) heap));
42241
42242 thr = duk__get_temp_hthread(heap);
42243 DUK_ASSERT(thr != NULL);
42244
42245 hdr = heap->heap_allocated;
42246 while (hdr) {
42247 /* A finalizer is looked up from the object and up its prototype chain
42248 * (which allows inherited finalizers). A prototype loop must not cause
42249 * an error to be thrown here; duk_hobject_hasprop_raw() will ignore a
42250 * prototype loop silently and indicate that the property doesn't exist.
42251 */
42252
42253 if (!DUK_HEAPHDR_HAS_REACHABLE(hdr) &&
42257
42258 /* heaphdr:
42259 * - is not reachable
42260 * - is an object
42261 * - is not a finalized object
42262 * - has a finalizer
42263 */
42264
42265 DUK_DD(DUK_DDPRINT("unreachable heap object will be "
42266 "finalized -> mark as finalizable "
42267 "and treat as a reachability root: %p",
42268 (void *) hdr));
42271 count_finalizable ++;
42272 }
42273
42274 hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
42275 }
42276
42277 if (count_finalizable == 0) {
#define DUK_HEAPHDR_SET_FINALIZABLE(h)

◆ duk__mark_finalize_list()

DUK_LOCAL void duk__mark_finalize_list ( duk_heap * heap)

Definition at line 42284 of file duktape-1.5.2/src/duktape.c.

42285 {
42286 if (DUK_HEAPHDR_HAS_FINALIZABLE(hdr)) {
42287 duk__mark_heaphdr(heap, hdr);
42288 }
42289
42290 hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
42291 }
42292
42293 /* Caller will finish the marking process if we hit a recursion limit. */
42294}
42295
42296/*
42297 * Mark objects on finalize_list.
42298 *
42299 */
42300
42302 duk_heaphdr *hdr;
42303#ifdef DUK_USE_DEBUG
42304 duk_size_t count_finalize_list = 0;
42305#endif
42306
42307 DUK_DD(DUK_DDPRINT("duk__mark_finalize_list: %p", (void *) heap));
DUK_LOCAL_DECL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h)
DUK_LOCAL void duk__mark_finalize_list(duk_heap *heap)
#define DUK_HEAPHDR_HAS_FINALIZABLE(h)

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 42097 of file duktape-1.5.2/src/duktape.c.

42099 {
42100 duk_catcher *cat = t->catchstack + i;
42101 }
42102#endif
42103
42104 duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer);
42105
42106 /* XXX: duk_small_uint_t would be enough for this loop */
42107 for (i = 0; i < DUK_NUM_BUILTINS; i++) {
42108 duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]);
42109 }
42110 }
42111}
42112
42113/* recursion tracking happens here only */
42115 DUK_DDD(DUK_DDDPRINT("duk__mark_heaphdr %p, type %ld",
42116 (void *) h,
42117 (h != NULL ? (long) DUK_HEAPHDR_GET_TYPE(h) : (long) -1)));
42118 if (!h) {
42119 return;
42120 }
42121#if defined(DUK_USE_ROM_OBJECTS)
42122 if (DUK_HEAPHDR_HAS_READONLY(h)) {
42123 DUK_DDD(DUK_DDDPRINT("readonly object %p, skip", (void *) h));
42124 return;
42125 }
42126#endif
42128 DUK_DDD(DUK_DDDPRINT("already marked reachable, skip"));
42129 return;
42130 }
42132
42134 /* log this with a normal debug level because this should be relatively rare */
42135 DUK_D(DUK_DPRINT("mark-and-sweep recursion limit reached, marking as temproot: %p", (void *) h));
42138 return;
42139 }
42140
42142
#define DUK_USE_MARK_AND_SWEEP_RECLIMIT
#define DUK_HEAPHDR_SET_REACHABLE(h)
#define DUK_HEAPHDR_SET_TEMPROOT(h)
#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap)
#define DUK_NUM_BUILTINS

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 41994 of file duktape-1.5.2/src/duktape.c.

42001 {
42002 DUK_UNREF(heap);
42003 DUK_UNREF(h);
42004
42005 DUK_DDD(DUK_DDDPRINT("duk__mark_hstring: %p", (void *) h));
42006 DUK_ASSERT(h);
42007
42008 /* nothing to process */
42009}
42010
42013
42014 DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h));
42015
42016 DUK_ASSERT(h);
42017
42018 /* XXX: use advancing pointers instead of index macros -> faster and smaller? */
42019
42020 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
42021 duk_hstring *key = DUK_HOBJECT_E_GET_KEY(heap, h, i);
42022 if (!key) {
42023 continue;
42024 }
42025 duk__mark_heaphdr(heap, (duk_heaphdr *) key);
42026 if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) {
42027 duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get);
42028 duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set);
42029 } else {
42030 duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v);
42031 }
42032 }
42033
42034 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
42036 }
42037
42038 /* hash part is a 'weak reference' and does not contribute */
42039
42041
42044 duk_tval *tv, *tv_end;
42045 duk_hobject **fn, **fn_end;
42046
42047 /* 'data' is reachable through every compiled function which
42048 * contains a reference.
42049 */
42050
42052
42053 if (DUK_HCOMPILEDFUNCTION_GET_DATA(heap, f) != NULL) {
42055 tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, f);
42056 while (tv < tv_end) {
42057 duk__mark_tval(heap, tv);
42058 tv++;
42059 }
42060
42062 fn_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f);
42063 while (fn < fn_end) {
42064 duk__mark_heaphdr(heap, (duk_heaphdr *) *fn);
42065 fn++;
42066 }
42067 } else {
42068 /* May happen in some out-of-memory corner cases. */
42069 DUK_D(DUK_DPRINT("duk_hcompiledfunction 'data' is NULL, skipping marking"));
42070 }
42071 } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
42073 DUK_UNREF(f);
42074 /* nothing to mark */
42075 } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
42077 duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf);
42078 } else if (DUK_HOBJECT_IS_THREAD(h)) {
42079 duk_hthread *t = (duk_hthread *) h;
42080 duk_tval *tv;
42081
42082 tv = t->valstack;
42083 while (tv < t->valstack_top) {
42084 duk__mark_tval(heap, tv);
42085 tv++;
42086 }
42087
42088 for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
42089 duk_activation *act = t->callstack + i;
42091 duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env);
42092 duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env);
42093#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
42094 duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller);
#define DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)
DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h)
DUK_LOCAL_DECL void duk__mark_tval(duk_heap *heap, duk_tval *tv)

◆ duk__mark_hstring()

DUK_LOCAL void duk__mark_hstring ( duk_heap * heap,
duk_hstring * h )

Definition at line 41984 of file duktape-1.5.2/src/duktape.c.

41990 {
41991 if (heap->curr_thread) {
41992 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 42193 of file duktape-1.5.2/src/duktape.c.

◆ duk__mark_roots_heap()

DUK_LOCAL void duk__mark_roots_heap ( duk_heap * heap)

Definition at line 42158 of file duktape-1.5.2/src/duktape.c.

42161 {
42162 DUK_DDD(DUK_DDDPRINT("duk__mark_tval %p", (void *) tv));
42163 if (!tv) {
42164 return;
42165 }
42168 }
42169}
42170
42171/*
42172 * Mark the heap.
42173 */
42174
42177
42178 DUK_DD(DUK_DDPRINT("duk__mark_roots_heap: %p", (void *) heap));
42179
DUK_LOCAL void duk__mark_roots_heap(duk_heap *heap)

◆ duk__mark_temproots_by_heap_scan()

DUK_LOCAL void duk__mark_temproots_by_heap_scan ( duk_heap * heap)

Definition at line 42343 of file duktape-1.5.2/src/duktape.c.

42343 {
42344#endif
42345 if (!DUK_HEAPHDR_HAS_TEMPROOT(hdr)) {
42346 DUK_DDD(DUK_DDDPRINT("not a temp root: %p", (void *) hdr));
42347 return;
42348 }
42349
42350 DUK_DDD(DUK_DDDPRINT("found a temp root: %p", (void *) hdr));
42352 DUK_HEAPHDR_CLEAR_REACHABLE(hdr); /* done so that duk__mark_heaphdr() works correctly */
42353 duk__mark_heaphdr(heap, hdr);
42354
42355#ifdef DUK_USE_DEBUG
42356 (*count)++;
42357#endif
42358}
42359
42361 duk_heaphdr *hdr;
42362#ifdef DUK_USE_DEBUG
42363 duk_size_t count;
42364#endif
42365
42366 DUK_DD(DUK_DDPRINT("duk__mark_temproots_by_heap_scan: %p", (void *) heap));
42367
42369 DUK_DD(DUK_DDPRINT("recursion limit reached, doing heap scan to continue from temproots"));
42370
42371#ifdef DUK_USE_DEBUG
42372 count = 0;
42373#endif
42375
42376 hdr = heap->heap_allocated;
42377 while (hdr) {
42378#ifdef DUK_USE_DEBUG
42379 duk__handle_temproot(heap, hdr, &count);
42380#else
42381 duk__handle_temproot(heap, hdr);
42382#endif
42383 hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
42384 }
42385
42386 /* must also check refzero_list */
#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)
#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap)
DUK_LOCAL void duk__mark_temproots_by_heap_scan(duk_heap *heap)
DUK_LOCAL void duk__handle_temproot(duk_heap *heap, duk_heaphdr *hdr)
#define DUK_HEAPHDR_HAS_TEMPROOT(h)
#define DUK_HEAPHDR_CLEAR_REACHABLE(h)
#define DUK_HEAPHDR_CLEAR_TEMPROOT(h)

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 42144 of file duktape-1.5.2/src/duktape.c.

42144 :
42145 duk__mark_hstring(heap, (duk_hstring *) h);
42146 break;
42147 case DUK_HTYPE_OBJECT:
42148 duk__mark_hobject(heap, (duk_hobject *) h);
42149 break;
42150 case DUK_HTYPE_BUFFER:
42151 /* nothing to mark */
42152 break;
DUK_LOCAL void duk__mark_hstring(duk_heap *heap, duk_hstring *h)
#define DUK_HTYPE_BUFFER

◆ 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 78582 of file duktape-1.5.2/src/duktape.c.

78582 {
78583 /* note: caller 'sp' is intentionally not updated here */
78584 (void) duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) 1);
78585 return duk__inp_get_cp(re_ctx, &sp);
78586}
78587
78588/*
78589 * Regexp recursive matching function.
78590 *
78591 * Returns 'sp' on successful match (points to character after last matched one),
78592 * NULL otherwise.
78593 *
78594 * The C recursion depth limit check is only performed in this function, this
78595 * suffices because the function is present in all true recursion required by
78596 * regexp execution.
78597 */
78598
78599DUK_LOCAL const duk_uint8_t *duk__match_regexp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *pc, const duk_uint8_t *sp) {
78600 if (re_ctx->recursion_depth >= re_ctx->recursion_limit) {
78602 }
78603 re_ctx->recursion_depth++;
78604
78605 for (;;) {
78606 duk_small_int_t op;
78607
78608 if (re_ctx->steps_count >= re_ctx->steps_limit) {
78610 }
78611 re_ctx->steps_count++;
78612
78613 op = (duk_small_int_t) duk__bc_get_u32(re_ctx, &pc);
78614
78615 DUK_DDD(DUK_DDDPRINT("match: rec=%ld, steps=%ld, pc (after op)=%ld, sp=%ld, op=%ld",
78616 (long) re_ctx->recursion_depth,
78617 (long) re_ctx->steps_count,
78618 (long) (pc - re_ctx->bytecode),
78619 (long) (sp - re_ctx->input),
78620 (long) op));
78621
78622 switch (op) {
78623 case DUK_REOP_MATCH: {
78624 goto match;
78625 }
78626 case DUK_REOP_CHAR: {
78627 /*
78628 * Byte-based matching would be possible for case-sensitive
78629 * matching but not for case-insensitive matching. So, we
78630 * match by decoding the input and bytecode character normally.
78631 *
78632 * Bytecode characters are assumed to be already canonicalized.
78633 * Input characters are canonicalized automatically by
78634 * duk__inp_get_cp() if necessary.
78635 *
78636 * There is no opcode for matching multiple characters. The
78637 * regexp compiler has trouble joining strings efficiently
78638 * during compilation. See doc/regexp.rst for more discussion.
78639 */
78640 duk_codepoint_t c1, c2;
78641
78642 c1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
78644 c1 == duk_unicode_re_canonicalize_char(re_ctx->thr, c1)); /* canonicalized by compiler */
78645 if (sp >= re_ctx->input_end) {
78646 goto fail;
78647 }
78648 c2 = duk__inp_get_cp(re_ctx, &sp);
78649 DUK_DDD(DUK_DDDPRINT("char match, c1=%ld, c2=%ld", (long) c1, (long) c2));
78650 if (c1 != c2) {
78651 goto fail;
78652 }
78653 break;
78654 }
78655 case DUK_REOP_PERIOD: {
78657
78658 if (sp >= re_ctx->input_end) {
78659 goto fail;
78660 }
78661 c = duk__inp_get_cp(re_ctx, &sp);
78663 /* E5 Sections 15.10.2.8, 7.3 */
78664 goto fail;
78665 }
78666 break;
78667 }
78668 case DUK_REOP_RANGES:
78669 case DUK_REOP_INVRANGES: {
78670 duk_uint32_t n;
78673
78674 n = duk__bc_get_u32(re_ctx, &pc);
78675 if (sp >= re_ctx->input_end) {
78676 goto fail;
78677 }
78678 c = duk__inp_get_cp(re_ctx, &sp);
78679
78680 match = 0;
78681 while (n) {
78682 duk_codepoint_t r1, r2;
78683 r1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
78684 r2 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
78685 DUK_DDD(DUK_DDDPRINT("matching ranges/invranges, n=%ld, r1=%ld, r2=%ld, c=%ld",
78686 (long) n, (long) r1, (long) r2, (long) c));
78687 if (c >= r1 && c <= r2) {
78688 /* Note: don't bail out early, we must read all the ranges from
78689 * bytecode. Another option is to skip them efficiently after
78690 * breaking out of here. Prefer smallest code.
78691 */
78692 match = 1;
78693 }
78694 n--;
78695 }
78696
78697 if (op == DUK_REOP_RANGES) {
78698 if (!match) {
78699 goto fail;
78700 }
78701 } else {
78703 if (match) {
78704 goto fail;
78705 }
78706 }
78707 break;
78708 }
78709 case DUK_REOP_ASSERT_START: {
78711
78712 if (sp <= re_ctx->input) {
78713 break;
78714 }
78715 if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) {
78716 goto fail;
78717 }
78718 c = duk__inp_get_prev_cp(re_ctx, sp);
78720 /* E5 Sections 15.10.2.8, 7.3 */
78721 break;
78722 }
78723 goto fail;
78724 }
78725 case DUK_REOP_ASSERT_END: {
78727 const duk_uint8_t *tmp_sp;
78728
78729 if (sp >= re_ctx->input_end) {
78730 break;
78731 }
78732 if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) {
78733 goto fail;
78734 }
78735 tmp_sp = sp;
78736 c = duk__inp_get_cp(re_ctx, &tmp_sp);
78738 /* E5 Sections 15.10.2.8, 7.3 */
78739 break;
78740 }
78741 goto fail;
78742 }
78745 /*
78746 * E5 Section 15.10.2.6. The previous and current character
78747 * should -not- be canonicalized as they are now. However,
78748 * canonicalization does not affect the result of IsWordChar()
78749 * (which depends on Unicode characters never canonicalizing
78750 * into ASCII characters) so this does not matter.
78751 */
78752 duk_small_int_t w1, w2;
78753
78754 if (sp <= re_ctx->input) {
78755 w1 = 0; /* not a wordchar */
78756 } else {
78758 c = duk__inp_get_prev_cp(re_ctx, sp);
78760 }
78761 if (sp >= re_ctx->input_end) {
78762 w2 = 0; /* not a wordchar */
78763 } else {
78764 const duk_uint8_t *tmp_sp = sp; /* dummy so sp won't get updated */
78766 c = duk__inp_get_cp(re_ctx, &tmp_sp);
78768 }
78769
78771 if (w1 == w2) {
78772 goto fail;
78773 }
78774 } else {
78776 if (w1 != w2) {
78777 goto fail;
78778 }
78779 }
78780 break;
78781 }
78782 case DUK_REOP_JUMP: {
78783 duk_int32_t skip;
78784
78785 skip = duk__bc_get_i32(re_ctx, &pc);
78786 pc += skip;
78787 break;
78788 }
78789 case DUK_REOP_SPLIT1: {
78790 /* split1: prefer direct execution (no jump) */
78791 const duk_uint8_t *sub_sp;
78792 duk_int32_t skip;
78793
78794 skip = duk__bc_get_i32(re_ctx, &pc);
78795 sub_sp = duk__match_regexp(re_ctx, pc, sp);
78796 if (sub_sp) {
78797 sp = sub_sp;
78798 goto match;
78799 }
78800 pc += skip;
78801 break;
78802 }
78803 case DUK_REOP_SPLIT2: {
78804 /* split2: prefer jump execution (not direct) */
78805 const duk_uint8_t *sub_sp;
78806 duk_int32_t skip;
78807
78808 skip = duk__bc_get_i32(re_ctx, &pc);
78809 sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
78810 if (sub_sp) {
78811 sp = sub_sp;
78812 goto match;
78813 }
78814 break;
78815 }
78816 case DUK_REOP_SQMINIMAL: {
78817 duk_uint32_t q, qmin, qmax;
78818 duk_int32_t skip;
78819 const duk_uint8_t *sub_sp;
78820
78821 qmin = duk__bc_get_u32(re_ctx, &pc);
78822 qmax = duk__bc_get_u32(re_ctx, &pc);
78823 skip = duk__bc_get_i32(re_ctx, &pc);
78824 DUK_DDD(DUK_DDDPRINT("minimal quantifier, qmin=%lu, qmax=%lu, skip=%ld",
78825 (unsigned long) qmin, (unsigned long) qmax, (long) skip));
78826
78827 q = 0;
78828 while (q <= qmax) {
78829 if (q >= qmin) {
78830 sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
78831 if (sub_sp) {
78832 sp = sub_sp;
78833 goto match;
78834 }
78835 }
78836 sub_sp = duk__match_regexp(re_ctx, pc, sp);
78837 if (!sub_sp) {
78838 break;
78839 }
78840 sp = sub_sp;
78841 q++;
78842 }
78843 goto fail;
78844 }
78845 case DUK_REOP_SQGREEDY: {
78846 duk_uint32_t q, qmin, qmax, atomlen;
78847 duk_int32_t skip;
78848 const duk_uint8_t *sub_sp;
78849
78850 qmin = duk__bc_get_u32(re_ctx, &pc);
78851 qmax = duk__bc_get_u32(re_ctx, &pc);
78852 atomlen = duk__bc_get_u32(re_ctx, &pc);
78853 skip = duk__bc_get_i32(re_ctx, &pc);
78854 DUK_DDD(DUK_DDDPRINT("greedy quantifier, qmin=%lu, qmax=%lu, atomlen=%lu, skip=%ld",
78855 (unsigned long) qmin, (unsigned long) qmax, (unsigned long) atomlen, (long) skip));
78856
78857 q = 0;
78858 while (q < qmax) {
78859 sub_sp = duk__match_regexp(re_ctx, pc, sp);
78860 if (!sub_sp) {
78861 break;
78862 }
78863 sp = sub_sp;
78864 q++;
78865 }
78866 while (q >= qmin) {
78867 sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
78868 if (sub_sp) {
78869 sp = sub_sp;
78870 goto match;
78871 }
78872 if (q == qmin) {
78873 break;
78874 }
78875
78876 /* Note: if atom were to contain e.g. captures, we would need to
78877 * re-match the atom to get correct captures. Simply quantifiers
78878 * do not allow captures in their atom now, so this is not an issue.
78879 */
78880
78881 DUK_DDD(DUK_DDDPRINT("greedy quantifier, backtrack %ld characters (atomlen)",
78882 (long) atomlen));
78883 sp = duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) atomlen);
78884 q--;
78885 }
78886 goto fail;
78887 }
78888 case DUK_REOP_SAVE: {
78889 duk_uint32_t idx;
78890 const duk_uint8_t *old;
78891 const duk_uint8_t *sub_sp;
78892
78893 idx = duk__bc_get_u32(re_ctx, &pc);
78894 if (idx >= re_ctx->nsaved) {
78895 /* idx is unsigned, < 0 check is not necessary */
78896 DUK_D(DUK_DPRINT("internal error, regexp save index insane: idx=%ld", (long) idx));
78897 goto internal_error;
78898 }
78899 old = re_ctx->saved[idx];
78900 re_ctx->saved[idx] = sp;
78901 sub_sp = duk__match_regexp(re_ctx, pc, sp);
78902 if (sub_sp) {
78903 sp = sub_sp;
78904 goto match;
78905 }
78906 re_ctx->saved[idx] = old;
78907 goto fail;
78908 }
78909 case DUK_REOP_WIPERANGE: {
78910 /* Wipe capture range and save old values for backtracking.
78911 *
78912 * XXX: this typically happens with a relatively small idx_count.
78913 * It might be useful to handle cases where the count is small
78914 * (say <= 8) by saving the values in stack instead. This would
78915 * reduce memory churn and improve performance, at the cost of a
78916 * slightly higher code footprint.
78917 */
78918 duk_uint32_t idx_start, idx_count;
78919#ifdef DUK_USE_EXPLICIT_NULL_INIT
78920 duk_uint32_t idx_end, idx;
78921#endif
78922 duk_uint8_t **range_save;
78923 const duk_uint8_t *sub_sp;
78924
78925 idx_start = duk__bc_get_u32(re_ctx, &pc);
78926 idx_count = duk__bc_get_u32(re_ctx, &pc);
78927 DUK_DDD(DUK_DDDPRINT("wipe saved range: start=%ld, count=%ld -> [%ld,%ld] (captures [%ld,%ld])",
78928 (long) idx_start, (long) idx_count,
78929 (long) idx_start, (long) (idx_start + idx_count - 1),
78930 (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
78931 if (idx_start + idx_count > re_ctx->nsaved || idx_count == 0) {
78932 /* idx is unsigned, < 0 check is not necessary */
78933 DUK_D(DUK_DPRINT("internal error, regexp wipe indices insane: idx_start=%ld, idx_count=%ld",
78934 (long) idx_start, (long) idx_count));
78935 goto internal_error;
78936 }
78937 DUK_ASSERT(idx_count > 0);
78938
78939 duk_require_stack((duk_context *) re_ctx->thr, 1);
78940 range_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr,
78941 sizeof(duk_uint8_t *) * idx_count);
78942 DUK_ASSERT(range_save != NULL);
78943 DUK_MEMCPY(range_save, re_ctx->saved + idx_start, sizeof(duk_uint8_t *) * idx_count);
78944#ifdef DUK_USE_EXPLICIT_NULL_INIT
78945 idx_end = idx_start + idx_count;
78946 for (idx = idx_start; idx < idx_end; idx++) {
78947 re_ctx->saved[idx] = NULL;
78948 }
78949#else
78950 DUK_MEMZERO((void *) (re_ctx->saved + idx_start), sizeof(duk_uint8_t *) * idx_count);
78951#endif
78952
78953 sub_sp = duk__match_regexp(re_ctx, pc, sp);
78954 if (sub_sp) {
78955 /* match: keep wiped/resaved values */
78956 DUK_DDD(DUK_DDDPRINT("match: keep wiped/resaved values [%ld,%ld] (captures [%ld,%ld])",
78957 (long) idx_start, (long) (idx_start + idx_count - 1),
78958 (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
78959 duk_pop((duk_context *) re_ctx->thr);
78960 sp = sub_sp;
78961 goto match;
78962 }
78963
78964 /* fail: restore saves */
78965 DUK_DDD(DUK_DDDPRINT("fail: restore wiped/resaved values [%ld,%ld] (captures [%ld,%ld])",
78966 (long) idx_start, (long) (idx_start + idx_count - 1),
78967 (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
78968 DUK_MEMCPY((void *) (re_ctx->saved + idx_start),
78969 (const void *) range_save,
78970 sizeof(duk_uint8_t *) * idx_count);
78971 duk_pop((duk_context *) re_ctx->thr);
78972 goto fail;
78973 }
78974 case DUK_REOP_LOOKPOS:
78975 case DUK_REOP_LOOKNEG: {
78976 /*
78977 * Needs a save of multiple saved[] entries depending on what range
78978 * may be overwritten. Because the regexp parser does no such analysis,
78979 * we currently save the entire saved array here. Lookaheads are thus
78980 * a bit expensive. Note that the saved array is not needed for just
78981 * the lookahead sub-match, but for the matching of the entire sequel.
78982 *
78983 * The temporary save buffer is pushed on to the valstack to handle
78984 * errors correctly. Each lookahead causes a C recursion and pushes
78985 * more stuff on the value stack. If the C recursion limit is less
78986 * than the value stack spare, there is no need to check the stack.
78987 * We do so regardless, just in case.
78988 */
78989
78990 duk_int32_t skip;
78991 duk_uint8_t **full_save;
78992 const duk_uint8_t *sub_sp;
78993
78994 DUK_ASSERT(re_ctx->nsaved > 0);
78995
78996 duk_require_stack((duk_context *) re_ctx->thr, 1);
78997 full_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr,
78998 sizeof(duk_uint8_t *) * re_ctx->nsaved);
78999 DUK_ASSERT(full_save != NULL);
79000 DUK_MEMCPY(full_save, re_ctx->saved, sizeof(duk_uint8_t *) * re_ctx->nsaved);
79001
79002 skip = duk__bc_get_i32(re_ctx, &pc);
79003 sub_sp = duk__match_regexp(re_ctx, pc, sp);
79004 if (op == DUK_REOP_LOOKPOS) {
79005 if (!sub_sp) {
79006 goto lookahead_fail;
79007 }
79008 } else {
79009 if (sub_sp) {
79010 goto lookahead_fail;
79011 }
79012 }
79013 sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
79014 if (sub_sp) {
79015 /* match: keep saves */
79016 duk_pop((duk_context *) re_ctx->thr);
79017 sp = sub_sp;
79018 goto match;
79019 }
79020
79021 /* fall through */
79022
79023 lookahead_fail:
79024 /* fail: restore saves */
79025 DUK_MEMCPY((void *) re_ctx->saved,
79026 (const void *) full_save,
79027 sizeof(duk_uint8_t *) * re_ctx->nsaved);
79028 duk_pop((duk_context *) re_ctx->thr);
79029 goto fail;
79030 }
79032 /*
79033 * Byte matching for back-references would be OK in case-
79034 * sensitive matching. In case-insensitive matching we need
79035 * to canonicalize characters, so back-reference matching needs
79036 * to be done with codepoints instead. So, we just decode
79037 * everything normally here, too.
79038 *
79039 * Note: back-reference index which is 0 or higher than
79040 * NCapturingParens (= number of capturing parens in the
79041 * -entire- regexp) is a compile time error. However, a
79042 * backreference referring to a valid capture which has
79043 * not matched anything always succeeds! See E5 Section
79044 * 15.10.2.9, step 5, sub-step 3.
79045 */
79046 duk_uint32_t idx;
79047 const duk_uint8_t *p;
79048
79049 idx = duk__bc_get_u32(re_ctx, &pc);
79050 idx = idx << 1; /* backref n -> saved indices [n*2, n*2+1] */
79051 if (idx < 2 || idx + 1 >= re_ctx->nsaved) {
79052 /* regexp compiler should catch these */
79053 DUK_D(DUK_DPRINT("internal error, backreference index insane"));
79054 goto internal_error;
79055 }
79056 if (!re_ctx->saved[idx] || !re_ctx->saved[idx+1]) {
79057 /* capture is 'undefined', always matches! */
79058 DUK_DDD(DUK_DDDPRINT("backreference: saved[%ld,%ld] not complete, always match",
79059 (long) idx, (long) (idx + 1)));
79060 break;
79061 }
79062 DUK_DDD(DUK_DDDPRINT("backreference: match saved[%ld,%ld]", (long) idx, (long) (idx + 1)));
79063
79064 p = re_ctx->saved[idx];
79065 while (p < re_ctx->saved[idx+1]) {
79066 duk_codepoint_t c1, c2;
79067
79068 /* Note: not necessary to check p against re_ctx->input_end:
79069 * the memory access is checked by duk__inp_get_cp(), while
79070 * valid compiled regexps cannot write a saved[] entry
79071 * which points to outside the string.
79072 */
79073 if (sp >= re_ctx->input_end) {
79074 goto fail;
79075 }
79076 c1 = duk__inp_get_cp(re_ctx, &p);
79077 c2 = duk__inp_get_cp(re_ctx, &sp);
79078 if (c1 != c2) {
79079 goto fail;
79080 }
79081 }
79082 break;
79083 }
79084 default: {
79085 DUK_D(DUK_DPRINT("internal error, regexp opcode error: %ld", (long) op));
DUK_LOCAL duk_uint32_t duk__bc_get_u32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc)
#define DUK_REOP_MATCH
#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT
#define DUK_REOP_RANGES
#define DUK_REOP_ASSERT_WORD_BOUNDARY
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t cp)
#define DUK_REOP_ASSERT_END
#define DUK_RE_FLAG_MULTILINE
#define DUK_REOP_INVRANGES
#define DUK_REOP_SAVE
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 duk_int32_t duk__bc_get_i32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc)
#define DUK_REOP_PERIOD
#define DUK_REOP_SQGREEDY
#define DUK_REOP_SPLIT2
#define DUK_REOP_LOOKPOS
#define DUK_REOP_LOOKNEG
DUK_LOCAL duk_codepoint_t duk__inp_get_prev_cp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *sp)
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator(duk_codepoint_t cp)
#define DUK_REOP_JUMP
#define DUK_REOP_BACKREFERENCE
#define DUK_REOP_WIPERANGE
#define DUK_REOP_ASSERT_START
DUK_LOCAL duk_codepoint_t duk__inp_get_cp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **sp)
#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY
#define DUK_REOP_SPLIT1
#define DUK_REOP_CHAR
#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT
#define DUK_REOP_SQMINIMAL
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)

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 32350 of file duktape-1.5.2/src/duktape.c.

32367 {
32368 duk_idx_t n = duk_get_top(ctx);
32369 duk_idx_t i;
32370 duk_double_t res = initial;
32371 duk_double_t t;
32372
32373 /*
32374 * Note: fmax() does not match the E5 semantics. E5 requires
32375 * that if -any- input to Math.max() is a NaN, the result is a
32376 * NaN. fmax() will return a NaN only if -both- inputs are NaN.
32377 * Same applies to fmin().
32378 *
32379 * 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 55453 of file duktape-1.5.2/src/duktape.c.

55456 :
55457 DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_this));
55458 DUK_DDD(DUK_DDDPRINT("this binding: non-strict, not object/undefined/null -> use ToObject(value)"));
55459 duk_to_object(ctx, idx_this); /* may have side effects */
55460 break;
55461 }
55462}
55463
55464/*
55465 * Shared helper for non-bound func lookup.
55466 *
55467 * Returns duk_hobject * to the final non-bound function (NULL for lightfunc).
55468 */
55469
55471 duk_idx_t idx_func,
55472 duk_idx_t *out_num_stack_args,
55473 duk_tval **out_tv_func,
55474 duk_small_uint_t call_flags) {
55475 duk_hthread *thr = (duk_hthread *) ctx;
55476 duk_tval *tv_func;
55477 duk_hobject *func;
55478
55479 for (;;) {
55480 /* Use loop to minimize code size of relookup after bound function case */
55481 tv_func = DUK_GET_TVAL_POSIDX(ctx, idx_func);
55482 DUK_ASSERT(tv_func != NULL);
55483
55484 if (DUK_TVAL_IS_OBJECT(tv_func)) {
55485 func = DUK_TVAL_GET_OBJECT(tv_func);
55486 if (!DUK_HOBJECT_IS_CALLABLE(func)) {
55487 goto not_callable_error;
55488 }
55489 if (DUK_HOBJECT_HAS_BOUND(func)) {
55490 duk__handle_bound_chain_for_call(thr, idx_func, out_num_stack_args, call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL);
55491
55492 /* The final object may be a normal function or a lightfunc.
55493 * We need to re-lookup tv_func because it may have changed
55494 * (also value stack may have been resized). Loop again to
55495 * do that; we're guaranteed not to come here again.
55496 */
55498 DUK_TVAL_IS_LIGHTFUNC(duk_require_tval(ctx, idx_func)));
55499 continue;
55500 }
55501 } else if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
55502 func = NULL;
55503 } else {
55504 goto not_callable_error;
55505 }
55506 break;
55507 }
55508
55510 DUK_TVAL_IS_LIGHTFUNC(tv_func));
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)

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 60204 of file duktape-1.5.2/src/duktape.c.

60221 {
60222 duk_hthread *thr = comp_ctx->thr;
60223 duk_reg_t reg_obj; /* result reg */
60224 duk_reg_t reg_temp; /* temp reg */
60225 duk_reg_t temp_start; /* temp reg value for start of loop */
60226 duk_small_uint_t max_init_values; /* max # of values initialized in one MPUTARR set */
60227 duk_small_uint_t num_values; /* number of values in current MPUTARR set */
60228 duk_uarridx_t curr_idx; /* current (next) array index */
60229 duk_uarridx_t start_idx; /* start array index of current MPUTARR set */
60230 duk_uarridx_t init_idx; /* last array index explicitly initialized, +1 */
60231 duk_bool_t require_comma; /* next loop requires a comma */
60232
60233 /* DUK_TOK_LBRACKET already eaten, current token is right after that */
60235
60236 max_init_values = DUK__MAX_ARRAY_INIT_VALUES; /* XXX: depend on available temps? */
60237
60238 reg_obj = DUK__ALLOCTEMP(comp_ctx);
60239 duk__emit_extraop_b_c(comp_ctx,
60241 reg_obj,
60242 0); /* XXX: patch initial size afterwards? */
60243 temp_start = DUK__GETTEMP(comp_ctx);
60244
60245 /*
60246 * Emit initializers in sets of maximum max_init_values.
60247 * Corner cases such as single value initializers do not have
60248 * special handling now.
60249 *
60250 * Elided elements must not be emitted as 'undefined' values,
60251 * because such values would be enumerable (which is incorrect).
60252 * Also note that trailing elisions must be reflected in the
60253 * length of the final array but cause no elements to be actually
60254 * inserted.
60255 */
60256
60257 curr_idx = 0;
60258 init_idx = 0; /* tracks maximum initialized index + 1 */
60259 start_idx = 0;
60260 require_comma = 0;
60261
60262 for (;;) {
60263 num_values = 0;
60264 DUK__SETTEMP(comp_ctx, temp_start);
60265
60266 if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) {
60267 break;
60268 }
60269
60270 for (;;) {
60271 if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) {
60272 /* the outer loop will recheck and exit */
60273 break;
60274 }
60275
60276 /* comma check */
60277 if (require_comma) {
60278 if (comp_ctx->curr_token.t == DUK_TOK_COMMA) {
60279 /* comma after a value, expected */
60280 duk__advance(comp_ctx);
60281 require_comma = 0;
60282 continue;
60283 } else {
60284 goto syntax_error;
60285 }
60286 } else {
60287 if (comp_ctx->curr_token.t == DUK_TOK_COMMA) {
60288 /* elision - flush */
60289 curr_idx++;
60290 duk__advance(comp_ctx);
60291 /* if num_values > 0, MPUTARR emitted by outer loop after break */
60292 break;
60293 }
60294 }
60295 /* else an array initializer element */
60296
60297 /* initial index */
60298 if (num_values == 0) {
60299 start_idx = curr_idx;
60300 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60301 duk__emit_load_int32(comp_ctx, reg_temp, (duk_int32_t) start_idx);
60302 }
60303
60304 reg_temp = DUK__ALLOCTEMP(comp_ctx); /* alloc temp just in case, to update max temp */
60305 DUK__SETTEMP(comp_ctx, reg_temp);
60306 duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);
60307 DUK__SETTEMP(comp_ctx, reg_temp + 1);
60308
60309 num_values++;
60310 curr_idx++;
60311 require_comma = 1;
60312
60313 if (num_values >= max_init_values) {
60314 /* MPUTARR emitted by outer loop */
60315 break;
60316 }
60317 }
60318
60319 if (num_values > 0) {
60320 /* - A is a source register (it's not a write target, but used
60321 * to identify the target object) but can be shuffled.
60322 * - B cannot be shuffled normally because it identifies a range
60323 * of registers, the emitter has special handling for this
60324 * (the "no shuffle" flag must not be set).
60325 * - C is a non-register number and cannot be shuffled, but
60326 * never needs to be.
60327 */
60328 duk__emit_a_b_c(comp_ctx,
60332 (duk_regconst_t) reg_obj,
60333 (duk_regconst_t) temp_start,
60334 (duk_regconst_t) num_values);
60335 init_idx = start_idx + num_values;
60336
60337 /* num_values and temp_start reset at top of outer loop */
60338 }
60339 }
60340
60342 duk__advance(comp_ctx);
60343
60344 DUK_DDD(DUK_DDDPRINT("array literal done, curridx=%ld, initidx=%ld",
60345 (long) curr_idx, (long) init_idx));
60346
60347 /* trailing elisions? */
60348 if (curr_idx > init_idx) {
60349 /* yes, must set array length explicitly */
60350 DUK_DDD(DUK_DDDPRINT("array literal has trailing elisions which affect its length"));
60351 reg_temp = DUK__ALLOCTEMP(comp_ctx);
#define DUK__MAX_ARRAY_INIT_VALUES

◆ duk__nud_object_literal()

DUK_LOCAL_DECL void duk__nud_object_literal ( duk_compiler_ctx * comp_ctx,
duk_ivalue * res )

Definition at line 60412 of file duktape-1.5.2/src/duktape.c.

60412 : getter/setter encountered twice"));
60413 return 1;
60414 }
60415 }
60416
60417 new_key_flags |= key_flags;
60418 DUK_DDD(DUK_DDDPRINT("setting/updating key %!T flags: 0x%08lx -> 0x%08lx",
60419 (duk_tval *) duk_get_tval(ctx, -1),
60420 (unsigned long) key_flags,
60421 (unsigned long) new_key_flags));
60422 duk_dup(ctx, -1);
60423 duk_push_int(ctx, new_key_flags); /* [ ... key_obj key key flags ] */
60424 duk_put_prop(ctx, -4); /* [ ... key_obj key ] */
60425
60426 return 0;
60427}
60428
60429DUK_LOCAL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
60430 duk_hthread *thr = comp_ctx->thr;
60431 duk_context *ctx = (duk_context *) thr;
60432 duk_reg_t reg_obj; /* result reg */
60433 duk_reg_t reg_key; /* temp reg for key literal */
60434 duk_reg_t reg_temp; /* temp reg */
60435 duk_reg_t temp_start; /* temp reg value for start of loop */
60436 duk_small_uint_t max_init_pairs; /* max # of key-value pairs initialized in one MPUTOBJ set */
60437 duk_small_uint_t num_pairs; /* number of pairs in current MPUTOBJ set */
60438 duk_bool_t first; /* first value: comma must not precede the value */
60439 duk_bool_t is_set, is_get; /* temps */
60440
60441 DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LCURLY);
60442
60443 max_init_pairs = DUK__MAX_OBJECT_INIT_PAIRS; /* XXX: depend on available temps? */
60444
60445 reg_obj = DUK__ALLOCTEMP(comp_ctx);
60446 duk__emit_extraop_b_c(comp_ctx,
60447 DUK_EXTRAOP_NEWOBJ | DUK__EMIT_FLAG_B_IS_TARGET,
60448 reg_obj,
60449 0); /* XXX: patch initial size afterwards? */
60450 temp_start = DUK__GETTEMP(comp_ctx);
60451
60452 /* temp object for tracking / detecting duplicate keys */
60453 duk_push_object(ctx);
60454
60455 /*
60456 * Emit initializers in sets of maximum max_init_pairs keys.
60457 * Setter/getter is handled separately and terminates the
60458 * current set of initializer values. Corner cases such as
60459 * single value initializers do not have special handling now.
60460 */
60461
60462 first = 1;
60463 for (;;) {
60464 num_pairs = 0;
60465 DUK__SETTEMP(comp_ctx, temp_start);
60466
60467 if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
60468 break;
60469 }
60470
60471 for (;;) {
60472 /*
60473 * Three possible element formats:
60474 * 1) PropertyName : AssignmentExpression
60475 * 2) get PropertyName () { FunctionBody }
60476 * 3) set PropertyName ( PropertySetParameterList ) { FunctionBody }
60477 *
60478 * PropertyName can be IdentifierName (includes reserved words), a string
60479 * literal, or a number literal. Note that IdentifierName allows 'get' and
60480 * 'set' too, so we need to look ahead to the next token to distinguish:
60481 *
60482 * { get : 1 }
60483 *
60484 * and
60485 *
60486 * { get foo() { return 1 } }
60487 * { get get() { return 1 } } // 'get' as getter propertyname
60488 *
60489 * Finally, a trailing comma is allowed.
60490 *
60491 * Key name is coerced to string at compile time (and ends up as a
60492 * a string constant) even for numeric keys (e.g. "{1:'foo'}").
60493 * These could be emitted using e.g. LDINT, but that seems hardly
60494 * worth the effort and would increase code size.
60495 */
60496
60497 DUK_DDD(DUK_DDDPRINT("object literal inner loop, curr_token->t = %ld",
60498 (long) comp_ctx->curr_token.t));
60499
60500 if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
60501 /* the outer loop will recheck and exit */
60502 break;
60503 }
60504 if (num_pairs >= max_init_pairs) {
60505 /* MPUTOBJ emitted by outer loop */
60506 break;
60507 }
60508
60509 if (first) {
60510 first = 0;
60511 } else {
60512 if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
60513 goto syntax_error;
60514 }
60515 duk__advance(comp_ctx);
60516 if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
60517 /* trailing comma followed by rcurly */
60518 break;
60519 }
60520 }
60521
60522 /* advance to get one step of lookup */
60523 duk__advance(comp_ctx);
60524
60525 /* NOTE: "get" and "set" are not officially ReservedWords and the lexer
60526 * currently treats them always like ordinary identifiers (DUK_TOK_GET
60527 * and DUK_TOK_SET are unused). They need to be detected based on the
60528 * identifier string content.
60529 */
60530
60531 is_get = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
60532 comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_GET(thr));
60533 is_set = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
60534 comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_SET(thr));
60535 if ((is_get || is_set) && comp_ctx->curr_token.t != DUK_TOK_COLON) {
60536 /* getter/setter */
60537 duk_int_t fnum;
60538
60539 if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER ||
60540 comp_ctx->curr_token.t_nores == DUK_TOK_STRING) {
60541 /* same handling for identifiers and strings */
60542 DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
60543 duk_push_hstring(ctx, comp_ctx->curr_token.str1);
60544 } else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) {
60545 duk_push_number(ctx, comp_ctx->curr_token.num);
60546 duk_to_string(ctx, -1);
60547 } else {
60548 goto syntax_error;
60549 }
60550
60551 DUK_ASSERT(duk_is_string(ctx, -1));
60552 if (duk__nud_object_literal_key_check(comp_ctx,
60553 (is_get ? DUK__OBJ_LIT_KEY_GET : DUK__OBJ_LIT_KEY_SET))) {
60554 goto syntax_error;
60555 }
60556 reg_key = duk__getconst(comp_ctx);
60557
60558 if (num_pairs > 0) {
60559 /* - A is a source register (it's not a write target, but used
60560 * to identify the target object) but can be shuffled.
60561 * - B cannot be shuffled normally because it identifies a range
60562 * of registers, the emitter has special handling for this
60563 * (the "no shuffle" flag must not be set).
60564 * - C is a non-register number and cannot be shuffled, but
60565 * never needs to be.
60566 */
60567 duk__emit_a_b_c(comp_ctx,
60568 DUK_OP_MPUTOBJ |
60569 DUK__EMIT_FLAG_NO_SHUFFLE_C |
60570 DUK__EMIT_FLAG_A_IS_SOURCE,
60571 reg_obj,
60572 temp_start,
60573 num_pairs);
60574 num_pairs = 0;
60575 DUK__SETTEMP(comp_ctx, temp_start);
60576 }
60577
60578 /* curr_token = get/set name */
60579 fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 1 /*is_setget*/);
60580
60581 DUK_ASSERT(DUK__GETTEMP(comp_ctx) == temp_start);
60582 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60583 duk__emit_a_bc(comp_ctx,
60584 DUK_OP_LDCONST,
60585 (duk_regconst_t) reg_temp,
60586 (duk_regconst_t) reg_key);
60587 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60588 duk__emit_a_bc(comp_ctx,
60589 DUK_OP_CLOSURE,
60590 (duk_regconst_t) reg_temp,
60591 (duk_regconst_t) fnum);
60592
60593 /* Slot C is used in a non-standard fashion (range of regs),
60594 * emitter code has special handling for it (must not set the
60595 * "no shuffle" flag).
60596 */
60597 duk__emit_extraop_b_c(comp_ctx,
60598 (is_get ? DUK_EXTRAOP_INITGET : DUK_EXTRAOP_INITSET),
60599 reg_obj,
60600 temp_start); /* temp_start+0 = key, temp_start+1 = closure */
60601
60602 DUK__SETTEMP(comp_ctx, temp_start);
60603 } else {
60604 /* normal key/value */
60605 if (comp_ctx->prev_token.t_nores == DUK_TOK_IDENTIFIER ||
60606 comp_ctx->prev_token.t_nores == DUK_TOK_STRING) {
60607 /* same handling for identifiers and strings */
60608 DUK_ASSERT(comp_ctx->prev_token.str1 != NULL);
60609 duk_push_hstring(ctx, comp_ctx->prev_token.str1);
60610 } else if (comp_ctx->prev_token.t == DUK_TOK_NUMBER) {
60611 duk_push_number(ctx, comp_ctx->prev_token.num);
60612 duk_to_string(ctx, -1);
60613 } else {
60614 goto syntax_error;
60615 }
60616
60617 DUK_ASSERT(duk_is_string(ctx, -1));
60618 if (duk__nud_object_literal_key_check(comp_ctx, DUK__OBJ_LIT_KEY_PLAIN)) {
60619 goto syntax_error;
60620 }
60621 reg_key = duk__getconst(comp_ctx);
60622
60623 reg_temp = DUK__ALLOCTEMP(comp_ctx);
60624 duk__emit_a_bc(comp_ctx,
60625 DUK_OP_LDCONST,
60626 (duk_regconst_t) reg_temp,
60627 (duk_regconst_t) reg_key);
60628 duk__advance_expect(comp_ctx, DUK_TOK_COLON);
60629
60630 reg_temp = DUK__ALLOCTEMP(comp_ctx); /* alloc temp just in case, to update max temp */
60631 DUK__SETTEMP(comp_ctx, reg_temp);
60632 duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);
60633 DUK__SETTEMP(comp_ctx, reg_temp + 1);
60634
60635 num_pairs++;
60636 }
60637 }
60638
60639 if (num_pairs > 0) {
60640 /* See MPUTOBJ comments above. */
60641 duk__emit_a_b_c(comp_ctx,
60642 DUK_OP_MPUTOBJ |
60643 DUK__EMIT_FLAG_NO_SHUFFLE_C |
60644 DUK__EMIT_FLAG_A_IS_SOURCE,
60645 reg_obj,
60646 temp_start,
60647 num_pairs);
60648
60649 /* num_pairs and temp_start reset at top of outer loop */
60650 }
60651 }
60652

◆ 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 60354 of file duktape-1.5.2/src/duktape.c.

60366 :
60368}
60369
60370/* duplicate/invalid key checks; returns 1 if syntax error */
60372 duk_hthread *thr = comp_ctx->thr;
60373 duk_context *ctx = (duk_context *) thr;
60374 duk_small_uint_t key_flags;
60375
60376 /* [ ... key_obj key ] */
60377
60378 DUK_ASSERT(duk_is_string(ctx, -1));
60379
60380 /*
60381 * 'key_obj' tracks keys encountered so far by associating an
60382 * integer with flags with already encountered keys. The checks
60383 * below implement E5 Section 11.1.5, step 4 for production:
60384 *
60385 * PropertyNameAndValueList: PropertyNameAndValueList , PropertyAssignment
60386 */
60387
60388 duk_dup(ctx, -1); /* [ ... key_obj key key ] */
60389 duk_get_prop(ctx, -3); /* [ ... key_obj key val ] */
60390 key_flags = duk_to_int(ctx, -1);
60391 duk_pop(ctx); /* [ ... key_obj key ] */
60392
60393 if (new_key_flags & DUK__OBJ_LIT_KEY_PLAIN) {
60394 if ((key_flags & DUK__OBJ_LIT_KEY_PLAIN) && comp_ctx->curr_func.is_strict) {
60395 /* step 4.a */
60396 DUK_DDD(DUK_DDDPRINT("duplicate key: plain key appears twice in strict mode"));
60397 return 1;
60398 }
60399 if (key_flags & (DUK__OBJ_LIT_KEY_GET | DUK__OBJ_LIT_KEY_SET)) {
60400 /* step 4.c */
60401 DUK_DDD(DUK_DDDPRINT("duplicate key: plain key encountered after setter/getter"));
60402 return 1;
60403 }
60404 } else {
60405 if (key_flags & DUK__OBJ_LIT_KEY_PLAIN) {
60406 /* step 4.b */
60407 DUK_DDD(DUK_DDDPRINT("duplicate key: getter/setter encountered after plain key"));
60408 return 1;
60409 }
60410 if (key_flags & new_key_flags) {
#define DUK__OBJ_LIT_KEY_PLAIN
#define DUK__OBJ_LIT_KEY_GET
DUK_LOCAL_DECL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags)
#define DUK_STR_INVALID_ARRAY_LITERAL
#define DUK__OBJ_LIT_KEY_SET

◆ 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 17521 of file duktape-1.5.2/src/duktape.c.

17528 {
17529 duk_tval *tv;
17530
17531 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 60658 of file duktape-1.5.2/src/duktape.c.

60662 : %!T",
60663 (duk_tval *) duk_get_tval(ctx, -1)));
60664 duk_pop(ctx);
60665 return;
60666
60667 syntax_error:
60668 DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_OBJECT_LITERAL);
60669}
60670
60671/* Parse argument list. Arguments are written to temps starting from
60672 * "next temp". Returns number of arguments parsed. Expects left paren
60673 * to be already eaten, and eats the right paren before returning.
60674 */
60675DUK_LOCAL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
60676 duk_int_t nargs = 0;
60677 duk_reg_t reg_temp;
60678
60679 /* Note: expect that caller has already eaten the left paren */
60680
60681 DUK_DDD(DUK_DDDPRINT("start parsing arguments, prev_token.t=%ld, curr_token.t=%ld",
60682 (long) comp_ctx->prev_token.t, (long) comp_ctx->curr_token.t));
60683
60684 for (;;) {
60685 if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
60686 break;
60687 }
60688 if (nargs > 0) {
60689 duk__advance_expect(comp_ctx, DUK_TOK_COMMA);
60690 }
60691
60692 /* We want the argument expression value to go to "next temp"
60693 * without additional moves. That should almost always be the
60694 * case, but we double check after expression parsing.
60695 *
60696 * This is not the cleanest possible approach.
60697 */
60698
60699 reg_temp = DUK__ALLOCTEMP(comp_ctx); /* bump up "allocated" reg count, just in case */
60700 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 63196 of file duktape-1.5.2/src/duktape.c.

63213 {
63214 duk_hthread *thr = comp_ctx->thr;
63215 duk_bool_t is_break = (comp_ctx->curr_token.t == DUK_TOK_BREAK);
63216 duk_int_t label_id;
63217 duk_int_t label_catch_depth;
63218 duk_int_t label_pc; /* points to LABEL; pc+1 = jump site for break; pc+2 = jump site for continue */
63219 duk_bool_t label_is_closest;
63220
63221 DUK_UNREF(res);
63222
63223 duk__advance(comp_ctx); /* eat 'break' or 'continue' */
63224
63225 if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || /* explicit semi follows */
63226 comp_ctx->curr_token.lineterm || /* automatic semi will be inserted */
63227 comp_ctx->curr_token.allow_auto_semi) { /* automatic semi will be inserted */
63228 /* break/continue without label */
63229
63230 duk__lookup_active_label(comp_ctx, DUK_HTHREAD_STRING_EMPTY_STRING(thr), is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest);
63231 } else if (comp_ctx->curr_token.t == DUK_TOK_IDENTIFIER) {
63232 /* break/continue with label (label cannot be a reserved word, production is 'Identifier' */
63233 DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
63234 duk__lookup_active_label(comp_ctx, comp_ctx->curr_token.str1, is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest);
63235 duk__advance(comp_ctx);
63236 } else {
63238 }
63239
63240 /* Use a fast break/continue when possible. A fast break/continue is
63241 * just a jump to the LABEL break/continue jump slot, which then jumps
63242 * to an appropriate place (for break, going through ENDLABEL correctly).
63243 * The peephole optimizer will optimize the jump to a direct one.
63244 */
63245
63246 if (label_catch_depth == comp_ctx->curr_func.catch_depth &&
63247 label_is_closest) {
63248 DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, "
63249 "label_catch_depth=%ld, catch_depth=%ld "
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)
#define DUK_TOK_BREAK
#define DUK_STR_INVALID_BREAK_CONT_LABEL

◆ 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 77652 of file duktape-1.5.2/src/duktape.c.

77669 {
77670 duk_int32_t atom_start_offset = -1; /* negative -> no atom matched on previous round */
77671 duk_int32_t atom_char_length = 0; /* negative -> complex atom */
77672 duk_uint32_t atom_start_captures = re_ctx->captures; /* value of re_ctx->captures at start of atom */
77673 duk_int32_t unpatched_disjunction_split = -1;
77674 duk_int32_t unpatched_disjunction_jump = -1;
77675 duk_uint32_t entry_offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);
77676 duk_int32_t res_charlen = 0; /* -1 if disjunction is complex, char length if simple */
77677 duk__re_disjunction_info tmp_disj;
77678
77679 DUK_ASSERT(out_atom_info != NULL);
77680
77681 if (re_ctx->recursion_depth >= re_ctx->recursion_limit) {
77683 }
77684 re_ctx->recursion_depth++;
77685
77686#if 0
77687 out_atom_info->start_captures = re_ctx->captures;
77688#endif
77689
77690 for (;;) {
77691 /* atom_char_length, atom_start_offset, atom_start_offset reflect the
77692 * atom matched on the previous loop. If a quantifier is encountered
77693 * on this loop, these are needed to handle the quantifier correctly.
77694 * new_atom_char_length etc are for the atom parsed on this round;
77695 * they're written to atom_char_length etc at the end of the round.
77696 */
77697 duk_int32_t new_atom_char_length; /* char length of the atom parsed in this loop */
77698 duk_int32_t new_atom_start_offset; /* bytecode start offset of the atom parsed in this loop
77699 * (allows quantifiers to copy the atom bytecode)
77700 */
77701 duk_uint32_t new_atom_start_captures; /* re_ctx->captures at the start of the atom parsed in this loop */
77702
77703 duk_lexer_parse_re_token(&re_ctx->lex, &re_ctx->curr_token);
77704
77705 DUK_DD(DUK_DDPRINT("re token: %ld (num=%ld, char=%c)",
77706 (long) re_ctx->curr_token.t,
77707 (long) re_ctx->curr_token.num,
77708 (re_ctx->curr_token.num >= 0x20 && re_ctx->curr_token.num <= 0x7e) ?
77709 (int) re_ctx->curr_token.num : (int) '?'));
77710
77711 /* set by atom case clauses */
77712 new_atom_start_offset = -1;
77713 new_atom_char_length = -1;
77714 new_atom_start_captures = re_ctx->captures;
77715
77716 switch (re_ctx->curr_token.t) {
77717 case DUK_RETOK_DISJUNCTION: {
77718 /*
77719 * The handling here is a bit tricky. If a previous '|' has been processed,
77720 * we have a pending split1 and a pending jump (for a previous match). These
77721 * need to be back-patched carefully. See docs for a detailed example.
77722 */
77723
77724 /* patch pending jump and split */
77725 if (unpatched_disjunction_jump >= 0) {
77726 duk_uint32_t offset;
77727
77728 DUK_ASSERT(unpatched_disjunction_split >= 0);
77729 offset = unpatched_disjunction_jump;
77730 offset += duk__insert_jump_offset(re_ctx,
77731 offset,
77732 (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - offset));
77733 /* offset is now target of the pending split (right after jump) */
77735 unpatched_disjunction_split,
77736 offset - unpatched_disjunction_split);
77737 }
77738
77739 /* add a new pending split to the beginning of the entire disjunction */
77740 (void) duk__insert_u32(re_ctx,
77741 entry_offset,
77742 DUK_REOP_SPLIT1); /* prefer direct execution */
77743 unpatched_disjunction_split = entry_offset + 1; /* +1 for opcode */
77744
77745 /* add a new pending match jump for latest finished alternative */
77747 unpatched_disjunction_jump = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
77748
77749 /* 'taint' result as complex */
77750 res_charlen = -1;
77751 break;
77752 }
77753 case DUK_RETOK_QUANTIFIER: {
77754 if (atom_start_offset < 0) {
77756 }
77757 if (re_ctx->curr_token.qmin > re_ctx->curr_token.qmax) {
77759 }
77760 if (atom_char_length >= 0) {
77761 /*
77762 * Simple atom
77763 *
77764 * If atom_char_length is zero, we'll have unbounded execution time for e.g.
77765 * /()*x/.exec('x'). We can't just skip the match because it might have some
77766 * side effects (for instance, if we allowed captures in simple atoms, the
77767 * capture needs to happen). The simple solution below is to force the
77768 * quantifier to match at most once, since the additional matches have no effect.
77769 *
77770 * With a simple atom there can be no capture groups, so no captures need
77771 * to be reset.
77772 */
77773 duk_int32_t atom_code_length;
77774 duk_uint32_t offset;
77775 duk_uint32_t qmin, qmax;
77776
77777 qmin = re_ctx->curr_token.qmin;
77778 qmax = re_ctx->curr_token.qmax;
77779 if (atom_char_length == 0) {
77780 /* qmin and qmax will be 0 or 1 */
77781 if (qmin > 1) {
77782 qmin = 1;
77783 }
77784 if (qmax > 1) {
77785 qmax = 1;
77786 }
77787 }
77788
77789 duk__append_u32(re_ctx, DUK_REOP_MATCH); /* complete 'sub atom' */
77790 atom_code_length = (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - atom_start_offset);
77791
77792 offset = atom_start_offset;
77793 if (re_ctx->curr_token.greedy) {
77794 offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQGREEDY);
77795 offset += duk__insert_u32(re_ctx, offset, qmin);
77796 offset += duk__insert_u32(re_ctx, offset, qmax);
77797 offset += duk__insert_u32(re_ctx, offset, atom_char_length);
77798 offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length);
77799 } else {
77800 offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQMINIMAL);
77801 offset += duk__insert_u32(re_ctx, offset, qmin);
77802 offset += duk__insert_u32(re_ctx, offset, qmax);
77803 offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length);
77804 }
77805 DUK_UNREF(offset); /* silence scan-build warning */
77806 } else {
77807 /*
77808 * Complex atom
77809 *
77810 * The original code is used as a template, and removed at the end
77811 * (this differs from the handling of simple quantifiers).
77812 *
77813 * NOTE: there is no current solution for empty atoms in complex
77814 * quantifiers. This would need some sort of a 'progress' instruction.
77815 *
77816 * XXX: impose limit on maximum result size, i.e. atom_code_len * atom_copies?
77817 */
77818 duk_int32_t atom_code_length;
77819 duk_uint32_t atom_copies;
77820 duk_uint32_t tmp_qmin, tmp_qmax;
77821
77822 /* pre-check how many atom copies we're willing to make (atom_copies not needed below) */
77823 atom_copies = (re_ctx->curr_token.qmax == DUK_RE_QUANTIFIER_INFINITE) ?
77824 re_ctx->curr_token.qmin : re_ctx->curr_token.qmax;
77825 if (atom_copies > DUK_RE_MAX_ATOM_COPIES) {
77827 }
77828
77829 /* wipe the capture range made by the atom (if any) */
77830 DUK_ASSERT(atom_start_captures <= re_ctx->captures);
77831 if (atom_start_captures != re_ctx->captures) {
77832 DUK_ASSERT(atom_start_captures < re_ctx->captures);
77833 DUK_DDD(DUK_DDDPRINT("must wipe ]atom_start_captures,re_ctx->captures]: ]%ld,%ld]",
77834 (long) atom_start_captures, (long) re_ctx->captures));
77835
77836 /* insert (DUK_REOP_WIPERANGE, start, count) in reverse order so the order ends up right */
77837 duk__insert_u32(re_ctx, atom_start_offset, (re_ctx->captures - atom_start_captures) * 2);
77838 duk__insert_u32(re_ctx, atom_start_offset, (atom_start_captures + 1) * 2);
77839 duk__insert_u32(re_ctx, atom_start_offset, DUK_REOP_WIPERANGE);
77840 } else {
77841 DUK_DDD(DUK_DDDPRINT("no need to wipe captures: atom_start_captures == re_ctx->captures == %ld",
77842 (long) atom_start_captures));
77843 }
77844
77845 atom_code_length = (duk_int32_t) DUK__RE_BUFLEN(re_ctx) - atom_start_offset;
77846
77847 /* insert the required matches (qmin) by copying the atom */
77848 tmp_qmin = re_ctx->curr_token.qmin;
77849 tmp_qmax = re_ctx->curr_token.qmax;
77850 while (tmp_qmin > 0) {
77851 duk__append_slice(re_ctx, atom_start_offset, atom_code_length);
77852 tmp_qmin--;
77853 if (tmp_qmax != DUK_RE_QUANTIFIER_INFINITE) {
77854 tmp_qmax--;
77855 }
77856 }
77857 DUK_ASSERT(tmp_qmin == 0);
77858
77859 /* insert code for matching the remainder - infinite or finite */
77860 if (tmp_qmax == DUK_RE_QUANTIFIER_INFINITE) {
77861 /* reuse last emitted atom for remaining 'infinite' quantifier */
77862
77863 if (re_ctx->curr_token.qmin == 0) {
77864 /* Special case: original qmin was zero so there is nothing
77865 * to repeat. Emit an atom copy but jump over it here.
77866 */
77868 duk__append_jump_offset(re_ctx, atom_code_length);
77869 duk__append_slice(re_ctx, atom_start_offset, atom_code_length);
77870 }
77871 if (re_ctx->curr_token.greedy) {
77872 duk__append_u32(re_ctx, DUK_REOP_SPLIT2); /* prefer jump */
77873 } else {
77874 duk__append_u32(re_ctx, DUK_REOP_SPLIT1); /* prefer direct */
77875 }
77876 duk__append_jump_offset(re_ctx, -atom_code_length - 1); /* -1 for opcode */
77877 } else {
77878 /*
77879 * The remaining matches are emitted as sequence of SPLITs and atom
77880 * copies; the SPLITs skip the remaining copies and match the sequel.
77881 * This sequence needs to be emitted starting from the last copy
77882 * because the SPLITs are variable length due to the variable length
77883 * skip offset. This causes a lot of memory copying now.
77884 *
77885 * Example structure (greedy, match maximum # atoms):
77886 *
77887 * SPLIT1 LSEQ
77888 * (atom)
77889 * SPLIT1 LSEQ ; <- the byte length of this instruction is needed
77890 * (atom) ; to encode the above SPLIT1 correctly
77891 * ...
77892 * LSEQ:
77893 */
77894 duk_uint32_t offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);
77895 while (tmp_qmax > 0) {
77896 duk__insert_slice(re_ctx, offset, atom_start_offset, atom_code_length);
77897 if (re_ctx->curr_token.greedy) {
77898 duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT1); /* prefer direct */
77899 } else {
77900 duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT2); /* prefer jump */
77901 }
77903 offset + 1, /* +1 for opcode */
77904 (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1)));
77905 tmp_qmax--;
77906 }
77907 }
77908
77909 /* remove the original 'template' atom */
77910 duk__remove_slice(re_ctx, atom_start_offset, atom_code_length);
77911 }
77912
77913 /* 'taint' result as complex */
77914 res_charlen = -1;
77915 break;
77916 }
77919 break;
77920 }
77921 case DUK_RETOK_ASSERT_END: {
77923 break;
77924 }
77927 break;
77928 }
77931 break;
77932 }
77935 duk_uint32_t offset;
77936 duk_uint32_t opcode = (re_ctx->curr_token.t == DUK_RETOK_ASSERT_START_POS_LOOKAHEAD) ?
77938
77939 offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx);
77940 duk__parse_disjunction(re_ctx, 0, &tmp_disj);
77942
77943 (void) duk__insert_u32(re_ctx, offset, opcode);
77944 (void) duk__insert_jump_offset(re_ctx,
77945 offset + 1, /* +1 for opcode */
77946 (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1)));
77947
77948 /* 'taint' result as complex -- this is conservative,
77949 * as lookaheads do not backtrack.
77950 */
77951 res_charlen = -1;
77952 break;
77953 }
77954 case DUK_RETOK_ATOM_PERIOD: {
77955 new_atom_char_length = 1;
77956 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
77958 break;
77959 }
77960 case DUK_RETOK_ATOM_CHAR: {
77961 /* Note: successive characters could be joined into string matches
77962 * but this is not trivial (consider e.g. '/xyz+/); see docs for
77963 * more discussion.
77964 */
77965 duk_uint32_t ch;
77966
77967 new_atom_char_length = 1;
77968 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
77970 ch = re_ctx->curr_token.num;
77971 if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) {
77972 ch = duk_unicode_re_canonicalize_char(re_ctx->thr, ch);
77973 }
77974 duk__append_u32(re_ctx, ch);
77975 break;
77976 }
77979 new_atom_char_length = 1;
77980 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
77981 duk__append_u32(re_ctx,
77982 (re_ctx->curr_token.t == DUK_RETOK_ATOM_DIGIT) ?
77984 duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_digit) / (2 * sizeof(duk_uint16_t)));
77985 duk__append_u16_list(re_ctx, duk_unicode_re_ranges_digit, sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t));
77986 break;
77987 }
77990 new_atom_char_length = 1;
77991 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
77992 duk__append_u32(re_ctx,
77993 (re_ctx->curr_token.t == DUK_RETOK_ATOM_WHITE) ?
77995 duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_white) / (2 * sizeof(duk_uint16_t)));
77996 duk__append_u16_list(re_ctx, duk_unicode_re_ranges_white, sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t));
77997 break;
77998 }
78001 new_atom_char_length = 1;
78002 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
78003 duk__append_u32(re_ctx,
78006 duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_wordchar) / (2 * sizeof(duk_uint16_t)));
78008 break;
78009 }
78011 duk_uint32_t backref = (duk_uint32_t) re_ctx->curr_token.num;
78012 if (backref > re_ctx->highest_backref) {
78013 re_ctx->highest_backref = backref;
78014 }
78015 new_atom_char_length = -1; /* mark as complex */
78016 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
78018 duk__append_u32(re_ctx, backref);
78019 break;
78020 }
78022 duk_uint32_t cap;
78023
78024 new_atom_char_length = -1; /* mark as complex (capture handling) */
78025 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
78026 cap = ++re_ctx->captures;
78028 duk__append_u32(re_ctx, cap * 2);
78029 duk__parse_disjunction(re_ctx, 0, &tmp_disj); /* retval (sub-atom char length) unused, tainted as complex above */
78031 duk__append_u32(re_ctx, cap * 2 + 1);
78032 break;
78033 }
78035 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
78036 duk__parse_disjunction(re_ctx, 0, &tmp_disj);
78037 new_atom_char_length = tmp_disj.charlen;
78038 break;
78039 }
78042 /*
78043 * Range parsing is done with a special lexer function which calls
78044 * us for every range parsed. This is different from how rest of
78045 * the parsing works, but avoids a heavy, arbitrary size intermediate
78046 * value type to hold the ranges.
78047 *
78048 * Another complication is the handling of character ranges when
78049 * case insensitive matching is used (see docs for discussion).
78050 * The range handler callback given to the lexer takes care of this
78051 * as well.
78052 *
78053 * Note that duplicate ranges are not eliminated when parsing character
78054 * classes, so that canonicalization of
78055 *
78056 * [0-9a-fA-Fx-{]
78057 *
78058 * creates the result (note the duplicate ranges):
78059 *
78060 * [0-9A-FA-FX-Z{-{]
78061 *
78062 * where [x-{] is split as a result of canonicalization. The duplicate
78063 * ranges are not a semantics issue: they work correctly.
78064 */
78065
78066 duk_uint32_t offset;
78067
78068 DUK_DD(DUK_DDPRINT("character class"));
78069
78070 /* insert ranges instruction, range count patched in later */
78071 new_atom_char_length = 1;
78072 new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx);
78073 duk__append_u32(re_ctx,
78076 offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); /* patch in range count later */
78077
78078 /* parse ranges until character class ends */
78079 re_ctx->nranges = 0; /* note: ctx-wide temporary */
78080 duk_lexer_parse_re_ranges(&re_ctx->lex, duk__generate_ranges, (void *) re_ctx);
78081
78082 /* insert range count */
78083 duk__insert_u32(re_ctx, offset, re_ctx->nranges);
78084 break;
78085 }
78087 if (expect_eof) {
78089 }
78090 goto done;
78091 }
78092 case DUK_RETOK_EOF: {
78093 if (!expect_eof) {
78095 }
78096 goto done;
78097 }
78098 default: {
78100 }
78101 }
78102
78103 /* a complex (new) atom taints the result */
78104 if (new_atom_start_offset >= 0) {
78105 if (new_atom_char_length < 0) {
78106 res_charlen = -1;
78107 } else if (res_charlen >= 0) {
78108 /* only advance if not tainted */
78109 res_charlen += new_atom_char_length;
78110 }
78111 }
78112
78113 /* record previous atom info in case next token is a quantifier */
78114 atom_start_offset = new_atom_start_offset;
78115 atom_char_length = new_atom_char_length;
78116 atom_start_captures = new_atom_start_captures;
78117 }
78118
78119 done:
78120
78121 /* finish up pending jump and split for last alternative */
78122 if (unpatched_disjunction_jump >= 0) {
78123 duk_uint32_t offset;
78124
78125 DUK_ASSERT(unpatched_disjunction_split >= 0);
78126 offset = unpatched_disjunction_jump;
78127 offset += duk__insert_jump_offset(re_ctx,
#define DUK_RETOK_DISJUNCTION
DUK_LOCAL duk_uint32_t duk__append_jump_offset(duk_re_compiler_ctx *re_ctx, duk_int32_t skip)
DUK_LOCAL void duk__remove_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length)
#define DUK_RETOK_ATOM_PERIOD
#define DUK_RETOK_EOF
#define DUK_RETOK_ATOM_WORD_CHAR
#define DUK_RETOK_ATOM_START_CHARCLASS
#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM
#define DUK_STR_UNEXPECTED_REGEXP_TOKEN
DUK_LOCAL duk_uint32_t duk__insert_jump_offset(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t skip)
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_digit[2]
#define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED
#define DUK_STR_UNEXPECTED_END_OF_PATTERN
#define DUK_RETOK_ATOM_DIGIT
#define DUK_RETOK_ATOM_END_GROUP
DUK_LOCAL void duk__append_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length)
#define DUK_RETOK_ATOM_NOT_WHITE
#define DUK_RETOK_ASSERT_WORD_BOUNDARY
#define DUK_RETOK_ATOM_NOT_WORD_CHAR
#define DUK_RETOK_ATOM_START_CAPTURE_GROUP
#define DUK_RETOK_ASSERT_START
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)
#define DUK_STR_INVALID_QUANTIFIER_VALUES
#define DUK_RETOK_ASSERT_START_POS_LOOKAHEAD
#define DUK_RETOK_ATOM_NOT_DIGIT
DUK_INTERNAL_DECL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token)
DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t expect_eof, duk__re_disjunction_info *out_atom_info)
#define DUK_RETOK_QUANTIFIER
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_wordchar[8]
#define DUK_RE_QUANTIFIER_INFINITE
#define DUK_RETOK_ATOM_START_NONCAPTURE_GROUP
#define DUK_RETOK_ATOM_WHITE
#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT
DUK_LOCAL void duk__append_u16_list(duk_re_compiler_ctx *re_ctx, const duk_uint16_t *values, duk_uint32_t count)
#define DUK_RETOK_ASSERT_END
#define DUK_RETOK_ATOM_BACKREFERENCE
#define DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD
#define DUK_RE_MAX_ATOM_COPIES
#define DUK_STR_UNEXPECTED_CLOSING_PAREN
DUK_LOCAL duk_uint32_t duk__insert_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t x)
#define DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY
#define DUK__RE_BUFLEN(re_ctx)
#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES
DUK_INTERNAL_DECL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata)
#define DUK_RETOK_ATOM_CHAR
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_white[22]

References duk_re_compiler_ctx::captures, duk__re_disjunction_info::charlen, duk_re_compiler_ctx::curr_token, duk__append_jump_offset(), duk__append_slice(), duk__append_u16_list(), duk__append_u32(), duk__generate_ranges(), duk__insert_jump_offset(), duk__insert_slice(), duk__insert_u32(), duk__parse_disjunction(), DUK__RE_BUFLEN, duk__remove_slice(), DUK_ASSERT, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_ERROR_RANGE, DUK_ERROR_SYNTAX, duk_lexer_parse_re_ranges(), duk_lexer_parse_re_token(), DUK_RE_FLAG_IGNORE_CASE, DUK_RE_MAX_ATOM_COPIES, DUK_RE_QUANTIFIER_INFINITE, DUK_REOP_ASSERT_END, DUK_REOP_ASSERT_NOT_WORD_BOUNDARY, DUK_REOP_ASSERT_START, DUK_REOP_ASSERT_WORD_BOUNDARY, DUK_REOP_BACKREFERENCE, DUK_REOP_CHAR, DUK_REOP_INVRANGES, DUK_REOP_JUMP, DUK_REOP_LOOKNEG, DUK_REOP_LOOKPOS, DUK_REOP_MATCH, DUK_REOP_PERIOD, DUK_REOP_RANGES, DUK_REOP_SAVE, DUK_REOP_SPLIT1, DUK_REOP_SPLIT2, DUK_REOP_SQGREEDY, DUK_REOP_SQMINIMAL, DUK_REOP_WIPERANGE, DUK_RETOK_ASSERT_END, DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY, DUK_RETOK_ASSERT_START, DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD, DUK_RETOK_ASSERT_START_POS_LOOKAHEAD, DUK_RETOK_ASSERT_WORD_BOUNDARY, DUK_RETOK_ATOM_BACKREFERENCE, DUK_RETOK_ATOM_CHAR, DUK_RETOK_ATOM_DIGIT, DUK_RETOK_ATOM_END_GROUP, DUK_RETOK_ATOM_NOT_DIGIT, DUK_RETOK_ATOM_NOT_WHITE, DUK_RETOK_ATOM_NOT_WORD_CHAR, DUK_RETOK_ATOM_PERIOD, DUK_RETOK_ATOM_START_CAPTURE_GROUP, DUK_RETOK_ATOM_START_CHARCLASS, DUK_RETOK_ATOM_START_CHARCLASS_INVERTED, DUK_RETOK_ATOM_START_NONCAPTURE_GROUP, DUK_RETOK_ATOM_WHITE, DUK_RETOK_ATOM_WORD_CHAR, DUK_RETOK_DISJUNCTION, DUK_RETOK_EOF, DUK_RETOK_QUANTIFIER, DUK_STR_INVALID_QUANTIFIER_NO_ATOM, DUK_STR_INVALID_QUANTIFIER_VALUES, DUK_STR_QUANTIFIER_TOO_MANY_COPIES, DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT, DUK_STR_UNEXPECTED_CLOSING_PAREN, DUK_STR_UNEXPECTED_END_OF_PATTERN, DUK_STR_UNEXPECTED_REGEXP_TOKEN, duk_unicode_re_canonicalize_char(), duk_unicode_re_ranges_digit, duk_unicode_re_ranges_white, duk_unicode_re_ranges_wordchar, DUK_UNREF, duk_re_token::greedy, duk_re_compiler_ctx::highest_backref, duk_re_compiler_ctx::lex, duk_re_compiler_ctx::nranges, NULL, duk_re_token::num, duk_re_token::qmax, duk_re_token::qmin, duk_re_compiler_ctx::re_flags, duk_re_compiler_ctx::recursion_depth, duk_re_compiler_ctx::recursion_limit, duk_re_token::t, and duk_re_compiler_ctx::thr.

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 63136 of file duktape-1.5.2/src/duktape.c.

63144 {
63145 DUK_DDD(DUK_DDDPRINT("if does not have else part"));
63146
63147 duk__patch_jump_here(comp_ctx, pc_jump_false);
63148 }
63149
63150 DUK_DDD(DUK_DDDPRINT("end parsing if statement"));
63151}
63152
63153DUK_LOCAL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
63154 duk_regconst_t rc_cond;
63155 duk_int_t pc_start;
63156
63157 DUK_DDD(DUK_DDDPRINT("begin parsing do statement"));
63158
63159 duk__advance(comp_ctx); /* eat 'do' */
63160
63161 pc_start = duk__get_current_pc(comp_ctx);
DUK_LOCAL_DECL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site)

◆ 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 62535 of file duktape-1.5.2/src/duktape.c.

62535 {
62536 duk_reg_t reg_varbind;
62537 duk_regconst_t rc_varname;
62538
62539 duk__advance(comp_ctx); /* eat 'var' */
62540
62541 for (;;) {
62542 /* rc_varname and reg_varbind are ignored here */
62543 duk__parse_var_decl(comp_ctx, res, 0 | expr_flags, &reg_varbind, &rc_varname);
62544
62545 if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
62546 break;
62547 }
62548 duk__advance(comp_ctx);
62549 }
62550}
62551
62552DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
62553 duk_hthread *thr = comp_ctx->thr;
62554 duk_context *ctx = (duk_context *) thr;
62555 duk_int_t pc_v34_lhs; /* start variant 3/4 left-hand-side code (L1 in doc/compiler.rst example) */
62556 duk_reg_t temp_reset; /* knock back "next temp" to this whenever possible */
62557 duk_reg_t reg_temps; /* preallocated temporaries (2) for variants 3 and 4 */
62558
62559 DUK_DDD(DUK_DDDPRINT("start parsing a for/for-in statement"));
62560
62561 /* Two temporaries are preallocated here for variants 3 and 4 which need
62562 * registers which are never clobbered by expressions in the loop
62563 * (concretely: for the enumerator object and the next enumerated value).
62564 * Variants 1 and 2 "release" these temps.
62565 */
62566
62567 reg_temps = DUK__ALLOCTEMPS(comp_ctx, 2);
62568
62569 temp_reset = DUK__GETTEMP(comp_ctx);
62570
62571 /*
62572 * For/for-in main variants are:
62573 *
62574 * 1. for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement
62575 * 2. for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement
62576 * 3. for (LeftHandSideExpression in Expression) Statement
62577 * 4. for (var VariableDeclarationNoIn in Expression) Statement
62578 *
62579 * Parsing these without arbitrary lookahead or backtracking is relatively
62580 * tricky but we manage to do so for now.
62581 *
62582 * See doc/compiler.rst for a detailed discussion of control flow
62583 * issues, evaluation order issues, etc.
62584 */
62585
62586 duk__advance(comp_ctx); /* eat 'for' */
62588
62589 DUK_DDD(DUK_DDDPRINT("detecting for/for-in loop variant, pc=%ld", (long) duk__get_current_pc(comp_ctx)));
62590
62591 /* a label site has been emitted by duk__parse_stmt() automatically
62592 * (it will also emit the ENDLABEL).
62593 */
62594
62595 if (comp_ctx->curr_token.t == DUK_TOK_VAR) {
62596 /*
62597 * Variant 2 or 4
62598 */
62599
62600 duk_reg_t reg_varbind; /* variable binding register if register-bound (otherwise < 0) */
62601 duk_regconst_t rc_varname; /* variable name reg/const, if variable not register-bound */
62602
62603 duk__advance(comp_ctx); /* eat 'var' */
62604 duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, &reg_varbind, &rc_varname);
62605 DUK__SETTEMP(comp_ctx, temp_reset);
62606
62607 if (comp_ctx->curr_token.t == DUK_TOK_IN) {
62608 /*
62609 * Variant 4
62610 */
62611
62612 DUK_DDD(DUK_DDDPRINT("detected for variant 4: for (var VariableDeclarationNoIn in Expression) Statement"));
62613 pc_v34_lhs = duk__get_current_pc(comp_ctx); /* jump is inserted here */
62614 if (reg_varbind >= 0) {
62615 duk__emit_a_bc(comp_ctx,
62617 (duk_regconst_t) reg_varbind,
62618 (duk_regconst_t) (reg_temps + 0));
62619 } else {
62620 duk__emit_a_bc(comp_ctx,
62622 (duk_regconst_t) (reg_temps + 0),
62623 rc_varname);
62624 }
62625 goto parse_3_or_4;
62626 } else {
62627 /*
62628 * Variant 2
62629 */
62630
62631 DUK_DDD(DUK_DDDPRINT("detected for variant 2: for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement"));
62632 for (;;) {
62633 /* more initializers */
62634 if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
62635 break;
62636 }
62637 DUK_DDD(DUK_DDDPRINT("variant 2 has another variable initializer"));
62638
62639 duk__advance(comp_ctx); /* eat comma */
62640 duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, &reg_varbind, &rc_varname);
62641 }
62642 goto parse_1_or_2;
62643 }
62644 } else {
62645 /*
62646 * Variant 1 or 3
62647 */
62648
62649 pc_v34_lhs = duk__get_current_pc(comp_ctx); /* jump is inserted here (variant 3) */
62650
62651 /* Note that duk__exprtop() here can clobber any reg above current temp_next,
62652 * so any loop variables (e.g. enumerator) must be "preallocated".
62653 */
62654
62655 /* don't coerce yet to a plain value (variant 3 needs special handling) */
62656 duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_REJECT_IN | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/); /* Expression */
62657 if (comp_ctx->curr_token.t == DUK_TOK_IN) {
62658 /*
62659 * Variant 3
62660 */
62661
62662 /* XXX: need to determine LHS type, and check that it is LHS compatible */
62663 DUK_DDD(DUK_DDDPRINT("detected for variant 3: for (LeftHandSideExpression in Expression) Statement"));
62664 if (duk__expr_is_empty(comp_ctx)) {
62665 goto syntax_error; /* LeftHandSideExpression does not allow empty expression */
62666 }
62667
62668 if (res->t == DUK_IVAL_VAR) {
62669 duk_reg_t reg_varbind;
62670 duk_regconst_t rc_varname;
62671
62672 duk_dup(ctx, res->x1.valstack_idx);
62673 if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
62674 duk__emit_a_bc(comp_ctx,
62676 (duk_regconst_t) reg_varbind,
62677 (duk_regconst_t) (reg_temps + 0));
62678 } else {
62679 duk__emit_a_bc(comp_ctx,
62681 (duk_regconst_t) (reg_temps + 0),
62682 rc_varname);
62683 }
62684 } else if (res->t == DUK_IVAL_PROP) {
62685 /* Don't allow a constant for the object (even for a number etc), as
62686 * it goes into the 'A' field of the opcode.
62687 */
62688 duk_reg_t reg_obj;
62689 duk_regconst_t rc_key;
62690 reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */
62691 rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
62692 duk__emit_a_b_c(comp_ctx,
62694 (duk_regconst_t) reg_obj,
62695 rc_key,
62696 (duk_regconst_t) (reg_temps + 0));
62697 } else {
62698 duk__ivalue_toplain_ignore(comp_ctx, res); /* just in case */
62699 duk__emit_extraop_only(comp_ctx,
62701 }
62702 goto parse_3_or_4;
62703 } else {
62704 /*
62705 * Variant 1
62706 */
62707
62708 DUK_DDD(DUK_DDDPRINT("detected for variant 1: for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement"));
62709 duk__ivalue_toplain_ignore(comp_ctx, res);
62710 goto parse_1_or_2;
62711 }
62712 }
62713
62714 parse_1_or_2:
62715 /*
62716 * Parse variant 1 or 2. The first part expression (which differs
62717 * in the variants) has already been parsed and its code emitted.
62718 *
62719 * reg_temps + 0: unused
62720 * reg_temps + 1: unused
62721 */
62722 {
62723 duk_regconst_t rc_cond;
62724 duk_int_t pc_l1, pc_l2, pc_l3, pc_l4;
62725 duk_int_t pc_jumpto_l3, pc_jumpto_l4;
62726 duk_bool_t expr_c_empty;
62727
62728 DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 1 and 2"));
62729
62730 /* "release" preallocated temps since we won't need them */
62731 temp_reset = reg_temps + 0;
62732 DUK__SETTEMP(comp_ctx, temp_reset);
62733
62735
62736 pc_l1 = duk__get_current_pc(comp_ctx);
62737 duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/); /* Expression_opt */
62738 if (duk__expr_is_empty(comp_ctx)) {
62739 /* no need to coerce */
62740 pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx); /* to body */
62741 pc_jumpto_l4 = -1; /* omitted */
62742 } else {
62743 rc_cond = duk__ivalue_toregconst(comp_ctx, res);
62744 duk__emit_if_false_skip(comp_ctx, rc_cond);
62745 pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx); /* to body */
62746 pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx); /* to exit */
62747 }
62748 DUK__SETTEMP(comp_ctx, temp_reset);
62749
62751
62752 pc_l2 = duk__get_current_pc(comp_ctx);
62753 duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/); /* Expression_opt */
62754 if (duk__expr_is_empty(comp_ctx)) {
62755 /* no need to coerce */
62756 expr_c_empty = 1;
62757 /* JUMP L1 omitted */
62758 } else {
62759 duk__ivalue_toplain_ignore(comp_ctx, res);
62760 expr_c_empty = 0;
62761 duk__emit_jump(comp_ctx, pc_l1);
62762 }
62763 DUK__SETTEMP(comp_ctx, temp_reset);
62764
62766
62767 pc_l3 = duk__get_current_pc(comp_ctx);
62768 duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
62769 if (expr_c_empty) {
62770 duk__emit_jump(comp_ctx, pc_l1);
62771 } else {
62772 duk__emit_jump(comp_ctx, pc_l2);
62773 }
62774 /* temp reset is not necessary after duk__parse_stmt(), which already does it */
62775
62776 pc_l4 = duk__get_current_pc(comp_ctx);
62777
62778 DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l3: %ld->%ld, jumpto_l4: %ld->%ld, "
62779 "break: %ld->%ld, continue: %ld->%ld",
62780 (long) pc_jumpto_l3, (long) pc_l3, (long) pc_jumpto_l4, (long) pc_l4,
62781 (long) (pc_label_site + 1), (long) pc_l4, (long) (pc_label_site + 2), (long) pc_l2));
62782
62783 duk__patch_jump(comp_ctx, pc_jumpto_l3, pc_l3);
62784 duk__patch_jump(comp_ctx, pc_jumpto_l4, pc_l4);
62785 duk__patch_jump(comp_ctx,
62786 pc_label_site + 1,
62787 pc_l4); /* break jump */
62788 duk__patch_jump(comp_ctx,
62789 pc_label_site + 2,
62790 expr_c_empty ? pc_l1 : pc_l2); /* continue jump */
62791 }
62792 goto finished;
62793
62794 parse_3_or_4:
62795 /*
62796 * Parse variant 3 or 4.
62797 *
62798 * For variant 3 (e.g. "for (A in C) D;") the code for A (except the
62799 * final property/variable write) has already been emitted. The first
62800 * instruction of that code is at pc_v34_lhs; a JUMP needs to be inserted
62801 * there to satisfy control flow needs.
62802 *
62803 * For variant 4, if the variable declaration had an initializer
62804 * (e.g. "for (var A = B in C) D;") the code for the assignment
62805 * (B) has already been emitted.
62806 *
62807 * Variables set before entering here:
62808 *
62809 * pc_v34_lhs: insert a "JUMP L2" here (see doc/compiler.rst example).
62810 * reg_temps + 0: iteration target value (written to LHS)
62811 * reg_temps + 1: enumerator object
62812 */
62813 {
62814 duk_int_t pc_l1, pc_l2, pc_l3, pc_l4, pc_l5;
62815 duk_int_t pc_jumpto_l2, pc_jumpto_l3, pc_jumpto_l4, pc_jumpto_l5;
62816 duk_reg_t reg_target;
62817
62818 DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 3 and 4, pc_v34_lhs=%ld", (long) pc_v34_lhs));
62819
62820 DUK__SETTEMP(comp_ctx, temp_reset);
62821
62822 /* First we need to insert a jump in the middle of previously
62823 * emitted code to get the control flow right. No jumps can
62824 * cross the position where the jump is inserted. See doc/compiler.rst
62825 * for discussion on the intricacies of control flow and side effects
62826 * for variants 3 and 4.
62827 */
62828
62829 duk__insert_jump_entry(comp_ctx, pc_v34_lhs);
62830 pc_jumpto_l2 = pc_v34_lhs; /* inserted jump */
62831 pc_l1 = pc_v34_lhs + 1; /* +1, right after inserted jump */
62832
62833 /* The code for writing reg_temps + 0 to the left hand side has already
62834 * been emitted.
62835 */
62836
62837 pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx); /* -> loop body */
62838
62839 duk__advance(comp_ctx); /* eat 'in' */
62840
62841 /* Parse enumeration target and initialize enumerator. For 'null' and 'undefined',
62842 * INITENUM will creates a 'null' enumerator which works like an empty enumerator
62843 * (E5 Section 12.6.4, step 3). Note that INITENUM requires the value to be in a
62844 * register (constant not allowed).
62845 */
62846
62847 pc_l2 = duk__get_current_pc(comp_ctx);
62848 reg_target = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression */
62849 duk__emit_extraop_b_c(comp_ctx,
62851 (duk_regconst_t) (reg_temps + 1),
62852 (duk_regconst_t) reg_target);
62853 pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx);
62854 DUK__SETTEMP(comp_ctx, temp_reset);
62855
62857
62858 pc_l3 = duk__get_current_pc(comp_ctx);
62859 duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
62860 /* temp reset is not necessary after duk__parse_stmt(), which already does it */
62861
62862 /* NEXTENUM needs a jump slot right after the main opcode.
62863 * We need the code emitter to reserve the slot: if there's
62864 * target shuffling, the target shuffle opcodes must happen
62865 * after the jump slot (for NEXTENUM the shuffle opcodes are
62866 * not needed if the enum is finished).
62867 */
62868 pc_l4 = duk__get_current_pc(comp_ctx);
62869 duk__emit_extraop_b_c(comp_ctx,
62871 (duk_regconst_t) (reg_temps + 0),
62872 (duk_regconst_t) (reg_temps + 1));
62873 pc_jumpto_l5 = comp_ctx->emit_jumpslot_pc; /* NEXTENUM jump slot: executed when enum finished */
62874 duk__emit_jump(comp_ctx, pc_l1); /* jump to next loop, using reg_v34_iter as iterated value */
62875
62876 pc_l5 = duk__get_current_pc(comp_ctx);
62877
62878 /* XXX: since the enumerator may be a memory expensive object,
62879 * perhaps clear it explicitly here? If so, break jump must
62880 * go through this clearing operation.
62881 */
62882
62883 DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l2: %ld->%ld, jumpto_l3: %ld->%ld, "
62884 "jumpto_l4: %ld->%ld, jumpto_l5: %ld->%ld, "
62885 "break: %ld->%ld, continue: %ld->%ld",
62886 (long) pc_jumpto_l2, (long) pc_l2, (long) pc_jumpto_l3, (long) pc_l3,
62887 (long) pc_jumpto_l4, (long) pc_l4, (long) pc_jumpto_l5, (long) pc_l5,
62888 (long) (pc_label_site + 1), (long) pc_l5, (long) (pc_label_site + 2), (long) pc_l4));
DUK_LOCAL_DECL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc)
#define DUK__EXPR_FLAG_REJECT_IN
DUK_LOCAL_DECL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc)
DUK_LOCAL_DECL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem)
#define DUK_TOK_VAR
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__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst)
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 duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags)
DUK_LOCAL_DECL duk_bool_t duk__expr_is_empty(duk_compiler_ctx *comp_ctx)

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 64598 of file duktape-1.5.2/src/duktape.c.

64602 :
64603 *
64604 * - Global and eval code have an implicit return value generated
64605 * by the last statement; function code does not
64606 *
64607 * - Global code, eval code, and Function constructor body end in
64608 * an EOF, other bodies in a closing brace ('}')
64609 *
64610 * Upon entry, 'curr_tok' is ignored and the function will pull in the
64611 * first token on its own. Upon exit, 'curr_tok' is the terminating
64612 * token (EOF or closing brace).
64613 */
64614
64615DUK_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) {
64616 duk_compiler_func *func;
64617 duk_hthread *thr;
64618 duk_context *ctx;
64619 duk_reg_t reg_stmt_value = -1;
64620 duk_lexer_point lex_pt;
64621 duk_reg_t temp_first;
64622 duk_small_int_t compile_round = 1;
64623
64624 DUK_ASSERT(comp_ctx != NULL);
64625
64626 thr = comp_ctx->thr;
64627 ctx = (duk_context *) thr;
64628 DUK_ASSERT(thr != NULL);
64629
64630 func = &comp_ctx->curr_func;
64631 DUK_ASSERT(func != NULL);
64632
64633 DUK__RECURSION_INCREASE(comp_ctx, thr);
64634
64636
64637 /*
64638 * Store lexer position for a later rewind
64639 */
64640
64641 DUK_LEXER_GETPOINT(&comp_ctx->lex, &lex_pt);
64642
64643 /*
64644 * Program code (global and eval code) has an implicit return value
64645 * from the last statement value (e.g. eval("1; 2+3;") returns 3).
64646 * This is not the case with functions. If implicit statement return
64647 * value is requested, all statements are coerced to a register
64648 * allocated here, and used in the implicit return statement below.
64649 */
64650
64651 /* XXX: this is pointless here because pass 1 is throw-away */
64652 if (implicit_return_value) {
64653 reg_stmt_value = DUK__ALLOCTEMP(comp_ctx);
64654
64655 /* If an implicit return value is needed by caller, it must be
64656 * initialized to 'undefined' because we don't know whether any
64657 * non-empty (where "empty" is a continuation type, and different
64658 * from an empty statement) statements will be executed.
64659 *
64660 * However, since 1st pass is a throwaway one, no need to emit
64661 * it here.
64662 */
64663#if 0
64664 duk__emit_extraop_bc(comp_ctx,
64666 0);
64667#endif
64668 }
64669
64670 /*
64671 * First pass.
64672 *
64673 * Gather variable/function declarations needed for second pass.
64674 * Code generated is dummy and discarded.
64675 */
64676
64677 func->in_directive_prologue = 1;
64678 func->in_scanning = 1;
64679 func->may_direct_eval = 0;
64680 func->id_access_arguments = 0;
64681 func->id_access_slow = 0;
64682 func->reg_stmt_value = reg_stmt_value;
64683#if defined(DUK_USE_DEBUGGER_SUPPORT)
64684 func->min_line = DUK_INT_MAX;
64685 func->max_line = 0;
64686#endif
64687
64688 /* duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp literal" mode with current strictness */
64689 if (expect_token >= 0) {
64690 /* Eating a left curly; regexp mode is allowed by left curly
64691 * based on duk__token_lbp[] automatically.
64692 */
64693 DUK_ASSERT(expect_token == DUK_TOK_LCURLY);
64695 duk__advance_expect(comp_ctx, expect_token);
64696 } else {
64697 /* Need to set curr_token.t because lexing regexp mode depends on current
64698 * token type. Zero value causes "allow regexp" mode.
64699 */
64700 comp_ctx->curr_token.t = 0;
64701 duk__advance(comp_ctx);
64702 }
64703
64704 DUK_DDD(DUK_DDDPRINT("begin 1st pass"));
64705 duk__parse_stmts(comp_ctx,
64706 1, /* allow source elements */
64707 expect_eof); /* expect EOF instead of } */
64708 DUK_DDD(DUK_DDDPRINT("end 1st pass"));
64709
64710 /*
64711 * Second (and possibly third) pass.
64712 *
64713 * Generate actual code. In most cases the need for shuffle
64714 * registers is detected during pass 1, but in some corner cases
64715 * we'll only detect it during pass 2 and a third pass is then
64716 * needed (see GH-115).
64717 */
64718
64719 for (;;) {
64720 duk_bool_t needs_shuffle_before = comp_ctx->curr_func.needs_shuffle;
64721 compile_round++;
64722
64723 /*
64724 * Rewind lexer.
64725 *
64726 * duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp
64727 * literal" mode with current strictness.
64728 *
64729 * curr_token line number info should be initialized for pass 2 before
64730 * generating prologue, to ensure prologue bytecode gets nice line numbers.
64731 */
64732
64733 DUK_DDD(DUK_DDDPRINT("rewind lexer"));
64734 DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt);
64735 comp_ctx->curr_token.t = 0; /* this is needed for regexp mode */
64736 comp_ctx->curr_token.start_line = 0; /* needed for line number tracking (becomes prev_token.start_line) */
64737 duk__advance(comp_ctx);
64738
64739 /*
64740 * Reset function state and perform register allocation, which creates
64741 * 'varmap' for second pass. Function prologue for variable declarations,
64742 * binding value initializations etc is emitted as a by-product.
64743 *
64744 * Strict mode restrictions for duplicate and invalid argument
64745 * names are checked here now that we know whether the function
64746 * is actually strict. See: test-dev-strict-mode-boundary.js.
64747 *
64748 * Inner functions are compiled during pass 1 and are not reset.
64749 */
64750
64751 duk__reset_func_for_pass2(comp_ctx);
64752 func->in_directive_prologue = 1;
64753 func->in_scanning = 0;
64754
64755 /* must be able to emit code, alloc consts, etc. */
64756
64758 (implicit_return_value ? &reg_stmt_value : NULL));
64759 func->reg_stmt_value = reg_stmt_value;
64760
64761 temp_first = DUK__GETTEMP(comp_ctx);
64762
64763 func->temp_first = temp_first;
64764 func->temp_next = temp_first;
64765 func->stmt_next = 0;
64766 func->label_next = 0;
64767
64768 /* XXX: init or assert catch depth etc -- all values */
64769 func->id_access_arguments = 0;
64770 func->id_access_slow = 0;
64771
64772 /*
64773 * Check function name validity now that we know strictness.
64774 * This only applies to function declarations and expressions,
64775 * not setter/getter name.
64776 *
64777 * See: test-dev-strict-mode-boundary.js
64778 */
64779
64780 if (func->is_function && !func->is_setget && func->h_name != NULL) {
64781 if (func->is_strict) {
64782 if (duk__hstring_is_eval_or_arguments(comp_ctx, func->h_name)) {
64783 DUK_DDD(DUK_DDDPRINT("func name is 'eval' or 'arguments' in strict mode"));
64784 goto error_funcname;
64785 }
64787 DUK_DDD(DUK_DDDPRINT("func name is a reserved word in strict mode"));
64788 goto error_funcname;
64789 }
64790 } else {
64793 DUK_DDD(DUK_DDDPRINT("func name is a reserved word in non-strict mode"));
64794 goto error_funcname;
64795 }
64796 }
64797 }
64798
64799 /*
64800 * Second pass parsing.
64801 */
64802
64803 if (implicit_return_value) {
64804 /* Default implicit return value. */
64805 duk__emit_extraop_bc(comp_ctx,
64807 0);
64808 }
64809
64810 DUK_DDD(DUK_DDDPRINT("begin 2nd pass"));
64811 duk__parse_stmts(comp_ctx,
64812 1, /* allow source elements */
64813 expect_eof); /* expect EOF instead of } */
64814 DUK_DDD(DUK_DDDPRINT("end 2nd pass"));
64815
64817
64818 if (needs_shuffle_before == comp_ctx->curr_func.needs_shuffle) {
64819 /* Shuffle decision not changed. */
64820 break;
64821 }
64822 if (compile_round >= 3) {
64823 /* Should never happen but avoid infinite loop just in case. */
64824 DUK_D(DUK_DPRINT("more than 3 compile passes needed, should never happen"));
64826 }
64827 DUK_D(DUK_DPRINT("need additional round to compile function, round now %d", (int) compile_round));
64828 }
64829
64830 /*
64831 * Emit a final RETURN.
64832 *
64833 * It would be nice to avoid emitting an unnecessary "return" opcode
64834 * if the current PC is not reachable. However, this cannot be reliably
64835 * detected; even if the previous instruction is an unconditional jump,
64836 * there may be a previous jump which jumps to current PC (which is the
64837 * case for iteration and conditional statements, for instance).
64838 */
64839
64840 /* XXX: request a "last statement is terminal" from duk__parse_stmt() and duk__parse_stmts();
64841 * we could avoid the last RETURN if we could ensure there is no way to get here
64842 * (directly or via a jump)
64843 */
64844
64845 DUK_ASSERT(comp_ctx->curr_func.catch_depth == 0);
64846 if (reg_stmt_value >= 0) {
64847 duk__emit_a_b(comp_ctx,
64850 (duk_regconst_t) reg_stmt_value /*reg*/);
64851 } else {
64852 duk__emit_a_b(comp_ctx,
64854 (duk_regconst_t) 0 /*flags*/,
64855 (duk_regconst_t) 0 /*reg(ignored)*/);
64856 }
64857
#define DUK__FUNCTION_BODY_REQUIRE_SLOTS
#define DUK_HSTRING_HAS_RESERVED_WORD(x)
#define DUK_LEXER_GETPOINT(ctx, pt)
DUK_LOCAL_DECL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx)
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 void duk__update_lineinfo_currtoken(duk_compiler_ctx *comp_ctx)
static int statement(LexState *ls)
static void body(LexState *ls, expdesc *e, int needself, int line)
static void constructor(LexState *ls, expdesc *t)

References duk_compiler_func::catch_depth, duk_compiler_ctx::curr_func, duk_compiler_ctx::curr_token, duk__advance(), duk__advance_expect(), DUK__ALLOCTEMP, duk__emit_a_b(), duk__emit_extraop_bc(), DUK__EMIT_FLAG_NO_SHUFFLE_A, DUK__FUNCTION_BODY_REQUIRE_SLOTS, DUK__GETTEMP, duk__hstring_is_eval_or_arguments(), duk__init_varmap_and_prologue_for_pass2(), duk__parse_stmts(), duk__peephole_optimize_bytecode(), DUK__RECURSION_DECREASE, DUK__RECURSION_INCREASE, duk__reset_func_for_pass2(), duk__update_lineinfo_currtoken(), DUK_ASSERT, DUK_BC_RETURN_FLAG_HAVE_RETVAL, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, DUK_ERROR_INTERNAL_DEFMSG, DUK_ERROR_SYNTAX, DUK_EXTRAOP_LDUNDEF, DUK_HSTRING_HAS_RESERVED_WORD, DUK_HSTRING_HAS_STRICT_RESERVED_WORD, DUK_INT_MAX, DUK_LEXER_GETPOINT, DUK_LEXER_SETPOINT, DUK_OP_RETURN, duk_require_stack(), DUK_STR_INVALID_FUNC_NAME, DUK_TOK_LCURLY, duk_compiler_func::h_name, duk_compiler_func::id_access_arguments, duk_compiler_func::id_access_slow, duk_compiler_func::in_directive_prologue, duk_compiler_func::in_scanning, duk_compiler_func::is_function, duk_compiler_func::is_setget, duk_compiler_func::is_strict, duk_compiler_func::label_next, duk_compiler_ctx::lex, duk_compiler_func::may_direct_eval, duk_compiler_func::needs_shuffle, NULL, duk_compiler_func::reg_stmt_value, duk_token::start_line, duk_compiler_func::stmt_next, duk_token::t, duk_compiler_func::temp_first, duk_compiler_func::temp_next, and duk_compiler_ctx::thr.

◆ duk__parse_func_formals()

DUK_LOCAL_DECL void duk__parse_func_formals ( duk_compiler_ctx * comp_ctx)

Definition at line 64877 of file duktape-1.5.2/src/duktape.c.

64877 :
64878 *
64879 * - function expression
64880 * - function declaration
64881 * - function statement (non-standard)
64882 * - setter/getter
64883 *
64884 * Adds the function to comp_ctx->curr_func function table and returns the
64885 * function number.
64886 *
64887 * On entry, curr_token points to:
64888 *
64889 * - the token after 'function' for function expression/declaration/statement
64890 * - the token after 'set' or 'get' for setter/getter
64891 */
64892
64893/* Parse formals. */
64895 duk_hthread *thr = comp_ctx->thr;
64896 duk_context *ctx = (duk_context *) thr;
64897 duk_bool_t first = 1;
64898 duk_uarridx_t n;
64899
64900 for (;;) {
64901 if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
64902 break;
64903 }
64904
64905 if (first) {
64906 /* no comma */
64907 first = 0;
64908 } else {
64910 }
64911
64912 /* Note: when parsing a formal list in non-strict context, e.g.
64913 * "implements" is parsed as an identifier. When the function is
64914 * later detected to be strict, the argument list must be rechecked
64915 * against a larger set of reserved words (that of strict mode).
64916 * This is handled by duk__parse_func_body(). Here we recognize
64917 * whatever tokens are considered reserved in current strictness
64918 * (which is not always enough).
64919 */
DUK_LOCAL_DECL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx)

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 65033 of file duktape-1.5.2/src/duktape.c.

65050 {
65051 duk_hthread *thr = comp_ctx->thr;
65052 duk_context *ctx = (duk_context *) thr;
65053 duk_compiler_func old_func;
65054 duk_idx_t entry_top;
65055 duk_int_t fnum;
65056
65057 /*
65058 * On second pass, skip the function.
65059 */
65060
65061 if (!comp_ctx->curr_func.in_scanning) {
65062 duk_lexer_point lex_pt;
65063
65064 fnum = comp_ctx->curr_func.fnum_next++;
65065 duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 1));
65066 lex_pt.offset = duk_to_int(ctx, -1);
65067 duk_pop(ctx);
65068 duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 2));
65069 lex_pt.line = duk_to_int(ctx, -1);
65070 duk_pop(ctx);
65071
65072 DUK_DDD(DUK_DDDPRINT("second pass of an inner func, skip the function, reparse closing brace; lex offset=%ld, line=%ld",
65073 (long) lex_pt.offset, (long) lex_pt.line));
65074
65075 DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt);
65076 comp_ctx->curr_token.t = 0; /* this is needed for regexp mode */
65077 comp_ctx->curr_token.start_line = 0; /* needed for line number tracking (becomes prev_token.start_line) */
65078 duk__advance(comp_ctx);
65080
65081 return fnum;
65082 }
65083
65084 /*
65085 * On first pass, perform actual parsing. Remember valstack top on entry
65086 * to restore it later, and switch to using a new function in comp_ctx.
65087 */
65088
65089 entry_top = duk_get_top(ctx);
65090 DUK_DDD(DUK_DDDPRINT("before func: entry_top=%ld, curr_tok.start_offset=%ld",
65091 (long) entry_top, (long) comp_ctx->curr_token.start_offset));
65092
65093 DUK_MEMCPY(&old_func, &comp_ctx->curr_func, sizeof(duk_compiler_func));
65094
65095 DUK_MEMZERO(&comp_ctx->curr_func, sizeof(duk_compiler_func));
65097 DUK_ASSERT(comp_ctx->curr_func.num_formals == 0);
65098
65099 /* inherit initial strictness from parent */
65100 comp_ctx->curr_func.is_strict = old_func.is_strict;
65101
65102 DUK_ASSERT(comp_ctx->curr_func.is_notail == 0);
65103 comp_ctx->curr_func.is_function = 1;
65104 DUK_ASSERT(comp_ctx->curr_func.is_eval == 0);
65105 DUK_ASSERT(comp_ctx->curr_func.is_global == 0);
65106 comp_ctx->curr_func.is_setget = is_setget;
65107 comp_ctx->curr_func.is_decl = is_decl;
65108
65109 /*
65110 * Parse inner function
65111 */
65112
65113 duk__parse_func_like_raw(comp_ctx, is_decl, is_setget); /* pushes function template */
65114
65115 /* prev_token.start_offset points to the closing brace here; when skipping
65116 * we're going to reparse the closing brace to ensure semicolon insertion
65117 * etc work as expected.
65118 */
65119 DUK_DDD(DUK_DDDPRINT("after func: prev_tok.start_offset=%ld, curr_tok.start_offset=%ld",
65120 (long) comp_ctx->prev_token.start_offset, (long) comp_ctx->curr_token.start_offset));
65121 DUK_ASSERT(comp_ctx->lex.input[comp_ctx->prev_token.start_offset] == (duk_uint8_t) DUK_ASC_RCURLY);
65122
65123 /* XXX: append primitive */
65124 DUK_ASSERT(duk_get_length(ctx, old_func.funcs_idx) == (duk_size_t) (old_func.fnum_next * 3));
65125 fnum = old_func.fnum_next++;
65126
65127 if (fnum > DUK__MAX_FUNCS) {
65129 }
65130
65131 /* array writes autoincrement length */
#define DUK_TOK_RCURLY
#define DUK__MAX_FUNCS
#define DUK_STR_FUNC_LIMIT

◆ 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 64925 of file duktape-1.5.2/src/duktape.c.

64926 : %!O",
64927 (duk_heaphdr *) comp_ctx->curr_token.str1));
64928
64929 /* XXX: append primitive */
64930 duk_push_hstring(ctx, comp_ctx->curr_token.str1);
64931 n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx);
64932 duk_put_prop_index(ctx, comp_ctx->curr_func.argnames_idx, n);
64933
64934 duk__advance(comp_ctx); /* eat identifier */
64935 }
64936}
64937
64938/* Parse a function-like expression, assuming that 'comp_ctx->curr_func' is
64939 * correctly set up. Assumes that curr_token is just after 'function' (or
64940 * 'set'/'get' etc).
64941 */
64942DUK_LOCAL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget) {
64943 duk_hthread *thr = comp_ctx->thr;
64944 duk_context *ctx = (duk_context *) thr;
64945
64946 DUK_ASSERT(comp_ctx->curr_func.num_formals == 0);
64947 DUK_ASSERT(comp_ctx->curr_func.is_function == 1);
64948 DUK_ASSERT(comp_ctx->curr_func.is_eval == 0);
64949 DUK_ASSERT(comp_ctx->curr_func.is_global == 0);
64950 DUK_ASSERT(comp_ctx->curr_func.is_setget == is_setget);
64951 DUK_ASSERT(comp_ctx->curr_func.is_decl == is_decl);
64952
64953 duk__update_lineinfo_currtoken(comp_ctx);
64954
64955 /*
64956 * Function name (if any)
64957 *
64958 * We don't check for prohibited names here, because we don't
64959 * yet know whether the function will be strict. Function body
64960 * parsing handles this retroactively.
64961 *
64962 * For function expressions and declarations function name must
64963 * be an Identifer (excludes reserved words). For setter/getter
64964 * it is a PropertyName which allows reserved words and also
64965 * strings and numbers (e.g. "{ get 1() { ... } }").
64966 */
64967
64968 if (is_setget) {
64969 /* PropertyName -> IdentifierName | StringLiteral | NumericLiteral */
64970 if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER ||
64971 comp_ctx->curr_token.t == DUK_TOK_STRING) {
64972 duk_push_hstring(ctx, comp_ctx->curr_token.str1); /* keep in valstack */
64973 } else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) {
64974 duk_push_number(ctx, comp_ctx->curr_token.num);
64975 duk_to_string(ctx, -1);
64976 } else {
64977 DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_GETSET_NAME);
64978 }
64979 comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1); /* borrowed reference */
64980 DUK_ASSERT(comp_ctx->curr_func.h_name != NULL);
64981 duk__advance(comp_ctx);
64982 } else {
64983 /* Function name is an Identifier (not IdentifierName), but we get
64984 * the raw name (not recognizing keywords) here and perform the name
64985 * checks only after pass 1.
64986 */
64987 if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER) {
64988 duk_push_hstring(ctx, comp_ctx->curr_token.str1); /* keep in valstack */
64989 comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1); /* borrowed reference */
64990 DUK_ASSERT(comp_ctx->curr_func.h_name != NULL);
64991 duk__advance(comp_ctx);
64992 } else {
64993 /* valstack will be unbalanced, which is OK */
64994 DUK_ASSERT(!is_setget);
64995 if (is_decl) {
64996 DUK_ERROR_SYNTAX(thr, DUK_STR_FUNC_NAME_REQUIRED);
64997 }
64998 }
64999 }
65000
65001 DUK_DDD(DUK_DDDPRINT("function name: %!O",
65002 (duk_heaphdr *) comp_ctx->curr_func.h_name));
65003
65004 /*
65005 * Formal argument list
65006 *
65007 * We don't check for prohibited names or for duplicate argument
65008 * names here, becase we don't yet know whether the function will
65009 * be strict. Function body parsing handles this retroactively.
65010 */
65011
65012 duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
65013
65014 duk__parse_func_formals(comp_ctx);
65015
65016 DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RPAREN);
65017 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 63089 of file duktape-1.5.2/src/duktape.c.

63102 :
63104}
63105
63107 duk_reg_t temp_reset;
63108 duk_regconst_t rc_cond;
63109 duk_int_t pc_jump_false;
63110
63111 DUK_DDD(DUK_DDDPRINT("begin parsing if statement"));
63112
63113 temp_reset = DUK__GETTEMP(comp_ctx);
63114
63115 duk__advance(comp_ctx); /* eat 'if' */
63117
63118 rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
63119 duk__emit_if_true_skip(comp_ctx, rc_cond);
63120 pc_jump_false = duk__emit_jump_empty(comp_ctx); /* jump to end or else part */
63121 DUK__SETTEMP(comp_ctx, temp_reset);
63122
63124
63125 duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
63126
63127 /* The 'else' ambiguity is resolved by 'else' binding to the innermost
63128 * construct, so greedy matching is correct here.
63129 */
63130
63131 if (comp_ctx->curr_token.t == DUK_TOK_ELSE) {
63132 duk_int_t pc_jump_end;
63133
63134 DUK_DDD(DUK_DDDPRINT("if has else part"));
#define DUK_STR_INVALID_SWITCH
DUK_LOCAL_DECL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
DUK_LOCAL_DECL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags)
#define DUK_TOK_ELSE

◆ duk__parse_regexp_flags()

DUK_LOCAL duk_uint32_t duk__parse_regexp_flags ( duk_hthread * thr,
duk_hstring * h )

Definition at line 78133 of file duktape-1.5.2/src/duktape.c.

78140 : charlen=%ld",
78141 (long) out_atom_info->charlen));
78142
78143 re_ctx->recursion_depth--;
78144}
78145
78146/*
78147 * Flags parsing (see E5 Section 15.10.4.1).
78148 */
78149
78150DUK_LOCAL duk_uint32_t duk__parse_regexp_flags(duk_hthread *thr, duk_hstring *h) {
78151 const duk_uint8_t *p;
78152 const duk_uint8_t *p_end;
78153 duk_uint32_t flags = 0;
78154
78155 p = DUK_HSTRING_GET_DATA(h);
78156 p_end = p + DUK_HSTRING_GET_BYTELEN(h);
78157
78158 /* Note: can be safely scanned as bytes (undecoded) */
78159
78160 while (p < p_end) {
78161 duk_uint8_t c = *p++;
78162 switch ((int) c) {
78163 case (int) 'g': {
78164 if (flags & DUK_RE_FLAG_GLOBAL) {
78165 goto error;
78166 }
78167 flags |= DUK_RE_FLAG_GLOBAL;
78168 break;
78169 }
78170 case (int) 'i': {
78171 if (flags & DUK_RE_FLAG_IGNORE_CASE) {
78172 goto error;
78173 }
78174 flags |= DUK_RE_FLAG_IGNORE_CASE;
78175 break;
78176 }
78177 case (int) 'm': {
78178 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 63251 of file duktape-1.5.2/src/duktape.c.

63254 : 2));
63255 } else {
63256 DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, "
63257 "label_catch_depth=%ld, catch_depth=%ld "
63258 "-> use slow variant (longjmp)",
63259 (long) is_break, (long) label_id, (long) label_is_closest,
63260 (long) label_catch_depth, (long) comp_ctx->curr_func.catch_depth));
63261
63262 duk__emit_extraop_bc(comp_ctx,
63264 (duk_regconst_t) label_id);
63265 }
63266}
63267
63269 duk_hthread *thr = comp_ctx->thr;
63270 duk_regconst_t rc_val;
63271 duk_small_uint_t ret_flags;
63272
63273 duk__advance(comp_ctx); /* eat 'return' */
63274
63275 /* A 'return' statement is only allowed inside an actual function body,
63276 * not as part of eval or global code.
63277 */
63278 if (!comp_ctx->curr_func.is_function) {
63280 }
63281
63282 ret_flags = 0;
63283
63284 if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || /* explicit semi follows */
63285 comp_ctx->curr_token.lineterm || /* automatic semi will be inserted */
63286 comp_ctx->curr_token.allow_auto_semi) { /* automatic semi will be inserted */
63287 DUK_DDD(DUK_DDDPRINT("empty return value -> undefined"));
63288 rc_val = 0;
63289 } else {
63290 duk_int_t pc_before_expr;
63291 duk_int_t pc_after_expr;
63292
63293 DUK_DDD(DUK_DDDPRINT("return with a value"));
63294
63295 DUK_UNREF(pc_before_expr);
63296 DUK_UNREF(pc_after_expr);
63297
63298 pc_before_expr = duk__get_current_pc(comp_ctx);
63299 rc_val = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
63300 pc_after_expr = duk__get_current_pc(comp_ctx);
63301
63302 /* Tail call check: if last opcode emitted was CALL(I), and
63303 * the context allows it, change the CALL(I) to a tail call.
63304 * This doesn't guarantee that a tail call will be allowed at
63305 * runtime, so the RETURN must still be emitted. (Duktape
63306 * 0.10.0 avoided this and simulated a RETURN if a tail call
63307 * couldn't be used at runtime; but this didn't work
63308 * correctly with a thread yield/resume, see
63309 * test-bug-tailcall-thread-yield-resume.js for discussion.)
63310 *
63311 * In addition to the last opcode being CALL, we also need to
63312 * be sure that 'rc_val' is the result register of the CALL(I).
63313 * For instance, for the expression 'return 0, (function ()
63314 * { return 1; }), 2' the last opcode emitted is CALL (no
63315 * bytecode is emitted for '2') but 'rc_val' indicates
63316 * constant '2'. Similarly if '2' is replaced by a register
63317 * bound variable, no opcodes are emitted but tail call would
63318 * be incorrect.
63319 *
63320 * This is tricky and easy to get wrong. It would be best to
63321 * track enough expression metadata to check that 'rc_val' came
63322 * from that last CALL instruction. We don't have that metadata
63323 * now, so we check that 'rc_val' is a temporary register result
63324 * (not a constant or a register bound variable). There should
63325 * be no way currently for 'rc_val' to be a temporary for an
63326 * expression following the CALL instruction without emitting
63327 * some opcodes following the CALL. This proxy check is used
63328 * below.
63329 *
63330 * See: test-bug-comma-expr-gh131.js.
63331 *
63332 * The non-standard 'caller' property disables tail calls
63333 * because they pose some special cases which haven't been
63334 * fixed yet.
63335 */
63336
63337#if defined(DUK_USE_TAILCALL)
63338 if (comp_ctx->curr_func.catch_depth == 0 && /* no catchers */
63339 pc_after_expr > pc_before_expr) { /* at least one opcode emitted */
63340 duk_compiler_instr *instr;
63342
63343 instr = duk__get_instr_ptr(comp_ctx, pc_after_expr - 1);
63344 DUK_ASSERT(instr != NULL);
63345
63346 op = (duk_small_uint_t) DUK_DEC_OP(instr->ins);
63347 if ((op == DUK_OP_CALL || op == DUK_OP_CALLI) &&
63348 DUK__ISTEMP(comp_ctx, rc_val) /* see above */) {
63349 DUK_DDD(DUK_DDDPRINT("return statement detected a tail call opportunity: "
#define DUK_STR_INVALID_RETURN
DUK_LOCAL_DECL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res)

◆ 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 63666 of file duktape-1.5.2/src/duktape.c.

63667 : %ld", (long) label_id));
63668
63669 duk__emit_extraop_bc(comp_ctx,
63670 DUK_EXTRAOP_LABEL,
63671 (duk_regconst_t) label_id);
63672 duk__emit_invalid(comp_ctx);
63673 duk__emit_invalid(comp_ctx);
63674
63675 return label_id;
63676}
63677
63678/* Parse a single statement.
63679 *
63680 * Creates a label site (with an empty label) automatically for iteration
63681 * statements. Also "peels off" any label statements for explicit labels.
63682 */
63683DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem) {
63684 duk_hthread *thr = comp_ctx->thr;
63685 duk_context *ctx = (duk_context *) thr;
63686 duk_bool_t dir_prol_at_entry; /* directive prologue status at entry */
63687 duk_reg_t temp_at_entry;
63688 duk_uarridx_t labels_len_at_entry;
63689 duk_int_t pc_at_entry; /* assumed to also be PC of "LABEL" */
63690 duk_int_t stmt_id;
63691 duk_small_uint_t stmt_flags = 0;
63692 duk_int_t label_id = -1;
63693 duk_small_uint_t tok;
63694
63695 DUK__RECURSION_INCREASE(comp_ctx, thr);
63696
63697 temp_at_entry = DUK__GETTEMP(comp_ctx);
63698 pc_at_entry = duk__get_current_pc(comp_ctx);
63699 labels_len_at_entry = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.labelnames_idx);
63700 stmt_id = comp_ctx->curr_func.stmt_next++;
63701 dir_prol_at_entry = comp_ctx->curr_func.in_directive_prologue;
63702
63703 DUK_UNREF(stmt_id);
63704
63705 DUK_DDD(DUK_DDDPRINT("parsing a statement, stmt_id=%ld, temp_at_entry=%ld, labels_len_at_entry=%ld, "
63706 "is_strict=%ld, in_directive_prologue=%ld, catch_depth=%ld",
63707 (long) stmt_id, (long) temp_at_entry, (long) labels_len_at_entry,
63708 (long) comp_ctx->curr_func.is_strict, (long) comp_ctx->curr_func.in_directive_prologue,
63709 (long) comp_ctx->curr_func.catch_depth));
63710
63711 /* The directive prologue flag is cleared by default so that it is
63712 * unset for any recursive statement parsing. It is only "revived"
63713 * if a directive is detected. (We could also make directives only
63714 * allowed if 'allow_source_elem' was true.)
63715 */
63716 comp_ctx->curr_func.in_directive_prologue = 0;
63717
63718 retry_parse:
63719
63720 DUK_DDD(DUK_DDDPRINT("try stmt parse, stmt_id=%ld, label_id=%ld, allow_source_elem=%ld, catch_depth=%ld",
63721 (long) stmt_id, (long) label_id, (long) allow_source_elem,
63722 (long) comp_ctx->curr_func.catch_depth));
63723
63724 /*
63725 * Detect iteration statements; if encountered, establish an
63726 * empty label.
63727 */
63728
63729 tok = comp_ctx->curr_token.t;
63730 if (tok == DUK_TOK_FOR || tok == DUK_TOK_DO || tok == DUK_TOK_WHILE ||
63731 tok == DUK_TOK_SWITCH) {
63732 DUK_DDD(DUK_DDDPRINT("iteration/switch statement -> add empty label"));
63733
63734 label_id = duk__stmt_label_site(comp_ctx, label_id);
63735 duk__add_label(comp_ctx,
63736 DUK_HTHREAD_STRING_EMPTY_STRING(thr),
63737 pc_at_entry /*pc_label*/,
63738 label_id);
63739 }
63740
63741 /*
63742 * Main switch for statement / source element type.
63743 */
63744
63745 switch (comp_ctx->curr_token.t) {
63746 case DUK_TOK_FUNCTION: {
63747 /*
63748 * Function declaration, function expression, or (non-standard)
63749 * function statement.
63750 *
63751 * The E5 specification only allows function declarations at
63752 * the top level (in "source elements"). An ExpressionStatement
63753 * is explicitly not allowed to begin with a "function" keyword
63754 * (E5 Section 12.4). Hence any non-error semantics for such
63755 * non-top-level statements are non-standard. Duktape semantics
63756 * for function statements are modelled after V8, see
63757 * test-dev-func-decl-outside-top.js.
63758 */
63759
63760#if defined(DUK_USE_NONSTD_FUNC_STMT)
63761 /* Lenient: allow function declarations outside top level in
63762 * non-strict mode but reject them in strict mode.
63763 */
63764 if (allow_source_elem || !comp_ctx->curr_func.is_strict)
63765#else /* DUK_USE_NONSTD_FUNC_STMT */
63766 /* Strict: never allow function declarations outside top level. */
63767 if (allow_source_elem)
63768#endif /* DUK_USE_NONSTD_FUNC_STMT */
63769 {
63770 /* FunctionDeclaration: not strictly a statement but handled as such.
63771 *
63772 * O(depth^2) parse count for inner functions is handled by recording a
63773 * lexer offset on the first compilation pass, so that the function can
63774 * be efficiently skipped on the second pass. This is encapsulated into
63775 * duk__parse_func_like_fnum().
63776 */
63777
63778 duk_int_t fnum;
63779
63780 DUK_DDD(DUK_DDDPRINT("function declaration statement"));
63781
63782 duk__advance(comp_ctx); /* eat 'function' */
63783 fnum = duk__parse_func_like_fnum(comp_ctx, 1 /*is_decl*/, 0 /*is_setget*/);
63784
63785 if (comp_ctx->curr_func.in_scanning) {
63786 duk_uarridx_t n;
63787 duk_hstring *h_funcname;
63788
63789 duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, fnum * 3);
63790 duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME); /* -> [ ... func name ] */
63791 h_funcname = duk_get_hstring(ctx, -1);
63792 DUK_ASSERT(h_funcname != NULL);
63793
63794 DUK_DDD(DUK_DDDPRINT("register function declaration %!O in pass 1, fnum %ld",
63795 (duk_heaphdr *) h_funcname, (long) fnum));
63796 n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
63797 duk_push_hstring(ctx, h_funcname);
63798 duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n);
63799 duk_push_int(ctx, (duk_int_t) (DUK_DECL_TYPE_FUNC + (fnum << 8)));
63800 duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1);
63801
63802 duk_pop_n(ctx, 2);
63803 }
63804
63805 /* no statement value (unlike function expression) */
63806 stmt_flags = 0;
63807 break;
63808 } else {
63809 DUK_ERROR_SYNTAX(thr, DUK_STR_FUNC_STMT_NOT_ALLOWED);
63810 }
63811 break;
63812 }
63813 case DUK_TOK_LCURLY: {
63814 DUK_DDD(DUK_DDDPRINT("block statement"));
63815 duk__advance(comp_ctx);
63816 duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
63817 /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
63818 if (label_id >= 0) {
63819 duk__patch_jump_here(comp_ctx, pc_at_entry + 1); /* break jump */
63820 }
63821 stmt_flags = 0;
63822 break;
63823 }
63824 case DUK_TOK_CONST: {
63825 DUK_DDD(DUK_DDDPRINT("constant declaration statement"));
63826 duk__parse_var_stmt(comp_ctx, res, DUK__EXPR_FLAG_REQUIRE_INIT /*expr_flags*/);
63827 stmt_flags = DUK__HAS_TERM;
63828 break;
63829 }
63830 case DUK_TOK_VAR: {
63831 DUK_DDD(DUK_DDDPRINT("variable declaration statement"));
63832 duk__parse_var_stmt(comp_ctx, res, 0 /*expr_flags*/);
63833 stmt_flags = DUK__HAS_TERM;
63834 break;
63835 }
63836 case DUK_TOK_SEMICOLON: {
63837 /* empty statement with an explicit semicolon */
63838 DUK_DDD(DUK_DDDPRINT("empty statement"));
63839 stmt_flags = DUK__HAS_TERM;
63840 break;
63841 }
63842 case DUK_TOK_IF: {
63843 DUK_DDD(DUK_DDDPRINT("if statement"));
63844 duk__parse_if_stmt(comp_ctx, res);
63845 if (label_id >= 0) {
63846 duk__patch_jump_here(comp_ctx, pc_at_entry + 1); /* break jump */
63847 }
63848 stmt_flags = 0;
63849 break;
63850 }
63851 case DUK_TOK_DO: {
63852 /*
63853 * Do-while statement is mostly trivial, but there is special
63854 * handling for automatic semicolon handling (triggered by the
63855 * DUK__ALLOW_AUTO_SEMI_ALWAYS) flag related to a bug filed at:
63856 *
63857 * https://bugs.ecmascript.org/show_bug.cgi?id=8
63858 *
63859 * See doc/compiler.rst for details.
63860 */
63861 DUK_DDD(DUK_DDDPRINT("do statement"));
63862 DUK_ASSERT(label_id >= 0);
63863 duk__update_label_flags(comp_ctx,
63864 label_id,
63865 DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
63866 duk__parse_do_stmt(comp_ctx, res, pc_at_entry);
63867 stmt_flags = DUK__HAS_TERM | DUK__ALLOW_AUTO_SEMI_ALWAYS; /* DUK__ALLOW_AUTO_SEMI_ALWAYS workaround */
63868 break;
63869 }
63870 case DUK_TOK_WHILE: {
63871 DUK_DDD(DUK_DDDPRINT("while statement"));
63872 DUK_ASSERT(label_id >= 0);
63873 duk__update_label_flags(comp_ctx,
63874 label_id,
63875 DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
63876 duk__parse_while_stmt(comp_ctx, res, pc_at_entry);
63877 stmt_flags = 0;
63878 break;
63879 }
63880 case DUK_TOK_FOR: {
63881 /*
63882 * For/for-in statement is complicated to parse because
63883 * determining the statement type (three-part for vs. a
63884 * for-in) requires potential backtracking.
63885 *
63886 * See the helper for the messy stuff.
63887 */
63888 DUK_DDD(DUK_DDDPRINT("for/for-in statement"));
63889 DUK_ASSERT(label_id >= 0);
63890 duk__update_label_flags(comp_ctx,
63891 label_id,
63892 DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
63893 duk__parse_for_stmt(comp_ctx, res, pc_at_entry);
63894 stmt_flags = 0;
63895 break;
63896 }
63897 case DUK_TOK_CONTINUE:
63898 case DUK_TOK_BREAK: {
63899 DUK_DDD(DUK_DDDPRINT("break/continue statement"));
63900 duk__parse_break_or_continue_stmt(comp_ctx, res);
63901 stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
63902 break;
63903 }
63904 case DUK_TOK_RETURN: {
63905 DUK_DDD(DUK_DDDPRINT("return statement"));
63906 duk__parse_return_stmt(comp_ctx, res);
63907 stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
63908 break;
63909 }
63910 case DUK_TOK_WITH: {
63911 DUK_DDD(DUK_DDDPRINT("with statement"));
63912 comp_ctx->curr_func.with_depth++;
63913 duk__parse_with_stmt(comp_ctx, res);
63914 if (label_id >= 0) {
63915 duk__patch_jump_here(comp_ctx, pc_at_entry + 1); /* break jump */
63916 }
63917 comp_ctx->curr_func.with_depth--;
63918 stmt_flags = 0;
63919 break;
63920 }
63921 case DUK_TOK_SWITCH: {
63922 /*
63923 * The switch statement is pretty messy to compile.
63924 * See the helper for details.
63925 */
63926 DUK_DDD(DUK_DDDPRINT("switch statement"));
63927 DUK_ASSERT(label_id >= 0);
63928 duk__update_label_flags(comp_ctx,
63929 label_id,
63930 DUK_LABEL_FLAG_ALLOW_BREAK); /* don't allow continue */
63931 duk__parse_switch_stmt(comp_ctx, res, pc_at_entry);
63932 stmt_flags = 0;
63933 break;
63934 }
63935 case DUK_TOK_THROW: {
63936 DUK_DDD(DUK_DDDPRINT("throw statement"));
63937 duk__parse_throw_stmt(comp_ctx, res);
63938 stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
63939 break;
63940 }
63941 case DUK_TOK_TRY: {
63942 DUK_DDD(DUK_DDDPRINT("try statement"));
63943 duk__parse_try_stmt(comp_ctx, res);
63944 stmt_flags = 0;
63945 break;
63946 }
63947 case DUK_TOK_DEBUGGER: {
63948 duk__advance(comp_ctx);
63949#if defined(DUK_USE_DEBUGGER_SUPPORT)
63950 DUK_DDD(DUK_DDDPRINT("debugger statement: debugging enabled, emit debugger opcode"));
63951 duk__emit_extraop_only(comp_ctx, DUK_EXTRAOP_DEBUGGER);
63952#else
63953 DUK_DDD(DUK_DDDPRINT("debugger statement: ignored"));
63954#endif
63955 stmt_flags = DUK__HAS_TERM;
63956 break;
63957 }
63958 default: {
63959 /*
63960 * Else, must be one of:
63961 * - ExpressionStatement, possibly a directive (String)
63962 * - LabelledStatement (Identifier followed by ':')
63963 *
63964 * Expressions beginning with 'function' keyword are covered by a case
63965 * above (such expressions are not allowed in standard E5 anyway).
63966 * Also expressions starting with '{' are interpreted as block
63967 * statements. See E5 Section 12.4.
63968 *
63969 * Directive detection is tricky; see E5 Section 14.1 on directive
63970 * prologue. A directive is an expression statement with a single
63971 * string literal and an explicit or automatic semicolon. Escape
63972 * characters are significant and no parens etc are allowed:
63973 *
63974 * 'use strict'; // valid 'use strict' directive
63975 * 'use\u0020strict'; // valid directive, not a 'use strict' directive
63976 * ('use strict'); // not a valid directive
63977 *
63978 * The expression is determined to consist of a single string literal
63979 * based on duk__expr_nud() and duk__expr_led() call counts. The string literal
63980 * of a 'use strict' directive is determined to lack any escapes based
63981 * num_escapes count from the lexer. Note that other directives may be
63982 * allowed to contain escapes, so a directive with escapes does not
63983 * terminate a directive prologue.
63984 *
63985 * We rely on the fact that the expression parser will not emit any
63986 * code for a single token expression. However, it will generate an
63987 * intermediate value which we will then successfully ignore.
63988 *
63989 * A similar approach is used for labels.
63990 */
63991
63992 duk_bool_t single_token;
63993
63994 DUK_DDD(DUK_DDDPRINT("expression statement"));
63995 duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
63996
63997 single_token = (comp_ctx->curr_func.nud_count == 1 && /* one token */
63998 comp_ctx->curr_func.led_count == 0); /* no operators */
63999
64000 if (single_token &&
64001 comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
64002 comp_ctx->curr_token.t == DUK_TOK_COLON) {
64003 /*
64004 * Detected label
64005 */
64006
64007 duk_hstring *h_lab;
64008
64009 /* expected ival */
64010 DUK_ASSERT(res->t == DUK_IVAL_VAR);
64011 DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE);
64012 DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx)));
64013 h_lab = comp_ctx->prev_token.str1;
64014 DUK_ASSERT(h_lab != NULL);
64015
64016 DUK_DDD(DUK_DDDPRINT("explicit label site for label '%!O'",
64017 (duk_heaphdr *) h_lab));
64018
64019 duk__advance(comp_ctx); /* eat colon */
64020
64021 label_id = duk__stmt_label_site(comp_ctx, label_id);
64022
64023 duk__add_label(comp_ctx,
64024 h_lab,
64025 pc_at_entry /*pc_label*/,
64026 label_id);
64027
64028 /* a statement following a label cannot be a source element
64029 * (a function declaration).
64030 */
64031 allow_source_elem = 0;
64032
64033 DUK_DDD(DUK_DDDPRINT("label handled, retry statement parsing"));
64034 goto retry_parse;
64035 }
64036
64037 stmt_flags = 0;
64038
64039 if (dir_prol_at_entry && /* still in prologue */
64040 single_token && /* single string token */
64041 comp_ctx->prev_token.t == DUK_TOK_STRING) {
64042 /*
64043 * Detected a directive
64044 */
64045 duk_hstring *h_dir;
64046
64047 /* expected ival */
64048 DUK_ASSERT(res->t == DUK_IVAL_PLAIN);
64049 DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE);
64050 DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx)));
64051 h_dir = comp_ctx->prev_token.str1;
64052 DUK_ASSERT(h_dir != NULL);
64053
64054 DUK_DDD(DUK_DDDPRINT("potential directive: %!O", h_dir));
64055
64056 stmt_flags |= DUK__STILL_PROLOGUE;
64057
64058 /* Note: escaped characters differentiate directives */
64059
64060 if (comp_ctx->prev_token.num_escapes > 0) {
64061 DUK_DDD(DUK_DDDPRINT("directive contains escapes: valid directive "
64062 "but we ignore such directives"));
64063 } else {
64064 /*
64065 * The length comparisons are present to handle
64066 * strings like "use strict\u0000foo" as required.
64067 */
64068
64069 if (DUK_HSTRING_GET_BYTELEN(h_dir) == 10 &&
64070 DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use strict", 10) == 0) {
64071#if defined(DUK_USE_STRICT_DECL)
64072 DUK_DDD(DUK_DDDPRINT("use strict directive detected: strict flag %ld -> %ld",
64073 (long) comp_ctx->curr_func.is_strict, (long) 1));
64074 comp_ctx->curr_func.is_strict = 1;
64075#else
64076 DUK_DDD(DUK_DDDPRINT("use strict detected but strict declarations disabled, ignoring"));
64077#endif
64078 } else if (DUK_HSTRING_GET_BYTELEN(h_dir) == 14 &&
64079 DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use duk notail", 14) == 0) {
64080 DUK_DDD(DUK_DDDPRINT("use duk notail directive detected: notail flag %ld -> %ld",
64081 (long) comp_ctx->curr_func.is_notail, (long) 1));
64082 comp_ctx->curr_func.is_notail = 1;
64083 } else {
64084 DUK_DD(DUK_DDPRINT("unknown directive: '%!O', ignoring but not terminating "
64085 "directive prologue", (duk_hobject *) h_dir));
64086 }
64087 }
64088 } else {
64089 DUK_DDD(DUK_DDDPRINT("non-directive expression statement or no longer in prologue; "
64090 "prologue terminated if still active"));
64091 }
64092
64093 stmt_flags |= DUK__HAS_VAL | DUK__HAS_TERM;
64094 }
64095 } /* end switch (tok) */
64096
64097 /*
64098 * Statement value handling.
64099 *
64100 * Global code and eval code has an implicit return value
64101 * which comes from the last statement with a value
64102 * (technically a non-"empty" continuation, which is
64103 * different from an empty statement).
64104 *
64105 * Since we don't know whether a later statement will
64106 * override the value of the current statement, we need
64107 * to coerce the statement value to a register allocated
64108 * for implicit return values. In other cases we need
64109 * to coerce the statement value to a plain value to get
64110 * any side effects out (consider e.g. "foo.bar;").
64111 */
64112
64113 /* XXX: what about statements which leave a half-cooked value in 'res'
64114 * but have no stmt value? Any such statements?
64115 */
64116
64117 if (stmt_flags & DUK__HAS_VAL) {
64118 duk_reg_t reg_stmt_value = comp_ctx->curr_func.reg_stmt_value;
64119 if (reg_stmt_value >= 0) {
64120 duk__ivalue_toforcedreg(comp_ctx, res, reg_stmt_value);
64121 } else {
64122 duk__ivalue_toplain_ignore(comp_ctx, res);
64123 }
64124 } else {
64125 ;
64126 }
64127
64128 /*
64129 * Statement terminator check, including automatic semicolon
64130 * handling. After this step, 'curr_tok' should be the first
64131 * token after a possible statement terminator.
64132 */
64133
64134 if (stmt_flags & DUK__HAS_TERM) {
64135 if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON) {
64136 DUK_DDD(DUK_DDDPRINT("explicit semicolon terminates statement"));
64137 duk__advance(comp_ctx);
64138 } else {
64139 if (comp_ctx->curr_token.allow_auto_semi) {
64140 DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement"));
64141 } else if (stmt_flags & DUK__ALLOW_AUTO_SEMI_ALWAYS) {
64142 /* XXX: make this lenience dependent on flags or strictness? */
64143 DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement (allowed for compatibility "
64144 "even though no lineterm present before next token)"));
64145 } else {
64146 DUK_ERROR_SYNTAX(thr, DUK_STR_UNTERMINATED_STMT);
64147 }
64148 }
64149 } else {
64150 DUK_DDD(DUK_DDDPRINT("statement has no terminator"));
64151 }
64152
64153 /*
64154 * Directive prologue tracking.
64155 */
64156
64157 if (stmt_flags & DUK__STILL_PROLOGUE) {
64158 DUK_DDD(DUK_DDDPRINT("setting in_directive_prologue"));
64159 comp_ctx->curr_func.in_directive_prologue = 1;
64160 }
64161
64162 /*
64163 * Cleanups (all statement parsing flows through here).
64164 *
64165 * Pop label site and reset labels. Reset 'next temp' to value at
static void block(LexState *ls)
#define notail(x)

◆ 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 64182 of file duktape-1.5.2/src/duktape.c.

64199 {
64200 duk_hthread *thr = comp_ctx->thr;
64201 duk_context *ctx = (duk_context *) thr;
64202 duk_ivalue res_alloc;
64203 duk_ivalue *res = &res_alloc;
64204
64205 /* Setup state. Initial ivalue is 'undefined'. */
64206
64208
64209 /* XXX: 'res' setup can be moved to function body level; in fact, two 'res'
64210 * intermediate values suffice for parsing of each function. Nesting is needed
64211 * for nested functions (which may occur inside expressions).
64212 */
64213
64214 DUK_MEMZERO(&res_alloc, sizeof(res_alloc));
64215 res->t = DUK_IVAL_PLAIN;
64216 res->x1.t = DUK_ISPEC_VALUE;
64217 res->x1.valstack_idx = duk_get_top(ctx);
64218 res->x2.valstack_idx = res->x1.valstack_idx + 1;
64219 duk_push_undefined(ctx);
64220 duk_push_undefined(ctx);
64221
64222 /* Parse statements until a closing token (EOF or '}') is found. */
64223
64224 for (;;) {
64225 /* Check whether statement list ends. */
64226
64227 if (expect_eof) {
64228 if (comp_ctx->curr_token.t == DUK_TOK_EOF) {
64229 break;
64230 }
64231 } else {
64232 if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
64233 break;
64234 }
64235 }
64236
#define DUK__PARSE_STATEMENTS_SLOTS
#define DUK_TOK_EOF

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 24787 of file duktape-1.5.2/src/duktape.c.

24804 {
24805 /* XXX: there is a small risk here: because the ISO 8601 parser is
24806 * very loose, it may end up parsing some datetime values which
24807 * would be better parsed with a platform specific parser.
24808 */
24809
24810 DUK_ASSERT(str != NULL);
24811 DUK_DDD(DUK_DDDPRINT("parse datetime from string '%s'", (const char *) str));
24812
24813 if (duk__parse_string_iso8601_subset(ctx, str) != 0) {
24814 return 1;
24815 }
DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const char *str)

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 24592 of file duktape-1.5.2/src/duktape.c.

24609 {
24612 duk_double_t d;
24613 const duk_uint8_t *p;
24614 duk_small_uint_t part_idx = 0;
24615 duk_int_t accum = 0;
24616 duk_small_uint_t ndigits = 0;
24617 duk_bool_t neg_year = 0;
24618 duk_bool_t neg_tzoffset = 0;
24621
24622 /* During parsing, month and day are one-based; set defaults here. */
24623 DUK_MEMZERO(parts, sizeof(parts));
24624 DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] == 0); /* don't care value, year is mandatory */
24625 parts[DUK_DATE_IDX_MONTH] = 1;
24626 parts[DUK_DATE_IDX_DAY] = 1;
24627
24628 /* Special handling for year sign. */
24629 p = (const duk_uint8_t *) str;
24630 ch = p[0];
24631 if (ch == DUK_ASC_PLUS) {
24632 p++;
24633 } else if (ch == DUK_ASC_MINUS) {
24634 neg_year = 1;
24635 p++;
24636 }
24637
24638 for (;;) {
24639 ch = *p++;
24640 DUK_DDD(DUK_DDDPRINT("parsing, part_idx=%ld, char=%ld ('%c')",
24641 (long) part_idx, (long) ch,
24642 (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : DUK_ASC_QUESTION)));
24643
24644 if (ch >= DUK_ASC_0 && ch <= DUK_ASC_9) {
24645 if (ndigits >= 9) {
24646 DUK_DDD(DUK_DDDPRINT("too many digits -> reject"));
24647 goto reject;
24648 }
24649 if (part_idx == DUK__PI_MILLISECOND /*msec*/ && ndigits >= 3) {
24650 /* ignore millisecond fractions after 3 */
24651 } else {
24652 accum = accum * 10 + ((duk_int_t) ch) - ((duk_int_t) DUK_ASC_0) + 0x00;
24653 ndigits++;
24654 }
24655 } else {
24656 duk_uint_fast32_t match_val;
24657 duk_small_int_t sep_idx;
24658
24659 if (ndigits <= 0) {
24660 goto reject;
24661 }
24662 if (part_idx == DUK__PI_MILLISECOND) {
24663 /* complete the millisecond field */
24664 while (ndigits < 3) {
24665 accum *= 10;
24666 ndigits++;
24667 }
24668 }
24669 parts[part_idx] = accum;
24670 DUK_DDD(DUK_DDDPRINT("wrote part %ld -> value %ld", (long) part_idx, (long) accum));
24671
24672 accum = 0;
24673 ndigits = 0;
24674
24675 for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t)); i++) {
24676 if (duk__parse_iso8601_seps[i] == ch) {
24677 break;
24678 }
24679 }
24680 if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t))) {
24681 DUK_DDD(DUK_DDDPRINT("separator character doesn't match -> reject"));
24682 goto reject;
24683 }
24684
24685 sep_idx = i;
24686 match_val = (1UL << part_idx) + (1UL << (sep_idx + 9)); /* match against rule part/sep bits */
24687
24688 for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t)); i++) {
24690 duk_small_uint_t nextpart;
24691 duk_small_uint_t cflags;
24692
24693 DUK_DDD(DUK_DDDPRINT("part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, considering rule=0x%08lx",
24694 (long) part_idx, (long) sep_idx,
24695 (unsigned long) match_val, (unsigned long) rule));
24696
24697 if ((rule & match_val) != match_val) {
24698 continue;
24699 }
24700
24701 DUK__UNPACK_RULE(rule, nextpart, cflags);
24702
24703 DUK_DDD(DUK_DDDPRINT("rule match -> part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, "
24704 "rule=0x%08lx -> nextpart=%ld, cflags=0x%02lx",
24705 (long) part_idx, (long) sep_idx,
24706 (unsigned long) match_val, (unsigned long) rule,
24707 (long) nextpart, (unsigned long) cflags));
24708
24709 if (cflags & DUK__CF_NEG) {
24710 neg_tzoffset = 1;
24711 }
24712
24713 if (cflags & DUK__CF_ACCEPT) {
24714 goto accept;
24715 }
24716
24717 if (cflags & DUK__CF_ACCEPT_NUL) {
24718 DUK_ASSERT(*(p - 1) != (char) 0);
24719 if (*p == DUK_ASC_NUL) {
24720 goto accept;
24721 }
24722 goto reject;
24723 }
24724
24725 part_idx = nextpart;
24726 break;
24727 } /* rule match */
24728
24729 if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t))) {
24730 DUK_DDD(DUK_DDDPRINT("no rule matches -> reject"));
24731 goto reject;
24732 }
24733
24734 if (ch == 0) {
24735 /* This shouldn't be necessary, but check just in case
24736 * to avoid any chance of overruns.
24737 */
24738 DUK_DDD(DUK_DDDPRINT("NUL after rule matching (should not happen) -> reject"));
24739 goto reject;
24740 }
24741 } /* if-digit-else-ctrl */
24742 } /* char loop */
24743
24744 /* We should never exit the loop above. */
24746
24747 reject:
24748 DUK_DDD(DUK_DDDPRINT("reject"));
24749 return 0;
24750
24751 accept:
24752 DUK_DDD(DUK_DDDPRINT("accept"));
24753
24754 /* Apply timezone offset to get the main parts in UTC */
24755 if (neg_year) {
24756 parts[DUK__PI_YEAR] = -parts[DUK__PI_YEAR];
24757 }
24758 if (neg_tzoffset) {
24759 parts[DUK__PI_HOUR] += parts[DUK__PI_TZHOUR];
24760 parts[DUK__PI_MINUTE] += parts[DUK__PI_TZMINUTE];
24761 } else {
24762 parts[DUK__PI_HOUR] -= parts[DUK__PI_TZHOUR];
24763 parts[DUK__PI_MINUTE] -= parts[DUK__PI_TZMINUTE];
24764 }
24765 parts[DUK__PI_MONTH] -= 1; /* zero-based month */
24766 parts[DUK__PI_DAY] -= 1; /* zero-based day */
DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[]
#define DUK__PI_TZMINUTE
#define DUK_ASC_NUL
#define DUK__CF_ACCEPT_NUL
#define DUK__PI_HOUR
#define DUK__UNPACK_RULE(rule, var_nextidx, var_flags)
#define DUK__PI_MONTH
DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[]
#define DUK__PI_TZHOUR
#define DUK__CF_ACCEPT
#define DUK__NUM_ISO8601_PARSER_PARTS
#define DUK__PI_YEAR
#define DUK__CF_NEG
#define DUK_ASC_QUESTION
#define DUK__PI_MINUTE
#define DUK__PI_DAY
#define DUK__PI_MILLISECOND

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 62890 of file duktape-1.5.2/src/duktape.c.

62899 :
62900 DUK_DDD(DUK_DDDPRINT("end parsing a for/for-in statement"));
62901 return;
62902
62903 syntax_error:
62905}
62906
62907DUK_LOCAL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
62908 duk_hthread *thr = comp_ctx->thr;
62909 duk_reg_t temp_at_loop;
62910 duk_regconst_t rc_switch; /* reg/const for switch value */
62911 duk_regconst_t rc_case; /* reg/const for case value */
62912 duk_reg_t reg_temp; /* general temp register */
62913 duk_int_t pc_prevcase = -1;
62914 duk_int_t pc_prevstmt = -1;
62915 duk_int_t pc_default = -1; /* -1 == not set, -2 == pending (next statement list) */
62916
62917 /* Note: negative pc values are ignored when patching jumps, so no explicit checks needed */
62918
62919 /*
62920 * Switch is pretty complicated because of several conflicting concerns:
62921 *
62922 * - Want to generate code without an intermediate representation,
62923 * i.e., in one go
62924 *
62925 * - Case selectors are expressions, not values, and may thus e.g. throw
62926 * exceptions (which causes evaluation order concerns)
62927 *
62928 * - Evaluation semantics of case selectors and default clause need to be
62929 * carefully implemented to provide correct behavior even with case value
62930 * side effects
62931 *
62932 * - Fall through case and default clauses; avoiding dead JUMPs if case
62933 * ends with an unconditional jump (a break or a continue)
62934 *
62935 * - The same case value may occur multiple times, but evaluation rules
62936 * only process the first match before switching to a "propagation" mode
62937 * where case values are no longer evaluated
62938 *
62939 * See E5 Section 12.11. Also see doc/compiler.rst for compilation
62940 * discussion.
62941 */
62942
62943 duk__advance(comp_ctx);
62945 rc_switch = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
62948
62949 DUK_DDD(DUK_DDDPRINT("switch value in register %ld", (long) rc_switch));
62950
62951 temp_at_loop = DUK__GETTEMP(comp_ctx);
62952
62953 for (;;) {
62954 duk_int_t num_stmts;
62955 duk_small_int_t tok;
62956
62957 /* sufficient for keeping temp reg numbers in check */
62958 DUK__SETTEMP(comp_ctx, temp_at_loop);
62959
62960 if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
62961 break;
62962 }
62963
62964 /*
62965 * Parse a case or default clause.
62966 */
62967
62968 if (comp_ctx->curr_token.t == DUK_TOK_CASE) {
62969 /*
62970 * Case clause.
62971 *
62972 * Note: cannot use reg_case as a temp register (for SEQ target)
62973 * because it may be a constant.
62974 */
62975
62976 duk__patch_jump_here(comp_ctx, pc_prevcase); /* chain jumps for case
62977 * evaluation and checking
62978 */
62979
62980 duk__advance(comp_ctx);
62981 rc_case = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
62983
62984 reg_temp = DUK__ALLOCTEMP(comp_ctx);
62985 duk__emit_a_b_c(comp_ctx,
62986 DUK_OP_SEQ,
62987 (duk_regconst_t) reg_temp,
62988 rc_switch,
62989 rc_case);
62990 duk__emit_if_true_skip(comp_ctx, (duk_regconst_t) reg_temp);
62991
62992 /* jump to next case clause */
62993 pc_prevcase = duk__emit_jump_empty(comp_ctx); /* no match, next case */
62994
62995 /* statements go here (if any) on next loop */
62996 } else if (comp_ctx->curr_token.t == DUK_TOK_DEFAULT) {
62997 /*
62998 * Default clause.
62999 */
63000
63001 if (pc_default >= 0) {
63002 goto syntax_error;
63003 }
63004 duk__advance(comp_ctx);
63006
63007 /* Fix for https://github.com/svaarala/duktape/issues/155:
63008 * If 'default' is first clause (detected by pc_prevcase < 0)
63009 * we need to ensure we stay in the matching chain.
63010 */
63011 if (pc_prevcase < 0) {
63012 DUK_DD(DUK_DDPRINT("default clause is first, emit prevcase jump"));
63013 pc_prevcase = duk__emit_jump_empty(comp_ctx);
63014 }
63015
63016 /* default clause matches next statement list (if any) */
63017 pc_default = -2;
63018 } else {
63019 /* Code is not accepted before the first case/default clause */
63020 goto syntax_error;
63021 }
63022
63023 /*
63024 * Parse code after the clause. Possible terminators are
63025 * 'case', 'default', and '}'.
63026 *
63027 * Note that there may be no code at all, not even an empty statement,
63028 * between case clauses. This must be handled just like an empty statement
63029 * (omitting seemingly pointless JUMPs), to avoid situations like
63030 * test-bug-case-fallthrough.js.
63031 */
63032
63033 num_stmts = 0;
63034 if (pc_default == -2) {
63035 pc_default = duk__get_current_pc(comp_ctx);
63036 }
63037
63038 /* Note: this is correct even for default clause statements:
63039 * they participate in 'fall-through' behavior even if the
63040 * default clause is in the middle.
63041 */
63042 duk__patch_jump_here(comp_ctx, pc_prevstmt); /* chain jumps for 'fall-through'
63043 * after a case matches.
63044 */
63045
63046 for (;;) {
63047 tok = comp_ctx->curr_token.t;
63048 if (tok == DUK_TOK_CASE || tok == DUK_TOK_DEFAULT ||
63049 tok == DUK_TOK_RCURLY) {
63050 break;
63051 }
63052 num_stmts++;
63053 duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
63054 }
63055
63056 /* fall-through jump to next code of next case (backpatched) */
63057 pc_prevstmt = duk__emit_jump_empty(comp_ctx);
63058
63059 /* XXX: would be nice to omit this jump when the jump is not
63060 * reachable, at least in the obvious cases (such as the case
63061 * ending with a 'break'.
63062 *
63063 * Perhaps duk__parse_stmt() could provide some info on whether
63064 * the statement is a "dead end"?
63065 *
63066 * If implemented, just set pc_prevstmt to -1 when not needed.
63067 */
63068 }
63069
63070 DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RCURLY);
63071 duk__advance(comp_ctx);
63072
63073 /* default case control flow patchup; note that if pc_prevcase < 0
63074 * (i.e. no case clauses), control enters default case automatically.
63075 */
63076 if (pc_default >= 0) {
63077 /* default case exists: go there if no case matches */
63078 duk__patch_jump(comp_ctx, pc_prevcase, pc_default);
63079 } else {
63080 /* default case does not exist, or no statements present
63081 * after default case: finish case evaluation
63082 */
63083 duk__patch_jump_here(comp_ctx, pc_prevcase);
63084 }
63085
63086 /* fall-through control flow patchup; note that pc_prevstmt may be
63087 * < 0 (i.e. no case clauses), in which case this is a no-op.
#define DUK_TOK_DEFAULT
#define DUK_TOK_CASE
#define DUK_STR_INVALID_FOR
DUK_LOCAL_DECL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site)

◆ duk__parse_throw_stmt()

DUK_LOCAL_DECL void duk__parse_throw_stmt ( duk_compiler_ctx * comp_ctx,
duk_ivalue * res )

Definition at line 63351 of file duktape-1.5.2/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 63368 of file duktape-1.5.2/src/duktape.c.

63368 {
63369 duk_reg_t reg_val;
63370
63371 duk__advance(comp_ctx); /* eat 'throw' */
63372
63373 /* Unlike break/continue, throw statement does not allow an empty value. */
63374
63375 if (comp_ctx->curr_token.lineterm) {
63377 }
63378
63379 reg_val = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
63380 duk__emit_extraop_bc(comp_ctx,
63382 (duk_regconst_t) reg_val);
63383}
63384
63386 duk_hthread *thr = comp_ctx->thr;
63387 duk_context *ctx = (duk_context *) thr;
63388 duk_reg_t reg_catch; /* reg_catch+0 and reg_catch+1 are reserved for TRYCATCH */
63389 duk_regconst_t rc_varname = 0;
63390 duk_small_uint_t trycatch_flags = 0;
63391 duk_int_t pc_ldconst = -1;
63392 duk_int_t pc_trycatch = -1;
63393 duk_int_t pc_catch = -1;
63394 duk_int_t pc_finally = -1;
63395
63396 DUK_UNREF(res);
63397
63398 /*
63399 * See the following documentation for discussion:
63400 *
63401 * doc/execution.rst: control flow details
63402 *
63403 * Try, catch, and finally "parts" are Blocks, not Statements, so
63404 * they must always be delimited by curly braces. This is unlike e.g.
63405 * the if statement, which accepts any Statement. This eliminates any
63406 * questions of matching parts of nested try statements. The Block
63407 * parsing is implemented inline here (instead of calling out).
63408 *
63409 * Finally part has a 'let scoped' variable, which requires a few kinks
63410 * here.
63411 */
63412
63413 comp_ctx->curr_func.catch_depth++;
63414
63415 duk__advance(comp_ctx); /* eat 'try' */
63416
63417 reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2);
63418
63419 /* The target for this LDCONST may need output shuffling, but we assume
63420 * that 'pc_ldconst' will be the LDCONST that we can patch later. This
63421 * should be the case because there's no input shuffling. (If there's
63422 * no catch clause, this LDCONST will be replaced with a NOP.)
63423 */
63424 pc_ldconst = duk__get_current_pc(comp_ctx);
63425 duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, reg_catch, 0 /*patched later*/);
63426
63427 pc_trycatch = duk__get_current_pc(comp_ctx);
63428 duk__emit_invalid(comp_ctx); /* TRYCATCH, cannot emit now (not enough info) */
63429 duk__emit_invalid(comp_ctx); /* jump for 'catch' case */
63430 duk__emit_invalid(comp_ctx); /* jump for 'finally' case or end (if no finally) */
63431
63432 /* try part */
63434 duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
63435 /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
63436 duk__emit_extraop_only(comp_ctx,
63438
63439 if (comp_ctx->curr_token.t == DUK_TOK_CATCH) {
63440 /*
63441 * The catch variable must be updated to reflect the new allocated
63442 * register for the duration of the catch clause. We need to store
63443 * and restore the original value for the varmap entry (if any).
63444 */
63445
63446 /*
63447 * Note: currently register bindings must be fixed for the entire
63448 * function. So, even though the catch variable is in a register
63449 * we know, we must use an explicit environment record and slow path
63450 * accesses to read/write the catch binding to make closures created
63451 * within the catch clause work correctly. This restriction should
63452 * be fixable (at least in common cases) later.
63453 *
63454 * See: test-bug-catch-binding-2.js.
63455 *
63456 * XXX: improve to get fast path access to most catch clauses.
63457 */
63458
63459 duk_hstring *h_var;
63460 duk_int_t varmap_value; /* for storing/restoring the varmap binding for catch variable */
63461
63462 DUK_DDD(DUK_DDDPRINT("stack top at start of catch clause: %ld", (long) duk_get_top(ctx)));
63463
63464 trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_CATCH;
63465
63466 pc_catch = duk__get_current_pc(comp_ctx);
63467
63468 duk__advance(comp_ctx);
63470
63471 if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
63472 /* Identifier, i.e. don't allow reserved words */
63473 goto syntax_error;
63474 }
63475 h_var = comp_ctx->curr_token.str1;
63476 DUK_ASSERT(h_var != NULL);
63477
63478 duk_push_hstring(ctx, h_var); /* keep in on valstack, use borrowed ref below */
63479
63480 if (comp_ctx->curr_func.is_strict &&
63481 ((h_var == DUK_HTHREAD_STRING_EVAL(thr)) ||
63482 (h_var == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)))) {
63483 DUK_DDD(DUK_DDDPRINT("catch identifier 'eval' or 'arguments' in strict mode -> SyntaxError"));
63484 goto syntax_error;
63485 }
63486
63487 duk_dup_top(ctx);
63488 rc_varname = duk__getconst(comp_ctx);
63489 DUK_DDD(DUK_DDDPRINT("catch clause, rc_varname=0x%08lx (%ld)",
63490 (unsigned long) rc_varname, (long) rc_varname));
63491
63492 duk__advance(comp_ctx);
63494
63496
63497 DUK_DDD(DUK_DDDPRINT("varmap before modifying for catch clause: %!iT",
63498 (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
63499
63500 duk_dup_top(ctx);
63501 duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
63502 if (duk_is_undefined(ctx, -1)) {
63503 varmap_value = -2;
63504 } else if (duk_is_null(ctx, -1)) {
63505 varmap_value = -1;
63506 } else {
63507 DUK_ASSERT(duk_is_number(ctx, -1));
63508 varmap_value = duk_get_int(ctx, -1);
63509 DUK_ASSERT(varmap_value >= 0);
63510 }
63511 duk_pop(ctx);
63512
63513#if 0
63514 /* It'd be nice to do something like this - but it doesn't
63515 * work for closures created inside the catch clause.
63516 */
63517 duk_dup_top(ctx);
63518 duk_push_int(ctx, (duk_int_t) (reg_catch + 0));
63519 duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
63520#endif
63521 duk_dup_top(ctx);
63522 duk_push_null(ctx);
63523 duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
63524
63525 duk__emit_a_bc(comp_ctx,
63527 (duk_regconst_t) (reg_catch + 0) /*value*/,
63528 rc_varname /*varname*/);
63529
63530 DUK_DDD(DUK_DDDPRINT("varmap before parsing catch clause: %!iT",
63531 (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
63532
63533 duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
63534 /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
63535
63536 if (varmap_value == -2) {
63537 /* not present */
63538 duk_del_prop(ctx, comp_ctx->curr_func.varmap_idx);
63539 } else {
63540 if (varmap_value == -1) {
63541 duk_push_null(ctx);
63542 } else {
63543 DUK_ASSERT(varmap_value >= 0);
63544 duk_push_int(ctx, varmap_value);
63545 }
63546 duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
63547 }
63548 /* varname is popped by above code */
63549
63550 DUK_DDD(DUK_DDDPRINT("varmap after restore catch clause: %!iT",
63551 (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
63552
63553 duk__emit_extraop_only(comp_ctx,
63555
63556 /*
63557 * XXX: for now, indicate that an expensive catch binding
63558 * declarative environment is always needed. If we don't
63559 * need it, we don't need the const_varname either.
63560 */
63561
63562 trycatch_flags |= DUK_BC_TRYCATCH_FLAG_CATCH_BINDING;
63563
63564 DUK_DDD(DUK_DDDPRINT("stack top at end of catch clause: %ld", (long) duk_get_top(ctx)));
63565 }
63566
63567 if (comp_ctx->curr_token.t == DUK_TOK_FINALLY) {
63568 trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY;
63569
63570 pc_finally = duk__get_current_pc(comp_ctx);
63571
63572 duk__advance(comp_ctx);
63573
63575 duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
63576 /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
63577 duk__emit_extraop_b(comp_ctx,
63579 reg_catch); /* rethrow */
63580 }
63581
63582 if (!(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) &&
63583 !(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY)) {
63584 /* must have catch and/or finally */
63585 goto syntax_error;
63586 }
63587
63588 /* If there's no catch block, rc_varname will be 0 and duk__patch_trycatch()
63589 * will replace the LDCONST with a NOP. For any actual constant (including
63590 * constant 0) the DUK__CONST_MARKER flag will be set in rc_varname.
63591 */
63592
63593 duk__patch_trycatch(comp_ctx,
63594 pc_ldconst,
63595 pc_trycatch,
63596 reg_catch,
63597 rc_varname,
63598 trycatch_flags);
63599
63600 if (trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) {
63601 DUK_ASSERT(pc_catch >= 0);
#define DUK_TOK_FINALLY
DUK_LOCAL_DECL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
DUK_EXTERNAL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index)
DUK_LOCAL_DECL void duk__emit_invalid(duk_compiler_ctx *comp_ctx)
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)
#define DUK_TOK_CATCH
DUK_LOCAL_DECL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b)
#define DUK_STR_INVALID_THROW

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 62440 of file duktape-1.5.2/src/duktape.c.

62448 :
62449 *
62450 * If register bound: out_reg_varbind >= 0, out_rc_varname == 0 (ignore)
62451 * If not register bound: out_reg_varbind < 0, out_rc_varname >= 0
62452 *
62453 * These allow the caller to use the variable for further assignment, e.g.
62454 * as is done in 'for-in' parsing.
62455 */
62456
62457DUK_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) {
62458 duk_hthread *thr = comp_ctx->thr;
62459 duk_context *ctx = (duk_context *) thr;
62460 duk_hstring *h_varname;
62461 duk_reg_t reg_varbind;
62462 duk_regconst_t rc_varname;
62463
62464 /* assume 'var' has been eaten */
62465
62466 /* Note: Identifier rejects reserved words */
62467 if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
62468 goto syntax_error;
62469 }
62470 h_varname = comp_ctx->curr_token.str1;
62471
62472 DUK_ASSERT(h_varname != NULL);
62473
62474 /* strict mode restrictions (E5 Section 12.2.1) */
62475 if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
62476 goto syntax_error;
62477 }
62478
62479 /* register declarations in first pass */
62480 if (comp_ctx->curr_func.in_scanning) {
62481 duk_uarridx_t n;
62482 DUK_DDD(DUK_DDDPRINT("register variable declaration %!O in pass 1",
62483 (duk_heaphdr *) h_varname));
62484 n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
62485 duk_push_hstring(ctx, h_varname);
62486 duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n);
62487 duk_push_int(ctx, DUK_DECL_TYPE_VAR + (0 << 8));
62488 duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1);
62489 }
62490
62491 duk_push_hstring(ctx, h_varname); /* push before advancing to keep reachable */
62492
62493 /* register binding lookup is based on varmap (even in first pass) */
62494 duk_dup_top(ctx);
62495 (void) duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname);
62496
62497 duk__advance(comp_ctx); /* eat identifier */
62498
62499 if (comp_ctx->curr_token.t == DUK_TOK_EQUALSIGN) {
62500 duk__advance(comp_ctx);
62501
62502 DUK_DDD(DUK_DDDPRINT("vardecl, assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
62503 (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
62504
62505 duk__exprtop(comp_ctx, res, DUK__BP_COMMA | expr_flags /*rbp_flags*/); /* AssignmentExpression */
62506
62507 if (reg_varbind >= 0) {
62508 duk__ivalue_toforcedreg(comp_ctx, res, reg_varbind);
62509 } else {
62510 duk_reg_t reg_val;
62511 reg_val = duk__ivalue_toreg(comp_ctx, res);
62512 duk__emit_a_bc(comp_ctx,
62514 (duk_regconst_t) reg_val,
62515 rc_varname);
62516 }
static void assignment(LexState *ls, struct LHS_assign *lh, int nvars)

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 62518 of file duktape-1.5.2/src/duktape.c.

62518 {
62519 /* Used for minimal 'const': initializer required. */
62520 goto syntax_error;
62521 }
62522 }
62523
62524 duk_pop(ctx); /* pop varname */
62525
62526 *out_rc_varname = rc_varname;
62527 *out_reg_varbind = reg_varbind;
62528
62529 return;
62530
62531 syntax_error:
62533}
#define 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 63163 of file duktape-1.5.2/src/duktape.c.

63180 {
63181 duk_reg_t temp_reset;
63182 duk_regconst_t rc_cond;
63183 duk_int_t pc_start;
63184 duk_int_t pc_jump_false;
63185
63186 DUK_DDD(DUK_DDDPRINT("begin parsing while statement"));
63187
63188 temp_reset = DUK__GETTEMP(comp_ctx);
63189
63190 duk__advance(comp_ctx); /* eat 'while' */
63191
63193
63194 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 63603 of file duktape-1.5.2/src/duktape.c.

63605 {
63606 DUK_ASSERT(pc_finally >= 0);
63607 duk__patch_jump(comp_ctx, pc_trycatch + 2, pc_finally);
63608 } else {
63609 /* without finally, the second jump slot is used to jump to end of stmt */
63610 duk__patch_jump_here(comp_ctx, pc_trycatch + 2);
63611 }
63612
63613 comp_ctx->curr_func.catch_depth--;
63614 return;
63615
63616 syntax_error:
63618}
63619
63621 duk_int_t pc_trycatch;
63622 duk_int_t pc_finished;
63623 duk_reg_t reg_catch;
63624 duk_small_uint_t trycatch_flags;
63625
63626 if (comp_ctx->curr_func.is_strict) {
63628 }
63629
63630 comp_ctx->curr_func.catch_depth++;
63631
63632 duk__advance(comp_ctx); /* eat 'with' */
63633
63634 reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2);
63635
63637 duk__exprtop_toforcedreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/, reg_catch);
63639
63640 pc_trycatch = duk__get_current_pc(comp_ctx);
63641 trycatch_flags = DUK_BC_TRYCATCH_FLAG_WITH_BINDING;
#define DUK_STR_INVALID_TRY
DUK_LOCAL_DECL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res)
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)
#define DUK_STR_WITH_IN_STRICT_MODE

◆ 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 59079 of file duktape-1.5.2/src/duktape.c.

59084 {
59085 goto fail_bc_limit;
59086 }
59087 return;
59088
59089 fail_bc_limit:
59091}
59092
59093/* Does not assume that jump_pc contains a DUK_OP_JUMP previously; this is intentional
59094 * to allow e.g. an INVALID opcode be overwritten with a JUMP (label management uses this).
59095 */
59096DUK_LOCAL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc) {
59097 duk_compiler_instr *instr;
59098 duk_int_t offset;
59099
59100 /* allow negative PCs, behave as a no-op */
59101 if (jump_pc < 0) {
#define DUK_STR_BYTECODE_LIMIT

◆ 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 59103 of file duktape-1.5.2/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 59107 of file duktape-1.5.2/src/duktape.c.

59116 : jump_pc=%ld, target_pc=%ld, offset=%ld",
59117 (long) jump_pc, (long) target_pc, (long) offset));
59118}
59119
59120DUK_LOCAL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
59121 duk__patch_jump(comp_ctx, jump_pc, duk__get_current_pc(comp_ctx));
59122}
59123
59124DUK_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) {
59125 duk_compiler_instr *instr;
59126
59127 DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0);
59128
59129 instr = duk__get_instr_ptr(comp_ctx, ldconst_pc);
59130 DUK_ASSERT(DUK_DEC_OP(instr->ins) == DUK_OP_LDCONST);
59131 DUK_ASSERT(instr != NULL);
59132 if (const_varname & DUK__CONST_MARKER) {
59133 /* Have a catch variable. */
59134 const_varname = const_varname & (~DUK__CONST_MARKER);
59135 if (reg_catch > DUK_BC_BC_MAX || const_varname > DUK_BC_BC_MAX) {
59136 /* Catch attempts to use out-of-range reg/const. Without this
59137 * check Duktape 0.12.0 could generate invalid code which caused
59138 * an assert failure on execution. This error is triggered e.g.
59139 * for functions with a lot of constants and a try-catch statement.
59140 * Shuffling or opcode semantics change is needed to fix the issue.
59141 * See: test-bug-trycatch-many-constants.js.
59142 */
59143 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 12537 of file duktape-1.5.2/src/duktape.c.

12539 {
12540 /* See comments in duk_pcall(). */
12542 return DUK_EXEC_ERROR; /* unreachable */
12543 }
12544
12545 call_flags = 0; /* respect reclimit, not constructor */
12546
12547 rc = duk_handle_call_protected(thr, /* thread */
12548 nargs, /* num_stack_args */
12549 call_flags); /* call_flags */
12550
12551 return rc;
12552}
12553
12555 duk_idx_t obj_index;
DUK_LOCAL duk_ret_t duk__pcall_prop_raw(duk_context *ctx)
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)

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 59172 of file duktape-1.5.2/src/duktape.c.

59178 {
59180}
59181
59182/*
59183 * Peephole optimizer for finished bytecode.
59184 *
59185 * Does not remove opcodes; currently only straightens out unconditional
59186 * jump chains which are generated by several control structures.
59187 */
59188
59191 duk_small_uint_t iter;
59192 duk_int_t i, n;
59193 duk_int_t count_opt;
59194
59195 bc = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code);
59196#if defined(DUK_USE_BUFLEN16)
59197 /* No need to assert, buffer size maximum is 0xffff. */
59198#else
59199 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 */
59200#endif
59201 n = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr));
59202
59203 for (iter = 0; iter < DUK_COMPILER_PEEPHOLE_MAXITER; iter++) {
59204 count_opt = 0;
59205
59206 for (i = 0; i < n; i++) {
59207 duk_instr_t ins;
59208 duk_int_t target_pc1;
59209 duk_int_t target_pc2;
59210
59211 ins = bc[i].ins;
59212 if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
59213 continue;
59214 }
59215
59216 target_pc1 = i + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;
59217 DUK_DDD(DUK_DDDPRINT("consider jump at pc %ld; target_pc=%ld", (long) i, (long) target_pc1));
59218 DUK_ASSERT(target_pc1 >= 0);
59219 DUK_ASSERT(target_pc1 < n);
59220
59221 /* Note: if target_pc1 == i, we'll optimize a jump to itself.
59222 * This does not need to be checked for explicitly; the case
59223 * is rare and max iter breaks us out.
59224 */
59225
59226 ins = bc[target_pc1].ins;
59227 if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
59228 continue;
59229 }
59230
DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx)
#define DUK_COMPILER_PEEPHOLE_MAXITER

Referenced by duk__parse_func_body().

◆ duk__pnew_helper()

DUK_LOCAL duk_ret_t duk__pnew_helper ( duk_context * ctx)

Definition at line 12794 of file duktape-1.5.2/src/duktape.c.

◆ duk__pow_fixed()

DUK_LOCAL double duk__pow_fixed ( double x,
double y )

Definition at line 32459 of file duktape-1.5.2/src/duktape.c.

32464 {
32465 /* +0.5 is handled by floor, this is on purpose */
32466 if (x < 0.0) {
32467 return -0.0;
32468 } else {
32469 return +0.0;
32470 }
32471 }
32472
32473 return DUK_FLOOR(x + 0.5);
32474}
32475
32476DUK_LOCAL double duk__pow_fixed(double x, double y) {
32477 /* The ANSI C pow() semantics differ from Ecmascript.
32478 *
32479 * E.g. when x==1 and y is +/- infinite, the Ecmascript required
32480 * result is NaN, while at least Linux pow() returns 1.
32481 */
32482
32483 duk_small_int_t cx, cy, sx;
32484
32485 DUK_UNREF(cx);
32486 DUK_UNREF(sx);
32488
32489 if (cy == DUK_FP_NAN) {
32490 goto ret_nan;
32491 }
32492 if (DUK_FABS(x) == 1.0 && cy == DUK_FP_INFINITE) {
32493 goto ret_nan;
32494 }
32495#if defined(DUK_USE_POW_NETBSD_WORKAROUND)
32496 /* See test-bug-netbsd-math-pow.js: NetBSD 6.0 on x86 (at least) does not
32497 * correctly handle some cases where x=+/-0. Specific fixes to these
32498 * here.
32499 */
32501 if (cx == DUK_FP_ZERO && y < 0.0) {
32502 sx = (duk_small_int_t) DUK_SIGNBIT(x);
32503 if (sx == 0) {
32504 /* Math.pow(+0,y) should be Infinity when y<0. NetBSD pow()
32505 * returns -Infinity instead when y is <0 and finite. The
32506 * if-clause also catches y == -Infinity (which works even
32507 * without the fix).
32508 */
32509 return DUK_DOUBLE_INFINITY;
32510 } else {
32511 /* Math.pow(-0,y) where y<0 should be:
32512 * - -Infinity if y<0 and an odd integer
32513 * - Infinity otherwise
32514 * NetBSD pow() returns -Infinity for all finite y<0. The
32515 * if-clause also catches y == -Infinity (which works even
32516 * without the fix).
32517 */
32518
32519 /* fmod() return value has same sign as input (negative) so
32520 * the result here will be in the range ]-2,0], 1 indicates
32521 * odd. If x is -Infinity, NaN is returned and the odd check
DUK_LOCAL double duk__pow_fixed(double x, double y)

◆ 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 12942 of file duktape-1.5.2/src/duktape.c.

◆ duk__protected_compact_object()

DUK_LOCAL int duk__protected_compact_object ( duk_context * ctx)

Definition at line 42893 of file duktape-1.5.2/src/duktape.c.

42900 : %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 47564 of file duktape-1.5.2/src/duktape.c.

47566 {
47567 if (duk_hobject_proxy_check(thr, obj, &h_target, &h_handler)) {
47568 DUK_ASSERT(h_target != NULL);
47569 obj = h_target;
47570 } else {
47571 break;
47572 }
47573 }
47574
47575 DUK_ASSERT(obj != NULL);
47576 return obj;
47577}
47578#endif /* DUK_USE_ES6_PROXY */
47579
47580#if defined(DUK_USE_ES6_PROXY)
47582 duk_context *ctx = (duk_context *) thr;
47583 duk_hobject *h_handler;
47584
47585 DUK_ASSERT(thr != NULL);
47586 DUK_ASSERT(obj != NULL);
47587 DUK_ASSERT(tv_key != NULL);
47588 DUK_ASSERT(out_target != NULL);
47589
47590 if (!duk_hobject_proxy_check(thr, obj, out_target, &h_handler)) {
47591 return 0;
47592 }
47593 DUK_ASSERT(*out_target != NULL);
47594 DUK_ASSERT(h_handler != NULL);
47595
47596 /* XXX: At the moment Duktape accesses internal keys like _Finalizer using a
47597 * normal property set/get which would allow a proxy handler to interfere with
47598 * such behavior and to get access to internal key strings. This is not a problem
47599 * as such because internal key strings can be created in other ways too (e.g.
47600 * through buffers). The best fix is to change Duktape internal lookups to
47601 * skip proxy behavior. Until that, internal property accesses bypass the
47602 * proxy and are applied to the target (as if the handler did not exist).
47603 * This has some side effects, see test-bi-proxy-internal-keys.js.
47604 */
47605
47606 if (DUK_TVAL_IS_STRING(tv_key)) {
47607 duk_hstring *h_key = (duk_hstring *) DUK_TVAL_GET_STRING(tv_key);
47608 DUK_ASSERT(h_key != NULL);
47609 if (DUK_HSTRING_HAS_INTERNAL(h_key)) {
47610 DUK_DDD(DUK_DDDPRINT("internal key, skip proxy handler and apply to target"));
47611 return 0;
47612 }
47613 }
47614
47615 /* The handler is looked up with a normal property lookup; it may be an
47616 * accessor or the handler object itself may be a proxy object. If the
47617 * handler is a proxy, we need to extend the valstack as we make a
47618 * recursive proxy check without a function call in between (in fact
47619 * there is no limit to the potential recursion here).
47620 *
47621 * (For sanity, proxy creation rejects another proxy object as either
47622 * the handler or the target at the moment so recursive proxy cases
47623 * are not realized now.)
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_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)

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 21721 of file duktape-1.5.2/src/duktape.c.

21738 {
21739 duk_hbuffer *h_val;
21740 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 18654 of file duktape-1.5.2/src/duktape.c.

18657 : 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
18658
18659 tv_slot = thr->valstack_top;
18660 DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
18661 DUK_HOBJECT_INCREF(thr, obj);
18662 ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
18663 thr->valstack_top++;
18664
18665 /* default prototype (Note: 'obj' must be reachable) */
18666 DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
18667
18668 return ret;
18669}
18670
18671DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags) {
18672 duk_hthread *thr = (duk_hthread *) ctx;
18673 duk_hnativefunction *obj;
18674 duk_idx_t ret;
18675 duk_tval *tv_slot;
18676 duk_int16_t func_nargs;
18677
18678 DUK_ASSERT_CTX_VALID(ctx);
18679
18680 /* check stack first */
18681 if (thr->valstack_top >= thr->valstack_end) {
18682 DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
18683 }
18684 if (func == NULL) {
18685 goto api_error;
18686 }
18687 if (nargs >= 0 && nargs < DUK_HNATIVEFUNCTION_NARGS_MAX) {
18688 func_nargs = (duk_int16_t) nargs;
18689 } else if (nargs == DUK_VARARGS) {
18690 func_nargs = DUK_HNATIVEFUNCTION_NARGS_VARARGS;
18691 } else {
18692 goto api_error;
18693 }
18694
18695 obj = duk_hnativefunction_alloc(thr->heap, flags);
18696 if (!obj) {
18697 DUK_ERROR_ALLOC_DEFMSG(thr);
18698 }
18699
18700 obj->func = func;
18701 obj->nargs = func_nargs;
18702
18703 DUK_DDD(DUK_DDDPRINT("created native function object with flags: 0x%08lx, nargs=%ld",
static union @102 native

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 53509 of file duktape-1.5.2/src/duktape.c.

53514 {
53515 *p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
53516 }
53517 duk_to_string(ctx, -1);
53518}
53520 if (duk_bd_decode_flag(bd)) {
53521 duk__push_string(ctx, bd);
DUK_LOCAL void duk__push_string(duk_context *ctx, duk_bitdecoder_ctx *bd)
#define DUK__STRING_CHAR_BITS
DUK_LOCAL void duk__push_stridx_or_string(duk_context *ctx, duk_bitdecoder_ctx *bd)
DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx)

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 19479 of file duktape-1.5.2/src/duktape.c.

19496 {
19497 duk_hthread *thr;
19498 const duk_uint8_t *p, *p_start, *p_end;
19500 2 /*quotes*/ + 3 /*periods*/];
19501 duk_uint8_t *q;
19503 duk_small_uint_t nchars;
19504
19506 DUK_ASSERT(h_input != NULL);
19507 thr = (duk_hthread *) ctx;
19508
19509 p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
19510 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
19511 p = p_start;
19512 q = buf;
19513
19514 nchars = 0;
19515 *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE;
19516 for (;;) {
19517 if (p >= p_end) {
19518 break;
19519 }
19520 if (nchars == DUK__READABLE_STRING_MAXCHARS) {
19521 *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
19522 *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
19523 *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
19524 break;
19525 }
19526 if (duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) {
19527 if (cp < 0x20 || cp == 0x7f || cp == DUK_ASC_SINGLEQUOTE || cp == DUK_ASC_BACKSLASH) {
19528 DUK_ASSERT(DUK_UNICODE_MAX_XUTF8_LENGTH >= 4); /* estimate is valid */
19529 DUK_ASSERT((cp >> 4) <= 0x0f);
#define DUK_ASC_SINGLEQUOTE
#define DUK__READABLE_STRING_MAXCHARS

◆ duk__push_stash()

DUK_LOCAL void duk__push_stash ( duk_context * ctx)

Definition at line 18312 of file duktape-1.5.2/src/duktape.c.

18315 {
18316 duk_push_hobject(ctx, (duk_hobject *) thr->heap->curr_thread);
18317 } else {
18318 duk_push_undefined(ctx);
18319 }
18320}
18321
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 53482 of file duktape-1.5.2/src/duktape.c.

53482 {
53483 duk_hobject *h;
53484 h = (duk_hobject *) DUK_LOSE_CONST(duk_rom_builtins_bidx[i]);
53485 DUK_ASSERT(h != NULL);
53486 thr->builtins[i] = h;
53487 }
53488
53489#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 53502 of file duktape-1.5.2/src/duktape.c.

53507 {

◆ duk__push_string()

DUK_LOCAL void duk__push_string ( duk_context * ctx,
duk_bitdecoder_ctx * bd )

Definition at line 53490 of file duktape-1.5.2/src/duktape.c.

53499 {
53501

◆ 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 25335 of file duktape-1.5.2/src/duktape.c.

25337 {

◆ 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 25293 of file duktape-1.5.2/src/duktape.c.

25310 {
25311 duk_hthread *thr = (duk_hthread *) ctx;
25312 duk_hobject *h;
25313 duk_double_t d;
25314 duk_int_t tzoffset = 0;
25315
25316 duk_push_this(ctx);
25317 h = duk_get_hobject(ctx, -1); /* XXX: getter with class check, useful in built-ins */
25319 DUK_ERROR_TYPE(thr, "expected Date");
25320 }
25321
25323 d = duk_to_number(ctx, -1);
25324 duk_pop(ctx);
25325
25326 if (DUK_ISNAN(d)) {
25327 if (flags & DUK_DATE_FLAG_NAN_TO_ZERO) {
25328 d = 0.0;
25329 }
25331 DUK_ERROR_RANGE(thr, "Invalid Date");
25332 }
25333 }
#define DUK_DATE_FLAG_NAN_TO_RANGE_ERROR
#define DUK_DATE_FLAG_NAN_TO_ZERO
#define DUK_HOBJECT_CLASS_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 18187 of file duktape-1.5.2/src/duktape.c.

18193 {
18194 duk_hthread *thr;
18195 duk_tval *tv_slot;
18196
18198 thr = (duk_hthread *) ctx;
18200 tv_slot = thr->valstack_top++;
18201 DUK_TVAL_SET_POINTER(tv_slot, val);
18202}
18203
18204DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t check_object_coercible) {
18205 duk_hthread *thr;
18206 duk_tval *tv_slot;
18207
18209 DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */
18210 thr = (duk_hthread *) ctx;
18213
18214 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(thr->valstack_top)); /* because of valstack init policy */
18215 tv_slot = thr->valstack_top++;
18216
18217 if (DUK_UNLIKELY(thr->callstack_top == 0)) {
18218 if (check_object_coercible) {
18219 goto type_error;
18220 }
18221 /* 'undefined' already on stack top */
18222 } else {
18223 duk_tval *tv;
18224
DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t check_object_coercible)
#define DUK_TVAL_SET_POINTER(tv, hptr)
#define DUK__CHECK_SPACE()

◆ duk__push_this_number_plain()

DUK_LOCAL duk_double_t duk__push_this_number_plain ( duk_context * ctx)

Definition at line 32685 of file duktape-1.5.2/src/duktape.c.

32689 {
32690 DUK_UNREF(ctx);
32692}
32693
32694#endif /* DUK_USE_MATH_BUILTIN */
32695#line 1 "duk_bi_number.c"
32696/*
32697 * Number built-ins
32698 */
32699
32700/* include removed: duk_internal.h */
32701
32703 duk_hobject *h;
32704
32705 /* Number built-in accepts a plain number or a Number object (whose
32706 * internal value is operated on). Other types cause TypeError.
32707 */
32708
32709 duk_push_this(ctx);
32710 if (duk_is_number(ctx, -1)) {
32711 DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
#define DUK_RET_UNIMPLEMENTED_ERROR
DUK_LOCAL duk_double_t duk__push_this_number_plain(duk_context *ctx)

◆ duk__push_this_obj_len_u32()

DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32 ( duk_context * ctx)

Definition at line 20060 of file duktape-1.5.2/src/duktape.c.

20062 : even Duktape code internally
20063 * assumes that an Array instance will always have a 'length' property.
20064 * Preventing deletion of the property is critical.
20065 */
20066
20067/* include removed: duk_internal.h */
20068
20069/* 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 20071 of file duktape-1.5.2/src/duktape.c.

20077 {
20078 duk_uint32_t len;
20079
DUK_INTERNAL_DECL duk_hobject * duk_push_this_coercible_to_object(duk_context *ctx)

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 47314 of file duktape-1.5.2/src/duktape.c.

47316 {
47317 /* Catches >0x100000000 and negative values. */
47318 return DUK__NO_ARRAY_INDEX;
47319 }
47320
47321 /* If the value happens to be 0xFFFFFFFF, it's not a valid array index
47322 * but will then match DUK__NO_ARRAY_INDEX.
47323 */
47324 return (duk_uint32_t) t;
47325}
47326#endif /* DUK_USE_FASTINT */
47327
47328/* Push an arbitrary duk_tval to the stack, coerce it to string, and return
47329 * both a duk_hstring pointer and an array index (or DUK__NO_ARRAY_INDEX).
47330 */

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 14402 of file duktape-1.5.2/src/duktape.c.

14402 {
14403 duk_bool_t rc;
14404
14406 DUK_ASSERT_DISABLE(stridx >= 0);
14408
14409 rc = duk_get_prop_stridx(ctx, obj_index, stridx);
14410 if (out_has_prop) {
14411 *out_has_prop = rc;
14412 }
14413 rc = duk_to_boolean(ctx, -1);
14414 DUK_ASSERT(rc == 0 || rc == 1);
14415 duk_pop(ctx);
14416 return rc;
14417}
14418
14420 duk_hthread *thr = (duk_hthread *) ctx;
14421 duk_tval *tv_obj;
14422 duk_tval *tv_key;
14423 duk_tval *tv_val;
14424 duk_small_int_t throw_flag;
14425 duk_bool_t rc;
14426
14427 /* Note: copying tv_obj and tv_key to locals to shield against a valstack
14428 * resize is not necessary for a property put right now (putprop protects
14429 * against it internally).
14430 */
DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index)
DUK_LOCAL duk_bool_t duk__put_prop_shared(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t idx_key)

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 49324 of file duktape-1.5.2/src/duktape.c.

49330 {
49331 data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
49332 duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size);
49333 } else {
49334 DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)"));
49335 duk_push_uint(ctx, 0);
49336 }
49337
49338 return 1;
49339}
49340
49342 duk_context *ctx;
49343 duk_uint32_t idx;
49344 duk_hbufferobject *h_bufobj;
49345 duk_uint_t byte_off;
49346 duk_small_uint_t elem_size;
49347 duk_uint8_t *data;
49348
49349 ctx = (duk_context *) thr;
49350
49351 if (!(DUK_HOBJECT_IS_BUFFEROBJECT(obj) &&
49352 DUK_TVAL_IS_NUMBER(tv_val))) {
49353 return 0;
49354 }
49355 DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj)); /* caller ensures; rom objects are never bufferobjects now */
49356
49357 h_bufobj = (duk_hbufferobject *) obj;
49358#if defined(DUK_USE_FASTINT)
49359 if (DUK_TVAL_IS_FASTINT(tv_key)) {
49360 idx = duk__tval_fastint_to_arr_idx(tv_key);
49361 } else
49362#endif
49363 if (DUK_TVAL_IS_DOUBLE(tv_key)) {
49364 idx = duk__tval_number_to_arr_idx(tv_key);
49365 } else {
49366 return 0;
49367 }
49368
49369 /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
49370 * is 0xffffffffUL. We don't need to check for that explicitly
49371 * because 0xffffffffUL will never be inside bufferobject length.
49372 */
49373
49374 /* Careful with wrapping (left shifting idx would be unsafe). */
49375 if (idx >= (h_bufobj->length >> h_bufobj->shift)) {
49376 return 0;
49377 }
49379
49380 byte_off = idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */
49381 elem_size = 1 << h_bufobj->shift;
DUK_LOCAL duk_bool_t duk__putprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val)

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 49207 of file duktape-1.5.2/src/duktape.c.

49215 {
49216 DUK_DDD(DUK_DDDPRINT("-> fast path successful"));
49217 return tv;
49218 }
49219
49220 DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path"));
49221 return NULL;
49222}
49223
49225 duk_tval *tv;
49226 duk_uint32_t idx;
49227 duk_uint32_t old_len, new_len;
49228
49229 if (!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj) &&
49232 return 0;
49233 }
49234 DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj)); /* caller ensures */
49235
49236#if defined(DUK_USE_FASTINT)
49237 if (DUK_TVAL_IS_FASTINT(tv_key)) {
49238 idx = duk__tval_fastint_to_arr_idx(tv_key);
49239 } else
49240#endif
49241 if (DUK_TVAL_IS_DOUBLE(tv_key)) {
49242 idx = duk__tval_number_to_arr_idx(tv_key);
49243 } else {
49244 DUK_DDD(DUK_DDDPRINT("key is not a number"));
49245 return 0;
49246 }
49247
49248 /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which
49249 * is 0xffffffffUL. We don't need to check for that explicitly
49250 * because 0xffffffffUL will never be inside object 'a_size'.
49251 */
49252
49253 if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) { /* for resizing of array part, use slow path */
49254 return 0;
49255 }
49256 DUK_ASSERT(idx != 0xffffffffUL);
49258
49259 old_len = duk__get_old_array_length(thr, obj, temp_desc);
49260
49261 if (idx >= old_len) {
49262 DUK_DDD(DUK_DDDPRINT("write new array entry requires length update "
49263 "(arr_idx=%ld, old_len=%ld)",
49264 (long) idx, (long) old_len));
49265 if (!(temp_desc->flags & DUK_PROPDESC_FLAG_WRITABLE)) {
49267 return 0; /* not reachable */
#define DUK_STR_NOT_WRITABLE
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)
#define DUK_HOBJECT_HAS_EXTENSIBLE(h)
DUK_LOCAL duk_uint32_t duk__get_old_array_length(duk_hthread *thr, duk_hobject *obj, duk_propdesc *temp_desc)

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 72516 of file duktape-1.5.2/src/duktape.c.

72538 {
72540 duk_tval tv_tmp_obj;
72541 duk_tval tv_tmp_key;
72542 duk_bool_t parents;
72543
72544 DUK_DDD(DUK_DDDPRINT("putvar: thr=%p, env=%p, act=%p, name=%!O, val=%p, strict=%ld "
72545 "(env -> %!dO, val -> %!T)",
72546 (void *) thr, (void *) env, (void *) act,
72547 (duk_heaphdr *) name, (void *) val, (long) strict,
72548 (duk_heaphdr *) env, (duk_tval *) val));
72549
72550 DUK_ASSERT(thr != NULL);
72551 DUK_ASSERT(name != NULL);
72552 DUK_ASSERT(val != NULL);
72553 /* env and act may be NULL */
72554
72558
72559 /*
72560 * In strict mode E5 protects 'eval' and 'arguments' from being
72561 * assigned to (or even declared anywhere). Attempt to do so
72562 * should result in a compile time SyntaxError. See the internal
72563 * design documentation for details.
72564 *
72565 * Thus, we should never come here, run-time, for strict code,
72566 * and name 'eval' or 'arguments'.
72567 */
72568
72569 DUK_ASSERT(!strict ||
72570 (name != DUK_HTHREAD_STRING_EVAL(thr) &&
72572
72573 /*
72574 * Lookup variable and update in-place if found.
72575 */
72576
72577 parents = 1; /* follow parent chain */
72578
72579 if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
72580 if (ref.value && (ref.attrs & DUK_PROPDESC_FLAG_WRITABLE)) {
72581 /* Update duk_tval in-place if pointer provided and the
72582 * property is writable. If the property is not writable
72583 * (immutable binding), use duk_hobject_putprop() which
72584 * will respect mutability.
72585 */
72586 duk_tval *tv_val;
72587
72588 DUK_ASSERT(ref.this_binding == NULL); /* always for register bindings */
72589
72590 tv_val = ref.value;
72591 DUK_ASSERT(tv_val != NULL);
72592 DUK_TVAL_SET_TVAL_UPDREF(thr, tv_val, val); /* side effects */
72593
72594 /* ref.value and ref.this_binding invalidated here */
72595 } else {
72596 DUK_ASSERT(ref.holder != NULL);
72597
72598 DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder);
72599 DUK_TVAL_SET_STRING(&tv_tmp_key, name);
72600 (void) duk_hobject_putprop(thr, &tv_tmp_obj, &tv_tmp_key, val, strict);
72601
72602 /* ref.value and ref.this_binding invalidated here */
72603 }
72604
72605 return;
72606 }
72607
72608 /*
72609 * Not found: write to global object (non-strict) or ReferenceError
72610 * (strict); see E5 Section 8.7.2, step 3.
#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv)

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 43857 of file duktape-1.5.2/src/duktape.c.

43874 {
43875 /* tail insert: don't disturb head in case refzero is running */
43876
43877 if (heap->refzero_list != NULL) {
43878 duk_heaphdr *hdr_prev;
43879
43880 hdr_prev = heap->refzero_list_tail;
43881 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 47659 of file duktape-1.5.2/src/duktape.c.

47666 : a non-checked variant would be nice but is a bit tricky to
47667 * implement for the array abandonment process. It's easy for
47668 * everything else.
47669 *
47670 * Note: because we need to potentially resize the valstack (as part
47671 * of abandoning the array part), any tval pointers to the valstack
47672 * will become invalid after this call.
47673 */
47674
47675DUK_LOCAL
47676void duk__realloc_props(duk_hthread *thr,
47677 duk_hobject *obj,
47678 duk_uint32_t new_e_size,
47679 duk_uint32_t new_a_size,
47680 duk_uint32_t new_h_size,
47681 duk_bool_t abandon_array) {
47682 duk_context *ctx = (duk_context *) thr;
47683#ifdef DUK_USE_MARK_AND_SWEEP
47684 duk_small_uint_t prev_mark_and_sweep_base_flags;
47685#endif
47686 duk_uint32_t new_alloc_size;
47687 duk_uint32_t new_e_size_adjusted;
47688 duk_uint8_t *new_p;
47689 duk_hstring **new_e_k;
47690 duk_propvalue *new_e_pv;
47691 duk_uint8_t *new_e_f;
47692 duk_tval *new_a;
47693 duk_uint32_t *new_h;
47694 duk_uint32_t new_e_next;
47695 duk_uint_fast32_t i;
47696
47697 DUK_ASSERT(thr != NULL);
47698 DUK_ASSERT(ctx != NULL);
47699 DUK_ASSERT(obj != NULL);
47700 DUK_ASSERT(!abandon_array || new_a_size == 0); /* if abandon_array, new_a_size must be 0 */
47701 DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL || (DUK_HOBJECT_GET_ESIZE(obj) == 0 && DUK_HOBJECT_GET_ASIZE(obj) == 0));
47702 DUK_ASSERT(new_h_size == 0 || new_h_size >= new_e_size); /* required to guarantee success of rehashing,
47703 * intentionally use unadjusted new_e_size
47704 */
47705 DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));
47706 DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
47707
47708 /*
47709 * Pre resize assertions.
47710 */
47711
47712#ifdef DUK_USE_ASSERTIONS
47713 /* XXX: pre-checks (such as no duplicate keys) */
47714#endif
47715
47716 /*
47717 * For property layout 1, tweak e_size to ensure that the whole entry
47718 * part (key + val + flags) is a suitable multiple for alignment
47719 * (platform specific).
47720 *
47721 * Property layout 2 does not require this tweaking and is preferred
47722 * on low RAM platforms requiring alignment.
47723 */
47724
47725#if defined(DUK_USE_HOBJECT_LAYOUT_2) || defined(DUK_USE_HOBJECT_LAYOUT_3)
47726 DUK_DDD(DUK_DDDPRINT("using layout 2 or 3, no need to pad e_size: %ld", (long) new_e_size));
47727 new_e_size_adjusted = new_e_size;
47728#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && (DUK_HOBJECT_ALIGN_TARGET == 1)
47729 DUK_DDD(DUK_DDDPRINT("using layout 1, but no need to pad e_size: %ld", (long) new_e_size));
47730 new_e_size_adjusted = new_e_size;
47731#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && ((DUK_HOBJECT_ALIGN_TARGET == 4) || (DUK_HOBJECT_ALIGN_TARGET == 8))
47732 new_e_size_adjusted = (new_e_size + DUK_HOBJECT_ALIGN_TARGET - 1) & (~(DUK_HOBJECT_ALIGN_TARGET - 1));
47733 DUK_DDD(DUK_DDDPRINT("using layout 1, and alignment target is %ld, adjusted e_size: %ld -> %ld",
47734 (long) DUK_HOBJECT_ALIGN_TARGET, (long) new_e_size, (long) new_e_size_adjusted));
47735 DUK_ASSERT(new_e_size_adjusted >= new_e_size);
47736#else
47737#error invalid hobject layout defines
47738#endif
47739
47740 /*
47741 * Debug logging after adjustment.
47742 */
47743
47744 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 "
47745 "{e_size=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld",
47746 (void *) obj,
47747 (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
47748 DUK_HOBJECT_GET_ASIZE(obj),
47749 DUK_HOBJECT_GET_HSIZE(obj)),
47750 (long) DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size),
47751 (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj),
47752 (long) DUK_HOBJECT_GET_ESIZE(obj),
47753 (long) DUK_HOBJECT_GET_ENEXT(obj),
47754 (long) DUK_HOBJECT_GET_ASIZE(obj),
47755 (long) DUK_HOBJECT_GET_HSIZE(obj),
47756 (long) new_e_size_adjusted,
47757 (long) new_a_size,
47758 (long) new_h_size,
47759 (long) abandon_array,
47760 (long) new_e_size));
47761
47762 /*
47763 * Property count check. This is the only point where we ensure that
47764 * we don't get more (allocated) property space that we can handle.
47765 * There aren't hard limits as such, but some algorithms fail (e.g.
47766 * finding next higher prime, selecting hash part size) if we get too
47767 * close to the 4G property limit.
47768 *
47769 * Since this works based on allocation size (not actually used size),
47770 * the limit is a bit approximate but good enough in practice.
47771 */
47772
47773 if (new_e_size_adjusted + new_a_size > DUK_HOBJECT_MAX_PROPERTIES) {
47774 DUK_ERROR_ALLOC_DEFMSG(thr);
47775 }
47776
47777 /*
47778 * Compute new alloc size and alloc new area.
47779 *
47780 * The new area is allocated as a dynamic buffer and placed into the
47781 * valstack for reachability. The actual buffer is then detached at
47782 * the end.
47783 *
47784 * Note: heap_mark_and_sweep_base_flags are altered here to ensure
47785 * no-one touches this object while we're resizing and rehashing it.
47786 * The flags must be reset on every exit path after it. Finalizers
47787 * and compaction is prevented currently for all objects while it
47788 * would be enough to restrict it only for the current object.
47789 */
47790
47791#ifdef DUK_USE_MARK_AND_SWEEP
47792 prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags;
47794 DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */
47795 DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid attempt to compact the current object */
47796#endif
47797
47798 new_alloc_size = DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size);
47799 DUK_DDD(DUK_DDDPRINT("new hobject allocation size is %ld", (long) new_alloc_size));
47800 if (new_alloc_size == 0) {
47801 /* for zero size, don't push anything on valstack */
47802 DUK_ASSERT(new_e_size_adjusted == 0);
47803 DUK_ASSERT(new_a_size == 0);
47804 DUK_ASSERT(new_h_size == 0);
47805 new_p = NULL;
47806 } else {
47807 /* This may trigger mark-and-sweep with arbitrary side effects,
47808 * including an attempted resize of the object we're resizing,
47809 * executing a finalizer which may add or remove properties of
47810 * the object we're resizing etc.
47811 */
47812
47813 /* Note: buffer is dynamic so that we can 'steal' the actual
47814 * allocation later.
47815 */
47816
47817 new_p = (duk_uint8_t *) duk_push_dynamic_buffer(ctx, new_alloc_size); /* errors out if out of memory */
47818 DUK_ASSERT(new_p != NULL); /* since new_alloc_size > 0 */
47819 }
47820
47821 /* Set up pointers to the new property area: this is hidden behind a macro
47822 * because it is memory layout specific.
47823 */
47824 DUK_HOBJECT_P_SET_REALLOC_PTRS(new_p, new_e_k, new_e_pv, new_e_f, new_a, new_h,
47825 new_e_size_adjusted, new_a_size, new_h_size);
47826 DUK_UNREF(new_h); /* happens when hash part dropped */
47827 new_e_next = 0;
47828
47829 /* if new_p == NULL, all of these pointers are NULL */
47830 DUK_ASSERT((new_p != NULL) ||
47831 (new_e_k == NULL && new_e_pv == NULL && new_e_f == NULL &&
47832 new_a == NULL && new_h == NULL));
47833
47834 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",
47835 (long) new_alloc_size, (void *) new_e_k, (void *) new_e_pv, (void *) new_e_f,
47836 (void *) new_a, (void *) new_h));
47837
47838 /*
47839 * Migrate array to start of entries if requested.
47840 *
47841 * Note: from an enumeration perspective the order of entry keys matters.
47842 * Array keys should appear wherever they appeared before the array abandon
47843 * operation.
47844 */
47845
47846 if (abandon_array) {
47847 /*
47848 * Note: assuming new_a_size == 0, and that entry part contains
47849 * no conflicting keys, refcounts do not need to be adjusted for
47850 * the values, as they remain exactly the same.
47851 *
47852 * The keys, however, need to be interned, incref'd, and be
47853 * reachable for GC. Any intern attempt may trigger a GC and
47854 * claim any non-reachable strings, so every key must be reachable
47855 * at all times.
47856 *
47857 * A longjmp must not occur here, as the new_p allocation would
47858 * be freed without these keys being decref'd, hence the messy
47859 * decref handling if intern fails.
47860 */
47861 DUK_ASSERT(new_a_size == 0);
47862
47863 for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
47864 duk_tval *tv1;
47865 duk_tval *tv2;
47866 duk_hstring *key;
47867
47869
47870 tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
47871 if (DUK_TVAL_IS_UNUSED(tv1)) {
47872 continue;
47873 }
47874
47875 DUK_ASSERT(new_p != NULL && new_e_k != NULL &&
47876 new_e_pv != NULL && new_e_f != NULL);
47877
47878 /*
47879 * Intern key via the valstack to ensure reachability behaves
47880 * properly. We must avoid longjmp's here so use non-checked
47881 * primitives.
47882 *
47883 * Note: duk_check_stack() potentially reallocs the valstack,
47884 * invalidating any duk_tval pointers to valstack. Callers
47885 * must be careful.
47886 */
47887
47888 /* never shrinks; auto-adds DUK_VALSTACK_INTERNAL_EXTRA, which is generous */
47889 if (!duk_check_stack(ctx, 1)) {
47890 goto abandon_error;
47891 }
47893 key = duk_heap_string_intern_u32(thr->heap, i);
47894 if (!key) {
47895 goto abandon_error;
47896 }
47897 duk_push_hstring(ctx, key); /* keep key reachable for GC etc; guaranteed not to fail */
47898
47899 /* key is now reachable in the valstack */
47900
47901 DUK_HSTRING_INCREF(thr, key); /* second incref for the entry reference */
47902 new_e_k[new_e_next] = key;
47903 tv2 = &new_e_pv[new_e_next].v; /* array entries are all plain values */
47904 DUK_TVAL_SET_TVAL(tv2, tv1);
47905 new_e_f[new_e_next] = DUK_PROPDESC_FLAG_WRITABLE |
47908 new_e_next++;
47909
47910 /* Note: new_e_next matches pushed temp key count, and nothing can
47911 * fail above between the push and this point.
47912 */
47913 }
47914
47915 DUK_DDD(DUK_DDDPRINT("abandon array: pop %ld key temps from valstack", (long) new_e_next));
47916 duk_pop_n(ctx, new_e_next);
47917 }
47918
47919 /*
47920 * Copy keys and values in the entry part (compacting them at the same time).
47921 */
47922
47923 for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
47924 duk_hstring *key;
47925
47927
47928 key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
47929 if (!key) {
47930 continue;
47931 }
47932
47933 DUK_ASSERT(new_p != NULL && new_e_k != NULL &&
47934 new_e_pv != NULL && new_e_f != NULL);
47935
47936 new_e_k[new_e_next] = key;
47937 new_e_pv[new_e_next] = DUK_HOBJECT_E_GET_VALUE(thr->heap, obj, i);
47938 new_e_f[new_e_next] = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i);
47939 new_e_next++;
47940 }
47941 /* the entries [new_e_next, new_e_size_adjusted[ are left uninitialized on purpose (ok, not gc reachable) */
47942
47943 /*
47944 * Copy array elements to new array part.
47945 */
47946
47947 if (new_a_size > DUK_HOBJECT_GET_ASIZE(obj)) {
47948 /* copy existing entries as is */
47949 DUK_ASSERT(new_p != NULL && new_a != NULL);
47950 if (DUK_HOBJECT_GET_ASIZE(obj) > 0) {
47951 /* Avoid zero copy with an invalid pointer. If obj->p is NULL,
47952 * the 'new_a' pointer will be invalid which is not allowed even
47953 * when copy size is zero.
47954 */
47957 DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * DUK_HOBJECT_GET_ASIZE(obj));
47958 }
47959
47960 /* fill new entries with -unused- (required, gc reachable) */
47961 for (i = DUK_HOBJECT_GET_ASIZE(obj); i < new_a_size; i++) {
47962 duk_tval *tv = &new_a[i];
47964 }
47965 } else {
47966#ifdef DUK_USE_ASSERTIONS
47967 /* caller must have decref'd values above new_a_size (if that is necessary) */
47968 if (!abandon_array) {
47969 for (i = new_a_size; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
47970 duk_tval *tv;
47971 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
47972
47973 /* current assertion is quite strong: decref's and set to unused */
47975 }
47976 }
47977#endif
47978 if (new_a_size > 0) {
47979 /* Avoid zero copy with an invalid pointer. If obj->p is NULL,
47980 * the 'new_a' pointer will be invalid which is not allowed even
47981 * when copy size is zero.
47982 */
47984 DUK_ASSERT(new_a_size > 0);
47985 DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * new_a_size);
47986 }
47987 }
47988
47989 /*
47990 * Rebuild the hash part always from scratch (guaranteed to finish).
47991 *
47992 * Any resize of hash part requires rehashing. In addition, by rehashing
47993 * get rid of any elements marked deleted (DUK__HASH_DELETED) which is critical
47994 * to ensuring the hash part never fills up.
47995 */
47996
47997#if defined(DUK_USE_HOBJECT_HASH_PART)
47998 if (DUK_UNLIKELY(new_h_size > 0)) {
47999 DUK_ASSERT(new_h != NULL);
48000
48001 /* fill new_h with u32 0xff = UNUSED */
48003 DUK_ASSERT(new_h_size > 0);
48004 DUK_MEMSET(new_h, 0xff, sizeof(duk_uint32_t) * new_h_size);
48005
48006 DUK_ASSERT(new_e_next <= new_h_size); /* equality not actually possible */
48007 for (i = 0; i < new_e_next; i++) {
48008 duk_hstring *key = new_e_k[i];
48009 duk_uint32_t j, step;
48010
48011 DUK_ASSERT(key != NULL);
48012 j = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size);
48014
48015 for (;;) {
48016 DUK_ASSERT(new_h[j] != DUK__HASH_DELETED); /* should never happen */
48017 if (new_h[j] == DUK__HASH_UNUSED) {
48018 DUK_DDD(DUK_DDDPRINT("rebuild hit %ld -> %ld", (long) j, (long) i));
48019 new_h[j] = i;
48020 break;
48021 }
48022 DUK_DDD(DUK_DDDPRINT("rebuild miss %ld, step %ld", (long) j, (long) step));
48023 j = (j + step) % new_h_size;
48024
48025 /* guaranteed to finish */
48026 DUK_ASSERT(j != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size));
48027 }
48028 }
48029 } else {
48030 DUK_DDD(DUK_DDDPRINT("no hash part, no rehash"));
48031 }
48032#endif /* DUK_USE_HOBJECT_HASH_PART */
48033
48034 /*
48035 * Nice debug log.
48036 */
48037
48038 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 "
48039 "{p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld",
48040 (void *) obj,
48044 (long) new_alloc_size,
48045 (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj),
48046 (long) DUK_HOBJECT_GET_ESIZE(obj),
48047 (long) DUK_HOBJECT_GET_ENEXT(obj),
48048 (long) DUK_HOBJECT_GET_ASIZE(obj),
48049 (long) DUK_HOBJECT_GET_HSIZE(obj),
48050 (void *) new_p,
48051 (long) new_e_size_adjusted,
48052 (long) new_e_next,
48053 (long) new_a_size,
48054 (long) new_h_size,
48055 (long) abandon_array,
48056 (long) new_e_size));
48057
48058 /*
48059 * All done, switch properties ('p') allocation to new one.
48060 */
48061
48062 DUK_FREE(thr->heap, DUK_HOBJECT_GET_PROPS(thr->heap, obj)); /* NULL obj->p is OK */
48063 DUK_HOBJECT_SET_PROPS(thr->heap, obj, new_p);
48064 DUK_HOBJECT_SET_ESIZE(obj, new_e_size_adjusted);
48065 DUK_HOBJECT_SET_ENEXT(obj, new_e_next);
48066 DUK_HOBJECT_SET_ASIZE(obj, new_a_size);
48067 DUK_HOBJECT_SET_HSIZE(obj, new_h_size);
48068
48069 if (new_p) {
48070 /*
48071 * Detach actual buffer from dynamic buffer in valstack, and
48072 * pop it from the stack.
48073 *
48074 * XXX: the buffer object is certainly not reachable at this point,
48075 * so it would be nice to free it forcibly even with only
48076 * mark-and-sweep enabled. Not a big issue though.
48077 */
48078 (void) duk_steal_buffer(ctx, -1, NULL);
48079 duk_pop(ctx);
48080 } else {
48081 DUK_ASSERT(new_alloc_size == 0);
48082 /* no need to pop, nothing was pushed */
48083 }
48084
48085 /* clear array part flag only after switching */
48086 if (abandon_array) {
48088 }
48089
48090 DUK_DDD(DUK_DDDPRINT("resize result: %!O", (duk_heaphdr *) obj));
48091
48092#ifdef DUK_USE_MARK_AND_SWEEP
48093 thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
48094#endif
48095
48096 /*
48097 * Post resize assertions.
48098 */
48099
48100#ifdef DUK_USE_ASSERTIONS
48101 /* XXX: post-checks (such as no duplicate keys) */
48102#endif
48103 return;
48104
48105 /*
48106 * Abandon array failed, need to decref keys already inserted
48107 * into the beginning of new_e_k before unwinding valstack.
48108 */
DUK_EXTERNAL void * duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size)
DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val)
#define DUK_TVAL_SET_UNUSED(tv)
#define DUK_HOBJECT_SET_ESIZE(h, v)
#define DUK_HOBJECT_SET_ENEXT(h, v)
#define DUK_HOBJECT_SET_ASIZE(h, v)
#define DUK_HOBJECT_CLEAR_ARRAY_PART(h)
DUK_EXTERNAL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra)
#define DUK_HOBJECT_SET_HSIZE(h, v)
union duk_tval_struct::@18 v

References DUK__HASH_DELETED, DUK__HASH_INITIAL, DUK__HASH_PROBE_STEP, DUK__HASH_UNUSED, DUK__VALSTACK_SPACE, 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(), duk_pop_n(), DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, duk_push_dynamic_buffer, duk_push_hstring(), duk_steal_buffer(), 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 45534 of file duktape-1.5.2/src/duktape.c.

45534 {
45536 } else {
45538 new_size = duk_util_get_hash_prime(new_size);
45539 }
45540 DUK_ASSERT(new_size > 0);
45541
45542 /* rehash even if old and new sizes are the same to get rid of
45543 * DELETED entries.
45544 */
45545
45546 ret = duk__resize_strtab_raw_probe(heap, new_size);
45547
45548 return ret;
45549}
45550
45551DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe(duk_heap *heap, duk_uint32_t new_used) {
45552 duk_uint32_t new_free;
45553 duk_uint32_t tmp1;
45554 duk_uint32_t tmp2;
#define DUK_STRTAB_HIGHEST_32BIT_PRIME
DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size)
#define DUK_STRTAB_GROW_ST_SIZE(n)

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 65939 of file duktape-1.5.2/src/duktape.c.

65956 {
65957 duk_activation *act;
65958 duk_catcher *cat;
65959 duk_hcompiledfunction *h_func;
65960 duk_idx_t clamp_top;
65961
65962 DUK_ASSERT(thr != NULL);
65963 DUK_ASSERT_DISABLE(act_idx >= 0); /* unsigned */
65964 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL);
65966 DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0); /* unsigned */
65967
65968 act = thr->callstack + act_idx;
65969 cat = thr->catchstack + cat_idx;
65970 h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
65971

◆ duk__reconfig_valstack_ecma_return()

DUK_LOCAL void duk__reconfig_valstack_ecma_return ( duk_hthread * thr,
duk_size_t act_idx )

Definition at line 65903 of file duktape-1.5.2/src/duktape.c.

65904 : should not ordinarily throw errors; if errors
65905 * occur (e.g. due to out-of-memory) they bubble outwards rather than being
65906 * handled recursively.
65907 */
65908
65909#define DUK__LONGJMP_RESTART 0 /* state updated, restart bytecode execution */
65910#define DUK__LONGJMP_RETHROW 1 /* exit bytecode executor by rethrowing an error to caller */
65911
65912#define DUK__RETHAND_RESTART 0 /* state updated, restart bytecode execution */
65913#define DUK__RETHAND_FINISHED 1 /* exit bytecode execution with return value */
65914
65915/* XXX: optimize reconfig valstack operations so that resize, clamp, and setting
65916 * top are combined into one pass.
65917 */
65918
65919/* Reconfigure value stack for return to an Ecmascript function at 'act_idx'. */
65921 duk_activation *act;
65922 duk_hcompiledfunction *h_func;
65923 duk_idx_t clamp_top;
65924
65925 DUK_ASSERT(thr != NULL);
65926 DUK_ASSERT_DISABLE(act_idx >= 0); /* unsigned */
65927 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL);
65929 DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0); /* unsigned */
65930
65931 /* Clamp so that values at 'clamp_top' and above are wiped and won't
65932 * retain reachable garbage. Then extend to 'nregs' because we're
65933 * returning to an Ecmascript function.
65934 */
65935
65936 act = thr->callstack + act_idx;
65937 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 57853 of file duktape-1.5.2/src/duktape.c.

◆ duk__recursion_increase()

DUK_LOCAL void duk__recursion_increase ( duk_compiler_ctx * comp_ctx)

Definition at line 57844 of file duktape-1.5.2/src/duktape.c.

◆ duk__refcount_finalize_hobject()

DUK_LOCAL void duk__refcount_finalize_hobject ( duk_hthread * thr,
duk_hobject * h )

Definition at line 43897 of file duktape-1.5.2/src/duktape.c.

43914 {
43916
43917 DUK_ASSERT(h);
43919
43920 /* XXX: better to get base and walk forwards? */
43921
43922 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
43923 duk_hstring *key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
43924 if (!key) {
43925 continue;
43926 }
43927 duk_heaphdr_decref(thr, (duk_heaphdr *) key);
43928 if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)) {
43931 } else {
43933 }
43934 }
43935
43936 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
43938 }
43939
43940 /* hash part is a 'weak reference' and does not contribute */
43941
43943
43946 duk_tval *tv, *tv_end;
43947 duk_hobject **funcs, **funcs_end;
43948
43949 if (DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f) != NULL) {
43952 while (tv < tv_end) {
43953 duk_tval_decref(thr, tv);
43954 tv++;
43955 }
43956
43958 funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, f);
43959 while (funcs < funcs_end) {
43961 funcs++;
43962 }
43963 } else {
43964 /* May happen in some out-of-memory corner cases. */
43965 DUK_D(DUK_DPRINT("duk_hcompiledfunction 'data' is NULL, skipping decref"));
43966 }
43967
43969 } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
43971 DUK_UNREF(f);
43972 /* nothing to finalize */
43973 } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
43975 if (b->buf) {
43976 duk_heaphdr_decref(thr, (duk_heaphdr *) b->buf);
43977 }
43978 } else if (DUK_HOBJECT_IS_THREAD(h)) {
43979 duk_hthread *t = (duk_hthread *) h;
43980 duk_tval *tv;
43981
43982 tv = t->valstack;
43983 while (tv < t->valstack_top) {
43984 duk_tval_decref(thr, tv);
43985 tv++;
43986 }
43987
43988 for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
43989 duk_activation *act = t->callstack + i;
43993#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h)
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__refzero_free_pending()

DUK_LOCAL void duk__refzero_free_pending ( duk_hthread * thr)

Definition at line 44077 of file duktape-1.5.2/src/duktape.c.

44094 {
44095 duk_heaphdr *h1, *h2;
44096 duk_heap *heap;
44097 duk_int_t count = 0;
44098
44099 DUK_ASSERT(thr != NULL);
44100 DUK_ASSERT(thr->heap != NULL);
44101 heap = thr->heap;
44102 DUK_ASSERT(heap != NULL);
44103
44104 /*
44105 * Detect recursive invocation
44106 */
44107
44109 DUK_DDD(DUK_DDDPRINT("refzero free running, skip run"));
44110 return;
44111 }
44112
44113 /*
44114 * Churn refzero_list until empty
44115 */
44116
44118 while (heap->refzero_list) {
44119 duk_hobject *obj;
44120 duk_bool_t rescued = 0;
44121
44122 /*
44123 * Pick an object from the head (don't remove yet).
44124 */
44125
44126 h1 = heap->refzero_list;
44127 obj = (duk_hobject *) h1;
44128 DUK_DD(DUK_DDPRINT("refzero processing %p: %!O", (void *) h1, (duk_heaphdr *) h1));
44129 DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, h1) == NULL);
44130 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(h1) == DUK_HTYPE_OBJECT); /* currently, always the case */
44131
44132#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE)
44133 /* Torture option to shake out finalizer side effect issues:
44134 * make a bogus function call for every finalizable object,
44135 * essentially simulating the case where everything has a
44136 * finalizer.
44137 */
44138 DUK_DD(DUK_DDPRINT("refzero torture enabled, fake finalizer"));
44140 DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */
44141 duk__refcount_run_torture_finalizer(thr, obj); /* must never longjmp */
44142 DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */
44143 DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */
44144#endif
44145
44146 /*
44147 * Finalizer check.
44148 *
44149 * Note: running a finalizer may have arbitrary side effects, e.g.
44150 * queue more objects on refzero_list (tail), or even trigger a
44151 * mark-and-sweep.
44152 *
44153 * Note: quick reject check should match vast majority of
44154 * objects and must be safe (not throw any errors, ever).
44155 */
44156
44157 /* An object may have FINALIZED here if it was finalized by mark-and-sweep
44158 * on a previous run and refcount then decreased to zero. We won't run the
44159 * finalizer again here.
44160 */
44161
44162 /* A finalizer is looked up from the object and up its prototype chain
44163 * (which allows inherited finalizers).
44164 */
44166 DUK_DDD(DUK_DDDPRINT("object has a finalizer, run it"));
44167
44169 DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */
44170
44171 duk_hobject_run_finalizer(thr, obj); /* must never longjmp */
44172 DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(h1)); /* duk_hobject_run_finalizer() sets */
44173
44174 DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */
44175 DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */
44176
44177 if (DUK_HEAPHDR_GET_REFCOUNT(h1) != 0) {
44178 DUK_DDD(DUK_DDDPRINT("-> object refcount after finalization non-zero, object will be rescued"));
44179 rescued = 1;
44180 } else {
44181 DUK_DDD(DUK_DDDPRINT("-> object refcount still zero after finalization, object will be freed"));
44182 }
44183 }
44184
44185 /* Refzero head is still the same. This is the case even if finalizer
44186 * inserted more refzero objects; they are inserted to the tail.
44187 */
44188 DUK_ASSERT(h1 == heap->refzero_list);
44189
44190 /*
44191 * Remove the object from the refzero list. This cannot be done
44192 * before a possible finalizer has been executed; the finalizer
44193 * may trigger a mark-and-sweep, and mark-and-sweep must be able
44194 * to traverse a complete refzero_list.
44195 */
44196
44197 h2 = DUK_HEAPHDR_GET_NEXT(heap, h1);
44198 if (h2) {
44199 DUK_HEAPHDR_SET_PREV(heap, h2, NULL); /* not strictly necessary */
44200 heap->refzero_list = h2;
44201 } else {
44202 heap->refzero_list = NULL;
44203 heap->refzero_list_tail = NULL;
44204 }
44205
44206 /*
44207 * Rescue or free.
44208 */
44209
44210 if (rescued) {
44211 /* yes -> move back to heap allocated */
44212 DUK_DD(DUK_DDPRINT("object rescued during refcount finalization: %p", (void *) h1));
44216 h2 = heap->heap_allocated;
44217 DUK_HEAPHDR_SET_PREV(heap, h1, NULL);
44218 if (h2) {
44219 DUK_HEAPHDR_SET_PREV(heap, h2, h1);
44220 }
44221 DUK_HEAPHDR_SET_NEXT(heap, h1, h2);
44222 DUK_ASSERT_HEAPHDR_LINKS(heap, h1);
44223 DUK_ASSERT_HEAPHDR_LINKS(heap, h2);
44224 heap->heap_allocated = h1;
44225 } else {
44226 /* no -> decref members, then free */
44228 duk_heap_free_heaphdr_raw(heap, h1);
44229 }
44230
44231 count++;
44232 }
44234
44235 DUK_DDD(DUK_DDDPRINT("refzero processed %ld objects", (long) count));
44236
44237 /*
44238 * Once the whole refzero cascade has been freed, check for
44239 * a voluntary mark-and-sweep.
#define DUK_HEAPHDR_CLEAR_FINALIZED(h)
#define DUK_HEAPHDR_SET_NEXT(heap, h, val)
#define DUK_HEAPHDR_GET_PREV(heap, h)
#define DUK_HEAPHDR_SET_PREV(heap, h, val)
#define DUK_HEAPHDR_PREINC_REFCOUNT(h)
#define DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap)
DUK_LOCAL void duk__refcount_finalize_hobject(duk_hthread *thr, duk_hobject *h)
#define DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)
#define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap)
#define DUK_ASSERT_HEAPHDR_LINKS(heap, h)

◆ duk__regexp_match_helper()

DUK_LOCAL void duk__regexp_match_helper ( duk_hthread * thr,
duk_small_int_t force_global )

Definition at line 79099 of file duktape-1.5.2/src/duktape.c.

79099 :
79100 DUK_ERROR_INTERNAL_DEFMSG(re_ctx->thr);
79101 return NULL; /* never here */
79102}
79103
79104/*
79105 * Exposed matcher function which provides the semantics of RegExp.prototype.exec().
79106 *
79107 * RegExp.prototype.test() has the same semantics as exec() but does not return the
79108 * result object (which contains the matching string and capture groups). Currently
79109 * there is no separate test() helper, so a temporary result object is created and
79110 * discarded if test() is needed. This is intentional, to save code space.
79111 *
79112 * Input stack: [ ... re_obj input ]
79113 * Output stack: [ ... result ]
79114 */
79115
79117 duk_context *ctx = (duk_context *) thr;
79118 duk_re_matcher_ctx re_ctx;
79119 duk_hobject *h_regexp;
79120 duk_hstring *h_bytecode;
79121 duk_hstring *h_input;
79122 duk_uint8_t *p_buf;
79123 const duk_uint8_t *pc;
79124 const duk_uint8_t *sp;
79126 duk_small_int_t global;
79128 double d;
79129 duk_uint32_t char_offset;
79130
79131 DUK_ASSERT(thr != NULL);
79132 DUK_ASSERT(ctx != NULL);
79133
79134 DUK_DD(DUK_DDPRINT("regexp match: regexp=%!T, input=%!T",
79135 (duk_tval *) duk_get_tval(ctx, -2),
79136 (duk_tval *) duk_get_tval(ctx, -1)));
79137
79138 /*
79139 * Regexp instance check, bytecode check, input coercion.
79140 *
79141 * See E5 Section 15.10.6.
79142 */
79143
79144 /* TypeError if wrong; class check, see E5 Section 15.10.6 */
79146 DUK_ASSERT(h_regexp != NULL);
79148 DUK_UNREF(h_regexp);
79149
79150 duk_to_string(ctx, -1);
79151 h_input = duk_get_hstring(ctx, -1);
79152 DUK_ASSERT(h_input != NULL);
79153
79154 duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_BYTECODE); /* [ ... re_obj input ] -> [ ... re_obj input bc ] */
79155 h_bytecode = duk_require_hstring(ctx, -1); /* no regexp instance should exist without a non-configurable bytecode property */
79156 DUK_ASSERT(h_bytecode != NULL);
79157
79158 /*
79159 * Basic context initialization.
79160 *
79161 * Some init values are read from the bytecode header
79162 * whose format is (UTF-8 codepoints):
79163 *
79164 * uint flags
79165 * uint nsaved (even, 2n+2 where n = num captures)
79166 */
79167
79168 /* [ ... re_obj input bc ] */
79169
79170 DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
79171
79172 re_ctx.thr = thr;
79173 re_ctx.input = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
79174 re_ctx.input_end = re_ctx.input + DUK_HSTRING_GET_BYTELEN(h_input);
79175 re_ctx.bytecode = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_bytecode);
79176 re_ctx.bytecode_end = re_ctx.bytecode + DUK_HSTRING_GET_BYTELEN(h_bytecode);
79177 re_ctx.saved = NULL;
79180
79181 /* read header */
79182 pc = re_ctx.bytecode;
79183 re_ctx.re_flags = duk__bc_get_u32(&re_ctx, &pc);
79184 re_ctx.nsaved = duk__bc_get_u32(&re_ctx, &pc);
79185 re_ctx.bytecode = pc;
79186
79187 DUK_ASSERT(DUK_RE_FLAG_GLOBAL < 0x10000UL); /* must fit into duk_small_int_t */
79188 global = (duk_small_int_t) (force_global | (re_ctx.re_flags & DUK_RE_FLAG_GLOBAL));
79189
79190 DUK_ASSERT(re_ctx.nsaved >= 2);
79191 DUK_ASSERT((re_ctx.nsaved % 2) == 0);
79192
79193 p_buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, sizeof(duk_uint8_t *) * re_ctx.nsaved);
79194 DUK_UNREF(p_buf);
79195 re_ctx.saved = (const duk_uint8_t **) duk_get_buffer(ctx, -1, NULL);
79196 DUK_ASSERT(re_ctx.saved != NULL);
79197
79198 /* [ ... re_obj input bc saved_buf ] */
79199
79200#if defined(DUK_USE_EXPLICIT_NULL_INIT)
79201 for (i = 0; i < re_ctx.nsaved; i++) {
79202 re_ctx.saved[i] = (duk_uint8_t *) NULL;
79203 }
79204#elif defined(DUK_USE_ZERO_BUFFER_DATA)
79205 /* buffer is automatically zeroed */
79206#else
79207 DUK_MEMZERO((void *) p_buf, sizeof(duk_uint8_t *) * re_ctx.nsaved);
79208#endif
79209
79210 DUK_DDD(DUK_DDDPRINT("regexp ctx initialized, flags=0x%08lx, nsaved=%ld, recursion_limit=%ld, steps_limit=%ld",
79211 (unsigned long) re_ctx.re_flags, (long) re_ctx.nsaved, (long) re_ctx.recursion_limit,
79212 (long) re_ctx.steps_limit));
79213
79214 /*
79215 * Get starting character offset for match, and initialize 'sp' based on it.
79216 *
79217 * Note: lastIndex is non-configurable so it must be present (we check the
79218 * internal class of the object above, so we know it is). User code can set
79219 * its value to an arbitrary (garbage) value though; E5 requires that lastIndex
79220 * be coerced to a number before using. The code below works even if the
79221 * property is missing: the value will then be coerced to zero.
79222 *
79223 * Note: lastIndex may be outside Uint32 range even after ToInteger() coercion.
79224 * For instance, ToInteger(+Infinity) = +Infinity. We track the match offset
79225 * as an integer, but pre-check it to be inside the 32-bit range before the loop.
79226 * If not, the check in E5 Section 15.10.6.2, step 9.a applies.
79227 */
79228
79229 /* XXX: lastIndex handling produces a lot of asm */
79230
79231 /* [ ... re_obj input bc saved_buf ] */
79232
79233 duk_get_prop_stridx(ctx, -4, DUK_STRIDX_LAST_INDEX); /* -> [ ... re_obj input bc saved_buf lastIndex ] */
79234 (void) duk_to_int(ctx, -1); /* ToInteger(lastIndex) */
79235 d = duk_get_number(ctx, -1); /* integer, but may be +/- Infinite, +/- zero (not NaN, though) */
79236 duk_pop(ctx);
79237
79238 if (global) {
79239 if (d < 0.0 || d > (double) DUK_HSTRING_GET_CHARLEN(h_input)) {
79240 /* match fail */
79241 char_offset = 0; /* not really necessary */
79242 DUK_ASSERT(match == 0);
79243 goto match_over;
79244 }
79245 char_offset = (duk_uint32_t) d;
79246 } else {
79247 /* lastIndex must be ignored for non-global regexps, but get the
79248 * value for (theoretical) side effects. No side effects can
79249 * really occur, because lastIndex is a normal property and is
79250 * always non-configurable for RegExp instances.
79251 */
79252 char_offset = (duk_uint32_t) 0;
79253 }
79254
79255 sp = re_ctx.input + duk_heap_strcache_offset_char2byte(thr, h_input, char_offset);
79256
79257 /*
79258 * Match loop.
79259 *
79260 * Try matching at different offsets until match found or input exhausted.
79261 */
79262
79263 /* [ ... re_obj input bc saved_buf ] */
79264
79265 DUK_ASSERT(match == 0);
79266
79267 for (;;) {
79268 /* char offset in [0, h_input->clen] (both ends inclusive), checked before entry */
79269 DUK_ASSERT_DISABLE(char_offset >= 0);
79270 DUK_ASSERT(char_offset <= DUK_HSTRING_GET_CHARLEN(h_input));
79271
79272 /* Note: ctx.steps is intentionally not reset, it applies to the entire unanchored match */
79273 DUK_ASSERT(re_ctx.recursion_depth == 0);
79274
79275 DUK_DDD(DUK_DDDPRINT("attempt match at char offset %ld; %p [%p,%p]",
79276 (long) char_offset, (const void *) sp,
79277 (const void *) re_ctx.input, (const void *) re_ctx.input_end));
79278
79279 /*
79280 * Note:
79281 *
79282 * - duk__match_regexp() is required not to longjmp() in ordinary "non-match"
79283 * conditions; a longjmp() will terminate the entire matching process.
79284 *
79285 * - Clearing saved[] is not necessary because backtracking does it
79286 *
79287 * - Backtracking also rewinds ctx.recursion back to zero, unless an
79288 * internal/limit error occurs (which causes a longjmp())
79289 *
79290 * - If we supported anchored matches, we would break out here
79291 * unconditionally; however, Ecmascript regexps don't have anchored
79292 * matches. It might make sense to implement a fast bail-out if
79293 * the regexp begins with '^' and sp is not 0: currently we'll just
79294 * run through the entire input string, trivially failing the match
79295 * at every non-zero offset.
79296 */
79297
79298 if (duk__match_regexp(&re_ctx, re_ctx.bytecode, sp) != NULL) {
79299 DUK_DDD(DUK_DDDPRINT("match at offset %ld", (long) char_offset));
79300 match = 1;
79301 break;
79302 }
79303
79304 /* advance by one character (code point) and one char_offset */
79305 char_offset++;
79306 if (char_offset > DUK_HSTRING_GET_CHARLEN(h_input)) {
79307 /*
79308 * Note:
79309 *
79310 * - Intentionally attempt (empty) match at char_offset == k_input->clen
79311 *
79312 * - Negative char_offsets have been eliminated and char_offset is duk_uint32_t
79313 * -> no need or use for a negative check
79314 */
79315
79316 DUK_DDD(DUK_DDDPRINT("no match after trying all sp offsets"));
79317 break;
79318 }
79319
79320 /* avoid calling at end of input, will DUK_ERROR (above check suffices to avoid this) */
79321 (void) duk__utf8_advance(thr, &sp, re_ctx.input, re_ctx.input_end, (duk_uint_fast32_t) 1);
79322 }
79323
79324 match_over:
79325
79326 /*
79327 * Matching complete, create result array or return a 'null'. Update lastIndex
79328 * if necessary. See E5 Section 15.10.6.2.
79329 *
79330 * Because lastIndex is a character (not byte) offset, we need the character
79331 * length of the match which we conveniently get as a side effect of interning
79332 * the matching substring (0th index of result array).
79333 *
79334 * saved[0] start pointer (~ byte offset) of current match
79335 * saved[1] end pointer (~ byte offset) of current match (exclusive)
79336 * char_offset start character offset of current match (-> .index of result)
79337 * char_end_offset end character offset (computed below)
79338 */
79339
79340 /* [ ... re_obj input bc saved_buf ] */
79341
79342 if (match) {
79343#ifdef DUK_USE_ASSERTIONS
79344 duk_hobject *h_res;
79345#endif
79346 duk_uint32_t char_end_offset = 0;
79347
79348 DUK_DDD(DUK_DDDPRINT("regexp matches at char_offset %ld", (long) char_offset));
79349
79350 DUK_ASSERT(re_ctx.nsaved >= 2); /* must have start and end */
79351 DUK_ASSERT((re_ctx.nsaved % 2) == 0); /* and even number */
79352
79353 /* XXX: Array size is known before and (2 * re_ctx.nsaved) but not taken
79354 * advantage of now. The array is not compacted either, as regexp match
79355 * objects are usually short lived.
79356 */
79357
79358 duk_push_array(ctx);
79359
79360#ifdef DUK_USE_ASSERTIONS
79361 h_res = duk_require_hobject(ctx, -1);
79365#endif
79366
79367 /* [ ... re_obj input bc saved_buf res_obj ] */
79368
79369 duk_push_u32(ctx, char_offset);
79371
79372 duk_dup(ctx, -4);
79374
79375 for (i = 0; i < re_ctx.nsaved; i += 2) {
79376 /* Captures which are undefined have NULL pointers and are returned
79377 * as 'undefined'. The same is done when saved[] pointers are insane
79378 * (this should, of course, never happen in practice).
79379 */
79380 if (re_ctx.saved[i] && re_ctx.saved[i+1] && re_ctx.saved[i+1] >= re_ctx.saved[i]) {
79381 duk_hstring *h_saved;
79382
79383 duk_push_lstring(ctx,
79384 (const char *) re_ctx.saved[i],
79385 (duk_size_t) (re_ctx.saved[i+1] - re_ctx.saved[i]));
79386 h_saved = duk_get_hstring(ctx, -1);
79387 DUK_ASSERT(h_saved != NULL);
79388
79389 if (i == 0) {
79390 /* Assumes that saved[0] and saved[1] are always
79391 * set by regexp bytecode (if not, char_end_offset
79392 * will be zero). Also assumes clen reflects the
79393 * correct char length.
79394 */
79395 char_end_offset = char_offset + DUK_HSTRING_GET_CHARLEN(h_saved);
79396 }
79397 } else {
79398 duk_push_undefined(ctx);
79399 }
79400
79401 /* [ ... re_obj input bc saved_buf res_obj val ] */
79402 duk_put_prop_index(ctx, -2, i / 2);
79403 }
79404
79405 /* [ ... re_obj input bc saved_buf res_obj ] */
79406
79407 /* NB: 'length' property is automatically updated by the array setup loop */
79408
79409 if (global) {
79410 /* global regexp: lastIndex updated on match */
79411 duk_push_u32(ctx, char_end_offset);
79413 } else {
79414 /* non-global regexp: lastIndex never updated on match */
79415 ;
79416 }
79417 } else {
79418 /*
79419 * No match, E5 Section 15.10.6.2, step 9.a.i - 9.a.ii apply, regardless
79420 * of 'global' flag of the RegExp. In particular, if lastIndex is invalid
79421 * initially, it is reset to zero.
79422 */
79423
79424 DUK_DDD(DUK_DDDPRINT("regexp does not match"));
79425
79426 duk_push_null(ctx);
79427
79428 /* [ ... re_obj input bc saved_buf res_obj ] */
79429
79430 duk_push_int(ctx, 0);
#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT
#define DUK_HOBJECT_CLASS_REGEXP
#define DUK_RE_EXECUTE_STEPS_LIMIT
DUK_EXTERNAL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index)
#define duk_xdef_prop_stridx_wec(ctx, obj_index, stridx)
#define DUK_STRIDX_INDEX
DUK_INTERNAL_DECL duk_hobject * duk_require_hobject_with_class(duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)
#define DUK_RE_FLAG_GLOBAL
#define DUK_STRIDX_LAST_INDEX
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_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 void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_global)
#define DUK_STRIDX_INT_BYTECODE

◆ 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 45348 of file duktape-1.5.2/src/duktape.c.

45352 : %ld (step %ld, size %ld)",
45353 (long) i, (long) step, (long) size));
45354 i = (i + step) % size;
45355
45356 /* looping should never happen */
45357 DUK_ASSERT(i != DUK__HASH_INITIAL(strhash, size));
45358 }
45359 DUK_UNREACHABLE();
45360}
45361
45362#if defined(DUK_USE_HEAPPTR16)
45363DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_hstring *h) {
45364#else
45365DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) {
45366#endif
45367 duk_uint32_t i;
45368 duk_uint32_t step;
45369 duk_uint32_t hash;
45370#if defined(DUK_USE_HEAPPTR16)
45371 duk_uint16_t null16 = heap->heapptr_null16;
45372 duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
45373#endif
45374
45375 DUK_ASSERT(size > 0);
45376
45377 hash = DUK_HSTRING_GET_HASH(h);
45378 i = DUK__HASH_INITIAL(hash, size);
45379 step = DUK__HASH_PROBE_STEP(hash);
45380 for (;;) {
45381#if defined(DUK_USE_HEAPPTR16)
45382 duk_uint16_t e16 = entries16[i];
45383#else
45384 duk_hstring *e = entries[i];
45385#endif
45386
45387#if defined(DUK_USE_HEAPPTR16)
45388 if (e16 == null16) {
45389#else
45390 if (!e) {
45391#endif
45392 DUK_UNREACHABLE();
45393 break;
45394 }
45395#if defined(DUK_USE_HEAPPTR16)
45396 if (e16 == h16) {
45397#else
45398 if (e == h) {
45399#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 77496 of file duktape-1.5.2/src/duktape.c.

77497 {
77498 /* 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__require_bufobj_value()

DUK_LOCAL duk_hbufferobject * duk__require_bufobj_value ( duk_context * ctx,
duk_idx_t index )

Definition at line 21673 of file duktape-1.5.2/src/duktape.c.

21674 {
21675 return duk__getrequire_bufobj_this(ctx, 0);
21676}
21677#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
21678
21679#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21680/* Check that 'this' is a duk_hbufferobject and return a pointer to it
21681 * (NULL if not).
21682 */
21684 return duk__getrequire_bufobj_this(ctx, 1);
21685}
21686#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
21687
21688#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21689/* Check that value is a duk_hbufferobject and return a pointer to it. */
21691 duk_hthread *thr;
21692 duk_tval *tv;
21693 duk_hbufferobject *h_obj;
21694
21695 thr = (duk_hthread *) ctx;
21696
DUK_LOCAL duk_hbufferobject * duk__getrequire_bufobj_this(duk_context *ctx, duk_bool_t throw_flag)
DUK_LOCAL duk_hbufferobject * duk__require_bufobj_value(duk_context *ctx, duk_idx_t index)
DUK_LOCAL duk_hbufferobject * duk__require_bufobj_this(duk_context *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 58016 of file duktape-1.5.2/src/duktape.c.

58033 {
58034 duk_compiler_func *func = &comp_ctx->curr_func;
58035 duk_hthread *thr = comp_ctx->thr;
58036 duk_context *ctx = (duk_context *) thr;
58037
58038 /* reset bytecode buffer but keep current size; pass 2 will
58039 * 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 60179 of file duktape-1.5.2/src/duktape.c.

60182 {
60184 }
60185
60186 DUK_DDD(DUK_DDDPRINT("label match: %!O -> label_id %ld, catch_depth=%ld, pc_label=%ld",
60187 (duk_heaphdr *) h_label, (long) li->label_id,
60188 (long) li->catch_depth, (long) li->pc_label));
60189

◆ duk__resize_strtab_probe()

DUK_LOCAL duk_bool_t duk__resize_strtab_probe ( duk_heap * heap)

Definition at line 45512 of file duktape-1.5.2/src/duktape.c.

45524 :
45525 DUK_FREE(heap, new_entries);
45526 return 1; /* FAIL */
45527}
45528
45530 duk_uint32_t new_size;
45531 duk_bool_t ret;
45532
DUK_LOCAL duk_bool_t duk__resize_strtab_probe(duk_heap *heap)

◆ 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 45401 of file duktape-1.5.2/src/duktape.c.

45401 : %ld", (long) i));
45402#if defined(DUK_USE_HEAPPTR16)
45403 entries16[i] = heap->heapptr_deleted16;
45404#else
45405 entries[i] = DUK__DELETED_MARKER(heap);
45406#endif
45407 break;
45408 }
45409
45410 DUK_DDD(DUK_DDDPRINT("free matching miss: %ld", (long) i));
45411 i = (i + step) % size;
45412
45413 /* looping should never happen */
45414 DUK_ASSERT(i != DUK__HASH_INITIAL(hash, size));
45415 }
45416}
45417
45418DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size) {
45419#if defined(DUK_USE_DEBUG)
45420 duk_uint32_t old_used = heap->st_used;
45421#endif
45422 duk_uint32_t old_size = heap->st_size;
45423#if defined(DUK_USE_HEAPPTR16)
45424 duk_uint16_t *old_entries = heap->strtable16;
45425 duk_uint16_t *new_entries = NULL;
45426#else
45427 duk_hstring **old_entries = heap->strtable;
45428 duk_hstring **new_entries = NULL;
45429#endif
45430 duk_uint32_t new_used = 0;
45431 duk_uint32_t i;
45432
45433#if defined(DUK_USE_DEBUG)
45434 DUK_UNREF(old_used); /* unused with some debug level combinations */
45435#endif
45436
45437#ifdef DUK_USE_DDDPRINT
45438 DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
45439 (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
45440 (long) (((double) old_used) / ((double) old_size) * 100.0),
45441 (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) duk__count_used_probe(heap),
45442 (long) (((double) duk__count_used_probe(heap)) / ((double) new_size) * 100.0)));
45443#endif
45444
45445 DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used_probe(heap)); /* required for rehash to succeed, equality not that useful */
45446 DUK_ASSERT(old_entries);
45447
45448 /*
45449 * The attempt to allocate may cause a GC. Such a GC must not attempt to resize
45450 * the stringtable (though it can be swept); finalizer execution and object
45451 * compaction must also be postponed to avoid the pressure to add strings to the
45452 * string table. Call site must prevent these.
45453 */
45454
45455#if defined(DUK_USE_MARK_AND_SWEEP)
45456 DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE);
45457 DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_FINALIZERS);
45458 DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_OBJECT_COMPACTION);
45459#endif
45460
45461#if defined(DUK_USE_HEAPPTR16)
45462 new_entries = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * new_size);
45463#else
45464 new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size);
45465#endif
45466
45467 if (!new_entries) {
45468 goto resize_error;
45469 }
45470
45471#if defined(DUK_USE_EXPLICIT_NULL_INIT)
45472 for (i = 0; i < new_size; i++) {
45473#if defined(DUK_USE_HEAPPTR16)
45474 new_entries[i] = heap->heapptr_null16;
45475#else
45476 new_entries[i] = NULL;
45477#endif
45478 }
45479#else
45480#if defined(DUK_USE_HEAPPTR16)
45481 /* Relies on NULL encoding to zero. */
45482 DUK_MEMZERO(new_entries, sizeof(duk_uint16_t) * new_size);
45483#else
45484 DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size);
45485#endif
45486#endif
45487
45488 /* Because new_size > duk__count_used_probe(heap), guaranteed to work */
45489 for (i = 0; i < old_size; i++) {
45490 duk_hstring *e;
45491
45492#if defined(DUK_USE_HEAPPTR16)
45493 e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, old_entries[i]);
45494#else
45495 e = old_entries[i];
45496#endif
45497 if (e == NULL || e == DUK__DELETED_MARKER(heap)) {
45498 continue;
45499 }
45500 /* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */
45501 duk__insert_hstring_probe(heap, new_entries, new_size, &new_used, e);
45502 }
45503
45504#ifdef DUK_USE_DDPRINT
45505 DUK_DD(DUK_DDPRINT("resized stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
45506 (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
45507 (long) (((double) old_used) / ((double) old_size) * 100.0),
45508 (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) new_used,
45509 (long) (((double) new_used) / ((double) new_size) * 100.0)));
45510#endif
#define free
Definition civetweb.c:1542
struct stringtable stringtable
static void resize(lua_State *L, Table *t, int nasize, int nhsize)

◆ duk__resize_valstack()

DUK_LOCAL duk_bool_t duk__resize_valstack ( duk_context * ctx,
duk_size_t new_size )

Definition at line 15415 of file duktape-1.5.2/src/duktape.c.

15432 {
15433 duk_hthread *thr = (duk_hthread *) ctx;
15434 duk_ptrdiff_t old_bottom_offset;
15435 duk_ptrdiff_t old_top_offset;
15436 duk_ptrdiff_t old_end_offset_post;
15437#ifdef DUK_USE_DEBUG
15438 duk_ptrdiff_t old_end_offset_pre;
15439 duk_tval *old_valstack_pre;
15440 duk_tval *old_valstack_post;
15441#endif
15442 duk_tval *new_valstack;
15443 duk_size_t new_alloc_size;
15444 duk_tval *p;
15445
15447 DUK_ASSERT(thr != NULL);
15448 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
15450 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
15451 DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) <= new_size); /* can't resize below 'top' */
15452 DUK_ASSERT(new_size <= thr->valstack_max); /* valstack limit caller has check, prevents wrapping */
15453 DUK_ASSERT(new_size <= DUK_SIZE_MAX / sizeof(duk_tval)); /* specific assert for wrapping */
15454
15455 /* get pointer offsets for tweaking below */
15456 old_bottom_offset = (((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack));
15457 old_top_offset = (((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack));
15458#ifdef DUK_USE_DEBUG
15459 old_end_offset_pre = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack)); /* not very useful, used for debugging */
15460 old_valstack_pre = thr->valstack;
15461#endif
15462
15463 /* Allocate a new valstack.
15464 *
15465 * Note: cannot use a plain DUK_REALLOC() because a mark-and-sweep may
15466 * invalidate the original thr->valstack base pointer inside the realloc
15467 * process. See doc/memory-management.rst.
15468 */
15469
15470 new_alloc_size = sizeof(duk_tval) * new_size;
15471 new_valstack = (duk_tval *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_valstack_ptr, (void *) thr, new_alloc_size);
15472 if (!new_valstack) {
15473 /* Because new_size != 0, if condition doesn't need to be
15474 * (new_valstack != NULL || new_size == 0).
15475 */
15476 DUK_ASSERT(new_size != 0);
15477 DUK_D(DUK_DPRINT("failed to resize valstack to %lu entries (%lu bytes)",
15478 (unsigned long) new_size, (unsigned long) new_alloc_size));
15479 return 0;
15480 }
15481
15482 /* Note: the realloc may have triggered a mark-and-sweep which may
15483 * have resized our valstack internally. However, the mark-and-sweep
15484 * MUST NOT leave the stack bottom/top in a different state. Particular
15485 * assumptions and facts:
15486 *
15487 * - The thr->valstack pointer may be different after realloc,
15488 * and the offset between thr->valstack_end <-> thr->valstack
15489 * may have changed.
15490 * - The offset between thr->valstack_bottom <-> thr->valstack
15491 * and thr->valstack_top <-> thr->valstack MUST NOT have changed,
15492 * because mark-and-sweep must adhere to a strict stack policy.
15493 * In other words, logical bottom and top MUST NOT have changed.
15494 * - All values above the top are unreachable but are initialized
15495 * to UNDEFINED, up to the post-realloc valstack_end.
15496 * - 'old_end_offset' must be computed after realloc to be correct.
15497 */
15498
15499 DUK_ASSERT((((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack)) == old_bottom_offset);
15500 DUK_ASSERT((((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack)) == old_top_offset);
15501
15502 /* success, fixup pointers */
15503 old_end_offset_post = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack)); /* must be computed after realloc */
15504#ifdef DUK_USE_DEBUG
15505 old_valstack_post = thr->valstack;
15506#endif
15507 thr->valstack = new_valstack;
15508 thr->valstack_end = new_valstack + new_size;
15509#if !defined(DUK_USE_PREFER_SIZE)
15510 thr->valstack_size = new_size;
15511#endif
15512 thr->valstack_bottom = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_bottom_offset);
15513 thr->valstack_top = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_top_offset);
15514
15515 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
15517 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
15518
15519 /* useful for debugging */
15520#ifdef DUK_USE_DEBUG
15521 if (old_end_offset_pre != old_end_offset_post) {
15522 DUK_D(DUK_DPRINT("valstack was resized during valstack_resize(), probably by mark-and-sweep; "
15523 "end offset changed: %lu -> %lu",
15524 (unsigned long) old_end_offset_pre,
15525 (unsigned long) old_end_offset_post));
15526 }
15527 if (old_valstack_pre != old_valstack_post) {
15528 DUK_D(DUK_DPRINT("valstack pointer changed during valstack_resize(), probably by mark-and-sweep: %p -> %p",
15529 (void *) old_valstack_pre,
15530 (void *) old_valstack_post));
15531 }
15532#endif
15533
15534 DUK_DD(DUK_DDPRINT("resized valstack to %lu elements (%lu bytes), bottom=%ld, top=%ld, "
15535 "new pointers: start=%p end=%p bottom=%p top=%p",
15536 (unsigned long) new_size, (unsigned long) new_alloc_size,
15537 (long) (thr->valstack_bottom - thr->valstack),
15538 (long) (thr->valstack_top - thr->valstack),
15539 (void *) thr->valstack, (void *) thr->valstack_end,
15540 (void *) thr->valstack_bottom, (void *) thr->valstack_top));
15541
15542 /* Init newly allocated slots (only). */
15543 p = (duk_tval *) (void *) ((duk_uint8_t *) thr->valstack + old_end_offset_post);
#define DUK_REALLOC_INDIRECT(heap, cb, ud, newsize)
DUK_INTERNAL_DECL void * duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud)

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 21745 of file duktape-1.5.2/src/duktape.c.

21768 {
21769 duk_hthread *thr;
21770 duk_int_t offset_signed;
21771 duk_int_t length_signed;
21772 duk_uint_t offset;
21773 duk_uint_t length;
21774
21775 thr = (duk_hthread *) ctx;
21776 DUK_UNREF(thr);
21777
21778 offset_signed = duk_to_int(ctx, idx_offset);
21779 if (offset_signed < 0) {
21780 goto fail_range;
21781 }
21782 offset = (duk_uint_t) offset_signed;
21783 if (offset > h_bufarg->length) {
21784 goto fail_range;
21785 }
21786 DUK_ASSERT_DISABLE(offset >= 0); /* unsigned */
21787 DUK_ASSERT(offset <= h_bufarg->length);
21788
21789 if (duk_is_undefined(ctx, idx_length)) {
21790 DUK_ASSERT(h_bufarg->length >= offset);
21791 length = h_bufarg->length - offset; /* >= 0 */
21792 } else {
21793 length_signed = duk_to_int(ctx, idx_length);
21794 if (length_signed < 0) {
21795 goto fail_range;
21796 }
21797 length = (duk_uint_t) length_signed;
21798 DUK_ASSERT(h_bufarg->length >= offset);
21799 if (length > h_bufarg->length - offset) {
21800 /* Unlike for negative arguments, some call sites
21801 * want length to be clamped if it's positive.
21802 */

◆ duk__round_fixed()

DUK_LOCAL double duk__round_fixed ( double x)

Definition at line 32418 of file duktape-1.5.2/src/duktape.c.

32421 {
32422 if (DUK_SIGNBIT(x) == 0 || DUK_SIGNBIT(y) == 0) {
32423 return +0.0;
32424 } else {
32425 return -0.0;
32426 }
32427 }
32428#ifdef DUK_USE_MATH_FMAX
32429 return DUK_FMAX(x, y);
32430#else
32431 return (x > y ? x : y);
32432#endif
32433}
32434
32435DUK_LOCAL double duk__round_fixed(double x) {
32436 /* Numbers half-way between integers must be rounded towards +Infinity,
32437 * e.g. -3.5 must be rounded to -3 (not -4). When rounded to zero, zero
32438 * sign must be set appropriately. E5.1 Section 15.8.2.15.
32439 *
32440 * Note that ANSI C round() is "round to nearest integer, away from zero",
32441 * which is incorrect for negative values. Here we make do with floor().
32442 */
32443
32445 if (c == DUK_FP_NAN || c == DUK_FP_INFINITE || c == DUK_FP_ZERO) {
32446 return x;
32447 }
32448
32449 /*
32450 * x is finite and non-zero
32451 *
32452 * -1.6 -> floor(-1.1) -> -2
32453 * -1.5 -> floor(-1.0) -> -1 (towards +Inf)
32454 * -1.4 -> floor(-0.9) -> -1
32455 * -0.5 -> -0.0 (special case)
32456 * -0.1 -> -0.0 (special case)
32457 * +0.1 -> +0.0 (special case)
DUK_LOCAL double duk__round_fixed(double x)

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 42828 of file duktape-1.5.2/src/duktape.c.

42829 {
42830 DUK_HEAPHDR_SET_NEXT(heap, prev, NULL);
42831 }
42832 DUK_ASSERT_HEAPHDR_LINKS(heap, prev);
42833
42834#ifdef DUK_USE_DEBUG
42835 DUK_D(DUK_DPRINT("mark-and-sweep sweep objects (non-string): %ld freed, %ld kept, %ld rescued, %ld queued for finalization",
42836 (long) count_free, (long) count_keep, (long) count_rescue, (long) count_finalize));
42837#endif
42838 *out_count_keep = count_keep;
42839}
42840
42841/*
42842 * Run (object) finalizers in the "to be finalized" work list.
42843 */
42844
42846 duk_heaphdr *curr;
42848#ifdef DUK_USE_DEBUG
42849 duk_size_t count = 0;
42850#endif
42851 duk_hthread *thr;
42852
42853 DUK_DD(DUK_DDPRINT("duk__run_object_finalizers: %p", (void *) heap));
42854
42855 thr = duk__get_temp_hthread(heap);
42856 DUK_ASSERT(thr != NULL);
42857
42858 curr = heap->finalize_list;
42859 while (curr) {
42860 DUK_DDD(DUK_DDDPRINT("mark-and-sweep finalize: %p", (void *) curr));
42861
42862 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT); /* only objects have finalizers */
42863 DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr)); /* flags have been already cleared */
42867 DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(curr)); /* No finalizers for ROM objects */
42868
42869 if (DUK_LIKELY((flags & DUK_MS_FLAG_SKIP_FINALIZERS) == 0)) {
42870 /* Run the finalizer, duk_hobject_run_finalizer() sets FINALIZED.
42871 * Next mark-and-sweep will collect the object unless it has
42872 * become reachable (i.e. rescued). FINALIZED prevents the
42873 * finalizer from being executed again before that.
42874 */
42875 duk_hobject_run_finalizer(thr, (duk_hobject *) curr); /* must never longjmp */
42877 } else {
42878 /* Used during heap destruction: don't actually run finalizers
42879 * because we're heading into forced finalization. Instead,
42880 * queue finalizable objects back to the heap_allocated list.
42881 */
42882 DUK_D(DUK_DPRINT("skip finalizers flag set, queue object to heap_allocated without finalizing"));
42884 }
42885
DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap, duk_small_uint_t flags)
#define DUK_MS_FLAG_SKIP_FINALIZERS

◆ duk__run_voluntary_gc()

DUK_LOCAL void duk__run_voluntary_gc ( duk_heap * heap)

Definition at line 43398 of file duktape-1.5.2/src/duktape.c.

43408 { \
43409 (heap)->mark_and_sweep_trigger_counter--; \
43410 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 55587 of file duktape-1.5.2/src/duktape.c.

55604 {
55605 duk_context *ctx = (duk_context *) thr;
55606 duk_idx_t idx_rcbase;
55607
55608 DUK_ASSERT(thr != NULL);
55609 DUK_ASSERT(idx_retbase >= 0);
55610 DUK_ASSERT(num_stack_rets >= 0);
55611 DUK_ASSERT(num_actual_rets >= 0);
55612
55613 idx_rcbase = duk_get_top(ctx) - num_actual_rets; /* base of known return values */
55614
55615 DUK_DDD(DUK_DDDPRINT("adjust valstack after func call: "
55616 "num_stack_rets=%ld, num_actual_rets=%ld, stack_top=%ld, idx_retbase=%ld, idx_rcbase=%ld",
55617 (long) num_stack_rets, (long) num_actual_rets, (long) duk_get_top(ctx),
55618 (long) idx_retbase, (long) idx_rcbase));
55619
55620 DUK_ASSERT(idx_rcbase >= 0); /* caller must check */
55621
55622 /* Ensure space for final configuration (idx_retbase + num_stack_rets)
55623 * and intermediate configurations.
55624 */
55626 (idx_rcbase > idx_retbase ? idx_rcbase : idx_retbase) +
55627 num_stack_rets);
55628
55629 /* Chop extra retvals away / extend with undefined. */
55630 duk_set_top(ctx, idx_rcbase + num_stack_rets);
55631
55632 if (idx_rcbase >= idx_retbase) {
55633 duk_idx_t count = idx_rcbase - idx_retbase;
55634 duk_idx_t i;
55635
55636 DUK_DDD(DUK_DDDPRINT("elements at/after idx_retbase have enough to cover func retvals "
55637 "(idx_retbase=%ld, idx_rcbase=%ld)", (long) idx_retbase, (long) idx_rcbase));
55638
55639 /* nuke values at idx_retbase to get the first retval (initially
55640 * at idx_rcbase) to idx_retbase
55641 */
55642
55643 DUK_ASSERT(count >= 0);
55644
55645 for (i = 0; i < count; i++) {
55646 /* XXX: inefficient; block remove primitive */
55647 duk_remove(ctx, idx_retbase);
55648 }
55649 } else {
55650 duk_idx_t count = idx_retbase - idx_rcbase;
55651 duk_idx_t i;
DUK_EXTERNAL void duk_require_stack_top(duk_context *ctx, duk_idx_t top)

◆ duk__safe_to_string_raw()

DUK_LOCAL duk_ret_t duk__safe_to_string_raw ( duk_context * ctx)

Definition at line 16977 of file duktape-1.5.2/src/duktape.c.

16977 : d=4.5, t=0.5 -> ret = (4 + 1) & 0xfe = 5 & 0xfe = 4
16978 */
16979 } else {
16980 /* Not halfway, round to nearest. */
16981 ret = (duk_uint8_t) (d + 0.5);
16982 }

◆ 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 44516 of file duktape-1.5.2/src/duktape.c.

44517 {
44518 while (n > 0) {
44519 for (;;) {
44520 p++;
44521 if (p >= q) {
44522 return NULL;
44523 }
44524 if ((*p & 0xc0) != 0x80) {
44525 break;
44526 }
44527 }
44528 n--;
44529 }
44530 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 44500 of file duktape-1.5.2/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 21699 of file duktape-1.5.2/src/duktape.c.

21702 {
21703 h_obj = (duk_hbufferobject *) DUK_TVAL_GET_OBJECT(tv);
21704 DUK_ASSERT(h_obj != NULL);
21707 return h_obj;
21708 }
21709 }
21710
21712 return NULL; /* not reachable */
21713}
21714#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
21715
21717 duk_hthread *thr;
21718
DUK_LOCAL void duk__set_bufobj_buffer(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_hbuffer *h_val)

◆ 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 65974 of file duktape-1.5.2/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 25506 of file duktape-1.5.2/src/duktape.c.

25512 : parts[idx_part]);
25513 return 1;
25514}
25515
25516/* Helper for component setter calls: check 'this' binding, get the
25517 * internal time value, split it into parts (either as UTC time or
25518 * local time), modify one or more components as specified, recompute
25519 * the time value, set it as the internal value. Finally, push the
25520 * new time value as a return value to the value stack and return 1
25521 * (caller can then tail call us).
25522 */
25524 duk_double_t d;
25527 duk_idx_t nargs;
25528 duk_small_uint_t maxnargs = (duk_small_uint_t) (flags_and_maxnargs >> DUK_DATE_FLAG_VALUE_SHIFT); /* unpack args */
25529 duk_small_uint_t idx_first, idx;
25531
25532 nargs = duk_get_top(ctx);
25533 d = duk__push_this_get_timeval(ctx, flags_and_maxnargs);
25535
25536 if (DUK_ISFINITE(d)) {
25537 duk_bi_date_timeval_to_parts(d, parts, dparts, flags_and_maxnargs);
25538 } else {
25539 /* NaN timevalue: we need to coerce the arguments, but
25540 * the resulting internal timestamp needs to remain NaN.
25541 * This works but is not pretty: parts and dparts will
25542 * be partially uninitialized, but we only write to them.
25543 */
25544 }
25545
25546 /*
25547 * Determining which datetime components to overwrite based on
25548 * stack arguments is a bit complicated, but important to factor
25549 * out from setters themselves for compactness.
25550 *
25551 * If DUK_DATE_FLAG_TIMESETTER, maxnargs indicates setter type:
25552 *
25553 * 1 -> millisecond
25554 * 2 -> second, [millisecond]
25555 * 3 -> minute, [second], [millisecond]
25556 * 4 -> hour, [minute], [second], [millisecond]
25557 *
25558 * Else:
25559 *
25560 * 1 -> date
25561 * 2 -> month, [date]
25562 * 3 -> year, [month], [date]
25563 *
25564 * By comparing nargs and maxnargs (and flags) we know which
25565 * components to override. We rely on part index ordering.
25566 */
25567
25568 if (flags_and_maxnargs & DUK_DATE_FLAG_TIMESETTER) {
25569 DUK_ASSERT(maxnargs >= 1 && maxnargs <= 4);
25570 idx_first = DUK_DATE_IDX_MILLISECOND - (maxnargs - 1);
25571 } else {
25572 DUK_ASSERT(maxnargs >= 1 && maxnargs <= 3);
25573 idx_first = DUK_DATE_IDX_DAY - (maxnargs - 1);
25574 }
25575 DUK_ASSERT_DISABLE(idx_first >= 0); /* unsigned */
25577
25578 for (i = 0; i < maxnargs; i++) {
25579 if ((duk_idx_t) i >= nargs) {
25580 /* no argument given -> leave components untouched */
25581 break;
25582 }
25583 idx = idx_first + i;
25584 DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */
25586
25587 if (idx == DUK_DATE_IDX_YEAR && (flags_and_maxnargs & DUK_DATE_FLAG_YEAR_FIXUP)) {
25589 }
25590
25591 dparts[idx] = duk_to_number(ctx, i);
25592
25593 if (idx == DUK_DATE_IDX_DAY) {
25594 /* Day-of-month is one-based in the API, but zero-based
25595 * internally, so fix here. Note that month is zero-based
25596 * both in the API and internally.
25597 */
25598 /* SCANBUILD: complains about use of uninitialized values.
25599 * The complaint is correct, but operating in undefined
25600 * values here is intentional in some cases and the caller
#define DUK_DATE_FLAG_TIMESETTER
#define DUK_DATE_IDX_MILLISECOND
#define DUK_DATE_FLAG_YEAR_FIXUP
DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flags_and_maxnargs)
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)

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 25631 of file duktape-1.5.2/src/duktape.c.

25631 {
25632 return;
25633 }
25634 duk_dup(ctx, idx_val);
25635 duk_to_int(ctx, -1);
25636 d = duk_get_number(ctx, -1); /* get as double to handle huge numbers correctly */
25637 if (d >= 0.0 && d <= 99.0) {
25638 d += 1900.0;
25639 duk_push_number(ctx, d);
25640 duk_replace(ctx, idx_val);
25641 }
25642 duk_pop(ctx);
25643}
25644
25645/* Set datetime parts from stack arguments, defaulting any missing values.
25646 * Day-of-week is not set; it is not required when setting the time value.
25647 */
25649 duk_double_t d;
25651 duk_small_uint_t idx;
25652
25653 /* Causes a ToNumber() coercion, but doesn't break coercion order since
25654 * year is coerced first anyway.
25655 */
25657
25658 /* There are at most 7 args, but we use 8 here so that also
25659 * DUK_DATE_IDX_WEEKDAY gets initialized (to zero) to avoid the potential
25660 * for any Valgrind gripes later.
25661 */
25662 for (i = 0; i < 8; i++) {
25663 /* Note: rely on index ordering */
25664 idx = DUK_DATE_IDX_YEAR + i;
25665 if ((duk_idx_t) i < nargs) {
25666 d = duk_to_number(ctx, (duk_idx_t) i);
25667 if (idx == DUK_DATE_IDX_DAY) {
25668 /* Convert day from one-based to zero-based (internal). This may
25669 * cause the day part to be negative, which is OK.
25670 */
25671 d -= 1.0;
DUK_LOCAL void duk__set_parts_from_args(duk_context *ctx, duk_double_t *dparts, duk_idx_t nargs)

◆ 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 25343 of file duktape-1.5.2/src/duktape.c.

25344 {
25345 *out_tzoffset = tzoffset;
25346 }
25347
25348 /* [ ... this ] */
25349 return d;
25350}
25351
25353 return duk__push_this_get_timeval_tzoffset(ctx, flags, NULL);
25354}
25355

◆ duk__settemp_checkmax()

DUK_LOCAL_DECL void duk__settemp_checkmax ( duk_compiler_ctx * comp_ctx,
duk_reg_t temp_next )

Definition at line 59342 of file duktape-1.5.2/src/duktape.c.

59343 { /* == DUK__MAX_TEMPS is OK */
59345 }
59346
59347 /* maintain highest 'used' temporary, needed to figure out nregs of function */
#define DUK_STR_TEMP_LIMIT

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 32555 of file duktape-1.5.2/src/duktape.c.

32557 {

◆ 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 10734 of file duktape-1.5.2/src/duktape.c.

10754 {
10755 duk_small_int_t skip = 0;
10758 duk_small_int_t count;
10759 duk_codepoint_t tmp_cp;
10760 duk_codepoint_t start_i;
10761 duk_codepoint_t start_o;
10762
10763 DUK_UNREF(thr);
10764 DUK_ASSERT(bd_ctx != NULL);
10765
10766 DUK_DDD(DUK_DDDPRINT("slow case conversion for codepoint: %ld", (long) cp));
10767
10768 /* range conversion with a "skip" */
10769 DUK_DDD(DUK_DDDPRINT("checking ranges"));
10770 for (;;) {
10771 skip++;
10772 n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6);
10773 if (n == 0x3f) {
10774 /* end marker */
10775 break;
10776 }
10777 DUK_DDD(DUK_DDDPRINT("skip=%ld, n=%ld", (long) skip, (long) n));
10778
10779 while (n--) {
10780 start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
10781 start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
10782 count = (duk_small_int_t) duk_bd_decode(bd_ctx, 7);
10783 DUK_DDD(DUK_DDDPRINT("range: start_i=%ld, start_o=%ld, count=%ld, skip=%ld",
10784 (long) start_i, (long) start_o, (long) count, (long) skip));
10785
10786 if (cp >= start_i) {
10787 tmp_cp = cp - start_i; /* always >= 0 */
10788 if (tmp_cp < (duk_codepoint_t) count * (duk_codepoint_t) skip &&
10789 (tmp_cp % (duk_codepoint_t) skip) == 0) {
10790 DUK_DDD(DUK_DDDPRINT("range matches input codepoint"));
10791 cp = start_o + tmp_cp;
10792 goto single;
10793 }
10794 }
10795 }
10796 }
10797
10798 /* 1:1 conversion */
10799 n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6);
10800 DUK_DDD(DUK_DDDPRINT("checking 1:1 conversions (count %ld)", (long) n));
10801 while (n--) {
10802 start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
10803 start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
10804 DUK_DDD(DUK_DDDPRINT("1:1 conversion %ld -> %ld", (long) start_i, (long) start_o));
10805 if (cp == start_i) {
10806 DUK_DDD(DUK_DDDPRINT("1:1 matches input codepoint"));
10807 cp = start_o;
10808 goto single;
10809 }
10810 }
10811
10812 /* complex, multicharacter conversion */
10813 n = (duk_small_int_t) duk_bd_decode(bd_ctx, 7);
10814 DUK_DDD(DUK_DDDPRINT("checking 1:n conversions (count %ld)", (long) n));
10815 while (n--) {
10816 start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
10817 t = (duk_small_int_t) duk_bd_decode(bd_ctx, 2);
10818 DUK_DDD(DUK_DDDPRINT("1:n conversion %ld -> %ld chars", (long) start_i, (long) t));
10819 if (cp == start_i) {
10820 DUK_DDD(DUK_DDDPRINT("1:n matches input codepoint"));
10821 if (bw != NULL) {
10822 while (t--) {
10823 tmp_cp = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
10824 DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) tmp_cp);
10825 }
10826 }
10827 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 46186 of file duktape-1.5.2/src/duktape.c.

46198 ://en.wikipedia.org/wiki/Insertion_sort
46199 *
46200 * (Compiles to about 160 bytes now as a stand-alone function.)
46201 */
46202
46204 duk_hstring **keys;
46205 duk_hstring **p_curr, **p_insert, **p_end;
46206 duk_hstring *h_curr;
46207 duk_uarridx_t val_highest, val_curr, val_insert;
46208
46209 DUK_ASSERT(h_obj != NULL);
46210 DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(h_obj) >= 2); /* control props */
46211 DUK_UNREF(thr);
46212
46213 if (DUK_HOBJECT_GET_ENEXT(h_obj) <= 1 + DUK__ENUM_START_INDEX) {
46214 return;
46215 }
46216
46217 keys = DUK_HOBJECT_E_GET_KEY_BASE(thr->heap, h_obj);
46218 p_end = keys + DUK_HOBJECT_GET_ENEXT(h_obj);
46219 keys += DUK__ENUM_START_INDEX;
46220
46221 DUK_DDD(DUK_DDDPRINT("keys=%p, p_end=%p (after skipping enum props)",
46222 (void *) keys, (void *) p_end));
46223
46224#ifdef DUK_USE_DDDPRINT
46225 {
46227 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h_obj); i++) {
46228 DUK_DDD(DUK_DDDPRINT("initial: %ld %p -> %!O",
46229 (long) i,
46230 (void *) DUK_HOBJECT_E_GET_KEY_PTR(thr->heap, h_obj, i),
46231 (duk_heaphdr *) DUK_HOBJECT_E_GET_KEY(thr->heap, h_obj, i)));
46232 }
46233 }
46234#endif
46235
46236 val_highest = DUK_HSTRING_GET_ARRIDX_SLOW(keys[0]);
46237 for (p_curr = keys + 1; p_curr < p_end; p_curr++) {
46238 DUK_ASSERT(*p_curr != NULL);
46239 val_curr = DUK_HSTRING_GET_ARRIDX_SLOW(*p_curr);
46240
46241 if (val_curr >= val_highest) {
46242 DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> "
46243 "already in correct order, next",
46244 (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr));
46245 val_highest = val_curr;
46246 continue;
46247 }
46248
46249 DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> "
46250 "needs to be inserted",
46251 (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr));
46252
46253 /* Needs to be inserted; scan backwards, since we optimize
46254 * for the case where elements are nearly in order.
46255 */
46256
46257 p_insert = p_curr - 1;
46258 for (;;) {
46259 val_insert = DUK_HSTRING_GET_ARRIDX_SLOW(*p_insert);
46260 if (val_insert < val_curr) {
46261 DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> insert after this",
46262 (void *) p_insert, (long) val_insert, (long) val_curr));
46263 p_insert++;
46264 break;
46265 }
46266 if (p_insert == keys) {
46267 DUK_DDD(DUK_DDDPRINT("p_insert=%p -> out of keys, insert to beginning", (void *) p_insert));
46268 break;
46269 }
46270 DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> search backwards",
46271 (void *) p_insert, (long) val_insert, (long) val_curr));
46272 p_insert--;
46273 }
46274
46275 DUK_DDD(DUK_DDDPRINT("final p_insert=%p", (void *) p_insert));
46276
46277 /* .-- p_insert .-- p_curr
46278 * v v
46279 * | ... | insert | ... | curr
46280 */
46281
46282 h_curr = *p_curr;
46283 DUK_DDD(DUK_DDDPRINT("memmove: dest=%p, src=%p, size=%ld, h_curr=%p",
46284 (void *) (p_insert + 1), (void *) p_insert,
46285 (long) (p_curr - p_insert), (void *) h_curr));
46286
46287 DUK_MEMMOVE((void *) (p_insert + 1),
46288 (const void *) p_insert,
DUK_LOCAL void duk__sort_array_indices(duk_hthread *thr, duk_hobject *h_obj)
#define DUK_HOBJECT_E_GET_KEY_BASE(heap, h)
#define DUK__ENUM_START_INDEX
#define DUK_HOBJECT_E_GET_KEY_PTR(heap, h, i)

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 32558 of file duktape-1.5.2/src/duktape.c.

32560 {

◆ 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 63643 of file duktape-1.5.2/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 42670 of file duktape-1.5.2/src/duktape.c.

42676 : %ld freed, %ld kept",
42677 (long) count_free, (long) count_keep));
42678#endif
42679 *out_count_keep = count_keep;
42680}
42681#endif /* DUK_USE_STRTAB_PROBE */
42682
42683/*
42684 * Sweep heap
42685 */
42686
42687DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep) {
42688 duk_heaphdr *prev; /* last element that was left in the heap */
42689 duk_heaphdr *curr;
42690 duk_heaphdr *next;
42691#ifdef DUK_USE_DEBUG
42692 duk_size_t count_free = 0;
42693 duk_size_t count_finalize = 0;
42694 duk_size_t count_rescue = 0;
42695#endif
42696 duk_size_t count_keep = 0;
42697
42698 DUK_UNREF(flags);
42699 DUK_DD(DUK_DDPRINT("duk__sweep_heap: %p", (void *) heap));
42700
42701 prev = NULL;
42702 curr = heap->heap_allocated;
42703 heap->heap_allocated = NULL;
42704 while (curr) {
42705 /* Strings and ROM objects are never placed on the heap allocated list. */
42706 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_STRING);
42707 DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(curr));
42708
42709 next = DUK_HEAPHDR_GET_NEXT(heap, curr);
42710
42711 if (DUK_HEAPHDR_HAS_REACHABLE(curr)) {
42712 /*
42713 * Reachable object, keep
42714 */
42715
42716 DUK_DDD(DUK_DDDPRINT("sweep, reachable: %p", (void *) curr));
42717
42718 if (DUK_HEAPHDR_HAS_FINALIZABLE(curr)) {
42719 /*
42720 * If object has been marked finalizable, move it to the
42721 * "to be finalized" work list. It will be collected on
42722 * the next mark-and-sweep if it is still unreachable
42723 * after running the finalizer.
42724 */
42725
42726 DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
42727 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
42728 DUK_DDD(DUK_DDDPRINT("object has finalizer, move to finalization work list: %p", (void *) curr));
42729
42730#ifdef DUK_USE_DOUBLE_LINKED_HEAP
42731 if (heap->finalize_list) {
42732 DUK_HEAPHDR_SET_PREV(heap, heap->finalize_list, curr);
42733 }
42734 DUK_HEAPHDR_SET_PREV(heap, curr, NULL);
42735#endif
42736 DUK_HEAPHDR_SET_NEXT(heap, curr, heap->finalize_list);
42737 DUK_ASSERT_HEAPHDR_LINKS(heap, curr);
42738 heap->finalize_list = curr;
42739#ifdef DUK_USE_DEBUG
42740 count_finalize++;
42741#endif
42742 } else {
42743 /*
42744 * Object will be kept; queue object back to heap_allocated (to tail)
42745 */
42746
42747 if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
42748 /*
42749 * Object's finalizer was executed on last round, and
42750 * object has been happily rescued.
42751 */
42752
42753 DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
42754 DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
42755 DUK_DD(DUK_DDPRINT("object rescued during mark-and-sweep finalization: %p", (void *) curr));
42756#ifdef DUK_USE_DEBUG
42757 count_rescue++;
42758#endif
42759 } else {
42760 /*
42761 * Plain, boring reachable object.
42762 */
42763 DUK_DD(DUK_DDPRINT("keep object: %!iO", curr));
42764 count_keep++;
42765 }
42766
42767 if (!heap->heap_allocated) {
42768 heap->heap_allocated = curr;
42769 }
42770 if (prev) {
42771 DUK_HEAPHDR_SET_NEXT(heap, prev, curr);
42772 }
42773#ifdef DUK_USE_DOUBLE_LINKED_HEAP
42774 DUK_HEAPHDR_SET_PREV(heap, curr, prev);
42775#endif
42776 DUK_ASSERT_HEAPHDR_LINKS(heap, prev);
42777 DUK_ASSERT_HEAPHDR_LINKS(heap, curr);
42778 prev = curr;
42779 }
42780
42781 DUK_HEAPHDR_CLEAR_REACHABLE(curr);
42782 DUK_HEAPHDR_CLEAR_FINALIZED(curr);
42783 DUK_HEAPHDR_CLEAR_FINALIZABLE(curr);
42784
42785 DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));
42786 DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
42787 DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
42788
42789 curr = next;
42790 } else {
42791 /*
42792 * Unreachable object, free
42793 */
42794
42795 DUK_DDD(DUK_DDDPRINT("sweep, not reachable: %p", (void *) curr));
42796
42797#if defined(DUK_USE_REFERENCE_COUNTING)
42798 /* Non-zero refcounts should not happen because we refcount
42799 * finalize all unreachable objects which should cancel out
42800 * refcounts (even for cycles).
42801 */
42802 DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(curr) == 0);
42803#endif
42804 DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
42805
42806 if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
42807 DUK_DDD(DUK_DDDPRINT("finalized object not rescued: %p", (void *) curr));
42808 }
42809
42810 /* Note: object cannot be a finalizable unreachable object, as
42811 * they have been marked temporarily reachable for this round,
42812 * and are handled above.
42813 */
42814
42815#ifdef DUK_USE_DEBUG
42816 count_free++;
42817#endif
42818
42819 /* weak refs should be handled here, but no weak refs for
42820 * any non-string objects exist right now.
42821 */
42822
DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep)

◆ duk__sweep_stringtable_probe()

DUK_LOCAL void duk__sweep_stringtable_probe ( duk_heap * heap,
duk_size_t * out_count_keep )

Definition at line 42597 of file duktape-1.5.2/src/duktape.c.

42597 {
42598#if defined(DUK_USE_HEAPPTR16)
42599 duk__sweep_string_chain16(heap, lst + j, &count_keep, &count_free);
42600#else
42601 duk__sweep_string_chain(heap, lst + j, &count_keep, &count_free);
42602#endif
42603 }
42604 }
42605 }
42606
42607 DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept",
42608 (long) count_free, (long) count_keep));
42609 *out_count_keep = count_keep;
42610}
42611#endif /* DUK_USE_STRTAB_CHAIN */
42612
42613#if defined(DUK_USE_STRTAB_PROBE)
42614DUK_LOCAL void duk__sweep_stringtable_probe(duk_heap *heap, duk_size_t *out_count_keep) {
42615 duk_hstring *h;
42617#ifdef DUK_USE_DEBUG
42618 duk_size_t count_free = 0;
42619#endif
42620 duk_size_t count_keep = 0;
42621
42622 DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap));
42623
42624 for (i = 0; i < heap->st_size; i++) {
42625#if defined(DUK_USE_HEAPPTR16)
42626 h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
42627#else
42628 h = heap->strtable[i];
42629#endif
42630 if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
42631 continue;
42632 } else if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
42634 count_keep++;
42635 continue;
42636 }
42637
42638#ifdef DUK_USE_DEBUG
42639 count_free++;
42640#endif
42641
42642#if defined(DUK_USE_REFERENCE_COUNTING)
42643 /* Non-zero refcounts should not happen for unreachable strings,
42644 * because we refcount finalize all unreachable objects which
42645 * should have decreased unreachable string refcounts to zero
42646 * (even for cycles).
42647 */
42649#endif
42650
42651 DUK_DDD(DUK_DDDPRINT("sweep string, not reachable: %p", (void *) h));
42652
42653 /* deal with weak references first */
42655
42656 /* remove the string (mark DELETED), could also call
42657 * duk_heap_string_remove() but that would be slow and
42658 * pointless because we already know the slot.
42659 */
42660#if defined(DUK_USE_HEAPPTR16)
42661 heap->strtable16[i] = heap->heapptr_deleted16;
42662#else
42663 heap->strtable[i] = DUK_STRTAB_DELETED_MARKER(heap);
#define DUK_STRTAB_DELETED_MARKER(heap)
DUK_INTERNAL_DECL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h)
DUK_LOCAL void duk__sweep_stringtable_probe(duk_heap *heap, duk_size_t *out_count_keep)

◆ 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 17511 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_is_function().

◆ duk__tan()

DUK_LOCAL double duk__tan ( double x)

Definition at line 32561 of file duktape-1.5.2/src/duktape.c.

32563 {

◆ duk__timeclip()

DUK_LOCAL duk_double_t duk__timeclip ( duk_double_t x)

Definition at line 24870 of file duktape-1.5.2/src/duktape.c.

24875 {
24876 return (x >= -DUK_DATE_MSEC_100M_DAYS && x <= DUK_DATE_MSEC_100M_DAYS);
24877}
24878
24881}
24882
#define DUK_DATE_MSEC_100M_DAYS
#define DUK_DATE_MSEC_100M_DAYS_LEEWAY
DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_leeway_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 16845 of file duktape-1.5.2/src/duktape.c.

16862 {

◆ duk__to_new_array_length_checked()

DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked ( duk_hthread * thr)

Definition at line 50085 of file duktape-1.5.2/src/duktape.c.

50090 {
50091 res = (duk_uint32_t) DUK_TVAL_GET_FASTINT_U32(tv);
50092 } else {
50093 res = (duk_uint32_t) DUK_TVAL_GET_DOUBLE(tv);
50094 }
50095#else
50096 res = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv);
50097#endif /* DUK_USE_FASTINT */
50098
50099 return res;
50100}
50101
50103 duk_context *ctx = (duk_context *) thr;
50104 duk_uint32_t res;
DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked(duk_hthread *thr)

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 34941 of file duktape-1.5.2/src/duktape.c.

34943 :
34944#ifdef DUK_USE_REGEXP_SUPPORT
34945 if (is_regexp) {
34946 duk_pop(ctx);
34947 }
34948#endif
34949
34950 return 1;
34951}
34952
34953/*
34954 * Various
34955 */
34956
34957#ifdef DUK_USE_REGEXP_SUPPORT
34959 duk_hobject *h;
34960
34961 /* Shared helper for match() steps 3-4, search() steps 3-4. */
34962
34963 DUK_ASSERT(index >= 0);
DUK_LOCAL void duk__to_regexp_helper(duk_context *ctx, duk_idx_t index, duk_bool_t force_new)

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 25418 of file duktape-1.5.2/src/duktape.c.

25419 {
25420 DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d",
25421 (const char *) yearstr, (int) parts[DUK_DATE_IDX_MONTH], (int) parts[DUK_DATE_IDX_DAY]);
25422 } else {
25424 DUK_SPRINTF((char *) out_buf, "%02d:%02d:%02d.%03d%s",
25425 (int) parts[DUK_DATE_IDX_HOUR], (int) parts[DUK_DATE_IDX_MINUTE],
25426 (int) parts[DUK_DATE_IDX_SECOND], (int) parts[DUK_DATE_IDX_MILLISECOND],
25427 (const char *) tzstr);
25428 }
25429}
25430
25431/* Helper for string conversion calls: check 'this' binding, get the
25432 * internal time value, and format date and/or time in a few formats.
25433 * Return value allows tail calls.
25434 */
25436 duk_double_t d;
25438 duk_int_t tzoffset; /* seconds, doesn't fit into 16 bits */
25439 duk_bool_t rc;
25440 duk_uint8_t buf[DUK_BI_DATE_ISO8601_BUFSIZE];
25441
25442 DUK_UNREF(rc); /* unreferenced with some options */
25443
25444 d = duk__push_this_get_timeval_tzoffset(ctx, flags, &tzoffset);
25445 if (DUK_ISNAN(d)) {
25447 return 1;
25448 }
25450
25451 /* formatters always get one-based month/day-of-month */
25453 DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12);
25454 DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31);
25455
25456 if (flags & DUK_DATE_FLAG_TOSTRING_LOCALE) {
25457 /* try locale specific formatter; if it refuses to format the
25458 * string, fall back to an ISO 8601 formatted value in local
25459 * time.
25460 */
25461#if defined(DUK_USE_DATE_FORMAT_STRING)
25462 /* Contract, either:
25463 * - Push string to value stack and return 1
25464 * - Don't push anything and return 0
25465 */
25466
25467 rc = DUK_USE_DATE_FORMAT_STRING(ctx, parts, tzoffset, flags);
#define DUK_DATE_FLAG_TOSTRING_LOCALE
#define DUK_DATE_FLAG_TOSTRING_TIME
#define DUK_DATE_FLAG_ONEBASED
#define DUK_BI_DATE_ISO8601_BUFSIZE
#define DUK_STRIDX_INVALID_DATE
DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t 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 70127 of file duktape-1.5.2/src/duktape.c.

70133 {
70134 /* XXX: fastint */
70135 duk_double_t d = duk_js_tonumber(thr, tv); /* invalidates tv */
70136 return duk_js_tointeger_number(d);
70137}
70138
70139/*
70140 * ToInt32(), ToUint32(), ToUint16() (E5 Sections 9.5, 9.6, 9.7)
70141 */
70142
70143/* combined algorithm matching E5 Sections 9.5 and 9.6 */
70147
70148 if (c == DUK_FP_NAN || c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
70149 return 0.0;
70150 }
70151
70152
70153 /* x = sign(x) * floor(abs(x)), i.e. truncate towards zero, keep sign */
70155 x = DUK_FLOOR(DUK_FABS(x));
70156 if (s) {
70157 x = -x;
70158 }
70159
70160 /* NOTE: fmod(x) result sign is same as sign of x, which
70161 * differs from what Javascript wants (see Section 9.6).
70162 */
70163
DUK_INTERNAL_DECL duk_double_t duk_js_tonumber(duk_hthread *thr, duk_tval *tv)
DUK_LOCAL duk_double_t duk__toint32_touint32_helper(duk_double_t x, duk_bool_t is_toint32)

◆ duk__tonumber_string_raw()

DUK_LOCAL duk_double_t duk__tonumber_string_raw ( duk_hthread * thr)

Definition at line 69986 of file duktape-1.5.2/src/duktape.c.

70003 {
70004 duk_context *ctx = (duk_context *) thr;
70005 duk_small_uint_t s2n_flags;
70006 duk_double_t d;
70007
70008 /* Quite lenient, e.g. allow empty as zero, but don't allow trailing
70009 * garbage.
70010 */
70011 s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
#define 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 27803 of file duktape-1.5.2/src/duktape.c.

27805 {
27806 t = (int) xutf8_buf[i];
27807 DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr,
27808 &tfm_ctx->bw,
27810 (duk_uint8_t) duk_uc_nybbles[t >> 4],
27811 (duk_uint8_t) duk_uc_nybbles[t & 0x0f]);
27812 }
27813
27814 return;
27815
27816 uri_error:
27817 DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input");
27818}
27819
27821 const duk_uint8_t *reserved_table = (const duk_uint8_t *) udata;
27822 duk_small_uint_t utf8_blen;
27823 duk_codepoint_t min_cp;
27824 duk_small_int_t t; /* must be signed */
27826
27827 /* Maximum write size: XUTF8 path writes max DUK_UNICODE_MAX_XUTF8_LENGTH,
27828 * percent escape path writes max two times CESU-8 encoded BMP length.
27829 */
27830 DUK_BW_ENSURE(tfm_ctx->thr,
27831 &tfm_ctx->bw,
27834
27835 if (cp == (duk_codepoint_t) '%') {
27836 const duk_uint8_t *p = tfm_ctx->p;
27837 duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p); /* bytes left */
27838
27839 DUK_DDD(DUK_DDDPRINT("percent encoding, left=%ld", (long) left));
27840
27841 if (left < 2) {
27842 goto uri_error;
27843 }
27844
27845 t = duk__decode_hex_escape(p, 2);
27846 DUK_DDD(DUK_DDDPRINT("first byte: %ld", (long) t));
27847 if (t < 0) {
27848 goto uri_error;
27849 }
27850
27851 if (t < 0x80) {
27852 if (DUK__CHECK_BITMASK(reserved_table, t)) {
27853 /* decode '%xx' to '%xx' if decoded char in reserved set */
27854 DUK_ASSERT(tfm_ctx->p - 1 >= tfm_ctx->p_start);
27855 DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr,
27856 &tfm_ctx->bw,
27858 p[0],
27859 p[1]);
27860 } else {
27861 DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) t);
27862 }
27863 tfm_ctx->p += 2;
27864 return;
27865 }
27866
27867 /* Decode UTF-8 codepoint from a sequence of hex escapes. The
27868 * first byte of the sequence has been decoded to 't'.
27869 *
27870 * Note that UTF-8 validation must be strict according to the
27871 * specification: E5.1 Section 15.1.3, decode algorithm step
27872 * 4.d.vii.8. URIError from non-shortest encodings is also
27873 * specifically noted in the spec.
27874 */
27875
27876 DUK_ASSERT(t >= 0x80);
27877 if (t < 0xc0) {
27878 /* continuation byte */
27879 goto uri_error;
27880 } else if (t < 0xe0) {
27881 /* 110x xxxx; 2 bytes */
27882 utf8_blen = 2;
27883 min_cp = 0x80L;
27884 cp = t & 0x1f;
27885 } else if (t < 0xf0) {
27886 /* 1110 xxxx; 3 bytes */
27887 utf8_blen = 3;
27888 min_cp = 0x800L;
27889 cp = t & 0x0f;
27890 } else if (t < 0xf8) {
27891 /* 1111 0xxx; 4 bytes */
27892 utf8_blen = 4;
27893 min_cp = 0x10000L;
27894 cp = t & 0x07;
27895 } else {
27896 /* extended utf-8 not allowed for URIs */
27897 goto uri_error;
27898 }
27899
27900 if (left < utf8_blen * 3 - 1) {
27901 /* '%xx%xx...%xx', p points to char after first '%' */
27902 goto uri_error;
27903 }
27904
27905 p += 3;
27906 for (i = 1; i < utf8_blen; i++) {
27907 /* p points to digit part ('%xy', p points to 'x') */
27908 t = duk__decode_hex_escape(p, 2);
27909 DUK_DDD(DUK_DDDPRINT("i=%ld utf8_blen=%ld cp=%ld t=0x%02lx",
27910 (long) i, (long) utf8_blen, (long) cp, (unsigned long) t));
27911 if (t < 0) {
27912 goto uri_error;
27913 }
27914 if ((t & 0xc0) != 0x80) {
27915 goto uri_error;
27916 }
27917 cp = (cp << 6) + (t & 0x3f);
27918 p += 3;
27919 }
27920 p--; /* p overshoots */
27921 tfm_ctx->p = p;
27922
27923 DUK_DDD(DUK_DDDPRINT("final cp=%ld, min_cp=%ld", (long) cp, (long) min_cp));
27924
27925 if (cp < min_cp || cp > 0x10ffffL || (cp >= 0xd800L && cp <= 0xdfffL)) {
27926 goto uri_error;
27927 }
27928
27929 /* The E5.1 algorithm checks whether or not a decoded codepoint
27930 * is below 0x80 and perhaps may be in the "reserved" set.
27931 * This seems pointless because the single byte UTF-8 case is
27932 * handled separately, and non-shortest encodings are rejected.
27933 * So, 'cp' cannot be below 0x80 here, and thus cannot be in
27934 * the reserved set.
27935 */
27936
27937 /* utf-8 validation ensures these */
27938 DUK_ASSERT(cp >= 0x80L && cp <= 0x10ffffL);
27939
#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH
DUK_LOCAL duk_small_int_t duk__decode_hex_escape(const duk_uint8_t *p, duk_small_int_t n)
#define DUK_BW_WRITE_RAW_U8_3(thr, bw_ctx, val1, val2, val3)
#define DUK_BW_ENSURE(thr, bw_ctx, sz)
DUK_INTERNAL const duk_uint8_t duk_uc_nybbles[16]
DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp)
#define DUK_ASC_PERCENT
#define DUK__CHECK_BITMASK(table, cp)

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 27741 of file duktape-1.5.2/src/duktape.c.

27747 {
27748 cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end);
27749 callback(tfm_ctx, udata, cp);
27750 }
27751
27752 DUK_BW_COMPACT(thr, &tfm_ctx->bw);
27753
27754 duk_to_string(ctx, -1);
27755 return 1;
27756}
27757
27759 duk_uint8_t xutf8_buf[DUK_UNICODE_MAX_XUTF8_LENGTH];
27760 duk_small_int_t len;
27761 duk_codepoint_t cp1, cp2;
27762 duk_small_int_t i, t;
27763 const duk_uint8_t *unescaped_table = (const duk_uint8_t *) udata;
27764
27765 /* UTF-8 encoded bytes escaped as %xx%xx%xx... -> 3 * nbytes.
27766 * Codepoint range is restricted so this is a slightly too large
27767 * but doesn't matter.
27768 */
27769 DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 3 * DUK_UNICODE_MAX_XUTF8_LENGTH);
27770
27771 if (cp < 0) {
27772 goto uri_error;
27773 } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(unescaped_table, cp)) {
27774 DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp);
27775 return;
27776 } else if (cp >= 0xdc00L && cp <= 0xdfffL) {
27777 goto uri_error;
27778 } else if (cp >= 0xd800L && cp <= 0xdbffL) {
27779 /* Needs lookahead */
27780 if (duk_unicode_decode_xutf8(tfm_ctx->thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end, (duk_ucodepoint_t *) &cp2) == 0) {
27781 goto uri_error;
27782 }
27783 if (!(cp2 >= 0xdc00L && cp2 <= 0xdfffL)) {
27784 goto uri_error;
27785 }
27786 cp1 = cp;
27787 cp = ((cp1 - 0xd800L) << 10) + (cp2 - 0xdc00L) + 0x10000L;
27788 } else if (cp > 0x10ffffL) {
27789 /* Although we can allow non-BMP characters (they'll decode
27790 * back into surrogate pairs), we don't allow extended UTF-8
27791 * characters; they would encode to URIs which won't decode
27792 * back because of strict UTF-8 checks in URI decoding.
27793 * (However, we could just as well allow them here.)
27794 */
27795 goto uri_error;
27796 } else {
27797 /* Non-BMP characters within valid UTF-8 range: encode as is.
27798 * They'll decode back into surrogate pairs if the escaped
27799 * output is decoded.
27800 */
27801 ;
DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp)
#define DUK_BW_COMPACT(thr, bw_ctx)
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__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 27942 of file duktape-1.5.2/src/duktape.c.

27946 {
27947 DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp);
27948 }
27949 } else {
27950 DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp);
27951 }
27952 return;
27953
27954 uri_error:
27955 DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input");
27956}
27957
27958#ifdef DUK_USE_SECTION_B
27960 DUK_UNREF(udata);
27961
27962 DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 6);
27963
27964 if (cp < 0) {
27965 goto esc_error;
27966 } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(duk__escape_unescaped_table, cp)) {
27967 DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp);
27968 } else if (cp < 0x100L) {
27969 DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr,
27970 &tfm_ctx->bw,
27971 (duk_uint8_t) DUK_ASC_PERCENT,
27972 (duk_uint8_t) duk_uc_nybbles[cp >> 4],
27973 (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]);
27974 } else if (cp < 0x10000L) {
27975 DUK_BW_WRITE_RAW_U8_6(tfm_ctx->thr,
27976 &tfm_ctx->bw,
27977 (duk_uint8_t) DUK_ASC_PERCENT,
27978 (duk_uint8_t) DUK_ASC_LC_U,
27979 (duk_uint8_t) duk_uc_nybbles[cp >> 12],
#define DUK_BW_WRITE_RAW_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6)
DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp)
DUK_LOCAL const duk_uint8_t duk__escape_unescaped_table[16]

◆ 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 27981 of file duktape-1.5.2/src/duktape.c.

27983 {
27984 /* Characters outside BMP cannot be escape()'d. We could
27985 * encode them as surrogate pairs (for codepoints inside
27986 * valid UTF-8 range, but not extended UTF-8). Because
27987 * escape() and unescape() are legacy functions, we don't.
27988 */
27989 goto esc_error;
27990 }
27991
27992 return;
27993
27994 esc_error:
27995 DUK_ERROR_TYPE(tfm_ctx->thr, "invalid input");
27996}
27997
28000
28001 DUK_UNREF(udata);
28002
DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp)

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 27713 of file duktape-1.5.2/src/duktape.c.

27713 {
27714 duk_small_int_t ch;
27715 duk_small_int_t t = 0;
27716
27717 while (n > 0) {
27718 t = t * 16;
27719 ch = (duk_small_int_t) duk_hex_dectab[*p++];
27720 if (DUK_LIKELY(ch >= 0)) {
27721 t += ch;
27722 } else {
27723 return -1;
27724 }
27725 n--;
27726 }
27727 return t;
27728}
27729
27730DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, const void *udata) {
27731 duk_hthread *thr = (duk_hthread *) ctx;
27732 duk__transform_context tfm_ctx_alloc;
27733 duk__transform_context *tfm_ctx = &tfm_ctx_alloc;
27734 duk_codepoint_t cp;
27735
27736 tfm_ctx->thr = thr;
27737
27738 tfm_ctx->h_str = duk_to_hstring(ctx, 0);
27739 DUK_ASSERT(tfm_ctx->h_str != NULL);
DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, const void *udata)

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 18352 of file duktape-1.5.2/src/duktape.c.

18357 {
18358 duk_hthread *thr = (duk_hthread *) ctx;
18360 if (!target_ctx) {
18362 return; /* not reached */
18363 }
18364 duk_push_hobject(ctx, (duk_hobject *) target_ctx);
18365 duk__push_stash(ctx);
18366}
18367
DUK_LOCAL void duk__push_stash(duk_context *ctx)

◆ duk__tval_number_to_arr_idx()

DUK_LOCAL duk_uint32_t duk__tval_number_to_arr_idx ( duk_tval * tv)

Definition at line 47269 of file duktape-1.5.2/src/duktape.c.

47286 {
47287 duk_double_t dbl;
47288 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 25605 of file duktape-1.5.2/src/duktape.c.

25610 {
25611 return duk__set_this_timeval_from_dparts(ctx, dparts, flags_and_maxnargs);
25612 } else {
25613 /* Internal timevalue is already NaN, so don't touch it. */
25614 duk_push_nan(ctx);
25615 return 1;
25616 }
25617}
25618
25619/* Apply ToNumber() to specified index; if ToInteger(val) in [0,99], add
25620 * 1900 and replace value at idx_val.
25621 */
25623 duk_double_t d;
25624
25625 /* XXX: idx_val would fit into 16 bits, but using duk_small_uint_t
25626 * might not generate better code due to casting.
DUK_EXTERNAL void duk_push_nan(duk_context *ctx)

◆ duk__unemit_1()

DUK_LOCAL_DECL void duk__unemit_1 ( duk_json_enc_ctx * js_ctx)

Definition at line 29966 of file duktape-1.5.2/src/duktape.c.

29967 {
29968 DUK_BW_WRITE_ENSURE_CSTRING(js_ctx->thr, &js_ctx->bw, str);
29969}
#define DUK_BW_WRITE_ENSURE_CSTRING(thr, bw_ctx, val)

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 10326 of file duktape-1.5.2/src/duktape.c.

10343 {
10344 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 10346 of file duktape-1.5.2/src/duktape.c.

10347 {
10348 return t;
10349 }
10350 t = (duk_uint32_t) duk_bd_decode(bd_ctx, 8);
10351 if (t <= 0xfdU) {
10352 return t + 0x0f;
10353 }
10354 if (t == 0xfeU) {
10355 t = (duk_uint32_t) duk_bd_decode(bd_ctx, 12);
10356 return t + 0x0fU + 0xfeU;
10357 } else {
10358 t = (duk_uint32_t) duk_bd_decode(bd_ctx, 24);
10359 return t + 0x0fU + 0xfeU + 0x1000UL;
10360 }
10361}
10362
10363DUK_LOCAL duk_small_int_t duk__uni_range_match(const duk_uint8_t *unitab, duk_size_t unilen, duk_codepoint_t cp) {
10364 duk_bitdecoder_ctx bd_ctx;
10365 duk_codepoint_t prev_re;
10366
10367 DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
10368 bd_ctx.data = (const duk_uint8_t *) unitab;
10369 bd_ctx.length = (duk_size_t) unilen;
10370
10371 prev_re = 0;
10372 for (;;) {
10373 duk_codepoint_t r1, r2;
10374 r1 = (duk_codepoint_t) duk__uni_decode_value(&bd_ctx);
10375 if (r1 == 0) {
10376 break;
10377 }
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__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 60065 of file duktape-1.5.2/src/duktape.c.

60076 : flags=0x%08lx, id=%ld, name=%!O, catch_depth=%ld, pc_label=%ld",
60077 (unsigned long) li->flags, (long) li->label_id, (duk_heaphdr *) li->h_label,
60078 (long) li->catch_depth, (long) li->pc_label));
60079}
60080
60081/* Update all labels with matching label_id. */
60082DUK_LOCAL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags) {
60083 duk_uint8_t *p;
60084 duk_labelinfo *li_start, *li;
60085
60086 p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, comp_ctx->curr_func.h_labelinfos);
60087 li_start = (duk_labelinfo *) (void *) p;
60088 li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
60089

◆ duk__update_lineinfo_currtoken()

DUK_LOCAL void duk__update_lineinfo_currtoken ( duk_compiler_ctx * comp_ctx)

Definition at line 58569 of file duktape-1.5.2/src/duktape.c.

58569 {
58570 goto fail_bc_limit;
58571 }
58572#endif
58573#endif
58574
58575 return;
58576
58577 fail_bc_limit:
58579}
58580
58581/* Update function min/max line from current token. Needed to improve
58582 * function line range information for debugging, so that e.g. opening
58583 * curly brace is covered by line range even when no opcodes are emitted
58584 * for the line containing the brace.
58585 */

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 78513 of file duktape-1.5.2/src/duktape.c.

78515 {
78516 /* utf-8 continuation bytes have the form 10xx xxxx */
78517 break;
78518 }
78519 }
78520 count--;
78521 }
78522 *ptr = p;
78523 return p;
78524
78525 fail:
78527 return NULL; /* never here */
78528}
78529
78530DUK_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) {
78531 const duk_uint8_t *p;
78532
78533 p = *ptr;
78534 if (p < ptr_start || p >= ptr_end) {
78535 goto fail;
78536 }
78537
78538 while (count > 0) {
78539 for (;;) {
78540 p++;
78541
78542 /* 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 78483 of file duktape-1.5.2/src/duktape.c.

78484 {
78485 return (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end);
78486}
78487
78488DUK_LOCAL duk_int32_t duk__bc_get_i32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc) {
78489 duk_uint32_t t;
78490
78491 /* signed integer encoding needed to work with UTF-8 */
78492 t = (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end);
78493 if (t & 1) {
78494 return -((duk_int32_t) (t >> 1));
78495 } else {
78496 return (duk_int32_t) (t >> 1);
78497 }
78498}
78499
78500DUK_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) {
78501 const duk_uint8_t *p;
78502
78503 /* Note: allow backtracking from p == ptr_end */
78504 p = *ptr;
78505 if (p < ptr_start || p > ptr_end) {
78506 goto fail;
78507 }
78508
78509 while (count > 0) {
78510 for (;;) {
78511 p--;
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)

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 65370 of file duktape-1.5.2/src/duktape.c.

65375 {
65376 /*
65377 * Ecmascript modulus ('%') does not match IEEE 754 "remainder"
65378 * operation (implemented by remainder() in C99) but does seem
65379 * to match ANSI C fmod().
65380 *
65381 * Compare E5 Section 11.5.3 and "man fmod".
65382 */
65383
65384 return (duk_double_t) DUK_FMOD((double) d1, (double) d2);
65385}
65386
65388 /*
65389 * Addition operator is different from other arithmetic
65390 * operations in that it also provides string concatenation.
65391 * Hence it is implemented separately.
65392 *
65393 * There is a fast path for number addition. Other cases go
65394 * through potentially multiple coercions as described in the
65395 * E5 specification. It may be possible to reduce the number
65396 * of coercions, but this must be done carefully to preserve
65397 * the exact semantics.
65398 *
65399 * E5 Section 11.6.1.
65400 *
65401 * Custom types also have special behavior implemented here.
65402 */
65403
65404 duk_context *ctx = (duk_context *) thr;
65406
65407 DUK_ASSERT(thr != NULL);
65408 DUK_ASSERT(ctx != NULL);
65409 DUK_ASSERT(tv_x != NULL); /* may be reg or const */
65410 DUK_ASSERT(tv_y != NULL); /* may be reg or const */
65411 DUK_ASSERT_DISABLE(idx_z >= 0); /* unsigned */
65412 DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
65413
65414 /*
65415 * Fast paths
65416 */
65417
65418#if defined(DUK_USE_FASTINT)
65419 if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
65420 duk_int64_t v1, v2, v3;
65421 duk_int32_t v3_hi;
65422 duk_tval *tv_z;
65423
65424 /* Input values are signed 48-bit so we can detect overflow
65425 * reliably from high bits or just a comparison.
65426 */
65427
65428 v1 = DUK_TVAL_GET_FASTINT(tv_x);
65429 v2 = DUK_TVAL_GET_FASTINT(tv_y);
65430 v3 = v1 + v2;
65431 v3_hi = (duk_int32_t) (v3 >> 32);
65432 if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) {
65433 tv_z = thr->valstack_bottom + idx_z;
65434 DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, v3); /* side effects */
65435 return;
65436 } else {
65437 /* overflow, fall through */
65438 ;
65439 }
65440 }
65441#endif /* DUK_USE_FASTINT */
65442
65443 if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
65444 duk_tval *tv_z;
65445
65446 du.d = DUK_TVAL_GET_NUMBER(tv_x) + DUK_TVAL_GET_NUMBER(tv_y);
65449
65450 tv_z = thr->valstack_bottom + idx_z;
65451 DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, du.d); /* side effects */
65452 return;
65453 }
65454
65455 /*
65456 * Slow path: potentially requires function calls for coercion
65457 */
65458
65459 duk_push_tval(ctx, tv_x);
65460 duk_push_tval(ctx, tv_y);
65461 duk_to_primitive(ctx, -2, DUK_HINT_NONE); /* side effects -> don't use tv_x, tv_y after */
65463
65464 /* As a first approximation, buffer values are coerced to strings
65465 * for addition. This means that adding two buffers currently
65466 * results in a string.
65467 */
65470 duk_to_string(ctx, -2);
65471 duk_to_string(ctx, -1);
65472 duk_concat(ctx, 2); /* [... s1 s2] -> [... s1+s2] */
65473 duk_replace(ctx, (duk_idx_t) idx_z); /* side effects */
65474 } else {
65475 duk_double_t d1, d2;
#define DUK_TYPE_MASK_STRING
#define DUK_DBLUNION_IS_NORMALIZED(u)
DUK_EXTERNAL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint)

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 65477 of file duktape-1.5.2/src/duktape.c.

65494 {
65495 /*
65496 * Arithmetic operations other than '+' have number-only semantics
65497 * and are implemented here. The separate switch-case here means a
65498 * "double dispatch" of the arithmetic opcode, but saves code space.
65499 *
65500 * E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3.
65501 */
65502
65503 duk_context *ctx = (duk_context *) thr;
65504 duk_tval *tv_z;
65505 duk_double_t d1, d2;
65507
65508 DUK_ASSERT(thr != NULL);
65509 DUK_ASSERT(ctx != NULL);
65510 DUK_ASSERT(tv_x != NULL); /* may be reg or const */
65511 DUK_ASSERT(tv_y != NULL); /* may be reg or const */
65512 DUK_ASSERT_DISABLE(idx_z >= 0); /* unsigned */
65513 DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
65514
65515#if defined(DUK_USE_FASTINT)
65516 if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
65517 duk_int64_t v1, v2, v3;
65518 duk_int32_t v3_hi;
65519
65520 v1 = DUK_TVAL_GET_FASTINT(tv_x);
65521 v2 = DUK_TVAL_GET_FASTINT(tv_y);
65522
65523 switch (opcode) {
65524 case DUK_OP_SUB: {
65525 v3 = v1 - v2;
65526 break;
65527 }
65528 case DUK_OP_MUL: {
65529 /* Must ensure result is 64-bit (no overflow); a
65530 * simple and sufficient fast path is to allow only
65531 * 32-bit inputs. Avoid zero inputs to avoid
65532 * negative zero issues (-1 * 0 = -0, for instance).
65533 */
65534 if (v1 >= -0x80000000LL && v1 <= 0x7fffffffLL && v1 != 0 &&
65535 v2 >= -0x80000000LL && v2 <= 0x7fffffffLL && v2 != 0) {
65536 v3 = v1 * v2;
65537 } else {
65538 goto skip_fastint;
65539 }
65540 break;
65541 }
65542 case DUK_OP_DIV: {
65543 /* Don't allow a zero divisor. Fast path check by
65544 * "verifying" with multiplication. Also avoid zero
65545 * dividend to avoid negative zero issues (0 / -1 = -0
65546 * for instance).
65547 */
65548 if (v1 == 0 || v2 == 0) {
65549 goto skip_fastint;
65550 }
65551 v3 = v1 / v2;
65552 if (v3 * v2 != v1) {
65553 goto skip_fastint;
65554 }
65555 break;
65556 }
65557 case DUK_OP_MOD: {
65558 /* Don't allow a zero divisor. Restrict both v1 and
65559 * v2 to positive values to avoid compiler specific
65560 * behavior.
65561 */
65562 if (v1 < 1 || v2 < 1) {
65563 goto skip_fastint;
65564 }
65565 v3 = v1 % v2;
65566 DUK_ASSERT(v3 >= 0);
65567 DUK_ASSERT(v3 < v2);
65568 DUK_ASSERT(v1 - (v1 / v2) * v2 == v3);
65569 break;
65570 }
65571 default: {
65573 goto skip_fastint;
65574 }
65575 }
65576
65577 v3_hi = (duk_int32_t) (v3 >> 32);
65578 if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) {
65579 tv_z = thr->valstack_bottom + idx_z;
65580 DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, v3); /* side effects */
65581 return;
65582 }
65583 /* fall through if overflow etc */
65584 }
65585 skip_fastint:
65586#endif /* DUK_USE_FASTINT */
65587
65588 if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
65589 /* fast path */
65590 d1 = DUK_TVAL_GET_NUMBER(tv_x);
65591 d2 = DUK_TVAL_GET_NUMBER(tv_y);
65592 } else {
65593 duk_push_tval(ctx, tv_x);
65594 duk_push_tval(ctx, tv_y);
65595 d1 = duk_to_number(ctx, -2); /* side effects */
65596 d2 = duk_to_number(ctx, -1);
65597 DUK_ASSERT(duk_is_number(ctx, -2));
65598 DUK_ASSERT(duk_is_number(ctx, -1));
65601 duk_pop_2(ctx);
65602 }
65603
65604 switch (opcode) {
65605 case DUK_OP_SUB: {
65606 du.d = d1 - d2;
65607 break;
65608 }
65609 case DUK_OP_MUL: {
65610 du.d = d1 * d2;
65611 break;
65612 }
65613 case DUK_OP_DIV: {
65614 du.d = d1 / d2;
65615 break;
65616 }
65617 case DUK_OP_MOD: {
#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval)

◆ 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 65739 of file duktape-1.5.2/src/duktape.c.

65740 :
65741 tv_z = thr->valstack_bottom + idx_z;
65742 DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, fi3); /* side effects */
65743#else
65744 d3 = (duk_double_t) i3;
65745
65746 result_set:
65747 DUK_ASSERT(!DUK_ISNAN(d3)); /* 'd3' is never NaN, so no need to normalize */
65748 DUK_ASSERT_DOUBLE_IS_NORMALIZED(d3); /* always normalized */
65749
65750 tv_z = thr->valstack_bottom + idx_z;
65751 DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, d3); /* side effects */
65752#endif
65753}
65754
65755/* In-place unary operation. */
65757 /*
65758 * Arithmetic operations other than '+' have number-only semantics
65759 * and are implemented here. The separate switch-case here means a
65760 * "double dispatch" of the arithmetic opcode, but saves code space.
65761 *
65762 * E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3.
65763 */
65764
65765 duk_context *ctx = (duk_context *) thr;
65766 duk_double_t d1;
65768
65769 DUK_ASSERT(thr != NULL);
65770 DUK_ASSERT(ctx != NULL);
65771 DUK_ASSERT(opcode == DUK_EXTRAOP_UNM || opcode == DUK_EXTRAOP_UNP);
65772 DUK_ASSERT(tv_x != NULL);
65773 DUK_ASSERT(idx_x >= 0);
65774
65775#if defined(DUK_USE_FASTINT)
65776 if (DUK_TVAL_IS_FASTINT(tv_x)) {
65777 duk_int64_t v1, v2;
65778
65779 v1 = DUK_TVAL_GET_FASTINT(tv_x);
65780 if (opcode == DUK_EXTRAOP_UNM) {
65781 /* The smallest fastint is no longer 48-bit when
65782 * negated. Positive zero becames negative zero
65783 * (cannot be represented) when negated.
65784 */
65785 if (DUK_LIKELY(v1 != DUK_FASTINT_MIN && v1 != 0)) {
65786 v2 = -v1;
65787 DUK_TVAL_SET_FASTINT(tv_x, v2); /* no refcount changes */
65788 return;
65789 }
65790 } else {
65791 /* ToNumber() for a fastint is a no-op. */
65792 DUK_ASSERT(opcode == DUK_EXTRAOP_UNP);
65793 return;
65794 }
65795 /* fall through if overflow etc */
65796 }
65797#endif /* DUK_USE_FASTINT */
65798
65799 if (!DUK_TVAL_IS_NUMBER(tv_x)) {
65800 duk_to_number(ctx, idx_x); /* side effects, perform in-place */
65801 tv_x = DUK_GET_TVAL_POSIDX(ctx, idx_x);
65802 DUK_ASSERT(tv_x != NULL);
65804 }
65805
65806 d1 = DUK_TVAL_GET_NUMBER(tv_x);
65807 if (opcode == DUK_EXTRAOP_UNM) {
65808 du.d = -d1;
65809 } 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 65619 of file duktape-1.5.2/src/duktape.c.

65621 : {
65623 du.d = DUK_DOUBLE_NAN; /* should not happen */
65624 break;
65625 }
65626 }
65627
65628 /* important to use normalized NaN with 8-byte tagged types */
65631
65632 tv_z = thr->valstack_bottom + idx_z;
65633 DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, du.d); /* side effects */
65634}
65635
65637 /*
65638 * Binary bitwise operations use different coercions (ToInt32, ToUint32)
65639 * depending on the operation. We coerce the arguments first using
65640 * ToInt32(), and then cast to an 32-bit value if necessary. Note that
65641 * such casts must be correct even if there is no native 32-bit type
65642 * (e.g., duk_int32_t and duk_uint32_t are 64-bit).
65643 *
65644 * E5 Sections 11.10, 11.7.1, 11.7.2, 11.7.3
65645 */
65646
65647 duk_context *ctx = (duk_context *) thr;
65648 duk_tval *tv_z;
65649 duk_int32_t i1, i2, i3;
65650 duk_uint32_t u1, u2, u3;
65651#if defined(DUK_USE_FASTINT)
65652 duk_int64_t fi3;
65653#else
65654 duk_double_t d3;
65655#endif
65656
65657 DUK_ASSERT(thr != NULL);
65658 DUK_ASSERT(ctx != NULL);
65659 DUK_ASSERT(tv_x != NULL); /* may be reg or const */
65660 DUK_ASSERT(tv_y != NULL); /* may be reg or const */
65661 DUK_ASSERT_DISABLE(idx_z >= 0); /* unsigned */
65662 DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
65663
65664#if defined(DUK_USE_FASTINT)
65665 if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
65666 i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x);
65667 i2 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_y);
65668 }
65669 else
65670#endif /* DUK_USE_FASTINT */
65671 {
65672 duk_push_tval(ctx, tv_x);
65673 duk_push_tval(ctx, tv_y);
65674 i1 = duk_to_int32(ctx, -2);
65675 i2 = duk_to_int32(ctx, -1);
65676 duk_pop_2(ctx);
65677 }
65678
65679 switch (opcode) {
65680 case DUK_OP_BAND: {
65681 i3 = i1 & i2;
65682 break;
65683 }
65684 case DUK_OP_BOR: {
65685 i3 = i1 | i2;
65686 break;
65687 }
65688 case DUK_OP_BXOR: {
65689 i3 = i1 ^ i2;
65690 break;
65691 }
65692 case DUK_OP_BASL: {
65693 /* Signed shift, named "arithmetic" (asl) because the result
65694 * is signed, e.g. 4294967295 << 1 -> -2. Note that result
65695 * must be masked.
65696 */
65697
65698 u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
65699 i3 = i1 << (u2 & 0x1f); /* E5 Section 11.7.1, steps 7 and 8 */
65700 i3 = i3 & ((duk_int32_t) 0xffffffffUL); /* Note: left shift, should mask */
65701 break;
65702 }
65703 case DUK_OP_BASR: {
65704 /* signed shift */
65705
65706 u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
65707 i3 = i1 >> (u2 & 0x1f); /* E5 Section 11.7.2, steps 7 and 8 */
65708 break;
65709 }
65710 case DUK_OP_BLSR: {
65711 /* unsigned shift */
65712
65713 u1 = ((duk_uint32_t) i1) & 0xffffffffUL;
65714 u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
65715
65716 /* special result value handling */
65717 u3 = u1 >> (u2 & 0x1f); /* E5 Section 11.7.2, steps 7 and 8 */
65718#if defined(DUK_USE_FASTINT)
65719 fi3 = (duk_int64_t) u3;
65720 goto fastint_result_set;
65721#else
65722 d3 = (duk_double_t) u3;
65723 goto result_set;
65724#endif
65725 }
65726 default: {
65728 i3 = 0; /* should not happen */
65729 break;
65730 }
65731 }
65732
65733#if defined(DUK_USE_FASTINT)
65734 /* Result is always fastint compatible. */
65735 /* XXX: Set 32-bit result (but must then handle signed and
65736 * unsigned results separately).
DUK_EXTERNAL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index)

◆ 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 65811 of file duktape-1.5.2/src/duktape.c.

65828 {
65829 /*
65830 * E5 Section 11.4.8
65831 */
65832
65833 duk_context *ctx = (duk_context *) thr;
65834 duk_tval *tv_z;
65835 duk_int32_t i1, i2;
65836#if !defined(DUK_USE_FASTINT)
65837 duk_double_t d2;
65838#endif
65839
65840 DUK_ASSERT(thr != NULL);
65841 DUK_ASSERT(ctx != NULL);
65842 DUK_ASSERT(tv_x != NULL); /* may be reg or const */
65843 DUK_ASSERT_DISABLE(idx_z >= 0);
65844 DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
65845
65846#if defined(DUK_USE_FASTINT)
65847 if (DUK_TVAL_IS_FASTINT(tv_x)) {
65848 i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x);
65849 }
65850 else
65851#endif /* DUK_USE_FASTINT */
65852 {
65853 duk_push_tval(ctx, tv_x);
65854 i1 = duk_to_int32(ctx, -1);
65855 duk_pop(ctx);
65856 }

◆ 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 65858 of file duktape-1.5.2/src/duktape.c.

65875 {
65876 /*
65877 * E5 Section 11.4.9
65878 */
65879

◆ 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 24911 of file duktape-1.5.2/src/duktape.c.

24917 {
24918 /* Note: in integer arithmetic, (x / 4) is same as floor(x / 4) for non-negative
24919 * values, but is incorrect for negative ones.
24920 */
24921 return 365 * (year - 1970)
24922 + duk__div_floor(year - 1969, 4)
24923 - duk__div_floor(year - 1901, 100)
24924 + duk__div_floor(year - 1601, 400);
24925}
24926
24927/* Given a day number, determine year and day-within-year. */
24929 duk_int_t year;
24930 duk_int_t diff_days;
24931
24932 /* estimate year upwards (towards positive infinity), then back down;
24933 * two iterations should be enough
24934 */
24935
24936 if (day >= 0) {
24937 year = 1970 + day / 365;
24938 } else {
24939 year = 1970 + day / 366;
24940 }
24941
24942 for (;;) {
24943 diff_days = duk__day_from_year(year) - day;
DUK_LOCAL duk_int_t duk__year_from_day(duk_int_t day, duk_small_int_t *out_day_within_year)
DUK_LOCAL duk_int_t duk__day_from_year(duk_int_t year)
DUK_LOCAL duk_int_t duk__div_floor(duk_int_t a, duk_int_t b)

◆ duk_alloc()

DUK_EXTERNAL void * duk_alloc ( duk_context * ctx,
duk_size_t size )

Definition at line 14244 of file duktape-1.5.2/src/duktape.c.

14245 {
14246 duk_hthread *thr = (duk_hthread *) ctx;
14247
14249
14250 DUK_FREE_RAW(thr->heap, ptr);
#define DUK_FREE_RAW(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 14220 of file duktape-1.5.2/src/duktape.c.

14221 {
14222 va_list ap;
14223
14225
14226 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 13337 of file duktape-1.5.2/src/duktape.c.

13337 {
13338 goto type_error;
13339 }
13340 dstlen = (srclen + 2) / 3 * 4;
13341 dst = (duk_uint8_t *) duk_push_fixed_buffer(ctx, dstlen);
13342
13343 duk__base64_encode_helper((const duk_uint8_t *) src, srclen, dst);
13344
13345 ret = duk_to_string(ctx, -1);
13346 duk_replace(ctx, index);
13347 return ret;
13348
13349 type_error:
13351 return NULL; /* never here */
13352}
13353
13355 duk_hthread *thr = (duk_hthread *) ctx;
13356 const duk_uint8_t *src;
13357 duk_size_t srclen;
13358 duk_size_t dstlen;
13359 duk_uint8_t *dst;
13360 duk_uint8_t *dst_final;
13361 duk_bool_t retval;
13362
13364
13365 /* XXX: optimize for buffer inputs: no need to coerce to a string
13366 * which causes an unnecessary interning.
13367 */
13368
13370 src = duk__prep_codec_arg(ctx, index, &srclen);
13371
13372 /* Computation must not wrap, only srclen + 3 is at risk of
13373 * wrapping because after that the number gets smaller.
13374 * This limit works for 32-bit size_t:
13375 * 0x100000000 - 3 - 1 = 4294967292
13376 */
13377 if (srclen > 4294967292UL) {
13378 goto type_error;
13379 }
DUK_LOCAL const duk_uint8_t * duk__prep_codec_arg(duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index)
#define DUK_STR_ENCODE_FAILED

◆ duk_base64_encode()

DUK_EXTERNAL const char * duk_base64_encode ( duk_context * ctx,
duk_idx_t index )

Definition at line 13297 of file duktape-1.5.2/src/duktape.c.

13298 {
13299 /* Here we'd have the option of decoding unpadded base64
13300 * (e.g. "xxxxyy" instead of "xxxxyy==". Currently not
13301 * accepted.
13302 */
13303 goto error;
13304 }
13305
13306 *out_dst_final = dst;
13307 return 1;
13308
13309 error:
13310 return 0;
13311}
13312#endif /* DUK_USE_BASE64_FASTPATH */
13313
13315 duk_hthread *thr = (duk_hthread *) ctx;
13316 const duk_uint8_t *src;
13317 duk_size_t srclen;
13318 duk_size_t dstlen;
13319 duk_uint8_t *dst;
13320 const char *ret;
13321
13323
13324 /* XXX: optimize for string inputs: no need to coerce to a buffer
13325 * which makes a copy of the input.
13326 */
13327
13329 src = duk__prep_codec_arg(ctx, index, &srclen);
13330 /* Note: for srclen=0, src may be NULL */
13331
13332 /* Computation must not wrap; this limit works for 32-bit size_t:
13333 * >>> srclen = 3221225469
13334 * >>> '%x' % ((srclen + 2) / 3 * 4)
13335 * 'fffffffc'
DUK_EXTERNAL const char * duk_base64_encode(duk_context *ctx, duk_idx_t index)

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 86092 of file duktape-1.5.2/src/duktape.c.

86109 {
86110 duk_small_int_t shift;
86111 duk_uint32_t mask;
86112 duk_uint32_t tmp;
86113
86114 /* Note: cannot read more than 24 bits without possibly shifting top bits out.
86115 * Fixable, but adds complexity.
86116 */
86117 DUK_ASSERT(bits >= 1 && bits <= 24);
86118
86119 while (ctx->currbits < bits) {
86120#if 0
86121 DUK_DDD(DUK_DDDPRINT("decode_bits: shift more data (bits=%ld, currbits=%ld)",
86122 (long) bits, (long) ctx->currbits));
86123#endif
86124 ctx->currval <<= 8;
86125 if (ctx->offset < ctx->length) {
86126 /* If ctx->offset >= ctx->length, we "shift zeroes in"
86127 * instead of croaking.
86128 */
86129 ctx->currval |= ctx->data[ctx->offset++];
86130 }
86131 ctx->currbits += 8;
86132 }
86133#if 0
86134 DUK_DDD(DUK_DDDPRINT("decode_bits: bits=%ld, currbits=%ld, currval=0x%08lx",
86135 (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()

Definition at line 86137 of file duktape-1.5.2/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 86145 of file duktape-1.5.2/src/duktape.c.

86147 : %ld bits -> 0x%08lx (%ld), currbits=%ld, currval=0x%08lx",
86148 (long) bits, (unsigned long) tmp, (long) tmp, (long) ctx->currbits, (unsigned long) ctx->currval));
86149#endif
86150
86151 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 86159 of file duktape-1.5.2/src/duktape.c.

86162 {
86163 if (duk_bd_decode_flag(ctx)) {
86164 return (duk_int32_t) duk_bd_decode(ctx, bits);
86165 } else {
86166 return def_value;
86167 }
86168}
86169#line 1 "duk_util_bitencoder.c"
86170/*
86171 * Bitstream encoder.
86172 */
86173
86174/* include removed: duk_internal.h */
86175
86176DUK_INTERNAL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits) {
86177 duk_uint8_t tmp;
86178
86179 DUK_ASSERT(ctx != NULL);
86180 DUK_ASSERT(ctx->currbits < 8);
86181
86182 /* 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 86184 of file duktape-1.5.2/src/duktape.c.

86188 {
86189 if (ctx->offset < ctx->length) {
86190 tmp = (duk_uint8_t) ((ctx->currval >> (ctx->currbits - 8)) & 0xff);
86191 ctx->data[ctx->offset++] = tmp;
86192 } else {
86193 /* If buffer has been exhausted, truncate bitstream */
86194 ctx->truncated = 1;
86195 }

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 20087 of file duktape-1.5.2/src/duktape.c.

20088 {
20089 /* Range limited to [0, 0x7fffffff] range, i.e. range that can be
20090 * represented with duk_int32_t. Use this when the method doesn't
20091 * handle the full 32-bit unsigned range correctly.
20092 */
20093 duk_uint32_t ret = duk__push_this_obj_len_u32(ctx);
20094 if (DUK_UNLIKELY(ret >= 0x80000000UL)) {
20096 }
20097 return ret;
20098}
20099
20100/*
20101 * Constructor
20102 */
20103
20105 duk_idx_t nargs;
20106 duk_double_t d;
20107 duk_uint32_t len;
20108 duk_idx_t i;
20109
20110 nargs = duk_get_top(ctx);
20111 duk_push_array(ctx);
20112
20113 if (nargs == 1 && duk_is_number(ctx, 0)) {
20114 /* XXX: expensive check (also shared elsewhere - so add a shared internal API call?) */
20115 d = duk_get_number(ctx, 0);
20116 len = duk_to_uint32(ctx, 0);
20117 if (((duk_double_t) len) != d) {
20118 return DUK_RET_RANGE_ERROR;
20119 }
20120
20121 /* XXX: if 'len' is low, may want to ensure array part is kept:
20122 * the caller is likely to want a dense array.
20123 */
20124 duk_push_u32(ctx, len);
#define DUK_RET_RANGE_ERROR
#define DUK_STR_ARRAY_LENGTH_OVER_2G
DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32(duk_context *ctx)
DUK_EXTERNAL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor(duk_context *ctx)

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 20130 of file duktape-1.5.2/src/duktape.c.

20133 {
20134 duk_dup(ctx, i);
20136 }

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 20181 of file duktape-1.5.2/src/duktape.c.

20186 : func=%!iT, this=%!iT",
20187 (duk_tval *) duk_get_tval(ctx, -2),
20188 (duk_tval *) duk_get_tval(ctx, -1)));
20189 duk_call_method(ctx, 0);
20190
20191 return 1;
20192}
20193
20194/*
20195 * concat()
20196 */
20197
20198DUK_INTERNAL duk_ret_t duk_bi_array_prototype_concat(duk_context *ctx) {
20199 duk_idx_t i, n;
20200 duk_uarridx_t idx, idx_last;
20201 duk_uarridx_t j, len;
20202 duk_hobject *h;
20203
20204 /* XXX: the insert here is a bit expensive if there are a lot of items.
20205 * It could also be special cased in the outermost for loop quite easily
20206 * (as the element is dup()'d anyway).
20207 */
20208
20209 (void) duk_push_this_coercible_to_object(ctx);
20210 duk_insert(ctx, 0);
20211 n = duk_get_top(ctx);
20212 duk_push_array(ctx); /* -> [ ToObject(this) item1 ... itemN arr ] */
20213
20214 /* NOTE: The Array special behaviors are NOT invoked by duk_xdef_prop_index()
20215 * (which differs from the official algorithm). If no error is thrown, this
20216 * doesn't matter as the length is updated at the end. However, if an error
20217 * is thrown, the length will be unset. That shouldn't matter because the
20218 * caller won't get a reference to the intermediate value.
20219 */
20220
20221 idx = 0;
20222 idx_last = 0;
20223 for (i = 0; i < n; i++) {
20224 DUK_ASSERT_TOP(ctx, n + 1);
20225
20226 /* [ ToObject(this) item1 ... itemN arr ] */
20227
20228 duk_dup(ctx, i);
20229 h = duk_get_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_ARRAY);
20230 if (!h) {
20231 duk_xdef_prop_index_wec(ctx, -2, idx++);
20232 idx_last = idx;
20233 continue;
20234 }
20235
20236 /* [ ToObject(this) item1 ... itemN arr item(i) ] */
20237
20238 /* XXX: an array can have length higher than 32 bits; this is not handled
20239 * correctly now.
20240 */
20241 len = (duk_uarridx_t) duk_get_length(ctx, -1);
20242 for (j = 0; j < len; j++) {
20243 if (duk_get_prop_index(ctx, -1, j)) {
20244 /* [ ToObject(this) item1 ... itemN arr item(i) item(i)[j] ] */
20245 duk_xdef_prop_index_wec(ctx, -3, idx++);
20246 idx_last = idx;
20247 } else {
20248 idx++;
20249 duk_pop(ctx);
20250#if defined(DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER)
20251 /* According to E5.1 Section 15.4.4.4 nonexistent trailing
20252 * elements do not affect 'length' of the result. Test262
20253 * and other engines disagree, so update idx_last here too.
20254 */
20255 idx_last = idx;
20256#else
20257 /* Strict standard behavior, ignore trailing elements for
20258 * 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 21123 of file duktape-1.5.2/src/duktape.c.

21140 {
21141 duk_idx_t nargs;
21142 duk_int_t i, len;
21143 duk_int_t from_index;
21144 duk_small_int_t idx_step = duk_get_current_magic(ctx); /* idx_step is +1 for indexOf, -1 for lastIndexOf */
21145
21146 /* lastIndexOf() needs to be a vararg function because we must distinguish
21147 * between an undefined fromIndex and a "not given" fromIndex; indexOf() is
21148 * made vararg for symmetry although it doesn't strictly need to be.
21149 */
21150
21151 nargs = duk_get_top(ctx);
21152 duk_set_top(ctx, 2);
21153
21154 /* XXX: must be able to represent -len */
21156 if (len == 0) {
21157 goto not_found;
21158 }
21159
21160 /* Index clamping is a bit tricky, we must ensure that we'll only iterate
21161 * through elements that exist and that the specific requirements from E5.1
21162 * Sections 15.4.4.14 and 15.4.4.15 are fulfilled; especially:
21163 *
21164 * - indexOf: clamp to [-len,len], negative handling -> [0,len],
21165 * if clamped result is len, for-loop bails out immediately
21166 *
21167 * - lastIndexOf: clamp to [-len-1, len-1], negative handling -> [-1, len-1],
21168 * if clamped result is -1, for-loop bails out immediately
21169 *
21170 * If fromIndex is not given, ToInteger(undefined) = 0, which is correct
21171 * for indexOf() but incorrect for lastIndexOf(). Hence special handling,
21172 * and why lastIndexOf() needs to be a vararg function.
21173 */
21174
21175 if (nargs >= 2) {
21176 /* indexOf: clamp fromIndex to [-len, len]
21177 * (if fromIndex == len, for-loop terminates directly)
21178 *
21179 * lastIndexOf: clamp fromIndex to [-len - 1, len - 1]
21180 * (if clamped to -len-1 -> fromIndex becomes -1, terminates for-loop directly)
21181 */
21182 from_index = duk_to_int_clamped(ctx,
21183 1,
21184 (idx_step > 0 ? -len : -len - 1),
21185 (idx_step > 0 ? len : len - 1));
21186 if (from_index < 0) {
21187 /* for lastIndexOf, result may be -1 (mark immediate termination) */
21188 from_index = len + from_index;
21189 }
21190 } else {
21191 /* for indexOf, ToInteger(undefined) would be 0, i.e. correct, but
21192 * handle both indexOf and lastIndexOf specially here.
21193 */
21194 if (idx_step > 0) {
21195 from_index = 0;
21196 } else {
21197 from_index = len - 1;
21198 }
21199 }
21200
21201 /* stack[0] = searchElement
21202 * stack[1] = fromIndex
21203 * stack[2] = object
21204 * stack[3] = length (not needed, but not popped above)
21205 */
21206
21207 for (i = from_index; i >= 0 && i < len; i += idx_step) {
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_EXTERNAL duk_int_t duk_get_current_magic(duk_context *ctx)
DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32_limited(duk_context *ctx)

◆ duk_bi_array_prototype_iter_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_iter_shared ( duk_context * ctx)

Definition at line 21224 of file duktape-1.5.2/src/duktape.c.

21241 {
21242 duk_uint32_t len;
21243 duk_uint32_t i;
21244 duk_uarridx_t k;
21245 duk_bool_t bval;
21246 duk_small_int_t iter_type = duk_get_current_magic(ctx);
21247 duk_uint32_t res_length = 0;
21248
21249 /* each call this helper serves has nargs==2 */
21250 DUK_ASSERT_TOP(ctx, 2);
21251
21252 len = duk__push_this_obj_len_u32(ctx);
21253 duk_require_callable(ctx, 0);
21254 /* if thisArg not supplied, behave as if undefined was supplied */
21255
21256 if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) {
21257 duk_push_array(ctx);
21258 } else {
21259 duk_push_undefined(ctx);
21260 }
21261
21262 /* stack[0] = callback
21263 * stack[1] = thisArg
21264 * stack[2] = object
21265 * stack[3] = ToUint32(length) (unused, but avoid unnecessary pop)
21266 * stack[4] = result array (or undefined)
21267 */
21268
21269 k = 0; /* result index for filter() */
21270 for (i = 0; i < len; i++) {
21271 DUK_ASSERT_TOP(ctx, 5);
21272
21273 if (!duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
21274#if defined(DUK_USE_NONSTD_ARRAY_MAP_TRAILER)
21275 /* Real world behavior for map(): trailing non-existent
21276 * elements don't invoke the user callback, but are still
21277 * counted towards result 'length'.
21278 */
21279 if (iter_type == DUK__ITER_MAP) {
21280 res_length = i + 1;
21281 }
21282#else
21283 /* Standard behavior for map(): trailing non-existent
21284 * elements don't invoke the user callback and are not
21285 * counted towards result 'length'.
21286 */
21287#endif
21288 duk_pop(ctx);
21289 continue;
21290 }
21291
21292 /* The original value needs to be preserved for filter(), hence
21293 * this funny order. We can't re-get the value because of side
21294 * effects.
21295 */
21296
21297 duk_dup(ctx, 0);
21298 duk_dup(ctx, 1);
21299 duk_dup(ctx, -3);
21300 duk_push_u32(ctx, i);
21301 duk_dup(ctx, 2); /* [ ... val callback thisArg val i obj ] */
21302 duk_call_method(ctx, 3); /* -> [ ... val retval ] */
21303
21304 switch (iter_type) {
21305 case DUK__ITER_EVERY:
21306 bval = duk_to_boolean(ctx, -1);
21307 if (!bval) {
21308 /* stack top contains 'false' */
21309 return 1;
21310 }
21311 break;
21312 case DUK__ITER_SOME:
21313 bval = duk_to_boolean(ctx, -1);
21314 if (bval) {
21315 /* stack top contains 'true' */
21316 return 1;
21317 }
21318 break;
21319 case DUK__ITER_FOREACH:
21320 /* nop */
21321 break;
21322 case DUK__ITER_MAP:
21323 duk_dup(ctx, -1);
21324 duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) i); /* retval to result[i] */
21325 res_length = i + 1;
21326 break;
21327 case DUK__ITER_FILTER:
21328 bval = duk_to_boolean(ctx, -1);
21329 if (bval) {
21330 duk_dup(ctx, -2); /* orig value */
21332 k++;
21333 res_length = k;
21334 }
21335 break;
21336 default:
21338 break;
21339 }
21340 duk_pop_2(ctx);
21341
21342 DUK_ASSERT_TOP(ctx, 5);
21343 }
21344
21345 switch (iter_type) {
21346 case DUK__ITER_EVERY:
21347 duk_push_true(ctx);
21348 break;
21349 case DUK__ITER_SOME:
21350 duk_push_false(ctx);
21351 break;
#define duk_require_callable(ctx, index)
#define DUK__ITER_SOME
#define DUK__ITER_MAP
#define DUK__ITER_FOREACH
#define DUK__ITER_EVERY
#define DUK__ITER_FILTER

◆ duk_bi_array_prototype_join_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_join_shared ( duk_context * ctx)

Definition at line 20273 of file duktape-1.5.2/src/duktape.c.

20290 {
20291 duk_uint32_t len, count;
20292 duk_uint32_t idx;
20293 duk_small_int_t to_locale_string = duk_get_current_magic(ctx);
20294 duk_idx_t valstack_required;
20295
20296 /* For join(), nargs is 1. For toLocaleString(), nargs is 0 and
20297 * setting the top essentially pushes an undefined to the stack,
20298 * thus defaulting to a comma separator.
20299 */
20300 duk_set_top(ctx, 1);
20301 if (duk_is_undefined(ctx, 0)) {
20302 duk_pop(ctx);
20304 } else {
20305 duk_to_string(ctx, 0);
20306 }
20307
20308 len = duk__push_this_obj_len_u32(ctx);
20309
20310 /* [ sep ToObject(this) len ] */
20311
20312 DUK_DDD(DUK_DDDPRINT("sep=%!T, this=%!T, len=%lu",
20313 (duk_tval *) duk_get_tval(ctx, 0),
20314 (duk_tval *) duk_get_tval(ctx, 1),
20315 (unsigned long) len));
20316
20317 /* The extra (+4) is tight. */
20318 valstack_required = (len >= DUK__ARRAY_MID_JOIN_LIMIT ?
20319 DUK__ARRAY_MID_JOIN_LIMIT : len) + 4;
20320 duk_require_stack(ctx, valstack_required);
20321
20322 duk_dup(ctx, 0);
20323
20324 /* [ sep ToObject(this) len sep ] */
20325
20326 count = 0;
20327 idx = 0;
20328 for (;;) {
20329 if (count >= DUK__ARRAY_MID_JOIN_LIMIT || /* intermediate join to avoid valstack overflow */
20330 idx >= len) { /* end of loop (careful with len==0) */
20331 /* [ sep ToObject(this) len sep str0 ... str(count-1) ] */
20332 DUK_DDD(DUK_DDDPRINT("mid/final join, count=%ld, idx=%ld, len=%ld",
20333 (long) count, (long) idx, (long) len));
20334 duk_join(ctx, (duk_idx_t) count); /* -> [ sep ToObject(this) len str ] */
20335 duk_dup(ctx, 0); /* -> [ sep ToObject(this) len str sep ] */
20336 duk_insert(ctx, -2); /* -> [ sep ToObject(this) len sep str ] */
20337 count = 1;
20338 }
20339 if (idx >= len) {
20340 /* if true, the stack already contains the final result */
20341 break;
20342 }
20343
20344 duk_get_prop_index(ctx, 1, (duk_uarridx_t) idx);
20345 if (duk_is_null_or_undefined(ctx, -1)) {
20346 duk_pop(ctx);
20348 } else {
20349 if (to_locale_string) {
20350 duk_to_object(ctx, -1);
#define DUK_STRIDX_COMMA
#define DUK__ARRAY_MID_JOIN_LIMIT
DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count)

◆ duk_bi_array_prototype_pop()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_pop ( duk_context * ctx)

Definition at line 20356 of file duktape-1.5.2/src/duktape.c.

20373 {
20374 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 20376 of file duktape-1.5.2/src/duktape.c.

20379 {
20380 duk_push_int(ctx, 0);
20382 return 0;
20383 }
20384 idx = len - 1;
20385
20386 duk_get_prop_index(ctx, 0, (duk_uarridx_t) idx);
20387 duk_del_prop_index(ctx, 0, (duk_uarridx_t) idx);
20388 duk_push_u32(ctx, idx);
20390 return 1;
20391}
20392
20394 /* Note: 'this' is not necessarily an Array object. The push()
20395 * algorithm is supposed to work for other kinds of objects too,
20396 * so the algorithm has e.g. an explicit update for the 'length'
20397 * property which is normally "magical" in arrays.
20398 */
20399
20400 duk_uint32_t len;
20401 duk_idx_t i, n;
20402
20403 n = duk_get_top(ctx);
20404 len = duk__push_this_obj_len_u32(ctx);
20405
20406 /* [ arg1 ... argN obj length ] */
20407
20408 /* Technically Array.prototype.push() can create an Array with length
20409 * longer than 2^32-1, i.e. outside the 32-bit range. The final length
20410 * is *not* wrapped to 32 bits in the specification.
20411 *
20412 * This implementation tracks length with a uint32 because it's much
20413 * more practical.
20414 *
20415 * See: test-bi-array-push-maxlen.js.
20416 */
20417
20418 if (len + (duk_uint32_t) n < len) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_push(duk_context *ctx)

◆ duk_bi_array_prototype_reduce_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reduce_shared ( duk_context * ctx)

Definition at line 21357 of file duktape-1.5.2/src/duktape.c.

21362 :
21364 break;
21365 }
21366
21367 return 1;
21368}
21369
21370/*
21371 * reduce(), reduceRight()
21372 */
21373
21375 duk_idx_t nargs;
21376 duk_bool_t have_acc;
21377 duk_uint32_t i, len;
21378 duk_small_int_t idx_step = duk_get_current_magic(ctx); /* idx_step is +1 for reduce, -1 for reduceRight */
21379
21380 /* We're a varargs function because we need to detect whether
21381 * initialValue was given or not.
21382 */
21383 nargs = duk_get_top(ctx);
21384 DUK_DDD(DUK_DDDPRINT("nargs=%ld", (long) nargs));
21385
21386 duk_set_top(ctx, 2);
21387 len = duk__push_this_obj_len_u32(ctx);
21388 if (!duk_is_callable(ctx, 0)) {
21389 goto type_error;
21390 }
21391
21392 /* stack[0] = callback fn
21393 * stack[1] = initialValue
21394 * stack[2] = object (coerced this)
21395 * stack[3] = length (not needed, but not popped above)
21396 * stack[4] = accumulator
21397 */
21398
21399 have_acc = 0;
21400 if (nargs >= 2) {
21401 duk_dup(ctx, 1);
21402 have_acc = 1;
21403 }
21404 DUK_DDD(DUK_DDDPRINT("have_acc=%ld, acc=%!T",
21405 (long) have_acc, (duk_tval *) duk_get_tval(ctx, 3)));
21406
21407 /* For len == 0, i is initialized to len - 1 which underflows.
21408 * The condition (i < len) will then exit the for-loop on the
21409 * first round which is correct. Similarly, loop termination
21410 * happens by i underflowing.
21411 */
21412
21413 for (i = (idx_step >= 0 ? 0 : len - 1);
21414 i < len; /* i >= 0 would always be true */
21415 i += idx_step) {
21416 DUK_DDD(DUK_DDDPRINT("i=%ld, len=%ld, have_acc=%ld, top=%ld, acc=%!T",
21417 (long) i, (long) len, (long) have_acc,
21418 (long) duk_get_top(ctx),
21419 (duk_tval *) duk_get_tval(ctx, 4)));
21420
21421 DUK_ASSERT((have_acc && duk_get_top(ctx) == 5) ||
21422 (!have_acc && duk_get_top(ctx) == 4));
21423
21424 if (!duk_has_prop_index(ctx, 2, (duk_uarridx_t) i)) {
21425 continue;
21426 }
21427
21428 if (!have_acc) {
21429 DUK_ASSERT_TOP(ctx, 4);
21430 duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
21431 have_acc = 1;
21432 DUK_ASSERT_TOP(ctx, 5);
21433 } else {
21434 DUK_ASSERT_TOP(ctx, 5);
21435 duk_dup(ctx, 0);
21436 duk_dup(ctx, 4);
21437 duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
21438 duk_push_u32(ctx, i);
21439 duk_dup(ctx, 2);
21440 DUK_DDD(DUK_DDDPRINT("calling reduce function: func=%!T, prev=%!T, curr=%!T, idx=%!T, obj=%!T",
21441 (duk_tval *) duk_get_tval(ctx, -5), (duk_tval *) duk_get_tval(ctx, -4),
21442 (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
21443 (duk_tval *) duk_get_tval(ctx, -1)));
DUK_EXTERNAL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)
DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx)

◆ duk_bi_array_prototype_reverse()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reverse ( duk_context * ctx)

Definition at line 20906 of file duktape-1.5.2/src/duktape.c.

20923 {
20924 duk_uint32_t len;
20925 duk_uint32_t middle;
20926 duk_uint32_t lower, upper;
20927 duk_bool_t have_lower, have_upper;
20928
20929 len = duk__push_this_obj_len_u32(ctx);
20930 middle = len / 2;
20931
20932 /* If len <= 1, middle will be 0 and for-loop bails out
20933 * immediately (0 < 0 -> false).
20934 */
20935
20936 for (lower = 0; lower < middle; lower++) {
20937 DUK_ASSERT(len >= 2);
20938 DUK_ASSERT_TOP(ctx, 2);
20939
20940 DUK_ASSERT(len >= lower + 1);
20941 upper = len - lower - 1;
20942
20943 have_lower = duk_get_prop_index(ctx, -2, (duk_uarridx_t) lower);
20944 have_upper = duk_get_prop_index(ctx, -3, (duk_uarridx_t) upper);
20945
20946 /* [ ToObject(this) ToUint32(length) lowerValue upperValue ] */
20947
20948 if (have_upper) {
20949 duk_put_prop_index(ctx, -4, (duk_uarridx_t) lower);
20950 } else {
20951 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 21019 of file duktape-1.5.2/src/duktape.c.

21036 {
21037 duk_uint32_t len;
21038 duk_uint32_t i;
21039
21040 len = duk__push_this_obj_len_u32(ctx);
21041 if (len == 0) {
21042 duk_push_int(ctx, 0);
21044 return 0;
21045 }
21046
21047 duk_get_prop_index(ctx, 0, 0);
21048
21049 /* stack[0] = object (this)
21050 * stack[1] = ToUint32(length)
21051 * stack[2] = elem at index 0 (retval)
21052 */
21053
21054 for (i = 1; i < len; i++) {
21055 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 20957 of file duktape-1.5.2/src/duktape.c.

20957 {
20958 duk_del_prop_index(ctx, -3, (duk_uarridx_t) upper);
20959 duk_pop(ctx);
20960 }
20961
20962 DUK_ASSERT_TOP(ctx, 2);
20963 }
20964
20965 DUK_ASSERT_TOP(ctx, 2);
20966 duk_pop(ctx); /* -> [ ToObject(this) ] */
20967 return 1;
20968}
20969
20970/*
20971 * slice()
20972 */
20973
20975 duk_uint32_t len;
20976 duk_int_t start, end;
20977 duk_int_t i;
20978 duk_uarridx_t idx;
20979 duk_uint32_t res_length = 0;
20980
20981 /* XXX: len >= 0x80000000 won't work below because we need to be
20982 * able to represent -len.
20983 */
20985 duk_push_array(ctx);
20986
20987 /* stack[0] = start
20988 * stack[1] = end
20989 * stack[2] = ToObject(this)
20990 * stack[3] = ToUint32(length)
20991 * stack[4] = result array
20992 */
20993
20994 start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
20995 if (start < 0) {
20996 start = len + start;
20997 }
20998 /* XXX: could duk_is_undefined() provide defaulting undefined to 'len'
20999 * (the upper limit)?
21000 */
21001 if (duk_is_undefined(ctx, 1)) {
21002 end = len;
21003 } else {
21004 end = duk_to_int_clamped(ctx, 1, -((duk_int_t) len), (duk_int_t) len);
21005 if (end < 0) {
21006 end = len + end;
21007 }
21008 }
21009 DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len);
21010 DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len);
21011
21012 idx = 0;
21013 for (i = start; i < end; i++) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx)

◆ duk_bi_array_prototype_sort()

DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_sort ( duk_context * ctx)

Definition at line 20706 of file duktape-1.5.2/src/duktape.c.

20711 : %!T", (duk_tval *) duk_get_tval(ctx, 1)));
20712 duk__array_sort_swap(ctx, lo, r);
20713
20714#if defined(DUK_USE_DDDPRINT)
20715 duk__debuglog_qsort_state(ctx, lo, hi, r);
20716#endif
20717
20718 DUK_DDD(DUK_DDDPRINT("recurse: pivot=%ld, obj=%!T", (long) r, (duk_tval *) duk_get_tval(ctx, 1)));
20719 duk__array_qsort(ctx, lo, r - 1);
20720 duk__array_qsort(ctx, r + 1, hi);
20721}
20722
20723DUK_INTERNAL duk_ret_t duk_bi_array_prototype_sort(duk_context *ctx) {
20724 duk_uint32_t len;
20725
20726 /* XXX: len >= 0x80000000 won't work below because a signed type
20727 * 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 20742 of file duktape-1.5.2/src/duktape.c.

20759 {
20760 duk_idx_t nargs;
20761 duk_uint32_t len;
20762 duk_bool_t have_delcount;
20763 duk_int_t item_count;
20764 duk_int_t act_start;
20765 duk_int_t del_count;
20766 duk_int_t i, n;
20767
20768 DUK_UNREF(have_delcount);
20769
20770 nargs = duk_get_top(ctx);
20771 if (nargs < 2) {
20772 duk_set_top(ctx, 2);
20773 nargs = 2;
20774 have_delcount = 0;
20775 } else {
20776 have_delcount = 1;
20777 }
20778
20779 /* XXX: len >= 0x80000000 won't work below because we need to be
20780 * able to represent -len.
20781 */
20783
20784 act_start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
20785 if (act_start < 0) {
20786 act_start = len + act_start;
20787 }
20788 DUK_ASSERT(act_start >= 0 && act_start <= (duk_int_t) len);
20789
20790#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
20791 if (have_delcount) {
20792#endif
20793 del_count = duk_to_int_clamped(ctx, 1, 0, len - act_start);
20794#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
20795 } else {
20796 /* E5.1 standard behavior when deleteCount is not given would be
20797 * to treat it just like if 'undefined' was given, which coerces
20798 * ultimately to 0. Real world behavior is to splice to the end
20799 * of array, see test-bi-array-proto-splice-no-delcount.js.
20800 */
20801 del_count = len - act_start;
20802 }
20803#endif
20804
20805 DUK_ASSERT(nargs >= 2);
20806 item_count = (duk_int_t) (nargs - 2);
20807
20808 DUK_ASSERT(del_count >= 0 && del_count <= (duk_int_t) len - act_start);
20809 DUK_ASSERT(del_count + act_start <= (duk_int_t) len);
20810
20811 /* For now, restrict result array into 32-bit length range. */
20812 if (((duk_double_t) len) - ((duk_double_t) del_count) + ((duk_double_t) item_count) > (duk_double_t) DUK_UINT32_MAX) {
20813 DUK_D(DUK_DPRINT("Array.prototype.splice() would go beyond 32-bit length, throw"));
20814 return DUK_RET_RANGE_ERROR;
20815 }
20816
20817 duk_push_array(ctx);
20818
20819 /* stack[0] = start
20820 * stack[1] = deleteCount
20821 * stack[2...nargs-1] = items
20822 * stack[nargs] = ToObject(this) -3
20823 * stack[nargs+1] = ToUint32(length) -2
20824 * stack[nargs+2] = result array -1
20825 */
20826
20827 DUK_ASSERT_TOP(ctx, nargs + 3);
20828
20829 /* Step 9: copy elements-to-be-deleted into the result array */
20830
20831 for (i = 0; i < del_count; i++) {
20832 if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (act_start + i))) {
20833 duk_xdef_prop_index_wec(ctx, -2, i); /* throw flag irrelevant (false in std alg) */
20834 } else {
20835 duk_pop(ctx);
20836 }
20837 }
20838 duk_push_u32(ctx, (duk_uint32_t) del_count);
20840
20841 /* Steps 12 and 13: reorganize elements to make room for itemCount elements */
20842
20843 if (item_count < del_count) {
20844 /* [ A B C D E F G H ] rel_index = 2, del_count 3, item count 1
20845 * -> [ A B F G H ] (conceptual intermediate step)
20846 * -> [ A B . F G H ] (placeholder marked)
20847 * [ A B C F G H ] (actual result at this point, C will be replaced)
20848 */
20849
20850 DUK_ASSERT_TOP(ctx, nargs + 3);
20851
20852 n = len - del_count;
20853 for (i = act_start; i < n; i++) {
20854 if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
20855 duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
20856 } else {
20857 duk_pop(ctx);
20858 duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
20859 }
20860 }
20861
20862 DUK_ASSERT_TOP(ctx, nargs + 3);
20863
20864 /* loop iterator init and limit changed from standard algorithm */
20865 n = len - del_count + item_count;
20866 for (i = len - 1; i >= n; i--) {
20867 duk_del_prop_index(ctx, -3, (duk_uarridx_t) i);
20868 }
20869
20870 DUK_ASSERT_TOP(ctx, nargs + 3);
20871 } else if (item_count > del_count) {
20872 /* [ A B C D E F G H ] rel_index = 2, del_count 3, item count 4
20873 * -> [ A B F G H ] (conceptual intermediate step)
20874 * -> [ A B . . . . F G H ] (placeholder marked)
20875 * [ A B C D E F F G H ] (actual result at this point)
20876 */
20877
20878 DUK_ASSERT_TOP(ctx, nargs + 3);
20879
20880 /* loop iterator init and limit changed from standard algorithm */
20881 for (i = len - del_count - 1; i >= act_start; i--) {
20882 if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
20883 duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
20884 } else {
20885 duk_pop(ctx);
20886 duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
20887 }
20888 }
20889
20890 DUK_ASSERT_TOP(ctx, nargs + 3);
20891 } else {
20892 /* [ A B C D E F G H ] rel_index = 2, del_count 3, item count 3
20893 * -> [ A B F G H ] (conceptual intermediate step)
20894 * -> [ A B . . . F G H ] (placeholder marked)
20895 * [ A B C D E F G H ] (actual result at this point)
20896 */
20897 }
20898 DUK_ASSERT_TOP(ctx, nargs + 3);
20899
20900 /* 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 20142 of file duktape-1.5.2/src/duktape.c.

20147 {
20148 duk_hobject *h;
20149
20151 duk_push_boolean(ctx, (h != NULL));
20152 return 1;
20153}
20154
20155/*
20156 * toString()
20157 */
20158
20162
20163 /* [ ... this func ] */
20164 if (!duk_is_callable(ctx, -1)) {
20165 /* Fall back to the initial (original) Object.toString(). We don't
20166 * currently have pointers to the built-in functions, only the top
20167 * level global objects (like "Array") so this is now done in a bit
20168 * of a hacky manner. It would be cleaner to push the (original)
20169 * function and use duk_call_method().
20170 */
20171
20172 /* XXX: 'this' will be ToObject() coerced twice, which is incorrect
20173 * but should have no visible side effects.
20174 */
20175 DUK_DDD(DUK_DDDPRINT("this.join is not callable, fall back to (original) Object.toString"));
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_ret_t duk_bi_array_prototype_to_string(duk_context *ctx)
#define DUK_STRIDX_JOIN

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 21061 of file duktape-1.5.2/src/duktape.c.

21078 {
21079 duk_idx_t nargs;
21080 duk_uint32_t len;
21081 duk_uint32_t i;
21082
21083 nargs = duk_get_top(ctx);
21084 len = duk__push_this_obj_len_u32(ctx);
21085
21086 /* stack[0...nargs-1] = unshift args (vararg)
21087 * stack[nargs] = ToObject(this)
21088 * stack[nargs+1] = ToUint32(length)
21089 */
21090
21091 DUK_ASSERT_TOP(ctx, nargs + 2);
21092
21093 /* Note: unshift() may operate on indices above unsigned 32-bit range
21094 * and the final length may be >= 2**32. However, we restrict the
21095 * final result to 32-bit range for practicality.
21096 */
21097
21098 if (len + (duk_uint32_t) nargs < len) {
21099 DUK_D(DUK_DPRINT("Array.prototype.unshift() would go beyond 32-bit length, throw"));
21100 return DUK_RET_RANGE_ERROR;
21101 }
21102
21103 i = len;
21104 while (i > 0) {
21105 DUK_ASSERT_TOP(ctx, nargs + 2);
21106 i--;
21107 /* k+argCount-1; note that may be above 32-bit range */
21108
21109 if (duk_get_prop_index(ctx, -2, (duk_uarridx_t) i)) {
21110 /* fromPresent = true */
21111 /* [ ... ToObject(this) ToUint32(length) val ] */
21112 duk_put_prop_index(ctx, -3, (duk_uarridx_t) (i + nargs)); /* -> [ ... ToObject(this) ToUint32(length) ] */
21113 } else {
21114 /* fromPresent = false */
21115 /* [ ... ToObject(this) ToUint32(length) val ] */
21116 duk_pop(ctx);
21117 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 22193 of file duktape-1.5.2/src/duktape.c.

22199 {
22200 DUK_UNREF(ctx);
22202}
22203#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22204
22205/*
22206 * ArrayBuffer, DataView, and TypedArray constructors
22207 */
22208
22209#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22211 duk_hthread *thr;
22212 duk_hbufferobject *h_bufobj;
22213 duk_hbuffer *h_val;
22214
22216 thr = (duk_hthread *) ctx;
22217 DUK_UNREF(thr);
22218
22219 /* XXX: function flag to make this automatic? */
22220 if (!duk_is_constructor_call(ctx)) {
22221 return DUK_RET_TYPE_ERROR;
22222 }
22223
22224 if (duk_is_buffer(ctx, 0)) {
22225 /* Custom behavior: plain buffer is used as internal buffer
22226 * without making a copy (matches Duktape.Buffer).
22227 */
22228
22229 h_val = duk_get_hbuffer(ctx, 0);
22230 DUK_ASSERT(h_val != NULL);
22231
22232 /* XXX: accept any duk_hbufferobject type as an input also? */
22233 } else {
22234 duk_int_t len;
22235 len = duk_to_int(ctx, 0);
22236 if (len < 0) {
22237 goto fail_length;
22238 }
22239 (void) duk_push_fixed_buffer(ctx, (duk_size_t) len);
22240 h_val = (duk_hbuffer *) duk_get_hbuffer(ctx, -1);
22241 DUK_ASSERT(h_val != NULL);
22242
22243#if !defined(DUK_USE_ZERO_BUFFER_DATA)
22244 /* Khronos/ES6 requires zeroing even when DUK_USE_ZERO_BUFFER_DATA
22245 * is not set.
22246 */
22248 DUK_MEMZERO((void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_val), (duk_size_t) len);
22249#endif
DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx)
DUK_EXTERNAL duk_bool_t duk_is_constructor_call(duk_context *ctx)

◆ duk_bi_arraybuffer_isview()

DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_isview ( duk_context * ctx)

Definition at line 22692 of file duktape-1.5.2/src/duktape.c.

22698 {
22699 DUK_UNREF(ctx);
22701}
22702#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 21498 of file duktape-1.5.2/src/duktape.c.

21499 {
21501 DUK_ASSERT(duk_is_boolean(ctx, -1));
21502 goto type_ok;
21503 }
21504 }
21505
21506 return DUK_RET_TYPE_ERROR;
21507
21508 type_ok:
21509 if (coerce_tostring) {
21510 duk_to_string(ctx, -1);
21511 }
21512 return 1;
21513}
21514
21516 duk_hthread *thr = (duk_hthread *) ctx;
21517 duk_hobject *h_this;
21518
21519 DUK_UNREF(thr);
21520
DUK_EXTERNAL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx)

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 21462 of file duktape-1.5.2/src/duktape.c.

21479 {
21480 duk_tval *tv;
21481 duk_hobject *h;
21482 duk_small_int_t coerce_tostring = duk_get_current_magic(ctx);
21483
21484 /* XXX: there is room to use a shared helper here, many built-ins
21485 * check the 'this' type, and if it's an object, check its class,
21486 * then get its internal value, etc.
21487 */
21488
21489 duk_push_this(ctx);
21490 tv = duk_get_tval(ctx, -1);
21491 DUK_ASSERT(tv != NULL);
21492
21493 if (DUK_TVAL_IS_BOOLEAN(tv)) {
21494 goto type_ok;
21495 } else if (DUK_TVAL_IS_OBJECT(tv)) {
21496 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 22884 of file duktape-1.5.2/src/duktape.c.

22888 {
22889 DUK_UNREF(ctx);
22891}
22892#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22893
22894/*
22895 * Node.js Buffer.prototype.equals()
22896 * Node.js Buffer.prototype.compare()
22897 * Node.js Buffer.compare()
22898 */
22899
22900#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22902 duk_hthread *thr;
22903 duk_small_uint_t magic;
22904 duk_hbufferobject *h_bufarg1;
22905 duk_hbufferobject *h_bufarg2;
22906 duk_small_int_t comp_res;
22907
22908 thr = (duk_hthread *) ctx;
22909 DUK_UNREF(thr);
22910
22911 magic = duk_get_current_magic(ctx);
22912 if (magic & 0x02) {
22913 /* Static call style. */
22914 h_bufarg1 = duk__require_bufobj_value(ctx, 0);
22915 h_bufarg2 = duk__require_bufobj_value(ctx, 1);
22916 } else {
22917 h_bufarg1 = duk__require_bufobj_this(ctx);
22918 h_bufarg2 = duk__require_bufobj_value(ctx, 0);
22919 }
22920 DUK_ASSERT(h_bufarg1 != NULL);
22921 DUK_ASSERT(h_bufarg2 != NULL);
22922
22923 /* We want to compare the slice/view areas of the arguments.
22924 * If either slice/view is invalid (underlying buffer is shorter)
22925 * ensure equals() is false, but otherwise the only thing that
22926 * matters is to be memory safe.
22927 */
22928
22929 if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg1) &&
22930 DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg2)) {
22931 comp_res = duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufarg1->buf) + h_bufarg1->offset,
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_ret_t duk_bi_buffer_compare_shared(duk_context *ctx)

◆ duk_bi_buffer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_constructor ( duk_context * ctx)

Definition at line 22009 of file duktape-1.5.2/src/duktape.c.

22011 :
22012 du.d = (duk_double_t) duk_to_number(ctx, -1);
22013 break;
22014#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22015 default:
22017 }
22018
22019 DUK_MEMCPY((void *) p, (const void *) du.uc, (size_t) elem_size);
22020}
22021
22022/*
22023 * Duktape.Buffer: constructor
22024 */
22025
22027 duk_hthread *thr;
22028 duk_size_t buf_size;
22029 duk_small_int_t buf_dynamic;
22030 duk_uint8_t *buf_data;
22031 const duk_uint8_t *src_data;
22032
22033 thr = (duk_hthread *) ctx;
22034 DUK_UNREF(thr);
22035
22036 /*
22037 * Constructor arguments are currently somewhat compatible with
22038 * (keep it that way if possible):
22039 *
22040 * http://nodejs.org/api/buffer.html
22041 *
22042 * Note that the ToBuffer() coercion (duk_to_buffer()) does NOT match
22043 * the constructor behavior.
22044 */
22045
22046 buf_dynamic = duk_get_boolean(ctx, 1); /* default to false */
22047
22048 switch (duk_get_type(ctx, 0)) {
22049 case DUK_TYPE_NUMBER: {
22050 /* new buffer of specified size */
22051 buf_size = (duk_size_t) duk_to_int(ctx, 0);
22052 (void) duk_push_buffer(ctx, buf_size, buf_dynamic);
22053 break;
22054 }
22055 case DUK_TYPE_BUFFER: {
22056 /* return input buffer, converted to a Duktape.Buffer object
22057 * if called as a constructor (no change if called as a
22058 * function).
22059 */
22060 duk_set_top(ctx, 1);
22061 break;
22062 }
22063 case DUK_TYPE_STRING: {
22064 /* new buffer with string contents */
22065 src_data = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &buf_size);
22066 DUK_ASSERT(src_data != NULL); /* even for zero-length string */
22067 buf_data = (duk_uint8_t *) duk_push_buffer(ctx, buf_size, buf_dynamic);
22068 DUK_MEMCPY((void *) buf_data, (const void *) src_data, (size_t) buf_size);
22069 break;
22070 }
22071 case DUK_TYPE_OBJECT: {
22072 /* For all duk_hbufferobjects, get the plain buffer inside
22073 * without making a copy. This is compatible with Duktape 1.2
22074 * but means that a slice/view information is ignored and the
22075 * full underlying buffer is returned.
22076 *
22077 * If called as a constructor, a new Duktape.Buffer object
22078 * pointing to the same plain buffer is created below.
22079 */
22080 duk_hbufferobject *h_bufobj;
22081 h_bufobj = (duk_hbufferobject *) duk_get_hobject(ctx, 0);
22082 DUK_ASSERT(h_bufobj != NULL);
22083 if (!DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj)) {
22084 return DUK_RET_TYPE_ERROR;
22085 }
22086 if (h_bufobj->buf == NULL) {
22087 return DUK_RET_TYPE_ERROR;
22088 }
22089 duk_push_hbuffer(ctx, h_bufobj->buf);
22090 break;
22091 }
22092 case DUK_TYPE_NONE:
22093 default: {
22094 return DUK_RET_TYPE_ERROR;
22095 }
22096 }
22097 DUK_ASSERT(duk_is_buffer(ctx, -1));
22098
22099 /* stack is unbalanced, but: [ <something> buf ] */
22100
22101 if (duk_is_constructor_call(ctx)) {
22102 duk_hbufferobject *h_bufobj;
22103 duk_hbuffer *h_val;
22104
22105 h_val = duk_get_hbuffer(ctx, -1);
#define duk_push_buffer(ctx, size, dynamic)
DUK_EXTERNAL const char * duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_EXTERNAL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h)
DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx)

◆ duk_bi_buffer_prototype_tostring_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_prototype_tostring_shared ( duk_context * ctx)

Definition at line 22772 of file duktape-1.5.2/src/duktape.c.

22774 :
22775 return DUK_RET_TYPE_ERROR;
22776}
22777#else /* DUK_USE_BUFFEROBJECT_SUPPORT */
22779 DUK_UNREF(ctx);
22781}
22782#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22783
22784/*
22785 * Duktape.Buffer: toString(), valueOf()
22786 */
22787
22788#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22790 duk_hthread *thr;
22791 duk_tval *tv;
22792 duk_small_int_t to_string = duk_get_current_magic(ctx);
22793
22794 thr = (duk_hthread *) ctx;
22795 DUK_UNREF(thr);
22796
22798 DUK_ASSERT(tv != NULL);
22799
22800 if (DUK_TVAL_IS_BUFFER(tv)) {
22801 duk_hbuffer *h_buf;
22802 h_buf = DUK_TVAL_GET_BUFFER(tv);
22803 DUK_ASSERT(h_buf != NULL);
22804 duk_push_hbuffer(ctx, h_buf);
22805 } else if (DUK_TVAL_IS_OBJECT(tv)) {
22806 duk_hobject *h;
22807 duk_hbufferobject *h_bufobj;
22808
22809 /* Accept any duk_hbufferobject, though we're only normally
22810 * called for Duktape.Buffer values.
22811 */
22812 h = DUK_TVAL_GET_OBJECT(tv);
22813 DUK_ASSERT(h != NULL);
22815 DUK_DD(DUK_DDPRINT("toString/valueOf() called for a non-bufferobject object"));
22816 goto type_error;
22817 }
22818 h_bufobj = (duk_hbufferobject *) h;
22820
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx)
DUK_INTERNAL_DECL duk_tval * duk_get_borrowed_this_tval(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx)

◆ duk_bi_buffer_readfield()

DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_readfield ( duk_context * ctx)

Definition at line 23848 of file duktape-1.5.2/src/duktape.c.

23865 {
23866 duk_hthread *thr;
23868 duk_small_int_t magic_ftype;
23869 duk_small_int_t magic_bigendian;
23870 duk_small_int_t magic_signed;
23871 duk_small_int_t magic_typedarray;
23872 duk_small_int_t endswap;
23873 duk_hbufferobject *h_this;
23874 duk_bool_t no_assert;
23875 duk_int_t offset_signed;
23876 duk_uint_t offset;
23877 duk_uint_t buffer_length;
23878 duk_uint_t check_length;
23879 duk_uint8_t *buf;
23881
23882 thr = (duk_hthread *) ctx;
23883 DUK_UNREF(thr);
23884
23885 magic_ftype = magic & 0x0007;
23886 magic_bigendian = magic & 0x0008;
23887 magic_signed = magic & 0x0010;
23888 magic_typedarray = magic & 0x0020;
23889
23890 h_this = duk__require_bufobj_this(ctx);
23891 DUK_ASSERT(h_this != NULL);
23892 buffer_length = h_this->length;
23893
23894 /* [ offset noAssert ], when ftype != DUK__FLD_VARINT */
23895 /* [ offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */
23896 /* [ offset littleEndian ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */
23897
23898 /* Handle TypedArray vs. Node.js Buffer arg differences */
23899 if (magic_typedarray) {
23900 no_assert = 0;
23901#if defined(DUK_USE_INTEGER_LE)
23902 endswap = !duk_to_boolean(ctx, 1); /* 1=little endian */
23903#else
23904 endswap = duk_to_boolean(ctx, 1); /* 1=little endian */
23905#endif
23906 } else {
23907 no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 2 : 1);
23908#if defined(DUK_USE_INTEGER_LE)
23909 endswap = magic_bigendian;
23910#else
23911 endswap = !magic_bigendian;
23912#endif
23913 }
23914
23915 /* Offset is coerced first to signed integer range and then to unsigned.
23916 * This ensures we can add a small byte length (1-8) to the offset in
23917 * bound checks and not wrap.
23918 */
23919 offset_signed = duk_to_int(ctx, 0);
23920 offset = (duk_uint_t) offset_signed;
23921 if (offset_signed < 0) {
23922 goto fail_bounds;
23923 }
23924
23925 DUK_DDD(DUK_DDDPRINT("readfield, buffer_length=%ld, offset=%ld, no_assert=%d, "
23926 "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, "
23927 "endswap=%d",
23928 (long) buffer_length, (long) offset, (int) no_assert,
23929 (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3),
23930 (int) (magic_signed >> 4), (int) endswap));
23931
23932 /* Update 'buffer_length' to be the effective, safe limit which
23933 * takes into account the underlying buffer. This value will be
23934 * potentially invalidated by any side effect.
23935 */
23936 check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length);
23937 DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld",
23938 (long) buffer_length, (long) check_length));
23939
23940 if (h_this->buf) {
23941 buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this);
23942 } else {
23943 /* Neutered. We could go into the switch-case safely with
23944 * buf == NULL because check_length == 0. To avoid scanbuild
23945 * warnings, fail directly instead.
23946 */
23947 DUK_ASSERT(check_length == 0);
23948 goto fail_neutered;
23949 }
23950 DUK_ASSERT(buf != NULL);
23951
23952 switch (magic_ftype) {
23953 case DUK__FLD_8BIT: {
23954 duk_uint8_t tmp;
23955 if (offset + 1U > check_length) {
23956 goto fail_bounds;
23957 }
23958 tmp = buf[offset];
23959 if (magic_signed) {
23960 duk_push_int(ctx, (duk_int_t) ((duk_int8_t) tmp));
23961 } else {
23962 duk_push_uint(ctx, (duk_uint_t) tmp);
23963 }
23964 break;
23965 }
23966 case DUK__FLD_16BIT: {
23967 duk_uint16_t tmp;
23968 if (offset + 2U > check_length) {
23969 goto fail_bounds;
23970 }
23971 DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 2);
23972 tmp = du.us[0];
23973 if (endswap) {
23974 tmp = DUK_BSWAP16(tmp);
23975 }
23976 if (magic_signed) {
23977 duk_push_int(ctx, (duk_int_t) ((duk_int16_t) tmp));
23978 } else {
23979 duk_push_uint(ctx, (duk_uint_t) tmp);
23980 }
23981 break;
23982 }
23983 case DUK__FLD_32BIT: {
23984 duk_uint32_t tmp;
23985 if (offset + 4U > check_length) {
23986 goto fail_bounds;
23987 }
23988 DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4);
23989 tmp = du.ui[0];
23990 if (endswap) {
23991 tmp = DUK_BSWAP32(tmp);
23992 }
23993 if (magic_signed) {
23994 duk_push_int(ctx, (duk_int_t) ((duk_int32_t) tmp));
23995 } else {
23996 duk_push_uint(ctx, (duk_uint_t) tmp);
23997 }
23998 break;
23999 }
24000 case DUK__FLD_FLOAT: {
24001 duk_uint32_t tmp;
24002 if (offset + 4U > check_length) {
24003 goto fail_bounds;
24004 }
24005 DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4);
24006 if (endswap) {
24007 tmp = du.ui[0];
24008 tmp = DUK_BSWAP32(tmp);
24009 du.ui[0] = tmp;
24010 }
24011 duk_push_number(ctx, (duk_double_t) du.f[0]);
24012 break;
24013 }
24014 case DUK__FLD_DOUBLE: {
24015 if (offset + 8U > check_length) {
24016 goto fail_bounds;
24017 }
24018 DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 8);
24019 if (endswap) {
24021 }
24022 duk_push_number(ctx, (duk_double_t) du.d);
24023 break;
24024 }
24025 case DUK__FLD_VARINT: {
24026 /* Node.js Buffer variable width integer field. We don't really
24027 * care about speed here, so aim for shortest algorithm.
24028 */
24029 duk_int_t field_bytelen;
24030 duk_int_t i, i_step, i_end;
24031#if defined(DUK_USE_64BIT_OPS)
24032 duk_int64_t tmp;
24033 duk_small_uint_t shift_tmp;
24034#else
24035 duk_double_t tmp;
24036 duk_small_int_t highbyte;
24037#endif
24038 const duk_uint8_t *p;
24039
24040 field_bytelen = duk_get_int(ctx, 1); /* avoid side effects! */
24041 if (field_bytelen < 1 || field_bytelen > 6) {
24042 goto fail_field_length;
24043 }
24044 if (offset + (duk_uint_t) field_bytelen > check_length) {
24045 goto fail_bounds;
24046 }
24047 p = (const duk_uint8_t *) (buf + offset);
24048
24049 /* Slow gathering of value using either 64-bit arithmetic
24050 * or IEEE doubles if 64-bit types not available. Handling
24051 * of negative numbers is a bit non-obvious in both cases.
24052 */
24053
24054 if (magic_bigendian) {
24055 /* Gather in big endian */
24056 i = 0;
24057 i_step = 1;
24058 i_end = field_bytelen; /* one i_step over */
24059 } else {
24060 /* Gather in little endian */
24061 i = field_bytelen - 1;
24062 i_step = -1;
24063 i_end = -1; /* one i_step over */
24064 }
24065
24066#if defined(DUK_USE_64BIT_OPS)
24067 tmp = 0;
24068 do {
24069 DUK_ASSERT(i >= 0 && i < field_bytelen);
24070 tmp = (tmp << 8) + (duk_int64_t) p[i];
24071 i += i_step;
24072 } while (i != i_end);
24073
24074 if (magic_signed) {
24075 /* Shift to sign extend. */
24076 shift_tmp = 64 - (field_bytelen * 8);
24077 tmp = (tmp << shift_tmp) >> shift_tmp;
24078 }
24079
24080 duk_push_i64(ctx, tmp);
24081#else
24082 highbyte = p[i];
24083 if (magic_signed && (highbyte & 0x80) != 0) {
24084 /* 0xff => 255 - 256 = -1; 0x80 => 128 - 256 = -128 */
24085 tmp = (duk_double_t) (highbyte - 256);
24086 } else {
24087 tmp = (duk_double_t) highbyte;
24088 }
24089 for (;;) {
24090 i += i_step;
24091 if (i == i_end) {
24092 break;
24093 }
24094 DUK_ASSERT(i >= 0 && i < field_bytelen);
24095 tmp = (tmp * 256.0) + (duk_double_t) p[i];
24096 }
24097
24098 duk_push_number(ctx, tmp);
24099#endif
24100 break;
24101 }
24102 default: { /* should never happen but default here */
24103 goto fail_bounds;
24104 }
#define DUK_DBLUNION_BSWAP64(u)
#define DUK__FLD_FLOAT
#define DUK__FLD_DOUBLE
#define DUK__FLD_16BIT
#define DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h, len)
#define duk_push_i64(ctx, val)
#define DUK__FLD_32BIT
#define DUK_HBUFFEROBJECT_GET_SLICE_BASE(heap, h)
#define DUK__FLD_VARINT
#define DUK__FLD_8BIT

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 23497 of file duktape-1.5.2/src/duktape.c.

23502 :
23503 *
23504 * - Copy/view behavior; Node.js .slice() and TypedArray .subarray() create
23505 * views, ArrayBuffer .slice() creates a copy
23506 *
23507 * - Resulting object has a different class and prototype depending on the
23508 * call (or 'this' argument)
23509 *
23510 * - TypedArray .subarray() arguments are element indices, not byte offsets
23511 */
23512
23513#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
23515 duk_hthread *thr;
23516 duk_small_int_t magic;
23517 duk_small_uint_t res_class_num;
23518 duk_hobject *res_proto;
23519 duk_hbufferobject *h_this;
23520 duk_hbufferobject *h_bufobj;
23521 duk_hbuffer *h_val;
23522 duk_int_t start_offset, end_offset;
23523 duk_uint_t slice_length;
23524
23525 thr = (duk_hthread *) ctx;
23526 DUK_UNREF(thr);
23527
23528 /* [ start end ] */
23529
23530 magic = duk_get_current_magic(ctx);
23531 h_this = duk__require_bufobj_this(ctx);
23532
23533 /* Slice offsets are element (not byte) offsets, which only matters
23534 * for TypedArray views, Node.js Buffer and ArrayBuffer have shift
23535 * zero so byte and element offsets are the same. Negative indices
23536 * are counted from end of slice, crossed indices are allowed (and
23537 * result in zero length result), and final values are clamped
23538 * against the current slice. There's intentionally no check
23539 * against the underlying buffer here.
23540 */
23541
23542 duk__clamp_startend_negidx_shifted(ctx, h_this, 0 /*idx_start*/, 1 /*idx_end*/, &start_offset, &end_offset);
23543 DUK_ASSERT(end_offset >= start_offset);
23544 slice_length = (duk_uint_t) (end_offset - start_offset);
23545
23546 /* The resulting buffer object gets the same class and prototype as
23547 * the buffer in 'this', e.g. if the input is a Node.js Buffer the
23548 * result is a Node.js Buffer; if the input is a Float32Array, the
23549 * result is a Float32Array.
23550 *
23551 * For the class number this seems correct. The internal prototype
23552 * is not so clear: if 'this' is a bufferobject with a non-standard
23553 * prototype object, that value gets copied over into the result
23554 * (instead of using the standard prototype for that object type).
23555 */
23556
23557 res_class_num = DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) h_this);
23558 h_bufobj = duk_push_bufferobject_raw(ctx,
23561 DUK_HOBJECT_CLASS_AS_FLAGS(res_class_num),
23562 DUK_BIDX_OBJECT_PROTOTYPE); /* replaced */
23563 DUK_ASSERT(h_bufobj != NULL);
23564 res_proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, (duk_hobject *) h_this); /* may be NULL */
23565 DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) h_bufobj, res_proto);
23566
23567 h_bufobj->length = slice_length;
23568 h_bufobj->shift = h_this->shift; /* inherit */
23569 h_bufobj->elem_type = h_this->elem_type; /* inherit */
23570 h_bufobj->is_view = magic & 0x01;
23571 DUK_ASSERT(h_bufobj->is_view == 0 || h_bufobj->is_view == 1);
23572
23573 h_val = h_this->buf;
23574 if (h_val == NULL) {
23575 return DUK_RET_TYPE_ERROR;
23576 }
23577
23578 if (magic & 0x02) {
23579 /* non-zero: make copy */
23580 duk_uint8_t *p_copy;
23581 duk_size_t copy_length;
23582
23583 p_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) slice_length);
23584 DUK_ASSERT(p_copy != NULL);
23585
23586 /* Copy slice, respecting underlying buffer limits; remainder
23587 * is left as zero.
23588 */
23589 copy_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, slice_length);
23590 DUK_MEMCPY((void *) p_copy,
23591 (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + start_offset),
23592 copy_length);
23593
23594 h_val = duk_get_hbuffer(ctx, -1);
23595 DUK_ASSERT(h_val != NULL);
23596
23597 h_bufobj->buf = h_val;
23598 DUK_HBUFFER_INCREF(thr, h_val);
23599 DUK_ASSERT(h_bufobj->offset == 0);
23600
23601 duk_pop(ctx); /* reachable so pop OK */
23602 } else {
23603 h_bufobj->buf = h_val;
23604 DUK_HBUFFER_INCREF(thr, h_val);
23605 h_bufobj->offset = (duk_uint_t) (h_this->offset + start_offset);
23606
23607 /* Copy the .buffer property, needed for TypedArray.prototype.subarray().
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 duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx)
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)

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 24114 of file duktape-1.5.2/src/duktape.c.

24123 {
24124 DUK_UNREF(ctx);
24126}
24127#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
24128
24129#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
24130/* XXX: split into separate functions for each field type? */
24132 duk_hthread *thr;
24134 duk_small_int_t magic_ftype;
24135 duk_small_int_t magic_bigendian;
24136 duk_small_int_t magic_signed;
24137 duk_small_int_t magic_typedarray;
24138 duk_small_int_t endswap;
24139 duk_hbufferobject *h_this;
24140 duk_bool_t no_assert;
24141 duk_int_t offset_signed;
24142 duk_uint_t offset;
24143 duk_uint_t buffer_length;
24144 duk_uint_t check_length;
24145 duk_uint8_t *buf;
24147 duk_int_t nbytes = 0;
24148
24149 thr = (duk_hthread *) ctx;
24150 DUK_UNREF(thr);
24151
24152 magic_ftype = magic & 0x0007;
24153 magic_bigendian = magic & 0x0008;
24154 magic_signed = magic & 0x0010;
24155 magic_typedarray = magic & 0x0020;
24156 DUK_UNREF(magic_signed);
24157
24158 h_this = duk__require_bufobj_this(ctx);
24159 DUK_ASSERT(h_this != NULL);
24160 buffer_length = h_this->length;
24161
24162 /* [ value offset noAssert ], when ftype != DUK__FLD_VARINT */
24163 /* [ value offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */
24164 /* [ offset value littleEndian ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */
24165
24166 /* Handle TypedArray vs. Node.js Buffer arg differences */
24167 if (magic_typedarray) {
24168 no_assert = 0;
24169#if defined(DUK_USE_INTEGER_LE)
24170 endswap = !duk_to_boolean(ctx, 2); /* 1=little endian */
24171#else
24172 endswap = duk_to_boolean(ctx, 2); /* 1=little endian */
24173#endif
24174 duk_swap(ctx, 0, 1); /* offset/value order different from Node.js */
24175 } else {
24176 no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 3 : 2);
24177#if defined(DUK_USE_INTEGER_LE)
24178 endswap = magic_bigendian;
24179#else
24180 endswap = !magic_bigendian;
24181#endif
24182 }
24183
24184 /* Offset is coerced first to signed integer range and then to unsigned.
24185 * This ensures we can add a small byte length (1-8) to the offset in
24186 * bound checks and not wrap.
24187 */
24188 offset_signed = duk_to_int(ctx, 1);
24189 offset = (duk_uint_t) offset_signed;
24190
24191 /* We need 'nbytes' even for a failed offset; return value must be
24192 * (offset + nbytes) even when write fails due to invalid offset.
24193 */
24194 if (magic_ftype != DUK__FLD_VARINT) {
24195 DUK_ASSERT(magic_ftype >= 0 && magic_ftype < (duk_small_int_t) (sizeof(duk__buffer_nbytes_from_fldtype) / sizeof(duk_uint8_t)));
24196 nbytes = duk__buffer_nbytes_from_fldtype[magic_ftype];
24197 } else {
24198 nbytes = duk_get_int(ctx, 2);
24199 if (nbytes < 1 || nbytes > 6) {
24200 goto fail_field_length;
24201 }
24202 }
24203 DUK_ASSERT(nbytes >= 1 && nbytes <= 8);
24204
24205 /* Now we can check offset validity. */
24206 if (offset_signed < 0) {
24207 goto fail_bounds;
24208 }
24209
24210 DUK_DDD(DUK_DDDPRINT("writefield, value=%!T, buffer_length=%ld, offset=%ld, no_assert=%d, "
24211 "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, "
24212 "endswap=%d",
24213 duk_get_tval(ctx, 0), (long) buffer_length, (long) offset, (int) no_assert,
24214 (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3),
24215 (int) (magic_signed >> 4), (int) endswap));
24216
24217 /* Coerce value to a number before computing check_length, so that
24218 * the field type specific coercion below can't have side effects
24219 * that would invalidate check_length.
24220 */
24221 duk_to_number(ctx, 0);
24222
24223 /* Update 'buffer_length' to be the effective, safe limit which
24224 * takes into account the underlying buffer. This value will be
24225 * potentially invalidated by any side effect.
24226 */
24227 check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length);
24228 DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld",
24229 (long) buffer_length, (long) check_length));
24230
24231 if (h_this->buf) {
24232 buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this);
24233 } else {
24234 /* Neutered. We could go into the switch-case safely with
24235 * buf == NULL because check_length == 0. To avoid scanbuild
24236 * warnings, fail directly instead.
24237 */
24238 DUK_ASSERT(check_length == 0);
24239 goto fail_neutered;
24240 }
24241 DUK_ASSERT(buf != NULL);
24242
24243 switch (magic_ftype) {
24244 case DUK__FLD_8BIT: {
24245 if (offset + 1U > check_length) {
24246 goto fail_bounds;
24247 }
24248 /* sign doesn't matter when writing */
24249 buf[offset] = (duk_uint8_t) duk_to_uint32(ctx, 0);
24250 break;
24251 }
24252 case DUK__FLD_16BIT: {
24253 duk_uint16_t tmp;
24254 if (offset + 2U > check_length) {
24255 goto fail_bounds;
24256 }
24257 tmp = (duk_uint16_t) duk_to_uint32(ctx, 0);
24258 if (endswap) {
24259 tmp = DUK_BSWAP16(tmp);
24260 }
24261 du.us[0] = tmp;
24262 /* sign doesn't matter when writing */
24263 DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 2);
24264 break;
24265 }
24266 case DUK__FLD_32BIT: {
24267 duk_uint32_t tmp;
24268 if (offset + 4U > check_length) {
24269 goto fail_bounds;
24270 }
24271 tmp = (duk_uint32_t) duk_to_uint32(ctx, 0);
24272 if (endswap) {
24273 tmp = DUK_BSWAP32(tmp);
24274 }
24275 du.ui[0] = tmp;
24276 /* sign doesn't matter when writing */
24277 DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4);
24278 break;
24279 }
24280 case DUK__FLD_FLOAT: {
24281 duk_uint32_t tmp;
24282 if (offset + 4U > check_length) {
24283 goto fail_bounds;
24284 }
24285 du.f[0] = (duk_float_t) duk_to_number(ctx, 0);
24286 if (endswap) {
24287 tmp = du.ui[0];
24288 tmp = DUK_BSWAP32(tmp);
24289 du.ui[0] = tmp;
24290 }
24291 /* sign doesn't matter when writing */
24292 DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4);
24293 break;
24294 }
24295 case DUK__FLD_DOUBLE: {
24296 if (offset + 8U > check_length) {
24297 goto fail_bounds;
24298 }
24299 du.d = (duk_double_t) duk_to_number(ctx, 0);
24300 if (endswap) {
24302 }
24303 /* sign doesn't matter when writing */
24304 DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 8);
24305 break;
24306 }
24307 case DUK__FLD_VARINT: {
24308 /* Node.js Buffer variable width integer field. We don't really
24309 * care about speed here, so aim for shortest algorithm.
24310 */
24311 duk_int_t field_bytelen;
24312 duk_int_t i, i_step, i_end;
24313#if defined(DUK_USE_64BIT_OPS)
24314 duk_int64_t tmp;
24315#else
24316 duk_double_t tmp;
24317#endif
24318 duk_uint8_t *p;
24319
24320 field_bytelen = (duk_int_t) nbytes;
24321 if (offset + (duk_uint_t) field_bytelen > check_length) {
24322 goto fail_bounds;
24323 }
24324
24325 /* Slow writing of value using either 64-bit arithmetic
24326 * or IEEE doubles if 64-bit types not available. There's
24327 * no special sign handling when writing varints.
24328 */
24329
24330 if (magic_bigendian) {
24331 /* Write in big endian */
24332 i = field_bytelen; /* one i_step added at top of loop */
24333 i_step = -1;
24334 i_end = 0;
24335 } else {
24336 /* Write in little endian */
24337 i = -1; /* one i_step added at top of loop */
24338 i_step = 1;
24339 i_end = field_bytelen - 1;
24340 }
24341
24342 /* XXX: The duk_to_number() cast followed by integer coercion
24343 * is platform specific so NaN, +/- Infinity, and out-of-bounds
24344 * values result in platform specific output now.
24345 * See: test-bi-nodejs-buffer-proto-varint-special.js
24346 */
24347
24348#if defined(DUK_USE_64BIT_OPS)
24349 tmp = (duk_int64_t) duk_to_number(ctx, 0);
24350 p = (duk_uint8_t *) (buf + offset);
24351 do {
24352 i += i_step;
24353 DUK_ASSERT(i >= 0 && i < field_bytelen);
24354 p[i] = (duk_uint8_t) (tmp & 0xff);
24355 tmp = tmp >> 8; /* unnecessary shift for last byte */
24356 } while (i != i_end);
24357#else
24358 tmp = duk_to_number(ctx, 0);
24359 p = (duk_uint8_t *) (buf + offset);
24360 do {
24361 i += i_step;
24362 tmp = DUK_FLOOR(tmp);
24363 DUK_ASSERT(i >= 0 && i < field_bytelen);
24364 p[i] = (duk_uint8_t) (DUK_FMOD(tmp, 256.0));
24365 tmp = tmp / 256.0; /* unnecessary div for last byte */
24366 } while (i != i_end);
24367#endif
24368 break;
24369 }
24370 default: { /* should never happen but default here */
24371 goto fail_bounds;
24372 }
24373 }
24374
24375 /* Node.js Buffer: return offset + #bytes written (i.e. next
24376 * write offset).
24377 */
24378 if (magic_typedarray) {
24379 /* For TypedArrays 'undefined' return value is specified
24380 * by ES6 (matches V8).
24381 */
24382 return 0;
24383 }
24384 duk_push_uint(ctx, offset + nbytes);
24385 return 1;
24386
24387 fail_neutered:
DUK_EXTERNAL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2)
static const duk_uint8_t duk__buffer_nbytes_from_fldtype[6]
DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx)

◆ duk_bi_dataview_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_dataview_constructor ( duk_context * ctx)

Definition at line 22625 of file duktape-1.5.2/src/duktape.c.

22631 :
22632 return DUK_RET_RANGE_ERROR;
22633}
22634#else /* DUK_USE_BUFFEROBJECT_SUPPORT */
22636 DUK_UNREF(ctx);
22638}
22639#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22640
22641#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22643 duk_hbufferobject *h_bufarg;
22644 duk_hbufferobject *h_bufobj;
22645 duk_hbuffer *h_val;
22646 duk_uint_t offset;
22647 duk_uint_t length;
22648
22649 /* XXX: function flag to make this automatic? */
22650 if (!duk_is_constructor_call(ctx)) {
22651 return DUK_RET_TYPE_ERROR;
22652 }
22653
22654 h_bufarg = duk__require_bufobj_value(ctx, 0);
22655 DUK_ASSERT(h_bufarg != NULL);
22656
22657 duk__resolve_offset_opt_length(ctx, h_bufarg, 1, 2, &offset, &length, 1 /*throw_flag*/);
22658 DUK_ASSERT(offset <= h_bufarg->length);
22659 DUK_ASSERT(offset + length <= h_bufarg->length);
22660
22661 h_bufobj = duk_push_bufferobject_raw(ctx,
22666
22667 h_val = h_bufarg->buf;
22668 if (h_val == NULL) {
22669 return DUK_RET_TYPE_ERROR;
22670 }
22671 h_bufobj->buf = h_val;
22672 DUK_HBUFFER_INCREF(thr, h_val);
22673 h_bufobj->offset = h_bufarg->offset + offset;
22674 h_bufobj->length = length;
22675 DUK_ASSERT(h_bufobj->shift == 0);
22677 h_bufobj->is_view = 1;
22678
22679 /* The DataView .buffer property is ordinarily set to the argument
DUK_INTERNAL_DECL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx)
#define DUK_BIDX_DATAVIEW_PROTOTYPE
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_INTERNAL_DECL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx)

◆ duk_bi_date_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor ( duk_context * ctx)

Definition at line 25837 of file duktape-1.5.2/src/duktape.c.

25844 {
25846 DUK_ASSERT(magicidx >= 0 && magicidx < (duk_small_int_t) (sizeof(duk__date_magics) / sizeof(duk_uint16_t)));
25847 return (duk_small_uint_t) duk__date_magics[magicidx];
25848}
25849
25850/*
25851 * Constructor calls
25852 */
25853
25855 duk_idx_t nargs = duk_get_top(ctx);
25856 duk_bool_t is_cons = duk_is_constructor_call(ctx);
25858 duk_double_t d;
25859
25860 DUK_DDD(DUK_DDDPRINT("Date constructor, nargs=%ld, is_cons=%ld", (long) nargs, (long) is_cons));
25861
25866
25867 /* Unlike most built-ins, the internal [[PrimitiveValue]] of a Date
25868 * is mutable.
25869 */
25870
25871 if (nargs == 0 || !is_cons) {
25872 d = duk__timeclip(DUK_USE_DATE_GET_NOW(ctx));
25873 duk_push_number(ctx, d);
25875 if (!is_cons) {
25876 /* called as a normal function: return new Date().toString() */
25877 duk_to_string(ctx, -1);
25878 }
25879 return 1;
25880 } else if (nargs == 1) {
25882 if (duk_is_string(ctx, 0)) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor(duk_context *ctx)
static duk_uint16_t duk__date_magics[]
#define DUK_BIDX_DATE_PROTOTYPE
DUK_LOCAL duk_double_t duk__timeclip(duk_double_t x)

◆ duk_bi_date_constructor_now()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_now ( duk_context * ctx)

Definition at line 25907 of file duktape-1.5.2/src/duktape.c.

25914 {

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 25884 of file duktape-1.5.2/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 25888 of file duktape-1.5.2/src/duktape.c.

25901 {
25902 return duk__parse_string(ctx, duk_to_string(ctx, 0));
25903}
25904
DUK_LOCAL duk_ret_t duk__parse_string(duk_context *ctx, const char *str)
DUK_INTERNAL_DECL 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 25678 of file duktape-1.5.2/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 26182 of file duktape-1.5.2/src/duktape.c.

26188 {
26189 time_t t;
26190
26191 DUK_UNREF(ctx);
26192 t = time(NULL);
26193 return ((duk_double_t) t) * 1000.0;
26194}
26195#endif /* DUK_USE_DATE_NOW_TIME */
26196
26197#if defined(DUK_USE_DATE_TZO_GMTIME) || defined(DUK_USE_DATE_TZO_GMTIME_R)
26198/* Get local time offset (in seconds) for a certain (UTC) instant 'd'. */
26200 time_t t, t1, t2;
26203 struct tm tms[2];
26204#ifdef DUK_USE_DATE_TZO_GMTIME
26205 struct tm *tm_ptr;
26206#endif
26207
26208 /* For NaN/inf, the return value doesn't matter. */
26209 if (!DUK_ISFINITE(d)) {
26210 return 0;
26211 }
26212
26213 /* If not within Ecmascript range, some integer time calculations
26214 * won't work correctly (and some asserts will fail), so bail out
26215 * if so. This fixes test-bug-date-insane-setyear.js. There is
26216 * a +/- 24h leeway in this range check to avoid a test262 corner
26217 * case documented in test-bug-date-timeval-edges.js.
26218 */
26220 DUK_DD(DUK_DDPRINT("timeval not within valid range, skip tzoffset computation to avoid integer overflows"));
26221 return 0;
26222 }
26223
26224 /*
26225 * This is a bit tricky to implement portably. The result depends
26226 * on the timestamp (specifically, DST depends on the timestamp).
26227 * If e.g. UNIX APIs are used, they'll have portability issues with
26228 * very small and very large years.
26229 *
26230 * Current approach:
26231 *
26232 * - Stay within portable UNIX limits by using equivalent year mapping.
26233 * Avoid year 1970 and 2038 as some conversions start to fail, at
26234 * least on some platforms. Avoiding 1970 means that there are
26235 * currently DST discrepancies for 1970.
26236 *
26237 * - Create a UTC and local time breakdowns from 't'. Then create
26238 * a time_t using gmtime() and localtime() and compute the time
26239 * difference between the two.
26240 *
26241 * Equivalent year mapping (E5 Section 15.9.1.8):
26242 *
26243 * If the host environment provides functionality for determining
26244 * daylight saving time, the implementation of ECMAScript is free
26245 * to map the year in question to an equivalent year (same
26246 * leap-year-ness and same starting week day for the year) for which
26247 * the host environment provides daylight saving time information.
26248 * The only restriction is that all equivalent years should produce
26249 * the same result.
26250 *
26251 * This approach is quite reasonable but not entirely correct, e.g.
26252 * the specification also states (E5 Section 15.9.1.8):
26253 *
26254 * The implementation of ECMAScript should not try to determine
26255 * whether the exact time was subject to daylight saving time, but
26256 * just whether daylight saving time would have been in effect if
26257 * the _current daylight saving time algorithm_ had been used at the
26258 * time. This avoids complications such as taking into account the
26259 * years that the locale observed daylight saving time year round.
26260 *
26261 * Since we rely on the platform APIs for conversions between local
26262 * time and UTC, we can't guarantee the above. Rather, if the platform
26263 * has historical DST rules they will be applied. This seems to be the
26264 * general preferred direction in Ecmascript standardization (or at least
26265 * implementations) anyway, and even the equivalent year mapping should
26266 * be disabled if the platform is known to handle DST properly for the
26267 * full Ecmascript range.
26268 *
26269 * The following has useful discussion and links:
26270 *
26271 * https://bugzilla.mozilla.org/show_bug.cgi?id=351066
26272 */
26273
26274 duk_bi_date_timeval_to_parts(d, parts, dparts, DUK_DATE_FLAG_EQUIVYEAR /*flags*/);
26275 DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= 1970 && parts[DUK_DATE_IDX_YEAR] <= 2038);
26276
26277 d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/);
26278 DUK_ASSERT(d >= 0 && d < 2147483648.0 * 1000.0); /* unsigned 31-bit range */
26279 t = (time_t) (d / 1000.0);
26280 DUK_DDD(DUK_DDDPRINT("timeval: %lf -> time_t %ld", (double) d, (long) t));
26281
26282 DUK_MEMZERO((void *) tms, sizeof(struct tm) * 2);
26283
26284#if defined(DUK_USE_DATE_TZO_GMTIME_R)
26285 (void) gmtime_r(&t, &tms[0]);
26286 (void) localtime_r(&t, &tms[1]);
26287#elif defined(DUK_USE_DATE_TZO_GMTIME)
26288 tm_ptr = gmtime(&t);
26289 DUK_MEMCPY((void *) &tms[0], tm_ptr, sizeof(struct tm));
26290 tm_ptr = localtime(&t);
26291 DUK_MEMCPY((void *) &tms[1], tm_ptr, sizeof(struct tm));
26292#else
26293#error internal error
26294#endif
26295 DUK_DDD(DUK_DDDPRINT("gmtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
26296 "wday:%ld,yday:%ld,isdst:%ld}",
26297 (long) tms[0].tm_sec, (long) tms[0].tm_min, (long) tms[0].tm_hour,
26298 (long) tms[0].tm_mday, (long) tms[0].tm_mon, (long) tms[0].tm_year,
26299 (long) tms[0].tm_wday, (long) tms[0].tm_yday, (long) tms[0].tm_isdst));
26300 DUK_DDD(DUK_DDDPRINT("localtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
26301 "wday:%ld,yday:%ld,isdst:%ld}",
26302 (long) tms[1].tm_sec, (long) tms[1].tm_min, (long) tms[1].tm_hour,
26303 (long) tms[1].tm_mday, (long) tms[1].tm_mon, (long) tms[1].tm_year,
26304 (long) tms[1].tm_wday, (long) tms[1].tm_yday, (long) tms[1].tm_isdst));
26305
26306 /* tm_isdst is both an input and an output to mktime(), use 0 to
26307 * avoid DST handling in mktime():
26308 * - https://github.com/svaarala/duktape/issues/406
26309 * - http://stackoverflow.com/questions/8558919/mktime-and-tm-isdst
26310 */
26311 tms[0].tm_isdst = 0;
26312 tms[1].tm_isdst = 0;
26313 t1 = mktime(&tms[0]); /* UTC */
26314 t2 = mktime(&tms[1]); /* local */
26315 if (t1 == (time_t) -1 || t2 == (time_t) -1) {
26316 /* This check used to be for (t < 0) but on some platforms
26317 * time_t is unsigned and apparently the proper way to detect
26318 * an mktime() error return is the cast above. See e.g.:
26319 * http://pubs.opengroup.org/onlinepubs/009695299/functions/mktime.html
26320 */
26321 goto error;
26322 }
26323 DUK_DDD(DUK_DDDPRINT("t1=%ld (utc), t2=%ld (local)", (long) t1, (long) t2));
26324
#define DUK_DATE_FLAG_EQUIVYEAR
DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d)

◆ duk_bi_date_get_now_time()

DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_time ( duk_context * ctx)

Definition at line 26171 of file duktape-1.5.2/src/duktape.c.

26174 {
26176 }
26177

◆ 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 25155 of file duktape-1.5.2/src/duktape.c.

25159 {
25160 for (i = 0; i < DUK_DATE_IDX_NUM_PARTS; i++) {
25161 dparts[i] = (duk_double_t) parts[i];
25162 }
25163 }
25164}
25165
25166/* Compute time value from (double) parts. The parts can be either UTC
25167 * or local time; if local, they need to be (conceptually) converted into
25168 * UTC time. The parts may represent valid or invalid time, and may be
25169 * wildly out of range (but may cancel each other and still come out in
25170 * the valid Date range).
25171 */
25173#if defined(DUK_USE_PARANOID_DATE_COMPUTATION)
25174 /* See comments below on MakeTime why these are volatile. */
25175 volatile duk_double_t tmp_time;
25176 volatile duk_double_t tmp_day;
25177 volatile duk_double_t d;
25178#else
25179 duk_double_t tmp_time;
25180 duk_double_t tmp_day;
25181 duk_double_t d;
25182#endif
25184 duk_int_t tzoff, tzoffprev1, tzoffprev2;
25185
25186 /* Expects 'this' at top of stack on entry. */
25187
25188 /* Coerce all finite parts with ToInteger(). ToInteger() must not
25189 * be called for NaN/Infinity because it will convert e.g. NaN to
25190 * zero. If ToInteger() has already been called, this has no side
25191 * effects and is idempotent.
25192 *
25193 * Don't read dparts[DUK_DATE_IDX_WEEKDAY]; it will cause Valgrind
25194 * issues if the value is uninitialized.
25195 */
25196 for (i = 0; i <= DUK_DATE_IDX_MILLISECOND; i++) {
25197 /* SCANBUILD: scan-build complains here about assigned value
25198 * being garbage or undefined. This is correct but operating
25199 * on undefined values has no ill effect and is ignored by the
25200 * caller in the case where this happens.
25201 */
25202 d = dparts[i];
25203 if (DUK_ISFINITE(d)) {
25204 dparts[i] = duk_js_tointeger_number(d);
25205 }
25206 }
25207
25208 /* Use explicit steps in computation to try to ensure that
25209 * computation happens with intermediate results coerced to
25210 * double values (instead of using something more accurate).
25211 * E.g. E5.1 Section 15.9.1.11 requires use of IEEE 754
25212 * rules (= Ecmascript '+' and '*' operators).
25213 *
25214 * Without 'volatile' even this approach fails on some platform
25215 * and compiler combinations. For instance, gcc 4.8.1 on Ubuntu
25216 * 64-bit, with -m32 and without -std=c99, test-bi-date-canceling.js
25217 * would fail because of some optimizations when computing tmp_time
25218 * (MakeTime below). Adding 'volatile' to tmp_time solved this
25219 * particular problem (annoyingly, also adding debug prints or
25220 * running the executable under valgrind hides it).
25221 */
25222
25223 /* MakeTime */
25224 tmp_time = 0.0;
25225 tmp_time += dparts[DUK_DATE_IDX_HOUR] * ((duk_double_t) DUK_DATE_MSEC_HOUR);
25226 tmp_time += dparts[DUK_DATE_IDX_MINUTE] * ((duk_double_t) DUK_DATE_MSEC_MINUTE);
25227 tmp_time += dparts[DUK_DATE_IDX_SECOND] * ((duk_double_t) DUK_DATE_MSEC_SECOND);
25228 tmp_time += dparts[DUK_DATE_IDX_MILLISECOND];
25229
25230 /* MakeDay */
25231 tmp_day = duk__make_day(dparts[DUK_DATE_IDX_YEAR], dparts[DUK_DATE_IDX_MONTH], dparts[DUK_DATE_IDX_DAY]);
25232
25233 /* MakeDate */
25234 d = tmp_day * ((duk_double_t) DUK_DATE_MSEC_DAY) + tmp_time;
25235
25236 DUK_DDD(DUK_DDDPRINT("time=%lf day=%lf --> timeval=%lf",
25237 (double) tmp_time, (double) tmp_day, (double) d));
25238
25239 /* Optional UTC conversion. */
25240 if (flags & DUK_DATE_FLAG_LOCALTIME) {
25241 /* DUK_USE_DATE_GET_LOCAL_TZOFFSET() needs to be called with a
25242 * time value computed from UTC parts. At this point we only
25243 * have 'd' which is a time value computed from local parts, so
25244 * it is off by the UTC-to-local time offset which we don't know
25245 * yet. The current solution for computing the UTC-to-local
25246 * time offset is to iterate a few times and detect a fixed
25247 * point or a two-cycle loop (or a sanity iteration limit),
25248 * see test-bi-date-local-parts.js and test-bi-date-tzoffset-basic-fi.js.
25249 *
25250 * E5.1 Section 15.9.1.9:
25251 * UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA)
25252 *
25253 * For NaN/inf, DUK_USE_DATE_GET_LOCAL_TZOFFSET() returns 0.
25254 */
25255
25256#if 0
25257 /* Old solution: don't iterate, incorrect */
25258 tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d);
25259 DUK_DDD(DUK_DDDPRINT("tzoffset w/o iteration, tzoff=%ld", (long) tzoff));
25260 d -= tzoff * 1000L;
25261 DUK_UNREF(tzoffprev1);
25262 DUK_UNREF(tzoffprev2);
25263#endif
25264
25265 /* Iteration solution */
25266 tzoff = 0;
25267 tzoffprev1 = 999999999L; /* invalid value which never matches */
25268 for (i = 0; i < DUK__LOCAL_TZOFFSET_MAXITER; i++) {
25269 tzoffprev2 = tzoffprev1;
25270 tzoffprev1 = tzoff;
25271 tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d - tzoff * 1000L);
25272 DUK_DDD(DUK_DDDPRINT("tzoffset iteration, i=%d, tzoff=%ld, tzoffprev1=%ld tzoffprev2=%ld",
25273 (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
25274 if (tzoff == tzoffprev1) {
25275 DUK_DDD(DUK_DDDPRINT("tzoffset iteration finished, i=%d, tzoff=%ld, tzoffprev1=%ld, tzoffprev2=%ld",
25276 (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
25277 break;
25278 } else if (tzoff == tzoffprev2) {
25279 /* Two value cycle, see e.g. test-bi-date-tzoffset-basic-fi.js.
25280 * In these cases, favor a higher tzoffset to get a consistent
25281 * result which is independent of iteration count. Not sure if
25282 * this is a generically correct solution.
25283 */
#define DUK__LOCAL_TZOFFSET_MAXITER

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 24845 of file duktape-1.5.2/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 26032 of file duktape-1.5.2/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 26037 of file duktape-1.5.2/src/duktape.c.

26038 :
26039 *
26040 * - Date.prototype.getDate(): 'date' means day-of-month, and is
26041 * zero-based in internal calculations but public API expects it to
26042 * be one-based.
26043 *
26044 * - Date.prototype.getTime() and Date.prototype.valueOf() have identical
26045 * behavior. They have separate function objects, but share the same C
26046 * function (duk_bi_date_prototype_value_of).
26047 */
26048
26051 return duk__get_part_helper(ctx, flags_and_idx);
26052}
26053
26055 /*
26056 * Return (t - LocalTime(t)) in minutes:
26057 *
26058 * t - LocalTime(t) = t - (t + LocalTZA + DaylightSavingTA(t))
26059 * = -(LocalTZA + DaylightSavingTA(t))
26060 *
26061 * where DaylightSavingTA() is checked for time 't'.
26062 *
26063 * Note that the sign of the result is opposite to common usage,
26064 * e.g. for EE(S)T which normally is +2h or +3h from UTC, this
26065 * function returns -120 or -180.
26066 *
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_value_of(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ctx)
DUK_LOCAL duk_ret_t duk__get_part_helper(duk_context *ctx, duk_small_uint_t flags_and_idx)
DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic(duk_context *ctx)

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 26117 of file duktape-1.5.2/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 26122 of file duktape-1.5.2/src/duktape.c.

26123 : special year check
26124 * is omitted. NaN / Infinity will just flow through and ultimately
26125 * result in a NaN internal time value.
26126 *
26127 * - Date.prototype.setYear() does not have optional arguments for
26128 * setting month and day-in-month (like setFullYear()), but we indicate
26129 * 'maxnargs' to be 3 to get the year written to the correct component
26130 * index in duk__set_part_helper(). The function has nargs == 1, so only
26131 * the year will be set regardless of actual argument count.
26132 */

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 25966 of file duktape-1.5.2/src/duktape.c.

25967 {
25969 return duk__to_string_helper(ctx, flags);
25970}
25971
25973 /* This native function is also used for Date.prototype.getTime()
25974 * as their behavior is identical.
25975 */
25976
25977 duk_double_t d = duk__push_this_get_timeval(ctx, 0 /*flags*/); /* -> [ this ] */
25979 duk_push_number(ctx, d);
25980 return 1;
25981}
25982
25984 /* Note: toJSON() is a generic function which works even if 'this'
25985 * is not a Date. The sole argument is ignored.
25986 */
25987
25988 duk_push_this(ctx);
25989 duk_to_object(ctx, -1);
DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_to_json(duk_context *ctx)

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 25950 of file duktape-1.5.2/src/duktape.c.

25952 :
25953 *

◆ duk_bi_date_prototype_value_of()

DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_value_of ( duk_context * ctx)

Definition at line 25955 of file duktape-1.5.2/src/duktape.c.

25958 : E5.1 specification does not require a
25959 * specific format, but result should be human readable. The
25960 * specification suggests using ISO 8601 format with a space (instead
25961 * of 'T') separator if a more human readable format is not available.
25962 *
25963 * - Date.prototype.toISOString(): unlike other conversion functions,
25964 * toISOString() requires a RangeError for invalid date values.
json_t format(printf, 1, 2)))
static int readable(const char *filename)

◆ 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 24862 of file duktape-1.5.2/src/duktape.c.

24862 {
24863 if ((year % 4) != 0) {
24864 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 24858 of file duktape-1.5.2/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 25010 of file duktape-1.5.2/src/duktape.c.

25012 {
25013 day_num += duk__days_in_month[i];
25014 if (i == 1 && is_leap) {
25015 day_num++;
25016 }
25017 }
25018
25019 /* If 'day' is NaN, returns NaN. */
25020 return (duk_double_t) day_num + day;
25021}
25022
25023/* Split time value into parts. The time value is assumed to be an internal
25024 * one, i.e. finite, no fractions. Possible local time adjustment has already
25025 * been applied when reading the time value.
25026 */
25028 duk_double_t d1, d2;
25029 duk_int_t t1, t2;
25030 duk_int_t day_since_epoch;
25031 duk_int_t year; /* does not fit into 16 bits */
25032 duk_small_int_t day_in_year;
25033 duk_small_int_t month;
25034 duk_small_int_t day;
25035 duk_small_int_t dim;
25036 duk_int_t jan1_since_epoch;
25037 duk_small_int_t jan1_weekday;
25038 duk_int_t equiv_year;
25040 duk_bool_t is_leap;
25041 duk_small_int_t arridx;
25042
25043 DUK_ASSERT(DUK_ISFINITE(d)); /* caller checks */
25044 DUK_ASSERT(DUK_FLOOR(d) == d); /* no fractions in internal time */
25045
25046 /* The timevalue must be in valid Ecmascript range, but since a local
25047 * time offset can be applied, we need to allow a +/- 24h leeway to
25048 * the value. In other words, although the UTC time is within the
25049 * Ecmascript range, the local part values can be just outside of it.
25050 */
25053
25054 /* these computations are guaranteed to be exact for the valid
25055 * E5 time value range, assuming milliseconds without fractions.
25056 */
25057 d1 = (duk_double_t) DUK_FMOD(d, (double) DUK_DATE_MSEC_DAY);
25058 if (d1 < 0.0) {
25059 /* deal with negative values */
25061 }
25062 d2 = DUK_FLOOR((double) (d / (duk_double_t) DUK_DATE_MSEC_DAY));
25063 DUK_ASSERT(d2 * ((duk_double_t) DUK_DATE_MSEC_DAY) + d1 == d);
25064 /* now expected to fit into a 32-bit integer */
25065 t1 = (duk_int_t) d1;
25066 t2 = (duk_int_t) d2;
25067 day_since_epoch = t2;
25068 DUK_ASSERT((duk_double_t) t1 == d1);
25069 DUK_ASSERT((duk_double_t) t2 == d2);
25070
25071 /* t1 = milliseconds within day (fits 32 bit)
25072 * t2 = day number from epoch (fits 32 bit, may be negative)
25073 */
25074
25075 parts[DUK_DATE_IDX_MILLISECOND] = t1 % 1000; t1 /= 1000;
25076 parts[DUK_DATE_IDX_SECOND] = t1 % 60; t1 /= 60;
25077 parts[DUK_DATE_IDX_MINUTE] = t1 % 60; t1 /= 60;
25078 parts[DUK_DATE_IDX_HOUR] = t1;
25079 DUK_ASSERT(parts[DUK_DATE_IDX_MILLISECOND] >= 0 && parts[DUK_DATE_IDX_MILLISECOND] <= 999);
25080 DUK_ASSERT(parts[DUK_DATE_IDX_SECOND] >= 0 && parts[DUK_DATE_IDX_SECOND] <= 59);
25081 DUK_ASSERT(parts[DUK_DATE_IDX_MINUTE] >= 0 && parts[DUK_DATE_IDX_MINUTE] <= 59);
25082 DUK_ASSERT(parts[DUK_DATE_IDX_HOUR] >= 0 && parts[DUK_DATE_IDX_HOUR] <= 23);
25083
25084 DUK_DDD(DUK_DDDPRINT("d=%lf, d1=%lf, d2=%lf, t1=%ld, t2=%ld, parts: hour=%ld min=%ld sec=%ld msec=%ld",
25085 (double) d, (double) d1, (double) d2, (long) t1, (long) t2,
25086 (long) parts[DUK_DATE_IDX_HOUR],
25087 (long) parts[DUK_DATE_IDX_MINUTE],
25088 (long) parts[DUK_DATE_IDX_SECOND],
25089 (long) parts[DUK_DATE_IDX_MILLISECOND]));
25090
25091 /* This assert depends on the input parts representing time inside
25092 * the Ecmascript range.
25093 */
25095 parts[DUK_DATE_IDX_WEEKDAY] = (t2 + 4 + DUK__WEEKDAY_MOD_ADDER) % 7; /* E5.1 Section 15.9.1.6 */
25096 DUK_ASSERT(parts[DUK_DATE_IDX_WEEKDAY] >= 0 && parts[DUK_DATE_IDX_WEEKDAY] <= 6);
25097
25098 year = duk__year_from_day(t2, &day_in_year);
25099 day = day_in_year;
25100 is_leap = duk_bi_date_is_leap_year(year);
25101 for (month = 0; month < 12; month++) {
25102 dim = duk__days_in_month[month];
25103 if (month == 1 && is_leap) {
25104 dim++;
25105 }
25106 DUK_DDD(DUK_DDDPRINT("month=%ld, dim=%ld, day=%ld",
25107 (long) month, (long) dim, (long) day));
25108 if (day < dim) {
25109 break;
25110 }
25111 day -= dim;
25112 }
25113 DUK_DDD(DUK_DDDPRINT("final month=%ld", (long) month));
25114 DUK_ASSERT(month >= 0 && month <= 11);
25115 DUK_ASSERT(day >= 0 && day <= 31);
25116
25117 /* Equivalent year mapping, used to avoid DST trouble when platform
25118 * may fail to provide reasonable DST answers for dates outside the
25119 * ordinary range (e.g. 1970-2038). An equivalent year has the same
25120 * leap-year-ness as the original year and begins on the same weekday
25121 * (Jan 1).
25122 *
25123 * The year 2038 is avoided because there seem to be problems with it
25124 * on some platforms. The year 1970 is also avoided as there were
25125 * practical problems with it; an equivalent year is used for it too,
25126 * which breaks some DST computations for 1970 right now, see e.g.
25127 * test-bi-date-tzoffset-brute-fi.js.
25128 */
25129 if ((flags & DUK_DATE_FLAG_EQUIVYEAR) && (year < 1971 || year > 2037)) {
25130 DUK_ASSERT(is_leap == 0 || is_leap == 1);
25131
25132 jan1_since_epoch = day_since_epoch - day_in_year; /* day number for Jan 1 since epoch */
25133 DUK_ASSERT(jan1_since_epoch + DUK__WEEKDAY_MOD_ADDER >= 0);
25134 jan1_weekday = (jan1_since_epoch + 4 + DUK__WEEKDAY_MOD_ADDER) % 7; /* E5.1 Section 15.9.1.6 */
25135 DUK_ASSERT(jan1_weekday >= 0 && jan1_weekday <= 6);
25136 arridx = jan1_weekday;
25137 if (is_leap) {
25138 arridx += 7;
25139 }
25140 DUK_ASSERT(arridx >= 0 && arridx < (duk_small_int_t) (sizeof(duk__date_equivyear) / sizeof(duk_uint8_t)));
25141
25142 equiv_year = (duk_int_t) duk__date_equivyear[arridx] + 1970;
25143 year = equiv_year;
25144 DUK_DDD(DUK_DDDPRINT("equiv year mapping, year=%ld, day_in_year=%ld, day_since_epoch=%ld, "
25145 "jan1_since_epoch=%ld, jan1_weekday=%ld -> equiv year %ld",
25146 (long) year, (long) day_in_year, (long) day_since_epoch,
25147 (long) jan1_since_epoch, (long) jan1_weekday, (long) equiv_year));
DUK_INTERNAL_DECL duk_bool_t duk_bi_date_is_leap_year(duk_int_t year)
#define DUK__WEEKDAY_MOD_ADDER
DUK_LOCAL duk_uint8_t duk__date_equivyear[14]
DUK_LOCAL duk_uint8_t duk__days_in_month[12]

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 24866 of file duktape-1.5.2/src/duktape.c.

24866 {
24867 return 1;
24868 }

◆ duk_bi_duktape_object_act()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_act ( duk_context * ctx)

Definition at line 26676 of file duktape-1.5.2/src/duktape.c.

26681 :
26682 /* set values into ret array */
26683 /* XXX: primitive to make array from valstack slice */
26684 n = duk_get_top(ctx);
26685 for (i = 2; i < n; i++) {
26686 duk_dup(ctx, i);
26687 duk_put_prop_index(ctx, 1, i - 2);
26688 }
26689 duk_dup(ctx, 1);
26690 return 1;
26691}
26692
26694 duk_hthread *thr = (duk_hthread *) ctx;
26695 duk_activation *act;
26697 duk_uint_fast32_t line;
26698 duk_int_t level;
26699
26700 /* -1 = top callstack entry, callstack[callstack_top - 1]
26701 * -callstack_top = bottom callstack entry, callstack[0]
26702 */
26703 level = duk_to_int(ctx, 0);
26704 if (level >= 0 || -level > (duk_int_t) thr->callstack_top) {
26705 return 0;
26706 }
26707 DUK_ASSERT(level >= -((duk_int_t) thr->callstack_top) && level <= -1);
26708 act = thr->callstack + thr->callstack_top + level;
26709
26710 duk_push_object(ctx);
26711
26712 duk_push_tval(ctx, &act->tv_func);
26713
26714 /* Relevant PC is just before current one because PC is
26715 * post-incremented. This should match what error augment
26716 * code does.
26717 */
26718 pc = duk_hthread_get_act_prev_pc(thr, act);
26719 duk_push_uint(ctx, (duk_uint_t) pc);
26720
26721#if defined(DUK_USE_PC2LINE)
26722 line = duk_hobject_pc2line_query(ctx, -2, pc);
26723#else
26724 line = 0;
DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act)
DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx)

◆ duk_bi_duktape_object_compact()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_compact ( duk_context * ctx)

Definition at line 26859 of file duktape-1.5.2/src/duktape.c.

26860 {
26862 1 /*idx_value*/,
26863 2 /*idx_replacer*/,
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_bi_duktape_object_dec()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_dec ( duk_context * ctx)

Definition at line 26813 of file duktape-1.5.2/src/duktape.c.

26816 {
26818 1 /*idx_value*/,
26819 2 /*idx_replacer*/,
26820 3 /*idx_space*/,
26822 DUK_JSON_FLAG_ASCII_ONLY /*flags*/);
26823#endif
26824 } else {
26825 return DUK_RET_TYPE_ERROR;
26826 }
26827 return 1;
26828}
26829
26831 duk_hthread *thr = (duk_hthread *) ctx;
26832 duk_hstring *h_str;
26833
26834 DUK_UNREF(thr);
26835
26836 /* Vararg function: must be careful to check/require arguments.
26837 * The JSON helpers accept invalid indices and treat them like
26838 * non-existent optional parameters.
26839 */
26840
26841 h_str = duk_require_hstring(ctx, 0);
26843
26844 if (h_str == DUK_HTHREAD_STRING_HEX(thr)) {
26845 duk_set_top(ctx, 2);
26846 duk_hex_decode(ctx, 1);
26847 DUK_ASSERT_TOP(ctx, 2);
26848 } else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) {
26849 duk_set_top(ctx, 2);
26850 duk_base64_decode(ctx, 1);
26851 DUK_ASSERT_TOP(ctx, 2);
26852#ifdef DUK_USE_JX
26853 } else if (h_str == DUK_HTHREAD_STRING_JX(thr)) {
#define DUK_HTHREAD_STRING_BASE64(thr)
#define DUK_HTHREAD_STRING_JX(thr)
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_DECL duk_ret_t duk_bi_duktape_object_dec(duk_context *ctx)
DUK_EXTERNAL void duk_require_valid_index(duk_context *ctx, duk_idx_t index)
#define DUK_HTHREAD_STRING_HEX(thr)
DUK_EXTERNAL void duk_hex_decode(duk_context *ctx, duk_idx_t index)
#define DUK_JSON_FLAG_ASCII_ONLY

◆ duk_bi_duktape_object_enc()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_enc ( duk_context * ctx)

Definition at line 26766 of file duktape-1.5.2/src/duktape.c.

26775 {
26776 /* Get. */
26777 DUK_ASSERT(duk_get_top(ctx) == 1);
26779 return 1;
26780 }
26781}
26782
26784 duk_hthread *thr = (duk_hthread *) ctx;
26785 duk_hstring *h_str;
26786
26787 DUK_UNREF(thr);
26788
26789 /* Vararg function: must be careful to check/require arguments.
26790 * The JSON helpers accept invalid indices and treat them like
26791 * non-existent optional parameters.
26792 */
26793
26794 h_str = duk_require_hstring(ctx, 0);
26796
26797 if (h_str == DUK_HTHREAD_STRING_HEX(thr)) {
26798 duk_set_top(ctx, 2);
26799 duk_hex_encode(ctx, 1);
26800 DUK_ASSERT_TOP(ctx, 2);
26801 } else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) {
26802 duk_set_top(ctx, 2);
26803 duk_base64_encode(ctx, 1);
26804 DUK_ASSERT_TOP(ctx, 2);
26805#ifdef DUK_USE_JX
26806 } else if (h_str == DUK_HTHREAD_STRING_JX(thr)) {
26808 1 /*idx_value*/,
26809 2 /*idx_replacer*/,
26810 3 /*idx_space*/,
DUK_EXTERNAL const char * duk_hex_encode(duk_context *ctx, duk_idx_t index)
#define DUK_STRIDX_INT_FINALIZER
DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_enc(duk_context *ctx)

◆ duk_bi_duktape_object_fin()

DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_fin ( duk_context * ctx)

Definition at line 26746 of file duktape-1.5.2/src/duktape.c.

26763 {
26764 (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 26726 of file duktape-1.5.2/src/duktape.c.

26743 {
26744#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 26562 of file duktape-1.5.2/src/duktape.c.

26563 : it might seem that vararg multipurpose functions
26564 * like fin(), enc(), and dec() are not very size optimal, but using a single
26565 * user-visible Ecmascript function saves a lot of run-time footprint; each
26566 * Function instance takes >100 bytes. Using a shared native helper and a
26567 * 'magic' value won't save much if there are multiple Function instances
26568 * anyway.
26569 */
26570
26571/* include removed: duk_internal.h */
26572
26573/* Raw helper to extract internal information / statistics about a value.
26574 * The return values are version specific and must not expose anything
26575 * that would lead to security issues (e.g. exposing compiled function
26576 * 'data' buffer might be an issue). Currently only counts and sizes and
26577 * such are given so there should not be a security impact.
26578 */
26580 duk_hthread *thr = (duk_hthread *) ctx;
26581 duk_tval *tv;
26582 duk_heaphdr *h;
26583 duk_int_t i, n;
26584
26585 DUK_UNREF(thr);
26586
26587 /* result array */
26588 duk_push_array(ctx); /* -> [ val arr ] */
26589
26590 /* type tag (public) */
26591 duk_push_int(ctx, duk_get_type(ctx, 0));
26592
26593 /* address */
26594 tv = duk_get_tval(ctx, 0);
26595 DUK_ASSERT(tv != NULL); /* because arg count is 1 */
26597 h = DUK_TVAL_GET_HEAPHDR(tv);
26598 duk_push_pointer(ctx, (void *) h);
26599 } else {
26600 /* internal type tag */
26602 goto done;
26603 }
26604 DUK_ASSERT(h != NULL);
26605
26606 /* refcount */
26607#ifdef DUK_USE_REFERENCE_COUNTING
26609#else
26610 duk_push_undefined(ctx);
26611#endif
26612
26613 /* heaphdr size and additional allocation size, followed by
26614 * type specific stuff (with varying value count)
26615 */
26617 case DUK_HTYPE_STRING: {
26618 duk_hstring *h_str = (duk_hstring *) h;
26619 duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hstring) + DUK_HSTRING_GET_BYTELEN(h_str) + 1));
26620 break;
26621 }
26622 case DUK_HTYPE_OBJECT: {
26623 duk_hobject *h_obj = (duk_hobject *) h;
26624 duk_small_uint_t hdr_size;
26626 hdr_size = (duk_small_uint_t) sizeof(duk_hcompiledfunction);
26627 } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h_obj)) {
26628 hdr_size = (duk_small_uint_t) sizeof(duk_hnativefunction);
26629 } else if (DUK_HOBJECT_IS_THREAD(h_obj)) {
26630 hdr_size = (duk_small_uint_t) sizeof(duk_hthread);
26631#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
26632 } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
26633 hdr_size = (duk_small_uint_t) sizeof(duk_hbufferobject);
26634#endif
26635 } else {
26636 hdr_size = (duk_small_uint_t) sizeof(duk_hobject);
26637 }
26638 duk_push_uint(ctx, (duk_uint_t) hdr_size);
26641 /* Note: e_next indicates the number of gc-reachable entries
26642 * in the entry part, and also indicates the index where the
26643 * next new property would be inserted. It does *not* indicate
26644 * the number of non-NULL keys present in the object. That
26645 * value could be counted separately but requires a pass through
26646 * the key list.
26647 */
26653 if (h_data) {
26655 } else {
26656 duk_push_uint(ctx, 0);
26657 }
26658 }
26659 break;
26660 }
26661 case DUK_HTYPE_BUFFER: {
26662 duk_hbuffer *h_buf = (duk_hbuffer *) h;
26663 if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) {
26664 if (DUK_HBUFFER_HAS_EXTERNAL(h_buf)) {
26666 } else {
26667 /* When alloc_size == 0 the second allocation may not
26668 * actually exist.
26669 */
26671 }
26673 } else {
26674 duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1));
#define duk_push_size_t(ctx, val)
DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx)
DUK_EXTERNAL void duk_push_pointer(duk_context *ctx, void *val)
#define DUK_HOBJECT_P_ALLOC_SIZE(h)
static void save(LexState *ls, int c)

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 26871 of file duktape-1.5.2/src/duktape.c.

26876 {
26877 DUK_ASSERT_TOP(ctx, 1);
26878 duk_compact(ctx, 0);
26879 return 1; /* return the argument object */
26880}
26881#line 1 "duk_bi_error.c"
26882/*
26883 * Error built-ins
26884 */
26885
26886/* include removed: duk_internal.h */
26887
26889 /* Behavior for constructor and non-constructor call is
26890 * the same except for augmenting the created error. When
26891 * called as a constructor, the caller (duk_new()) will handle
26892 * augmentation; when called as normal function, we need to do
26893 * it here.
26894 */
26895
26896 duk_hthread *thr = (duk_hthread *) ctx;
26897 duk_small_int_t bidx_prototype = duk_get_current_magic(ctx);
26898
26899 /* same for both error and each subclass like TypeError */
26900 duk_uint_t flags_and_class = DUK_HOBJECT_FLAG_EXTENSIBLE |
26902
26903 DUK_UNREF(thr);
26904
26905 duk_push_object_helper(ctx, flags_and_class, bidx_prototype);
26906
26907 /* If message is undefined, the own property 'message' is not set at
26908 * all to save property space. An empty message is inherited anyway.
26909 */
26910 if (!duk_is_undefined(ctx, 0)) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx)
#define DUK_HOBJECT_CLASS_ERROR

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 27166 of file duktape-1.5.2/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 27241 of file duktape-1.5.2/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 27170 of file duktape-1.5.2/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 27245 of file duktape-1.5.2/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 27162 of file duktape-1.5.2/src/duktape.c.

27163 {
27164 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 27237 of file duktape-1.5.2/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 26912 of file duktape-1.5.2/src/duktape.c.

26921 {
26922 duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/);
26923 }
26924#endif
26925
26926 return 1;
26927}
26928
26930 /* XXX: optimize with more direct internal access */
26931
26932 duk_push_this(ctx);
26934
26935 /* [ ... this ] */
26936
26938 if (duk_is_undefined(ctx, -1)) {
26939 duk_pop(ctx);
26940 duk_push_string(ctx, "Error");
26941 } else {
26942 duk_to_string(ctx, -1);
26943 }
26944
26945 /* [ ... this name ] */
26946
26947 /* XXX: Are steps 6 and 7 in E5 Section 15.11.4.4 duplicated by
26948 * accident or are they actually needed? The first ToString()
26949 * could conceivably return 'undefined'.
26950 */
26952 if (duk_is_undefined(ctx, -1)) {
26953 duk_pop(ctx);
26954 duk_push_string(ctx, "");
26955 } else {
26956 duk_to_string(ctx, -1);
26957 }
26958
DUK_INTERNAL_DECL duk_hobject * duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index)
#define DUK_STRIDX_MESSAGE
DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx)
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_bi_function_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_constructor ( duk_context * ctx)

Definition at line 27255 of file duktape-1.5.2/src/duktape.c.

27258 {
27260}
27261
27264}
27265#line 1 "duk_bi_function.c"
27266/*
27267 * Function built-ins
27268 */
27269
27270/* include removed: duk_internal.h */
27271
27273 duk_hthread *thr = (duk_hthread *) ctx;
27274 duk_hstring *h_sourcecode;
27275 duk_idx_t nargs;
27276 duk_idx_t i;
27277 duk_small_uint_t comp_flags;
27279 duk_hobject *outer_lex_env;
27280 duk_hobject *outer_var_env;
27281
27282 /* normal and constructor calls have identical semantics */
27283
27284 nargs = duk_get_top(ctx);
27285 for (i = 0; i < nargs; i++) {
27286 duk_to_string(ctx, i);
27287 }
27288
27289 if (nargs == 0) {
27290 duk_push_string(ctx, "");
27291 duk_push_string(ctx, "");
27292 } else if (nargs == 1) {
27293 /* XXX: cover this with the generic >1 case? */
27294 duk_push_string(ctx, "");
27295 } else {
27296 duk_insert(ctx, 0); /* [ arg1 ... argN-1 body] -> [body arg1 ... argN-1] */
27297 duk_push_string(ctx, ",");
27298 duk_insert(ctx, 1);
27299 duk_join(ctx, nargs - 1);
27300 }
27301
27302 /* [ body formals ], formals is comma separated list that needs to be parsed */
27303
27304 DUK_ASSERT_TOP(ctx, 2);
27305
27306 /* XXX: this placeholder is not always correct, but use for now.
27307 * It will fail in corner cases; see test-dev-func-cons-args.js.
27308 */
27309 duk_push_string(ctx, "function(");
27310 duk_dup(ctx, 1);
27311 duk_push_string(ctx, "){");
27312 duk_dup(ctx, 0);
27313 duk_push_string(ctx, "}");
27314 duk_concat(ctx, 5);
27315
27316 /* [ body formals source ] */
27317
27318 DUK_ASSERT_TOP(ctx, 3);
27319
27320 /* strictness is not inherited, intentional */
27321 comp_flags = DUK_JS_COMPILE_FLAG_FUNCEXPR;
27322
27323 duk_push_hstring_stridx(ctx, DUK_STRIDX_COMPILE); /* XXX: copy from caller? */ /* XXX: ignored now */
27324 h_sourcecode = duk_require_hstring(ctx, -2);
27325 duk_js_compile(thr,
27326 (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode),
27327 (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode),
27328 comp_flags);
27329 func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
27330 DUK_ASSERT(func != NULL);
DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_setter(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_bi_function_constructor(duk_context *ctx)
#define DUK_STRIDX_COMPILE

◆ duk_bi_function_prototype()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype ( duk_context * ctx)

Definition at line 27332 of file duktape-1.5.2/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 27405 of file duktape-1.5.2/src/duktape.c.

27405 {
27406 duk_push_sprintf(ctx, "function %s() {\"bound\"}", (const char *) func_name);
27407 } else {
27408 goto type_error;
27409 }
27410 } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
27412 } else {
27413 goto type_error;
27414 }
27415
27416 return 1;
27417
27418 type_error:
27419 return DUK_RET_TYPE_ERROR;
27420}
27421
27423 duk_idx_t len;
27424 duk_idx_t i;
27425
27426 DUK_ASSERT_TOP(ctx, 2); /* not a vararg function */
27427
27428 duk_push_this(ctx);
27429 if (!duk_is_callable(ctx, -1)) {
27430 DUK_DDD(DUK_DDDPRINT("func is not callable"));
27431 goto type_error;
27432 }
27433 duk_insert(ctx, 0);
27434 DUK_ASSERT_TOP(ctx, 3);
27435
27436 DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argArray=%!iT",
27437 (duk_tval *) duk_get_tval(ctx, 0),
27438 (duk_tval *) duk_get_tval(ctx, 1),
27439 (duk_tval *) duk_get_tval(ctx, 2)));
27440
27441 /* [ func thisArg argArray ] */
27442
27443 if (duk_is_null_or_undefined(ctx, 2)) {
27444 DUK_DDD(DUK_DDDPRINT("argArray is null/undefined, no args"));
27445 len = 0;
27446 } else if (!duk_is_object(ctx, 2)) {
27447 goto type_error;
27448 } else {
27449 DUK_DDD(DUK_DDDPRINT("argArray is an object"));
27450
27451 /* XXX: make this an internal helper */
27453 len = (duk_idx_t) duk_to_uint32(ctx, -1); /* ToUint32() coercion required */
27454 duk_pop(ctx);
27455
27456 duk_require_stack(ctx, len);
27457
27458 DUK_DDD(DUK_DDDPRINT("argArray length is %ld", (long) len));
27459 for (i = 0; i < len; i++) {
27460 duk_get_prop_index(ctx, 2, i);
DUK_INTERNAL_DECL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv)
DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx)

◆ duk_bi_function_prototype_bind()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_bind ( duk_context * ctx)

Definition at line 27499 of file duktape-1.5.2/src/duktape.c.

27516 {
27517 duk_hobject *h_bound;
27518 duk_hobject *h_target;
27519 duk_idx_t nargs;
27520 duk_idx_t i;
27521
27522 /* vararg function, careful arg handling (e.g. thisArg may not be present) */
27523 nargs = duk_get_top(ctx); /* = 1 + arg count */
27524 if (nargs == 0) {
27525 duk_push_undefined(ctx);
27526 nargs++;
27527 }
27528 DUK_ASSERT(nargs >= 1);
27529
27530 duk_push_this(ctx);
27531 if (!duk_is_callable(ctx, -1)) {
27532 DUK_DDD(DUK_DDDPRINT("func is not callable"));
27533 goto type_error;
27534 }
27535
27536 /* [ thisArg arg1 ... argN func ] (thisArg+args == nargs total) */
27537 DUK_ASSERT_TOP(ctx, nargs + 1);
27538
27539 /* create bound function object */
27546 h_bound = duk_get_hobject(ctx, -1);
27547 DUK_ASSERT(h_bound != NULL);
27548
27549 /* [ thisArg arg1 ... argN func boundFunc ] */
27550 duk_dup(ctx, -2); /* func */
27552
27553 duk_dup(ctx, 0); /* thisArg */
27555
27556 duk_push_array(ctx);
27557
27558 /* [ thisArg arg1 ... argN func boundFunc argArray ] */
27559
27560 for (i = 0; i < nargs - 1; i++) {
27561 duk_dup(ctx, 1 + i);
27562 duk_put_prop_index(ctx, -2, i);
27563 }
27565
27566 /* [ thisArg arg1 ... argN func boundFunc ] */
27567
27568 /* bound function 'length' property is interesting */
27569 h_target = duk_get_hobject(ctx, -2);
27570 if (h_target == NULL || /* lightfunc */
27572 /* For lightfuncs, simply read the virtual property. */
27573 duk_int_t tmp;
27575 tmp = duk_to_int(ctx, -1) - (nargs - 1); /* step 15.a */
27576 duk_pop(ctx);
27577 duk_push_int(ctx, (tmp < 0 ? 0 : tmp));
27578 } else {
27579 duk_push_int(ctx, 0);
27580 }
27581 duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); /* attrs in E5 Section 15.3.5.1 */
27582
27583 /* caller and arguments must use the same thrower, [[ThrowTypeError]] */
27586
27587 /* these non-standard properties are copied for convenience */
27588 /* XXX: 'copy properties' API call? */
27593
27594 /* The 'strict' flag is copied to get the special [[Get]] of E5.1
#define DUK_HOBJECT_FLAG_CONSTRUCTABLE

◆ duk_bi_function_prototype_call()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_call ( duk_context * ctx)

Definition at line 27462 of file duktape-1.5.2/src/duktape.c.

27475 :
27476 return DUK_RET_TYPE_ERROR;
27477}
27478
27480 duk_idx_t nargs;
27481
27482 /* Step 1 is not necessary because duk_call_method() will take
27483 * care of it.
27484 */
27485
27486 /* vararg function, thisArg needs special handling */
27487 nargs = duk_get_top(ctx); /* = 1 + arg count */
27488 if (nargs == 0) {
27489 duk_push_undefined(ctx);
27490 nargs++;
27491 }
DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx)

◆ duk_bi_function_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_to_string ( duk_context * ctx)

Definition at line 27338 of file duktape-1.5.2/src/duktape.c.

27349 {
27350 /* ignore arguments, return undefined (E5 Section 15.3.4) */
27351 DUK_UNREF(ctx);
27352 return 0;
27353}
27354
27356 duk_tval *tv;
27357
27358 /*
27359 * E5 Section 15.3.4.2 places few requirements on the output of
27360 * this function:
27361 *
27362 * - The result is an implementation dependent representation
27363 * of the function; in particular
27364 *
27365 * - The result must follow the syntax of a FunctionDeclaration.
27366 * In particular, the function must have a name (even in the
27367 * case of an anonymous function or a function with an empty
27368 * name).
27369 *
27370 * - Note in particular that the output does NOT need to compile
27371 * into anything useful.
27372 */
27373
27374
27375 /* XXX: faster internal way to get this */
27376 duk_push_this(ctx);
27377 tv = duk_get_tval(ctx, -1);
27378 DUK_ASSERT(tv != NULL);
27379
27380 if (DUK_TVAL_IS_OBJECT(tv)) {
27382 const char *func_name;
27383
27384 /* Function name: missing/undefined is mapped to empty string,
27385 * otherwise coerce to string.
27386 */
27387 /* XXX: currently no handling for non-allowed identifier characters,
27388 * e.g. a '{' in the function name.
27389 */
27391 if (duk_is_undefined(ctx, -1)) {
27392 func_name = "";
27393 } else {
27394 func_name = duk_to_string(ctx, -1);
27395 DUK_ASSERT(func_name != NULL);
27396 }
27397
27398 /* Indicate function type in the function body using a dummy
27399 * directive.
27400 */
27402 duk_push_sprintf(ctx, "function %s() {\"ecmascript\"}", (const char *) func_name);
27403 } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx)

◆ duk_bi_global_object_decode_uri()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri ( duk_context * ctx)

Definition at line 28282 of file duktape-1.5.2/src/duktape.c.

28283 {
28284 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 28286 of file duktape-1.5.2/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 28290 of file duktape-1.5.2/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 28294 of file duktape-1.5.2/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 28299 of file duktape-1.5.2/src/duktape.c.

28299 {
28301}
DUK_LOCAL const duk_uint8_t duk__decode_uri_reserved_table[16]

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 28016 of file duktape-1.5.2/src/duktape.c.

28033 {
28034 duk_hthread *thr = (duk_hthread *) ctx;
28035 duk_hstring *h;
28036 duk_activation *act_caller;
28037 duk_activation *act_eval;
28038 duk_activation *act;
28040 duk_hobject *outer_lex_env;
28041 duk_hobject *outer_var_env;
28042 duk_bool_t this_to_global = 1;
28043 duk_small_uint_t comp_flags;
28044 duk_int_t level = -2;
28045
28046 DUK_ASSERT(duk_get_top(ctx) == 1 || duk_get_top(ctx) == 2); /* 2 when called by debugger */
28047 DUK_ASSERT(thr->callstack_top >= 1); /* at least this function exists */
28048 DUK_ASSERT(((thr->callstack + thr->callstack_top - 1)->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0 || /* indirect eval */
28049 (thr->callstack_top >= 2)); /* if direct eval, calling activation must exist */
28050
28051 /*
28052 * callstack_top - 1 --> this function
28053 * callstack_top - 2 --> caller (may not exist)
28054 *
28055 * If called directly from C, callstack_top might be 1. If calling
28056 * activation doesn't exist, call must be indirect.
28057 */
28058
28059 h = duk_get_hstring(ctx, 0);
28060 if (!h) {
28061 return 1; /* return arg as-is */
28062 }
28063
28064#if defined(DUK_USE_DEBUGGER_SUPPORT)
28065 /* NOTE: level is used only by the debugger and should never be present
28066 * for an Ecmascript eval().
28067 */
28068 DUK_ASSERT(level == -2); /* by default, use caller's environment */
28069 if (duk_get_top(ctx) >= 2 && duk_is_number(ctx, 1)) {
28070 level = duk_get_int(ctx, 1);
28071 }
28072 DUK_ASSERT(level <= -2); /* This is guaranteed by debugger code. */
28073#endif
28074
28075 /* [ source ] */
28076
28077 comp_flags = DUK_JS_COMPILE_FLAG_EVAL;
28078 act_eval = thr->callstack + thr->callstack_top - 1; /* this function */
28079 if (thr->callstack_top >= (duk_size_t) -level) {
28080 /* Have a calling activation, check for direct eval (otherwise
28081 * assume indirect eval.
28082 */
28083 act_caller = thr->callstack + thr->callstack_top + level; /* caller */
28084 if ((act_caller->flags & DUK_ACT_FLAG_STRICT) &&
28085 (act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL)) {
28086 /* Only direct eval inherits strictness from calling code
28087 * (E5.1 Section 10.1.1).
28088 */
28089 comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
28090 }
28091 } else {
28092 DUK_ASSERT((act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0);
28093 }
28094 act_caller = NULL; /* avoid dereference after potential callstack realloc */
28095 act_eval = NULL;
28096
28097 duk_push_hstring_stridx(ctx, DUK_STRIDX_INPUT); /* XXX: copy from caller? */
28098 duk_js_compile(thr,
28099 (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h),
28101 comp_flags);
28102 func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
28103 DUK_ASSERT(func != NULL);
28105
28106 /* [ source template ] */
28107
28108 /* E5 Section 10.4.2 */
28109 DUK_ASSERT(thr->callstack_top >= 1);
28110 act = thr->callstack + thr->callstack_top - 1; /* this function */
28111 if (act->flags & DUK_ACT_FLAG_DIRECT_EVAL) {
28112 DUK_ASSERT(thr->callstack_top >= 2);
28113 act = thr->callstack + thr->callstack_top + level; /* caller */
28114 if (act->lex_env == NULL) {
28115 DUK_ASSERT(act->var_env == NULL);
28116 DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
28117
28118 /* this may have side effects, so re-lookup act */
28120 act = thr->callstack + thr->callstack_top + level;
28121 }
28122 DUK_ASSERT(act->lex_env != NULL);
28123 DUK_ASSERT(act->var_env != NULL);
28124
28125 this_to_global = 0;
28126
28127 if (DUK_HOBJECT_HAS_STRICT((duk_hobject *) func)) {
28128 duk_hobject *new_env;
28129 duk_hobject *act_lex_env;
28130
28131 DUK_DDD(DUK_DDDPRINT("direct eval call to a strict function -> "
28132 "var_env and lex_env to a fresh env, "
28133 "this_binding to caller's this_binding"));
28134
28135 act = thr->callstack + thr->callstack_top + level; /* caller */
28136 act_lex_env = act->lex_env;
28137 act = NULL; /* invalidated */
28138
28142 act_lex_env);
28143 new_env = duk_require_hobject(ctx, -1);
28144 DUK_ASSERT(new_env != NULL);
28145 DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO",
28146 (duk_heaphdr *) new_env));
28147
28148 outer_lex_env = new_env;
28149 outer_var_env = new_env;
28150
28151 duk_insert(ctx, 0); /* stash to bottom of value stack to keep new_env reachable for duration of eval */
28152
28153 /* compiler's responsibility */
28155 } else {
28156 DUK_DDD(DUK_DDDPRINT("direct eval call to a non-strict function -> "
28157 "var_env and lex_env to caller's envs, "
28158 "this_binding to caller's this_binding"));
28159
28160 outer_lex_env = act->lex_env;
28161 outer_var_env = act->var_env;
28162
28163 /* compiler's responsibility */
28165 }
28166 } else {
28167 DUK_DDD(DUK_DDDPRINT("indirect eval call -> var_env and lex_env to "
28168 "global object, this_binding to global object"));
28169
28170 this_to_global = 1;
28171 outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
28172 outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
28173 }
28174 act = NULL;
28175
28176 /* Eval code doesn't need an automatic .prototype object. */
28177 duk_js_push_closure(thr, func, outer_var_env, outer_lex_env, 0 /*add_auto_proto*/);
28178
28179 /* [ source template closure ] */
28180
28181 if (this_to_global) {
28184 } else {
28185 duk_tval *tv;
28186 DUK_ASSERT(thr->callstack_top >= 2);
28187 act = thr->callstack + thr->callstack_top + level; /* caller */
28188 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 28272 of file duktape-1.5.2/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 28266 of file duktape-1.5.2/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 28237 of file duktape-1.5.2/src/duktape.c.

28238 {
28239 s2n_flags &= ~DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
28240 }
28241 } else {
28242 radix = 10;
28243 }
28244
28245 duk_dup(ctx, 0);
28246 duk_numconv_parse(ctx, radix, s2n_flags);
28247 return 1;
28248
28249 ret_nan:
28250 duk_push_nan(ctx);
28251 return 1;
28252}
28253
28255 duk_small_uint_t s2n_flags;
28256 duk_int32_t radix;
28257
28258 DUK_ASSERT_TOP(ctx, 1);
28259 duk_to_string(ctx, 0);
28260
DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_float(duk_context *ctx)
DUK_INTERNAL_DECL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk_small_uint_t flags)

◆ duk_bi_global_object_parse_int()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_int ( duk_context * ctx)

Definition at line 28194 of file duktape-1.5.2/src/duktape.c.

28211 {
28212 duk_int32_t radix;
28213 duk_small_uint_t s2n_flags;
28214
28215 DUK_ASSERT_TOP(ctx, 2);
28216 duk_to_string(ctx, 0);
28217
28218 radix = duk_to_int32(ctx, 1);
28219
28220 s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
28226
28227 /* Specification stripPrefix maps to DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT.
28228 *
28229 * Don't autodetect octals (from leading zeroes), require user code to
28230 * provide an explicit radix 8 for parsing octal. See write-up from Mozilla:
28231 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt#ECMAScript_5_Removes_Octal_Interpretation
28232 */
28233
28234 if (radix != 0) {
28235 if (radix < 2 || radix > 36) {
#define DUK_S2N_FLAG_ALLOW_MINUS
#define DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT
#define DUK_S2N_FLAG_ALLOW_PLUS
#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO
#define DUK_S2N_FLAG_ALLOW_GARBAGE

◆ duk_bi_global_object_print_helper()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_print_helper ( duk_context * ctx)

Definition at line 28319 of file duktape-1.5.2/src/duktape.c.

28320 {
28321 return duk__transform_helper(ctx, duk__transform_callback_unescape, (const void *) NULL);
28322}
28323#else /* DUK_USE_SECTION_B */
28325 DUK_UNREF(ctx);
28327}
28328
28330 DUK_UNREF(ctx);
28332}
28333#endif /* DUK_USE_SECTION_B */
28334
28335#if defined(DUK_USE_BROWSER_LIKE) && (defined(DUK_USE_FILE_IO) || defined(DUK_USE_DEBUGGER_SUPPORT))
28337 duk_hthread *thr = (duk_hthread *) ctx;
28338 duk_int_t magic;
28339 duk_idx_t nargs;
28340 const duk_uint8_t *buf;
28341 duk_size_t sz_buf;
28342 const char nl = (const char) DUK_ASC_LF;
28343#ifndef DUK_USE_PREFER_SIZE
28344 duk_uint8_t buf_stack[256];
28345#endif
28346#ifdef DUK_USE_FILE_IO
28347 duk_file *f_out;
28348#endif
28349
28350 DUK_UNREF(thr);
28351
28352 magic = duk_get_current_magic(ctx);
28353 DUK_UNREF(magic);
28354
28355 nargs = duk_get_top(ctx);
28356
28357 /* If argument count is 1 and first argument is a buffer, write the buffer
28358 * as raw data into the file without a newline; this allows exact control
28359 * over stdout/stderr without an additional entrypoint (useful for now).
28360 *
28361 * Otherwise current print/alert semantics are to ToString() coerce
28362 * arguments, join them with a single space, and append a newline.
28363 */
28364
28365 if (nargs == 1 && duk_is_buffer(ctx, 0)) {
28366 buf = (const duk_uint8_t *) duk_get_buffer(ctx, 0, &sz_buf);
28367 DUK_ASSERT(buf != NULL);
28368 } else if (nargs > 0) {
28369#ifdef DUK_USE_PREFER_SIZE
28370 /* Compact but lots of churn. */
28372 duk_insert(ctx, 0);
28373 duk_join(ctx, nargs);
28374 duk_push_string(thr, "\n");
28375 duk_concat(ctx, 2);
28376 buf = (const duk_uint8_t *) duk_get_lstring(ctx, -1, &sz_buf);
28377 DUK_ASSERT(buf != NULL);
28378#else /* DUK_USE_PREFER_SIZE */
28379 /* Higher footprint, less churn. */
28380 duk_idx_t i;
28381 duk_size_t sz_str;
28382 const duk_uint8_t *p_str;
28383 duk_uint8_t *p;
28384
28385 sz_buf = (duk_size_t) nargs; /* spaces (nargs - 1) + newline */
28386 for (i = 0; i < nargs; i++) {
28387 (void) duk_to_lstring(ctx, i, &sz_str);
28388 sz_buf += sz_str;
28389 }
28390
28391 if (sz_buf <= sizeof(buf_stack)) {
28392 p = (duk_uint8_t *) buf_stack;
28393 } else {
28394 p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, sz_buf);
28395 DUK_ASSERT(p != NULL);
28396 }
28397
28398 buf = (const duk_uint8_t *) p;
28399 for (i = 0; i < nargs; i++) {
28400 p_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &sz_str);
28401 DUK_ASSERT(p_str != NULL);
28402 DUK_MEMCPY((void *) p, (const void *) p_str, sz_str);
28403 p += sz_str;
28404 *p++ = (duk_uint8_t) (i == nargs - 1 ? DUK_ASC_LF : DUK_ASC_SPACE);
28405 }
28406 DUK_ASSERT((const duk_uint8_t *) p == buf + sz_buf);
28407#endif /* DUK_USE_PREFER_SIZE */
28408 } else {
28409 buf = (const duk_uint8_t *) &nl;
28410 sz_buf = 1;
28411 }
28412
28413 /* 'buf' contains the string to write, 'sz_buf' contains the length
28414 * (which may be zero).
28415 */
28416 DUK_ASSERT(buf != NULL);
28417
28418 if (sz_buf == 0) {
28419 return 0;
#define DUK_STRIDX_SPACE
DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx)
#define DUK_ASC_LF
DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_escape(duk_context *ctx)

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 28621 of file duktape-1.5.2/src/duktape.c.

28638 {
28639 const char *str_req_id; /* requested identifier */
28640 const char *str_mod_id; /* require.id of current module */
28641 duk_int_t pcall_rc;
28642
28643 /* NOTE: we try to minimize code size by avoiding unnecessary pops,
28644 * so the stack looks a bit cluttered in this function. DUK_ASSERT_TOP()
28645 * assertions are used to ensure stack configuration is correct at each
28646 * step.
28647 */
28648
28649 /*
28650 * Resolve module identifier into canonical absolute form.
28651 */
28652
28653 str_req_id = duk_require_string(ctx, DUK__IDX_REQUESTED_ID);
28656 str_mod_id = duk_get_string(ctx, DUK__IDX_REQUIRE_ID); /* ignore non-strings */
28657 DUK_DDD(DUK_DDDPRINT("resolve module id: requested=%!T, currentmodule=%!T",
28660 duk__bi_global_resolve_module_id(ctx, str_req_id, str_mod_id);
28661 str_req_id = NULL;
28662 str_mod_id = NULL;
28663 DUK_DDD(DUK_DDDPRINT("resolved module id: requested=%!T, currentmodule=%!T, result=%!T, lastcomp=%!T",
28668
28669 /* [ requested_id require require.id resolved_id last_comp ] */
28671
28672 /*
28673 * Cached module check.
28674 *
28675 * If module has been loaded or its loading has already begun without
28676 * finishing, return the same cached value ('exports'). The value is
28677 * registered when module load starts so that circular references can
28678 * be supported to some extent.
28679 */
28680
28682 duk_get_prop_stridx(ctx, DUK__IDX_DUKTAPE, DUK_STRIDX_MOD_LOADED); /* Duktape.modLoaded */
28685
28687 if (duk_get_prop(ctx, DUK__IDX_MODLOADED)) {
28688 /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded Duktape.modLoaded[id] ] */
28689 DUK_DD(DUK_DDPRINT("module already loaded: %!T",
28691 duk_get_prop_stridx(ctx, -1, DUK_STRIDX_EXPORTS); /* return module.exports */
28692 return 1;
28693 }
28695
28696 /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined ] */
28697
28698 /*
28699 * Module not loaded (and loading not started previously).
28700 *
28701 * Create a new require() function with 'id' set to resolved ID
28702 * of module being loaded. Also create 'exports' and 'module'
28703 * tables but don't register exports to the loaded table yet.
28704 * We don't want to do that unless the user module search callbacks
28705 * succeeds in finding the module.
28706 */
28707
28708 DUK_D(DUK_DPRINT("loading module %!T, resolution base %!T, requested ID %!T -> resolved ID %!T, last component %!T",
28714
28715 /* Fresh require: require.id is left configurable (but not writable)
28716 * so that is not easy to accidentally tweak it, but it can still be
28717 * done with Object.defineProperty().
28718 *
28719 * XXX: require.id could also be just made non-configurable, as there
28720 * is no practical reason to touch it.
28721 */
28726 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 */
28727
28728 /* Module table:
28729 * - module.exports: initial exports table (may be replaced by user)
28730 * - module.id is non-writable and non-configurable, as the CommonJS
28731 * spec suggests this if possible
28732 * - module.filename: not set, defaults to resolved ID if not explicitly
28733 * set by modSearch() (note capitalization, not .fileName, matches Node.js)
28734 * - module.name: not set, defaults to last component of resolved ID if
28735 * not explicitly set by modSearch()
28736 */
28737 duk_push_object(ctx); /* exports */
28738 duk_push_object(ctx); /* module */
28741 duk_dup(ctx, DUK__IDX_RESOLVED_ID); /* resolved id: require(id) must return this same module */
28742 duk_xdef_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_NONE); /* module.id = resolved_id */
28743 duk_compact(ctx, DUK__IDX_MODULE); /* module table remains registered to modLoaded, minimize its size */
28745
28746 DUK_DD(DUK_DDPRINT("module table created: %!T", duk_get_tval(ctx, DUK__IDX_MODULE)));
28747
28748 /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module ] */
28749
28750 /* Register the module table early to modLoaded[] so that we can
28751 * support circular references even in modSearch(). If an error
28752 * is thrown, we'll delete the reference.
28753 */
28756 duk_put_prop(ctx, DUK__IDX_MODLOADED); /* Duktape.modLoaded[resolved_id] = module */
28757
28758 /*
28759 * Call user provided module search function and build the wrapped
28760 * module source code (if necessary). The module search function
28761 * can be used to implement pure Ecmacsript, pure C, and mixed
28762 * Ecmascript/C modules.
28763 *
28764 * The module search function can operate on the exports table directly
28765 * (e.g. DLL code can register values to it). It can also return a
28766 * string which is interpreted as module source code (if a non-string
28767 * is returned the module is assumed to be a pure C one). If a module
28768 * cannot be found, an error must be thrown by the user callback.
28769 *
28770 * Because Duktape.modLoaded[] already contains the module being
28771 * loaded, circular references for C modules should also work
28772 * (although expected to be quite rare).
28773 */
28774
28775 duk_push_string(ctx, "(function(require,exports,module){");
28776
28777 /* Duktape.modSearch(resolved_id, fresh_require, exports, module). */
28778 duk_get_prop_stridx(ctx, DUK__IDX_DUKTAPE, DUK_STRIDX_MOD_SEARCH); /* Duktape.modSearch */
28782 duk_dup(ctx, DUK__IDX_MODULE); /* [ ... Duktape.modSearch resolved_id last_comp fresh_require exports module ] */
28783 pcall_rc = duk_pcall(ctx, 4 /*nargs*/); /* -> [ ... source ] */
28785
28786 if (pcall_rc != DUK_EXEC_SUCCESS) {
28787 /* Delete entry in Duktape.modLoaded[] and rethrow. */
28788 goto delete_rethrow;
28789 }
28790
28791 /* If user callback did not return source code, module loading
28792 * is finished (user callback initialized exports table directly).
28793 */
28794 if (!duk_is_string(ctx, -1)) {
28795 /* User callback did not return source code, so module loading
28796 * is finished: just update modLoaded with final module.exports
28797 * and we're done.
28798 */
28799 goto return_exports;
28800 }
28801
28802 /* Finish the wrapped module source. Force module.filename as the
28803 * function .fileName so it gets set for functions defined within a
28804 * module. This also ensures loggers created within the module get
28805 * the module ID (or overridden filename) as their default logger name.
28806 * (Note capitalization: .filename matches Node.js while .fileName is
28807 * used elsewhere in Duktape.)
28808 */
28809 duk_push_string(ctx, "})");
28810 duk_concat(ctx, 3);
28812 /* module.filename for .fileName, default to resolved ID if
28813 * not present.
28814 */
28815 duk_pop(ctx);
28817 }
28819
28820 /* Module has now evaluated to a wrapped module function. Force its
28821 * .name to match module.name (defaults to last component of resolved
28822 * ID) so that it is shown in stack traces too. Note that we must not
28823 * introduce an actual name binding into the function scope (which is
28824 * usually the case with a named function) because it would affect the
28825 * scope seen by the module and shadow accesses to globals of the same name.
28826 * This is now done by compiling the function as anonymous and then forcing
28827 * its .name without setting a "has name binding" flag.
28828 */
28829
28832 /* module.name for .name, default to last component if
28833 * not present.
28834 */
28835 duk_pop(ctx);
28837 }
28839
28840 /*
28841 * Call the wrapped module function.
28842 *
28843 * Use a protected call so that we can update Duktape.modLoaded[resolved_id]
28844 * even if the module throws an error.
28845 */
28846
28847 /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module mod_func ] */
28849
28850 duk_dup(ctx, DUK__IDX_EXPORTS); /* exports (this binding) */
28851 duk_dup(ctx, DUK__IDX_FRESH_REQUIRE); /* fresh require (argument) */
28852 duk_get_prop_stridx(ctx, DUK__IDX_MODULE, DUK_STRIDX_EXPORTS); /* relookup exports from module.exports in case it was changed by modSearch */
28853 duk_dup(ctx, DUK__IDX_MODULE); /* module (argument) */
28855
28856 /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module mod_func exports fresh_require exports module ] */
28857
28858 pcall_rc = duk_pcall_method(ctx, 3 /*nargs*/);
28859 if (pcall_rc != DUK_EXEC_SUCCESS) {
28860 /* Module loading failed. Node.js will forget the module
28861 * registration so that another require() will try to load
28862 * the module again. Mimic that behavior.
28863 */
28864 goto delete_rethrow;
28865 }
#define DUK_DEFPROP_HAVE_VALUE
DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags)
#define DUK_STRIDX_MOD_LOADED
#define DUK__IDX_UNDEFINED
#define DUK_PROPDESC_FLAGS_C
DUK_EXTERNAL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_int_t nargs)
DUK_EXTERNAL void duk_push_current_function(duk_context *ctx)
#define DUK__IDX_EXPORTS
#define DUK__IDX_REQUIRE_ID
#define DUK_STRIDX_EXPORTS
#define DUK_STRIDX_MOD_SEARCH
#define DUK__IDX_REQUESTED_ID
DUK_EXTERNAL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs)
DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_require(duk_context *ctx)
#define DUK__IDX_DUKTAPE
#define DUK_STRIDX_REQUIRE
#define DUK__IDX_FRESH_REQUIRE
#define DUK__IDX_LASTCOMP
#define DUK__IDX_MODLOADED
#define DUK_STRIDX_FILENAME
#define DUK_STRIDX_ID
#define DUK__IDX_RESOLVED_ID
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_EXTERNAL const char * duk_require_string(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs)
#define DUK__IDX_MODULE

◆ duk_bi_global_object_unescape()

DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_unescape ( duk_context * ctx)

◆ duk_bi_json_object_parse()

DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_parse ( duk_context * ctx)

Definition at line 32006 of file duktape-1.5.2/src/duktape.c.

32007 : value=%!T, replacer=%!T, space=%!T, "
32008 "flags=0x%08lx, result=%!T, stack_top=%ld",
32009 (duk_tval *) duk_get_tval(ctx, idx_value),
32010 (duk_tval *) duk_get_tval(ctx, idx_replacer),
32011 (duk_tval *) duk_get_tval(ctx, idx_space),
32012 (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 32014 of file duktape-1.5.2/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 31566 of file duktape-1.5.2/src/duktape.c.

31569 {
31570 DUK_DD(DUK_DDPRINT("top level value not supported, fail fast path"));
31571 return DUK_RET_ERROR; /* error message doesn't matter, ignored anyway */
31572 }
31573
31574 return 0;
31575}
31576#endif /* DUK_USE_JSON_STRINGIFY_FASTPATH */
31577
31578/*
31579 * Top level wrappers
31580 */
31581
31584 duk_idx_t idx_value,
31585 duk_idx_t idx_reviver,
31586 duk_small_uint_t flags) {
31587 duk_hthread *thr = (duk_hthread *) ctx;
31588 duk_json_dec_ctx js_ctx_alloc;
31589 duk_json_dec_ctx *js_ctx = &js_ctx_alloc;
31590 duk_hstring *h_text;
31591#ifdef DUK_USE_ASSERTIONS
31592 duk_idx_t entry_top = duk_get_top(ctx);
31593#endif
31594
31595 /* negative top-relative indices not allowed now */
31596 DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0);
31597 DUK_ASSERT(idx_reviver == DUK_INVALID_INDEX || idx_reviver >= 0);
31598
31599 DUK_DDD(DUK_DDDPRINT("JSON parse start: text=%!T, reviver=%!T, flags=0x%08lx, stack_top=%ld",
31600 (duk_tval *) duk_get_tval(ctx, idx_value),
31601 (duk_tval *) duk_get_tval(ctx, idx_reviver),
31602 (unsigned long) flags,
31603 (long) duk_get_top(ctx)));
31604
31605 DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc));
31606 js_ctx->thr = thr;
31607#ifdef DUK_USE_EXPLICIT_NULL_INIT
31608 /* nothing now */
31609#endif
31611 DUK_ASSERT(js_ctx->recursion_depth == 0);
31612
31613 /* Flag handling currently assumes that flags are consistent. This is OK
31614 * because the call sites are now strictly controlled.
31615 */
31616
31617 js_ctx->flags = flags;
31618#if defined(DUK_USE_JX)
31619 js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM;
31620#endif
31621#if defined(DUK_USE_JC)
31623#endif
31624#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31626#endif
31627
31628 h_text = duk_to_hstring(ctx, idx_value); /* coerce in-place */
31629 DUK_ASSERT(h_text != NULL);
31630
31631 /* JSON parsing code is allowed to read [p_start,p_end]: p_end is
31632 * valid and points to the string NUL terminator (which is always
31633 * guaranteed for duk_hstrings.
31634 */
31635 js_ctx->p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text);
31636 js_ctx->p = js_ctx->p_start;
31637 js_ctx->p_end = ((const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text)) +
31639 DUK_ASSERT(*(js_ctx->p_end) == 0x00);
31640
31641 duk__dec_value(js_ctx); /* -> [ ... value ] */
31642
31643 /* Trailing whitespace has been eaten by duk__dec_value(), so if
31644 * we're not at end of input here, it's a SyntaxError.
31645 */
31646
31647 if (js_ctx->p != js_ctx->p_end) {
31648 duk__dec_syntax_error(js_ctx);
31649 }
31650
31651 if (duk_is_callable(ctx, idx_reviver)) {
31652 DUK_DDD(DUK_DDDPRINT("applying reviver: %!T",
31653 (duk_tval *) duk_get_tval(ctx, idx_reviver)));
31654
31655 js_ctx->idx_reviver = idx_reviver;
31656
31657 duk_push_object(ctx);
31658 duk_dup(ctx, -2); /* -> [ ... val root val ] */
31659 duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING); /* default attrs ok */
31660 duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); /* -> [ ... val root "" ] */
31661
31662 DUK_DDD(DUK_DDDPRINT("start reviver walk, root=%!T, name=%!T",
31663 (duk_tval *) duk_get_tval(ctx, -2),
31664 (duk_tval *) duk_get_tval(ctx, -1)));
31665
31666 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 31669 of file duktape-1.5.2/src/duktape.c.

31669 : %!T",
31670 (duk_tval *) duk_get_tval(ctx, idx_reviver)));
31671 }
31672
31673 /* Final result is at stack top. */
31674
31675 DUK_DDD(DUK_DDDPRINT("JSON parse end: text=%!T, reviver=%!T, flags=0x%08lx, result=%!T, stack_top=%ld",
31676 (duk_tval *) duk_get_tval(ctx, idx_value),
31677 (duk_tval *) duk_get_tval(ctx, idx_reviver),
31678 (unsigned long) flags,
31679 (duk_tval *) duk_get_tval(ctx, -1),
31680 (long) duk_get_top(ctx)));
31681
31682 DUK_ASSERT(duk_get_top(ctx) == entry_top + 1);
31683}
31684
31685DUK_INTERNAL
31686void duk_bi_json_stringify_helper(duk_context *ctx,
31687 duk_idx_t idx_value,
31688 duk_idx_t idx_replacer,
31689 duk_idx_t idx_space,
31690 duk_small_uint_t flags) {
31691 duk_hthread *thr = (duk_hthread *) ctx;
31692 duk_json_enc_ctx js_ctx_alloc;
31693 duk_json_enc_ctx *js_ctx = &js_ctx_alloc;
31694 duk_hobject *h;
31695 duk_idx_t idx_holder;
31696 duk_idx_t entry_top;
31697
31698 /* negative top-relative indices not allowed now */
31699 DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0);
31700 DUK_ASSERT(idx_replacer == DUK_INVALID_INDEX || idx_replacer >= 0);
31701 DUK_ASSERT(idx_space == DUK_INVALID_INDEX || idx_space >= 0);
31702
31703 DUK_DDD(DUK_DDDPRINT("JSON stringify start: value=%!T, replacer=%!T, space=%!T, flags=0x%08lx, stack_top=%ld",
31704 (duk_tval *) duk_get_tval(ctx, idx_value),
31705 (duk_tval *) duk_get_tval(ctx, idx_replacer),
31706 (duk_tval *) duk_get_tval(ctx, idx_space),
31707 (unsigned long) flags,
31708 (long) duk_get_top(ctx)));
31709
31710 entry_top = duk_get_top(ctx);
31711
31712 /*
31713 * Context init
31714 */
31715
31716 DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc));
31717 js_ctx->thr = thr;
31718#ifdef DUK_USE_EXPLICIT_NULL_INIT
31719 js_ctx->h_replacer = NULL;
31720 js_ctx->h_gap = NULL;
31721#endif
31722 js_ctx->idx_proplist = -1;
31723
31724 /* Flag handling currently assumes that flags are consistent. This is OK
31725 * because the call sites are now strictly controlled.
31726 */
31727
31728 js_ctx->flags = flags;
31729 js_ctx->flag_ascii_only = flags & DUK_JSON_FLAG_ASCII_ONLY;
31730 js_ctx->flag_avoid_key_quotes = flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES;
31731#ifdef DUK_USE_JX
31732 js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM;
31733#endif
31734#ifdef DUK_USE_JC
31735 js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE;
31736#endif
31737#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31738 js_ctx->flag_ext_custom_or_compatible = flags & (DUK_JSON_FLAG_EXT_CUSTOM | DUK_JSON_FLAG_EXT_COMPATIBLE);
31739#endif
31740
31741 /* The #ifdef clutter here handles the JX/JC enable/disable
31742 * combinations properly.
31743 */
31744#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31745 js_ctx->stridx_custom_undefined = DUK_STRIDX_LC_NULL; /* standard JSON; array gaps */
31746#if defined(DUK_USE_JX)
31747 if (flags & DUK_JSON_FLAG_EXT_CUSTOM) {
31748 js_ctx->stridx_custom_undefined = DUK_STRIDX_LC_UNDEFINED;
31749 js_ctx->stridx_custom_nan = DUK_STRIDX_NAN;
31750 js_ctx->stridx_custom_neginf = DUK_STRIDX_MINUS_INFINITY;
31751 js_ctx->stridx_custom_posinf = DUK_STRIDX_INFINITY;
31752 js_ctx->stridx_custom_function =
31753 (flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES) ?
31754 DUK_STRIDX_JSON_EXT_FUNCTION2 :
31755 DUK_STRIDX_JSON_EXT_FUNCTION1;
31756 }
31757#endif /* DUK_USE_JX */
31758#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
31759 else
31760#endif /* DUK_USE_JX && DUK_USE_JC */
31761#if defined(DUK_USE_JC)
31762 if (js_ctx->flags & DUK_JSON_FLAG_EXT_COMPATIBLE) {
31763 js_ctx->stridx_custom_undefined = DUK_STRIDX_JSON_EXT_UNDEFINED;
31764 js_ctx->stridx_custom_nan = DUK_STRIDX_JSON_EXT_NAN;
31765 js_ctx->stridx_custom_neginf = DUK_STRIDX_JSON_EXT_NEGINF;
31766 js_ctx->stridx_custom_posinf = DUK_STRIDX_JSON_EXT_POSINF;
31767 js_ctx->stridx_custom_function = DUK_STRIDX_JSON_EXT_FUNCTION1;
31768 }
31769#endif /* DUK_USE_JC */
31770#endif /* DUK_USE_JX || DUK_USE_JC */
31771
31772#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
31773 if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
31774 DUK_JSON_FLAG_EXT_COMPATIBLE)) {
31775 DUK_ASSERT(js_ctx->mask_for_undefined == 0); /* already zero */
31776 }
31777 else
31778#endif /* DUK_USE_JX || DUK_USE_JC */
31779 {
31780 js_ctx->mask_for_undefined = DUK_TYPE_MASK_UNDEFINED |
31781 DUK_TYPE_MASK_POINTER |
31782 DUK_TYPE_MASK_BUFFER |
31783 DUK_TYPE_MASK_LIGHTFUNC;
31784 }
31785
31786 DUK_BW_INIT_PUSHBUF(thr, &js_ctx->bw, DUK__JSON_STRINGIFY_BUFSIZE);
31787
31788 js_ctx->idx_loop = duk_push_object_internal(ctx);
31789 DUK_ASSERT(js_ctx->idx_loop >= 0);
31790
31791 /* [ ... buf loop ] */
31792
31793 /*
31794 * Process replacer/proplist (2nd argument to JSON.stringify)
31795 */
31796
31797 h = duk_get_hobject(ctx, idx_replacer);
31798 if (h != NULL) {
31799 if (DUK_HOBJECT_IS_CALLABLE(h)) {
31800 js_ctx->h_replacer = h;
31801 } else if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
31802 /* Here the specification requires correct array index enumeration
31803 * which is a bit tricky for sparse arrays (it is handled by the
31804 * enum setup code). We now enumerate ancestors too, although the
31805 * specification is not very clear on whether that is required.
31806 */
31807
31808 duk_uarridx_t plist_idx = 0;
31809 duk_small_uint_t enum_flags;
31810
31811 js_ctx->idx_proplist = duk_push_array(ctx); /* XXX: array internal? */
31812
31813 enum_flags = DUK_ENUM_ARRAY_INDICES_ONLY |
31814 DUK_ENUM_SORT_ARRAY_INDICES; /* expensive flag */
31815 duk_enum(ctx, idx_replacer, enum_flags);
31816 while (duk_next(ctx, -1 /*enum_index*/, 1 /*get_value*/)) {
31817 /* [ ... proplist enum_obj key val ] */
31818 if (duk__enc_allow_into_proplist(duk_get_tval(ctx, -1))) {
31819 /* XXX: duplicates should be eliminated here */
31820 DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> accept",
31821 (duk_tval *) duk_get_tval(ctx, -2),
31822 (duk_tval *) duk_get_tval(ctx, -1)));
31823 duk_to_string(ctx, -1); /* extra coercion of strings is OK */
31824 duk_put_prop_index(ctx, -4, plist_idx); /* -> [ ... proplist enum_obj key ] */
31825 plist_idx++;
31826 duk_pop(ctx);
31827 } else {
31828 DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> reject",
31829 (duk_tval *) duk_get_tval(ctx, -2),
31830 (duk_tval *) duk_get_tval(ctx, -1)));
31831 duk_pop_2(ctx);
31832 }
31833 }
31834 duk_pop(ctx); /* pop enum */
31835
31836 /* [ ... proplist ] */
31837 }
31838 }
31839
31840 /* [ ... buf loop (proplist) ] */
31841
31842 /*
31843 * Process space (3rd argument to JSON.stringify)
31844 */
31845
31846 h = duk_get_hobject(ctx, idx_space);
31847 if (h != NULL) {
31848 int c = DUK_HOBJECT_GET_CLASS_NUMBER(h);
31849 if (c == DUK_HOBJECT_CLASS_NUMBER) {
31850 duk_to_number(ctx, idx_space);
31851 } else if (c == DUK_HOBJECT_CLASS_STRING) {
31852 duk_to_string(ctx, idx_space);
31853 }
31854 }
31855
31856 if (duk_is_number(ctx, idx_space)) {
31857 duk_small_int_t nspace;
31858 /* spaces[] must be static to allow initializer with old compilers like BCC */
31859 static const char spaces[10] = {
31860 DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE,
31861 DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE,
31862 DUK_ASC_SPACE, DUK_ASC_SPACE
31863 }; /* XXX: helper */
31864
31865 /* ToInteger() coercion; NaN -> 0, infinities are clamped to 0 and 10 */
31866 nspace = (duk_small_int_t) duk_to_int_clamped(ctx, idx_space, 0 /*minval*/, 10 /*maxval*/);
31867 DUK_ASSERT(nspace >= 0 && nspace <= 10);
31868
31869 duk_push_lstring(ctx, spaces, (duk_size_t) nspace);
31870 js_ctx->h_gap = duk_get_hstring(ctx, -1);
31871 DUK_ASSERT(js_ctx->h_gap != NULL);
31872 } else if (duk_is_string(ctx, idx_space)) {
31873 /* XXX: substring in-place at idx_place? */
31874 duk_dup(ctx, idx_space);
31875 duk_substring(ctx, -1, 0, 10); /* clamp to 10 chars */
31876 js_ctx->h_gap = duk_get_hstring(ctx, -1);
31877 DUK_ASSERT(js_ctx->h_gap != NULL);
31878 } else {
31879 /* nop */
31880 }
31881
31882 if (js_ctx->h_gap != NULL) {
31883 /* if gap is empty, behave as if not given at all */
31884 if (DUK_HSTRING_GET_CHARLEN(js_ctx->h_gap) == 0) {
31885 js_ctx->h_gap = NULL;
31886 }
31887 }
31888
31889 /* [ ... buf loop (proplist) (gap) ] */
31890
31891 /*
31892 * Fast path: assume no mutation, iterate object property tables
31893 * directly; bail out if that assumption doesn't hold.
31894 */
31895
31896#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH)
31897 if (js_ctx->h_replacer == NULL && /* replacer is a mutation risk */
31898 js_ctx->idx_proplist == -1) { /* proplist is very rare */
31899 duk_int_t pcall_rc;
31900#ifdef DUK_USE_MARK_AND_SWEEP
31901 duk_small_uint_t prev_mark_and_sweep_base_flags;
31902#endif
31903
31904 DUK_DD(DUK_DDPRINT("try JSON.stringify() fast path"));
31905
31906 /* Use recursion_limit to ensure we don't overwrite js_ctx->visiting[]
31907 * array so we don't need two counter checks in the fast path. The
31908 * slow path has a much larger recursion limit which we'll use if
31909 * necessary.
31910 */
31911 DUK_ASSERT(DUK_USE_JSON_ENC_RECLIMIT >= DUK_JSON_ENC_LOOPARRAY);
31912 js_ctx->recursion_limit = DUK_JSON_ENC_LOOPARRAY;
31913 DUK_ASSERT(js_ctx->recursion_depth == 0);
31914
31915 /* Execute the fast path in a protected call. If any error is thrown,
31916 * fall back to the slow path. This includes e.g. recursion limit
31917 * because the fast path has a smaller recursion limit (and simpler,
31918 * limited loop detection).
31919 */
31920
31921 duk_push_pointer(ctx, (void *) js_ctx);
31922 duk_dup(ctx, idx_value);
31923
31924#if defined(DUK_USE_MARK_AND_SWEEP)
31925 /* Must prevent finalizers which may have arbitrary side effects. */
31926 prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags;
31927 thr->heap->mark_and_sweep_base_flags |=
31928 DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */
31929 DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid attempt to compact any objects */
31930#endif
31931
31932 pcall_rc = duk_safe_call(ctx, duk__json_stringify_fast, 2 /*nargs*/, 0 /*nret*/);
31933
31934#if defined(DUK_USE_MARK_AND_SWEEP)
31935 thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
31936#endif
31937 if (pcall_rc == DUK_EXEC_SUCCESS) {
31938 DUK_DD(DUK_DDPRINT("fast path successful"));
31939 DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw);
31940 goto replace_finished;
31941 }
31942
31943 /* We come here for actual aborts (like encountering .toJSON())
31944 * but also for recursion/loop errors. Bufwriter size can be
31945 * kept because we'll probably need at least as much as we've
31946 * allocated so far.
31947 */
31948 DUK_D(DUK_DPRINT("fast path failed, serialize using slow path instead"));
31949 DUK_BW_RESET_SIZE(thr, &js_ctx->bw);
31950 js_ctx->recursion_depth = 0;
31951 }
31952#endif
31953
31954 /*
31955 * Create wrapper object and serialize
31956 */
31957
31958 idx_holder = duk_push_object(ctx);
31959 duk_dup(ctx, idx_value);
31960 duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING);
31961
31962 DUK_DDD(DUK_DDDPRINT("before: flags=0x%08lx, loop=%!T, replacer=%!O, "
31963 "proplist=%!T, gap=%!O, holder=%!T",
31964 (unsigned long) js_ctx->flags,
31965 (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop),
31966 (duk_heaphdr *) js_ctx->h_replacer,
31967 (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL),
31968 (duk_heaphdr *) js_ctx->h_gap,
31969 (duk_tval *) duk_get_tval(ctx, -1)));
31970
31971 /* serialize the wrapper with empty string key */
31972
31973 duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
31974
31975 /* [ ... buf loop (proplist) (gap) holder "" ] */
31976
31977 js_ctx->recursion_limit = DUK_USE_JSON_ENC_RECLIMIT;
31978 DUK_ASSERT(js_ctx->recursion_depth == 0);
31979
31980 if (DUK_UNLIKELY(duk__enc_value(js_ctx, idx_holder) == 0)) { /* [ ... holder key ] -> [ ... holder ] */
31981 /* Result is undefined. */
31982 duk_push_undefined(ctx);
31983 } else {
31984 /* Convert buffer to result string. */
31985 DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw);
31986 }
31987
31988 DUK_DDD(DUK_DDDPRINT("after: flags=0x%08lx, loop=%!T, replacer=%!O, "
31989 "proplist=%!T, gap=%!O, holder=%!T",
31990 (unsigned long) js_ctx->flags,
31991 (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop),
31992 (duk_heaphdr *) js_ctx->h_replacer,
31993 (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL),
31994 (duk_heaphdr *) js_ctx->h_gap,
31995 (duk_tval *) duk_get_tval(ctx, idx_holder)));
31996
31997 /* The stack has a variable shape here, so force it to the
31998 * desired one explicitly.
31999 */
32000

◆ duk_bi_logger_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_constructor ( duk_context * ctx)

Definition at line 32046 of file duktape-1.5.2/src/duktape.c.

32053 {
32054 (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C,
32055 (duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G,
32056 (duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F,
32057 (duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N,
32058 (duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R,
32059 (duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L
32060};
32061
32062/* Constructor */
32064 duk_hthread *thr = (duk_hthread *) ctx;
32065 duk_idx_t nargs;
32066
32067 /* Calling as a non-constructor is not meaningful. */
32068 if (!duk_is_constructor_call(ctx)) {
32069 return DUK_RET_TYPE_ERROR;
32070 }
32071
32072 nargs = duk_get_top(ctx);
32073 duk_set_top(ctx, 1);
32074
32075 duk_push_this(ctx);
32076
32077 /* [ name this ] */
32078
32079 if (nargs == 0) {
32080 /* Automatic defaulting of logger name from caller. This would
32081 * work poorly with tail calls, but constructor calls are currently
32082 * never tail calls, so tail calls are not an issue now.
32083 */
32084
32085 if (thr->callstack_top >= 2) {
32086 duk_activation *act_caller = thr->callstack + thr->callstack_top - 2;
32087 duk_hobject *func_caller;
32088
32089 func_caller = DUK_ACT_GET_FUNC(act_caller);
32090 if (func_caller) {
32091 /* Stripping the filename might be a good idea
32092 * ("/foo/bar/quux.js" -> logger name "quux"),
32093 * but now used verbatim.
32094 */
32095 duk_push_hobject(ctx, func_caller);
32097 duk_replace(ctx, 0);
32098 }
#define DUK_ASC_UC_C
#define DUK_ASC_UC_B
#define DUK_ASC_UC_D
#define DUK_ASC_UC_L
#define DUK_ASC_UC_W
#define DUK_ASC_UC_I
#define DUK_ASC_UC_R
#define DUK_ASC_UC_G
#define DUK_ASC_UC_N
#define DUK_ASC_UC_F
DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_constructor(duk_context *ctx)

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 32103 of file duktape-1.5.2/src/duktape.c.

32105 {
32106 duk_dup(ctx, 0);
32108 } else {
32109 /* don't set 'n' at all, inherited value is used as name */
32110 }
32111
32112 duk_compact(ctx, 1);
32113
32114 return 0; /* keep default instance */
32115}
32116
32117/* Default function to format objects. Tries to use toLogString() but falls
32118 * back to toString(). Any errors are propagated out without catching.
#define DUK_STRIDX_LC_N

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 32151 of file duktape-1.5.2/src/duktape.c.

32168 {
32169 duk_hthread *thr = (duk_hthread *) ctx;
32170 duk_double_t now;
32171 duk_small_int_t entry_lev = duk_get_current_magic(ctx);
32172 duk_small_int_t logger_lev;
32173 duk_int_t nargs;
32174 duk_int_t i;
32175 duk_size_t tot_len;
32176 const duk_uint8_t *arg_str;
32177 duk_size_t arg_len;
32178 duk_uint8_t *buf, *p;
32179 const duk_uint8_t *q;
32180 duk_uint8_t date_buf[DUK_BI_DATE_ISO8601_BUFSIZE];
32181 duk_size_t date_len;
32182 duk_small_int_t rc;
32183
32184 DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5);
32185 DUK_UNREF(thr);
32186
32187 /* XXX: sanitize to printable (and maybe ASCII) */
32188 /* XXX: better multiline */
32189
32190 /*
32191 * Logger arguments are:
32192 *
32193 * magic: log level (0-5)
32194 * this: logger
32195 * stack: plain log args
32196 *
32197 * We want to minimize memory churn so a two-pass approach
32198 * is used: first pass formats arguments and computes final
32199 * string length, second pass copies strings either into a
32200 * pre-allocated and reused buffer (short messages) or into a
32201 * newly allocated fixed buffer. If the backend function plays
32202 * nice, it won't coerce the buffer to a string (and thus
32203 * intern it).
32204 */
32205
32206 nargs = duk_get_top(ctx);
32207
32208 /* [ arg1 ... argN this ] */
32209
32210 /*
32211 * Log level check
32212 */
32213
32214 duk_push_this(ctx);
32215
32217 logger_lev = (duk_small_int_t) duk_get_int(ctx, -1);
32218 if (entry_lev < logger_lev) {
32219 return 0;
32220 }
32221 /* log level could be popped but that's not necessary */
32222
32223 now = DUK_USE_DATE_GET_NOW(ctx);
32224 duk_bi_date_format_timeval(now, date_buf);
32225 date_len = DUK_STRLEN((const char *) date_buf);
32226
32228 duk_to_string(ctx, -1);
32229 DUK_ASSERT(duk_is_string(ctx, -1));
32230
32231 /* [ arg1 ... argN this loggerLevel loggerName ] */
32232
32233 /*
32234 * Pass 1
32235 */
32236
32237 /* Line format: <time> <entryLev> <loggerName>: <msg> */
32238
32239 tot_len = 0;
32240 tot_len += 3 + /* separators: space, space, colon */
32241 3 + /* level string */
32242 date_len + /* time */
32243 duk_get_length(ctx, -1); /* loggerName */
32244
32245 for (i = 0; i < nargs; i++) {
32246 /* When formatting an argument to a string, errors may happen from multiple
32247 * causes. In general we want to catch obvious errors like a toLogString()
32248 * throwing an error, but we don't currently try to catch every possible
32249 * error. In particular, internal errors (like out of memory or stack) are
32250 * not caught. Also, we expect Error toString() to not throw an error.
32251 */
32252 if (duk_is_object(ctx, i)) {
32253 /* duk_pcall_prop() may itself throw an error, but we're content
32254 * in catching the obvious errors (like toLogString() throwing an
32255 * error).
32256 */
32258 duk_dup(ctx, i);
32259 /* [ arg1 ... argN this loggerLevel loggerName 'fmt' arg ] */
32260 /* call: this.fmt(arg) */
32261 rc = duk_pcall_prop(ctx, -5 /*obj_index*/, 1 /*nargs*/);
32262 if (rc) {
32263 /* Keep the error as the result (coercing it might fail below,
32264 * but we don't catch that now).
32265 */
32266 ;
32267 }
32268 duk_replace(ctx, i);
32269 }
32270 (void) duk_to_lstring(ctx, i, &arg_len);
32271 tot_len++; /* sep (even before first one) */
32272 tot_len += arg_len;
32273 }
32274
32275 /*
32276 * Pass 2
32277 */
32278
32279 /* XXX: There used to be a shared log buffer here, but it was removed
32280 * when dynamic buffer spare was removed. The problem with using
32281 * bufwriter is that, without the spare, the buffer gets passed on
32282 * as an argument to the raw() call so it'd need to be resized
32283 * (reallocated) anyway. If raw() call convention is changed, this
32284 * could be made more efficient.
32285 */
32286
32287 buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len);
32288 DUK_ASSERT(buf != NULL);
32289 p = buf;
32290
32291 DUK_MEMCPY((void *) p, (const void *) date_buf, (size_t) date_len);
32292 p += date_len;
32293 *p++ = (duk_uint8_t) DUK_ASC_SPACE;
32294
32295 q = duk__log_level_strings + (entry_lev * 3);
32296 DUK_MEMCPY((void *) p, (const void *) q, (size_t) 3);
32297 p += 3;
32298
32299 *p++ = (duk_uint8_t) DUK_ASC_SPACE;
32300
32301 arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len);
32302 DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len);
32303 p += arg_len;
32304
32305 *p++ = (duk_uint8_t) DUK_ASC_COLON;
32306
32307 for (i = 0; i < nargs; i++) {
32308 *p++ = (duk_uint8_t) DUK_ASC_SPACE;
32309
32310 arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len);
32311 DUK_ASSERT(arg_str != NULL);
32312 DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len);
32313 p += arg_len;
32314 }
32315 DUK_ASSERT(buf + tot_len == p);
32316
32317 /* [ arg1 ... argN this loggerLevel loggerName buffer ] */
32318
32319#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_LOGGING)
32320 /* Do debugger forwarding before raw() because the raw() function
32321 * doesn't get the log level right now.
32322 */
32323 if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
32324 const char *log_buf;
32325 duk_size_t sz_buf;
32326 log_buf = (const char *) duk_get_buffer(ctx, -1, &sz_buf);
32327 DUK_ASSERT(log_buf != NULL);
32328 duk_debug_write_notify(thr, DUK_DBG_CMD_LOG);
DUK_INTERNAL_DECL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf)
#define DUK_STRIDX_FMT
DUK_LOCAL const duk_uint8_t duk__log_level_strings[]
#define DUK_DBG_CMD_LOG
DUK_EXTERNAL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs)
#define DUK_STRIDX_LC_L

◆ duk_bi_logger_prototype_raw()

DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_raw ( duk_context * ctx)

Definition at line 32127 of file duktape-1.5.2/src/duktape.c.

32144 {

◆ duk_bi_math_object_max()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_max ( duk_context * ctx)

Definition at line 32635 of file duktape-1.5.2/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 32639 of file duktape-1.5.2/src/duktape.c.

32641 {

◆ duk_bi_math_object_onearg_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_onearg_shared ( duk_context * ctx)

Definition at line 32613 of file duktape-1.5.2/src/duktape.c.

32620 {
32621#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
32622 duk__atan2,
DUK_LOCAL double duk__atan2(double x, double y)

◆ duk_bi_math_object_random()

DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_random ( duk_context * ctx)

Definition at line 32643 of file duktape-1.5.2/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 32624 of file duktape-1.5.2/src/duktape.c.

32630 {
32633
double(* duk__one_arg_func)(double)

◆ duk_bi_nodejs_buffer_byte_length()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_byte_length ( duk_context * ctx)

Definition at line 23683 of file duktape-1.5.2/src/duktape.c.

23689 {
23690 DUK_UNREF(ctx);
23692}
23693#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
23694
23695/*
23696 * 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 23709 of file duktape-1.5.2/src/duktape.c.

23715 {
23716 DUK_UNREF(ctx);
23718}
23719#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
23720
23721/*
23722 * Node.js Buffer.concat()
23723 */
23724
23725#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
23727 duk_hthread *thr;
23728 duk_hobject *h_arg;
23729 duk_int_t total_length = 0;
23730 duk_hbufferobject *h_bufobj;
23731 duk_hbufferobject *h_bufres;
23732 duk_hbuffer *h_val;
23733 duk_uint_t i, n;
23734 duk_uint8_t *p;
23735 duk_size_t space_left;
23736 duk_size_t copy_size;
23737
23738 thr = (duk_hthread *) ctx;
23739 DUK_UNREF(thr);
23740
23741 /* Node.js accepts only actual Arrays. */
23742 h_arg = duk_require_hobject(ctx, 0);
23744 return DUK_RET_TYPE_ERROR;
23745 }
23746
23747 /* Compute result length and validate argument buffers. */
23748 n = (duk_uint_t) duk_get_length(ctx, 0);
23749 for (i = 0; i < n; i++) {
23750 /* Neutered checks not necessary here: neutered buffers have
23751 * zero 'length' so we'll effectively skip them.
23752 */
23753 DUK_ASSERT_TOP(ctx, 2); /* [ array totalLength ] */
23754 duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); /* -> [ array totalLength buf ] */
23755 h_bufobj = duk__require_bufobj_value(ctx, 2);
23756 DUK_ASSERT(h_bufobj != NULL);
23757 total_length += h_bufobj->length;
23758 duk_pop(ctx);
23759 }
23760 if (n == 1) {
23761 /* For the case n==1 Node.js doesn't seem to type check
23762 * the sole member but we do it before returning it.
23763 * For this case only the original buffer object is
23764 * returned (not a copy).
23765 */
23766 duk_get_prop_index(ctx, 0, 0);
23767 return 1;
23768 }
23769
23770 /* User totalLength overrides a computed length, but we'll check
23771 * every copy in the copy loop. Note that duk_to_uint() can
23772 * technically have arbitrary side effects so we need to recheck
23773 * the buffers in the copy loop.
23774 */
23775 if (!duk_is_undefined(ctx, 1) && n > 0) {
23776 /* For n == 0, Node.js ignores totalLength argument and
23777 * returns a zero length buffer.
23778 */
23779 total_length = duk_to_int(ctx, 1);
23780 }
23781 if (total_length < 0) {
23782 return DUK_RET_RANGE_ERROR;
23783 }
23784
23785 h_bufres = duk_push_bufferobject_raw(ctx,
23790 DUK_ASSERT(h_bufres != NULL);
23791
23792 p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, total_length);
23793 DUK_ASSERT(p != NULL);
23794 space_left = total_length;
23795
23796 for (i = 0; i < n; i++) {
23797 DUK_ASSERT_TOP(ctx, 4); /* [ array totalLength bufres buf ] */
23798
23799 duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);
23800 h_bufobj = duk__require_bufobj_value(ctx, 4);
23801 DUK_ASSERT(h_bufobj != NULL);
23802
23803 copy_size = h_bufobj->length;
23804 if (copy_size > space_left) {
23805 copy_size = space_left;
23806 }
23807
23808 if (h_bufobj->buf != NULL &&
23810 DUK_MEMCPY((void *) p,
23811 (const void *) DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj),
23812 copy_size);
23813 } else {
23814 /* Just skip, leaving zeroes in the result. */
23815 ;
#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx)

◆ duk_bi_nodejs_buffer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_constructor ( duk_context * ctx)

Definition at line 22112 of file duktape-1.5.2/src/duktape.c.

22129 {
22130 /* Internal class is Object: Object.prototype.toString.call(new Buffer(0))
22131 * prints "[object Object]".
22132 */
22133 duk_int_t len;
22134 duk_int_t i;
22135 duk_hbuffer *h_buf;
22136 duk_hbufferobject *h_bufobj;
22137 duk_size_t buf_size;
22138
22139 switch (duk_get_type(ctx, 0)) {
22140 case DUK_TYPE_BUFFER: {
22141 /* Custom behavior: plain buffer is used as internal buffer
22142 * without making a copy (matches Duktape.Buffer).
22143 */
22144 duk_set_top(ctx, 1); /* -> [ buffer ] */
22145 break;
22146 }
22147 case DUK_TYPE_NUMBER: {
22148 len = duk_to_int_clamped(ctx, 0, 0, DUK_INT_MAX);
22149 (void) duk_push_fixed_buffer(ctx, (duk_size_t) len);
22150 break;
22151 }
22152 case DUK_TYPE_OBJECT: {
22153 duk_uint8_t *buf;
22154
22155 (void) duk_get_prop_string(ctx, 0, "length");
22156 len = duk_to_int_clamped(ctx, -1, 0, DUK_INT_MAX);
22157 duk_pop(ctx);
22158 buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
22159 for (i = 0; i < len; i++) {
22160 /* XXX: fast path for array arguments? */
22161 duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);
22162 buf[i] = (duk_uint8_t) (duk_to_uint32(ctx, -1) & 0xffU);
22163 duk_pop(ctx);
22164 }
22165 break;
22166 }
22167 case DUK_TYPE_STRING: {
22168 /* ignore encoding for now */
22169 duk_dup(ctx, 0);
22170 (void) duk_to_buffer(ctx, -1, &buf_size);
22171 break;
22172 }
22173 default:
22174 return DUK_RET_TYPE_ERROR;
22175 }
22176
22177 DUK_ASSERT(duk_is_buffer(ctx, -1));
22178 h_buf = duk_get_hbuffer(ctx, -1);
22179 DUK_ASSERT(h_buf != NULL);
22180
#define duk_to_buffer(ctx, index, out_size)
DUK_EXTERNAL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key)

◆ duk_bi_nodejs_buffer_copy()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_copy ( duk_context * ctx)

Definition at line 23072 of file duktape-1.5.2/src/duktape.c.

23078 {
23079 DUK_UNREF(ctx);
23081}
23082#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
23083
23084/*
23085 * Node.js Buffer.prototype.copy()
23086 */
23087
23088#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
23090 duk_hthread *thr;
23091 duk_hbufferobject *h_this;
23092 duk_hbufferobject *h_bufarg;
23093 duk_int_t source_length;
23094 duk_int_t target_length;
23095 duk_int_t target_start, source_start, source_end;
23096 duk_uint_t target_ustart, source_ustart, source_uend;
23097 duk_uint_t copy_size = 0;
23098
23099 /* [ targetBuffer targetStart sourceStart sourceEnd ] */
23100
23101 thr = (duk_hthread *) ctx;
23102 DUK_UNREF(thr);
23103
23104 h_this = duk__require_bufobj_this(ctx);
23105 h_bufarg = duk__require_bufobj_value(ctx, 0);
23106 DUK_ASSERT(h_this != NULL);
23107 DUK_ASSERT(h_bufarg != NULL);
23108 source_length = (duk_int_t) h_this->length;
23109 target_length = (duk_int_t) h_bufarg->length;
23110
23111 target_start = duk_to_int(ctx, 1);
23112 source_start = duk_to_int(ctx, 2);
23113 if (duk_is_undefined(ctx, 3)) {
23114 source_end = source_length;
23115 } else {
23116 source_end = duk_to_int(ctx, 3);
23117 }
23118
23119 DUK_DDD(DUK_DDDPRINT("checking copy args: target_start=%ld, target_length=%ld, "
23120 "source_start=%ld, source_end=%ld, source_length=%ld",
23121 (long) target_start, (long) h_bufarg->length,
23122 (long) source_start, (long) source_end, (long) source_length));
23123
23124 /* This behavior mostly mimics Node.js now. */
23125
23126 if (source_start < 0 || source_end < 0 || target_start < 0) {
23127 /* Negative offsets cause a RangeError. */
23128 goto fail_bounds;
23129 }
23130 source_ustart = (duk_uint_t) source_start;
23131 source_uend = (duk_uint_t) source_end;
23132 target_ustart = (duk_uint_t) target_start;
23133 if (source_ustart >= source_uend || /* crossed offsets or zero size */
23134 source_ustart >= (duk_uint_t) source_length || /* source out-of-bounds (but positive) */
23135 target_ustart >= (duk_uint_t) target_length) { /* target out-of-bounds (but positive) */
23136 goto silent_ignore;
23137 }
23138 if (source_uend >= (duk_uint_t) source_length) {
23139 /* Source end clamped silently to available length. */
23140 source_uend = source_length;
23141 }
23142 copy_size = source_uend - source_ustart;
23143 if (target_ustart + copy_size > (duk_uint_t) target_length) {
23144 /* Clamp to target's end if too long.
23145 *
23146 * NOTE: there's no overflow possibility in the comparison;
23147 * both target_ustart and copy_size are >= 0 and based on
23148 * values in duk_int_t range. Adding them as duk_uint_t
23149 * values is then guaranteed not to overflow.
23150 */
23151 DUK_ASSERT(target_ustart + copy_size >= target_ustart); /* no overflow */
23152 DUK_ASSERT(target_ustart + copy_size >= copy_size); /* no overflow */
23153 copy_size = (duk_uint_t) target_length - target_ustart;
23154 }
23155
23156 DUK_DDD(DUK_DDDPRINT("making copy: target_ustart=%lu source_ustart=%lu copy_size=%lu",
23157 (unsigned long) target_ustart, (unsigned long) source_ustart,
23158 (unsigned long) copy_size));
23159
23160 DUK_ASSERT(copy_size >= 1);
23161 DUK_ASSERT(source_ustart <= (duk_uint_t) source_length);
23162 DUK_ASSERT(source_ustart + copy_size <= (duk_uint_t) source_length);
23163 DUK_ASSERT(target_ustart <= (duk_uint_t) target_length);
23164 DUK_ASSERT(target_ustart + copy_size <= (duk_uint_t) target_length);
23165
23166 /* Ensure copy is covered by underlying buffers. */
23167 DUK_ASSERT(h_bufarg->buf != NULL); /* length check */
23168 DUK_ASSERT(h_this->buf != NULL); /* length check */
23169 if (DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufarg, target_ustart + copy_size) &&
23170 DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, source_ustart + copy_size)) {
23171 /* Must use memmove() because copy area may overlap (source and target
23172 * buffer may be the same, or from different slices.
23173 */
23174 DUK_MEMMOVE((void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg) + target_ustart),
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx)

◆ duk_bi_nodejs_buffer_fill()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_fill ( duk_context * ctx)

Definition at line 22944 of file duktape-1.5.2/src/duktape.c.

22950 {
22951 DUK_UNREF(ctx);
22953}
22954#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22955
22956/*
22957 * Node.js Buffer.prototype.fill()
22958 */
22959
22960#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22962 duk_hthread *thr;
22963 duk_hbufferobject *h_this;
22964 const duk_uint8_t *fill_str_ptr;
22965 duk_size_t fill_str_len;
22966 duk_uint8_t fill_value;
22967 duk_int_t fill_offset;
22968 duk_int_t fill_end;
22969 duk_size_t fill_length;
22970 duk_uint8_t *p;
22971
22972 thr = (duk_hthread *) ctx;
22973 DUK_UNREF(thr);
22974
22975 h_this = duk__require_bufobj_this(ctx);
22976 DUK_ASSERT(h_this != NULL);
22977 if (h_this->buf == NULL) {
22978 return DUK_RET_TYPE_ERROR;
22979 }
22980
22981 /* [ value offset end ] */
22982
22983 if (duk_is_string(ctx, 0)) {
22984 fill_str_ptr = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &fill_str_len);
22985 DUK_ASSERT(fill_str_ptr != NULL);
22986 } else {
22987 fill_value = (duk_uint8_t) duk_to_uint32(ctx, 0);
22988 fill_str_ptr = (const duk_uint8_t *) &fill_value;
22989 fill_str_len = 1;
22990 }
22991
22992 /* Fill offset handling is more lenient than in Node.js. */
22993
22994 duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &fill_offset, &fill_end);
22995
22996 DUK_DDD(DUK_DDDPRINT("fill: fill_value=%02x, fill_offset=%ld, fill_end=%ld, view length=%ld",
22997 (unsigned int) fill_value, (long) fill_offset, (long) fill_end, (long) h_this->length));
22998
22999 DUK_ASSERT(fill_end - fill_offset >= 0);
23000 DUK_ASSERT(h_this->buf != NULL);
23001
23002 p = (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + fill_offset);
23003 fill_length = (duk_size_t) (fill_end - fill_offset);
23004 if (fill_str_len == 1) {
23005 /* Handle single character fills as memset() even when
23006 * the fill data comes from a one-char argument.
23007 */
23008 DUK_MEMSET((void *) p, (int) fill_str_ptr[0], (size_t) fill_length);
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx)

◆ duk_bi_nodejs_buffer_is_buffer()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_buffer ( duk_context * ctx)

Definition at line 23642 of file duktape-1.5.2/src/duktape.c.

23648 {
23649 DUK_UNREF(ctx);
23651}
23652#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
23653
23654/*
23655 * Node.js Buffer.isBuffer()
23656 */
23657
23658#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
23660 duk_hthread *thr;
23661 duk_tval *tv;
23662 duk_hobject *h;
23663 duk_hobject *h_proto;
23664 duk_bool_t ret = 0;
23665
23666 thr = (duk_hthread *) ctx;
23667
23668 DUK_ASSERT(duk_get_top(ctx) >= 1); /* nargs */
23669 tv = duk_get_tval(ctx, 0);
23670 DUK_ASSERT(tv != NULL);
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx)

◆ duk_bi_nodejs_buffer_is_encoding()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_encoding ( duk_context * ctx)

Definition at line 23620 of file duktape-1.5.2/src/duktape.c.

23626 {
23627 DUK_UNREF(ctx);
23629}

◆ duk_bi_nodejs_buffer_tojson()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tojson ( duk_context * ctx)

Definition at line 22833 of file duktape-1.5.2/src/duktape.c.

22835 :
22836 return DUK_RET_TYPE_ERROR;
22837}
22838#else /* DUK_USE_BUFFEROBJECT_SUPPORT */
22840 DUK_UNREF(ctx);
22842}
22843#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22844
22845/*
22846 * Node.js Buffer.prototype: toJSON()
22847 */
22848
22849#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22851 duk_hthread *thr;
22852 duk_hbufferobject *h_this;
22853 duk_uint8_t *buf;
22854 duk_uint_t i;
22855
22856 thr = (duk_hthread *) ctx;
22857 DUK_UNREF(thr);
22858 h_this = duk__require_bufobj_this(ctx);
22859 DUK_ASSERT(h_this != NULL);
22860
22861 if (h_this->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_this)) {
22862 /* Serialize uncovered backing buffer as a null; doesn't
22863 * really matter as long we're memory safe.
22864 */
22865 duk_push_null(ctx);
22866 return 1;
22867 }
22868
22869 duk_push_object(ctx);
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx)

◆ duk_bi_nodejs_buffer_tostring()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tostring ( duk_context * ctx)

Definition at line 22715 of file duktape-1.5.2/src/duktape.c.

22721 {
22722 DUK_UNREF(ctx);
22724}
22725#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22726
22727/*
22728 * Node.js Buffer: toString([encoding], [start], [end])
22729 */
22730
22731#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22733 duk_hthread *thr;
22734 duk_hbufferobject *h_this;
22735 duk_int_t start_offset, end_offset;
22736 duk_uint8_t *buf_slice;
22737 duk_size_t slice_length;
22738
22739 thr = (duk_hthread *) ctx;
22740 DUK_UNREF(thr);
22741
22742 h_this = duk__get_bufobj_this(ctx);
22743 if (h_this == NULL) {
22744 /* XXX: happens e.g. when evaluating: String(Buffer.prototype). */
22745 duk_push_string(ctx, "[object Object]");
22746 return 1;
22747 }
22749
22750 /* ignore encoding for now */
22751
22752 duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &start_offset, &end_offset);
22753
22754 slice_length = (duk_size_t) (end_offset - start_offset);
22755 buf_slice = (duk_uint8_t *) duk_push_fixed_buffer(ctx, slice_length);
22756 DUK_ASSERT(buf_slice != NULL);
22757
22758 if (h_this->buf == NULL) {
22759 goto type_error;
DUK_LOCAL duk_hbufferobject * duk__get_bufobj_this(duk_context *ctx)

◆ duk_bi_nodejs_buffer_write()

DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_write ( duk_context * ctx)

Definition at line 23021 of file duktape-1.5.2/src/duktape.c.

23027 {
23028 DUK_UNREF(ctx);
23030}
23031#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
23032
23033/*
23034 * Node.js Buffer.prototype.write(string, [offset], [length], [encoding])
23035 */
23036
23037#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
23039 duk_hthread *thr;
23040 duk_hbufferobject *h_this;
23041 duk_uint_t offset;
23042 duk_uint_t length;
23043 const duk_uint8_t *str_data;
23045
23046 thr = (duk_hthread *) ctx;
23047 DUK_UNREF(thr);
23048
23049 h_this = duk__require_bufobj_this(ctx);
23050 DUK_ASSERT(h_this != NULL);
23051
23052 /* Argument must be a string, e.g. a buffer is not allowed. */
23053 str_data = (const duk_uint8_t *) duk_require_lstring(ctx, 0, &str_len);
23054
23055 duk__resolve_offset_opt_length(ctx, h_this, 1, 2, &offset, &length, 0 /*throw_flag*/);
23056 DUK_ASSERT(offset <= h_this->length);
23057 DUK_ASSERT(offset + length <= h_this->length);
23058
23059 /* XXX: encoding is ignored now. */
DUK_EXTERNAL const char * duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx)
static int str_len(lua_State *L)

◆ duk_bi_number_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_constructor ( duk_context * ctx)

Definition at line 32713 of file duktape-1.5.2/src/duktape.c.

32716 {
32717 DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
32718 DUK_ERROR_TYPE((duk_hthread *) ctx, "number expected");
32719 }
32721 DUK_ASSERT(duk_is_number(ctx, -1));
32722 DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T",
32723 (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
32724 duk_remove(ctx, -2);
32725
32726 done:
32727 return duk_get_number(ctx, -1);
32728}
32729
32731 duk_hthread *thr = (duk_hthread *) ctx;
32732 duk_idx_t nargs;
32733 duk_hobject *h_this;
32734
32735 DUK_UNREF(thr);
32736
32737 /*
32738 * The Number constructor uses ToNumber(arg) for number coercion
32739 * (coercing an undefined argument to NaN). However, if the
32740 * argument is not given at all, +0 must be used instead. To do
32741 * this, a vararg function is used.
32742 */
32743
32744 nargs = duk_get_top(ctx);
32745 if (nargs == 0) {
32746 duk_push_int(ctx, 0);
32747 }
32748 duk_to_number(ctx, 0);
32749 duk_set_top(ctx, 1);
32750 DUK_ASSERT_TOP(ctx, 1);
32751
32752 if (!duk_is_constructor_call(ctx)) {
32753 return 1;
32754 }
32755
32756 /*
32757 * E5 Section 15.7.2.1 requires that the constructed object
32758 * must have the original Number.prototype as its internal
32759 * prototype. However, since Number.prototype is non-writable
32760 * and non-configurable, this doesn't have to be enforced here:
32761 * The default object (bound to 'this') is OK, though we have
32762 * to change its class.
32763 *
32764 * Internal value set to ToNumber(arg) or +0; if no arg given,
32765 * ToNumber(undefined) = NaN, so special treatment is needed
DUK_INTERNAL_DECL duk_ret_t duk_bi_number_constructor(duk_context *ctx)

◆ duk_bi_number_prototype_to_exponential()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_exponential ( duk_context * ctx)

Definition at line 32839 of file duktape-1.5.2/src/duktape.c.

32850 :
32851 DUK_ASSERT_TOP(ctx, 2);
32852 duk_to_string(ctx, -1);
32853 return 1;
32854}
32855
32857 duk_bool_t frac_undefined;
32858 duk_small_int_t frac_digits;
32859 duk_double_t d;
32861 duk_small_uint_t n2s_flags;
32862
32864
32865 frac_undefined = duk_is_undefined(ctx, 0);
32866 duk_to_int(ctx, 0); /* for side effects */
32867
32869 if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
32870 goto use_to_string;
32871 }
DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx)

◆ duk_bi_number_prototype_to_fixed()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_fixed ( duk_context * ctx)

Definition at line 32806 of file duktape-1.5.2/src/duktape.c.

32810 {
32811 /* XXX: just use toString() for now; permitted although not recommended.
32812 * nargs==1, so radix is passed to toString().
32813 */
32815}
32816
32817/*
32818 * toFixed(), toExponential(), toPrecision()
32819 */
32820
32821/* XXX: shared helper for toFixed(), toExponential(), toPrecision()? */
32822
32824 duk_small_int_t frac_digits;
32825 duk_double_t d;
32827 duk_small_uint_t n2s_flags;
32828
32829 frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20);
32831
32833 if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
32834 goto use_to_string;
32835 }
32836
32837 if (d >= 1.0e21 || d <= -1.0e21) {
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_ret_t duk_bi_number_prototype_to_string(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx)

◆ 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 32793 of file duktape-1.5.2/src/duktape.c.

32794 {
32795 radix = 10;
32796 } else {
32797 radix = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 2, 36);
32798 }

◆ duk_bi_number_prototype_to_precision()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_precision ( duk_context * ctx)

Definition at line 32873 of file duktape-1.5.2/src/duktape.c.

32877
32879 10 /*radix*/,
32880 frac_digits + 1 /*leading digit + fractions*/,
32881 n2s_flags /*flags*/);
32882 return 1;
32883
32884 use_to_string:
32885 DUK_ASSERT_TOP(ctx, 2);
32886 duk_to_string(ctx, -1);
32887 return 1;
32888}
32889
32891 /* The specification has quite awkward order of coercion and
32892 * checks for toPrecision(). The operations below are a bit
32893 * reordered, within constraints of observable side effects.
32894 */
32895
32896 duk_double_t d;
32897 duk_small_int_t prec;
32899 duk_small_uint_t n2s_flags;
32900
32901 DUK_ASSERT_TOP(ctx, 1);
32902
32904 if (duk_is_undefined(ctx, 0)) {
32905 goto use_to_string;
32906 }
32907 DUK_ASSERT_TOP(ctx, 2);
32908
32909 duk_to_int(ctx, 0); /* for side effects */
32910
32912 if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
32913 goto use_to_string;
32914 }
32915
32916 prec = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 1, 21);
32917
32918 n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |
#define DUK_N2S_FLAG_FIXED_FORMAT
DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx)

◆ duk_bi_number_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_string ( duk_context * ctx)

Definition at line 32772 of file duktape-1.5.2/src/duktape.c.

32784 {
32785 (void) duk__push_this_number_plain(ctx);
32786 return 1;
32787}
32788
32790 duk_small_int_t radix;
32791 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 32767 of file duktape-1.5.2/src/duktape.c.

◆ duk_bi_object_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor ( duk_context * ctx)

Definition at line 32926 of file duktape-1.5.2/src/duktape.c.

32927 :
32928 /* Used when precision is undefined; also used for NaN (-> "NaN"),
32929 * and +/- infinity (-> "Infinity", "-Infinity").
32930 */
32931
32932 DUK_ASSERT_TOP(ctx, 2);
32933 duk_to_string(ctx, -1);
32934 return 1;
32935}
32936#line 1 "duk_bi_object.c"
32937/*
32938 * Object built-ins
32939 */
32940
32941/* include removed: duk_internal.h */
32942
32944 if (!duk_is_constructor_call(ctx) &&
32945 !duk_is_null_or_undefined(ctx, 0)) {
32946 duk_to_object(ctx, 0);
32947 return 1;
32948 }
32949
32950 if (duk_is_object(ctx, 0)) {
32951 return 1;
32952 }
32953
32954 /* Pointer and buffer primitive values are treated like other
32955 * primitives values which have a fully fledged object counterpart:
32956 * promote to an object value. Lightfuncs are coerced with
32957 * ToObject() even they could also be returned as is.
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor(duk_context *ctx)

◆ duk_bi_object_constructor_create()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_create ( duk_context * ctx)

Definition at line 33077 of file duktape-1.5.2/src/duktape.c.

33080 :
33081 duk_set_top(ctx, 1);
33082 return ret_success;
33083
33084 fail_nonextensible:
33085 fail_loop:
33086 return DUK_RET_TYPE_ERROR;
33087}
33088
33090 /* XXX: no need for indirect call */
33092}
33093
33095 duk_tval *tv;
33097
33098 DUK_ASSERT_TOP(ctx, 2);
33099
33100 tv = duk_get_tval(ctx, 0);
33101 DUK_ASSERT(tv != NULL);
33102 if (DUK_TVAL_IS_NULL(tv)) {
33103 ;
33104 } else if (DUK_TVAL_IS_OBJECT(tv)) {
33106 DUK_ASSERT(proto != NULL);
33107 } else {
33108 return DUK_RET_TYPE_ERROR;
33109 }
33110
33114 proto);
33115
33116 if (!duk_is_undefined(ctx, 1)) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_hobject_object_get_own_property_descriptor(duk_context *ctx)
#define DUK_TVAL_IS_NULL(tv)
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx)

◆ duk_bi_object_constructor_define_properties()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_properties ( duk_context * ctx)

Definition at line 33188 of file duktape-1.5.2/src/duktape.c.

33205 {
33206 duk_small_uint_t pass;
33207 duk_uint_t defprop_flags;
33208 duk_hobject *obj;
33209 duk_idx_t idx_value;
33210 duk_hobject *get;
33211 duk_hobject *set;
33212
33213 /* Lightfunc handling by ToObject() coercion. */
33214 obj = duk_require_hobject_or_lfunc_coerce(ctx, 0); /* target */
33215 DUK_ASSERT(obj != NULL);
33216
33217 duk_to_object(ctx, 1); /* properties object */
33218
33219 DUK_DDD(DUK_DDDPRINT("target=%!iT, properties=%!iT",
33220 (duk_tval *) duk_get_tval(ctx, 0),
33221 (duk_tval *) duk_get_tval(ctx, 1)));
33222
33223 /*
33224 * Two pass approach to processing the property descriptors.
33225 * On first pass validate and normalize all descriptors before
33226 * any changes are made to the target object. On second pass
33227 * make the actual modifications to the target object.
33228 *
33229 * Right now we'll just use the same normalize/validate helper
33230 * on both passes, ignoring its outputs on the first pass.
33231 */
33232
33233 for (pass = 0; pass < 2; pass++) {
33234 duk_set_top(ctx, 2); /* -> [ hobject props ] */
33235 duk_enum(ctx, 1, DUK_ENUM_OWN_PROPERTIES_ONLY /*enum_flags*/);
33236
33237 for (;;) {
33238 duk_hstring *key;
33239
33240 /* [ hobject props enum(props) ] */
33241
33242 duk_set_top(ctx, 3);
33243
33244 if (!duk_next(ctx, 2, 1 /*get_value*/)) {
33245 break;
33246 }
33247
33248 DUK_DDD(DUK_DDDPRINT("-> key=%!iT, desc=%!iT",
33249 (duk_tval *) duk_get_tval(ctx, -2),
33250 (duk_tval *) duk_get_tval(ctx, -1)));
33251
33252 /* [ hobject props enum(props) key desc ] */
33253
33255 4 /*idx_desc*/,
33256 &defprop_flags,
33257 &idx_value,
33258 &get,
33259 &set);
33260
33261 /* [ hobject props enum(props) key desc value? getter? setter? ] */
33262
33263 if (pass == 0) {
33264 continue;
33265 }
33266
33267 key = duk_get_hstring(ctx, 3);
33268 DUK_ASSERT(key != NULL);
33269
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_bi_object_constructor_define_property()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_property ( duk_context * ctx)

Definition at line 33118 of file duktape-1.5.2/src/duktape.c.

33135 {
33136 duk_hobject *obj;
33137 duk_hstring *key;
33138 duk_hobject *get;
33139 duk_hobject *set;
33140 duk_idx_t idx_value;
33141 duk_uint_t defprop_flags;
33142
33143 DUK_ASSERT(ctx != NULL);
33144
33145 DUK_DDD(DUK_DDDPRINT("Object.defineProperty(): ctx=%p obj=%!T key=%!T desc=%!T",
33146 (void *) ctx,
33147 (duk_tval *) duk_get_tval(ctx, 0),
33148 (duk_tval *) duk_get_tval(ctx, 1),
33149 (duk_tval *) duk_get_tval(ctx, 2)));
33150
33151 /* [ obj key desc ] */
33152
33153 /* Lightfuncs are currently supported by coercing to a temporary
33154 * Function object; changes will be allowed (the coerced value is
33155 * extensible) but will be lost.
33156 */
33158 (void) duk_to_string(ctx, 1);
33159 key = duk_require_hstring(ctx, 1);
33160 (void) duk_require_hobject(ctx, 2);
33161
33162 DUK_ASSERT(obj != NULL);
33163 DUK_ASSERT(key != NULL);
33164 DUK_ASSERT(duk_get_hobject(ctx, 2) != NULL);
33165
33166 /*
33167 * Validate and convert argument property descriptor (an Ecmascript
33168 * object) into a set of defprop_flags and possibly property value,
33169 * getter, and/or setter values on the value stack.
33170 *
33171 * Lightfunc set/get values are coerced to full Functions.
33172 */
33173
33175 2 /*idx_desc*/,
33176 &defprop_flags,
33177 &idx_value,
33178 &get,
33179 &set);
33180
33181 /*
33182 * Use Object.defineProperty() helper for the actual operation.
33183 */
33184
33186 defprop_flags,
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_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 33072 of file duktape-1.5.2/src/duktape.c.

33073 {
33074 goto fail_loop;
33075 }

◆ duk_bi_object_constructor_is_extensible()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_extensible ( duk_context * ctx)

Definition at line 33330 of file duktape-1.5.2/src/duktape.c.

33331 {
33332 duk_hobject *h;
33333 duk_bool_t is_frozen;
33334 duk_bool_t rc;
33335
33336 h = duk_require_hobject_or_lfunc(ctx, 0);
33337 if (!h) {
33338 duk_push_true(ctx); /* frozen and sealed */
33339 } else {
33340 is_frozen = duk_get_current_magic(ctx);
DUK_INTERNAL_DECL duk_hobject * duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index)

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 33314 of file duktape-1.5.2/src/duktape.c.

33315 {
33316 /* Lightfunc, always success. */
33317 return 1;
33318 }
33319 DUK_ASSERT(h != NULL);
33320
33322
33323 /* A non-extensible object cannot gain any more properties,
33324 * so this is a good time to compact.
33325 */
33327
33328 return 1;
#define DUK_HOBJECT_CLEAR_EXTENSIBLE(h)

◆ duk_bi_object_constructor_keys_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_keys_shared ( duk_context * ctx)

Definition at line 33345 of file duktape-1.5.2/src/duktape.c.

33347 {
33348 duk_hobject *h;
33349
33350 h = duk_require_hobject_or_lfunc(ctx, 0);
33351 if (!h) {
33352 duk_push_false(ctx);
33353 } else {
33355 }
33356 return 1;
33357}
33358
33359/* Shared helper for Object.getOwnPropertyNames() and Object.keys().
33360 * Magic: 0=getOwnPropertyNames, 1=Object.keys.
33361 */
33363 duk_hthread *thr = (duk_hthread *) ctx;
33364 duk_hobject *obj;
33365#if defined(DUK_USE_ES6_PROXY)
33366 duk_hobject *h_proxy_target;
33367 duk_hobject *h_proxy_handler;
33368 duk_hobject *h_trap_result;
33369 duk_uarridx_t i, len, idx;
33370#endif
33371 duk_small_uint_t enum_flags;
33372
33373 DUK_ASSERT_TOP(ctx, 1);
33374 DUK_UNREF(thr);
33375
33377 DUK_ASSERT(obj != NULL);
33378 DUK_UNREF(obj);
33379
33380#if defined(DUK_USE_ES6_PROXY)
33382 obj,
33383 &h_proxy_target,
33384 &h_proxy_handler))) {
33385 goto skip_proxy;
33386 }
33387
33388 duk_push_hobject(ctx, h_proxy_handler);
33390 /* Careful with reachability here: don't pop 'obj' before pushing
33391 * proxy target.
33392 */
33393 DUK_DDD(DUK_DDDPRINT("no ownKeys trap, get keys of target instead"));
33394 duk_pop_2(ctx);
33395 duk_push_hobject(ctx, h_proxy_target);
33396 duk_replace(ctx, 0);
33397 DUK_ASSERT_TOP(ctx, 1);
33398 goto skip_proxy;
33399 }
33400
33401 /* [ obj handler trap ] */
33402 duk_insert(ctx, -2);
33403 duk_push_hobject(ctx, h_proxy_target); /* -> [ obj trap handler target ] */
33404 duk_call_method(ctx, 1 /*nargs*/); /* -> [ obj trap_result ] */
33405 h_trap_result = duk_require_hobject(ctx, -1);
33406 DUK_UNREF(h_trap_result);
33407
33408 len = (duk_uarridx_t) duk_get_length(ctx, -1);
33409 idx = 0;
33410 duk_push_array(ctx);
33411 for (i = 0; i < len; i++) {
33412 /* [ obj trap_result res_arr ] */
33413 if (duk_get_prop_index(ctx, -2, i) && duk_is_string(ctx, -1)) {
33414 /* XXX: for Object.keys() we should check enumerability of key */
33415 /* [ obj trap_result res_arr propname ] */
33416 duk_put_prop_index(ctx, -2, idx);
33417 idx++;
33418 } else {
33419 duk_pop(ctx);
33420 }
33421 }
33422
33423 /* XXX: missing trap result validation for non-configurable target keys
33424 * (must be present), for non-extensible target all target keys must be
33425 * present and no extra keys can be present.
33426 * http://www.ecma-international.org/ecma-262/6.0/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
33427 */
33428
33429 /* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result)
33430 * should be filtered so that only enumerable keys remain. Enumerability
33431 * should be checked with [[GetOwnProperty]] on the original object
33432 * (i.e., the proxy in this case). If the proxy has a getOwnPropertyDescriptor
33433 * trap, it should be triggered for every property. If the proxy doesn't have
33434 * the trap, enumerability should be checked against the target object instead.
33435 * We don't do any of this now, so Object.keys() and Object.getOwnPropertyNames()
33436 * return the same result now for proxy traps. We still do clean up the trap
33437 * result, so that Object.keys() and Object.getOwnPropertyNames() will return a
33438 * clean array of strings without gaps.
33439 */
33440 return 1;
33441
33442 skip_proxy:
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx)
#define DUK_STRIDX_OWN_KEYS

◆ duk_bi_object_constructor_prevent_extensions()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_prevent_extensions ( duk_context * ctx)

Definition at line 33293 of file duktape-1.5.2/src/duktape.c.

33294 {
33295 /* Lightfunc, always success. */
33296 return 1;
33297 }
33298
33299 is_freeze = (duk_bool_t) duk_get_current_magic(ctx);
33300 duk_hobject_object_seal_freeze_helper(thr, h, is_freeze);
33301
33302 /* Sealed and frozen objects cannot gain any more properties,
33303 * so this is a good time to compact them.
33304 */
33306
33307 return 1;
33308}
33309
33311 duk_hthread *thr = (duk_hthread *) ctx;
33312 duk_hobject *h;
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_prevent_extensions(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_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 33271 of file duktape-1.5.2/src/duktape.c.

33288 {
33289 duk_hthread *thr = (duk_hthread *) ctx;
33290 duk_hobject *h;
33291 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 32964 of file duktape-1.5.2/src/duktape.c.

32964 {
32965 duk_to_object(ctx, 0);
32966 return 1;
32967 }
32968
32973 return 1;
32974}
32975
32976/* Shared helper to implement Object.getPrototypeOf and the ES6
32977 * Object.prototype.__proto__ getter.
32978 *
32979 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
32980 */
32982 duk_hthread *thr = (duk_hthread *) ctx;
32983 duk_hobject *h;
32985
32986 DUK_UNREF(thr);
32987
32988 /* magic: 0=getter call, 1=Object.getPrototypeOf */
32989 if (duk_get_current_magic(ctx) == 0) {
32991 duk_insert(ctx, 0);
32992 }
32993
32994 h = duk_require_hobject_or_lfunc(ctx, 0);
32995 /* h is NULL for lightfunc */
32996
32997 /* XXX: should the API call handle this directly, i.e. attempt
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx)

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 33490 of file duktape-1.5.2/src/duktape.c.

33492 {

◆ 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 33467 of file duktape-1.5.2/src/duktape.c.

33467 {
33468 DUK_ASSERT_TOP(ctx, 0);
33471 if (!duk_is_callable(ctx, 1)) {
33472 return DUK_RET_TYPE_ERROR;
33473 }
33474 duk_dup(ctx, 0); /* -> [ O toString O ] */
33475 duk_call_method(ctx, 0); /* XXX: call method tail call? */
33476 return 1;
33477}
33478
33481 return 1;
33482}
33483
33485 duk_hthread *thr = (duk_hthread *) ctx;
33486 duk_hobject *h_v;
33487 duk_hobject *h_obj;
33488
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx)
#define DUK_STRIDX_TO_STRING
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx)

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 33494 of file duktape-1.5.2/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 33450 of file duktape-1.5.2/src/duktape.c.

33451 {
33452 /* Object.getOwnPropertyNames */
33453 enum_flags = DUK_ENUM_INCLUDE_NONENUMERABLE |
33456 }
33457
33458 return duk_hobject_get_enumerated_keys(ctx, enum_flags);
33459}
33460
#define DUK_ENUM_NO_PROXY_BEHAVIOR
#define DUK_ENUM_INCLUDE_NONENUMERABLE

◆ duk_bi_object_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_string ( duk_context * ctx)

Definition at line 33444 of file duktape-1.5.2/src/duktape.c.

33447 {
33448 /* 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 33462 of file duktape-1.5.2/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 33005 of file duktape-1.5.2/src/duktape.c.

33005 {
33006 proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
33007 if (proto) {
33008 duk_push_hobject(ctx, proto);
33009 } else {
33010 duk_push_null(ctx);
33011 }
33012 }
33013 return 1;
33014}
33015
33016/* Shared helper to implement ES6 Object.setPrototypeOf and
33017 * Object.prototype.__proto__ setter.
33018 *
33019 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
33020 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.setprototypeof
33021 */
33023 duk_hthread *thr = (duk_hthread *) ctx;
33024 duk_hobject *h_obj;
33025 duk_hobject *h_new_proto;
33026 duk_hobject *h_curr;
33027 duk_ret_t ret_success = 1; /* retval for success path */
33028
33029 /* Preliminaries for __proto__ and setPrototypeOf (E6 19.1.2.18 steps 1-4);
33030 * magic: 0=setter call, 1=Object.setPrototypeOf
33031 */
33032 if (duk_get_current_magic(ctx) == 0) {
33034 duk_insert(ctx, 0);
33036 return 0;
33037 }
33038
33039 /* __proto__ setter returns 'undefined' on success unlike the
33040 * setPrototypeOf() call which returns the target object.
33041 */
33042 ret_success = 0;
33043 } else {
33046 }
33047
33048 h_new_proto = duk_get_hobject(ctx, 1);
33049 /* h_new_proto may be NULL */
33050 if (duk_is_lightfunc(ctx, 0)) {
33051 if (h_new_proto == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]) {
33052 goto skip;
33053 }
33054 goto fail_nonextensible;
33055 }
33056 h_obj = duk_get_hobject(ctx, 0);
33057 if (!h_obj) {
33058 goto skip;
33059 }
33060 DUK_ASSERT(h_obj != NULL);
33061
33062 /* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */
33063 /* TODO: implement Proxy object support here */
33064
33065 if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) {
33066 goto skip;
33067 }
33068 if (!DUK_HOBJECT_HAS_EXTENSIBLE(h_obj)) {
33069 goto fail_nonextensible;
33070 }
#define DUK_TYPE_MASK_OBJECT
#define duk_require_object_coercible(ctx, index)
#define duk_require_type_mask(ctx, index, mask)
DUK_INTERNAL_DECL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx)
DUK_EXTERNAL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL void duk_push_this_check_object_coercible(duk_context *ctx)

◆ duk_bi_pointer_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_constructor ( duk_context * ctx)

Definition at line 33508 of file duktape-1.5.2/src/duktape.c.

33511 {
33512 return duk_hobject_object_ownprop_helper(ctx, DUK_PROPDESC_FLAG_ENUMERABLE /*required_desc_flags*/);
33513}
33514#line 1 "duk_bi_pointer.c"
33515/*
33516 * Pointer built-ins
33517 */
33518
33519/* include removed: duk_internal.h */
33520
33521/*
33522 * Constructor
33523 */
33524
33526 /* XXX: this behavior is quite useless now; it would be nice to be able
33527 * to create pointer values from e.g. numbers or strings. Numbers are
33528 * problematic on 64-bit platforms though. Hex encoded strings?
33529 */
33530 if (duk_get_top(ctx) == 0) {
33531 duk_push_pointer(ctx, NULL);
33532 } else {
33533 duk_to_pointer(ctx, 0);
33534 }
DUK_EXTERNAL void * duk_to_pointer(duk_context *ctx, duk_idx_t index)
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_ret_t duk_bi_pointer_constructor(duk_context *ctx)

◆ duk_bi_pointer_prototype_tostring_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_prototype_tostring_shared ( duk_context * ctx)

Definition at line 33540 of file duktape-1.5.2/src/duktape.c.

33557 {
33558 duk_tval *tv;
33559 duk_small_int_t to_string = duk_get_current_magic(ctx);
33560
33561 duk_push_this(ctx);
33562 tv = duk_require_tval(ctx, -1);
33563 DUK_ASSERT(tv != NULL);
33564
33565 if (DUK_TVAL_IS_POINTER(tv)) {
33566 /* nop */
33567 } else if (DUK_TVAL_IS_OBJECT(tv)) {
33569 DUK_ASSERT(h != NULL);
33570
33571 /* Must be a "pointer object", i.e. class "Pointer" */
#define DUK_TVAL_IS_POINTER(tv)

◆ duk_bi_proxy_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor ( duk_context * ctx)

Definition at line 33580 of file duktape-1.5.2/src/duktape.c.

33581 {
33582 duk_to_string(ctx, -1);
33583 }
33584 return 1;
33585
33586 type_error:
33587 return DUK_RET_TYPE_ERROR;
33588}
33589#line 1 "duk_bi_proxy.c"
33590/*
33591 * Proxy built-in (ES6)
33592 */
33593
33594/* include removed: duk_internal.h */
33595
33596#if defined(DUK_USE_ES6_PROXY)
33598 duk_hobject *h_target;
33599 duk_hobject *h_handler;
33600
33601 if (!duk_is_constructor_call(ctx)) {
33602 return DUK_RET_TYPE_ERROR;
33603 }
33604
33605 /* Reject a proxy object as the target because it would need
33606 * special handler in property lookups. (ES6 has no such restriction)
33607 */
33608 h_target = duk_require_hobject_or_lfunc_coerce(ctx, 0);
33609 DUK_ASSERT(h_target != NULL);
33610 if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_target)) {
33611 return DUK_RET_TYPE_ERROR;
33612 }
33613
33614 /* Reject a proxy object as the handler because it would cause
33615 * potentially unbounded recursion. (ES6 has no such restriction)
33616 */
33617 h_handler = duk_require_hobject_or_lfunc_coerce(ctx, 1);
33618 DUK_ASSERT(h_handler != NULL);
33619 if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_handler)) {
33620 return DUK_RET_TYPE_ERROR;
33621 }
33622
33623 /* XXX: the returned value is exotic in ES6, but we use a
33624 * simple object here with no prototype. Without a prototype,
33625 * [[DefaultValue]] coercion fails which is abit confusing.
33626 * No callable check/handling in the current Proxy subset.
33627 */
33632 NULL);
DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx)

References duk_to_string().

◆ duk_bi_regexp_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_constructor ( duk_context * ctx)

Definition at line 33659 of file duktape-1.5.2/src/duktape.c.

33665 {
33666 duk_hobject *h;
33667
33668 duk_push_this(ctx);
33670 DUK_ASSERT(h != NULL);
33671 DUK_UNREF(h);
33672 duk_insert(ctx, 0); /* prepend regexp to valstack 0 index */
33673}
33674
33675/* XXX: much to improve (code size) */
33677 duk_hthread *thr = (duk_hthread *) ctx;
33678 duk_hobject *h_pattern;
33679
33680 DUK_ASSERT_TOP(ctx, 2);
33681 h_pattern = duk_get_hobject(ctx, 0);
33682
33683 if (!duk_is_constructor_call(ctx) &&
33684 h_pattern != NULL &&
33686 duk_is_undefined(ctx, 1)) {
33687 /* Called as a function, pattern has [[Class]] "RegExp" and
33688 * flags is undefined -> return object as is.
33689 */
33690 duk_dup(ctx, 0);
33691 return 1;
33692 }
33693
33694 /* Else functionality is identical for function call and constructor
33695 * call.
33696 */
33697
33698 if (h_pattern != NULL &&
33700 if (duk_is_undefined(ctx, 1)) {
33701 duk_bool_t flag_g, flag_i, flag_m;
33706
33707 duk_push_sprintf(ctx, "%s%s%s",
33708 (const char *) (flag_g ? "g" : ""),
33709 (const char *) (flag_i ? "i" : ""),
33710 (const char *) (flag_m ? "m" : ""));
33711
33712 /* [ ... pattern flags ] */
33713 } else {
33714 return DUK_RET_TYPE_ERROR;
33715 }
33716 } else {
33717 if (duk_is_undefined(ctx, 0)) {
33718 duk_push_string(ctx, "");
33719 } else {
33720 duk_dup(ctx, 0);
33721 duk_to_string(ctx, -1);
33722 }
33723 if (duk_is_undefined(ctx, 1)) {
33724 duk_push_string(ctx, "");
33725 } else {
33726 duk_dup(ctx, 1);
33727 duk_to_string(ctx, -1);
33728 }
33729
33730 /* [ ... pattern flags ] */
DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx)
#define DUK_STRIDX_SOURCE
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)
#define DUK_STRIDX_IGNORE_CASE
#define DUK_STRIDX_MULTILINE

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 33732 of file duktape-1.5.2/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 33744 of file duktape-1.5.2/src/duktape.c.

33749 {
33751
33752 /* [ regexp input ] */
33753
33755
33756 /* [ result ] */
33757
DUK_LOCAL void duk__get_this_regexp(duk_context *ctx)
DUK_INTERNAL_DECL void duk_regexp_match(duk_hthread *thr)

◆ duk_bi_regexp_prototype_to_string()

DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_to_string ( duk_context * ctx)

Definition at line 33759 of file duktape-1.5.2/src/duktape.c.

33761 {
33763
33764 /* [ regexp input ] */
33765
33766 /* result object is created and discarded; wasteful but saves code space */
33768
33769 /* [ result ] */
33770
33771 duk_push_boolean(ctx, (duk_is_null(ctx, -1) ? 0 : 1));
33772
33773 return 1;
33774}
33775
33777 duk_hstring *h_bc;
33778 duk_small_int_t re_flags;
33779
33780#if 0
33781 /* A little tricky string approach to provide the flags string.
33782 * This depends on the specific flag values in duk_regexp.h,
33783 * which needs to be asserted for. In practice this doesn't
33784 * produce more compact code than the easier approach in use.
33785 */
33786
33787 const char *flag_strings = "gim\0gi\0gm\0g\0";
33788 duk_uint8_t flag_offsets[8] = {
33789 (duk_uint8_t) 3, /* flags: "" */
33790 (duk_uint8_t) 10, /* flags: "g" */
33791 (duk_uint8_t) 5, /* flags: "i" */
33792 (duk_uint8_t) 4, /* flags: "gi" */
33793 (duk_uint8_t) 2, /* flags: "m" */
33794 (duk_uint8_t) 7, /* flags: "gm" */
33795 (duk_uint8_t) 1, /* flags: "im" */
33796 (duk_uint8_t) 0, /* flags: "gim" */
33797 };
33801#endif
33802
33804
33805 /* [ regexp ] */
33806
33809 h_bc = duk_get_hstring(ctx, -1);
33810 DUK_ASSERT(h_bc != NULL);
33813 DUK_ASSERT(DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);
33814 re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
33815
33816 /* [ regexp source bytecode ] */
33817
33818#if 1
33819 /* This is a cleaner approach and also produces smaller code than
33820 * the other alternative. Use duk_require_string() for format
33821 * safety (although the source property should always exist).
33822 */
33823 duk_push_sprintf(ctx, "/%s/%s%s%s",
33824 (const char *) duk_require_string(ctx, -2), /* require to be safe */
DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx)

◆ duk_bi_string_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor ( duk_context * ctx)

Definition at line 33869 of file duktape-1.5.2/src/duktape.c.

33886 {
33887 /* String constructor needs to distinguish between an argument not given at all
33888 * vs. given as 'undefined'. We're a vararg function to handle this properly.
33889 */
33890
33891 if (duk_get_top(ctx) == 0) {
33893 } else {
33894 duk_to_string(ctx, 0);
33895 }
33896 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 33898 of file duktape-1.5.2/src/duktape.c.

33899 {
33905
33906 /* String object internal value is immutable */
33907 duk_dup(ctx, 0);
33909 }
33910 /* Note: unbalanced stack on purpose */
33911
33912 return 1;
33913}
33914
33916 duk_hthread *thr = (duk_hthread *) ctx;
33917 duk_bufwriter_ctx bw_alloc;
33919 duk_idx_t i, n;
33921
33922 /* XXX: It would be nice to build the string directly but ToUint16()
33923 * coercion is needed so a generic helper would not be very
33924 * helpful (perhaps coerce the value stack first here and then
33925 * build a string from a duk_tval number sequence in one go?).
33926 */
33927
33928 n = duk_get_top(ctx);
33929
33930 bw = &bw_alloc;
33931 DUK_BW_INIT_PUSHBUF(thr, bw, n); /* initial estimate for ASCII only codepoints */
33932
33933 for (i = 0; i < n; i++) {
33934 /* XXX: could improve bufwriter handling to write multiple codepoints
33935 * with one ensure call but the relative benefit would be quite small.
33936 */
33937
33938#if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT)
33939 /* ToUint16() coercion is mandatory in the E5.1 specification, but
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx)
#define DUK_BIDX_STRING_PROTOTYPE

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 34150 of file duktape-1.5.2/src/duktape.c.

34153 {
34154 end_pos = start_pos;
34155 }
34156
34157 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 33982 of file duktape-1.5.2/src/duktape.c.

33985 {
33986 goto type_error;
33987 }
33988
33989 /* never here, but fall through */
33990
33991 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 33993 of file duktape-1.5.2/src/duktape.c.

33999 {
34000 duk_int_t pos;
34001
34002 /* XXX: faster implementation */
34003
34005 pos = duk_to_int(ctx, 0);
34006 duk_substring(ctx, -1, pos, pos + 1);
34007 return 1;
34008}
34009
34011 duk_hthread *thr = (duk_hthread *) ctx;
34012 duk_int_t pos;
34013 duk_hstring *h;
34014 duk_bool_t clamped;
34015
34016 /* XXX: faster implementation */
34017
34018 DUK_DDD(DUK_DDDPRINT("arg=%!T", (duk_tval *) duk_get_tval(ctx, 0)));
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx)
DUK_INTERNAL_DECL duk_hstring * duk_push_this_coercible_to_string(duk_context *ctx)

◆ duk_bi_string_prototype_concat()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_concat ( duk_context * ctx)

Definition at line 35091 of file duktape-1.5.2/src/duktape.c.

35095 {
35096 duk_push_null(ctx);
35097 }

◆ duk_bi_string_prototype_indexof_shared()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_indexof_shared ( duk_context * ctx)

Definition at line 34163 of file duktape-1.5.2/src/duktape.c.

34167 {
34168 duk_hthread *thr = (duk_hthread *) ctx;
34169 duk_small_int_t uppercase = duk_get_current_magic(ctx);
34170
34173 return 1;
34174}
34175
34176/*
34177 * indexOf() and lastIndexOf()
34178 */
34179
34181 duk_hthread *thr = (duk_hthread *) ctx;
34182 duk_hstring *h_this;
34183 duk_hstring *h_search;
34184 duk_int_t clen_this;
34185 duk_int_t cpos;
34186 duk_int_t bpos;
34187 const duk_uint8_t *p_start, *p_end, *p;
34188 const duk_uint8_t *q_start;
34189 duk_int_t q_blen;
34190 duk_uint8_t firstbyte;
34191 duk_uint8_t t;
34192 duk_small_int_t is_lastindexof = duk_get_current_magic(ctx); /* 0=indexOf, 1=lastIndexOf */
34193
34195 DUK_ASSERT(h_this != NULL);
34196 clen_this = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h_this);
34197
34198 h_search = duk_to_hstring(ctx, 0);
34199 DUK_ASSERT(h_search != NULL);
34200 q_start = DUK_HSTRING_GET_DATA(h_search);
34201 q_blen = (duk_int_t) DUK_HSTRING_GET_BYTELEN(h_search);
34202
34203 duk_to_number(ctx, 1);
34204 if (duk_is_nan(ctx, 1) && is_lastindexof) {
34205 /* indexOf: NaN should cause pos to be zero.
34206 * lastIndexOf: NaN should cause pos to be +Infinity
34207 * (and later be clamped to len).
34208 */
34209 cpos = clen_this;
34210 } else {
34211 cpos = duk_to_int_clamped(ctx, 1, 0, clen_this);
34212 }
34213
34214 /* Empty searchstring always matches; cpos must be clamped here.
34215 * (If q_blen were < 0 due to clamped coercion, it would also be
34216 * caught here.)
34217 */
34218 if (q_blen <= 0) {
34219 duk_push_int(ctx, cpos);
34220 return 1;
34221 }
34222 DUK_ASSERT(q_blen > 0);
34223
34224 bpos = (duk_int_t) duk_heap_strcache_offset_char2byte(thr, h_this, (duk_uint32_t) cpos);
34225
34226 p_start = DUK_HSTRING_GET_DATA(h_this);
34227 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_this);
34228 p = p_start + bpos;
34229
34230 /* This loop is optimized for size. For speed, there should be
34231 * two separate loops, and we should ensure that memcmp() can be
34232 * used without an extra "will searchstring fit" check. Doing
34233 * the preconditioning for 'p' and 'p_end' is easy but cpos
34234 * must be updated if 'p' is wound back (backward scanning).
34235 */
34236
34237 firstbyte = q_start[0]; /* leading byte of match string */
34238 while (p <= p_end && p >= p_start) {
34239 t = *p;
34240
34241 /* For Ecmascript strings, this check can only match for
34242 * initial UTF-8 bytes (not continuation bytes). For other
34243 * strings all bets are off.
34244 */
34245
34246 if ((t == firstbyte) && ((duk_size_t) (p_end - p) >= (duk_size_t) q_blen)) {
34247 DUK_ASSERT(q_blen > 0); /* no issues with memcmp() zero size, even if broken */
34248 if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
34249 duk_push_int(ctx, cpos);
34250 return 1;
34251 }
34252 }
34253
34254 /* track cpos while scanning */
34255 if (is_lastindexof) {
34256 /* when going backwards, we decrement cpos 'early';
34257 * 'p' may point to a continuation byte of the char
34258 * at offset 'cpos', but that's OK because we'll
34259 * backtrack all the way to the initial byte.
DUK_EXTERNAL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL void duk_unicode_case_convert_string(duk_hthread *thr, duk_bool_t uppercase)
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx)

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 35107 of file duktape-1.5.2/src/duktape.c.

35108 {
35109 /* duk_concat() coerces arguments with ToString() in correct order */
35111 duk_insert(ctx, 0); /* this is relatively expensive */
35112 duk_concat(ctx, duk_get_top(ctx));
35113 return 1;
35114}
35115
35117 DUK_ASSERT_TOP(ctx, 0);
35119 duk_trim(ctx, 0);
35120 DUK_ASSERT_TOP(ctx, 1);
35121 return 1;
35122}
35123
35125 duk_hstring *h1;
35126 duk_hstring *h2;
35127 duk_size_t h1_len, h2_len, prefix_len;
35128 duk_small_int_t ret = 0;
35129 duk_small_int_t rc;
35130
35131 /* The current implementation of localeCompare() is simply a codepoint
35132 * by codepoint comparison, implemented with a simple string compare
35133 * because UTF-8 should preserve codepoint ordering (assuming valid
35134 * shortest UTF-8 encoding).
35135 *
35136 * The specification requires that the return value must be related
35137 * to the sort order: e.g. negative means that 'this' comes before
35138 * 'that' in sort order. We assume an ascending sort order.
35139 */
35140
35141 /* XXX: could share code with duk_js_ops.c, duk_js_compare_helper */
35142
35144 DUK_ASSERT(h1 != NULL);
35145
35146 h2 = duk_to_hstring(ctx, 0);
35147 DUK_ASSERT(h2 != NULL);
35148
35149 h1_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1);
35150 h2_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2);
35151 prefix_len = (h1_len <= h2_len ? h1_len : h2_len);
35152
35153 /* Zero size compare not an issue with DUK_MEMCMP. */
35154 rc = (duk_small_int_t) DUK_MEMCMP((const void *) DUK_HSTRING_GET_DATA(h1),
35155 (const void *) DUK_HSTRING_GET_DATA(h2),
35156 (size_t) prefix_len);
35157
35158 if (rc < 0) {
35159 ret = -1;
35160 goto done;
35161 } else if (rc > 0) {
35162 ret = 1;
35163 goto done;
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx)
DUK_EXTERNAL void duk_trim(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx)

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 35013 of file duktape-1.5.2/src/duktape.c.

35013 {
35014 duk_push_int(ctx, -1);
35015 return 1;
35016 }
35017
35019 DUK_ASSERT(duk_is_number(ctx, -1));
35020 return 1;
35021}
35022#else /* DUK_USE_REGEXP_SUPPORT */
35024 DUK_UNREF(ctx);
35026}
35027#endif /* DUK_USE_REGEXP_SUPPORT */
35028
35029#ifdef DUK_USE_REGEXP_SUPPORT
35031 duk_hthread *thr = (duk_hthread *) ctx;
35032 duk_bool_t global;
35033 duk_int_t prev_last_index;
35034 duk_int_t this_index;
35035 duk_int_t arr_idx;
35036
35037 DUK_ASSERT_TOP(ctx, 1);
35039 duk__to_regexp_helper(ctx, 0 /*index*/, 0 /*force_new*/);
35041 DUK_ASSERT_TOP(ctx, 2);
35042
35043 /* stack[0] = regexp
35044 * stack[1] = string
35045 */
35046
35047 if (!global) {
35048 duk_regexp_match(thr); /* -> [ res_obj ] */
35049 return 1; /* return 'res_obj' */
35050 }
35051
35052 /* Global case is more complex. */
35053
35054 /* [ regexp string ] */
35055
35056 duk_push_int(ctx, 0);
35058 duk_push_array(ctx);
35059
35060 /* [ regexp string res_arr ] */
35061
35062 prev_last_index = 0;
35063 arr_idx = 0;
35064
35065 for (;;) {
35066 DUK_ASSERT_TOP(ctx, 3);
35067
35068 duk_dup(ctx, 0);
35069 duk_dup(ctx, 1);
35070 duk_regexp_match(thr); /* -> [ ... regexp string ] -> [ ... res_obj ] */
35071
35072 if (!duk_is_object(ctx, -1)) {
35073 duk_pop(ctx);
35074 break;
35075 }
35076
35078 DUK_ASSERT(duk_is_number(ctx, -1));
35079 this_index = duk_get_int(ctx, -1);
35080 duk_pop(ctx);
35081
35082 if (this_index == prev_last_index) {
35083 this_index++;
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx)

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 34276 of file duktape-1.5.2/src/duktape.c.

34293 {
34294 duk_hthread *thr = (duk_hthread *) ctx;
34295 duk_hstring *h_input;
34296 duk_hstring *h_match;
34297 duk_hstring *h_search;
34298 duk_hobject *h_re;
34299 duk_bufwriter_ctx bw_alloc;
34301#ifdef DUK_USE_REGEXP_SUPPORT
34302 duk_bool_t is_regexp;
34303 duk_bool_t is_global;
34304#endif
34305 duk_bool_t is_repl_func;
34306 duk_uint32_t match_start_coff, match_start_boff;
34307#ifdef DUK_USE_REGEXP_SUPPORT
34308 duk_int_t match_caps;
34309#endif
34310 duk_uint32_t prev_match_end_boff;
34311 const duk_uint8_t *r_start, *r_end, *r; /* repl string scan */
34312 duk_size_t tmp_sz;
34313
34314 DUK_ASSERT_TOP(ctx, 2);
34315 h_input = duk_push_this_coercible_to_string(ctx);
34316 DUK_ASSERT(h_input != NULL);
34317
34318 bw = &bw_alloc;
34319 DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* input size is good output starting point */
34320
34321 DUK_ASSERT_TOP(ctx, 4);
34322
34323 /* stack[0] = search value
34324 * stack[1] = replace value
34325 * stack[2] = input string
34326 * stack[3] = result buffer
34327 */
34328
34330 if (h_re) {
34331#ifdef DUK_USE_REGEXP_SUPPORT
34332 is_regexp = 1;
34334
34335 if (is_global) {
34336 /* start match from beginning */
34337 duk_push_int(ctx, 0);
34339 }
34340#else /* DUK_USE_REGEXP_SUPPORT */
34342#endif /* DUK_USE_REGEXP_SUPPORT */
34343 } else {
34344 duk_to_string(ctx, 0);
34345#ifdef DUK_USE_REGEXP_SUPPORT
34346 is_regexp = 0;
34347 is_global = 0;
34348#endif
34349 }
34350
34351 if (duk_is_function(ctx, 1)) {
34352 is_repl_func = 1;
34353 r_start = NULL;
34354 r_end = NULL;
34355 } else {
34356 duk_hstring *h_repl;
34357
34358 is_repl_func = 0;
34359 h_repl = duk_to_hstring(ctx, 1);
34360 DUK_ASSERT(h_repl != NULL);
34361 r_start = DUK_HSTRING_GET_DATA(h_repl);
34362 r_end = r_start + DUK_HSTRING_GET_BYTELEN(h_repl);
34363 }
34364
34365 prev_match_end_boff = 0;
34366
34367 for (;;) {
34368 /*
34369 * If matching with a regexp:
34370 * - non-global RegExp: lastIndex not touched on a match, zeroed
34371 * on a non-match
34372 * - global RegExp: on match, lastIndex will be updated by regexp
34373 * executor to point to next char after the matching part (so that
34374 * characters in the matching part are not matched again)
34375 *
34376 * If matching with a string:
34377 * - always non-global match, find first occurrence
34378 *
34379 * We need:
34380 * - The character offset of start-of-match for the replacer function
34381 * - The byte offsets for start-of-match and end-of-match to implement
34382 * the replacement values $&, $`, and $', and to copy non-matching
34383 * input string portions (including header and trailer) verbatim.
34384 *
34385 * NOTE: the E5.1 specification is a bit vague how the RegExp should
34386 * behave in the replacement process; e.g. is matching done first for
34387 * all matches (in the global RegExp case) before any replacer calls
34388 * are made? See: test-bi-string-proto-replace.js for discussion.
34389 */
34390
34391 DUK_ASSERT_TOP(ctx, 4);
34392
34393#ifdef DUK_USE_REGEXP_SUPPORT
34394 if (is_regexp) {
34395 duk_dup(ctx, 0);
34396 duk_dup(ctx, 2);
34397 duk_regexp_match(thr); /* [ ... regexp input ] -> [ res_obj ] */
34398 if (!duk_is_object(ctx, -1)) {
34399 duk_pop(ctx);
34400 break;
34401 }
34402
34404 DUK_ASSERT(duk_is_number(ctx, -1));
34405 match_start_coff = duk_get_int(ctx, -1);
34406 duk_pop(ctx);
34407
34408 duk_get_prop_index(ctx, -1, 0);
34409 DUK_ASSERT(duk_is_string(ctx, -1));
34410 h_match = duk_get_hstring(ctx, -1);
34411 DUK_ASSERT(h_match != NULL);
34412 duk_pop(ctx); /* h_match is borrowed, remains reachable through match_obj */
34413
34414 if (DUK_HSTRING_GET_BYTELEN(h_match) == 0) {
34415 /* This should be equivalent to match() algorithm step 8.f.iii.2:
34416 * detect an empty match and allow it, but don't allow it twice.
34417 */
34418 duk_uint32_t last_index;
34419
34421 last_index = (duk_uint32_t) duk_get_uint(ctx, -1);
34422 DUK_DDD(DUK_DDDPRINT("empty match, bump lastIndex: %ld -> %ld",
34423 (long) last_index, (long) (last_index + 1)));
34424 duk_pop(ctx);
34425 duk_push_int(ctx, last_index + 1);
34427 }
34428
34429 DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_INT_MAX); /* string limits */
34430 match_caps = (duk_int_t) duk_get_length(ctx, -1);
34431 } else {
34432#else /* DUK_USE_REGEXP_SUPPORT */
34433 { /* unconditionally */
34434#endif /* DUK_USE_REGEXP_SUPPORT */
34435 const duk_uint8_t *p_start, *p_end, *p; /* input string scan */
34436 const duk_uint8_t *q_start; /* match string */
34437 duk_size_t q_blen;
34438
34439#ifdef DUK_USE_REGEXP_SUPPORT
34440 DUK_ASSERT(!is_global); /* single match always */
34441#endif
34442
34443 p_start = DUK_HSTRING_GET_DATA(h_input);
34444 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
34445 p = p_start;
34446
34447 h_search = duk_get_hstring(ctx, 0);
34448 DUK_ASSERT(h_search != NULL);
34449 q_start = DUK_HSTRING_GET_DATA(h_search);
34450 q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_search);
34451
34452 p_end -= q_blen; /* ensure full memcmp() fits in while */
34453
34454 match_start_coff = 0;
34455
34456 while (p <= p_end) {
34457 DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
34458 if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
34459 duk_dup(ctx, 0);
34460 h_match = duk_get_hstring(ctx, -1);
34461 DUK_ASSERT(h_match != NULL);
34462#ifdef DUK_USE_REGEXP_SUPPORT
34463 match_caps = 0;
34464#endif
34465 goto found;
34466 }
34467
34468 /* track utf-8 non-continuation bytes */
34469 if ((p[0] & 0xc0) != 0x80) {
34470 match_start_coff++;
34471 }
34472 p++;
34473 }
34474
34475 /* not found */
34476 break;
34477 }
34478 found:
34479
34480 /* stack[0] = search value
34481 * stack[1] = replace value
34482 * stack[2] = input string
34483 * stack[3] = result buffer
34484 * stack[4] = regexp match OR match string
34485 */
34486
34487 match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
34488
34489 tmp_sz = (duk_size_t) (match_start_boff - prev_match_end_boff);
34490 DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz);
34491
34492 prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match);
34493
34494 if (is_repl_func) {
34495 duk_idx_t idx_args;
34496 duk_hstring *h_repl;
34497
34498 /* regexp res_obj is at index 4 */
34499
34500 duk_dup(ctx, 1);
34501 idx_args = duk_get_top(ctx);
34502
34503#ifdef DUK_USE_REGEXP_SUPPORT
34504 if (is_regexp) {
34505 duk_int_t idx;
34506 duk_require_stack(ctx, match_caps + 2);
34507 for (idx = 0; idx < match_caps; idx++) {
34508 /* match followed by capture(s) */
34509 duk_get_prop_index(ctx, 4, idx);
34510 }
34511 } else {
34512#else /* DUK_USE_REGEXP_SUPPORT */
34513 { /* unconditionally */
34514#endif /* DUK_USE_REGEXP_SUPPORT */
34515 /* match == search string, by definition */
34516 duk_dup(ctx, 0);
34517 }
34518 duk_push_int(ctx, match_start_coff);
34519 duk_dup(ctx, 2);
34520
34521 /* [ ... replacer match [captures] match_char_offset input ] */
34522
34523 duk_call(ctx, duk_get_top(ctx) - idx_args);
34524 h_repl = duk_to_hstring(ctx, -1); /* -> [ ... repl_value ] */
34525 DUK_ASSERT(h_repl != NULL);
34526
34527 DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_repl);
34528
34529 duk_pop(ctx); /* repl_value */
34530 } else {
34531 r = r_start;
34532
34533 while (r < r_end) {
34534 duk_int_t ch1;
34535 duk_int_t ch2;
34536#ifdef DUK_USE_REGEXP_SUPPORT
34537 duk_int_t ch3;
34538#endif
34540
34541 ch1 = *r++;
34542 if (ch1 != DUK_ASC_DOLLAR) {
34543 goto repl_write;
34544 }
34545 left = r_end - r;
34546
34547 if (left <= 0) {
34548 goto repl_write;
34549 }
34550
34551 ch2 = r[0];
34552 switch ((int) ch2) {
34553 case DUK_ASC_DOLLAR: {
34554 ch1 = (1 << 8) + DUK_ASC_DOLLAR;
34555 goto repl_write;
34556 }
34557 case DUK_ASC_AMP: {
34558 DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_match);
34559 r++;
34560 continue;
34561 }
34562 case DUK_ASC_GRAVE: {
34563 tmp_sz = (duk_size_t) match_start_boff;
34564 DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input), tmp_sz);
34565 r++;
34566 continue;
34567 }
34568 case DUK_ASC_SINGLEQUOTE: {
34569 duk_uint32_t match_end_boff;
34570
34571 /* Use match charlen instead of bytelen, just in case the input and
34572 * match codepoint encodings would have different lengths.
34573 */
34574 match_end_boff = duk_heap_strcache_offset_char2byte(thr,
34575 h_input,
34576 match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match));
34577
34578 tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff);
34579 DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + match_end_boff, tmp_sz);
34580 r++;
34581 continue;
34582 }
34583 default: {
34584#ifdef DUK_USE_REGEXP_SUPPORT
34585 duk_int_t capnum, captmp, capadv;
34586 /* XXX: optional check, match_caps is zero if no regexp,
34587 * so dollar will be interpreted literally anyway.
34588 */
34589
34590 if (!is_regexp) {
34591 goto repl_write;
34592 }
34593
34594 if (!(ch2 >= DUK_ASC_0 && ch2 <= DUK_ASC_9)) {
34595 goto repl_write;
34596 }
34597 capnum = ch2 - DUK_ASC_0;
34598 capadv = 1;
34599
34600 if (left >= 2) {
34601 ch3 = r[1];
34602 if (ch3 >= DUK_ASC_0 && ch3 <= DUK_ASC_9) {
34603 captmp = capnum * 10 + (ch3 - DUK_ASC_0);
34604 if (captmp < match_caps) {
34605 capnum = captmp;
34606 capadv = 2;
34607 }
34608 }
34609 }
34610
34611 if (capnum > 0 && capnum < match_caps) {
34612 DUK_ASSERT(is_regexp != 0); /* match_caps == 0 without regexps */
34613
34614 /* regexp res_obj is at offset 4 */
34615 duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum);
34616 if (duk_is_string(ctx, -1)) {
34617 duk_hstring *h_tmp_str;
34618
34619 h_tmp_str = duk_get_hstring(ctx, -1);
34620 DUK_ASSERT(h_tmp_str != NULL);
34621
34622 DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_tmp_str);
34623 } else {
34624 /* undefined -> skip (replaced with empty) */
34625 }
34626 duk_pop(ctx);
34627 r += capadv;
34628 continue;
34629 } else {
34630 goto repl_write;
34631 }
34632#else /* DUK_USE_REGEXP_SUPPORT */
34633 goto repl_write; /* unconditionally */
34634#endif /* DUK_USE_REGEXP_SUPPORT */
34635 } /* default case */
34636 } /* switch (ch2) */
34637
34638 repl_write:
34639 /* ch1 = (r_increment << 8) + byte */
34640
34641 DUK_BW_WRITE_ENSURE_U8(thr, bw, (duk_uint8_t) (ch1 & 0xff));
34642 r += ch1 >> 8;
34643 } /* while repl */
34644 } /* if (is_repl_func) */
34645
34646 duk_pop(ctx); /* pop regexp res_obj or match string */
34647
34648#ifdef DUK_USE_REGEXP_SUPPORT
#define DUK_ASC_AMP
#define DUK_BW_WRITE_ENSURE_U8(thr, bw_ctx, val)
DUK_EXTERNAL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index)
#define DUK_ASC_GRAVE
#define DUK_BW_WRITE_ENSURE_BYTES(thr, bw_ctx, valptr, valsz)
#define DUK_ASC_DOLLAR

◆ duk_bi_string_prototype_search()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_search ( duk_context * ctx)

Definition at line 34967 of file duktape-1.5.2/src/duktape.c.

34970 {
34971 goto do_new;
34972 }
34973 return;
34974
34975 do_new:
34977 duk_dup(ctx, index);
34978 duk_new(ctx, 1); /* [ ... RegExp val ] -> [ ... res ] */
34979 duk_replace(ctx, index);
34980}
34981#endif /* DUK_USE_REGEXP_SUPPORT */
34982
34983#ifdef DUK_USE_REGEXP_SUPPORT
34985 duk_hthread *thr = (duk_hthread *) ctx;
34986
34987 /* Easiest way to implement the search required by the specification
34988 * is to do a RegExp test() with lastIndex forced to zero. To avoid
34989 * side effects on the argument, "clone" the RegExp if a RegExp was
34990 * given as input.
34991 *
34992 * The global flag of the RegExp should be ignored; setting lastIndex
34993 * to zero (which happens when "cloning" the RegExp) should have an
34994 * equivalent effect.
34995 */
34996
34997 DUK_ASSERT_TOP(ctx, 1);
34998 (void) duk_push_this_coercible_to_string(ctx); /* at index 1 */
34999 duk__to_regexp_helper(ctx, 0 /*index*/, 1 /*force_new*/);
35000
35001 /* stack[0] = regexp
35002 * stack[1] = string
35003 */
35004
#define DUK_BIDX_REGEXP_CONSTRUCTOR

◆ duk_bi_string_prototype_slice()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_slice ( duk_context * ctx)

Definition at line 34110 of file duktape-1.5.2/src/duktape.c.

34121 {
34122 DUK_UNREF(ctx);
34124}
34125#endif /* DUK_USE_SECTION_B */
34126
34128 duk_hstring *h;
34129 duk_int_t start_pos, end_pos;
34130 duk_int_t len;
34131
34133 DUK_ASSERT(h != NULL);
34135
34136 /* [ start end str ] */
34137
34138 start_pos = duk_to_int_clamped(ctx, 0, -len, len);
34139 if (start_pos < 0) {
34140 start_pos = len + start_pos;
34141 }
34142 if (duk_is_undefined(ctx, 1)) {
34143 end_pos = len;
34144 } else {
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx)

◆ duk_bi_string_prototype_split()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_split ( duk_context * ctx)

Definition at line 34658 of file duktape-1.5.2/src/duktape.c.

34675 {
34676 duk_hthread *thr = (duk_hthread *) ctx;
34677 duk_hstring *h_input;
34678 duk_hstring *h_sep;
34679 duk_uint32_t limit;
34680 duk_uint32_t arr_idx;
34681#ifdef DUK_USE_REGEXP_SUPPORT
34682 duk_bool_t is_regexp;
34683#endif
34684 duk_bool_t matched; /* set to 1 if any match exists (needed for empty input special case) */
34685 duk_uint32_t prev_match_end_coff, prev_match_end_boff;
34686 duk_uint32_t match_start_boff, match_start_coff;
34687 duk_uint32_t match_end_boff, match_end_coff;
34688
34689 DUK_UNREF(thr);
34690
34691 h_input = duk_push_this_coercible_to_string(ctx);
34692 DUK_ASSERT(h_input != NULL);
34693
34694 duk_push_array(ctx);
34695
34696 if (duk_is_undefined(ctx, 1)) {
34697 limit = 0xffffffffUL;
34698 } else {
34699 limit = duk_to_uint32(ctx, 1);
34700 }
34701
34702 if (limit == 0) {
34703 return 1;
34704 }
34705
34706 /* If the separator is a RegExp, make a "clone" of it. The specification
34707 * algorithm calls [[Match]] directly for specific indices; we emulate this
34708 * by tweaking lastIndex and using a "force global" variant of duk_regexp_match()
34709 * which will use global-style matching even when the RegExp itself is non-global.
34710 */
34711
34712 if (duk_is_undefined(ctx, 0)) {
34713 /* The spec algorithm first does "R = ToString(separator)" before checking
34714 * whether separator is undefined. Since this is side effect free, we can
34715 * skip the ToString() here.
34716 */
34717 duk_dup(ctx, 2);
34718 duk_put_prop_index(ctx, 3, 0);
34719 return 1;
34721#ifdef DUK_USE_REGEXP_SUPPORT
34723 duk_dup(ctx, 0);
34724 duk_new(ctx, 1); /* [ ... RegExp val ] -> [ ... res ] */
34725 duk_replace(ctx, 0);
34726 /* lastIndex is initialized to zero by new RegExp() */
34727 is_regexp = 1;
34728#else
34730#endif
34731 } else {
34732 duk_to_string(ctx, 0);
34733#ifdef DUK_USE_REGEXP_SUPPORT
34734 is_regexp = 0;
34735#endif
34736 }
34737
34738 /* stack[0] = separator (string or regexp)
34739 * stack[1] = limit
34740 * stack[2] = input string
34741 * stack[3] = result array
34742 */
34743
34744 prev_match_end_boff = 0;
34745 prev_match_end_coff = 0;
34746 arr_idx = 0;
34747 matched = 0;
34748
34749 for (;;) {
34750 /*
34751 * The specification uses RegExp [[Match]] to attempt match at specific
34752 * offsets. We don't have such a primitive, so we use an actual RegExp
34753 * and tweak lastIndex. Since the RegExp may be non-global, we use a
34754 * special variant which forces global-like behavior for matching.
34755 */
34756
34757 DUK_ASSERT_TOP(ctx, 4);
34758
34759#ifdef DUK_USE_REGEXP_SUPPORT
34760 if (is_regexp) {
34761 duk_dup(ctx, 0);
34762 duk_dup(ctx, 2);
34763 duk_regexp_match_force_global(thr); /* [ ... regexp input ] -> [ res_obj ] */
34764 if (!duk_is_object(ctx, -1)) {
34765 duk_pop(ctx);
34766 break;
34767 }
34768 matched = 1;
34769
34771 DUK_ASSERT(duk_is_number(ctx, -1));
34772 match_start_coff = duk_get_int(ctx, -1);
34773 match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
34774 duk_pop(ctx);
34775
34776 if (match_start_coff == DUK_HSTRING_GET_CHARLEN(h_input)) {
34777 /* don't allow an empty match at the end of the string */
34778 duk_pop(ctx);
34779 break;
34780 }
34781
34783 DUK_ASSERT(duk_is_number(ctx, -1));
34784 match_end_coff = duk_get_int(ctx, -1);
34785 match_end_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_end_coff);
34786 duk_pop(ctx);
34787
34788 /* empty match -> bump and continue */
34789 if (prev_match_end_boff == match_end_boff) {
34790 duk_push_int(ctx, match_end_coff + 1);
34792 duk_pop(ctx);
34793 continue;
34794 }
34795 } else {
34796#else /* DUK_USE_REGEXP_SUPPORT */
34797 { /* unconditionally */
34798#endif /* DUK_USE_REGEXP_SUPPORT */
34799 const duk_uint8_t *p_start, *p_end, *p; /* input string scan */
34800 const duk_uint8_t *q_start; /* match string */
34801 duk_size_t q_blen, q_clen;
34802
34803 p_start = DUK_HSTRING_GET_DATA(h_input);
34804 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
34805 p = p_start + prev_match_end_boff;
34806
34807 h_sep = duk_get_hstring(ctx, 0);
34808 DUK_ASSERT(h_sep != NULL);
34809 q_start = DUK_HSTRING_GET_DATA(h_sep);
34810 q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sep);
34811 q_clen = (duk_size_t) DUK_HSTRING_GET_CHARLEN(h_sep);
34812
34813 p_end -= q_blen; /* ensure full memcmp() fits in while */
34814
34815 match_start_coff = prev_match_end_coff;
34816
34817 if (q_blen == 0) {
34818 /* Handle empty separator case: it will always match, and always
34819 * triggers the check in step 13.c.iii initially. Note that we
34820 * must skip to either end of string or start of first codepoint,
34821 * skipping over any continuation bytes!
34822 *
34823 * Don't allow an empty string to match at the end of the input.
34824 */
34825
34826 matched = 1; /* empty separator can always match */
34827
34828 match_start_coff++;
34829 p++;
34830 while (p < p_end) {
34831 if ((p[0] & 0xc0) != 0x80) {
34832 goto found;
34833 }
34834 p++;
34835 }
34836 goto not_found;
34837 }
34838
34839 DUK_ASSERT(q_blen > 0 && q_clen > 0);
34840 while (p <= p_end) {
34841 DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
34842 DUK_ASSERT(q_blen > 0); /* no issues with empty memcmp() */
34843 if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
34844 /* never an empty match, so step 13.c.iii can't be triggered */
34845 goto found;
34846 }
34847
34848 /* track utf-8 non-continuation bytes */
34849 if ((p[0] & 0xc0) != 0x80) {
34850 match_start_coff++;
34851 }
34852 p++;
34853 }
34854
34855 not_found:
34856 /* not found */
34857 break;
34858
34859 found:
34860 matched = 1;
34861 match_start_boff = (duk_uint32_t) (p - p_start);
34862 match_end_coff = (duk_uint32_t) (match_start_coff + q_clen); /* constrained by string length */
34863 match_end_boff = (duk_uint32_t) (match_start_boff + q_blen); /* ditto */
34864
34865 /* empty match (may happen with empty separator) -> bump and continue */
34866 if (prev_match_end_boff == match_end_boff) {
34867 prev_match_end_boff++;
34868 prev_match_end_coff++;
34869 continue;
34870 }
34871 } /* if (is_regexp) */
34872
34873 /* stack[0] = separator (string or regexp)
34874 * stack[1] = limit
34875 * stack[2] = input string
34876 * stack[3] = result array
34877 * stack[4] = regexp res_obj (if is_regexp)
34878 */
34879
34880 DUK_DDD(DUK_DDDPRINT("split; match_start b=%ld,c=%ld, match_end b=%ld,c=%ld, prev_end b=%ld,c=%ld",
34881 (long) match_start_boff, (long) match_start_coff,
34882 (long) match_end_boff, (long) match_end_coff,
34883 (long) prev_match_end_boff, (long) prev_match_end_coff));
34884
34885 duk_push_lstring(ctx,
34886 (const char *) (DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff),
34887 (duk_size_t) (match_start_boff - prev_match_end_boff));
34888 duk_put_prop_index(ctx, 3, arr_idx);
34889 arr_idx++;
34890 if (arr_idx >= limit) {
34891 goto hit_limit;
34892 }
34893
34894#ifdef DUK_USE_REGEXP_SUPPORT
34895 if (is_regexp) {
34896 duk_size_t i, len;
34897
34898 len = duk_get_length(ctx, 4);
34899 for (i = 1; i < len; i++) {
34900 DUK_ASSERT(i <= DUK_UARRIDX_MAX); /* cannot have >4G captures */
34901 duk_get_prop_index(ctx, 4, (duk_uarridx_t) i);
34902 duk_put_prop_index(ctx, 3, arr_idx);
34903 arr_idx++;
34904 if (arr_idx >= limit) {
34905 goto hit_limit;
34906 }
34907 }
34908
34909 duk_pop(ctx);
34910 /* lastIndex already set up for next match */
34911 } else {
34912#else /* DUK_USE_REGEXP_SUPPORT */
34913 { /* unconditionally */
34914#endif /* DUK_USE_REGEXP_SUPPORT */
34915 /* no action */
34916 }
34917
34918 prev_match_end_boff = match_end_boff;
34919 prev_match_end_coff = match_end_coff;
34920 continue;
34921 } /* for */
34922
34923 /* Combined step 11 (empty string special case) and 14-15. */
34924
34925 DUK_DDD(DUK_DDDPRINT("split trailer; prev_end b=%ld,c=%ld",
34926 (long) prev_match_end_boff, (long) prev_match_end_coff));
34927
34928 if (DUK_HSTRING_GET_CHARLEN(h_input) > 0 || !matched) {
34929 /* Add trailer if:
34930 * a) non-empty input
34931 * b) empty input and no (zero size) match found (step 11)
34932 */
34933
34934 duk_push_lstring(ctx,
DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr)

◆ duk_bi_string_prototype_substr()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substr ( duk_context * ctx)

Definition at line 34061 of file duktape-1.5.2/src/duktape.c.

34065 {
34066 duk_int_t tmp = start_pos;
34067 start_pos = end_pos;
34068 end_pos = tmp;
34069 }
34070
34071 DUK_ASSERT(end_pos >= start_pos);
34072
34073 duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
34074 return 1;
34075}
34076
34077#ifdef DUK_USE_SECTION_B
34079 duk_hstring *h;
34080 duk_int_t start_pos, end_pos;
34081 duk_int_t len;
34082
34083 /* Unlike non-obsolete String calls, substr() algorithm in E5.1
34084 * specification will happily coerce undefined and null to strings
34085 * ("undefined" and "null").
34086 */
34087 duk_push_this(ctx);
34088 h = duk_to_hstring(ctx, -1);
34089 DUK_ASSERT(h != NULL);
34091
34092 /* [ start length str ] */
34093
34094 /* The implementation for computing of start_pos and end_pos differs
34095 * from the standard algorithm, but is intended to result in the exactly
34096 * same behavior. This is not always obvious.
34097 */
34098
34099 /* combines steps 2 and 5; -len ensures max() not needed for step 5 */
34100 start_pos = duk_to_int_clamped(ctx, 0, -len, len);
34101 if (start_pos < 0) {
34102 start_pos = len + start_pos;
DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx)

◆ duk_bi_string_prototype_substring()

DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substring ( duk_context * ctx)

Definition at line 34028 of file duktape-1.5.2/src/duktape.c.

34028 {
34030 return 1;
34031 }
34032
34033 duk_push_u32(ctx, (duk_uint32_t) duk_hstring_char_code_at_raw(thr, h, pos));
34034 return 1;
34035}
34036
34037/*
34038 * substring(), substr(), slice()
34039 */
34040
34041/* XXX: any chance of merging these three similar but still slightly
34042 * different algorithms so that footprint would be reduced?
34043 */
34044
34046 duk_hstring *h;
34047 duk_int_t start_pos, end_pos;
34048 duk_int_t len;
34049
34051 DUK_ASSERT(h != NULL);
34053
34054 /* [ start end str ] */
34055
34056 start_pos = duk_to_int_clamped(ctx, 0, 0, len);
34057 if (duk_is_undefined(ctx, 1)) {
34058 end_pos = len;
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_ret_t duk_bi_string_prototype_substring(duk_context *ctx)

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 33945 of file duktape-1.5.2/src/duktape.c.

33962 {
33963 duk_tval *tv;
33964
33965 duk_push_this(ctx);
33966 tv = duk_require_tval(ctx, -1);
33967 DUK_ASSERT(tv != NULL);
33968
33969 if (DUK_TVAL_IS_STRING(tv)) {
33970 /* return as is */
33971 return 1;
33972 } else if (DUK_TVAL_IS_OBJECT(tv)) {
33974 DUK_ASSERT(h != NULL);
33975
33976 /* 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 35099 of file duktape-1.5.2/src/duktape.c.

35102 {
35103 DUK_UNREF(ctx);
35105}

◆ duk_bi_thread_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_constructor ( duk_context * ctx)

Definition at line 35175 of file duktape-1.5.2/src/duktape.c.

35177 :
35178 duk_push_int(ctx, (duk_int_t) ret);
35179 return 1;
35180}
35181#line 1 "duk_bi_thread.c"
35182/*
35183 * Thread builtins
35184 */
35185
35186/* include removed: duk_internal.h */
35187
35188/*
35189 * Constructor
35190 */
35191
35193 duk_hthread *new_thr;
35194 duk_hobject *func;
35195
35196 /* XXX: need a duk_require_func_or_lfunc_coerce() */
35197 if (!duk_is_callable(ctx, 0)) {
DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_constructor(duk_context *ctx)

◆ duk_bi_thread_current()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_current ( duk_context * ctx)

Definition at line 35466 of file duktape-1.5.2/src/duktape.c.

◆ duk_bi_thread_resume()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_resume ( duk_context * ctx)

Definition at line 35214 of file duktape-1.5.2/src/duktape.c.

35231 {
35232 duk_hthread *thr = (duk_hthread *) ctx;
35233 duk_hthread *thr_resume;
35234 duk_tval *tv;
35235 duk_hobject *func;
35236 duk_hobject *caller_func;
35237 duk_small_int_t is_error;
35238
35239 DUK_DDD(DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T",
35240 (duk_tval *) duk_get_tval(ctx, 0),
35241 (duk_tval *) duk_get_tval(ctx, 1),
35242 (duk_tval *) duk_get_tval(ctx, 2)));
35243
35245 DUK_ASSERT(thr->heap->curr_thread == thr);
35246
35247 thr_resume = duk_require_hthread(ctx, 0);
35248 is_error = (duk_small_int_t) duk_to_boolean(ctx, 2);
35249 duk_set_top(ctx, 2);
35250
35251 /* [ thread value ] */
35252
35253 /*
35254 * Thread state and calling context checks
35255 */
35256
35257 if (thr->callstack_top < 2) {
35258 DUK_DD(DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)"));
35259 goto state_error;
35260 }
35261 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); /* us */
35263 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL); /* caller */
35264
35265 caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
35266 if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
35267 DUK_DD(DUK_DDPRINT("resume state invalid: caller must be Ecmascript code"));
35268 goto state_error;
35269 }
35270
35271 /* Note: there is no requirement that: 'thr->callstack_preventcount == 1'
35272 * like for yield.
35273 */
35274
35275 if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE &&
35276 thr_resume->state != DUK_HTHREAD_STATE_YIELDED) {
35277 DUK_DD(DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED"));
35278 goto state_error;
35279 }
35280
35282 thr_resume->state == DUK_HTHREAD_STATE_YIELDED);
35283
35284 /* Further state-dependent pre-checks */
35285
35286 if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
35287 /* no pre-checks now, assume a previous yield() has left things in
35288 * tip-top shape (longjmp handler will assert for these).
35289 */
35290 } else {
35292
35293 if ((thr_resume->callstack_top != 0) ||
35294 (thr_resume->valstack_top - thr_resume->valstack != 1)) {
35295 goto state_invalid_initial;
35296 }
35297 tv = &thr_resume->valstack_top[-1];
35298 DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top);
35299 if (!DUK_TVAL_IS_OBJECT(tv)) {
35300 goto state_invalid_initial;
35301 }
35302 func = DUK_TVAL_GET_OBJECT(tv);
35303 DUK_ASSERT(func != NULL);
35305 /* Note: cannot be a bound function either right now,
35306 * this would be easy to relax though.
35307 */
35308 goto state_invalid_initial;
35309 }
35310
35311 }
35312
35313 /*
35314 * The error object has been augmented with a traceback and other
35315 * info from its creation point -- usually another thread. The
35316 * error handler is called here right before throwing, but it also
35317 * runs in the resumer's thread. It might be nice to get a traceback
35318 * from the resumee but this is not the case now.
35319 */
35320
35321#if defined(DUK_USE_AUGMENT_ERROR_THROW)
35322 if (is_error) {
35323 DUK_ASSERT_TOP(ctx, 2); /* value (error) is at stack top */
35324 duk_err_augment_error_throw(thr); /* in resumer's context */
35325 }
35326#endif
35327
35328#ifdef DUK_USE_DEBUG
35329 if (is_error) {
35330 DUK_DDD(DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T",
35331 (duk_tval *) duk_get_tval(ctx, 0),
35332 (duk_tval *) duk_get_tval(ctx, 1)));
35333 } else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
35334 DUK_DDD(DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T",
35335 (duk_tval *) duk_get_tval(ctx, 0),
35336 (duk_tval *) duk_get_tval(ctx, 1)));
35337 } else {
35338 DUK_DDD(DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T",
35339 (duk_tval *) duk_get_tval(ctx, 0),
35340 (duk_tval *) duk_get_tval(ctx, 1)));
35341 }
35342#endif
35343
35345
35346 /* lj value2: thread */
35348 DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value2, &thr->valstack_bottom[0]); /* side effects */
35349
35350 /* lj value1: value */
35351 DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top);
DUK_INTERNAL_DECL duk_hthread * duk_require_hthread(duk_context *ctx, duk_idx_t index)

◆ duk_bi_thread_yield()

DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_yield ( duk_context * ctx)

Definition at line 35368 of file duktape-1.5.2/src/duktape.c.

35385 {
35386 duk_hthread *thr = (duk_hthread *) ctx;
35387 duk_hobject *caller_func;
35388 duk_small_int_t is_error;
35389
35390 DUK_DDD(DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T",
35391 (duk_tval *) duk_get_tval(ctx, 0),
35392 (duk_tval *) duk_get_tval(ctx, 1)));
35393
35395 DUK_ASSERT(thr->heap->curr_thread == thr);
35396
35397 is_error = (duk_small_int_t) duk_to_boolean(ctx, 1);
35398 duk_set_top(ctx, 1);
35399
35400 /* [ value ] */
35401
35402 /*
35403 * Thread state and calling context checks
35404 */
35405
35406 if (!thr->resumer) {
35407 DUK_DD(DUK_DDPRINT("yield state invalid: current thread must have a resumer"));
35408 goto state_error;
35409 }
35411
35412 if (thr->callstack_top < 2) {
35413 DUK_DD(DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)"));
35414 goto state_error;
35415 }
35416 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); /* us */
35418 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL); /* caller */
35419
35420 caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
35421 if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
35422 DUK_DD(DUK_DDPRINT("yield state invalid: caller must be Ecmascript code"));
35423 goto state_error;
35424 }
35425
35426 DUK_ASSERT(thr->callstack_preventcount >= 1); /* should never be zero, because we (Duktape.Thread.yield) are on the stack */
35427 if (thr->callstack_preventcount != 1) {
35428 /* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */
35429 DUK_DD(DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %ld)",
35430 (long) thr->callstack_preventcount));
35431 goto state_error;
35432 }
35433
35434 /*
35435 * The error object has been augmented with a traceback and other
35436 * info from its creation point -- usually the current thread.
35437 * The error handler, however, is called right before throwing
35438 * and runs in the yielder's thread.
35439 */
35440
35441#if defined(DUK_USE_AUGMENT_ERROR_THROW)
35442 if (is_error) {
35443 DUK_ASSERT_TOP(ctx, 1); /* value (error) is at stack top */
35444 duk_err_augment_error_throw(thr); /* in yielder's context */
35445 }
35446#endif
35447
35448#ifdef DUK_USE_DEBUG
35449 if (is_error) {
35450 DUK_DDD(DUK_DDDPRINT("YIELD ERROR: value=%!T",
35451 (duk_tval *) duk_get_tval(ctx, 0)));
35452 } else {
35453 DUK_DDD(DUK_DDDPRINT("YIELD NORMAL: value=%!T",
35454 (duk_tval *) duk_get_tval(ctx, 0)));
35455 }
35456#endif
35457
35458 /*
35459 * Process yield
35460 *
35461 * After longjmp(), processing continues in bytecode executor longjmp
35462 * handler, which will e.g. update thr->resumer to NULL.
35463 */
35464

◆ duk_bi_type_error_thrower()

DUK_INTERNAL_DECL duk_ret_t duk_bi_type_error_thrower ( duk_context * ctx)

Definition at line 35477 of file duktape-1.5.2/src/duktape.c.

35478 :
35479 DUK_ERROR_TYPE(thr, "invalid state");
35480 return 0; /* never here */

◆ duk_bi_typedarray_constructor()

DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_constructor ( duk_context * ctx)

Definition at line 22264 of file duktape-1.5.2/src/duktape.c.

22264 :
22265 return DUK_RET_RANGE_ERROR;
22266}
22267#else /* DUK_USE_BUFFEROBJECT_SUPPORT */
22269 DUK_UNREF(ctx);
22271}
22272#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
22273
22274
22275/* Format of magic, bits:
22276 * 0...1: elem size shift (0-3)
22277 * 2...5: elem type (DUK_HBUFFEROBJECT_ELEM_xxx)
22278 */
22279
22280#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
22282 duk_hthread *thr;
22283 duk_tval *tv;
22284 duk_hobject *h_obj;
22285 duk_hbufferobject *h_bufobj = NULL;
22286 duk_hbufferobject *h_bufarr = NULL;
22287 duk_hbufferobject *h_bufarg = NULL;
22288 duk_hbuffer *h_val;
22289 duk_small_uint_t magic;
22290 duk_small_uint_t shift;
22291 duk_small_uint_t elem_type;
22292 duk_small_uint_t elem_size;
22293 duk_small_uint_t class_num;
22294 duk_small_uint_t proto_bidx;
22295 duk_uint_t align_mask;
22296 duk_uint_t elem_length;
22297 duk_int_t elem_length_signed;
22298 duk_uint_t byte_length;
22299 duk_small_uint_t copy_mode;
22300
22301 thr = (duk_hthread *) ctx;
22302 DUK_UNREF(thr);
22303
22304 /* XXX: function flag to make this automatic? */
22305 if (!duk_is_constructor_call(ctx)) {
22306 return DUK_RET_TYPE_ERROR;
22307 }
22308
22309 /* We could fit built-in index into magic but that'd make the magic
22310 * number dependent on built-in numbering (genbuiltins.py doesn't
22311 * handle that yet). So map both class and prototype from the
22312 * element type.
22313 */
22314 magic = duk_get_current_magic(ctx);
22315 shift = magic & 0x03; /* bits 0...1: shift */
22316 elem_type = (magic >> 2) & 0x0f; /* bits 2...5: type */
22317 elem_size = 1 << shift;
22318 align_mask = elem_size - 1;
22319 DUK_ASSERT(elem_type < sizeof(duk__buffer_proto_from_elemtype) / sizeof(duk_uint8_t));
22320 proto_bidx = duk__buffer_proto_from_elemtype[elem_type];
22321 DUK_ASSERT(proto_bidx < DUK_NUM_BUILTINS);
22322 DUK_ASSERT(elem_type < sizeof(duk__buffer_class_from_elemtype) / sizeof(duk_uint8_t));
22323 class_num = duk__buffer_class_from_elemtype[elem_type];
22324
22325 DUK_DD(DUK_DDPRINT("typedarray constructor, magic=%d, shift=%d, elem_type=%d, "
22326 "elem_size=%d, proto_bidx=%d, class_num=%d",
22327 (int) magic, (int) shift, (int) elem_type, (int) elem_size,
22328 (int) proto_bidx, (int) class_num));
22329
22330 /* Argument variants. When the argument is an ArrayBuffer a view to
22331 * the same buffer is created; otherwise a new ArrayBuffer is always
22332 * created.
22333 */
22334
22335 tv = duk_get_tval(ctx, 0);
22336 DUK_ASSERT(tv != NULL); /* arg count */
22337 if (DUK_TVAL_IS_OBJECT(tv)) {
22338 h_obj = DUK_TVAL_GET_OBJECT(tv);
22339 DUK_ASSERT(h_obj != NULL);
22340
22342 /* ArrayBuffer: unlike any other argument variant, create
22343 * a view into the existing buffer.
22344 */
22345
22346 duk_int_t byte_offset_signed;
22347 duk_uint_t byte_offset;
22348
22349 h_bufarg = (duk_hbufferobject *) h_obj;
22350
22351 byte_offset_signed = duk_to_int(ctx, 1);
22352 if (byte_offset_signed < 0) {
22353 goto fail_arguments;
22354 }
22355 byte_offset = (duk_uint_t) byte_offset_signed;
22356 if (byte_offset > h_bufarg->length ||
22357 (byte_offset & align_mask) != 0) {
22358 /* Must be >= 0 and multiple of element size. */
22359 goto fail_arguments;
22360 }
22361 if (duk_is_undefined(ctx, 2)) {
22362 DUK_ASSERT(h_bufarg->length >= byte_offset);
22363 byte_length = h_bufarg->length - byte_offset;
22364 if ((byte_length & align_mask) != 0) {
22365 /* Must be element size multiple from
22366 * start offset to end of buffer.
22367 */
22368 goto fail_arguments;
22369 }
22370 elem_length = (byte_length >> shift);
22371 } else {
22372 elem_length_signed = duk_to_int(ctx, 2);
22373 if (elem_length_signed < 0) {
22374 goto fail_arguments;
22375 }
22376 elem_length = (duk_uint_t) elem_length_signed;
22377 byte_length = elem_length << shift;
22378 if ((byte_length >> shift) != elem_length) {
22379 /* Byte length would overflow. */
22380 /* XXX: easier check with less code? */
22381 goto fail_arguments;
22382 }
22383 DUK_ASSERT(h_bufarg->length >= byte_offset);
22384 if (byte_length > h_bufarg->length - byte_offset) {
22385 /* Not enough data. */
22386 goto fail_arguments;
22387 }
22388 }
22389 DUK_UNREF(elem_length);
22390 DUK_ASSERT_DISABLE(byte_offset >= 0);
22391 DUK_ASSERT(byte_offset <= h_bufarg->length);
22392 DUK_ASSERT_DISABLE(byte_length >= 0);
22393 DUK_ASSERT(byte_offset + byte_length <= h_bufarg->length);
22394 DUK_ASSERT((elem_length << shift) == byte_length);
22395
22396 h_bufobj = duk_push_bufferobject_raw(ctx,
22399 DUK_HOBJECT_CLASS_AS_FLAGS(class_num),
22400 proto_bidx);
22401 h_val = h_bufarg->buf;
22402 if (h_val == NULL) {
22403 return DUK_RET_TYPE_ERROR;
22404 }
22405 h_bufobj->buf = h_val;
22406 DUK_HBUFFER_INCREF(thr, h_val);
22407 h_bufobj->offset = h_bufarg->offset + byte_offset;
22408 h_bufobj->length = byte_length;
22409 h_bufobj->shift = (duk_uint8_t) shift;
22410 h_bufobj->elem_type = (duk_uint8_t) elem_type;
22411 h_bufobj->is_view = 1;
22413
22414 /* Set .buffer to the argument ArrayBuffer. */
22415 duk_dup(ctx, 0);
22417 duk_compact(ctx, -1);
22418 return 1;
22419 } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
22420 /* TypedArray (or other non-ArrayBuffer duk_hbufferobject).
22421 * Conceptually same behavior as for an Array-like argument,
22422 * with a few fast paths.
22423 */
22424
22425 h_bufarg = (duk_hbufferobject *) h_obj;
22427 elem_length_signed = (duk_int_t) (h_bufarg->length >> h_bufarg->shift);
22428 if (h_bufarg->buf == NULL) {
22429 return DUK_RET_TYPE_ERROR;
22430 }
22431
22432 /* Select copy mode. Must take into account element
22433 * compatibility and validity of the underlying source
22434 * buffer.
22435 */
22436
22437 DUK_DDD(DUK_DDDPRINT("selecting copy mode for bufobj arg, "
22438 "src byte_length=%ld, src shift=%d, "
22439 "src/dst elem_length=%ld; "
22440 "dst shift=%d -> dst byte_length=%ld",
22441 (long) h_bufarg->length, (int) h_bufarg->shift,
22442 (long) elem_length_signed, (int) shift,
22443 (long) (elem_length_signed << shift)));
22444
22445 copy_mode = 2; /* default is explicit index read/write copy */
22446 DUK_ASSERT(elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t));
22447 if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) {
22448 if ((duk__buffer_elemtype_copy_compatible[elem_type] & (1 << h_bufarg->elem_type)) != 0) {
22449 DUK_DDD(DUK_DDDPRINT("source/target are copy compatible, memcpy"));
22450 DUK_ASSERT(shift == h_bufarg->shift); /* byte sizes will match */
22451 copy_mode = 0;
22452 } else {
22453 DUK_DDD(DUK_DDDPRINT("source/target not copy compatible but valid, fast copy"));
22454 copy_mode = 1;
22455 }
22456 }
22457 } else {
22458 /* Array or Array-like */
22459 elem_length_signed = (duk_int_t) duk_get_length(ctx, 0);
22460 copy_mode = 2;
22461 }
22462 } else if (DUK_TVAL_IS_BUFFER(tv)) {
22463 /* Accept plain buffer values like array initializers
22464 * (new in Duktape 1.4.0).
22465 */
22466 duk_hbuffer *h_srcbuf;
22467 h_srcbuf = DUK_TVAL_GET_BUFFER(tv);
22468 elem_length_signed = (duk_int_t) DUK_HBUFFER_GET_SIZE(h_srcbuf);
22469 copy_mode = 2; /* XXX: could add fast path for u8 compatible views */
22470 } else {
22471 /* Non-object argument is simply int coerced, matches
22472 * V8 behavior (except for "null", which we coerce to
22473 * 0 but V8 TypeErrors).
22474 */
22475 elem_length_signed = duk_to_int(ctx, 0);
22476 copy_mode = 3;
22477 }
22478 if (elem_length_signed < 0) {
22479 goto fail_arguments;
22480 }
22481 elem_length = (duk_uint_t) elem_length_signed;
22482 byte_length = (duk_uint_t) (elem_length << shift);
22483 if ((byte_length >> shift) != elem_length) {
22484 /* Byte length would overflow. */
22485 /* XXX: easier check with less code? */
22486 goto fail_arguments;
22487 }
22488
22489 DUK_DDD(DUK_DDDPRINT("elem_length=%ld, byte_length=%ld",
22490 (long) elem_length, (long) byte_length));
22491
22492 /* ArrayBuffer argument is handled specially above; the rest of the
22493 * argument variants are handled by shared code below.
22494 */
22495
22496 /* Push a new ArrayBuffer (becomes view .buffer) */
22497 h_bufarr = duk__push_arraybuffer_with_length(ctx, byte_length);
22498 DUK_ASSERT(h_bufarr != NULL);
22499 h_val = h_bufarr->buf;
22500 DUK_ASSERT(h_val != NULL);
22501
22502 /* Push the resulting view object and attach the ArrayBuffer. */
22503 h_bufobj = duk_push_bufferobject_raw(ctx,
22506 DUK_HOBJECT_CLASS_AS_FLAGS(class_num),
22507 proto_bidx);
22508
22509 h_bufobj->buf = h_val;
22510 DUK_HBUFFER_INCREF(thr, h_val);
22511 DUK_ASSERT(h_bufobj->offset == 0);
22512 h_bufobj->length = byte_length;
22513 h_bufobj->shift = (duk_uint8_t) shift;
22514 h_bufobj->elem_type = (duk_uint8_t) elem_type;
22515 h_bufobj->is_view = 1;
22517
22518 /* Set .buffer */
22519 duk_dup(ctx, -2);
22521 duk_compact(ctx, -1);
22522
22523 /* Copy values, the copy method depends on the arguments.
22524 *
22525 * Copy mode decision may depend on the validity of the underlying
22526 * buffer of the source argument; there must be no harmful side effects
22527 * from there to here for copy_mode to still be valid.
22528 */
22529 DUK_DDD(DUK_DDDPRINT("copy mode: %d", (int) copy_mode));
22530 switch (copy_mode) {
22531 case 0: {
22532 /* Use byte copy. */
22533
22534 duk_uint8_t *p_src;
22535 duk_uint8_t *p_dst;
22536
22537 DUK_ASSERT(h_bufobj != NULL);
22538 DUK_ASSERT(h_bufobj->buf != NULL);
22540 DUK_ASSERT(h_bufarg != NULL);
22541 DUK_ASSERT(h_bufarg->buf != NULL);
22543
22544 p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj);
22545 p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg);
22546
22547 DUK_DDD(DUK_DDDPRINT("using memcpy: p_src=%p, p_dst=%p, byte_length=%ld",
22548 (void *) p_src, (void *) p_dst, (long) byte_length));
22549
22550 DUK_MEMCPY((void *) p_dst, (const void *) p_src, (size_t) byte_length);
22551 break;
22552 }
22553 case 1: {
22554 /* Copy values through direct validated reads and writes. */
22555
22556 duk_small_uint_t src_elem_size;
22557 duk_small_uint_t dst_elem_size;
22558 duk_uint8_t *p_src;
22559 duk_uint8_t *p_src_end;
22560 duk_uint8_t *p_dst;
22561
22562 DUK_ASSERT(h_bufobj != NULL);
22563 DUK_ASSERT(h_bufobj->buf != NULL);
22565 DUK_ASSERT(h_bufarg != NULL);
22566 DUK_ASSERT(h_bufarg->buf != NULL);
22568
22569 src_elem_size = 1 << h_bufarg->shift;
22570 dst_elem_size = elem_size;
22571
22572 p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg);
22573 p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj);
22574 p_src_end = p_src + h_bufarg->length;
22575
22576 DUK_DDD(DUK_DDDPRINT("using fast copy: p_src=%p, p_src_end=%p, p_dst=%p, "
22577 "src_elem_size=%d, dst_elem_size=%d",
22578 (void *) p_src, (void *) p_src_end, (void *) p_dst,
22579 (int) src_elem_size, (int) dst_elem_size));
22580
22581 while (p_src != p_src_end) {
22582 DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: "
22583 "p_src=%p, p_src_end=%p, p_dst=%p",
22584 (void *) p_src, (void *) p_src_end, (void *) p_dst));
22585 /* A validated read() is always a number, so it's write coercion
22586 * is always side effect free an won't invalidate pointers etc.
22587 */
22588 duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size);
22589 duk_hbufferobject_validated_write(ctx, h_bufobj, p_dst, dst_elem_size);
22590 duk_pop(ctx);
22591 p_src += src_elem_size;
22592 p_dst += dst_elem_size;
22593 }
22594 break;
22595 }
22596 case 2: {
22597 /* Copy values by index reads and writes. Let virtual
22598 * property handling take care of coercion.
22599 */
22600 duk_uint_t i;
22601
22602 DUK_DDD(DUK_DDDPRINT("using slow copy"));
22603
22604 for (i = 0; i < elem_length; i++) {
22605 duk_get_prop_index(ctx, 0, (duk_uarridx_t) i);
22606 duk_put_prop_index(ctx, -2, (duk_uarridx_t) i);
22607 }
22608 break;
22609 }
22610 default:
22611 case 3: {
22612 /* No copy, leave zero bytes in the buffer. There's no
22613 * ambiguity with Float32/Float64 because zero bytes also
22614 * represent 0.0.
22615 */
22616#if !defined(DUK_USE_ZERO_BUFFER_DATA)
#define DUK_STRIDX_LC_BUFFER
DUK_LOCAL duk_hbufferobject * duk__push_arraybuffer_with_length(duk_context *ctx, duk_uint_t len)
static const duk_uint8_t duk__buffer_class_from_elemtype[9]
static const duk_uint8_t duk__buffer_proto_from_elemtype[9]
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)
static duk_uint16_t duk__buffer_elemtype_copy_compatible[9]

◆ duk_bi_typedarray_set()

DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_set ( duk_context * ctx)

Definition at line 23219 of file duktape-1.5.2/src/duktape.c.

23222 :
23223 *
23224 * - Source and target separate buffers or non-overlapping.
23225 *
23226 * - Source and target have a compatible type so that a plain byte copy
23227 * is possible. Note that while e.g. uint8 and int8 are compatible
23228 * (coercion one way or another doesn't change the byte representation),
23229 * e.g. int8 and uint8clamped are NOT compatible when writing int8
23230 * values into uint8clamped typedarray (-1 would clamp to 0 for instance).
23231 *
23232 * See test-bi-typedarray-proto-set.js.
23233 */
23234
23235#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
23236DUK_INTERNAL duk_ret_t duk_bi_typedarray_set(duk_context *ctx) {
23237 duk_hthread *thr;
23238 duk_hbufferobject *h_this;
23239 duk_hobject *h_obj;
23240 duk_uarridx_t i, n;
23241 duk_int_t offset_signed;
23242 duk_uint_t offset_elems;
23243 duk_uint_t offset_bytes;
23244
23245 thr = (duk_hthread *) ctx;
23246 DUK_UNREF(thr);
23247
23248 h_this = duk__require_bufobj_this(ctx);
23249 DUK_ASSERT(h_this != NULL);
23250 DUK_ASSERT_HBUFFEROBJECT_VALID(h_this);
23251
23252 if (h_this->buf == NULL) {
23253 DUK_DDD(DUK_DDDPRINT("source neutered, skip copy"));
23254 return 0;
23255 }
23256
23257 h_obj = duk_require_hobject(ctx, 0);
23258 DUK_ASSERT(h_obj != NULL);
23259
23260 /* XXX: V8 throws a TypeError for negative values. Would it
23261 * be more useful to interpret negative offsets here from the
23262 * end of the buffer too?
23263 */
23264 offset_signed = duk_to_int(ctx, 1);
23265 if (offset_signed < 0) {
23266 return DUK_RET_TYPE_ERROR;
23267 }
23268 offset_elems = (duk_uint_t) offset_signed;
23269 offset_bytes = offset_elems << h_this->shift;
23270 if ((offset_bytes >> h_this->shift) != offset_elems) {
23271 /* Byte length would overflow. */
23272 /* XXX: easier check with less code? */
23273 return DUK_RET_RANGE_ERROR;
23274 }
23275 if (offset_bytes > h_this->length) {
23276 /* Equality may be OK but >length not. Checking
23277 * this explicitly avoids some overflow cases
23278 * below.
23279 */
23280 return DUK_RET_RANGE_ERROR;
23281 }
23282 DUK_ASSERT(offset_bytes <= h_this->length);
23283
23284 /* Fast path: source is a TypedArray (or any bufferobject). */
23285
23286 if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
23287 duk_hbufferobject *h_bufarg;
23288 duk_uint16_t comp_mask;
23289 duk_small_int_t no_overlap = 0;
23290 duk_uint_t src_length;
23291 duk_uint_t dst_length;
23292 duk_uint_t dst_length_elems;
23293 duk_uint8_t *p_src_base;
23294 duk_uint8_t *p_src_end;
23295 duk_uint8_t *p_src;
23296 duk_uint8_t *p_dst_base;
23297 duk_uint8_t *p_dst;
23298 duk_small_uint_t src_elem_size;
23299 duk_small_uint_t dst_elem_size;
23300
23301 h_bufarg = (duk_hbufferobject *) h_obj;
23302 DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg);
23303
23304 if (h_bufarg->buf == NULL) {
23305 DUK_DDD(DUK_DDDPRINT("target neutered, skip copy"));
23306 return 0;
23307 }
23308
23309 /* Nominal size check. */
23310 src_length = h_bufarg->length; /* bytes in source */
23311 dst_length_elems = (src_length >> h_bufarg->shift); /* elems in source and dest */
23312 dst_length = dst_length_elems << h_this->shift; /* bytes in dest */
23313 if ((dst_length >> h_this->shift) != dst_length_elems) {
23314 /* Byte length would overflow. */
23315 /* XXX: easier check with less code? */
23316 return DUK_RET_RANGE_ERROR;
23317 }
23318 DUK_DDD(DUK_DDDPRINT("nominal size check: src_length=%ld, dst_length=%ld",
23319 (long) src_length, (long) dst_length));
23320 DUK_ASSERT(offset_bytes <= h_this->length);
23321 if (dst_length > h_this->length - offset_bytes) {
23322 /* Overflow not an issue because subtraction is used on the right
23323 * side and guaranteed to be >= 0.
23324 */
23325 DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length"));
23326 return DUK_RET_RANGE_ERROR;
23327 }
23328 if (!DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, offset_bytes + dst_length)) {
23329 DUK_DDD(DUK_DDDPRINT("copy not covered by underlying target buffer, ignore"));
23330 return 0;
23331 }
23332
23333 p_src_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg);
23334 p_dst_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + offset_bytes;
23335
23336 /* Check actual underlying buffers for validity and that they
23337 * cover the copy. No side effects are allowed after the check
23338 * so that the validity status doesn't change.
23339 */
23340 if (!DUK_HBUFFEROBJECT_VALID_SLICE(h_this) ||
23341 !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) {
23342 /* The condition could be more narrow and check for the
23343 * copy area only, but there's no need for fine grained
23344 * behavior when the underlying buffer is misconfigured.
23345 */
23346 DUK_DDD(DUK_DDDPRINT("source and/or target not covered by underlying buffer, skip copy"));
23347 return 0;
23348 }
23349
23350 /* We want to do a straight memory copy if possible: this is
23351 * an important operation because .set() is the TypedArray
23352 * way to copy chunks of memory. However, because set()
23353 * conceptually works in terms of elements, not all views are
23354 * compatible with direct byte copying.
23355 *
23356 * If we do manage a direct copy, the "overlap issue" handled
23357 * below can just be solved using memmove() because the source
23358 * and destination element sizes are necessarily equal.
23359 */
23360
23361 DUK_ASSERT(h_this->elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t));
23362 comp_mask = duk__buffer_elemtype_copy_compatible[h_this->elem_type];
23363 if (comp_mask & (1 << h_bufarg->elem_type)) {
23364 DUK_ASSERT(src_length == dst_length);
23365
23366 DUK_DDD(DUK_DDDPRINT("fast path: able to use memmove() because views are compatible"));
23367 DUK_MEMMOVE((void *) p_dst_base, (const void *) p_src_base, (size_t) dst_length);
23368 return 0;
23369 }
23370 DUK_DDD(DUK_DDDPRINT("fast path: views are not compatible with a byte copy, copy by item"));
23371
23372 /* We want to avoid making a copy to process set() but that's
23373 * not always possible: the source and the target may overlap
23374 * and because element sizes are different, the overlap cannot
23375 * always be handled with a memmove() or choosing the copy
23376 * direction in a certain way. For example, if source type is
23377 * uint8 and target type is uint32, the target area may exceed
23378 * the source area from both ends!
23379 *
23380 * Note that because external buffers may point to the same
23381 * memory areas, we must ultimately make this check using
23382 * pointers.
23383 *
23384 * NOTE: careful with side effects: any side effect may cause
23385 * a buffer resize (or external buffer pointer/length update)!
23386 */
23387
23388 DUK_DDD(DUK_DDDPRINT("overlap check: p_src_base=%p, src_length=%ld, "
23389 "p_dst_base=%p, dst_length=%ld",
23390 (void *) p_src_base, (long) src_length,
23391 (void *) p_dst_base, (long) dst_length));
23392
23393 if (p_src_base >= p_dst_base + dst_length || /* source starts after dest ends */
23394 p_src_base + src_length <= p_dst_base) { /* source ends before dest starts */
23395 no_overlap = 1;
23396 }
23397
23398 if (!no_overlap) {
23399 /* There's overlap: the desired end result is that
23400 * conceptually a copy is made to avoid "trampling"
23401 * of source data by destination writes. We make
23402 * an actual temporary copy to handle this case.
23403 */
23404 duk_uint8_t *p_src_copy;
23405
23406 DUK_DDD(DUK_DDDPRINT("there is overlap, make a copy of the source"));
23407 p_src_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, src_length);
23408 DUK_ASSERT(p_src_copy != NULL);
23409 DUK_MEMCPY((void *) p_src_copy, (const void *) p_src_base, (size_t) src_length);
23410
23411 p_src_base = p_src_copy; /* use p_src_base from now on */
23412 }
23413 /* Value stack intentionally mixed size here. */
23414
23415 DUK_DDD(DUK_DDDPRINT("after overlap check: p_src_base=%p, src_length=%ld, "
23416 "p_dst_base=%p, dst_length=%ld, valstack top=%ld",
23417 (void *) p_src_base, (long) src_length,
23418 (void *) p_dst_base, (long) dst_length,
23419 (long) duk_get_top(ctx)));
23420
23421 /* Ready to make the copy. We must proceed element by element
23422 * and must avoid any side effects that might cause the buffer
23423 * validity check above to become invalid.
23424 *
23425 * Although we work through the value stack here, only plain
23426 * numbers are handled which should be side effect safe.
23427 */
23428
23429 src_elem_size = 1 << h_bufarg->shift;
23430 dst_elem_size = 1 << h_this->shift;
23431 p_src = p_src_base;
23432 p_dst = p_dst_base;
23433 p_src_end = p_src_base + src_length;
23434
23435 while (p_src != p_src_end) {
23436 DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: "
23437 "p_src=%p, p_src_end=%p, p_dst=%p",
23438 (void *) p_src, (void *) p_src_end, (void *) p_dst));
23439 /* A validated read() is always a number, so it's write coercion
23440 * is always side effect free an won't invalidate pointers etc.
23441 */
23442 duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size);
23443 duk_hbufferobject_validated_write(ctx, h_this, p_dst, dst_elem_size);
23444 duk_pop(ctx);
23445 p_src += src_elem_size;
23446 p_dst += dst_elem_size;
23447 }
23448
23449 return 0;
23450 } else {
23451 /* Slow path: quite slow, but we save space by using the property code
23452 * to write coerce target values. We don't need to worry about overlap
23453 * here because the source is not a TypedArray.
23454 *
23455 * We could use the bufferobject write coercion helper but since the
23456 * property read may have arbitrary side effects, full validity checks
23457 * would be needed for every element anyway.
23458 */
23459
23460 n = (duk_uarridx_t) duk_get_length(ctx, 0);
23461 DUK_ASSERT(offset_bytes <= h_this->length);
23462 if ((n << h_this->shift) > h_this->length - offset_bytes) {
23463 /* Overflow not an issue because subtraction is used on the right
23464 * side and guaranteed to be >= 0.
23465 */
23466 DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length"));
23467 return DUK_RET_RANGE_ERROR;
23468 }
23469
23470 /* 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 86285 of file duktape-1.5.2/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 86221 of file duktape-1.5.2/src/duktape.c.

86224 {
86225 duk_uint8_t *p;
86226
86227 DUK_ASSERT(thr != NULL);
86228 DUK_ASSERT(bw_ctx != NULL);
86229 DUK_UNREF(thr);
86230

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 86232 of file duktape-1.5.2/src/duktape.c.

86238 {
86239
86240 DUK_ASSERT(thr != NULL);
86241 DUK_ASSERT(bw_ctx != NULL);
86242 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 86432 of file duktape-1.5.2/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 86350 of file duktape-1.5.2/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 86398 of file duktape-1.5.2/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 86414 of file duktape-1.5.2/src/duktape.c.

86415 {
86416 DUK_ASSERT(thr != NULL);
86417 DUK_ASSERT(bw != NULL);
86418 DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
86419 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86420 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86421 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86422 DUK_UNREF(thr);
86423
86424 /* Don't support "straddled" source now. */
86425 DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);
86426
86427 DUK_BW_ENSURE(thr, bw, len);
86428 duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len);
86429}
86430
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)

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 86326 of file duktape-1.5.2/src/duktape.c.

86331 {
86332 DUK_ASSERT(thr != NULL);
86333 DUK_ASSERT(bw != NULL);
86334 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86335 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86336 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86337 DUK_UNREF(thr);
86338
86339 DUK_BW_ENSURE(thr, bw, len);
86340 duk_bw_write_raw_slice(thr, bw, src_off, len);
86341}
86342
86343DUK_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) {
86344 duk_uint8_t *p_base;
86345 duk_size_t buf_sz, move_sz;
86346
86347 DUK_ASSERT(thr != NULL);
86348 DUK_ASSERT(bw != NULL);
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_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len)

◆ 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 86361 of file duktape-1.5.2/src/duktape.c.

86367 {
86368 DUK_ASSERT(thr != NULL);
86369 DUK_ASSERT(bw != NULL);
86370 DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
86371 DUK_ASSERT(buf != NULL);
86372 DUK_UNREF(thr);
86373
86374 DUK_BW_ENSURE(thr, bw, len);
86375 duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len);
86376}
86377
86379 duk_uint8_t *p_base;
86380 duk_size_t buf_sz, move_sz;
86381
86382 DUK_ASSERT(thr != NULL);
86383 DUK_ASSERT(bw != NULL);
86384 DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
86385 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86386 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86387 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86388 DUK_UNREF(thr);
86389
86390 p_base = bw->p_base;
86391
86392 /* Don't support "straddled" source now. */
86393 DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);
86394
86395 if (dst_off <= src_off) {
86396 /* 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 86442 of file duktape-1.5.2/src/duktape.c.

86449 {
86450 DUK_ASSERT(thr != NULL);
86451 DUK_ASSERT(bw != NULL);
86452 DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
86453 DUK_UNREF(thr);
86454
86455 DUK_BW_ENSURE(thr, bw, len);
86456 return duk_bw_insert_raw_area(thr, bw, off, len);
86457}
86458
86460 duk_size_t move_sz;
86461
86462 duk_uint8_t *p_base;
86463 duk_uint8_t *p_src;
86464 duk_uint8_t *p_dst;
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 void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len)

◆ 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 86247 of file duktape-1.5.2/src/duktape.c.

86249 {
86250 duk_context *ctx;
86251
86252 DUK_ASSERT(thr != NULL);
86253 DUK_ASSERT(bw_ctx != NULL);
86254 ctx = (duk_context *) thr;
86255
86256 (void) duk_push_dynamic_buffer(ctx, buf_size);
86257 bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
86258 duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size);
86259}
86260
86261/* Resize target buffer for requested size. Called by the macro only when the
86262 * fast path test (= there is space) fails.
86263 */
86264DUK_INTERNAL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) {
86265 duk_size_t curr_off;
86266 duk_size_t add_sz;
86267 duk_size_t new_sz;
86268
86269 DUK_ASSERT(thr != NULL);
86270 DUK_ASSERT(bw_ctx != NULL);
86271
86272 /* We could do this operation without caller updating bw_ctx->ptr,
86273 * but by writing it back here we can share code better.
86274 */
86275
86276 curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
86277 add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD;
86278 new_sz = curr_off + sz + add_sz;
86279 if (new_sz < curr_off) {
86280 /* overflow */
86282 return NULL; /* not reachable */
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)
#define DUK_STR_BUFFER_TOO_LONG
#define DUK_BW_SPARE_SHIFT
#define DUK_BW_SPARE_ADD

◆ 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 86314 of file duktape-1.5.2/src/duktape.c.

86314 {
86315 duk_uint8_t *p_base;
86316
86317 DUK_ASSERT(thr != NULL);
86318 DUK_ASSERT(bw != NULL);
86319 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86320 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86321 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86322 DUK_UNREF(thr);
86323
86324 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 86297 of file duktape-1.5.2/src/duktape.c.

86302 {
86303 duk_size_t len;
86304
86305 DUK_ASSERT(thr != NULL);
86306 DUK_ASSERT(bw_ctx != NULL);
86307 DUK_UNREF(thr);
86308
86309 len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
86310 duk_hbuffer_resize(thr, bw_ctx->buf, len);
86311 duk__bw_update_ptrs(thr, bw_ctx, len, len);
86312}

◆ duk_call()

DUK_EXTERNAL void duk_call ( duk_context * ctx,
duk_idx_t nargs )

Definition at line 12409 of file duktape-1.5.2/src/duktape.c.

12412 : %!T", (duk_tval *) duk_get_tval(ctx, -1)));
12413
12414 /* [... key arg1 ... argN func] */
12415
12416 duk_replace(ctx, -nargs - 2);
12417
12418 /* [... func arg1 ... argN] */
12419
12420 duk_dup(ctx, normalized_obj_index);
12421 duk_insert(ctx, -nargs - 1);
12422
12423 /* [... func this arg1 ... argN] */
12424}
12425
12426DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) {
12427 duk_hthread *thr = (duk_hthread *) ctx;
12428 duk_small_uint_t call_flags;
12429 duk_idx_t idx_func;
12430
12431 DUK_ASSERT_CTX_VALID(ctx);
12432 DUK_ASSERT(thr != NULL);
12433
12434 idx_func = duk_get_top(ctx) - nargs - 1;

◆ duk_call_method()

DUK_EXTERNAL void duk_call_method ( duk_context * ctx,
duk_idx_t nargs )

◆ duk_call_prop()

DUK_EXTERNAL void duk_call_prop ( duk_context * ctx,
duk_idx_t obj_index,
duk_idx_t nargs )

Definition at line 12457 of file duktape-1.5.2/src/duktape.c.

12462 {
12463 /* note that we can't reliably pop anything here */
12465 }
12466
12467 call_flags = 0; /* not protected, respect reclimit, not constructor */
12468
12469 duk_handle_call_unprotected(thr, /* thread */
12470 nargs, /* num_stack_args */
12471 call_flags); /* call_flags */
12472}

◆ 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 19900 of file duktape-1.5.2/src/duktape.c.

19904 : p_start=%p, p_end=%p, q_start=%p, q_end=%p",
19905 (const void *) p_start, (const void *) p_end,
19906 (const void *) q_start, (const void *) q_end));
19907
19908 if (q_start == p_start && q_end == p_end) {
19909 DUK_DDD(DUK_DDDPRINT("nothing was trimmed: avoid interning (hashing etc)"));
19910 return;
19911 }
19912
19913 duk_push_lstring(ctx, (const char *) q_start, (duk_size_t) (q_end - q_start));
19914 duk_replace(ctx, index);
19915}
19916
19917DUK_EXTERNAL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset) {
19918 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 15645 of file duktape-1.5.2/src/duktape.c.

15651 {
15653 } else {
15654 return 0;
15655 }
15656 }
15657
15658 DUK_DDD(DUK_DDDPRINT("valstack resize successful"));
15659 return 1;
15660}
15661
15663 duk_hthread *thr = (duk_hthread *) ctx;
15664 duk_size_t min_new_size;
15665

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 15689 of file duktape-1.5.2/src/duktape.c.

15691 {
15692 /* Clamping to zero makes the API more robust to calling code
15693 * calculation errors.
15694 */
15695 extra = 0;
15696 }
15697
15698 min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
15699 (void) duk_valstack_resize_raw(ctx,
15700 min_new_size, /* min_new_size */
15701 0 /* no shrink */ | /* flags */
15702 0 /* no compact */ |
15704}
15705
15707 duk_size_t min_new_size;
DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top)

◆ 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 17596 of file duktape-1.5.2/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 17640 of file duktape-1.5.2/src/duktape.c.

17641 :
17642 return DUK_TYPE_MASK_POINTER;
17643 case DUK_TAG_LIGHTFUNC:
17645#if defined(DUK_USE_FASTINT)
17646 case DUK_TAG_FASTINT:
17647#endif
17648 default:
17649 /* Note: number has no explicit tag (in 8-byte representation) */
17652 return DUK_TYPE_MASK_NUMBER;
17653 }
#define DUK_TYPE_MASK_LIGHTFUNC
#define DUK_TYPE_MASK_NUMBER
#define DUK_TYPE_MASK_POINTER

Referenced by duk_to_boolean().

◆ duk_compact()

DUK_EXTERNAL void duk_compact ( duk_context * ctx,
duk_idx_t obj_index )

Definition at line 14758 of file duktape-1.5.2/src/duktape.c.

14759 :
14761 return;
14762
14763 fail_not_callable:
14765 return;
14766}
14767
14768/*
14769 * Object related
#define DUK_STR_INVALID_DESCRIPTOR

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 13717 of file duktape-1.5.2/src/duktape.c.

13734 {
13735 duk__compile_raw_args comp_args_alloc;
13736 duk__compile_raw_args *comp_args = &comp_args_alloc;
13737
13739
13740 if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) {
13741 /* String length is computed here to avoid multiple evaluation
13742 * of a macro argument in the calling side.
13743 */
13744 src_length = DUK_STRLEN(src_buffer);
13745 }
13746
13747 comp_args->src_buffer = (const duk_uint8_t *) src_buffer;
13748 comp_args->src_length = src_length;
13749 comp_args->flags = flags;
13750 duk_push_pointer(ctx, (void *) comp_args);
13751
13752 /* [ ... source? filename? &comp_args ] (depends on flags) */
13753
13754 if (flags & DUK_COMPILE_SAFE) {
13755 duk_int_t rc;
13756 duk_int_t nargs;
13757 duk_int_t nrets = 1;
13758
13759 /* Arguments can be: [ source? filename? &comp_args] so that
13760 * 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 19696 of file duktape-1.5.2/src/duktape.c.

19697 {
19698 duk_replace(ctx, -((duk_idx_t) count) - 1); /* overwrite str1 */
19699 duk_pop_n(ctx, count-1);
19700 }

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 11626 of file duktape-1.5.2/src/duktape.c.

11634 {
11635 *out_size = sz;
11636 }
11639
11640 return ptr;
11641}
11642
#define DUK_HBUFFER_DYNAMIC_SET_SIZE(x, v)
#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap, x)

◆ duk_copy()

DUK_EXTERNAL void duk_copy ( duk_context * ctx,
duk_idx_t from_index,
duk_idx_t to_index )

Definition at line 15858 of file duktape-1.5.2/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 71695 of file duktape-1.5.2/src/duktape.c.

71714 {
71715 duk_context *ctx = (duk_context *) thr;
71716 duk_hobject *env;
71717 duk_hobject *parent;
71718 duk_tval *tv;
71719
71720 DUK_ASSERT(thr != NULL);
71721 DUK_ASSERT(func != NULL);
71722
71724 if (tv) {
71727 parent = DUK_TVAL_GET_OBJECT(tv);
71728 } else {
71729 parent = thr->builtins[DUK_BIDX_GLOBAL_ENV];
71730 }
71731
71732 (void) duk_push_object_helper(ctx,
71735 -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 14033 of file duktape-1.5.2/src/duktape.c.

14035 {
14036 /* Treat like debugger statement: nop */
14038 DUK_UNREF(ctx);
14039}
14040
14041#endif /* DUK_USE_DEBUGGER_SUPPORT */
14042#line 1 "duk_api_heap.c"
14043/*
14044 * Heap creation and destruction
14045 */
14046
14047/* include removed: duk_internal.h */
14048
14051 duk_realloc_function realloc_func,
14052 duk_free_function free_func,
14053 void *heap_udata,
14054 duk_fatal_function fatal_handler) {
14055 duk_heap *heap = NULL;
14056 duk_context *ctx;
14057
14058 /* Assume that either all memory funcs are NULL or non-NULL, mixed
14059 * cases will now be unsafe.
14060 */
14061
14062 /* XXX: just assert non-NULL values here and make caller arguments
14063 * do the defaulting to the default implementations (smaller code)?
14064 */
14065
14066 if (!alloc_func) {
14067 DUK_ASSERT(realloc_func == NULL);
14068 DUK_ASSERT(free_func == NULL);
14069#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS)
14070 alloc_func = duk_default_alloc_function;
14071 realloc_func = duk_default_realloc_function;
14072 free_func = duk_default_free_function;
14073#else
14074 DUK_D(DUK_DPRINT("no allocation functions given and no default providers"));
14075 return NULL;
14076#endif
14077 } else {
14078 DUK_ASSERT(realloc_func != NULL);
14079 DUK_ASSERT(free_func != NULL);
14080 }
14081
14082 if (!fatal_handler) {
void *(* duk_alloc_function)(void *udata, duk_size_t size)
void(* duk_fatal_function)(duk_context *ctx, duk_errcode_t code, const char *msg)
void(* duk_free_function)(void *udata, void *ptr)
void *(* duk_realloc_function)(void *udata, void *ptr, duk_size_t size)
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_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_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 13970 of file duktape-1.5.2/src/duktape.c.

13973 {
13974 DUK_HEAP_SET_PAUSED(thr->heap);
13975
13976 /* Pause on the next opcode executed. This is always safe to do even
13977 * inside the debugger message loop: the interrupt counter will be reset
13978 * to its proper value when the message loop exits.
13979 */
13980 thr->interrupt_init = 1;
13981 thr->interrupt_counter = 0;
13982 }
13983}
13984
13985#else /* DUK_USE_DEBUGGER_SUPPORT */
13986
13989 duk_debug_write_function write_cb,
duk_size_t(* duk_debug_read_function)(void *udata, char *buffer, duk_size_t length)
duk_size_t(* duk_debug_write_function)(void *udata, const char *buffer, duk_size_t length)
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_debugger_cooperate()

DUK_EXTERNAL void duk_debugger_cooperate ( duk_context * ctx)

Definition at line 13996 of file duktape-1.5.2/src/duktape.c.

◆ duk_debugger_detach()

DUK_EXTERNAL void duk_debugger_detach ( duk_context * ctx)

Definition at line 13991 of file duktape-1.5.2/src/duktape.c.

◆ duk_debugger_notify()

DUK_EXTERNAL duk_bool_t duk_debugger_notify ( duk_context * ctx,
duk_idx_t nvalues )

Definition at line 14002 of file duktape-1.5.2/src/duktape.c.

14008 {
14010 DUK_ERROR_API((duk_hthread *) ctx, "no debugger support");
14011}
14012
14014 /* nop */
14016 DUK_UNREF(ctx);
DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx)

◆ duk_debugger_pause()

DUK_EXTERNAL void duk_debugger_pause ( duk_context * ctx)

Definition at line 14018 of file duktape-1.5.2/src/duktape.c.

14019 {
14020 duk_idx_t top;
14021

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 19712 of file duktape-1.5.2/src/duktape.c.

19713 {
19715
19716 duk__concat_and_join_helper(ctx, count, 0 /*is_join*/);
19717}
19718
19719DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count) {
19721
19722 duk__concat_and_join_helper(ctx, count, 1 /*is_join*/);
19723}
19724
19725/* XXX: could map/decode be unified with duk_unicode_support.c code?
19726 * Case conversion needs also the character surroundings though.
19727 */
19728
19730 duk_hthread *thr = (duk_hthread *) ctx;
19731 duk_hstring *h_input;
19732 const duk_uint8_t *p, *p_start, *p_end;
19733 duk_codepoint_t cp;
19734
void(* duk_decode_char_function)(void *udata, duk_codepoint_t codepoint)
DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata)

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 14666 of file duktape-1.5.2/src/duktape.c.

14675 {
14676 duk_hthread *thr = (duk_hthread *) ctx;
14677 duk_hobject *obj = duk_require_hobject(ctx, obj_index);
14679 duk_hobject_define_accessor_internal(thr, obj, DUK_HTHREAD_GET_STRING(thr, stridx), thrower, thrower, desc_flags);
14680}
14681
14682/* Object.defineProperty() equivalent C binding. */
14683DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags) {
14684 duk_hthread *thr = (duk_hthread *) ctx;
14685 duk_idx_t idx_base;
14686 duk_hobject *obj;
14687 duk_hstring *key;
14688 duk_idx_t idx_value;
14689 duk_hobject *get;
14690 duk_hobject *set;
14691 duk_uint_t is_data_desc;
14692 duk_uint_t is_acc_desc;
14693
14695
14696 obj = duk_require_hobject(ctx, obj_index);
14697
14698 is_data_desc = flags & (DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
14699 is_acc_desc = flags & (DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
14700 if (is_data_desc && is_acc_desc) {
14701 /* "Have" flags must not be conflicting so that they would
14702 * apply to both a plain property and an accessor at the same
14703 * time.
14704 */
14705 goto fail_invalid_desc;
14706 }
14707
14708 idx_base = duk_get_top_index(ctx);
14709 if (flags & DUK_DEFPROP_HAVE_SETTER) {
14713 set = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
14714 if (set != NULL && !DUK_HOBJECT_IS_CALLABLE(set)) {
14715 goto fail_not_callable;
14716 }
14717 idx_base--;
14718 } else {
14719 set = NULL;
14720 }
14721 if (flags & DUK_DEFPROP_HAVE_GETTER) {
14725 get = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
14726 if (get != NULL && !DUK_HOBJECT_IS_CALLABLE(get)) {
14727 goto fail_not_callable;
14728 }
14729 idx_base--;
14730 } else {
14731 get = NULL;
14732 }
14733 if (flags & DUK_DEFPROP_HAVE_VALUE) {
14734 idx_value = idx_base;
14735 idx_base--;
14736 } else {
14737 idx_value = (duk_idx_t) -1;
14738 }
14739 key = duk_require_hstring(ctx, idx_base);
14740
14741 duk_require_valid_index(ctx, idx_base);
14742
14744 flags /*defprop_flags*/,
14745 obj,
14746 key,
14747 idx_value,
14748 get,
14749 set);
#define DUK_DEFPROP_HAVE_GETTER
#define DUK_DEFPROP_HAVE_WRITABLE
#define DUK_DEFPROP_HAVE_SETTER
#define DUK_TYPE_MASK_UNDEFINED
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)
#define DUK_BIDX_TYPE_ERROR_THROWER

◆ duk_default_alloc_function()

DUK_INTERNAL_DECL void * duk_default_alloc_function ( void * udata,
duk_size_t size )

Definition at line 11545 of file duktape-1.5.2/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 9871 of file duktape-1.5.2/src/duktape.c.

9873 {
9875}
9878}
9881}
9882#endif
#define DUK_ERR_ALLOC_ERROR
DUK_INTERNAL void duk_err_alloc(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message)
DUK_INTERNAL void duk_err_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message)
#define DUK_ERROR_RAW(thr, file, line, err, msg)

◆ duk_default_free_function()

DUK_INTERNAL_DECL void duk_default_free_function ( void * udata,
void * ptr )

Definition at line 11563 of file duktape-1.5.2/src/duktape.c.

11566 : %lu -> %p",
11567 (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 9889 of file duktape-1.5.2/src/duktape.c.

9891 : %s\n", (long) code, (const char *) (msg ? msg : "null"));
9892 DUK_FFLUSH(DUK_STDERR);
9893#else
9894 /* omit print */
9895#endif
9896 DUK_D(DUK_DPRINT("default fatal handler called, code %ld -> calling DUK_PANIC()", (long) code));
9897 DUK_PANIC(code, msg);
9898 DUK_UNREACHABLE();
9899}
9900
9901/*
9902 * Default panic handler
9903 */
9904
9905#if !defined(DUK_USE_PANIC_HANDLER)
9906DUK_INTERNAL void duk_default_panic_handler(duk_errcode_t code, const char *msg) {
9907#if defined(DUK_USE_FILE_IO)
9908 DUK_FPRINTF(DUK_STDERR, "PANIC %ld: %s ("
9909#if defined(DUK_USE_PANIC_ABORT)
9910 "calling abort"
9911#elif defined(DUK_USE_PANIC_EXIT)
9912 "calling exit"
9913#elif defined(DUK_USE_PANIC_SEGFAULT)
9914 "segfaulting on purpose"
9915#else
9916#error no DUK_USE_PANIC_xxx macro defined
9917#endif
9918 ")\n", (long) code, (const char *) (msg ? msg : "null"));
9919 DUK_FFLUSH(DUK_STDERR);
9920#else
9921 /* omit print */
9922 DUK_UNREF(code);
#define DUK_PANIC(code, msg)
static void fatal(const char *message)

◆ duk_default_realloc_function()

DUK_INTERNAL_DECL void * duk_default_realloc_function ( void * udata,
void * ptr,
duk_size_t newsize )

Definition at line 11554 of file duktape-1.5.2/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 14471 of file duktape-1.5.2/src/duktape.c.

14475 {
14476 duk_hthread *thr = (duk_hthread *) ctx;
14477
14479 DUK_ASSERT_DISABLE(stridx >= 0);
14481 DUK_UNREF(thr);
14482
14483 obj_idx = duk_require_normalize_index(ctx, obj_idx);
14484 duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
14485 return duk__put_prop_shared(ctx, obj_idx, -1);
14486}
14487
14489 duk_hthread *thr = (duk_hthread *) ctx;
14490 duk_tval *tv_obj;
14491 duk_tval *tv_key;
14492 duk_small_int_t throw_flag;
14493 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 14504 of file duktape-1.5.2/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 14512 of file duktape-1.5.2/src/duktape.c.

14512 {
14514 DUK_ASSERT(key != NULL);
14515
14516 obj_index = duk_require_normalize_index(ctx, obj_index);
14517 duk_push_string(ctx, key);
14518 return duk_del_prop(ctx, obj_index);
14519}
14520
14523

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 14495 of file duktape-1.5.2/src/duktape.c.

◆ duk_del_var()

DUK_EXTERNAL duk_bool_t duk_del_var ( duk_context * ctx)

Definition at line 19993 of file duktape-1.5.2/src/duktape.c.

19993 {
19994 duk_js_putvar_activation(thr, act, h_varname, tv_val, throw_flag); /* -> [ ... varname val this ] */
19995 } else {
19996 /* Outside any activation -> put to global. */
19997 DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL);
19998 duk_js_putvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, tv_val, 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)

References duk_js_putvar_activation().

◆ duk_destroy_heap()

DUK_EXTERNAL void duk_destroy_heap ( duk_context * ctx)

Definition at line 14084 of file duktape-1.5.2/src/duktape.c.

14092 {
14093 return NULL;
14094 }
14095 ctx = (duk_context *) heap->heap_thread;

◆ duk_dump_function()

DUK_EXTERNAL void duk_dump_function ( duk_context * ctx)

Definition at line 12280 of file duktape-1.5.2/src/duktape.c.

12289 : %!iT", duk_get_tval(ctx, -1)));
12290 DUK_ASSERT_TOP(ctx, idx_base + 1);
12291 return p;
12292
12293 format_error:
12294 return NULL;
12295}
12296
12297DUK_EXTERNAL void duk_dump_function(duk_context *ctx) {
12298 duk_hthread *thr;
12299 duk_hcompiledfunction *func;
12300 duk_bufwriter_ctx bw_ctx_alloc;
12301 duk_bufwriter_ctx *bw_ctx = &bw_ctx_alloc;
12302 duk_uint8_t *p;
12303
12304 DUK_ASSERT(ctx != NULL);
12305 thr = (duk_hthread *) ctx;
12306
12307 /* Bound functions don't have all properties so we'd either need to
12308 * lookup the non-bound target function or reject bound functions.
12309 * For now, bound functions are rejected.
12310 */
12311 func = duk_require_hcompiledfunction(ctx, -1);
12312 DUK_ASSERT(func != NULL);

◆ duk_dup()

◆ duk_dup_top()

DUK_EXTERNAL void duk_dup_top ( duk_context * ctx)

Definition at line 15774 of file duktape-1.5.2/src/duktape.c.

15774 {
15775 duk_hthread *thr;
15776 duk_tval *tv_from;
15777 duk_tval *tv_to;
15778
15780 thr = (duk_hthread *) ctx;
15782
15783 tv_from = duk_require_tval(ctx, from_index);
15784 tv_to = thr->valstack_top++;
15785 DUK_ASSERT(tv_from != NULL);
15786 DUK_ASSERT(tv_to != NULL);
15787 DUK_TVAL_SET_TVAL(tv_to, tv_from);
15788 DUK_TVAL_INCREF(thr, tv_to); /* no side effects */
15789}
15790
15792 duk_hthread *thr;
15793 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 14773 of file duktape-1.5.2/src/duktape.c.

14775 {
14776 duk_hthread *thr = (duk_hthread *) ctx;
14777 duk_hobject *obj;
14778

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 19337 of file duktape-1.5.2/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 9834 of file duktape-1.5.2/src/duktape.c.

9834 {
9835 DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_API_ERROR, message);
9836}

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 9817 of file duktape-1.5.2/src/duktape.c.

9818 {
9819 DUK_ERROR_RAW_FMT3(thr, filename, linenumber, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)",
#define DUK_ERROR_RAW_FMT3(thr, file, line, err, fmt, arg1, arg2, arg3)

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 9814 of file duktape-1.5.2/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 40128 of file duktape-1.5.2/src/duktape.c.

40132 : thread containing the error value
40133 * thr_callstack: thread which should be used for generating callstack etc.
40134 * c_filename: C __FILE__ related to the error
40135 * c_line: C __LINE__ related to the error
40136 * noblame_fileline: if true, don't fileName/line as error source, otherwise use traceback
40137 * (needed because user code filename/line are reported but internal ones
40138 * are not)
40139 *
40140 * XXX: rename noblame_fileline to flags field; combine it to some existing
40141 * field (there are only a few call sites so this may not be worth it).
40142 */
40143
40144#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
40145DUK_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) {
40146 duk_context *ctx = (duk_context *) thr;
40147 duk_hobject *obj;
40148
40149 DUK_ASSERT(thr != NULL);
40150 DUK_ASSERT(thr_callstack != NULL);
40151 DUK_ASSERT(ctx != NULL);
40152
40153 /* [ ... error ] */
40154
40155 /*
40156 * Criteria for augmenting:
40157 *
40158 * - augmentation enabled in build (naturally)
40159 * - error value internal prototype chain contains the built-in
40160 * Error prototype object (i.e. 'val instanceof Error')
40161 *
40162 * Additional criteria for built-in augmenting:
40163 *
40164 * - error value is an extensible object
40165 */
40166
40167 obj = duk_get_hobject(ctx, -1);
40168 if (!obj) {
40169 DUK_DDD(DUK_DDDPRINT("value is not an object, skip both built-in and user augment"));
40170 return;
40171 }
40172 if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE], 1 /*ignore_loop*/)) {
40173 /* If the value has a prototype loop, it's critical not to
40174 * throw here. Instead, assume the value is not to be
40175 * 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 40185 of file duktape-1.5.2/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 40394 of file duktape-1.5.2/src/duktape.c.

40411 {
40412#else
40414#endif
40415 duk_context *ctx = (duk_context *) thr;
40416 duk_bool_t double_error = thr->heap->handling_error;
40417
40418#ifdef DUK_USE_VERBOSE_ERRORS
40419 DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld, msg=%s, filename=%s, line=%ld",
40420 (long) code, (const char *) msg,
40421 (const char *) filename, (long) line));
40422#else
40423 DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld", (long) code));
40424#endif
40425
40426 DUK_ASSERT(thr != NULL);
40427 DUK_ASSERT(ctx != NULL);
40428
40429 thr->heap->handling_error = 1;
40430
40431 if (!double_error) {
40432 /* Allow headroom for calls during error handling (see GH-191).
40433 * We allow space for 10 additional recursions, with one extra
40434 * for, e.g. a print() call at the deepest level.
40435 */
40438 }
40439
40440 DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11); /* just making sure */
40441
40442 /* Sync so that augmentation sees up-to-date activations, NULL
40443 * thr->ptr_curr_pc so that it's not used if side effects occur
40444 * in augmentation or longjmp handling.
40445 */
40447
40448 /*
40449 * Create and push an error object onto the top of stack.
40450 * If a "double error" occurs, use a fixed error instance
40451 * to avoid further trouble.
40452 */
40453
40454 /* XXX: if attempt to push beyond allocated valstack, this double fault
40455 * handling fails miserably. We should really write the double error
40456 * directly to thr->heap->lj.value1 and avoid valstack use entirely.
40457 */
40458
40459 if (double_error) {
40460 if (thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
40461 DUK_D(DUK_DPRINT("double fault detected -> push built-in fixed 'double error' instance"));
40463 } else {
40464 DUK_D(DUK_DPRINT("double fault detected; there is no built-in fixed 'double error' instance "
40465 "-> push the error code as a number"));
40466 duk_push_int(ctx, (duk_int_t) code);
40467 }
40468 } else {
40469 /* Error object is augmented at its creation here. */
40470 duk_require_stack(ctx, 1);
40471 /* XXX: unnecessary '%s' formatting here, but cannot use
40472 * 'msg' as a format string directly.
40473 */
40474#ifdef DUK_USE_VERBOSE_ERRORS
40477 filename,
40478 line,
40479 "%s",
40480 (const char *) msg);
40481#else
40484 NULL,
40485 0,
40486 NULL);
40487#endif
40488 }
40489
40490 /*
40491 * Augment error (throw time), unless alloc/double error
40492 */
40493
40494 if (double_error || code == DUK_ERR_ALLOC_ERROR) {
40495 DUK_D(DUK_DPRINT("alloc or double error: skip throw augmenting to avoid further trouble"));
40496 } else {
40497#if defined(DUK_USE_AUGMENT_ERROR_THROW)
40498 DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT (before throw augment)",
40499 (duk_tval *) duk_get_tval(ctx, -1)));
40501#endif
#define DUK_BIDX_DOUBLE_ERROR
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)
#define DUK_CALLSTACK_DEFAULT_MAX
#define DUK_CALLSTACK_GROW_STEP
#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE
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,...)

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 )

◆ 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 9773 of file duktape-1.5.2/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 9831 of file duktape-1.5.2/src/duktape.c.

9831 {
9832 DUK_ERROR_RAW_FMT1(thr, filename, linenumber, DUK_ERR_API_ERROR, "invalid stack index %ld", (long) (index));
9833}
#define DUK_ERROR_RAW_FMT1(thr, file, line, err, fmt, arg1)

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 9828 of file duktape-1.5.2/src/duktape.c.

9828 {
9829 DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_RANGE_ERROR, message);
9830}
#define DUK_ERR_RANGE_ERROR

References DUK_ERR_RANGE_ERROR, and DUK_ERROR_RAW.

◆ duk_err_longjmp()

DUK_INTERNAL void duk_err_longjmp ( duk_hthread * thr)

Definition at line 40199 of file duktape-1.5.2/src/duktape.c.

40202 {
40203#if defined(DUK_USE_ERRTHROW)
40205#endif /* DUK_USE_ERRTHROW */
40206}
40207#endif /* DUK_USE_AUGMENT_ERROR_THROW */
40208#line 1 "duk_error_longjmp.c"
40209/*
40210 * Do a longjmp call, calling the fatal error handler if no
40211 * catchpoint exists.
40212 */
40213
40214/* include removed: duk_internal.h */
40215
40217 DUK_ASSERT(thr != NULL);
40218
40219 DUK_DD(DUK_DDPRINT("longjmp error: type=%d iserror=%d value1=%!T value2=%!T",
40220 (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
40221 &thr->heap->lj.value1, &thr->heap->lj.value2));
40222
40223#if !defined(DUK_USE_CPP_EXCEPTIONS)
40224 /* If we don't have a jmpbuf_ptr, there is little we can do
40225 * except panic. The caller's expectation is that we never
40226 * return.
40227 *
40228 * With C++ exceptions we now just propagate an uncaught error
40229 * instead of invoking the fatal error handler. Because there's
40230 * a dummy jmpbuf for C++ exceptions now, this could be changed.
40231 */
40232 if (!thr->heap->lj.jmpbuf_ptr) {
40233
40234 DUK_D(DUK_DPRINT("uncaught error: type=%d iserror=%d value1=%!T value2=%!T",
40235 (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
40236 &thr->heap->lj.value1, &thr->heap->lj.value2));
#define DUK_STRIDX_ERR_THROW

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 9811 of file duktape-1.5.2/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 9806 of file duktape-1.5.2/src/duktape.c.

9806 {
9807 duk_err_create_and_throw(thr, code);
9808}
9809

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 40311 of file duktape-1.5.2/src/duktape.c.

40313 :
40317 case DUK_ERR_API_ERROR:
40318 case DUK_ERR_ERROR:
40319 default:
40321 }
40322}
40323
40324/*
40325 * Exposed helper for setting up heap longjmp state.
40326 */
40327
40329#if defined(DUK_USE_DEBUGGER_SUPPORT)
40330 /* If something is thrown with the debugger attached and nobody will
40331 * catch it, execution is paused before the longjmp, turning over
40332 * control to the debug client. This allows local state to be examined
40333 * before the stack is unwound. Errors are not intercepted when debug
40334 * message loop is active (e.g. for Eval).
40335 */
40336
40337 /* XXX: Allow customizing the pause and notify behavior at runtime
40338 * using debugger runtime flags. For now the behavior is fixed using
40339 * config options.
40340 */
40341#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
40342 if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) &&
40343 !thr->heap->dbg_processing &&
40344 lj_type == DUK_LJ_TYPE_THROW) {
40345 duk_context *ctx = (duk_context *) thr;
40347 duk_hobject *h_obj;
40348
40349 /* Don't intercept a DoubleError, we may have caused the initial double
40350 * fault and attempting to intercept it will cause us to be called
40351 * recursively and exhaust the C stack.
40352 */
40353 h_obj = duk_get_hobject(ctx, -1);
40354 if (h_obj == thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
40355 DUK_D(DUK_DPRINT("built-in DoubleError instance thrown, not intercepting"));
40356 goto skip_throw_intercept;
40357 }
40358
40359 DUK_D(DUK_DPRINT("throw with debugger attached, report to client"));
40360
40361 fatal = !duk__have_active_catcher(thr);
40362
40363#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY)
40364 /* Report it to the debug client */
40365 duk_debug_send_throw(thr, fatal);
40366#endif
40367
40368#if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
40369 if (fatal) {
#define DUK_ERR_ASSERTION_ERROR
#define DUK_BIDX_ERROR_PROTOTYPE

◆ duk_err_unimplemented_defmsg()

DUK_INTERNAL void duk_err_unimplemented_defmsg ( duk_hthread * thr,
const char * filename,
duk_int_t linenumber )

Definition at line 9820 of file duktape-1.5.2/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 40280 of file duktape-1.5.2/src/duktape.c.

40280 {
40281 for (i = 0; i < thr->catchstack_top; i++) {
40282 duk_catcher *cat = thr->catchstack + i;
40283 if (DUK_CAT_HAS_CATCH_ENABLED(cat)) {
40284 return 1; /* all we need to know */
40285 }
40286 }
40287 thr = thr->resumer;
40288 }
40289 return 0;
40290}
40291#endif /* DUK_USE_DEBUGGER_SUPPORT && (DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) */
40292
40293/*
40294 * Get prototype object for an integer error code.
40295 */
40296
40298 switch (code) {
40299 case DUK_ERR_EVAL_ERROR:
#define DUK_BIDX_EVAL_ERROR_PROTOTYPE
DUK_INTERNAL_DECL duk_hobject * duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code)
#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE
#define DUK_BIDX_RANGE_ERROR_PROTOTYPE

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 19302 of file duktape-1.5.2/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 19314 of file duktape-1.5.2/src/duktape.c.

19319 {
19320 va_list ap;
19321
19323
19324 va_start(ap, fmt);
19325 duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
19326 va_end(ap);
19327 duk_throw(ctx);
19328}
19329
19330#if !defined(DUK_USE_VARIADIC_MACROS)
DUK_EXTERNAL void duk_throw(duk_context *ctx)
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_error_throw_from_negative_rc()

DUK_INTERNAL void duk_error_throw_from_negative_rc ( duk_hthread * thr,
duk_ret_t rc )

Definition at line 40507 of file duktape-1.5.2/src/duktape.c.

40513 : %!iT, %!iT (after throw augment)",
40514 (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2));
40515
40516 duk_err_longjmp(thr);
40517 DUK_UNREACHABLE();
40518}
40519
40520/*
40521 * Helper for C function call negative return values.
40522 */
40523
40524DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc) {
40525 duk_context *ctx = (duk_context *) thr;
40526 const char *msg;
40527 duk_errcode_t code;
40528
40529 DUK_ASSERT(thr != NULL);
40530 DUK_ASSERT(rc < 0);
40531
40532 /* XXX: this generates quite large code - perhaps select the error
40533 * class based on the code and then just use the error 'name'?
40534 */
40535 /* XXX: shared strings */
40536
40537 code = -rc;
40538
40539 switch (rc) {
40540 case DUK_RET_UNIMPLEMENTED_ERROR: msg = "unimplemented"; break;
40541 case DUK_RET_UNSUPPORTED_ERROR: msg = "unsupported"; break;
40542 case DUK_RET_INTERNAL_ERROR: msg = "internal"; break;
40543 case DUK_RET_ALLOC_ERROR: msg = "alloc"; break;
40544 case DUK_RET_ASSERTION_ERROR: msg = "assertion"; break;
40545 case DUK_RET_API_ERROR: msg = "api"; break;
40546 case DUK_RET_UNCAUGHT_ERROR: msg = "uncaught"; break;
40547 case DUK_RET_ERROR: msg = "error"; break;
40548 case DUK_RET_EVAL_ERROR: msg = "eval"; break;
40549 case DUK_RET_RANGE_ERROR: msg = "range"; break;
40550 case DUK_RET_REFERENCE_ERROR: msg = "reference"; break;
40551 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 19295 of file duktape-1.5.2/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 13581 of file duktape-1.5.2/src/duktape.c.

13591 {
13592 duk_size_t src_length; /* should be first on 64-bit platforms */
13593 const duk_uint8_t *src_buffer;
13594 duk_uint_t flags;
13595};
13596
13597/* Eval is just a wrapper now. */
13598DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) {
13599 duk_uint_t comp_flags;
13600 duk_int_t rc;
13601
13603
13604 /* Note: strictness is *not* inherited from the current Duktape/C.
13605 * This would be confusing because the current strictness state
13606 * depends on whether we're running inside a Duktape/C activation
13607 * (= strict mode) or outside of any activation (= non-strict mode).
13608 * See tests/api/test-eval-strictness.c for more discussion.
13609 */
13610
13611 /* [ ... source? filename? ] (depends on flags) */
13612
13613 comp_flags = flags;
13614 comp_flags |= DUK_COMPILE_EVAL;
13615 rc = duk_compile_raw(ctx, src_buffer, src_length, comp_flags); /* may be safe, or non-safe depending on flags */
13616
13617 /* [ ... closure/error ] */
13618
13619 if (rc != DUK_EXEC_SUCCESS) {
13620 rc = DUK_EXEC_ERROR;
13621 goto got_rc;
13622 }
13623
13624 duk_push_global_object(ctx); /* explicit 'this' binding, see GH-164 */
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_fatal()

DUK_EXTERNAL void duk_fatal ( duk_context * ctx,
duk_errcode_t err_code,
const char * err_msg )

Definition at line 19275 of file duktape-1.5.2/src/duktape.c.

19276 : %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
19277 duk_err_augment_error_throw(thr);
19278#endif
19279 DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (after throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
19280
19281 duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
19282
19283 /* thr->heap->lj.jmpbuf_ptr is checked by duk_err_longjmp() so we don't
19284 * need to check that here. If the value is NULL, a panic occurs because
19285 * we can't return.
19286 */
19287
19288 duk_err_longjmp(thr);
19289 DUK_UNREACHABLE();
19290}
19291
19292DUK_EXTERNAL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg) {
19293 duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_free()

DUK_EXTERNAL void duk_free ( duk_context * ctx,
void * ptr )

Definition at line 14252 of file duktape-1.5.2/src/duktape.c.

14253 {
14254 duk_hthread *thr = (duk_hthread *) ctx;
14255
14257
14258 return DUK_REALLOC_RAW(thr->heap, ptr, size);
#define DUK_REALLOC_RAW(heap, ptr, newsize)

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 40849 of file duktape-1.5.2/src/duktape.c.

40849 {
40850 duk_hthread *t = (duk_hthread *) h;
40851 DUK_FREE(heap, t->valstack);
40852 DUK_FREE(heap, t->callstack);
40853 DUK_FREE(heap, t->catchstack);
40854 /* Don't free h->resumer because it exists in the heap.
40855 * Callstack entries also contain function pointers which
40856 * are not freed for the same reason.
40857 */
40858

◆ duk_free_hobject_inner()

DUK_INTERNAL_DECL void duk_free_hobject_inner ( duk_heap * heap,
duk_hobject * h )

Definition at line 40818 of file duktape-1.5.2/src/duktape.c.

40835 {
40836 DUK_ASSERT(heap != NULL);
40837 DUK_ASSERT(h != NULL);
40838
40839 DUK_FREE(heap, DUK_HOBJECT_GET_PROPS(heap, h));
40840
40843 DUK_UNREF(f);
40844 /* Currently nothing to free; 'data' is a heap object */
40845 } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
40847 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 40860 of file duktape-1.5.2/src/duktape.c.

40866 {
40867 DUK_ASSERT(heap != NULL);
40868 DUK_ASSERT(h != NULL);
40869
40872 DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g)));
40874 }

◆ duk_free_raw()

DUK_EXTERNAL void duk_free_raw ( duk_context * ctx,
void * ptr )

Definition at line 14228 of file duktape-1.5.2/src/duktape.c.

◆ duk_gc()

DUK_EXTERNAL void duk_gc ( duk_context * ctx,
duk_uint_t flags )

Definition at line 14294 of file duktape-1.5.2/src/duktape.c.

14295 {
14296 duk_hthread *thr = (duk_hthread *) ctx;
14297 duk_heap *heap;
14298
14300 DUK_ASSERT(out_funcs != NULL);
14301 DUK_ASSERT(thr != NULL);
14302 DUK_ASSERT(thr->heap != NULL);
14303
14304 heap = thr->heap;
14305 out_funcs->alloc_func = heap->alloc_func;
14306 out_funcs->realloc_func = heap->realloc_func;
14307 out_funcs->free_func = heap->free_func;
14308 out_funcs->udata = heap->heap_udata;
14309}
14310
14311DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags) {
14312#ifdef DUK_USE_MARK_AND_SWEEP
14313 duk_hthread *thr = (duk_hthread *) ctx;
14314 duk_heap *heap;
14315
14316 DUK_UNREF(flags);
DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags)
duk_realloc_function realloc_func
duk_alloc_function alloc_func

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 16020 of file duktape-1.5.2/src/duktape.c.

16023 {
16024 duk_hthread *thr = (duk_hthread *) ctx;
16025 duk_tval *tv;
16026
16028
16029 tv = duk_get_tval(ctx, index);
16030 if (tv && DUK_TVAL_IS_NULL(tv)) {
16031 return;
16032 }
#define 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 18262 of file duktape-1.5.2/src/duktape.c.

18267 {
18268 duk_hstring *h;
18269
18271
18272 duk__push_this_helper(ctx, 1 /*check_object_coercible*/);
18273 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 16252 of file duktape-1.5.2/src/duktape.c.

16254 {

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 16314 of file duktape-1.5.2/src/duktape.c.

16315 {
16316 *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 16433 of file duktape-1.5.2/src/duktape.c.

16433 {
16435 if (h != NULL && !DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
16436 h = NULL;
16437 }
16438 return (duk_hnativefunction *) h;
16439}
16440
16442 duk_hthread *thr = (duk_hthread *) ctx;
16444 if (!(h != NULL && DUK_HOBJECT_IS_NATIVEFUNCTION(h))) {
16446 }
16447 return (duk_hnativefunction *) h;
16448}
16449
16451 duk_tval *tv;
16452 duk_hobject *h;
16454
16456
16457 tv = duk_get_tval(ctx, index);
#define DUK_STR_NOT_NATIVEFUNCTION
DUK_EXTERNAL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index)
DUK_INTERNAL_DECL duk_hnativefunction * duk_require_hnativefunction(duk_context *ctx, duk_idx_t 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 16478 of file duktape-1.5.2/src/duktape.c.

◆ duk_get_current_magic()

DUK_EXTERNAL duk_int_t duk_get_current_magic ( duk_context * ctx)

Definition at line 12864 of file duktape-1.5.2/src/duktape.c.

12870 {
12871 /* Strict by default. */
12872 return 1;
12873 }
12874 return ((act->flags & DUK_ACT_FLAG_STRICT) != 0 ? 1 : 0);
12875}
12876
12877/*
12878 * Duktape/C function magic
12879 */
12880
12882 duk_hthread *thr = (duk_hthread *) ctx;
12883 duk_activation *act;
12884 duk_hobject *func;
12885
12887 DUK_ASSERT(thr != NULL);
12889
DUK_INTERNAL_DECL duk_activation * duk_hthread_get_current_activation(duk_hthread *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 17844 of file duktape-1.5.2/src/duktape.c.

17847 {
17848 duk_tval *tv;
17849
17851
17852 tv = duk_get_tval(ctx, index);
17853 if (tv && DUK_TVAL_IS_BUFFER(tv)) {
17855 DUK_ASSERT(h != NULL);
17856 return (DUK_HBUFFER_HAS_DYNAMIC(h) && DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0);
17857 }
17858 return 0;
17859}
17860
17862 duk_hthread *thr = (duk_hthread *) ctx;
17863 duk_hobject *h;
17864 duk_uint_t sanity;
17865
17867
17868 h = duk_get_hobject(ctx, index);
17869
17871 do {
17872 if (!h) {
17873 return DUK_ERR_NONE;
17874 }
17875 if (h == thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE]) {
17876 return DUK_ERR_EVAL_ERROR;
17877 }
17879 return DUK_ERR_RANGE_ERROR;
17880 }
17883 }
DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index)
#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE

◆ duk_get_finalizer()

DUK_EXTERNAL void duk_get_finalizer ( duk_context * ctx,
duk_idx_t index )

Definition at line 14917 of file duktape-1.5.2/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 14827 of file duktape-1.5.2/src/duktape.c.

14831 {
14832 while (ent->key != NULL) {
14833 duk_push_number(ctx, ent->value);
14834 duk_put_prop_string(ctx, obj_index, ent->key);
14835 ent++;
14836 }
14837 }
14838}
14839
14840/*
DUK_EXTERNAL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key)

◆ duk_get_hbuffer()

DUK_INTERNAL_DECL duk_hbuffer * duk_get_hbuffer ( duk_context * ctx,
duk_idx_t index )

Definition at line 16369 of file duktape-1.5.2/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 16399 of file duktape-1.5.2/src/duktape.c.

16399 {
16401 if (h != NULL && !DUK_HOBJECT_IS_THREAD(h)) {
16402 h = NULL;
16403 }
16404 return (duk_hthread *) h;
16405}

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 16490 of file duktape-1.5.2/src/duktape.c.

16490 {
16492 }
16493}
16494
16497
16498 return (duk_context *) duk_get_hthread(ctx, index);
16499}
16500
16503
16504 return (duk_context *) duk_require_hthread(ctx, index);
#define DUK_STR_NOT_FUNCTION
DUK_INTERNAL_DECL duk_hthread * duk_get_hthread(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)

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 16416 of file duktape-1.5.2/src/duktape.c.

16416 {
16418 if (h != NULL && !DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
16419 h = NULL;
16420 }
16421 return (duk_hcompiledfunction *) h;
16422}

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_TAG_OBJECT, index, and NULL.

◆ duk_get_hobject()

◆ 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 16538 of file duktape-1.5.2/src/duktape.c.

16546 {
16547}
16548#endif
16549
16550/* Useful for internal call sites where we either expect an object (function)
16551 * or a lightfunc. Accepts an object (returned as is) or a lightfunc (coerced
16552 * to an object). Return value is NULL if value is neither an object nor a
16553 * 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 )

◆ duk_get_hstring()

◆ duk_get_hthread()

DUK_INTERNAL_DECL duk_hthread * duk_get_hthread ( duk_context * ctx,
duk_idx_t index )

Definition at line 16382 of file duktape-1.5.2/src/duktape.c.

16386 {
16388}

◆ duk_get_int()

DUK_EXTERNAL duk_int_t duk_get_int ( duk_context * ctx,
duk_idx_t index )

Definition at line 16095 of file duktape-1.5.2/src/duktape.c.

16096 {
16097 duk_double_union ret;
16098 ret.d = DUK_TVAL_GET_NUMBER(tv);
16099

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 16630 of file duktape-1.5.2/src/duktape.c.

16637 {
16638 duk_hstring *h_class;
16640 DUK_UNREF(h_class);
16641
16643 }
16644 return h;
16645}
16646
16648 duk_tval *tv;
16649
16651
16652 tv = duk_get_tval(ctx, index);
16653 if (!tv) {
16654 return 0;
16655 }
16656
16657 switch (DUK_TVAL_GET_TAG(tv)) {
16658 case DUK_TAG_UNDEFINED:
16659 case DUK_TAG_NULL:
16660 case DUK_TAG_BOOLEAN:
16661 case DUK_TAG_POINTER:
16662 return 0;
16663 case DUK_TAG_STRING: {
16665 DUK_ASSERT(h != NULL);
16667 }
16668 case DUK_TAG_OBJECT: {
16670 DUK_ASSERT(h != NULL);
16671 return (duk_size_t) duk_hobject_get_length((duk_hthread *) ctx, h);
16672 }
16673 case DUK_TAG_BUFFER: {
16675 DUK_ASSERT(h != NULL);
16676 return (duk_size_t) DUK_HBUFFER_GET_SIZE(h);
16677 }
#define DUK_STR_UNEXPECTED_TYPE

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 16119 of file duktape-1.5.2/src/duktape.c.

16124 {
16125 /* Custom coercion for API */
16127 return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/);
16128}
16129
16131 /* Custom coercion for API */
16133 return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/);
16134}
16135
16137 const char *ret;
16138 duk_tval *tv;
16139
16141
16142 /* default: NULL, length 0 */
16143 ret = NULL;
16144 if (out_len) {
16145 *out_len = 0;
DUK_EXTERNAL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index)

◆ duk_get_magic()

DUK_EXTERNAL duk_int_t duk_get_magic ( duk_context * ctx,
duk_idx_t index )

Definition at line 12892 of file duktape-1.5.2/src/duktape.c.

12893 {
12894 duk_tval *tv = &act->tv_func;
12895 duk_small_uint_t lf_flags;
12896 lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
12897 return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
12898 }
12899 DUK_ASSERT(func != NULL);
12900
12903 return (duk_int_t) nf->magic;
12904 }
12905 }
12906 return 0;
12907}
12908
12910 duk_hthread *thr = (duk_hthread *) ctx;
12911 duk_tval *tv;
12912 duk_hobject *h;
12913
12915
12916 tv = duk_require_tval(ctx, index);
#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags)
DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index)

◆ duk_get_memory_functions()

DUK_EXTERNAL void duk_get_memory_functions ( duk_context * ctx,
duk_memory_functions * out_funcs )

Definition at line 14278 of file duktape-1.5.2/src/duktape.c.

◆ duk_get_number()

DUK_EXTERNAL duk_double_t duk_get_number ( duk_context * ctx,
duk_idx_t index )

Definition at line 16051 of file duktape-1.5.2/src/duktape.c.

16052 {
16053 duk_hthread *thr = (duk_hthread *) ctx;
16054 duk_tval *tv;
16055
16057
16058 tv = duk_get_tval(ctx, index);
16059 if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
16061 DUK_ASSERT(ret == 0 || ret == 1);
16062 return ret;
16063 }
16065 return 0; /* not reachable */
16066}
16067
16069 duk_double_union ret;
16070 duk_tval *tv;
#define DUK_STR_NOT_BOOLEAN

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 16176 of file duktape-1.5.2/src/duktape.c.

16181 {
16183
16184 return duk_get_lstring(ctx, index, NULL);
16185}
16186

◆ duk_get_prop()

DUK_EXTERNAL duk_bool_t duk_get_prop ( duk_context * ctx,
duk_idx_t obj_index )

Definition at line 14332 of file duktape-1.5.2/src/duktape.c.

14349 {
14350 duk_hthread *thr = (duk_hthread *) ctx;
14351 duk_tval *tv_obj;
14352 duk_tval *tv_key;
14353 duk_bool_t rc;

Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk_get_prop_stridx().

◆ duk_get_prop_index()

◆ duk_get_prop_stridx()

◆ 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 14385 of file duktape-1.5.2/src/duktape.c.

14389 {
14390 duk_hthread *thr = (duk_hthread *) ctx;
14391
14393 DUK_ASSERT_DISABLE(stridx >= 0);
14395 DUK_UNREF(thr);
14396
14397 obj_index = duk_require_normalize_index(ctx, obj_index);
14398 duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
14399 return duk_get_prop(ctx, obj_index);
14400}

◆ 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 14355 of file duktape-1.5.2/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 14862 of file duktape-1.5.2/src/duktape.c.

14879 {
14880 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 16164 of file duktape-1.5.2/src/duktape.c.

16164 {
16165 duk_hthread *thr = (duk_hthread *) ctx;
16166 const char *ret;
16167

References DUK_ASSERT_CTX_VALID.

Referenced by duk__error_getter_helper().

◆ duk_get_top()

◆ duk_get_top_index()

DUK_EXTERNAL duk_idx_t duk_get_top_index ( duk_context * ctx)

Definition at line 15362 of file duktape-1.5.2/src/duktape.c.

15370 {
15371 tv--;
15373 } while (tv != tv_end);
15374 thr->valstack_top = tv_end;
15375#endif /* DUK_USE_REFERENCE_COUNTING */
15376 }
15377}
#define DUK_TVAL_SET_UNDEFINED(tv)

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 15176 of file duktape-1.5.2/src/duktape.c.

15176 {
15177 uindex = vs_size + (duk_uidx_t) index;
15178 } else {
15180 uindex = (duk_uidx_t) index;
15181 }
15182
15183 /* DUK_INVALID_INDEX won't be accepted as a valid index. */
15184 DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
15185
15186 if (DUK_LIKELY(uindex < vs_size)) {
15187 return (duk_idx_t) uindex;
15188 }
15190 return 0; /* unreachable */
15191}
15192
15194 duk_hthread *thr = (duk_hthread *) ctx;
15195 duk_uidx_t vs_size;
15196 duk_uidx_t uindex;
15197
15200
15202 vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
#define DUK_ERROR_API_INDEX(thr, index)

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 17533 of file duktape-1.5.2/src/duktape.c.

17538 {
17539 duk_hobject *obj;
17540
17542
17543 obj = duk_get_hobject(ctx, index);
17544 if (obj) {
17545 return (DUK_HEAPHDR_CHECK_FLAG_BITS((duk_heaphdr *) obj, flag_mask) ? 1 : 0);
17546 }
17547 return 0;
17548}
17549
17551 duk_tval *tv;
17552
17554
17555 tv = duk_get_tval(ctx, index);
17556 if (!tv) {
17557 return DUK_TYPE_NONE;
17558 }
17559 switch (DUK_TVAL_GET_TAG(tv)) {
17560 case DUK_TAG_UNDEFINED:
17561 return DUK_TYPE_UNDEFINED;
17562 case DUK_TAG_NULL:
17563 return DUK_TYPE_NULL;
17564 case DUK_TAG_BOOLEAN:
17565 return DUK_TYPE_BOOLEAN;
17566 case DUK_TAG_STRING:
17567 return DUK_TYPE_STRING;
17568 case DUK_TAG_OBJECT:
17569 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 17602 of file duktape-1.5.2/src/duktape.c.

17602 {
17603 duk_int_t type_tag;
17604
17605 type_tag = duk_get_type(ctx, index);
17606 DUK_ASSERT(type_tag >= DUK_TYPE_MIN && type_tag <= DUK_TYPE_MAX);
17607 DUK_ASSERT(DUK_TYPE_MIN == 0 && sizeof(duk__type_names) / sizeof(const char *) == DUK_TYPE_MAX + 1);
17608
17609 return duk__type_names[type_tag];
17610}
17611#endif
17612
17615
17616 return (duk_get_type(ctx, index) == type) ? 1 : 0;
17617}
17618
17620 duk_tval *tv;
17621
17623
17624 tv = duk_get_tval(ctx, index);
17625 if (!tv) {
17626 return DUK_TYPE_MASK_NONE;
17627 }
17628 switch (DUK_TVAL_GET_TAG(tv)) {
17629 case DUK_TAG_UNDEFINED:
17631 case DUK_TAG_NULL:
17632 return DUK_TYPE_MASK_NULL;
17633 case DUK_TAG_BOOLEAN:
17634 return DUK_TYPE_MASK_BOOLEAN;
17635 case DUK_TAG_STRING:
17636 return DUK_TYPE_MASK_STRING;
17637 case DUK_TAG_OBJECT:
17638 return DUK_TYPE_MASK_OBJECT;
#define DUK_TYPE_MASK_BOOLEAN
DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index)

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 16101 of file duktape-1.5.2/src/duktape.c.

◆ duk_get_var()

DUK_EXTERNAL void duk_get_var ( duk_context * ctx)

Definition at line 19926 of file duktape-1.5.2/src/duktape.c.

19928 {
19929 return 0;
19930 }
19931
19932 DUK_ASSERT(char_offset <= DUK_UINT_MAX); /* guaranteed by string limits */
19933 cp = duk_hstring_char_code_at_raw(thr, h, (duk_uint_t) char_offset);
19934 return (duk_codepoint_t) cp;
19935}
19936#line 1 "duk_api_var.c"
19937/*
19938 * Variable access
19939 */
19940
19941/* include removed: duk_internal.h */
19942
19944 duk_hthread *thr = (duk_hthread *) ctx;
19945 duk_activation *act;
19946 duk_hstring *h_varname;
19947 duk_small_int_t throw_flag = 1; /* always throw ReferenceError for unresolvable */
19948
19950
19951 h_varname = duk_require_hstring(ctx, -1); /* XXX: tostring? */
19952 DUK_ASSERT(h_varname != NULL);
19953
19955 if (act) {
19956 (void) duk_js_getvar_activation(thr, act, h_varname, throw_flag); /* -> [ ... varname val this ] */
19957 } else {
DUK_EXTERNAL void duk_get_var(duk_context *ctx)

◆ 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 55702 of file duktape-1.5.2/src/duktape.c.

55705 :
55706 *
55707 * [ retval ] (DUK_EXEC_SUCCESS)
55708 * [ errobj ] (DUK_EXEC_ERROR (normal error), protected call)
55709 *
55710 * Even when executing a protected call an error may be thrown in rare cases
55711 * such as an insane num_stack_args argument. If there is no catchpoint for
55712 * such errors, the fatal error handler is called.
55713 *
55714 * The error handling path should be error free, even for out-of-memory
55715 * errors, to ensure safe sandboxing. (As of Duktape 1.4.0 this is not
55716 * yet the case, see XXX notes below.)
55717 */
55718
55720 duk_idx_t num_stack_args,
55721 duk_small_uint_t call_flags) {
55722 duk_context *ctx;
55723 duk_size_t entry_valstack_bottom_index;
55724 duk_size_t entry_valstack_end;
55725 duk_size_t entry_callstack_top;
55726 duk_size_t entry_catchstack_top;
55727 duk_int_t entry_call_recursion_depth;
55728 duk_hthread *entry_curr_thread;
55729 duk_uint_fast8_t entry_thread_state;
55730 duk_instr_t **entry_ptr_curr_pc;
55731 duk_jmpbuf *old_jmpbuf_ptr = NULL;
55732 duk_jmpbuf our_jmpbuf;
55733 duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
55734
55735 /* XXX: Multiple tv_func lookups are now avoided by making a local
55736 * copy of tv_func. Another approach would be to compute an offset
55737 * for tv_func from valstack bottom and recomputing the tv_func
55738 * pointer quickly as valstack + offset instead of calling duk_get_tval().
55739 */
55740
55741 ctx = (duk_context *) thr;
55742 DUK_UNREF(ctx);
55743 DUK_ASSERT(thr != NULL);
55745 DUK_ASSERT(num_stack_args >= 0);
55746 /* XXX: currently NULL allocations are not supported; remove if later allowed */
55747 DUK_ASSERT(thr->valstack != NULL);
55748 DUK_ASSERT(thr->callstack != NULL);
55749 DUK_ASSERT(thr->catchstack != NULL);
55750
55751 /* Argument validation and func/args offset. */
55752 idx_func = duk__get_idx_func(thr, num_stack_args);
55753
55754 /* Preliminaries, required by setjmp() handler. Must be careful not
55755 * to throw an unintended error here.
55756 */
55757
55758 entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
55759#if defined(DUK_USE_PREFER_SIZE)
55760 entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack);
55761#else
55762 DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
55763 entry_valstack_end = thr->valstack_size;
55764#endif
55765 entry_callstack_top = thr->callstack_top;
55766 entry_catchstack_top = thr->catchstack_top;
55767 entry_call_recursion_depth = thr->heap->call_recursion_depth;
55768 entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */
55769 entry_thread_state = thr->state;
55770 entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */
55771
55772 DUK_DD(DUK_DDPRINT("duk_handle_call_protected: thr=%p, num_stack_args=%ld, "
55773 "call_flags=0x%08lx (ignorerec=%ld, constructor=%ld), "
55774 "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, "
55775 "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
55776 "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
55777 (void *) thr,
55778 (long) num_stack_args,
55779 (unsigned long) call_flags,
55780 (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0),
55781 (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0),
55782 (long) duk_get_top(ctx),
55783 (long) idx_func,
55784 (long) (idx_func + 2),
55785 (long) thr->heap->call_recursion_depth,
55786 (long) thr->heap->call_recursion_limit,
55787 (long) entry_valstack_bottom_index,
55788 (long) entry_callstack_top,
55789 (long) entry_catchstack_top,
55790 (long) entry_call_recursion_depth,
55791 (void *) entry_curr_thread,
55792 (long) entry_thread_state));
55793
55794 old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
55795 thr->heap->lj.jmpbuf_ptr = &our_jmpbuf;
55796
55797#if defined(DUK_USE_CPP_EXCEPTIONS)
55798 try {
55799#else
55800 DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == &our_jmpbuf);
55801 if (DUK_SETJMP(our_jmpbuf.jb) == 0) {
55802#endif
55803 /* Call handling and success path. Success path exit cleans
55804 * up almost all state.
55805 */
55806 duk__handle_call_inner(thr, num_stack_args, call_flags, idx_func);
55807
55808 /* Success path handles */
55809 DUK_ASSERT(thr->heap->call_recursion_depth == entry_call_recursion_depth);
55810 DUK_ASSERT(thr->ptr_curr_pc == entry_ptr_curr_pc);
55811
55812 /* Longjmp state is kept clean in success path */
55813 DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
55814 DUK_ASSERT(thr->heap->lj.iserror == 0);
55815 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
55816 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
55817
55818 thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
55819
55820 return DUK_EXEC_SUCCESS;
55821#if defined(DUK_USE_CPP_EXCEPTIONS)
55822 } catch (duk_internal_exception &exc) {
55823#else
55824 } else {
55825#endif
55826 /* Error; error value is in heap->lj.value1. */
55827
55828#if defined(DUK_USE_CPP_EXCEPTIONS)
55829 DUK_UNREF(exc);
55830#endif
55831
55833 entry_valstack_bottom_index,
55834 entry_valstack_end,
55835 entry_catchstack_top,
55836 entry_callstack_top,
55837 entry_call_recursion_depth,
55838 entry_curr_thread,
55839 entry_thread_state,
55840 entry_ptr_curr_pc,
55841 idx_func,
55842 old_jmpbuf_ptr);
55843
55844 /* Longjmp state is cleaned up by error handling */
55845 DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
55846 DUK_ASSERT(thr->heap->lj.iserror == 0);
55847 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
55848 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
55849 return DUK_EXEC_ERROR;
55850 }
55851#if defined(DUK_USE_CPP_EXCEPTIONS)
55852 catch (std::exception &exc) {
55853 const char *what = exc.what();
55854 if (!what) {
55855 what = "unknown";
55856 }
55857 DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)"));
55858 try {
55859 DUK_ERROR_FMT1(thr, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what);
55860 } catch (duk_internal_exception exc) {
55861 DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception"));
55862 DUK_UNREF(exc);
55864 entry_valstack_bottom_index,
55865 entry_valstack_end,
55866 entry_catchstack_top,
55867 entry_callstack_top,
55868 entry_call_recursion_depth,
55869 entry_curr_thread,
55870 entry_thread_state,
55871 entry_ptr_curr_pc,
55872 idx_func,
55873 old_jmpbuf_ptr);
55874 return DUK_EXEC_ERROR;
55875 }
55876 } catch (...) {
55877 DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)"));
55878 try {
55879 DUK_ERROR_API(thr, "caught invalid c++ exception (perhaps thrown by user code)");
55880 } catch (duk_internal_exception exc) {
55881 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 55883 of file duktape-1.5.2/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 57026 of file duktape-1.5.2/src/duktape.c.

57045 {
57046 duk_context *ctx = (duk_context *) thr;
57047 duk_size_t entry_valstack_bottom_index;
57048 duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
57049 duk_idx_t idx_args; /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */
57050 duk_idx_t nargs; /* # argument registers target function wants (< 0 => never for ecma calls) */
57051 duk_idx_t nregs; /* # total registers target function wants on entry (< 0 => never for ecma calls) */
57052 duk_hobject *func; /* 'func' on stack (borrowed reference) */
57053 duk_tval *tv_func; /* duk_tval ptr for 'func' on stack (borrowed reference) */
57054 duk_activation *act;
57055 duk_hobject *env;
57056 duk_bool_t use_tailcall;
57057 duk_instr_t **entry_ptr_curr_pc;
57058
57059 DUK_ASSERT(thr != NULL);
57060 DUK_ASSERT(ctx != NULL);
57061 DUK_ASSERT(!((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 && (call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0));
57062
57063 /* XXX: assume these? */
57064 DUK_ASSERT(thr->valstack != NULL);
57065 DUK_ASSERT(thr->callstack != NULL);
57066 DUK_ASSERT(thr->catchstack != NULL);
57067
57068 /* no need to handle thread state book-keeping here */
57069 DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ||
57071 thr->heap->curr_thread == thr));
57072
57073 /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc. Then NULL
57074 * thr->ptr_curr_pc so that it's not accidentally used with an incorrect
57075 * activation when side effects occur. If we end up not making the
57076 * call we must restore the value.
57077 */
57078 entry_ptr_curr_pc = thr->ptr_curr_pc;
57080
57081 /* if a tail call:
57082 * - an Ecmascript activation must be on top of the callstack
57083 * - there cannot be any active catchstack entries
57084 */
57085#if defined(DUK_USE_ASSERTIONS)
57086 if (call_flags & DUK_CALL_FLAG_IS_TAILCALL) {
57087 duk_size_t our_callstack_index;
57088 duk_size_t i;
57089
57090 DUK_ASSERT(thr->callstack_top >= 1);
57091 our_callstack_index = thr->callstack_top - 1;
57092 DUK_ASSERT_DISABLE(our_callstack_index >= 0);
57093 DUK_ASSERT(our_callstack_index < thr->callstack_size);
57094 DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index) != NULL);
57096
57097 /* No entry in the catchstack which would actually catch a
57098 * throw can refer to the callstack entry being reused.
57099 * There *can* be catchstack entries referring to the current
57100 * callstack entry as long as they don't catch (e.g. label sites).
57101 */
57102
57103 for (i = 0; i < thr->catchstack_top; i++) {
57104 DUK_ASSERT(thr->catchstack[i].callstack_index < our_callstack_index || /* refer to callstack entries below current */
57105 DUK_CAT_GET_TYPE(thr->catchstack + i) == DUK_CAT_TYPE_LABEL); /* or a non-catching entry */
57106 }
57107 }
57108#endif /* DUK_USE_ASSERTIONS */
57109
57110 entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
57111 /* XXX: rework */
57112 idx_func = duk_normalize_index(thr, -num_stack_args - 2);
57113 idx_args = idx_func + 2;
57114
57115 DUK_DD(DUK_DDPRINT("handle_ecma_call_setup: thr=%p, "
57116 "num_stack_args=%ld, call_flags=0x%08lx (resume=%ld, tailcall=%ld), "
57117 "idx_func=%ld, idx_args=%ld, entry_valstack_bottom_index=%ld",
57118 (void *) thr,
57119 (long) num_stack_args,
57120 (unsigned long) call_flags,
57121 (long) ((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ? 1 : 0),
57122 (long) ((call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0 ? 1 : 0),
57123 (long) idx_func,
57124 (long) idx_args,
57125 (long) entry_valstack_bottom_index));
57126
57127 if (DUK_UNLIKELY(idx_func < 0 || idx_args < 0)) {
57128 /* XXX: assert? compiler is responsible for this never happening */
57130 }
57131
57132 /*
57133 * Check the function type, handle bound function chains, and prepare
57134 * parameters for the rest of the call handling. Also figure out the
57135 * effective 'this' binding, which replaces the current value at
57136 * idx_func + 1.
57137 *
57138 * If the target function is a 'bound' one, follow the chain of 'bound'
57139 * functions until a non-bound function is found. During this process,
57140 * bound arguments are 'prepended' to existing ones, and the "this"
57141 * binding is overridden. See E5 Section 15.3.4.5.1.
57142 *
57143 * If the final target function cannot be handled by an ecma-to-ecma
57144 * call, return to the caller with a return value indicating this case.
57145 * The bound chain is resolved and the caller can resume with a plain
57146 * function call.
57147 */
57148
57149 func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags);
57150 if (func == NULL || !DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
57151 DUK_DDD(DUK_DDDPRINT("final target is a lightfunc/nativefunc, cannot do ecma-to-ecma call"));
57152 thr->ptr_curr_pc = entry_ptr_curr_pc;
57153 return 0;
57154 }
57155 /* XXX: tv_func is not actually needed */
57156
57157 DUK_ASSERT(func != NULL);
57160
57161 duk__coerce_effective_this_binding(thr, func, idx_func + 1);
57162 DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T",
57163 duk_get_tval(ctx, idx_func + 1)));
57164
57165 nargs = ((duk_hcompiledfunction *) func)->nargs;
57166 nregs = ((duk_hcompiledfunction *) func)->nregs;
57167 DUK_ASSERT(nregs >= nargs);
57168
57169 /* [ ... func this arg1 ... argN ] */
57170
57171 /*
57172 * Preliminary activation record and valstack manipulation.
57173 * The concrete actions depend on whether the we're dealing
57174 * with a tail call (reuse an existing activation), a resume,
57175 * or a normal call.
57176 *
57177 * The basic actions, in varying order, are:
57178 *
57179 * - Check stack size for call handling
57180 * - Grow call stack if necessary (non-tail-calls)
57181 * - Update current activation (idx_retval) if necessary
57182 * (non-tail, non-resume calls)
57183 * - Move start of args (idx_args) to valstack bottom
57184 * (tail calls)
57185 *
57186 * Don't touch valstack_bottom or valstack_top yet so that Duktape API
57187 * calls work normally.
57188 */
57189
57190 /* XXX: some overlapping code; cleanup */
57191 use_tailcall = call_flags & DUK_CALL_FLAG_IS_TAILCALL;
57192#if !defined(DUK_USE_TAILCALL)
57193 DUK_ASSERT(use_tailcall == 0); /* compiler ensures this */
57194#endif
57195 if (use_tailcall) {
57196 /* tailcall cannot be flagged to resume calls, and a
57197 * previous frame must exist
57198 */
57199 DUK_ASSERT(thr->callstack_top >= 1);
57200 DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) == 0);
57201
57202 act = thr->callstack + thr->callstack_top - 1;
57203 if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
57204 /* See: test-bug-tailcall-preventyield-assert.c. */
57205 DUK_DDD(DUK_DDDPRINT("tail call prevented by current activation having DUK_ACT_FLAG_PREVENTYIELD"));
57206 use_tailcall = 0;
57207 } else if (DUK_HOBJECT_HAS_NOTAIL(func)) {
57208 DUK_D(DUK_DPRINT("tail call prevented by function having a notail flag"));
57209 use_tailcall = 0;
57210 }
57211 }
57212
57213 if (use_tailcall) {
57214 duk_tval *tv1, *tv2;
57215 duk_size_t cs_index;
57216 duk_int_t i_stk; /* must be signed for loop structure */
57217 duk_idx_t i_arg;
57218
57219 /*
57220 * Tailcall handling
57221 *
57222 * Although the callstack entry is reused, we need to explicitly unwind
57223 * the current activation (or simulate an unwind). In particular, the
57224 * current activation must be closed, otherwise something like
57225 * test-bug-reduce-judofyr.js results. Also catchstack needs be unwound
57226 * because there may be non-error-catching label entries in valid tail calls.
57227 */
57228
57229 DUK_DDD(DUK_DDDPRINT("is tail call, reusing activation at callstack top, at index %ld",
57230 (long) (thr->callstack_top - 1)));
57231
57232 /* 'act' already set above */
57233
57238
57239 /* Unwind catchstack entries referring to the callstack entry we're reusing */
57240 cs_index = thr->callstack_top - 1;
57241 DUK_ASSERT(thr->catchstack_top <= DUK_INT_MAX); /* catchstack limits */
57242 for (i_stk = (duk_int_t) (thr->catchstack_top - 1); i_stk >= 0; i_stk--) {
57243 duk_catcher *cat = thr->catchstack + i_stk;
57244 if (cat->callstack_index != cs_index) {
57245 /* 'i' is the first entry we'll keep */
57246 break;
57247 }
57248 }
57249 duk_hthread_catchstack_unwind(thr, i_stk + 1);
57250
57251 /* Unwind the topmost callstack entry before reusing it */
57252 DUK_ASSERT(thr->callstack_top > 0);
57253 duk_hthread_callstack_unwind(thr, thr->callstack_top - 1);
57254
57255 /* Then reuse the unwound activation; callstack was not shrunk so there is always space */
57256 thr->callstack_top++;
57257 DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
57258 act = thr->callstack + thr->callstack_top - 1;
57259
57260 /* Start filling in the activation */
57261 act->func = func; /* don't want an intermediate exposed state with func == NULL */
57262#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
57263 act->prev_caller = NULL;
57264#endif
57265 DUK_ASSERT(func != NULL);
57267 /* don't want an intermediate exposed state with invalid pc */
57269#if defined(DUK_USE_DEBUGGER_SUPPORT)
57270 act->prev_line = 0;
57271#endif
57272 DUK_TVAL_SET_OBJECT(&act->tv_func, func); /* borrowed, no refcount */
57273#if defined(DUK_USE_REFERENCE_COUNTING)
57274 DUK_HOBJECT_INCREF(thr, func);
57275 act = thr->callstack + thr->callstack_top - 1; /* side effects (currently none though) */
57276#endif
57277
57278#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
57279#if defined(DUK_USE_TAILCALL)
57280#error incorrect options: tail calls enabled with function caller property
57281#endif
57282 /* XXX: this doesn't actually work properly for tail calls, so
57283 * tail calls are disabled when DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
57284 * is in use.
57285 */
57286 duk__update_func_caller_prop(thr, func);
57287 act = thr->callstack + thr->callstack_top - 1;
57288#endif
57289
57290 act->flags = (DUK_HOBJECT_HAS_STRICT(func) ?
57293
57294 DUK_ASSERT(DUK_ACT_GET_FUNC(act) == func); /* already updated */
57295 DUK_ASSERT(act->var_env == NULL); /* already NULLed (by unwind) */
57296 DUK_ASSERT(act->lex_env == NULL); /* already NULLed (by unwind) */
57297 act->idx_bottom = entry_valstack_bottom_index; /* tail call -> reuse current "frame" */
57298 DUK_ASSERT(nregs >= 0);
57299#if 0 /* topmost activation idx_retval is considered garbage, no need to init */
57300 act->idx_retval = 0;
57301#endif
57302
57303 /*
57304 * Manipulate valstack so that args are on the current bottom and the
57305 * previous caller's 'this' binding (which is the value preceding the
57306 * current bottom) is replaced with the new 'this' binding:
57307 *
57308 * [ ... this_old | (crud) func this_new arg1 ... argN ]
57309 * --> [ ... this_new | arg1 ... argN ]
57310 *
57311 * For tail calling to work properly, the valstack bottom must not grow
57312 * here; otherwise crud would accumulate on the valstack.
57313 */
57314
57315 tv1 = thr->valstack_bottom - 1;
57316 tv2 = thr->valstack_bottom + idx_func + 1;
57317 DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); /* tv1 is -below- valstack_bottom */
57318 DUK_ASSERT(tv2 >= thr->valstack_bottom && tv2 < thr->valstack_top);
57319 DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */
57320
57321 for (i_arg = 0; i_arg < idx_args; i_arg++) {
57322 /* XXX: block removal API primitive */
57323 /* Note: 'func' is popped from valstack here, but it is
57324 * already reachable from the activation.
57325 */
57326 duk_remove(ctx, 0);
57327 }
57328 idx_func = 0; DUK_UNREF(idx_func); /* really 'not applicable' anymore, should not be referenced after this */
57329 idx_args = 0;
57330
57331 /* [ ... this_new | arg1 ... argN ] */
57332 } else {
57333 DUK_DDD(DUK_DDDPRINT("not a tail call, pushing a new activation to callstack, to index %ld",
57334 (long) (thr->callstack_top)));
57335
57337
57338 if (call_flags & DUK_CALL_FLAG_IS_RESUME) {
57339 DUK_DDD(DUK_DDDPRINT("is resume -> no update to current activation (may not even exist)"));
57340 } else {
57341 DUK_DDD(DUK_DDDPRINT("update to current activation idx_retval"));
57342 DUK_ASSERT(thr->callstack_top < thr->callstack_size);
57343 DUK_ASSERT(thr->callstack_top >= 1);
57344 act = thr->callstack + thr->callstack_top - 1;
57347 act->idx_retval = entry_valstack_bottom_index + idx_func;
57348 }
57349
57350 DUK_ASSERT(thr->callstack_top < thr->callstack_size);
57351 act = thr->callstack + thr->callstack_top;
57352 thr->callstack_top++;
57353 DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
57354
57358
57359 act->flags = (DUK_HOBJECT_HAS_STRICT(func) ?
57361 0);
57362 act->func = func;
57363 act->var_env = NULL;
57364 act->lex_env = NULL;
57365#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
57366 act->prev_caller = NULL;
57367#endif
57368 DUK_ASSERT(func != NULL);
57371#if defined(DUK_USE_DEBUGGER_SUPPORT)
57372 act->prev_line = 0;
57373#endif
57374 act->idx_bottom = entry_valstack_bottom_index + idx_args;
57375 DUK_ASSERT(nregs >= 0);
57376#if 0 /* topmost activation idx_retval is considered garbage, no need to init */
57377 act->idx_retval = 0;
57378#endif
57379 DUK_TVAL_SET_OBJECT(&act->tv_func, func); /* borrowed, no refcount */
57380
57381 DUK_HOBJECT_INCREF(thr, func); /* act->func */
57382
57383#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
57384 duk__update_func_caller_prop(thr, func);
57385 act = thr->callstack + thr->callstack_top - 1;
57386#endif
57387 }
57388
57389 /* [ ... func this arg1 ... argN ] (not tail call)
57390 * [ this | arg1 ... argN ] (tail call)
57391 *
57392 * idx_args updated to match
57393 */
57394
57395 /*
57396 * Environment record creation and 'arguments' object creation.
57397 * Named function expression name binding is handled by the
57398 * compiler; the compiled function's parent env will contain
57399 * the (immutable) binding already.
57400 *
57401 * Delayed creation (on demand) is handled in duk_js_var.c.
57402 */
57403
57404 /* XXX: unify handling with native call. */
57405
57406 DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */
57407
57408 if (!DUK_HOBJECT_HAS_NEWENV(func)) {
57409 /* use existing env (e.g. for non-strict eval); cannot have
57410 * an own 'arguments' object (but can refer to the existing one)
57411 */
57412
57413 duk__handle_oldenv_for_call(thr, func, act);
57414
57415 DUK_ASSERT(act->lex_env != NULL);
57416 DUK_ASSERT(act->var_env != NULL);
57417 goto env_done;
57418 }
57419
57421
57422 if (!DUK_HOBJECT_HAS_CREATEARGS(func)) {
57423 /* no need to create environment record now; leave as NULL */
57424 DUK_ASSERT(act->lex_env == NULL);
57425 DUK_ASSERT(act->var_env == NULL);
57426 goto env_done;
57427 }
57428
57429 /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */
57431 DUK_ASSERT(env != NULL);
57432
57433 /* [ ... arg1 ... argN envobj ] */
57434
57435 /* original input stack before nargs/nregs handling must be
57436 * intact for 'arguments' object
57437 */
57439 duk__handle_createargs_for_call(thr, func, env, num_stack_args);
57440
57441 /* [ ... arg1 ... argN envobj ] */
57442
57443 act = thr->callstack + thr->callstack_top - 1;
57444 act->lex_env = env;
57445 act->var_env = env;
57446 DUK_HOBJECT_INCREF(thr, act->lex_env);
57447 DUK_HOBJECT_INCREF(thr, act->var_env);
57448 duk_pop(ctx);
57449
57450 env_done:
57451 /* [ ... arg1 ... argN ] */
57452
57453 /*
57454 * Setup value stack: clamp to 'nargs', fill up to 'nregs'
57455 */
57456
57458 num_stack_args,
57459 idx_args,
57460 nregs,
57461 nargs,
57462 func);
57463
DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index)
#define DUK_HOBJECT_HAS_NOTAIL(h)

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 56608 of file duktape-1.5.2/src/duktape.c.

56628 {
56629 duk_context *ctx = (duk_context *) thr;
56630 duk_size_t entry_valstack_bottom_index;
56631 duk_size_t entry_callstack_top;
56632 duk_size_t entry_catchstack_top;
56633 duk_int_t entry_call_recursion_depth;
56634 duk_hthread *entry_curr_thread;
56635 duk_uint_fast8_t entry_thread_state;
56636 duk_instr_t **entry_ptr_curr_pc;
56637 duk_jmpbuf *old_jmpbuf_ptr = NULL;
56638 duk_jmpbuf our_jmpbuf;
56639 duk_idx_t idx_retbase;
56640 duk_int_t retval;
56641
56642 DUK_ASSERT(thr != NULL);
56643 DUK_ASSERT(ctx != NULL);
56644
56645 /* Note: careful with indices like '-x'; if 'x' is zero, it refers to bottom */
56646 entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
56647 entry_callstack_top = thr->callstack_top;
56648 entry_catchstack_top = thr->catchstack_top;
56649 entry_call_recursion_depth = thr->heap->call_recursion_depth;
56650 entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */
56651 entry_thread_state = thr->state;
56652 entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */
56653 idx_retbase = duk_get_top(ctx) - num_stack_args; /* Note: not a valid stack index if num_stack_args == 0 */
56654
56655 /* Note: cannot portably debug print a function pointer, hence 'func' not printed! */
56656 DUK_DD(DUK_DDPRINT("duk_handle_safe_call: thr=%p, num_stack_args=%ld, num_stack_rets=%ld, "
56657 "valstack_top=%ld, idx_retbase=%ld, rec_depth=%ld/%ld, "
56658 "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
56659 "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
56660 (void *) thr,
56661 (long) num_stack_args,
56662 (long) num_stack_rets,
56663 (long) duk_get_top(ctx),
56664 (long) idx_retbase,
56665 (long) thr->heap->call_recursion_depth,
56666 (long) thr->heap->call_recursion_limit,
56667 (long) entry_valstack_bottom_index,
56668 (long) entry_callstack_top,
56669 (long) entry_catchstack_top,
56670 (long) entry_call_recursion_depth,
56671 (void *) entry_curr_thread,
56672 (long) entry_thread_state));
56673
56674 if (idx_retbase < 0) {
56675 /* Since stack indices are not reliable, we can't do anything useful
56676 * here. Invoke the existing setjmp catcher, or if it doesn't exist,
56677 * call the fatal error handler.
56678 */
56679
56681 }
56682
56683 /* setjmp catchpoint setup */
56684
56685 old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
56686 thr->heap->lj.jmpbuf_ptr = &our_jmpbuf;
56687
56688#if defined(DUK_USE_CPP_EXCEPTIONS)
56689 try {
56690#else
56691 DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == &our_jmpbuf);
56692 if (DUK_SETJMP(our_jmpbuf.jb) == 0) {
56693 /* Success path. */
56694#endif
56695 DUK_DDD(DUK_DDDPRINT("safe_call setjmp catchpoint setup complete"));
56696
56698 func,
56699 idx_retbase,
56700 num_stack_rets,
56701 entry_valstack_bottom_index,
56702 entry_callstack_top,
56703 entry_catchstack_top);
56704
56705 /* Longjmp state is kept clean in success path */
56706 DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
56707 DUK_ASSERT(thr->heap->lj.iserror == 0);
56708 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
56709 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
56710
56711 /* Note: either pointer may be NULL (at entry), so don't assert */
56712 thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
56713
56714 retval = DUK_EXEC_SUCCESS;
56715#if defined(DUK_USE_CPP_EXCEPTIONS)
56716 } catch (duk_internal_exception &exc) {
56717 DUK_UNREF(exc);
56718#else
56719 } else {
56720 /* Error path. */
56721#endif
56723 idx_retbase,
56724 num_stack_rets,
56725 entry_valstack_bottom_index,
56726 entry_callstack_top,
56727 entry_catchstack_top,
56728 old_jmpbuf_ptr);
56729
56730 /* Longjmp state is cleaned up by error handling */
56731 DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN);
56732 DUK_ASSERT(thr->heap->lj.iserror == 0);
56733 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1));
56734 DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2));
56735
56736 retval = DUK_EXEC_ERROR;
56737 }
56738#if defined(DUK_USE_CPP_EXCEPTIONS)
56739 catch (std::exception &exc) {
56740 const char *what = exc.what();
56741 if (!what) {
56742 what = "unknown";
56743 }
56744 DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)"));
56745 try {
56746 DUK_ERROR_FMT1(thr, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what);
56747 } catch (duk_internal_exception exc) {
56748 DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception"));
56749 DUK_UNREF(exc);
56751 idx_retbase,
56752 num_stack_rets,
56753 entry_valstack_bottom_index,
56754 entry_callstack_top,
56755 entry_catchstack_top,
56756 old_jmpbuf_ptr);
56757 retval = DUK_EXEC_ERROR;
56758 }
56759 } catch (...) {
56760 DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)"));
56761 try {
56762 DUK_ERROR_API(thr, "caught invalid c++ exception (perhaps thrown by user code)");
56763 } catch (duk_internal_exception exc) {
56764 DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception"));
56765 DUK_UNREF(exc);
56767 idx_retbase,
56768 num_stack_rets,
56769 entry_valstack_bottom_index,
56770 entry_callstack_top,
56771 entry_catchstack_top,
56772 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_has_prop()

DUK_EXTERNAL duk_bool_t duk_has_prop ( duk_context * ctx,
duk_idx_t obj_index )

Definition at line 14525 of file duktape-1.5.2/src/duktape.c.

14529 {
14530 duk_hthread *thr = (duk_hthread *) ctx;
14531
14533 DUK_ASSERT_DISABLE(stridx >= 0);
14535 DUK_UNREF(thr);
14536
14537 obj_index = duk_require_normalize_index(ctx, obj_index);
14538 duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
14539 return duk_del_prop(ctx, obj_index);
14540}
14541
14543 duk_hthread *thr = (duk_hthread *) ctx;
14544 duk_tval *tv_obj;
14545 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 14556 of file duktape-1.5.2/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 14564 of file duktape-1.5.2/src/duktape.c.

14564 {
14566 DUK_ASSERT(key != NULL);
14567
14568 obj_index = duk_require_normalize_index(ctx, obj_index);
14569 duk_push_string(ctx, key);
14570 return duk_has_prop(ctx, obj_index);
14571}
14572
14575

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 14547 of file duktape-1.5.2/src/duktape.c.

◆ duk_has_var()

DUK_EXTERNAL duk_bool_t duk_has_var ( duk_context * ctx)

Definition at line 20000 of file duktape-1.5.2/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 40563 of file duktape-1.5.2/src/duktape.c.

40580 {
40581 duk_hbuffer *res = NULL;
40582 duk_size_t header_size;
40583 duk_size_t alloc_size;
40584
40585 DUK_ASSERT(heap != NULL);
40586 DUK_ASSERT(out_bufdata != NULL);
40587
40588 DUK_DDD(DUK_DDDPRINT("allocate hbuffer"));
40589
40590 /* Size sanity check. Should not be necessary because caller is
40591 * required to check this, but we don't want to cause a segfault
40592 * if the size wraps either in duk_size_t computation or when
40593 * storing the size in a 16-bit field.
40594 */
40595 if (size > DUK_HBUFFER_MAX_BYTELEN) {
40596 DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size));
40597 return NULL; /* no need to write 'out_bufdata' */
40598 }
40599
40600 if (flags & DUK_BUF_FLAG_EXTERNAL) {
40601 header_size = sizeof(duk_hbuffer_external);
40602 alloc_size = sizeof(duk_hbuffer_external);
40603 } else if (flags & DUK_BUF_FLAG_DYNAMIC) {
40604 header_size = sizeof(duk_hbuffer_dynamic);
40605 alloc_size = sizeof(duk_hbuffer_dynamic);
40606 } else {
40607 header_size = sizeof(duk_hbuffer_fixed);
40608 alloc_size = sizeof(duk_hbuffer_fixed) + size;
40609 DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed)); /* no wrapping */
40610 }
40611
40612 res = (duk_hbuffer *) DUK_ALLOC(heap, alloc_size);
40613 if (!res) {
40614 goto error;
40615 }
40616
40617 /* zero everything unless requested not to do so */
40618#if defined(DUK_USE_ZERO_BUFFER_DATA)
40619 DUK_MEMZERO((void *) res,
40620 (flags & DUK_BUF_FLAG_NOZERO) ? header_size : alloc_size);
40621#else
40622 DUK_MEMZERO((void *) res, header_size);
40623#endif
40624
40625 if (flags & DUK_BUF_FLAG_EXTERNAL) {
40627 h = (duk_hbuffer_external *) res;
40628 DUK_UNREF(h);
40629 *out_bufdata = NULL;
40630#if defined(DUK_USE_EXPLICIT_NULL_INIT)
40631#if defined(DUK_USE_HEAPPTR16)
40632/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
40633#else
40635#endif
40636#endif
40638 } else if (flags & DUK_BUF_FLAG_DYNAMIC) {
40640 void *ptr;
40641
40642 if (size > 0) {
40643 DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); /* alloc external with size zero */
40644 DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer"));
40645#ifdef DUK_USE_ZERO_BUFFER_DATA
40646 ptr = DUK_ALLOC_ZEROED(heap, size);
40647#else
40648 ptr = DUK_ALLOC(heap, size);
40649#endif
40650 if (!ptr) {
40651 /* Because size > 0, NULL check is correct */
40652 goto error;
40653 }
40654 *out_bufdata = ptr;
40655
40657 } else {
40658 *out_bufdata = NULL;
40659#if defined(DUK_USE_EXPLICIT_NULL_INIT)
40660#if defined(DUK_USE_HEAPPTR16)
40661/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
40662#else
40664#endif
40665#endif
40667 }
40668 } else {
40669 *out_bufdata = (void *) ((duk_hbuffer_fixed *) res + 1);
40670 }
40671
40672 DUK_HBUFFER_SET_SIZE(res, size);
40673
40675 if (flags & DUK_BUF_FLAG_DYNAMIC) {
#define DUK_BUF_FLAG_NOZERO
#define DUK_BUF_FLAG_DYNAMIC
#define DUK_BUF_FLAG_EXTERNAL
#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, x)
struct duk_hbuffer_dynamic duk_hbuffer_dynamic
#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, x, v)
struct duk_hbuffer_external duk_hbuffer_external
struct duk_hbuffer_fixed duk_hbuffer_fixed
#define DUK_ALLOC_ZEROED(heap, size)
#define DUK_HBUFFER_SET_SIZE(x, v)
#define DUK_HBUFFER_SET_DYNAMIC(x)

◆ duk_hbuffer_get_dynalloc_ptr()

DUK_INTERNAL_DECL void * duk_hbuffer_get_dynalloc_ptr ( duk_heap * heap,
void * ud )

Definition at line 40680 of file duktape-1.5.2/src/duktape.c.

40680 {
40682 }
40683 DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr);
40684
#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, 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 40760 of file duktape-1.5.2/src/duktape.c.

40760 {
40761 DUK_ASSERT(new_size - prev_size > 0);
40762#ifdef DUK_USE_ZERO_BUFFER_DATA
40763 DUK_MEMZERO((void *) ((char *) res + prev_size),
40764 (duk_size_t) (new_size - prev_size));
40765#endif
40766 }
40767

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 40703 of file duktape-1.5.2/src/duktape.c.

40720 {
40721 void *res;
40722 duk_size_t prev_size;
40723
40724 DUK_ASSERT(thr != NULL);
40725 DUK_ASSERT(buf != NULL);
40728
40729 /*
40730 * Maximum size check
40731 */
40732
40733 if (new_size > DUK_HBUFFER_MAX_BYTELEN) {
40734 DUK_ERROR_RANGE(thr, "buffer too long");
40735 }
40736
40737 /*
40738 * Note: use indirect realloc variant just in case mark-and-sweep
40739 * (finalizers) might resize this same buffer during garbage
40740 * collection.
40741 */
40742
40743 res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_size);
40744 if (res != NULL || new_size == 0) {
40745 /* 'res' may be NULL if new allocation size is 0. */
40746
40747 DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld -> %p:%ld",
40748 (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf),
40749 (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf),
40750 (void *) res,
40751 (long) new_size));
40752
40753 /*
40754 * The entire allocated buffer area, regardless of actual used
40755 * size, is kept zeroed in resizes for simplicity. If the buffer
40756 * is grown, zero the new part.
40757 */
40758
DUK_INTERNAL_DECL void * duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud)

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 46048 of file duktape-1.5.2/src/duktape.c.

46051 {
46052 return NULL;
46053 }
46054 DUK_MEMZERO(res, sizeof(duk_hnativefunction));
46055
46056 duk__init_object_parts(heap, &res->obj, hobject_flags);
46057
46058#ifdef DUK_USE_EXPLICIT_NULL_INIT
46059 res->func = NULL;
46060#endif
46061
46062 return res;
46063}
46064
DUK_INTERNAL duk_hbufferobject * duk_hbufferobject_alloc(duk_heap *heap, duk_uint_t hobject_flags)
DUK_LOCAL void duk__init_object_parts(duk_heap *heap, duk_hobject *obj, 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 40772 of file duktape-1.5.2/src/duktape.c.

40777 {
40778 DUK_ASSERT(thr != NULL);
40779 DUK_ASSERT(buf != NULL);
40782
40783 duk_hbuffer_resize(thr, buf, 0);
40784}
40785/* include removed: duk_internal.h */
40786#line 2 "duk_hbufferobject_misc.c"
40787

◆ 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 21915 of file duktape-1.5.2/src/duktape.c.

21932 {
21934
21935 DUK_MEMCPY((void *) du.uc, (const void *) p, (size_t) elem_size);
21936
21937 switch (h_bufobj->elem_type) {
21939#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21941#endif
21942 duk_push_uint(ctx, (duk_uint_t) du.uc[0]);
21943 break;
21944#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21945 /* These are not needed when only Duktape.Buffer is supported. */
21947 duk_push_int(ctx, (duk_int_t) (duk_int8_t) du.uc[0]);
21948 break;
21950 duk_push_uint(ctx, (duk_uint_t) du.us[0]);
21951 break;
21953 duk_push_int(ctx, (duk_int_t) (duk_int16_t) du.us[0]);
21954 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 21956 of file duktape-1.5.2/src/duktape.c.

21958 :
21959 duk_push_int(ctx, (duk_int_t) (duk_int32_t) du.ui[0]);
21960 break;
21962 duk_push_number(ctx, (duk_double_t) du.f[0]);
21963 break;
21965 duk_push_number(ctx, (duk_double_t) du.d);
21966 break;
21967#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
21968 default:
21970 }
21971}
21972
21973DUK_INTERNAL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size) {
21975
21976 /* NOTE! Caller must ensure that any side effects from the
21977 * coercions below are safe. If that cannot be guaranteed
21978 * (which is normally the case), caller must coerce the
21979 * argument using duk_to_number() before any pointer
21980 * validations; the result of duk_to_number() always coerces
21981 * without side effects here.
21982 */
21983
21984 switch (h_bufobj->elem_type) {
21986 du.uc[0] = (duk_uint8_t) duk_to_uint32(ctx, -1);
21987 break;
21988#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21989 /* These are not needed when only Duktape.Buffer is supported. */
21991 du.uc[0] = (duk_uint8_t) duk_to_uint8clamped(ctx, -1);
21992 break;
21994 du.uc[0] = (duk_uint8_t) duk_to_int32(ctx, -1);
21995 break;
21997 du.us[0] = (duk_uint16_t) duk_to_uint32(ctx, -1);
21998 break;
22000 du.us[0] = (duk_uint16_t) duk_to_int32(ctx, -1);
22001 break;
22003 du.ui[0] = (duk_uint32_t) duk_to_uint32(ctx, -1);
DUK_INTERNAL_DECL duk_uint8_t duk_to_uint8clamped(duk_context *ctx, duk_idx_t index)

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 46006 of file duktape-1.5.2/src/duktape.c.

46013 {
46014 return NULL;
46015 }
46016 DUK_MEMZERO(res, sizeof(duk_hobject));
46017
46018 duk__init_object_parts(heap, res, hobject_flags);
46019
46020 return res;
46021}
46022
46025
46026 res = (duk_hcompiledfunction *) DUK_ALLOC(heap, sizeof(duk_hcompiledfunction));
46027 if (!res) {
46028 return NULL;
DUK_INTERNAL_DECL duk_hcompiledfunction * duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags)

◆ 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 41520 of file duktape-1.5.2/src/duktape.c.

41520 : big"));
41521#else
41522 DUK_D(DUK_DPRINT("integer endianness: ???"));
41523#endif
41524#if defined(DUK_USE_DOUBLE_LE)
41525 DUK_D(DUK_DPRINT("IEEE double endianness: little"));
41526#elif defined(DUK_USE_DOUBLE_ME)
41527 DUK_D(DUK_DPRINT("IEEE double endianness: mixed"));
41528#elif defined(DUK_USE_DOUBLE_BE)
41529 DUK_D(DUK_DPRINT("IEEE double endianness: big"));
41530#else
41531 DUK_D(DUK_DPRINT("IEEE double endianness: ???"));
41532#endif
41533}
41534#endif /* DUK_USE_DEBUG */
41535
41536DUK_INTERNAL
41537duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
41538 duk_realloc_function realloc_func,
41539 duk_free_function free_func,
41540 void *heap_udata,
41541 duk_fatal_function fatal_func) {
41542 duk_heap *res = NULL;
41543
41544 /* Silence a few global unused warnings here. */
41545 DUK_UNREF(duk_str_unsupported);
41546
41547 DUK_D(DUK_DPRINT("allocate heap"));
41548
41549 /*
41550 * Debug dump type sizes
41551 */
41552
41553#if defined(DUK_USE_DEBUG)
41554 duk__dump_misc_options();
41555 duk__dump_type_sizes();
41556 duk__dump_type_limits();
41557#endif
41558
41559 /*
41560 * If selftests enabled, run them as early as possible
41561 */
41562#if defined(DUK_USE_SELF_TESTS)
41563 DUK_D(DUK_DPRINT("running self tests"));
41564 duk_selftest_run_tests();
41565 DUK_D(DUK_DPRINT("self tests passed"));
41566#endif
41567
41568 /*
41569 * Computed values (e.g. INFINITY)
41570 */
41571
41572#if defined(DUK_USE_COMPUTED_NAN)
41573 do {
41574 /* Workaround for some exotic platforms where NAN is missing
41575 * and the expression (0.0 / 0.0) does NOT result in a NaN.
41576 * Such platforms use the global 'duk_computed_nan' which must
41577 * be initialized at runtime. Use 'volatile' to ensure that
41578 * the compiler will actually do the computation and not try
41579 * to do constant folding which might result in the original
41580 * problem.
41581 */
41582 volatile double dbl1 = 0.0;
41583 volatile double dbl2 = 0.0;
41584 duk_computed_nan = dbl1 / dbl2;
41585 } while (0);
41586#endif
41587
41588#if defined(DUK_USE_COMPUTED_INFINITY)
41589 do {
41590 /* Similar workaround for INFINITY. */
41591 volatile double dbl1 = 1.0;
41592 volatile double dbl2 = 0.0;
41593 duk_computed_infinity = dbl1 / dbl2;
41594 } while (0);
41595#endif
41596
41597 /*
41598 * Allocate heap struct
41599 *
41600 * Use a raw call, all macros expect the heap to be initialized
41601 */
41602
41603 res = (duk_heap *) alloc_func(heap_udata, sizeof(duk_heap));
41604 if (!res) {
41605 goto error;
41606 }
41607
41608 /*
41609 * Zero the struct, and start initializing roughly in order
41610 */
41611
41612 DUK_MEMZERO(res, sizeof(*res));
41613
41614 /* explicit NULL inits */
41615#if defined(DUK_USE_EXPLICIT_NULL_INIT)
41616 res->heap_udata = NULL;
41617 res->heap_allocated = NULL;
41618#if defined(DUK_USE_REFERENCE_COUNTING)
41619 res->refzero_list = NULL;
41620 res->refzero_list_tail = NULL;
41621#endif
41622#if defined(DUK_USE_MARK_AND_SWEEP)
41623 res->finalize_list = NULL;
41624#endif
41625 res->heap_thread = NULL;
41626 res->curr_thread = NULL;
41627 res->heap_object = NULL;
41628#if defined(DUK_USE_STRTAB_CHAIN)
41629 /* nothing to NULL */
41630#elif defined(DUK_USE_STRTAB_PROBE)
41631#if defined(DUK_USE_HEAPPTR16)
41632 res->strtable16 = (duk_uint16_t *) NULL;
41633#else
41634 res->strtable = (duk_hstring **) NULL;
41635#endif
41636#endif
41637#if defined(DUK_USE_ROM_STRINGS)
41638 /* no res->strs[] */
41639#else /* DUK_USE_ROM_STRINGS */
41640#if defined(DUK_USE_HEAPPTR16)
41641 /* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */
41642#else
41643 {
41644 duk_small_uint_t i;
41645 for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
41646 res->strs[i] = NULL;
41647 }
41648 }
41649#endif
41650#endif /* DUK_USE_ROM_STRINGS */
41651#if defined(DUK_USE_DEBUGGER_SUPPORT)
41652 res->dbg_read_cb = NULL;
41653 res->dbg_write_cb = NULL;
41654 res->dbg_peek_cb = NULL;
41655 res->dbg_read_flush_cb = NULL;
41656 res->dbg_write_flush_cb = NULL;
41657 res->dbg_request_cb = NULL;
41658 res->dbg_udata = NULL;
41659 res->dbg_step_thread = NULL;
41660#endif
41661#endif /* DUK_USE_EXPLICIT_NULL_INIT */
41662
41663 res->alloc_func = alloc_func;
41664 res->realloc_func = realloc_func;
41665 res->free_func = free_func;
41666 res->heap_udata = heap_udata;
41667 res->fatal_func = fatal_func;
41668
41669#if defined(DUK_USE_HEAPPTR16)
41670 /* XXX: zero assumption */
41671 res->heapptr_null16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) NULL);
41672 res->heapptr_deleted16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) DUK_STRTAB_DELETED_MARKER(res));
41673#endif
41674
41675 /* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */
41676
41677 res->call_recursion_depth = 0;
41678 res->call_recursion_limit = DUK_USE_NATIVE_CALL_RECLIMIT;
41679
41680 /* XXX: use the pointer as a seed for now: mix in time at least */
41681
41682 /* The casts through duk_intr_pt is to avoid the following GCC warning:
41683 *
41684 * warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
41685 *
41686 * This still generates a /Wp64 warning on VS2010 when compiling for x86.
41687 */
41688#if defined(DUK_USE_ROM_STRINGS)
41689 /* XXX: make a common DUK_USE_ option, and allow custom fixed seed? */
41690 DUK_D(DUK_DPRINT("using rom strings, force heap hash_seed to fixed value 0x%08lx", (long) DUK__FIXED_HASH_SEED));
41691 res->hash_seed = (duk_uint32_t) DUK__FIXED_HASH_SEED;
41692#else /* DUK_USE_ROM_STRINGS */
41693 res->hash_seed = (duk_uint32_t) (duk_intptr_t) res;
41694 res->rnd_state = (duk_uint32_t) (duk_intptr_t) res;
41695#if !defined(DUK_USE_STRHASH_DENSE)
41696 res->hash_seed ^= 5381; /* Bernstein hash init value is normally 5381; XOR it in in case pointer low bits are 0 */
41697#endif
41698#endif /* DUK_USE_ROM_STRINGS */
41699
41700#if defined(DUK_USE_EXPLICIT_NULL_INIT)
41701 res->lj.jmpbuf_ptr = NULL;
41702#endif
41703 DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN); /* zero */
41704
41705 DUK_TVAL_SET_UNDEFINED(&res->lj.value1);
41706 DUK_TVAL_SET_UNDEFINED(&res->lj.value2);
41707
41708#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME)
41709#error initial heap stringtable size is defined incorrectly
41710#endif
41711
41712 /*
41713 * Init stringtable: fixed variant
41714 */
41715
41716#if defined(DUK_USE_STRTAB_CHAIN)
41717 DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE);
41718#if defined(DUK_USE_EXPLICIT_NULL_INIT)
41719 {
41720 duk_small_uint_t i;
41721 for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
41722#if defined(DUK_USE_HEAPPTR16)
41723 res->strtable[i].u.str16 = res->heapptr_null16;
41724#else
41725 res->strtable[i].u.str = NULL;
41726#endif
41727 }
41728 }
41729#endif /* DUK_USE_EXPLICIT_NULL_INIT */
41730#endif /* DUK_USE_STRTAB_CHAIN */
41731
41732 /*
41733 * Init stringtable: probe variant
41734 */
41735
41736#if defined(DUK_USE_STRTAB_PROBE)
41737#if defined(DUK_USE_HEAPPTR16)
41738 res->strtable16 = (duk_uint16_t *) alloc_func(heap_udata, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
41739 if (!res->strtable16) {
41740 goto error;
41741 }
41742#else /* DUK_USE_HEAPPTR16 */
41743 res->strtable = (duk_hstring **) alloc_func(heap_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
41744 if (!res->strtable) {
41745 goto error;
41746 }
41747#endif /* DUK_USE_HEAPPTR16 */
41748 res->st_size = DUK_STRTAB_INITIAL_SIZE;
41749#if defined(DUK_USE_EXPLICIT_NULL_INIT)
41750 {
41751 duk_small_uint_t i;
41752 DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE);
41753 for (i = 0; i < DUK_STRTAB_INITIAL_SIZE; i++) {
41754#if defined(DUK_USE_HEAPPTR16)
41755 res->strtable16[i] = res->heapptr_null16;
41756#else
41757 res->strtable[i] = NULL;
41758#endif
41759 }
41760 }
41761#else /* DUK_USE_EXPLICIT_NULL_INIT */
41762#if defined(DUK_USE_HEAPPTR16)
41763 DUK_MEMZERO(res->strtable16, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
41764#else
41765 DUK_MEMZERO(res->strtable, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
41766#endif
41767#endif /* DUK_USE_EXPLICIT_NULL_INIT */
41768#endif /* DUK_USE_STRTAB_PROBE */
41769
41770 /*
41771 * Init stringcache
41772 */
41773
41774#if defined(DUK_USE_EXPLICIT_NULL_INIT)
41775 {
41776 duk_small_uint_t i;
41777 for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
41778 res->strcache[i].h = NULL;
41779 }
41780 }
41781#endif
41782
41783 /* XXX: error handling is incomplete. It would be cleanest if
41784 * there was a setjmp catchpoint, so that all init code could
41785 * freely throw errors. If that were the case, the return code
41786 * passing here could be removed.
41787 */
41788
41789 /*
41790 * Init built-in strings
41791 */
41792
41793 DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS"));
41794 if (!duk__init_heap_strings(res)) {
41795 goto error;
41796 }
41797
41798 /*
41799 * Init the heap thread
41800 */
41801
41802 DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD"));
41803 if (!duk__init_heap_thread(res)) {
41804 goto error;
41805 }
41806
41807 /*
41808 * Init the heap object
41809 */
41810
41811 DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT"));
41812 DUK_ASSERT(res->heap_thread != NULL);
41813 res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE |
41814 DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT));
41815 if (!res->heap_object) {
41816 goto error;
41817 }
41818 DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object);
41819
41820 /*
41821 * All done
41822 */
41823

◆ duk_heap_force_strtab_resize()

DUK_INTERNAL_DECL void duk_heap_force_strtab_resize ( duk_heap * heap)

Definition at line 45807 of file duktape-1.5.2/src/duktape.c.

45824 {
45825 duk_small_uint_t prev_mark_and_sweep_base_flags;
45826 /* 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 41061 of file duktape-1.5.2/src/duktape.c.

41064 {
41065 DUK_D(DUK_DPRINT("no more finalizable objects, forced finalization finished"));
41066 break;
41067 }
41068 if (count_finalized >= curr_limit) {
41069 DUK_D(DUK_DPRINT("finalizer count above limit, potentially runaway finalizer; skip remaining finalizers"));
41070 break;
41071 }
41072 }
41073
41076}
41077
41079 DUK_D(DUK_DPRINT("free heap: %p", (void *) heap));
41080
41081#if defined(DUK_USE_DEBUG)
41082 duk_heap_dump_strtab(heap);
41083#endif
41084
41085#if defined(DUK_USE_DEBUGGER_SUPPORT)
41086 /* Detach a debugger if attached (can be called multiple times)
41087 * safely.
41088 */
41089 /* XXX: Add a flag to reject an attempt to re-attach? Otherwise
41090 * the detached callback may immediately reattach.
41091 */
41092 duk_debug_do_detach(heap);
41093#endif
41094
41095 /* Execute finalizers before freeing the heap, even for reachable
41096 * objects, and regardless of whether or not mark-and-sweep is
41097 * enabled. This gives finalizers the chance to free any native
41098 * resources like file handles, allocations made outside Duktape,
41099 * etc. This is quite tricky to get right, so that all finalizer
41100 * guarantees are honored.
41101 *
41102 * XXX: this perhaps requires an execution time limit.
41103 */
41104 DUK_D(DUK_DPRINT("execute finalizers before freeing heap"));
41105#if defined(DUK_USE_MARK_AND_SWEEP)
41106 /* Run mark-and-sweep a few times just in case (unreachable object
41107 * finalizers run already here). The last round must rescue objects
41108 * from the previous round without running any more finalizers. This
41109 * ensures rescued objects get their FINALIZED flag cleared so that
41110 * their finalizer is called once more in forced finalization to
41111 * satisfy finalizer guarantees. However, we don't want to run any
41112 * more finalizer because that'd required one more loop, and so on.
41113 */
41114 DUK_D(DUK_DPRINT("forced gc #1 in heap destruction"));
41115 duk_heap_mark_and_sweep(heap, 0);
41116 DUK_D(DUK_DPRINT("forced gc #2 in heap destruction"));
41117 duk_heap_mark_and_sweep(heap, 0);
41118 DUK_D(DUK_DPRINT("forced gc #3 in heap destruction (don't run finalizers)"));
41119 duk_heap_mark_and_sweep(heap, DUK_MS_FLAG_SKIP_FINALIZERS); /* skip finalizers; queue finalizable objects to heap_allocated */
41120#endif
41121
41122 DUK_HEAP_SET_FINALIZER_NORESCUE(heap); /* rescue no longer supported */
41124
41125 /* Note: heap->heap_thread, heap->curr_thread, and heap->heap_object
41126 * are on the heap allocated list.
41127 */
41128
41129 DUK_D(DUK_DPRINT("freeing heap objects of heap: %p", (void *) heap));
41130 duk__free_allocated(heap);
#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap)
#define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap)
DUK_LOCAL void duk__free_allocated(duk_heap *heap)
DUK_INTERNAL_DECL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags)
DUK_INTERNAL_DECL void duk_heap_free(duk_heap *heap)

◆ duk_heap_free_heaphdr_raw()

DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw ( duk_heap * heap,
duk_heaphdr * hdr )

Definition at line 40876 of file duktape-1.5.2/src/duktape.c.

40877 {
40878 DUK_ASSERT(heap != NULL);
40879 DUK_ASSERT(h != NULL);
40880
40881 DUK_UNREF(heap);
40882 DUK_UNREF(h);
40883
40884#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_FREE)
40885 if (DUK_HSTRING_HAS_EXTDATA(h)) {
40886 DUK_DDD(DUK_DDDPRINT("free extstr: hstring %!O, extdata: %p",
40887 h, DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h)));
40888 DUK_USE_EXTSTR_FREE(heap->heap_udata, (const void *) DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h));
40889 }
40890#endif
40891}
40892
40894 DUK_ASSERT(heap);
40895 DUK_ASSERT(hdr);
40896
40897 DUK_DDD(DUK_DDDPRINT("free heaphdr %p, htype %ld", (void *) hdr, (long) DUK_HEAPHDR_GET_TYPE(hdr)));
#define DUK_HSTRING_HAS_EXTDATA(x)

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 45893 of file duktape-1.5.2/src/duktape.c.

45899 {
45900 duk_free_hstring_inner(heap, h);
45901 DUK_FREE(heap, h);
45902 }
45903 }
45904 e->listlen = 0;
45905 }
45906}
45907#endif /* DUK_USE_STRTAB_CHAIN */
45908
45909#if defined(DUK_USE_STRTAB_PROBE)
45912 duk_hstring *h;
45913
45914#if defined(DUK_USE_HEAPPTR16)
45915 if (heap->strtable16) {
45916#else
45917 if (heap->strtable) {
45918#endif
45919 for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
45920#if defined(DUK_USE_HEAPPTR16)
45921 h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
45922#else
45923 h = heap->strtable[i];
45924#endif
45925 if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
45926 continue;
45927 }
45928 DUK_ASSERT(h != NULL);
45929
DUK_INTERNAL_DECL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h)

◆ 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 41920 of file duktape-1.5.2/src/duktape.c.

41937 {
41938 duk_uint32_t hash;
41939 duk_size_t step;
41940 duk_size_t off;
41941
41942 /* Slightly modified "Bernstein hash" from:
41943 *
41944 * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
41945 *
41946 * Modifications: string skipping and reverse direction similar to
41947 * Lua 5.1.5, and different hash initializer.
41948 *
41949 * The reverse direction ensures last byte it always included in the
41950 * hash which is a good default as changing parts of the string are
41951 * 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 43792 of file duktape-1.5.2/src/duktape.c.

43793 {
43794 heap->heap_allocated = DUK_HEAPHDR_GET_NEXT(heap, hdr);
43795 }
43796 if (DUK_HEAPHDR_GET_NEXT(heap, hdr)) {
43798 } else {
43799 ;
43800 }
43801
43802 /* The prev/next pointers of the removed duk_heaphdr are left as garbage.
43803 * It's up to the caller to ensure they're written before inserting the
43804 * 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 43104 of file duktape-1.5.2/src/duktape.c.

43121 {
43122 duk_hthread *thr;
43123 duk_size_t count_keep_obj;
43124 duk_size_t count_keep_str;
43125#ifdef DUK_USE_VOLUNTARY_GC
43126 duk_size_t tmp;
43127#endif
43128
43129 /* XXX: thread selection for mark-and-sweep is currently a hack.
43130 * If we don't have a thread, the entire mark-and-sweep is now
43131 * skipped (although we could just skip finalizations).
43132 */
43133
43134 /* If thr != NULL, the thr may still be in the middle of
43135 * initialization.
43136 * XXX: Improve the thread viability test.
43137 */
43138 thr = duk__get_temp_hthread(heap);
43139 if (thr == NULL) {
43140 DUK_D(DUK_DPRINT("gc skipped because we don't have a temp thread"));
43141
43142 /* reset voluntary gc trigger count */
43143#ifdef DUK_USE_VOLUNTARY_GC
43145#endif
43146 return 0; /* OK */
43147 }
43148
43149 /* If debugger is paused, garbage collection is disabled by default. */
43150 /* XXX: will need a force flag if garbage collection is triggered
43151 * explicitly during paused state.
43152 */
43153#if defined(DUK_USE_DEBUGGER_SUPPORT)
43154 if (DUK_HEAP_IS_PAUSED(heap)) {
43155 /* Checking this here rather that in memory alloc primitives
43156 * reduces checking code there but means a failed allocation
43157 * will go through a few retries before giving up. That's
43158 * fine because this only happens during debugging.
43159 */
43160 DUK_D(DUK_DPRINT("gc skipped because debugger is paused"));
43161 return 0;
43162 }
43163#endif
43164
43165 DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) starting, requested flags: 0x%08lx, effective flags: 0x%08lx",
43166 (unsigned long) flags, (unsigned long) (flags | heap->mark_and_sweep_base_flags)));
43167
43168 flags |= heap->mark_and_sweep_base_flags;
43169
43170 /*
43171 * Assertions before
43172 */
43173
43174#ifdef DUK_USE_ASSERTIONS
43178 duk__assert_heaphdr_flags(heap);
43179#ifdef DUK_USE_REFERENCE_COUNTING
43180 /* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount
43181 * finalizer may trigger a mark-and-sweep.
43182 */
43183 duk__assert_valid_refcounts(heap);
43184#endif /* DUK_USE_REFERENCE_COUNTING */
43185#endif /* DUK_USE_ASSERTIONS */
43186
43187 /*
43188 * Begin
43189 */
43190
43192
43193 /*
43194 * Mark roots, hoping that recursion limit is not normally hit.
43195 * If recursion limit is hit, run additional reachability rounds
43196 * starting from "temproots" until marking is complete.
43197 *
43198 * Marking happens in two phases: first we mark actual reachability
43199 * roots (and run "temproots" to complete the process). Then we
43200 * check which objects are unreachable and are finalizable; such
43201 * objects are marked as FINALIZABLE and marked as reachability
43202 * (and "temproots" is run again to complete the process).
43203 *
43204 * The heap finalize_list must also be marked as a reachability root.
43205 * There may be objects on the list from a previous round if the
43206 * previous run had finalizer skip flag.
43207 */
43208
43209 duk__mark_roots_heap(heap); /* main reachability roots */
43210#ifdef DUK_USE_REFERENCE_COUNTING
43211 duk__mark_refzero_list(heap); /* refzero_list treated as reachability roots */
43212#endif
43213 duk__mark_temproots_by_heap_scan(heap); /* temproots */
43214
43215 duk__mark_finalizable(heap); /* mark finalizable as reachability roots */
43216 duk__mark_finalize_list(heap); /* mark finalizer work list as reachability roots */
43217 duk__mark_temproots_by_heap_scan(heap); /* temproots */
43218
43219 /*
43220 * Sweep garbage and remove marking flags, and move objects with
43221 * finalizers to the finalizer work list.
43222 *
43223 * Objects to be swept need to get their refcounts finalized before
43224 * they are swept. In other words, their target object refcounts
43225 * need to be decreased. This has to be done before freeing any
43226 * objects to avoid decref'ing dangling pointers (which may happen
43227 * even without bugs, e.g. with reference loops)
43228 *
43229 * Because strings don't point to other heap objects, similar
43230 * finalization is not necessary for strings.
43231 */
43232
43233 /* XXX: more emergency behavior, e.g. find smaller hash sizes etc */
43234
43235#ifdef DUK_USE_REFERENCE_COUNTING
43237#endif
43238 duk__sweep_heap(heap, flags, &count_keep_obj);
43239#if defined(DUK_USE_STRTAB_CHAIN)
43240 duk__sweep_stringtable_chain(heap, &count_keep_str);
43241#elif defined(DUK_USE_STRTAB_PROBE)
43242 duk__sweep_stringtable_probe(heap, &count_keep_str);
43243#else
43244#error internal error, invalid strtab options
43245#endif
43246#ifdef DUK_USE_REFERENCE_COUNTING
43248#endif
43250
43251 /*
43252 * Object compaction (emergency only).
43253 *
43254 * Object compaction is a separate step after sweeping, as there is
43255 * more free memory for it to work with. Also, currently compaction
43256 * may insert new objects into the heap allocated list and the string
43257 * table which we don't want to do during a sweep (the reachability
43258 * flags of such objects would be incorrect). The objects inserted
43259 * are currently:
43260 *
43261 * - a temporary duk_hbuffer for a new properties allocation
43262 * - if array part is abandoned, string keys are interned
43263 *
43264 * The object insertions go to the front of the list, so they do not
43265 * cause an infinite loop (they are not compacted).
43266 */
43267
43268 if ((flags & DUK_MS_FLAG_EMERGENCY) &&
43271 }
43272
43273 /*
43274 * String table resize check.
43275 *
43276 * Note: this may silently (and safely) fail if GC is caused by an
43277 * allocation call in stringtable resize_hash(). Resize_hash()
43278 * will prevent a recursive call to itself by setting the
43279 * DUK_MS_FLAG_NO_STRINGTABLE_RESIZE in heap->mark_and_sweep_base_flags.
43280 */
43281
43282 /* XXX: stringtable emergency compaction? */
43283
43284 /* XXX: remove this feature entirely? it would only matter for
43285 * emergency GC. Disable for lowest memory builds.
43286 */
43287#if defined(DUK_USE_MS_STRINGTABLE_RESIZE)
43288 if (!(flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE)) {
43289 DUK_DD(DUK_DDPRINT("resize stringtable: %p", (void *) heap));
43291 } else {
43292 DUK_D(DUK_DPRINT("stringtable resize skipped because DUK_MS_FLAG_NO_STRINGTABLE_RESIZE is set"));
43293 }
43294#endif
43295
43296 /*
43297 * Finalize objects in the finalization work list. Finalized
43298 * objects are queued back to heap_allocated with FINALIZED set.
43299 *
43300 * Since finalizers may cause arbitrary side effects, they are
43301 * prevented during string table and object property allocation
43302 * resizing using the DUK_MS_FLAG_NO_FINALIZERS flag in
43303 * heap->mark_and_sweep_base_flags. In this case the objects
43304 * remain in the finalization work list after mark-and-sweep
43305 * exits and they may be finalized on the next pass.
43306 *
43307 * Finalization currently happens inside "MARKANDSWEEP_RUNNING"
43308 * protection (no mark-and-sweep may be triggered by the
43309 * finalizers). As a side effect:
43310 *
43311 * 1) an out-of-memory error inside a finalizer will not
43312 * cause a mark-and-sweep and may cause the finalizer
43313 * to fail unnecessarily
43314 *
43315 * 2) any temporary objects whose refcount decreases to zero
43316 * during finalization will not be put into refzero_list;
43317 * they can only be collected by another mark-and-sweep
43318 *
43319 * This is not optimal, but since the sweep for this phase has
43320 * already happened, this is probably good enough for now.
43321 */
43322
43323#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE)
43324 /* Cannot simulate individual finalizers because finalize_list only
43325 * contains objects with actual finalizers. But simulate side effects
43326 * from finalization by doing a bogus function call and resizing the
43327 * stacks.
43328 */
43329 if (flags & DUK_MS_FLAG_NO_FINALIZERS) {
43330 DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, DUK_MS_FLAG_NO_FINALIZERS is set"));
43331 } else if (!(thr->valstack != NULL && thr->callstack != NULL && thr->catchstack != NULL)) {
43332 DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, thread not yet viable"));
43333 } else {
43334 DUK_D(DUK_DPRINT("run mark-and-sweep torture finalizer"));
43335 duk__markandsweep_torture_finalizer(thr);
43336 }
43337#endif /* DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE */
43338
43339 if (flags & DUK_MS_FLAG_NO_FINALIZERS) {
43340 DUK_D(DUK_DPRINT("finalizer run skipped because DUK_MS_FLAG_NO_FINALIZERS is set"));
43341 } else {
43342 duk__run_object_finalizers(heap, flags);
43343 }
43344
43345 /*
43346 * Finish
43347 */
43348
43350
43351 /*
43352 * Assertions after
43353 */
43354
43355#ifdef DUK_USE_ASSERTIONS
43359 duk__assert_heaphdr_flags(heap);
43360#ifdef DUK_USE_REFERENCE_COUNTING
43361 /* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount
43362 * finalizer may trigger a mark-and-sweep.
43363 */
43364 duk__assert_valid_refcounts(heap);
43365#endif /* DUK_USE_REFERENCE_COUNTING */
43366#endif /* DUK_USE_ASSERTIONS */
43367
43368 /*
#define DUK_MS_FLAG_EMERGENCY
DUK_LOCAL void duk__clear_refzero_list_flags(duk_heap *heap)
DUK_LOCAL void duk__finalize_refcounts(duk_heap *heap)
DUK_LOCAL void duk__mark_finalizable(duk_heap *heap)
DUK_LOCAL void duk__mark_refzero_list(duk_heap *heap)
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP
DUK_LOCAL void duk__clear_finalize_list_flags(duk_heap *heap)
DUK_INTERNAL_DECL void duk_heap_force_strtab_resize(duk_heap *heap)

◆ duk_heap_mem_alloc()

DUK_INTERNAL_DECL void * duk_heap_mem_alloc ( duk_heap * heap,
duk_size_t size )

Definition at line 43420 of file duktape-1.5.2/src/duktape.c.

43437 {
43438 void *res;
43439 duk_bool_t rc;
43441
43442 DUK_ASSERT(heap != NULL);
43443 DUK_ASSERT_DISABLE(size >= 0);
43444
43445 /*
43446 * Voluntary periodic GC (if enabled)
43447 */
43448
43450
43451 /*
43452 * First attempt
43453 */
43454
43455#ifdef DUK_USE_GC_TORTURE
43456 /* simulate alloc failure on every alloc (except when mark-and-sweep is running) */
43458 DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first alloc attempt fails"));
43459 res = NULL;
43460 DUK_UNREF(res);
43461 goto skip_attempt;
43462 }
43463#endif
43464 res = heap->alloc_func(heap->heap_udata, size);
43465 if (res || size == 0) {
43466 /* for zero size allocations NULL is allowed */
43467 return res;
43468 }
43469#ifdef DUK_USE_GC_TORTURE
43470 skip_attempt:
43471#endif
43472
43473 DUK_D(DUK_DPRINT("first alloc attempt failed, attempt to gc and retry"));
43474
43475 /*
43476 * Avoid a GC if GC is already running. This can happen at a late
43477 * stage in a GC when we try to e.g. resize the stringtable
43478 * or compact objects.
43479 */
43480
43482 DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed, gc in progress (gc skipped), alloc size %ld", (long) size));
43483 return NULL;
43484 }
43485
43486 /*
43487 * Retry with several GC attempts. Initial attempts are made without
43488 * emergency mode; later attempts use emergency mode which minimizes
43489 * memory allocations forcibly.
43490 */
43491
43492 for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
43493 duk_small_uint_t flags;
43494
43495 flags = 0;
#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT
#define DUK__VOLUNTARY_PERIODIC_GC(heap)
#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT

◆ duk_heap_mem_alloc_zeroed()

DUK_INTERNAL_DECL void * duk_heap_mem_alloc_zeroed ( duk_heap * heap,
duk_size_t size )

Definition at line 43510 of file duktape-1.5.2/src/duktape.c.

43519 {
43520 DUK_ASSERT(heap != NULL);
43521 DUK_ASSERT_DISABLE(size >= 0);
43522

◆ duk_heap_mem_free()

DUK_INTERNAL_DECL void duk_heap_mem_free ( duk_heap * heap,
void * ptr )

Definition at line 43730 of file duktape-1.5.2/src/duktape.c.

43737 {
43738 return heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
43739}
43740#endif /* DUK_USE_MARK_AND_SWEEP */
43741
43742/*
43743 * Free memory
43744 */
43745
43746#ifdef DUK_USE_MARK_AND_SWEEP
43747DUK_INTERNAL void duk_heap_mem_free(duk_heap *heap, void *ptr) {
DUK_INTERNAL_DECL 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 43529 of file duktape-1.5.2/src/duktape.c.

43534 {
43535 /* assume memset with zero size is OK */
43536 DUK_MEMZERO(res, size);
43537 }
43538 return res;
43539}
43540
43541/*
43542 * Reallocate memory with garbage collection
43543 */
43544
43545#ifdef DUK_USE_MARK_AND_SWEEP
43546DUK_INTERNAL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize) {
43547 void *res;
43548 duk_bool_t rc;
43550
43551 DUK_ASSERT(heap != NULL);
43552 /* ptr may be NULL */
43553 DUK_ASSERT_DISABLE(newsize >= 0);
43554
43555 /*
43556 * Voluntary periodic GC (if enabled)
43557 */
43558
43560
43561 /*
43562 * First attempt
43563 */
43564
43565#ifdef DUK_USE_GC_TORTURE
43566 /* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
43568 DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first realloc attempt fails"));
43569 res = NULL;
43570 DUK_UNREF(res);
43571 goto skip_attempt;
43572 }
43573#endif
43574 res = heap->realloc_func(heap->heap_udata, ptr, newsize);
43575 if (res || newsize == 0) {
43576 /* for zero size allocations NULL is allowed */
43577 return res;
43578 }
43579#ifdef DUK_USE_GC_TORTURE
43580 skip_attempt:
43581#endif
43582
43583 DUK_D(DUK_DPRINT("first realloc attempt failed, attempt to gc and retry"));
43584
43585 /*
43586 * Avoid a GC if GC is already running. See duk_heap_mem_alloc().
43587 */
43588
43590 DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
43591 return NULL;
43592 }
43593
43594 /*
43595 * Retry with several GC attempts. Initial attempts are made without
43596 * emergency mode; later attempts use emergency mode which minimizes
43597 * memory allocations forcibly.
43598 */
43599
43600 for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
43601 duk_small_uint_t flags;
43602
43603 flags = 0;
DUK_INTERNAL_DECL void * duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize)

◆ 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 43623 of file duktape-1.5.2/src/duktape.c.

43624 {
43625 DUK_ASSERT(heap != NULL);
43626 /* ptr may be NULL */
43627 DUK_ASSERT_DISABLE(newsize >= 0);
43628
43629 return heap->realloc_func(heap->heap_udata, ptr, newsize);
43630}
43631#endif /* DUK_USE_MARK_AND_SWEEP */
43632
43633/*
43634 * Reallocate memory with garbage collection, using a callback to provide
43635 * the current allocated pointer. This variant is used when a mark-and-sweep
43636 * (e.g. finalizers) might change the original pointer.
43637 */
43638
43639#ifdef DUK_USE_MARK_AND_SWEEP
43641 void *res;
43642 duk_bool_t rc;
43644
43645 DUK_ASSERT(heap != NULL);
43646 DUK_ASSERT_DISABLE(newsize >= 0);
43647
43648 /*
43649 * Voluntary periodic GC (if enabled)
43650 */
43651
43653
43654 /*
43655 * First attempt
43656 */
43657
43658#ifdef DUK_USE_GC_TORTURE
43659 /* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
43661 DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first indirect realloc attempt fails"));
43662 res = NULL;
43663 DUK_UNREF(res);
43664 goto skip_attempt;
43665 }
43666#endif
43667 res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
43668 if (res || newsize == 0) {
43669 /* for zero size allocations NULL is allowed */
43670 return res;
43671 }
43672#ifdef DUK_USE_GC_TORTURE
43673 skip_attempt:
43674#endif
43675
43676 DUK_D(DUK_DPRINT("first indirect realloc attempt failed, attempt to gc and retry"));
43677
43678 /*
43679 * Avoid a GC if GC is already running. See duk_heap_mem_alloc().
43680 */
43681
43683 DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
43684 return NULL;
43685 }
43686
43687 /*
43688 * Retry with several GC attempts. Initial attempts are made without
43689 * emergency mode; later attempts use emergency mode which minimizes
43690 * memory allocations forcibly.
43691 */
43692
43693 for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
43694 duk_small_uint_t flags;
43695
43696#ifdef DUK_USE_ASSERTIONS
43697 void *ptr_pre; /* ptr before mark-and-sweep */
43698 void *ptr_post;
43699#endif
43700
43701#ifdef DUK_USE_ASSERTIONS
43702 ptr_pre = cb(heap, ud);
43703#endif
43704 flags = 0;
43706 flags |= DUK_MS_FLAG_EMERGENCY;
43707 }
43708
43709 rc = duk_heap_mark_and_sweep(heap, flags);
43710 DUK_UNREF(rc);
43711#ifdef DUK_USE_ASSERTIONS
43712 ptr_post = cb(heap, ud);
43713 if (ptr_pre != ptr_post) {
43714 /* useful for debugging */
43715 DUK_DD(DUK_DDPRINT("note: base pointer changed by mark-and-sweep: %p -> %p",
43716 (void *) ptr_pre, (void *) ptr_post));
43717 }
DUK_INTERNAL_DECL void * duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize)
void *(* duk_mem_getptr)(duk_heap *heap, void *ud)

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 43771 of file duktape-1.5.2/src/duktape.c.

◆ 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 44544 of file duktape-1.5.2/src/duktape.c.

44561 {
44562 duk_heap *heap;
44563 duk_strcache *sce;
44564 duk_uint_fast32_t byte_offset;
44566 duk_bool_t use_cache;
44567 duk_uint_fast32_t dist_start, dist_end, dist_sce;
44568 const duk_uint8_t *p_start;
44569 const duk_uint8_t *p_end;
44570 const duk_uint8_t *p_found;
44571
44572 if (char_offset > DUK_HSTRING_GET_CHARLEN(h)) {
44573 goto error;
44574 }
44575
44576 /*
44577 * For ASCII strings, the answer is simple.
44578 */
44579
44580 if (DUK_HSTRING_IS_ASCII(h)) {
44581 /* clen == blen -> pure ascii */
44582 return char_offset;
44583 }
44584
44585 /*
44586 * For non-ASCII strings, we need to scan forwards or backwards
44587 * from some starting point. The starting point may be the start
44588 * or end of the string, or some cached midpoint in the string
44589 * cache.
44590 *
44591 * For "short" strings we simply scan without checking or updating
44592 * the cache. For longer strings we check and update the cache as
44593 * necessary, inserting a new cache entry if none exists.
44594 */
44595
44596 DUK_DDD(DUK_DDDPRINT("non-ascii string %p, char_offset=%ld, clen=%ld, blen=%ld",
44597 (void *) h, (long) char_offset,
44598 (long) DUK_HSTRING_GET_CHARLEN(h),
44599 (long) DUK_HSTRING_GET_BYTELEN(h)));
44600
44601 heap = thr->heap;
44602 sce = NULL;
44604
44605 if (use_cache) {
44606#ifdef DUK_USE_DDDPRINT
44607 DUK_DDD(DUK_DDDPRINT("stringcache before char2byte (using cache):"));
44608 for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
44609 duk_strcache *c = heap->strcache + i;
44610 DUK_DDD(DUK_DDDPRINT(" [%ld] -> h=%p, cidx=%ld, bidx=%ld",
44611 (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx));
44612 }
44613#endif
44614
44615 for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
44616 duk_strcache *c = heap->strcache + i;
44617
44618 if (c->h == h) {
44619 sce = c;
44620 break;
44621 }
44622 }
44623 }
44624
44625 /*
44626 * Scan from shortest distance:
44627 * - start of string
44628 * - end of string
44629 * - cache entry (if exists)
44630 */
44631
44632 DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h) >= char_offset);
44633 dist_start = char_offset;
44634 dist_end = DUK_HSTRING_GET_CHARLEN(h) - char_offset;
44635 dist_sce = 0; DUK_UNREF(dist_sce); /* initialize for debug prints, needed if sce==NULL */
44636
44637 p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
44638 p_end = (const duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h));
44639 p_found = NULL;
44640
44641 if (sce) {
44642 if (char_offset >= sce->cidx) {
44643 dist_sce = char_offset - sce->cidx;
44644 if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
44645 DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
44646 "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
44647 "scan forwards from sce",
44648 (long) use_cache, (void *) (sce ? sce->h : NULL),
44649 (sce ? (long) sce->cidx : (long) -1),
44650 (sce ? (long) sce->bidx : (long) -1),
44651 (long) dist_start, (long) dist_end, (long) dist_sce));
44652
44653 p_found = duk__scan_forwards(p_start + sce->bidx,
44654 p_end,
44655 dist_sce);
44656 goto scan_done;
44657 }
44658 } else {
44659 dist_sce = sce->cidx - char_offset;
44660 if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
44661 DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
44662 "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
44663 "scan backwards from sce",
44664 (long) use_cache, (void *) (sce ? sce->h : NULL),
44665 (sce ? (long) sce->cidx : (long) -1),
44666 (sce ? (long) sce->bidx : (long) -1),
44667 (long) dist_start, (long) dist_end, (long) dist_sce));
44668
44669 p_found = duk__scan_backwards(p_start + sce->bidx,
44670 p_start,
44671 dist_sce);
44672 goto scan_done;
44673 }
44674 }
44675 }
44676
44677 /* no sce, or sce scan not best */
44678
44679 if (dist_start <= dist_end) {
44680 DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
44681 "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
44682 "scan forwards from string start",
44683 (long) use_cache, (void *) (sce ? sce->h : NULL),
44684 (sce ? (long) sce->cidx : (long) -1),
44685 (sce ? (long) sce->bidx : (long) -1),
44686 (long) dist_start, (long) dist_end, (long) dist_sce));
44687
44688 p_found = duk__scan_forwards(p_start,
44689 p_end,
44690 dist_start);
44691 } else {
44692 DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
44693 "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
44694 "scan backwards from string end",
44695 (long) use_cache, (void *) (sce ? sce->h : NULL),
44696 (sce ? (long) sce->cidx : (long) -1),
44697 (sce ? (long) sce->bidx : (long) -1),
44698 (long) dist_start, (long) dist_end, (long) dist_sce));
44699
44700 p_found = duk__scan_backwards(p_end,
44701 p_start,
44702 dist_end);
44703 }
44704
44705 scan_done:
44706
44707 if (!p_found) {
44708 /* Scan error: this shouldn't normally happen; it could happen if
44709 * string is not valid UTF-8 data, and clen/blen are not consistent
44710 * with the scanning algorithm.
44711 */
44712 goto error;
44713 }
44714
44715 DUK_ASSERT(p_found >= p_start);
44716 DUK_ASSERT(p_found <= p_end); /* may be equal */
44717 byte_offset = (duk_uint32_t) (p_found - p_start);
44718
44719 DUK_DDD(DUK_DDDPRINT("-> string %p, cidx %ld -> bidx %ld",
44720 (void *) h, (long) char_offset, (long) byte_offset));
44721
44722 /*
44723 * Update cache entry (allocating if necessary), and move the
44724 * cache entry to the first place (in an "LRU" policy).
44725 */
44726
44727 if (use_cache) {
44728 /* update entry, allocating if necessary */
44729 if (!sce) {
44730 sce = heap->strcache + DUK_HEAP_STRCACHE_SIZE - 1; /* take last entry */
44731 sce->h = h;
44732 }
44733 DUK_ASSERT(sce != NULL);
44734 sce->bidx = (duk_uint32_t) (p_found - p_start);
44735 sce->cidx = (duk_uint32_t) char_offset;
44736
44737 /* LRU: move our entry to first */
44738 if (sce > &heap->strcache[0]) {
44739 /*
44740 * A C
44741 * B A
44742 * C <- sce ==> B
44743 * D D
44744 */
44745 duk_strcache tmp;
44746
44747 tmp = *sce;
44748 DUK_MEMMOVE((void *) (&heap->strcache[1]),
44749 (const void *) (&heap->strcache[0]),
44750 (size_t) (((char *) sce) - ((char *) &heap->strcache[0])));
44751 heap->strcache[0] = tmp;
44752
44753 /* 'sce' points to the wrong entry here, but is no longer used */
#define DUK_HSTRING_IS_ASCII(x)
DUK_LOCAL const duk_uint8_t * duk__scan_forwards(const duk_uint8_t *p, const duk_uint8_t *q, duk_uint_fast32_t n)
#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT
#define DUK_HEAP_STRCACHE_SIZE
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_strcache strcache[DUK_HEAP_STRCACHE_SIZE]

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 )

◆ 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 45734 of file duktape-1.5.2/src/duktape.c.

45745 {
45746 duk_uint32_t strhash; /* dummy */
45747 return duk__do_lookup(heap, str, blen, &strhash);
45748}

◆ 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 45750 of file duktape-1.5.2/src/duktape.c.

45751 {
45752 duk_hstring *res;
45753 duk_uint32_t strhash;
45754
45755 /* caller is responsible for ensuring this */

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 45768 of file duktape-1.5.2/src/duktape.c.

45769 {
45771 }
45772 return res;
45773}
45774

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 45776 of file duktape-1.5.2/src/duktape.c.

45776 {
45777 char buf[DUK_STRTAB_U32_MAX_STRLEN+1];
45778 DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val);
45779 buf[sizeof(buf) - 1] = (char) 0;
45780 DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX); /* formatted result limited */
45781 return duk_heap_string_lookup(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf));
45782}
#define DUK_STRTAB_U32_MAX_STRLEN

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 45786 of file duktape-1.5.2/src/duktape.c.

45793 {
45794 duk_hstring *res = duk_heap_string_intern_u32(thr->heap, val);
45795 if (!res) {
45797 }
45798 return res;
45799}
45800
45801/* find and remove string from stringtable; caller must free the string itself */
45802#if defined(DUK_USE_REFERENCE_COUNTING)
DUK_INTERNAL_DECL 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 44411 of file duktape-1.5.2/src/duktape.c.

44417 {
44418 if (h == NULL) {
44419 return;
44420 }
44423
44425}
44426#endif
44427

◆ duk_heaphdr_decref_allownull()

DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull ( duk_hthread * thr,
duk_heaphdr * h )

Definition at line 44429 of file duktape-1.5.2/src/duktape.c.

44436 {
44437 return;
44438 }
44439#endif
44440 if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
44441 return;
44442 }
44443 duk_heaphdr_refzero(thr, h);
44444}
44445
44447 DUK_ASSERT(thr != NULL);
44448 DUK_ASSERT(thr->heap != NULL);
DUK_INTERNAL_DECL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h)

◆ duk_heaphdr_refcount_finalize()

DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize ( duk_hthread * thr,
duk_heaphdr * hdr )

Definition at line 43995 of file duktape-1.5.2/src/duktape.c.

43999 {
44000 duk_catcher *cat = t->catchstack + i;
44001 }
44002#endif
44003
44004 for (i = 0; i < DUK_NUM_BUILTINS; i++) {
44005 duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->builtins[i]);
44006 }
44007
44008 duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->resumer);
44009 }
44010}

◆ duk_heaphdr_refzero()

DUK_INTERNAL_DECL void duk_heaphdr_refzero ( duk_hthread * thr,
duk_heaphdr * h )

Definition at line 44249 of file duktape-1.5.2/src/duktape.c.

44266 {
44267 duk_heap *heap;
44268
44269 DUK_ASSERT(thr != NULL);
44270 DUK_ASSERT(h != NULL);
44271
44272 heap = thr->heap;
44273 DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h));
44274
44275 /*
44276 * Refzero handling is skipped entirely if (1) mark-and-sweep is
44277 * running or (2) execution is paused in the debugger. The objects
44278 * are left in the heap, and will be freed by mark-and-sweep or
44279 * eventual heap destruction.
44280 *
44281 * This is necessary during mark-and-sweep because refcounts are also
44282 * updated during the sweep phase (otherwise objects referenced by a
44283 * swept object would have incorrect refcounts) which then calls here.
44284 * This could be avoided by using separate decref macros in
44285 * mark-and-sweep; however, mark-and-sweep also calls finalizers which
44286 * would use the ordinary decref macros anyway and still call this
44287 * function.
44288 *
44289 * This check must be enabled also when mark-and-sweep support has been
44290 * disabled: the flag is also used in heap destruction when running
44291 * finalizers for remaining objects, and the flag prevents objects from
44292 * being moved around in heap linked lists.
44293 */
44294
44295 /* XXX: ideally this would be just one flag (maybe a derived one) so
44296 * that a single bit test is sufficient to check the condition.
44297 */
44298#if defined(DUK_USE_DEBUGGER_SUPPORT)
44299 if (DUK_UNLIKELY(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap) || DUK_HEAP_IS_PAUSED(heap))) {
44300#else
44302#endif
44303 DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h));
44304 return;
44305 }
44306
44308 case DUK_HTYPE_STRING:
44309 /*
44310 * Strings have no internal references but do have "weak"
44311 * references in the string cache. Also note that strings
44312 * are not on the heap_allocated list like other heap
44313 * elements.
44314 */
44315
44319 break;
44320
44321 case DUK_HTYPE_OBJECT:
44322 /*
44323 * Objects have internal references. Must finalize through
44324 * the "refzero" work list.
44325 */
44326
44328 duk__queue_refzero(heap, h);
44330 break;
DUK_LOCAL void duk__queue_refzero(duk_heap *heap, duk_heaphdr *hdr)
DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr)
DUK_INTERNAL_DECL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr)

◆ duk_hex_decode()

DUK_EXTERNAL void duk_hex_decode ( duk_context * ctx,
duk_idx_t index )

Definition at line 13437 of file duktape-1.5.2/src/duktape.c.

13454 {
13455 duk_hthread *thr = (duk_hthread *) ctx;
13456 const duk_uint8_t *inp;
13457 duk_size_t len;
13458 duk_size_t i;
13459 duk_int_t t;
13460 duk_uint8_t *buf;
13461#if defined(DUK_USE_HEX_FASTPATH)
13462 duk_int_t chk;
13463 duk_uint8_t *p;
13464 duk_size_t len_safe;
13465#endif
13466
13468
13470 inp = duk__prep_codec_arg(ctx, index, &len);
13471 DUK_ASSERT(inp != NULL || len == 0);
13472
13473 if (len & 0x01) {
13474 goto type_error;
13475 }
13476
13477 /* Fixed buffer, no zeroing because we'll fill all the data. */
13478 buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len / 2, DUK_BUF_FLAG_NOZERO /*flags*/);
13479 DUK_ASSERT(buf != NULL);
13480
13481#if defined(DUK_USE_HEX_FASTPATH)
13482 p = buf;
13483 len_safe = len & ~0x07U;
13484 for (i = 0; i < len_safe; i += 8) {
13485 t = ((duk_int_t) duk_hex_dectab_shift4[inp[i]]) |
13486 ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
13487 chk = t;
13488 p[0] = (duk_uint8_t) t;
13489 t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 2]]) |
13490 ((duk_int_t) duk_hex_dectab[inp[i + 3]]);
13491 chk |= t;
13492 p[1] = (duk_uint8_t) t;
13493 t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 4]]) |
13494 ((duk_int_t) duk_hex_dectab[inp[i + 5]]);
13495 chk |= t;
13496 p[2] = (duk_uint8_t) t;
13497 t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 6]]) |
13498 ((duk_int_t) duk_hex_dectab[inp[i + 7]]);
13499 chk |= t;
13500 p[3] = (duk_uint8_t) t;
13501 p += 4;
13502
13503 /* Check if any lookup above had a negative result. */
13504 if (DUK_UNLIKELY(chk < 0)) {
13505 goto type_error;
13506 }
13507 }
13508 for (; i < len; i += 2) {
13509 t = (((duk_int_t) duk_hex_dectab[inp[i]]) << 4) |
13510 ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
13511 if (DUK_UNLIKELY(t < 0)) {
13512 goto type_error;
13513 }
13514 *p++ = (duk_uint8_t) t;
13515 }
13516#else /* DUK_USE_HEX_FASTPATH */
13517 for (i = 0; i < len; i += 2) {
13518 /* For invalid characters the value -1 gets extended to
13519 * at least 16 bits. If either nybble is invalid, the
DUK_EXTERNAL void * duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags)
DUK_INTERNAL const duk_int16_t duk_hex_dectab_shift4[256]

◆ duk_hex_encode()

DUK_EXTERNAL const char * duk_hex_encode ( duk_context * ctx,
duk_idx_t index )

Definition at line 13381 of file duktape-1.5.2/src/duktape.c.

13385 {
13386 goto type_error;
13387 }
13388
13389 /* XXX: convert to fixed buffer? */
13390 (void) duk_resize_buffer(ctx, -1, (duk_size_t) (dst_final - dst));
13391 duk_replace(ctx, index);
13392 return;
13393
13394 type_error:
13396}
13397
13399 const duk_uint8_t *inp;
13400 duk_size_t len;
13401 duk_size_t i;
13402 duk_uint8_t *buf;
13403 const char *ret;
13404#if defined(DUK_USE_HEX_FASTPATH)
13405 duk_size_t len_safe;
13406 duk_uint16_t *p16;
13407#endif
13408
13410
13412 inp = duk__prep_codec_arg(ctx, index, &len);
13413 DUK_ASSERT(inp != NULL || len == 0);
13414
13415 /* Fixed buffer, no zeroing because we'll fill all the data. */
13416 buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len * 2, DUK_BUF_FLAG_NOZERO /*flags*/);
13417 DUK_ASSERT(buf != NULL);
13418
13419#if defined(DUK_USE_HEX_FASTPATH)
13420 DUK_ASSERT((((duk_size_t) buf) & 0x01U) == 0); /* pointer is aligned, guaranteed for fixed buffer */
13421 p16 = (duk_uint16_t *) (void *) buf;
13422 len_safe = len & ~0x03U;
13423 for (i = 0; i < len_safe; i += 4) {
13424 p16[0] = duk_hex_enctab[inp[i]];
13425 p16[1] = duk_hex_enctab[inp[i + 1]];
13426 p16[2] = duk_hex_enctab[inp[i + 2]];
13427 p16[3] = duk_hex_enctab[inp[i + 3]];
13428 p16 += 4;
13429 }
13430 for (; i < len; i++) {
13431 *p16++ = duk_hex_enctab[inp[i]];
13432 }
13433#else /* DUK_USE_HEX_FASTPATH */
13434 for (i = 0; i < len; i++) {
#define DUK_STR_DECODE_FAILED
DUK_EXTERNAL void * duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size)

◆ duk_hnativefunction_alloc()

DUK_INTERNAL_DECL duk_hnativefunction * duk_hnativefunction_alloc ( duk_heap * heap,
duk_uint_t hobject_flags )

Definition at line 46030 of file duktape-1.5.2/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 45985 of file duktape-1.5.2/src/duktape.c.

45985 : empty objects consume a minimum
45986 * amount of memory. Further, an initial allocation might fail and cause
45987 * 'obj' to "leak" (require a mark-and-sweep) since it is not reachable yet.
45988 */
45989}
45990
45991/*
45992 * Allocate an duk_hobject.
45993 *
45994 * The allocated object has no allocation for properties; the caller may
45995 * want to force a resize if a desired size is known.
45996 *
45997 * The allocated object has zero reference count and is not reachable.
45998 * The caller MUST make the object reachable and increase its reference
45999 * count before invoking any operation that might require memory allocation.
46000 */
46001
46003 duk_hobject *res;
46004
DUK_INTERNAL_DECL duk_hobject * duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags)

◆ duk_hobject_compact_props()

DUK_INTERNAL_DECL void duk_hobject_compact_props ( duk_hthread * thr,
duk_hobject * obj )

Definition at line 48219 of file duktape-1.5.2/src/duktape.c.

48236 {
48237 duk_uint32_t e_size; /* currently used -> new size */
48238 duk_uint32_t a_size; /* currently required */
48239 duk_uint32_t a_used; /* actually used */
48240 duk_uint32_t h_size;
48241 duk_bool_t abandon_array;
48242
48243 DUK_ASSERT(thr != NULL);
48244 DUK_ASSERT(obj != NULL);
48245
48246#if defined(DUK_USE_ROM_OBJECTS)
48248 DUK_DD(DUK_DDPRINT("ignore attempt to compact a rom object"));
48249 return;
48250 }
48251#endif
48252
48253 e_size = duk__count_used_e_keys(thr, obj);
48254 duk__compute_a_stats(thr, obj, &a_used, &a_size);
48255
48256 DUK_DD(DUK_DDPRINT("compacting hobject, used e keys %ld, used a keys %ld, min a size %ld, "
48257 "resized array density would be: %ld/%ld = %lf",
48258 (long) e_size, (long) a_used, (long) a_size,
48259 (long) a_used, (long) a_size,
48260 (double) a_used / (double) a_size));
48261
48262 if (duk__abandon_array_density_check(a_used, a_size)) {
48263 DUK_DD(DUK_DDPRINT("decided to abandon array during compaction, a_used=%ld, a_size=%ld",
48264 (long) a_used, (long) a_size));
48265 abandon_array = 1;
48266 e_size += a_used;
48267 a_size = 0;
48268 } else {
48269 DUK_DD(DUK_DDPRINT("decided to keep array during compaction"));
48270 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 51866 of file duktape-1.5.2/src/duktape.c.

51883 {
51884 duk_context *ctx = (duk_context *) thr;
51885 duk_int_t e_idx;
51886 duk_int_t h_idx;
51887
51888 DUK_DDD(DUK_DDDPRINT("define new accessor (internal): thr=%p, obj=%!O, key=%!O, "
51889 "getter=%!O, setter=%!O, flags=0x%02lx",
51890 (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key,
51891 (duk_heaphdr *) getter, (duk_heaphdr *) setter,
51892 (unsigned long) propflags));
51893
51894 DUK_ASSERT(thr != NULL);
51895 DUK_ASSERT(thr->heap != NULL);
51896 DUK_ASSERT(obj != NULL);
51897 DUK_ASSERT(key != NULL);
51898 DUK_ASSERT((propflags & ~DUK_PROPDESC_FLAGS_MASK) == 0);
51899 /* setter and/or getter may be NULL */
51901

◆ 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 52182 of file duktape-1.5.2/src/duktape.c.

52184 : Ecmascript compliant [[DefineOwnProperty]](P, Desc, Throw) is not
52185 * implemented directly, but Object.defineProperty() serves its purpose.
52186 * We don't need the [[DefineOwnProperty]] internally and we don't have a
52187 * property descriptor with 'missing values' so it's easier to avoid it
52188 * entirely.
52189 *
52190 * Note: this is only called for actual objects, not primitive values.
52191 * This must support virtual properties for full objects (e.g. Strings)
52192 * but not for plain values (e.g. strings). Lightfuncs, even though
52193 * primitive in a sense, are treated like objects and accepted as target
52194 * values.
52195 */
52196
52197/* XXX: this is a major target for size optimization */
52198DUK_INTERNAL
52199void duk_hobject_define_property_helper(duk_context *ctx,
52200 duk_uint_t defprop_flags,
52201 duk_hobject *obj,
52202 duk_hstring *key,
52203 duk_idx_t idx_value,
52204 duk_hobject *get,
52205 duk_hobject *set) {
52206 duk_hthread *thr = (duk_hthread *) ctx;
52207 duk_uint32_t arr_idx;
52208 duk_tval tv;
52209 duk_bool_t has_enumerable;
52210 duk_bool_t has_configurable;
52211 duk_bool_t has_writable;
52212 duk_bool_t has_value;
52213 duk_bool_t has_get;
52214 duk_bool_t has_set;
52215 duk_bool_t is_enumerable;
52216 duk_bool_t is_configurable;
52217 duk_bool_t is_writable;
52218 duk_bool_t throw_flag;
52219 duk_bool_t force_flag;
52220 duk_small_uint_t new_flags;
52221 duk_propdesc curr;
52222 duk_uint32_t arridx_new_array_length; /* != 0 => post-update for array 'length' (used when key is an array index) */
52223 duk_uint32_t arrlen_old_len;
52224 duk_uint32_t arrlen_new_len;
52225 duk_bool_t pending_write_protect;
52226
52227 DUK_ASSERT(thr != NULL);
52228 DUK_ASSERT(thr->heap != NULL);
52229 DUK_ASSERT(ctx != NULL);
52230 DUK_ASSERT(obj != NULL);
52231 DUK_ASSERT(key != NULL);
52232 /* idx_value may be < 0 (no value), set and get may be NULL */
52233
52234 DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
52235
52236 /* All the flags fit in 16 bits, so will fit into duk_bool_t. */
52237
52238 has_writable = (defprop_flags & DUK_DEFPROP_HAVE_WRITABLE);
52239 has_enumerable = (defprop_flags & DUK_DEFPROP_HAVE_ENUMERABLE);
52240 has_configurable = (defprop_flags & DUK_DEFPROP_HAVE_CONFIGURABLE);
52241 has_value = (defprop_flags & DUK_DEFPROP_HAVE_VALUE);
52242 has_get = (defprop_flags & DUK_DEFPROP_HAVE_GETTER);
52243 has_set = (defprop_flags & DUK_DEFPROP_HAVE_SETTER);
52244 is_writable = (defprop_flags & DUK_DEFPROP_WRITABLE);
52245 is_enumerable = (defprop_flags & DUK_DEFPROP_ENUMERABLE);
52246 is_configurable = (defprop_flags & DUK_DEFPROP_CONFIGURABLE);
52247 throw_flag = 1; /* Object.defineProperty() calls [[DefineOwnProperty]] with Throw=true */
52248 force_flag = (defprop_flags & DUK_DEFPROP_FORCE);
52249
52250 arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
52251
52252 arridx_new_array_length = 0;
52253 pending_write_protect = 0;
52254 arrlen_old_len = 0;
52255 arrlen_new_len = 0;
52256
52257 DUK_DDD(DUK_DDDPRINT("has_enumerable=%ld is_enumerable=%ld "
52258 "has_configurable=%ld is_configurable=%ld "
52259 "has_writable=%ld is_writable=%ld "
52260 "has_value=%ld value=%!T "
52261 "has_get=%ld get=%p=%!O "
52262 "has_set=%ld set=%p=%!O "
52263 "arr_idx=%ld",
52264 (long) has_enumerable, (long) is_enumerable,
52265 (long) has_configurable, (long) is_configurable,
52266 (long) has_writable, (long) is_writable,
52267 (long) has_value, (duk_tval *) (idx_value >= 0 ? duk_get_tval(ctx, idx_value) : NULL),
52268 (long) has_get, (void *) get, (duk_heaphdr *) get,
52269 (long) has_set, (void *) set, (duk_heaphdr *) set,
52270 (long) arr_idx));
52271
52272 /*
52273 * Array exotic behaviors can be implemented at this point. The local variables
52274 * are essentially a 'value copy' of the input descriptor (Desc), which is modified
52275 * by the Array [[DefineOwnProperty]] (E5 Section 15.4.5.1).
52276 */
52277
52278 if (!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) {
52279 goto skip_array_exotic;
52280 }
52281
52282 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
52283 /* E5 Section 15.4.5.1, step 3, steps a - i are implemented here, j - n at the end */
52284 if (!has_value) {
52285 DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', but no value in descriptor -> normal behavior"));
52286 goto skip_array_exotic;
52287 }
52288
52289 DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', value present in descriptor -> exotic behavior"));
52290
52291 /*
52292 * Get old and new length
52293 */
52294
52295 /* Note: reuse 'curr' as a temp propdesc */
52296 arrlen_old_len = duk__get_old_array_length(thr, obj, &curr);
52297
52298 duk_dup(ctx, idx_value);
52299 arrlen_new_len = duk__to_new_array_length_checked(thr);
52300 duk_push_u32(ctx, arrlen_new_len);
52301 duk_replace(ctx, idx_value); /* step 3.e: replace 'Desc.[[Value]]' */
52302
52303 DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) arrlen_old_len, (long) arrlen_new_len));
52304
52305 if (arrlen_new_len >= arrlen_old_len) {
52306 /* standard behavior, step 3.f.i */
52307 DUK_DDD(DUK_DDDPRINT("new length is same or higher as previous => standard behavior"));
52308 goto skip_array_exotic;
52309 }
52310 DUK_DDD(DUK_DDDPRINT("new length is smaller than previous => exotic post behavior"));
52311
52312 /* XXX: consolidated algorithm step 15.f -> redundant? */
52313 if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && !force_flag) {
52314 /* Note: 'curr' refers to 'length' propdesc */
52315 goto fail_not_writable_array_length;
52316 }
52317
52318 /* steps 3.h and 3.i */
52319 if (has_writable && !is_writable) {
52320 DUK_DDD(DUK_DDDPRINT("desc writable is false, force it back to true, and flag pending write protect"));
52321 is_writable = 1;
52322 pending_write_protect = 1;
52323 }
52324
52325 /* remaining actual steps are carried out if standard DefineOwnProperty succeeds */
52326 } else if (arr_idx != DUK__NO_ARRAY_INDEX) {
52327 /* XXX: any chance of unifying this with the 'length' key handling? */
52328
52329 /* E5 Section 15.4.5.1, step 4 */
52330 duk_uint32_t old_len;
52331
52332 /* Note: use 'curr' as a temp propdesc */
52333 old_len = duk__get_old_array_length(thr, obj, &curr);
52334
52335 if (arr_idx >= old_len) {
52336 DUK_DDD(DUK_DDDPRINT("defineProperty requires array length update "
52337 "(arr_idx=%ld, old_len=%ld)",
52338 (long) arr_idx, (long) old_len));
52339
52340 if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
52341 /* Note: 'curr' refers to 'length' propdesc */
52342 goto fail_not_writable_array_length;
52343 }
52344
52345 /* actual update happens once write has been completed without
52346 * error below.
52347 */
52348 DUK_ASSERT(arr_idx != 0xffffffffUL);
52349 arridx_new_array_length = arr_idx + 1;
52350 } else {
52351 DUK_DDD(DUK_DDDPRINT("defineProperty does not require length update "
52352 "(arr_idx=%ld, old_len=%ld) -> standard behavior",
52353 (long) arr_idx, (long) old_len));
52354 }
52355 }
52356 skip_array_exotic:
52357
52358 /* XXX: There is currently no support for writing buffer object
52359 * indexed elements here. Attempt to do so will succeed and
52360 * write a concrete property into the buffer object. This should
52361 * be fixed at some point but because buffers are a custom feature
52362 * anyway, this is relatively unimportant.
52363 */
52364
52365 /*
52366 * Actual Object.defineProperty() default algorithm.
52367 */
52368
52369 /*
52370 * First check whether property exists; if not, simple case. This covers
52371 * steps 1-4.
52372 */
52373
52374 if (!duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE)) {
52375 DUK_DDD(DUK_DDDPRINT("property does not exist"));
52376
52377 if (!DUK_HOBJECT_HAS_EXTENSIBLE(obj) && !force_flag) {
52378 goto fail_not_extensible;
52379 }
52380
52381 /* XXX: share final setting code for value and flags? difficult because
52382 * refcount code is different. Share entry allocation? But can't allocate
52383 * until array index checked.
52384 */
52385
52386 /* steps 4.a and 4.b are tricky */
52387 if (has_set || has_get) {
52388 duk_int_t e_idx;
52389
52390 DUK_DDD(DUK_DDDPRINT("create new accessor property"));
52391
52392 DUK_ASSERT(has_set || set == NULL);
52393 DUK_ASSERT(has_get || get == NULL);
52394 DUK_ASSERT(!has_value);
52395 DUK_ASSERT(!has_writable);
52396
52397 new_flags = DUK_PROPDESC_FLAG_ACCESSOR; /* defaults, E5 Section 8.6.1, Table 7 */
52398 if (has_enumerable && is_enumerable) {
52399 new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
52400 }
52401 if (has_configurable && is_configurable) {
52402 new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
52403 }
52404
52405 if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
52406 DUK_DDD(DUK_DDDPRINT("accessor cannot go to array part, abandon array"));
52408 }
52409
52410 /* write to entry part */
52411 e_idx = duk__alloc_entry_checked(thr, obj, key);
52412 DUK_ASSERT(e_idx >= 0);
52413
52414 DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, e_idx, get);
52415 DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, e_idx, set);
52418
52419 DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags);
52420 goto success_exotics;
52421 } else {
52422 duk_int_t e_idx;
52423 duk_tval *tv2;
52424
52425 DUK_DDD(DUK_DDDPRINT("create new data property"));
52426
52427 DUK_ASSERT(!has_set);
52428 DUK_ASSERT(!has_get);
52429
52430 new_flags = 0; /* defaults, E5 Section 8.6.1, Table 7 */
52431 if (has_writable && is_writable) {
52432 new_flags |= DUK_PROPDESC_FLAG_WRITABLE;
52433 }
52434 if (has_enumerable && is_enumerable) {
52435 new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
52436 }
52437 if (has_configurable && is_configurable) {
52438 new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
52439 }
52440 if (has_value) {
52441 duk_tval *tv_tmp = duk_require_tval(ctx, idx_value);
52442 DUK_TVAL_SET_TVAL(&tv, tv_tmp);
52443 } else {
52444 DUK_TVAL_SET_UNDEFINED(&tv); /* default value */
52445 }
52446
52447 if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
52448 if (new_flags == DUK_PROPDESC_FLAGS_WEC) {
52449#if 0
52450 DUK_DDD(DUK_DDDPRINT("new data property attributes match array defaults, attempt to write to array part"));
52451 /* may become sparse...*/
52452#endif
52453 /* XXX: handling for array part missing now; this doesn't affect
52454 * compliance but causes array entry writes using defineProperty()
52455 * to always abandon array part.
52456 */
52457 }
52458 DUK_DDD(DUK_DDDPRINT("new data property cannot go to array part, abandon array"));
52460 /* fall through */
52461 }
52462
52463 /* write to entry part */
52464 e_idx = duk__alloc_entry_checked(thr, obj, key);
52465 DUK_ASSERT(e_idx >= 0);
52466 tv2 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
52467 DUK_TVAL_SET_TVAL(tv2, &tv);
52468 DUK_TVAL_INCREF(thr, tv2);
52469
52470 DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags);
52471 goto success_exotics;
52472 }
52474 }
52475
52476 /* we currently assume virtual properties are not configurable (as none of them are) */
52477 DUK_ASSERT((curr.e_idx >= 0 || curr.a_idx >= 0) || !(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE));
52478
52479 /* [obj key desc value get set curr_value] */
52480
52481 /*
52482 * Property already exists. Steps 5-6 detect whether any changes need
52483 * to be made.
52484 */
52485
52486 if (has_enumerable) {
52487 if (is_enumerable) {
52488 if (!(curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE)) {
52489 goto need_check;
52490 }
52491 } else {
52492 if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) {
52493 goto need_check;
52494 }
52495 }
52496 }
52497 if (has_configurable) {
52498 if (is_configurable) {
52499 if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
52500 goto need_check;
52501 }
52502 } else {
52503 if (curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) {
52504 goto need_check;
52505 }
52506 }
52507 }
52508 if (has_value) {
52509 duk_tval *tmp1;
52510 duk_tval *tmp2;
52511
52512 /* attempt to change from accessor to data property */
52513 if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
52514 goto need_check;
52515 }
52516
52517 tmp1 = duk_require_tval(ctx, -1); /* curr value */
52518 tmp2 = duk_require_tval(ctx, idx_value); /* new value */
52519 if (!duk_js_samevalue(tmp1, tmp2)) {
52520 goto need_check;
52521 }
52522 }
52523 if (has_writable) {
52524 /* attempt to change from accessor to data property */
52525 if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
52526 goto need_check;
52527 }
52528
52529 if (is_writable) {
52530 if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
52531 goto need_check;
52532 }
52533 } else {
52534 if (curr.flags & DUK_PROPDESC_FLAG_WRITABLE) {
52535 goto need_check;
52536 }
52537 }
52538 }
52539 if (has_set) {
52540 if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
52541 if (set != curr.set) {
52542 goto need_check;
52543 }
52544 } else {
52545 goto need_check;
52546 }
52547 }
52548 if (has_get) {
52549 if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
52550 if (get != curr.get) {
52551 goto need_check;
52552 }
52553 } else {
52554 goto need_check;
52555 }
52556 }
52557
52558 /* property exists, either 'desc' is empty, or all values
52559 * match (SameValue)
52560 */
52561 goto success_no_exotics;
52562
52563 need_check:
52564
52565 /*
52566 * Some change(s) need to be made. Steps 7-11.
52567 */
52568
52569 /* shared checks for all descriptor types */
52570 if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
52571 if (has_configurable && is_configurable) {
52572 goto fail_not_configurable;
52573 }
52574 if (has_enumerable) {
52575 if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) {
52576 if (!is_enumerable) {
52577 goto fail_not_configurable;
52578 }
52579 } else {
52580 if (is_enumerable) {
52581 goto fail_not_configurable;
52582 }
52583 }
52584 }
52585 }
52586
52587 /* Reject attempt to change virtual properties: not part of the
52588 * standard algorithm, applies currently to e.g. virtual index
52589 * properties of buffer objects (which are virtual but writable).
52590 * (Cannot "force" modification of a virtual property.)
52591 */
52592 if (curr.flags & DUK_PROPDESC_FLAG_VIRTUAL) {
52593 goto fail_virtual;
52594 }
52595
52596 /* Reject attempt to change a read-only object. */
52597#if defined(DUK_USE_ROM_OBJECTS)
52599 DUK_DD(DUK_DDPRINT("attempt to define property on read-only target object"));
52600 goto fail_not_configurable;
52601 }
52602#endif
52603
52604 /* descriptor type specific checks */
52605 if (has_set || has_get) {
52606 /* IsAccessorDescriptor(desc) == true */
52607 DUK_ASSERT(!has_writable);
52608 DUK_ASSERT(!has_value);
52609
52610 if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
52611 /* curr and desc are accessors */
52612 if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
52613 if (has_set && set != curr.set) {
52614 goto fail_not_configurable;
52615 }
52616 if (has_get && get != curr.get) {
52617 goto fail_not_configurable;
52618 }
52619 }
52620 } else {
52621 duk_bool_t rc;
52622 duk_tval *tv1;
52623 duk_tval tv_tmp;
52624
52625 /* curr is data, desc is accessor */
52626 if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
52627 goto fail_not_configurable;
52628 }
52629
52630 DUK_DDD(DUK_DDDPRINT("convert property to accessor property"));
52631 if (curr.a_idx >= 0) {
52632 DUK_DDD(DUK_DDDPRINT("property to convert is stored in an array entry, abandon array and re-lookup"));
52634 duk_pop(ctx); /* remove old value */
52635 rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
52636 DUK_UNREF(rc);
52637 DUK_ASSERT(rc != 0);
52638 DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
52639 }
52640
52641 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
52642
52643 /* Avoid side effects that might disturb curr.e_idx until
52644 * we're done editing the slot.
52645 */
52646 tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
52647 DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
52649
52650 DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL);
52651 DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL);
52652 DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
52653 DUK_HOBJECT_E_SLOT_SET_ACCESSOR(thr->heap, obj, curr.e_idx);
52654
52655 DUK_DDD(DUK_DDDPRINT("flags after data->accessor conversion: 0x%02lx",
52656 (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx)));
52657
52658 DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */
52659
52660 /* re-lookup to update curr.flags
52661 * XXX: would be faster to update directly
52662 */
52663 duk_pop(ctx); /* remove old value */
52664 rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
52665 DUK_UNREF(rc);
52666 DUK_ASSERT(rc != 0);
52667 }
52668 } else if (has_value || has_writable) {
52669 /* IsDataDescriptor(desc) == true */
52670 DUK_ASSERT(!has_set);
52671 DUK_ASSERT(!has_get);
52672
52673 if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
52674 duk_bool_t rc;
52675 duk_hobject *h_get;
52676 duk_hobject *h_set;
52677
52678 /* curr is accessor, desc is data */
52679 if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
52680 goto fail_not_configurable;
52681 }
52682
52683 /* curr is accessor -> cannot be in array part */
52684 DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
52685
52686 DUK_DDD(DUK_DDDPRINT("convert property to data property"));
52687
52688 /* Avoid side effects that might disturb curr.e_idx until
52689 * we're done editing the slot.
52690 */
52691 DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
52692 h_get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx);
52693 DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL);
52694 h_set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx);
52695 DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL);
52696
52697 DUK_TVAL_SET_UNDEFINED(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx));
52698 DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
52699 DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(thr->heap, obj, curr.e_idx);
52700
52701 DUK_DDD(DUK_DDDPRINT("flags after accessor->data conversion: 0x%02lx",
52702 (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx)));
52703
52704 DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_get); /* side effects */
52705 DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_set); /* side effects */
52706
52707 /* re-lookup to update curr.flags
52708 * XXX: would be faster to update directly
52709 */
52710 duk_pop(ctx); /* remove old value */
52711 rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
52712 DUK_UNREF(rc);
52713 DUK_ASSERT(rc != 0);
52714 } else {
52715 /* curr and desc are data */
52716 if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
52717 if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_writable && is_writable) {
52718 goto fail_not_configurable;
52719 }
52720 /* Note: changing from writable to non-writable is OK */
52721 if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_value) {
52722 duk_tval *tmp1 = duk_require_tval(ctx, -1); /* curr value */
52723 duk_tval *tmp2 = duk_require_tval(ctx, idx_value); /* new value */
52724 if (!duk_js_samevalue(tmp1, tmp2)) {
52725 goto fail_not_configurable;
52726 }
52727 }
52728 }
52729 }
52730 } else {
52731 /* IsGenericDescriptor(desc) == true; this means in practice that 'desc'
52732 * only has [[Enumerable]] or [[Configurable]] flag updates, which are
52733 * allowed at this point.
52734 */
52735
52736 DUK_ASSERT(!has_value && !has_writable && !has_get && !has_set);
52737 }
52738
52739 /*
52740 * Start doing property attributes updates. Steps 12-13.
52741 *
52742 * Start by computing new attribute flags without writing yet.
52743 * Property type conversion is done above if necessary.
52744 */
52745
52746 new_flags = curr.flags;
52747
52748 if (has_enumerable) {
52749 if (is_enumerable) {
52750 new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
52751 } else {
52752 new_flags &= ~DUK_PROPDESC_FLAG_ENUMERABLE;
52753 }
52754 }
52755 if (has_configurable) {
52756 if (is_configurable) {
52757 new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
52758 } else {
52759 new_flags &= ~DUK_PROPDESC_FLAG_CONFIGURABLE;
52760 }
52761 }
52762 if (has_writable) {
52763 if (is_writable) {
52764 new_flags |= DUK_PROPDESC_FLAG_WRITABLE;
52765 } else {
52766 new_flags &= ~DUK_PROPDESC_FLAG_WRITABLE;
52767 }
52768 }
52769
52770 /* XXX: write protect after flag? -> any chance of handling it here? */
52771
52772 DUK_DDD(DUK_DDDPRINT("new flags that we want to write: 0x%02lx",
52773 (unsigned long) new_flags));
52774
52775 /*
52776 * Check whether we need to abandon an array part (if it exists)
52777 */
52778
52779 if (curr.a_idx >= 0) {
52780 duk_bool_t rc;
52781
52782 DUK_ASSERT(curr.e_idx < 0);
52783
52784 if (new_flags == DUK_PROPDESC_FLAGS_WEC) {
52785 duk_tval *tv1, *tv2;
52786
52787 DUK_DDD(DUK_DDDPRINT("array index, new property attributes match array defaults, update in-place"));
52788
52789 DUK_ASSERT(curr.flags == DUK_PROPDESC_FLAGS_WEC); /* must have been, since in array part */
52790 DUK_ASSERT(!has_set);
52791 DUK_ASSERT(!has_get);
52792
52793 tv2 = duk_require_tval(ctx, idx_value);
52794 tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, curr.a_idx);
52795 DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */
52796 goto success_exotics;
52797 }
52798
52799 DUK_DDD(DUK_DDDPRINT("array index, new property attributes do not match array defaults, abandon array and re-lookup"));
52801 duk_pop(ctx); /* remove old value */
52802 rc = duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &curr, DUK_GETDESC_FLAG_PUSH_VALUE);
52803 DUK_UNREF(rc);
52804 DUK_ASSERT(rc != 0);
52805 DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
52806 }
52807
52808 DUK_DDD(DUK_DDDPRINT("updating existing property in entry part"));
52809
52810 /* array case is handled comprehensively above */
52811 DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
52812
52813 DUK_DDD(DUK_DDDPRINT("update existing property attributes"));
52814 DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, curr.e_idx, new_flags);
52815
52816 if (has_set) {
52817 duk_hobject *tmp;
52818
52819 DUK_DDD(DUK_DDDPRINT("update existing property setter"));
52820 DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
52821
52822 tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx);
52823 DUK_UNREF(tmp);
52824 DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, set);
52826 DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */
52827 }
52828 if (has_get) {
52829 duk_hobject *tmp;
52830
52831 DUK_DDD(DUK_DDDPRINT("update existing property getter"));
52832 DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
52833
52834 tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx);
52835 DUK_UNREF(tmp);
52836 DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, get);
52838 DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */
52839 }
52840 if (has_value) {
52841 duk_tval *tv1, *tv2;
52842
52843 DUK_DDD(DUK_DDDPRINT("update existing property value"));
52844 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
52845
52846 tv2 = duk_require_tval(ctx, idx_value);
52847 tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
52848 DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */
52849 }
52850
52851 /*
52852 * Standard algorithm succeeded without errors, check for exotic post-behaviors.
52853 *
52854 * Arguments exotic behavior in E5 Section 10.6 occurs after the standard
52855 * [[DefineOwnProperty]] has completed successfully.
52856 *
52857 * Array exotic behavior in E5 Section 15.4.5.1 is implemented partly
52858 * prior to the default [[DefineOwnProperty]], but:
52859 * - for an array index key (e.g. "10") the final 'length' update occurs here
52860 * - for 'length' key the element deletion and 'length' update occurs here
52861 */
52862
52863 success_exotics:
52864
52865 /* [obj key desc value get set curr_value] */
52866
52868 if (arridx_new_array_length > 0) {
52869 duk_tval *tmp;
52870 duk_bool_t rc;
52871
52872 /*
52873 * Note: zero works as a "no update" marker because the new length
52874 * can never be zero after a new property is written.
52875 */
52876
52877 /* E5 Section 15.4.5.1, steps 4.e.i - 4.e.ii */
52878
52879 DUK_DDD(DUK_DDDPRINT("defineProperty successful, pending array length update to: %ld",
52880 (long) arridx_new_array_length));
52881
52882 /* Note: reuse 'curr' */
52883 rc = duk__get_own_propdesc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &curr, 0 /*flags*/); /* don't push value */
52884 DUK_UNREF(rc);
52885 DUK_ASSERT(rc != 0);
52886 DUK_ASSERT(curr.e_idx >= 0);
52887
52888 tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
52890 /* no need for decref/incref because value is a number */
52891 DUK_TVAL_SET_FASTINT_U32(tmp, arridx_new_array_length);
52892 }
52893 if (key == DUK_HTHREAD_STRING_LENGTH(thr) && arrlen_new_len < arrlen_old_len) {
52894 /*
52895 * E5 Section 15.4.5.1, steps 3.k - 3.n. The order at the end combines
52896 * the error case 3.l.iii and the success case 3.m-3.n.
52897 *
52898 * Note: 'length' is always in entries part, so no array abandon issues for
52899 * 'writable' update.
52900 */
52901
52902 /* XXX: investigate whether write protect can be handled above, if we
52903 * just update length here while ignoring its protected status
52904 */
52905
52906 duk_tval *tmp;
52907 duk_uint32_t result_len;
52908 duk_bool_t rc;
52909
52910 DUK_DDD(DUK_DDDPRINT("defineProperty successful, key is 'length', exotic array behavior, "
52911 "doing array element deletion and length update"));
52912
52913 rc = duk__handle_put_array_length_smaller(thr, obj, arrlen_old_len, arrlen_new_len, force_flag, &result_len);
52914
52915 /* update length (curr points to length, and we assume it's still valid) */
52916 DUK_ASSERT(result_len >= arrlen_new_len && result_len <= arrlen_old_len);
52917
52918 DUK_ASSERT(curr.e_idx >= 0);
52919 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
52920 tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
52922 /* no decref needed for a number */
52923 DUK_TVAL_SET_FASTINT_U32(tmp, result_len);
52925
52926 if (pending_write_protect) {
52927 DUK_DDD(DUK_DDDPRINT("setting array length non-writable (pending writability update)"));
52928 DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
52929 }
52930
52931 /*
52932 * XXX: shrink array allocation or entries compaction here?
52933 */
52934
52935 if (!rc) {
52936 goto fail_array_length_partial;
52937 }
52938 }
52939 } else if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) {
52940 duk_hobject *map;
52941 duk_hobject *varenv;
52942
52943 DUK_ASSERT(arridx_new_array_length == 0);
52944 DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)); /* traits are separate; in particular, arguments not an array */
52945
52946 map = NULL;
52947 varenv = NULL;
52948 if (!duk__lookup_arguments_map(thr, obj, key, &curr, &map, &varenv)) {
52949 goto success_no_exotics;
52950 }
52951 DUK_ASSERT(map != NULL);
52952 DUK_ASSERT(varenv != NULL);
52953
52954 /* [obj key desc value get set curr_value varname] */
52955
52956 if (has_set || has_get) {
52957 /* = IsAccessorDescriptor(Desc) */
52958 DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map' "
52959 "changed to an accessor, delete arguments binding"));
52960
52961 (void) duk_hobject_delprop_raw(thr, map, key, 0); /* ignore result */
52962 } else {
52963 /* Note: this order matters (final value before deleting map entry must be done) */
52964 DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
52965 "check for value update / binding deletion"));
52966
52967 if (has_value) {
52968 duk_hstring *varname;
52969
52970 DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
52971 "update bound value (variable/argument)"));
52972
52973 varname = duk_require_hstring(ctx, -1);
52974 DUK_ASSERT(varname != NULL);
52975
52976 DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; "
52977 "key=%!O, varname=%!O, value=%!T",
52978 (duk_heaphdr *) key,
52979 (duk_heaphdr *) varname,
52980 (duk_tval *) duk_require_tval(ctx, idx_value)));
52981
52982 /* strict flag for putvar comes from our caller (currently: fixed) */
52983 duk_js_putvar_envrec(thr, varenv, varname, duk_require_tval(ctx, idx_value), throw_flag);
52984 }
52985 if (has_writable && !is_writable) {
52986 DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
52987 "changed to non-writable, delete arguments binding"));
52988
52989 (void) duk_hobject_delprop_raw(thr, map, key, 0); /* ignore result */
52990 }
52991 }
52992
52993 /* 'varname' is in stack in this else branch, leaving an unbalanced stack below,
52994 * but this doesn't matter now.
52995 */
52996 }
52997
52998 success_no_exotics:
52999 return;
53000
53001 fail_virtual:
53003 return;
#define DUK_TVAL_DECREF(thr, tv)
#define duk_js_samevalue(tv_x, tv_y)
DUK_LOCAL void duk__abandon_array_checked(duk_hthread *thr, duk_hobject *obj)
#define DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(heap, h, i)
#define DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(heap, h, i)
#define DUK_STR_PROPERTY_IS_VIRTUAL
#define DUK_PROPDESC_FLAGS_WEC
#define DUK_HOBJECT_E_SLOT_SET_ACCESSOR(heap, h, i)
union Value Value

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 51693 of file duktape-1.5.2/src/duktape.c.

51697 :
51698 * - virtual properties (error if write attempted)
51699 * - getter/setter properties (error if write attempted)
51700 * - non-default (!= WEC) attributes for array entries (error if attempted)
51701 * - array abandoning: if array part exists, it is always extended
51702 * - array 'length' updating
51703 *
51704 * Stack: [... in_val] -> []
51705 *
51706 * Used for e.g. built-in initialization and environment record
51707 * operations.
51708 */
51709
51711 duk_context *ctx = (duk_context *) thr;
51712 duk_propdesc desc;
51713 duk_uint32_t arr_idx;
51714 duk_int_t e_idx;
51715 duk_tval *tv1 = NULL;
51716 duk_tval *tv2 = NULL;
51717 duk_small_uint_t propflags = flags & DUK_PROPDESC_FLAGS_MASK; /* mask out flags not actually stored */
51718
51719 DUK_DDD(DUK_DDDPRINT("define new property (internal): thr=%p, obj=%!O, key=%!O, flags=0x%02lx, val=%!T",
51720 (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key,
51721 (unsigned long) flags, (duk_tval *) duk_get_tval(ctx, -1)));
51722
51723 DUK_ASSERT(thr != NULL);
51724 DUK_ASSERT(thr->heap != NULL);
51725 DUK_ASSERT(obj != NULL);
51726 DUK_ASSERT(key != NULL);
51729 DUK_ASSERT(duk_is_valid_index(ctx, -1)); /* contains value */
51730
51731 arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
51732
51733 if (duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */
51734 if (desc.e_idx >= 0) {
51735 if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
51736 DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> skip as requested"));
51737 goto pop_exit;
51738 }
51739 DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> update value and attributes"));
51740 if (DUK_UNLIKELY(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx))) {
51741 DUK_D(DUK_DPRINT("existing property is an accessor, not supported"));
51742 goto error_internal;
51743 }
51744
51745 DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, propflags);
51746 tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
51747 } else if (desc.a_idx >= 0) {
51748 if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
51749 DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> skip as requested"));
51750 goto pop_exit;
51751 }
51752 DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> update value (assert attributes)"));
51753 if (propflags != DUK_PROPDESC_FLAGS_WEC) {
51754 DUK_D(DUK_DPRINT("existing property in array part, but propflags not WEC (0x%02lx)",
51755 (unsigned long) propflags));
51756 goto error_internal;
51757 }
51758
51759 tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx);
51760 } else {
51761 if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
51762 DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> skip as requested"));
51763 goto pop_exit;
51764 }
51765 DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> failure"));
51766 goto error_virtual;
51767 }
51768
51769 goto write_value;
51770 }
51771
51772 if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
51773 if (arr_idx != DUK__NO_ARRAY_INDEX) {
51774 DUK_DDD(DUK_DDDPRINT("property does not exist, object has array part -> possibly extend array part and write value (assert attributes)"));
51775 DUK_ASSERT(propflags == DUK_PROPDESC_FLAGS_WEC);
51776
51777 /* always grow the array, no sparse / abandon support here */
51778 if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
51779 duk__grow_props_for_array_item(thr, obj, arr_idx);
51780 }
51781
51782 DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj));
51783 tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
51784 goto write_value;
51785 }
51786 }
51787
51788 DUK_DDD(DUK_DDDPRINT("property does not exist, object belongs in entry part -> allocate new entry and write value and attributes"));
51789 e_idx = duk__alloc_entry_checked(thr, obj, key); /* increases key refcount */
51790 DUK_ASSERT(e_idx >= 0);
51791 DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, propflags);
51792 tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
51793 /* new entry: previous value is garbage; set to undefined to share write_value */
51795 goto write_value;
51796
51797 write_value:
51798 /* tv1 points to value storage */
51799
51800 tv2 = duk_require_tval(ctx, -1); /* late lookup, avoid side effects */
51801 DUK_DDD(DUK_DDDPRINT("writing/updating value: %!T -> %!T",
DUK_LOCAL void duk__grow_props_for_array_item(duk_hthread *thr, duk_hobject *obj, duk_uint32_t highest_arr_idx)

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 51809 of file duktape-1.5.2/src/duktape.c.

51811 :
51813 return;
51814
51815 error_virtual:
51817 return;
51818}
51819
51820/*
51821 * Fast path for defining array indexed values without interning the key.
51822 * This is used by e.g. code for Array prototype and traceback creation so
51823 * must avoid interning.
51824 */
51825
51827 duk_context *ctx = (duk_context *) thr;
51828 duk_hstring *key;
51829 duk_tval *tv1, *tv2;
51830
51831 DUK_DDD(DUK_DDDPRINT("define new property (internal) arr_idx fast path: thr=%p, obj=%!O, "
51832 "arr_idx=%ld, flags=0x%02lx, val=%!T",
51833 (void *) thr, obj, (long) arr_idx, (unsigned long) flags,
51834 (duk_tval *) duk_get_tval(ctx, -1)));
51835
51836 DUK_ASSERT(thr != NULL);
51837 DUK_ASSERT(thr->heap != NULL);
51838 DUK_ASSERT(obj != NULL);
51840
51841 if (DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
51842 arr_idx != DUK__NO_ARRAY_INDEX &&
51843 flags == DUK_PROPDESC_FLAGS_WEC) {
51844 DUK_ASSERT((flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) == 0); /* covered by comparison */
51845
51846 DUK_DDD(DUK_DDDPRINT("define property to array part (property may or may not exist yet)"));
51847
51848 /* always grow the array, no sparse / abandon support here */
51849 if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
51850 duk__grow_props_for_array_item(thr, obj, arr_idx);
51851 }
51852
51853 DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj));
51854 tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
51855 tv2 = duk_require_tval(ctx, -1);
51856
#define DUK_STR_REDEFINE_VIRT_PROP
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_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 51486 of file duktape-1.5.2/src/duktape.c.

51490 :
51491 DUK_DDD(DUK_DDDPRINT("delete failed: property found, not configurable"));
51492
51493 if (throw_flag) {
51495 }
51496 return 0;
51497}
51498
51499/*
51500 * DELPROP: Ecmascript property deletion.
51501 */
51502
51504 duk_context *ctx = (duk_context *) thr;
51505 duk_hstring *key = NULL;
51506#if defined(DUK_USE_ES6_PROXY)
51507 duk_propdesc desc;
51508#endif
51509 duk_int_t entry_top;
51510 duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX;
51511 duk_bool_t rc;
51512
51513 DUK_DDD(DUK_DDDPRINT("delprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
51514 (void *) thr, (void *) tv_obj, (void *) tv_key,
51515 (duk_tval *) tv_obj, (duk_tval *) tv_key));
51516
51517 DUK_ASSERT(ctx != NULL);
51518 DUK_ASSERT(thr != NULL);
51519 DUK_ASSERT(thr->heap != NULL);
51520 DUK_ASSERT(tv_obj != NULL);
51521 DUK_ASSERT(tv_key != NULL);
51522
51524
51525 /* Storing the entry top is cheaper here to ensure stack is correct at exit,
51526 * as there are several paths out.
51527 */
51528 entry_top = duk_get_top(ctx);
51529
51530 if (DUK_TVAL_IS_UNDEFINED(tv_obj) ||
51531 DUK_TVAL_IS_NULL(tv_obj)) {
51532 DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject"));
51533 goto fail_invalid_base_uncond;
51534 }
51535
51536 duk_push_tval(ctx, tv_obj);
51537 duk_push_tval(ctx, tv_key);
51538
51539 tv_obj = DUK_GET_TVAL_NEGIDX(ctx, -2);
51540 if (DUK_TVAL_IS_OBJECT(tv_obj)) {
51541 duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_obj);
51542 DUK_ASSERT(obj != NULL);
51543
51544#if defined(DUK_USE_ES6_PROXY)
51546 duk_hobject *h_target;
51547 duk_bool_t tmp_bool;
51548
51549 /* Note: proxy handling must happen before key is string coerced. */
51550
51551 if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_DELETE_PROPERTY, tv_key, &h_target)) {
51552 /* -> [ ... trap handler ] */
51553 DUK_DDD(DUK_DDDPRINT("-> proxy object 'deleteProperty' for key %!T", (duk_tval *) tv_key));
51554 duk_push_hobject(ctx, h_target); /* target */
51555 duk_push_tval(ctx, tv_key); /* P */
51556 duk_call_method(ctx, 2 /*nargs*/);
51557 tmp_bool = duk_to_boolean(ctx, -1);
51558 duk_pop(ctx);
51559 if (!tmp_bool) {
51560 goto fail_proxy_rejected; /* retval indicates delete failed */
51561 }
51562
51563 /* Target object must be checked for a conflicting
51564 * non-configurable property.
51565 */
51566 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
51567 DUK_ASSERT(key != NULL);
51568
51569 if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */
51570 int desc_reject;
51571
51572 DUK_DDD(DUK_DDDPRINT("proxy 'deleteProperty': target has matching property %!O, check for "
51573 "conflicting property; desc.flags=0x%08lx, "
51574 "desc.get=%p, desc.set=%p",
51575 (duk_heaphdr *) key, (unsigned long) desc.flags,
51576 (void *) desc.get, (void *) desc.set));
51577
51578 desc_reject = !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE);
51579 if (desc_reject) {
51580 /* unconditional */
51582 }
51583 }
51584 rc = 1; /* success */
51585 goto done_rc;
51586 }
51587
51588 obj = h_target; /* resume delete to target */
51589 }
51590#endif /* DUK_USE_ES6_PROXY */
51591
51592 duk_to_string(ctx, -1);
51593 key = duk_get_hstring(ctx, -1);
51594 DUK_ASSERT(key != NULL);
51595
51596 rc = duk_hobject_delprop_raw(thr, obj, key, throw_flag ? DUK_DELPROP_FLAG_THROW : 0);
51597 goto done_rc;
51598 } else if (DUK_TVAL_IS_STRING(tv_obj)) {
51599 /* XXX: unnecessary string coercion for array indices,
51600 * intentional to keep small.
51601 */
51602 duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
51603 DUK_ASSERT(h != NULL);
51604
51605 duk_to_string(ctx, -1);
51606 key = duk_get_hstring(ctx, -1);
51607 DUK_ASSERT(key != NULL);
51608
51609 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
51610 goto fail_not_configurable;
51611 }
51612
51613 arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
51614
51615 if (arr_idx != DUK__NO_ARRAY_INDEX &&
51616 arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
51617 goto fail_not_configurable;
51618 }
51619 } else if (DUK_TVAL_IS_BUFFER(tv_obj)) {
51620 /* XXX: unnecessary string coercion for array indices,
51621 * intentional to keep small; some overlap with string
51622 * handling.
51623 */
51624 duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
51625 DUK_ASSERT(h != NULL);
51626
51627 duk_to_string(ctx, -1);
51628 key = duk_get_hstring(ctx, -1);
51629 DUK_ASSERT(key != NULL);
51630
51631 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
51632 goto fail_not_configurable;
51633 }
51634
51635 arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
51636
51637 if (arr_idx != DUK__NO_ARRAY_INDEX &&
51638 arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
51639 goto fail_not_configurable;
51640 }
51641 } else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) {
51642 /* Lightfunc virtual properties are non-configurable, so
51643 * reject if match any of them.
51644 */
51645
51646 duk_to_string(ctx, -1);
51647 key = duk_get_hstring(ctx, -1);
51648 DUK_ASSERT(key != NULL);
51649
51650 if (duk__key_is_lightfunc_ownprop(thr, key)) {
51651 goto fail_not_configurable;
51652 }
51653 }
51654
51655 /* non-object base, no offending virtual property */
51656 rc = 1;
51657 goto done_rc;
51658
51659 done_rc:
51660 duk_set_top(ctx, entry_top);
51661 return rc;
51662
51663 fail_invalid_base_uncond:
51664 /* Note: unconditional throw */
51665 DUK_ASSERT(duk_get_top(ctx) == entry_top);
51666#if defined(DUK_USE_PARANOID_ERRORS)
51668#else
51669 DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot delete property %s of %s",
51671#endif
51672 return 0;
#define DUK_DELPROP_FLAG_THROW
DUK_LOCAL duk_uint32_t duk__push_tval_to_hstring_arr_idx(duk_context *ctx, duk_tval *tv, duk_hstring **out_h)
#define DUK_STRIDX_DELETE_PROPERTY
#define DUK_ERROR_FMT2(thr, err, fmt, arg1, arg2)
#define DUK_STR_INVALID_BASE
#define DUK_STR_NOT_CONFIGURABLE
DUK_LOCAL duk_bool_t duk__key_is_lightfunc_ownprop(duk_hthread *thr, duk_hstring *key)
#define DUK_STR_PROXY_REJECTED

◆ 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 51318 of file duktape-1.5.2/src/duktape.c.

51322 :
51323 DUK_DDD(DUK_DDDPRINT("result: error, internal"));
51324 if (throw_flag) {
51326 }
51327 duk_pop(ctx); /* remove key */
51328 return 0;
51329}
51330
51331/*
51332 * Ecmascript compliant [[Delete]](P, Throw).
51333 */
51334
51336 duk_propdesc desc;
51337 duk_tval *tv;
51338 duk_uint32_t arr_idx;
51339 duk_bool_t throw_flag;
51340 duk_bool_t force_flag;
51341
51342 throw_flag = (flags & DUK_DELPROP_FLAG_THROW);
51343 force_flag = (flags & DUK_DELPROP_FLAG_FORCE);
51344
51345 DUK_DDD(DUK_DDDPRINT("delprop_raw: thr=%p, obj=%p, key=%p, throw=%ld, force=%ld (obj -> %!O, key -> %!O)",
51346 (void *) thr, (void *) obj, (void *) key, (long) throw_flag, (long) force_flag,
51347 (duk_heaphdr *) obj, (duk_heaphdr *) key));
51348
51349 DUK_ASSERT(thr != NULL);
51350 DUK_ASSERT(thr->heap != NULL);
51351 DUK_ASSERT(obj != NULL);
51352 DUK_ASSERT(key != NULL);
51353
51355
51356 arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
51357
51358 /* 0 = don't push current value */
51359 if (!duk__get_own_propdesc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */
51360 DUK_DDD(DUK_DDDPRINT("property not found, succeed always"));
51361 goto success;
51362 }
51363
51364#if defined(DUK_USE_ROM_OBJECTS)
51366 DUK_DD(DUK_DDPRINT("attempt to delprop on read-only target object"));
51367 goto fail_not_configurable;
51368 }
51369#endif
51370
51371 if ((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) == 0 && !force_flag) {
51372 goto fail_not_configurable;
51373 }
51374 if (desc.a_idx < 0 && desc.e_idx < 0) {
51375 /* Currently there are no deletable virtual properties, but
51376 * with force_flag we might attempt to delete one.
51377 */
51378 goto fail_virtual;
51379 }
51380
51381 if (desc.a_idx >= 0) {
51382 DUK_ASSERT(desc.e_idx < 0);
51383
51384 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx);
51385 DUK_TVAL_SET_UNUSED_UPDREF(thr, tv); /* side effects */
51386 goto success;
51387 } else {
51388 duk_hobject *h_get = NULL;
51389 duk_hobject *h_set = NULL;
51390 duk_tval tv_tmp;
51391
51392 DUK_ASSERT(desc.a_idx < 0);
51393
51394 /* Set property slot to an empty state. Careful not to invoke
51395 * any side effects while using desc.e_idx so that it doesn't
51396 * get invalidated by a finalizer mutating our object.
51397 */
51398
51399 /* remove hash entry (no decref) */
51400#if defined(DUK_USE_HOBJECT_HASH_PART)
51401 if (desc.h_idx >= 0) {
51402 duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj);
51403
51404 DUK_DDD(DUK_DDDPRINT("removing hash entry at h_idx %ld", (long) desc.h_idx));
51406 DUK_ASSERT((duk_uint32_t) desc.h_idx < DUK_HOBJECT_GET_HSIZE(obj));
51407 h_base[desc.h_idx] = DUK__HASH_DELETED;
51408 } else {
51410 }
51411#else
51413#endif
51414
51415 /* remove value */
51416 DUK_DDD(DUK_DDDPRINT("before removing value, e_idx %ld, key %p, key at slot %p",
51417 (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)));
51418 DUK_DDD(DUK_DDDPRINT("removing value at e_idx %ld", (long) desc.e_idx));
51419 DUK_MEMSET((void *) &tv_tmp, 0, sizeof(tv_tmp));
51420 DUK_TVAL_SET_UNDEFINED(&tv_tmp);
51421 if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx)) {
51422 h_get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, desc.e_idx);
51423 h_set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, desc.e_idx);
51424 DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, desc.e_idx, NULL);
51425 DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, desc.e_idx, NULL);
51426 } else {
51427 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
51428 DUK_TVAL_SET_TVAL(&tv_tmp, tv);
51430 }
51431#if 0
51432 /* Not strictly necessary because if key == NULL, flag MUST be ignored. */
51433 DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, 0);
51434#endif
51435
51436 /* remove key */
51437 DUK_DDD(DUK_DDDPRINT("before removing key, e_idx %ld, key %p, key at slot %p",
51438 (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)));
51439 DUK_DDD(DUK_DDDPRINT("removing key at e_idx %ld", (long) desc.e_idx));
51440 DUK_ASSERT(key == DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx));
51441 DUK_HOBJECT_E_SET_KEY(thr->heap, obj, desc.e_idx, NULL);
51442
51443 /* Do decrefs only with safe pointers to avoid side effects
51444 * disturbing e_idx.
51445 */
51446 DUK_TVAL_DECREF(thr, &tv_tmp);
51447 DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_get);
51448 DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_set);
51449 DUK_HSTRING_DECREF(thr, key);
51450 goto success;
51451 }
51452
51454
51455 success:
51456 /*
51457 * Argument exotic [[Delete]] behavior (E5 Section 10.6) is
51458 * a post-check, keeping arguments internal 'map' in sync with
51459 * any successful deletes (note that property does not need to
51460 * exist for delete to 'succeed').
51461 *
51462 * Delete key from 'map'. Since 'map' only contains array index
51463 * keys, we can use arr_idx for a fast skip.
51464 */
51465
51466 DUK_DDD(DUK_DDDPRINT("delete successful, check for arguments exotic behavior"));
51467
51469 /* Note: only numbered indices are relevant, so arr_idx fast reject
51470 * is good (this is valid unless there are more than 4**32-1 arguments).
51471 */
51472
51473 DUK_DDD(DUK_DDDPRINT("delete successful, arguments exotic behavior needed"));
51474
51475 /* Note: we can reuse 'desc' here */
51476 (void) duk__check_arguments_map_for_delete(thr, obj, key, &desc);
51477 }
51478
51479 DUK_DDD(DUK_DDDPRINT("delete successful"));
51480 return 1;
#define DUK_HSTRING_DECREF(thr, h)
DUK_LOCAL_DECL void duk__check_arguments_map_for_delete(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc)

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 46299 of file duktape-1.5.2/src/duktape.c.

46316 {
46317 duk_hthread *thr = (duk_hthread *) ctx;
46318 duk_hobject *enum_target;
46319 duk_hobject *curr;
46320 duk_hobject *res;
46321#if defined(DUK_USE_ES6_PROXY)
46322 duk_hobject *h_proxy_target;
46323 duk_hobject *h_proxy_handler;
46324 duk_hobject *h_trap_result;
46325#endif
46326 duk_uint_fast32_t i, len; /* used for array, stack, and entry indices */
46327
46328 DUK_ASSERT(ctx != NULL);
46329
46330 DUK_DDD(DUK_DDDPRINT("create enumerator, stack top: %ld", (long) duk_get_top(ctx)));
46331
46332 enum_target = duk_require_hobject(ctx, -1);
46333 DUK_ASSERT(enum_target != NULL);
46334
46336 res = duk_require_hobject(ctx, -1);
46337
46338 DUK_DDD(DUK_DDDPRINT("created internal object"));
46339
46340 /* [enum_target res] */
46341
46342 /* Target must be stored so that we can recheck whether or not
46343 * keys still exist when we enumerate. This is not done if the
46344 * enumeration result comes from a proxy trap as there is no
46345 * real object to check against.
46346 */
46347 duk_push_hobject(ctx, enum_target);
46349
46350 /* Initialize index so that we skip internal control keys. */
46353
46354 /*
46355 * Proxy object handling
46356 */
46357
46358#if defined(DUK_USE_ES6_PROXY)
46359 if (DUK_LIKELY((enum_flags & DUK_ENUM_NO_PROXY_BEHAVIOR) != 0)) {
46360 goto skip_proxy;
46361 }
46363 enum_target,
46364 &h_proxy_target,
46365 &h_proxy_handler))) {
46366 goto skip_proxy;
46367 }
46368
46369 DUK_DDD(DUK_DDDPRINT("proxy enumeration"));
46370 duk_push_hobject(ctx, h_proxy_handler);
46372 /* No need to replace the 'enum_target' value in stack, only the
46373 * enum_target reference. This also ensures that the original
46374 * enum target is reachable, which keeps the proxy and the proxy
46375 * target reachable. We do need to replace the internal _Target.
46376 */
46377 DUK_DDD(DUK_DDDPRINT("no enumerate trap, enumerate proxy target instead"));
46378 DUK_DDD(DUK_DDDPRINT("h_proxy_target=%!O", (duk_heaphdr *) h_proxy_target));
46379 enum_target = h_proxy_target;
46380
46381 duk_push_hobject(ctx, enum_target); /* -> [ ... enum_target res handler undefined target ] */
46383
46384 duk_pop_2(ctx); /* -> [ ... enum_target res ] */
46385 goto skip_proxy;
46386 }
46387
46388 /* [ ... enum_target res handler trap ] */
46389 duk_insert(ctx, -2);
46390 duk_push_hobject(ctx, h_proxy_target); /* -> [ ... enum_target res trap handler target ] */
46391 duk_call_method(ctx, 1 /*nargs*/); /* -> [ ... enum_target res trap_result ] */
46392 h_trap_result = duk_require_hobject(ctx, -1);
46393 DUK_UNREF(h_trap_result);
46394
46395 /* Copy trap result keys into the enumerator object. */
46396 len = (duk_uint_fast32_t) duk_get_length(ctx, -1);
46397 for (i = 0; i < len; i++) {
46398 /* XXX: not sure what the correct semantic details are here,
46399 * e.g. handling of missing values (gaps), handling of non-array
46400 * trap results, etc.
46401 *
46402 * For keys, we simply skip non-string keys which seems to be
46403 * consistent with how e.g. Object.keys() will process proxy trap
46404 * results (ES6, Section 19.1.2.14).
46405 */
46406 if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) {
46407 /* [ ... enum_target res trap_result val ] */
46408 duk_push_true(ctx);
46409 /* [ ... enum_target res trap_result val true ] */
46410 duk_put_prop(ctx, -4);
46411 } else {
46412 duk_pop(ctx);
46413 }
46414 }
46415 /* [ ... enum_target res trap_result ] */
46416 duk_pop(ctx);
46417 duk_remove(ctx, -2);
46418
46419 /* [ ... res ] */
46420
46421 /* The internal _Target property is kept pointing to the original
46422 * enumeration target (the proxy object), so that the enumerator
46423 * 'next' operation can read property values if so requested. The
46424 * fact that the _Target is a proxy disables key existence check
46425 * during enumeration.
46426 */
46427 DUK_DDD(DUK_DDDPRINT("proxy enumeration, final res: %!O", (duk_heaphdr *) res));
46428 goto compact_and_return;
46429
46430 skip_proxy:
46431#endif /* DUK_USE_ES6_PROXY */
46432
46433 curr = enum_target;
46434 while (curr) {
46435 /*
46436 * Virtual properties.
46437 *
46438 * String and buffer indices are virtual and always enumerable,
46439 * 'length' is virtual and non-enumerable. Array and arguments
46440 * object props have special behavior but are concrete.
46441 */
46442
46445 /* String and buffer enumeration behavior is identical now,
46446 * so use shared handler.
46447 */
46449 duk_hstring *h_val;
46450 h_val = duk_hobject_get_internal_value_string(thr->heap, curr);
46451 DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */
46453 } else {
46454 duk_hbufferobject *h_bufobj;
46456 h_bufobj = (duk_hbufferobject *) curr;
46457 if (h_bufobj == NULL) {
46458 /* Neutered buffer, zero length seems
46459 * like good behavior here.
46460 */
46461 len = 0;
46462 } else {
46463 /* There's intentionally no check for
46464 * current underlying buffer length.
46465 */
46466 len = (duk_uint_fast32_t) (h_bufobj->length >> h_bufobj->shift);
46467 }
46468 }
46469
46470 for (i = 0; i < len; i++) {
46471 duk_hstring *k;
46472
46474 DUK_ASSERT(k);
46475 duk_push_hstring(ctx, k);
46476 duk_push_true(ctx);
46477
46478 /* [enum_target res key true] */
46479 duk_put_prop(ctx, -3);
46480
46481 /* [enum_target res] */
46482 }
46483
46484 /* 'length' and other virtual properties are not
46485 * enumerable, but are included if non-enumerable
46486 * properties are requested.
46487 */
46488
46489 if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
46491
46492 if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) {
46493 n = sizeof(duk__bufferobject_virtual_props) / sizeof(duk_uint16_t);
46494 } else {
46497 n = 1; /* only 'length' */
46498 }
46499
46500 for (i = 0; i < n; i++) {
46502 duk_push_true(ctx);
46503 duk_put_prop(ctx, -3);
46504 }
46505
46506 }
46507 } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) {
46508 if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
46510 duk_push_true(ctx);
46511 duk_put_prop(ctx, -3);
46512 }
46513 }
46514
46515 /*
46516 * Array part
46517 *
46518 * Note: ordering between array and entry part must match 'abandon array'
46519 * behavior in duk_hobject_props.c: key order after an array is abandoned
46520 * must be the same.
46521 */
46522
46523 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(curr); i++) {
46524 duk_hstring *k;
46525 duk_tval *tv;
46526
46527 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, curr, i);
46528 if (DUK_TVAL_IS_UNUSED(tv)) {
46529 continue;
46530 }
46532 DUK_ASSERT(k);
46533
46534 duk_push_hstring(ctx, k);
46535 duk_push_true(ctx);
46536
46537 /* [enum_target res key true] */
46538 duk_put_prop(ctx, -3);
46539
46540 /* [enum_target res] */
46541 }
46542
46543 /*
46544 * Entries part
46545 */
46546
46547 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(curr); i++) {
46548 duk_hstring *k;
46549
46550 k = DUK_HOBJECT_E_GET_KEY(thr->heap, curr, i);
46551 if (!k) {
46552 continue;
46553 }
46554 if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(thr->heap, curr, i) &&
46555 !(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) {
46556 continue;
46557 }
46558 if (DUK_HSTRING_HAS_INTERNAL(k) &&
46559 !(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) {
46560 continue;
46561 }
46562 if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) &&
46564 continue;
46565 }
46566
46569
46570 duk_push_hstring(ctx, k);
46571 duk_push_true(ctx);
46572
46573 /* [enum_target res key true] */
46574 duk_put_prop(ctx, -3);
46575
46576 /* [enum_target res] */
46577 }
46578
46579 if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) {
46580 break;
46581 }
46582
46583 curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
46584 }
46585
46586 /* [enum_target res] */
46587
46588 duk_remove(ctx, -2);
46589
46590 /* [res] */
46591
46594 /*
46595 * Some E5/E5.1 algorithms require that array indices are iterated
46596 * in a strictly ascending order. This is the case for e.g.
46597 * Array.prototype.forEach() and JSON.stringify() PropertyList
46598 * handling.
46599 *
46600 * To ensure this property for arrays with an array part (and
46601 * arbitrary objects too, since e.g. forEach() can be applied
46602 * to an array), the caller can request that we sort the keys
46603 * here.
46604 */
46605
46606 /* XXX: avoid this at least when enum_target is an Array, it has an
46607 * array part, and no ancestor properties were included? Not worth
#define DUK_ENUM_ARRAY_INDICES_ONLY
#define DUK_ENUM_SORT_ARRAY_INDICES
#define DUK_ENUM_INCLUDE_INTERNAL
#define DUK_STRIDX_ENUMERATE
#define DUK_HSTRING_NO_ARRAY_INDEX
#define DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(heap, h, i)
#define DUK_STRIDX_INT_NEXT
DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val)
DUK_LOCAL const duk_uint16_t duk__bufferobject_virtual_props[]
DUK_INTERNAL_DECL duk_idx_t duk_push_object_internal(duk_context *ctx)

◆ 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 46617 of file duktape-1.5.2/src/duktape.c.

46618 :
46619#endif
46620 /* compact; no need to seal because object is internal */
46621 duk_hobject_compact_props(thr, res);
46622
46623 DUK_DDD(DUK_DDDPRINT("created enumerator object: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
46624}
46625
46626/*
46627 * Returns non-zero if a key and/or value was enumerated, and:
46628 *
46629 * [enum] -> [key] (get_value == 0)
46630 * [enum] -> [key value] (get_value == 1)
46631 *
46632 * Returns zero without pushing anything on the stack otherwise.
46633 */
46635 duk_hthread *thr = (duk_hthread *) ctx;
46636 duk_hobject *e;
46637 duk_hobject *enum_target;
46638 duk_hstring *res = NULL;
46640 duk_bool_t check_existence;
46641
46642 DUK_ASSERT(ctx != NULL);
46643
46644 /* [... enum] */
46645
46646 e = duk_require_hobject(ctx, -1);
46647
46648 /* XXX use get tval ptr, more efficient */
46650 idx = (duk_uint_fast32_t) duk_require_uint(ctx, -1);
46651 duk_pop(ctx);
46652 DUK_DDD(DUK_DDDPRINT("enumeration: index is: %ld", (long) idx));
46653
46654 /* Enumeration keys are checked against the enumeration target (to see
46655 * that they still exist). In the proxy enumeration case _Target will
46656 * be the proxy, and checking key existence against the proxy is not
46657 * required (or sensible, as the keys may be fully virtual).
46658 */
46660 enum_target = duk_require_hobject(ctx, -1);
46661 DUK_ASSERT(enum_target != NULL);
46662#if defined(DUK_USE_ES6_PROXY)
46663 check_existence = (!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(enum_target));
46664#else
46665 check_existence = 1;
46666#endif
46667 duk_pop(ctx); /* still reachable */
46668
46669 DUK_DDD(DUK_DDDPRINT("getting next enum value, enum_target=%!iO, enumerator=%!iT",
46670 (duk_heaphdr *) enum_target, (duk_tval *) duk_get_tval(ctx, -1)));
46671
46672 /* no array part */
46673 for (;;) {
46674 duk_hstring *k;
46675
46676 if (idx >= DUK_HOBJECT_GET_ENEXT(e)) {
46677 DUK_DDD(DUK_DDDPRINT("enumeration: ran out of elements"));
46678 break;
46679 }
46680
46681 /* we know these because enum objects are internally created */
46682 k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, idx);
46683 DUK_ASSERT(k != NULL);
46686
46687 idx++;
46688
46689 /* recheck that the property still exists */
46690 if (check_existence && !duk_hobject_hasprop_raw(thr, enum_target, k)) {
46691 DUK_DDD(DUK_DDDPRINT("property deleted during enumeration, skip"));
46692 continue;
46693 }
46694
46695 DUK_DDD(DUK_DDDPRINT("enumeration: found element, key: %!O", (duk_heaphdr *) k));
46696 res = k;
46697 break;
46698 }
46699
46700 DUK_DDD(DUK_DDDPRINT("enumeration: updating next index to %ld", (long) idx));
46701
46702 duk_push_u32(ctx, (duk_uint32_t) idx);
46704
46705 /* [... enum] */
46706

◆ 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 48403 of file duktape-1.5.2/src/duktape.c.

48410 {
48411 *out_attrs = DUK_HOBJECT_E_GET_FLAGS(heap, obj, e_idx);
48412 return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx);
48413 } else {
48414 *out_attrs = 0;
48415 return NULL;
48416 }
48417}

◆ 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 48282 of file duktape-1.5.2/src/duktape.c.

48299 {
48300 DUK_ASSERT(obj != NULL);
48301 DUK_ASSERT(key != NULL);
48302 DUK_ASSERT(e_idx != NULL);
48303 DUK_ASSERT(h_idx != NULL);
48304 DUK_UNREF(heap);
48305
48306 if (DUK_LIKELY(DUK_HOBJECT_GET_HSIZE(obj) == 0))
48307 {
48308 /* Linear scan: more likely because most objects are small.
48309 * This is an important fast path.
48310 *
48311 * XXX: this might be worth inlining for property lookups.
48312 */
48315 duk_hstring **h_keys_base;
48316 DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using linear scan for lookup"));
48317
48318 h_keys_base = DUK_HOBJECT_E_GET_KEY_BASE(heap, obj);
48319 n = DUK_HOBJECT_GET_ENEXT(obj);
48320 for (i = 0; i < n; i++) {
48321 if (h_keys_base[i] == key) {
48322 *e_idx = i;
48323 *h_idx = -1;
48324 return;
48325 }
48326 }
48327 }
48328#if defined(DUK_USE_HOBJECT_HASH_PART)
48329 else
48330 {
48331 /* hash lookup */
48332 duk_uint32_t n;
48333 duk_uint32_t i, step;
48334 duk_uint32_t *h_base;
48335
48336 DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using hash part for lookup"));
48337
48338 h_base = DUK_HOBJECT_H_GET_BASE(heap, obj);
48339 n = DUK_HOBJECT_GET_HSIZE(obj);
48342
48343 for (;;) {
48344 duk_uint32_t t;
48345
48346 DUK_ASSERT_DISABLE(i >= 0); /* unsigned */
48348 t = h_base[i];
48350 (t < DUK_HOBJECT_GET_ESIZE(obj))); /* t >= 0 always true, unsigned */
48351
48352 if (t == DUK__HASH_UNUSED) {
48353 break;
48354 } else if (t == DUK__HASH_DELETED) {
48355 DUK_DDD(DUK_DDDPRINT("lookup miss (deleted) i=%ld, t=%ld",
48356 (long) i, (long) t));
48357 } else {
48359 if (DUK_HOBJECT_E_GET_KEY(heap, obj, t) == key) {
48360 DUK_DDD(DUK_DDDPRINT("lookup hit i=%ld, t=%ld -> key %p",
48361 (long) i, (long) t, (void *) key));
48362 *e_idx = t;
48363 *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 )

◆ 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 48383 of file duktape-1.5.2/src/duktape.c.

48383 {
48384 duk_int_t e_idx;
48385 duk_int_t h_idx;
48386
48387 DUK_ASSERT(obj != NULL);
48388 DUK_ASSERT(key != NULL);
48389 DUK_UNREF(heap);
48390
48391 duk_hobject_find_existing_entry(heap, obj, key, &e_idx, &h_idx);
48392 if (e_idx >= 0 && !DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)) {
48393 return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx);
48394 } else {
48395 return NULL;
48396 }
48397}
48398
48399/* For internal use: get non-accessor entry value and attributes */

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 46713 of file duktape-1.5.2/src/duktape.c.

46715 {
46716 duk_remove(ctx, -2); /* -> [... key] */
46717 }
46718 return 1;
46719 } else {
46720 duk_pop(ctx); /* -> [...] */
46721 return 0;
46722 }
46723}
46724
46725/*
46726 * Get enumerated keys in an Ecmascript array. Matches Object.keys() behavior
46727 * described in E5 Section 15.2.3.14.
46728 */
46729
46731 duk_hthread *thr = (duk_hthread *) ctx;
46732 duk_hobject *e;
46735
46736 DUK_ASSERT(ctx != NULL);
46737 DUK_ASSERT(duk_get_hobject(ctx, -1) != NULL);
46738 DUK_UNREF(thr);
46739
46740 /* Create a temporary enumerator to get the (non-duplicated) key list;
46741 * the enumerator state is initialized without being needed, but that
46742 * has little impact.
46743 */
46744
46745 duk_hobject_enumerator_create(ctx, enum_flags);
46746 duk_push_array(ctx);
46747
46748 /* [enum_target enum res] */
46749
46750 e = duk_require_hobject(ctx, -2);
46751 DUK_ASSERT(e != NULL);
46752
46753 idx = 0;
46755 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 48506 of file duktape-1.5.2/src/duktape.c.

48523 {

◆ 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 48525 of file duktape-1.5.2/src/duktape.c.

48533 {
48534 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx));
48535 DUK_TVAL_SET_TVAL(tv_out, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx));
48536 return 1;
48537 }
48538 DUK_TVAL_SET_UNDEFINED(tv_out);
48539 return 0;
48540}
48541
48543 duk_tval tv;
48544

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 51926 of file duktape-1.5.2/src/duktape.c.

51926 {
51927 duk_context *ctx = (duk_context *) thr;
51928 duk_push_hobject(ctx, obj);
51930 duk_push_u32(ctx, length);
51931 (void) duk_hobject_putprop(thr,
51932 DUK_GET_TVAL_NEGIDX(ctx, -3),
51933 DUK_GET_TVAL_NEGIDX(ctx, -2),
51934 DUK_GET_TVAL_NEGIDX(ctx, -1),
51935 0);
51936 duk_pop_n(ctx, 3);
51937}
51938
51940 duk_hobject_set_length(thr, obj, 0);
DUK_INTERNAL_DECL void duk_hobject_set_length_zero(duk_hthread *thr, duk_hobject *obj)

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 49048 of file duktape-1.5.2/src/duktape.c.

49053 {
49054 DUK_DDD(DUK_DDDPRINT("-> arguments exotic behavior overrides result: %!T -> %!T",
49055 (duk_tval *) duk_get_tval(ctx, -2),
49056 (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 49387 of file duktape-1.5.2/src/duktape.c.

49389 {
49390 data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
49391 duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size);
49392 } else {
49393 DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)"));
49394 }
49395
49396 duk_pop(ctx);
49397 return 1;
49398}
49399
49400/*
49401 * GETPROP: Ecmascript property read.
49402 */
49403
49405 duk_context *ctx = (duk_context *) thr;
49406 duk_tval tv_obj_copy;
49407 duk_tval tv_key_copy;
49408 duk_hobject *curr = NULL;
49409 duk_hstring *key = NULL;
49410 duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX;
49411 duk_propdesc desc;
49412 duk_uint_t sanity;
49413
49414 DUK_DDD(DUK_DDDPRINT("getprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
49415 (void *) thr, (void *) tv_obj, (void *) tv_key,
49416 (duk_tval *) tv_obj, (duk_tval *) tv_key));
49417
49418 DUK_ASSERT(ctx != NULL);
49419 DUK_ASSERT(thr != NULL);
49420 DUK_ASSERT(thr->heap != NULL);
49421 DUK_ASSERT(tv_obj != NULL);
49422 DUK_ASSERT(tv_key != NULL);
49423
49425
49426 /*
49427 * Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of
49428 * them being invalidated by a valstack resize.
49429 *
49430 * XXX: this is now an overkill for many fast paths. Rework this
49431 * to be faster (although switching to a valstack discipline might
49432 * be a better solution overall).
49433 */
49434
49435 DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj);
49436 DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
49437 tv_obj = &tv_obj_copy;
49438 tv_key = &tv_key_copy;
49439
49440 /*
49441 * Coercion and fast path processing
49442 */
49443
49444 switch (DUK_TVAL_GET_TAG(tv_obj)) {
49445 case DUK_TAG_UNDEFINED:
49446 case DUK_TAG_NULL: {
49447 /* Note: unconditional throw */
49448 DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject"));
49449#if defined(DUK_USE_PARANOID_ERRORS)
49451#else
49452 DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot read property %s of %s",
49454#endif
49455 return 0;
49456 }
49457
49458 case DUK_TAG_BOOLEAN: {
49459 DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype"));
49460 curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE];
49461 break;
49462 }
49463
49464 case DUK_TAG_STRING: {
49465 duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
49466 duk_int_t pop_count;
49467
49468#if defined(DUK_USE_FASTINT)
49469 if (DUK_TVAL_IS_FASTINT(tv_key)) {
49470 arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
49471 DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
49472 pop_count = 0;
49473 } else
49474#endif
49475 if (DUK_TVAL_IS_NUMBER(tv_key)) {
49476 arr_idx = duk__tval_number_to_arr_idx(tv_key);
49477 DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path number; arr_idx %ld", (long) arr_idx));
49478 pop_count = 0;
49479 } else {
49480 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49481 DUK_ASSERT(key != NULL);
49482 DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after "
49483 "coercion key is %!T, arr_idx %ld",
49484 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
49485 pop_count = 1;
49486 }
49487
49488 if (arr_idx != DUK__NO_ARRAY_INDEX &&
49489 arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
49490 duk_pop_n(ctx, pop_count);
49491 duk_push_hstring(ctx, h);
49492 duk_substring(ctx, -1, arr_idx, arr_idx + 1); /* [str] -> [substr] */
49493
49494 DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is an index inside string length "
49495 "after coercion -> return char)",
49496 (duk_tval *) duk_get_tval(ctx, -1)));
49497 return 1;
49498 }
49499
49500 if (pop_count == 0) {
49501 /* This is a pretty awkward control flow, but we need to recheck the
49502 * key coercion here.
49503 */
49504 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49505 DUK_ASSERT(key != NULL);
49506 DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after "
49507 "coercion key is %!T, arr_idx %ld",
49508 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
49509 }
49510
49511 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
49512 duk_pop(ctx); /* [key] -> [] */
49513 duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h)); /* [] -> [res] */
49514
49515 DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is 'length' after coercion -> "
49516 "return string length)",
49517 (duk_tval *) duk_get_tval(ctx, -1)));
49518 return 1;
49519 }
49520 DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype"));
49521 curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE];
49522 goto lookup; /* avoid double coercion */
49523 }
49524
49525 case DUK_TAG_OBJECT: {
49526 duk_tval *tmp;
49527
49528 curr = DUK_TVAL_GET_OBJECT(tv_obj);
49529 DUK_ASSERT(curr != NULL);
49530
49531 tmp = duk__getprop_shallow_fastpath_array_tval(thr, curr, tv_key);
49532 if (tmp) {
49533 duk_push_tval(ctx, tmp);
49534
49535 DUK_DDD(DUK_DDDPRINT("-> %!T (base is object, key is a number, array part "
49536 "fast path)",
49537 (duk_tval *) duk_get_tval(ctx, -1)));
49538 return 1;
49539 }
49540
49541 if (duk__getprop_fastpath_bufobj_tval(thr, curr, tv_key) != 0) {
49542 /* Read value pushed on stack. */
49543 DUK_DDD(DUK_DDDPRINT("-> %!T (base is bufobj, key is a number, bufferobject "
49544 "fast path)",
49545 (duk_tval *) duk_get_tval(ctx, -1)));
49546 return 1;
49547 }
49548
49549#if defined(DUK_USE_ES6_PROXY)
49551 duk_hobject *h_target;
49552
49553 if (duk__proxy_check_prop(thr, curr, DUK_STRIDX_GET, tv_key, &h_target)) {
49554 /* -> [ ... trap handler ] */
49555 DUK_DDD(DUK_DDDPRINT("-> proxy object 'get' for key %!T", (duk_tval *) tv_key));
49556 duk_push_hobject(ctx, h_target); /* target */
49557 duk_push_tval(ctx, tv_key); /* P */
49558 duk_push_tval(ctx, tv_obj); /* Receiver: Proxy object */
49559 duk_call_method(ctx, 3 /*nargs*/);
49560
49561 /* Target object must be checked for a conflicting
49562 * non-configurable property.
49563 */
49564 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49565 DUK_ASSERT(key != NULL);
49566
49567 if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
49568 duk_tval *tv_hook = duk_require_tval(ctx, -3); /* value from hook */
49569 duk_tval *tv_targ = duk_require_tval(ctx, -1); /* value from target */
49570 duk_bool_t datadesc_reject;
49571 duk_bool_t accdesc_reject;
49572
49573 DUK_DDD(DUK_DDDPRINT("proxy 'get': target has matching property %!O, check for "
49574 "conflicting property; tv_hook=%!T, tv_targ=%!T, desc.flags=0x%08lx, "
49575 "desc.get=%p, desc.set=%p",
49576 (duk_heaphdr *) key, (duk_tval *) tv_hook, (duk_tval *) tv_targ,
49577 (unsigned long) desc.flags,
49578 (void *) desc.get, (void *) desc.set));
49579
49580 datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
49583 !duk_js_samevalue(tv_hook, tv_targ);
49584 accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
49586 (desc.get == NULL) &&
49587 !DUK_TVAL_IS_UNDEFINED(tv_hook);
49588 if (datadesc_reject || accdesc_reject) {
49590 }
49591
49592 duk_pop_2(ctx);
49593 } else {
49594 duk_pop(ctx);
49595 }
49596 return 1; /* return value */
49597 }
49598
49599 curr = h_target; /* resume lookup from target */
49600 DUK_TVAL_SET_OBJECT(tv_obj, curr);
49601 }
49602#endif /* DUK_USE_ES6_PROXY */
49603
49605 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49606 DUK_ASSERT(key != NULL);
49607
49608 if (duk__check_arguments_map_for_get(thr, curr, key, &desc)) {
49609 DUK_DDD(DUK_DDDPRINT("-> %!T (base is object with arguments exotic behavior, "
49610 "key matches magically bound property -> skip standard "
49611 "Get with replacement value)",
49612 (duk_tval *) duk_get_tval(ctx, -1)));
49613
49614 /* no need for 'caller' post-check, because 'key' must be an array index */
49615
49616 duk_remove(ctx, -2); /* [key result] -> [result] */
49617 return 1;
49618 }
49619
49620 goto lookup; /* avoid double coercion */
49621 }
49622 break;
49623 }
49624
49625 /* Buffer has virtual properties similar to string, but indexed values
49626 * are numbers, not 1-byte buffers/strings which would perform badly.
49627 */
49628 case DUK_TAG_BUFFER: {
49629 duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
49630 duk_int_t pop_count;
49631
49632 /*
49633 * Because buffer values are often looped over, a number fast path
49634 * is important.
49635 */
49636
49637#if defined(DUK_USE_FASTINT)
49638 if (DUK_TVAL_IS_FASTINT(tv_key)) {
49639 arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
49640 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
49641 pop_count = 0;
49642 }
49643 else
49644#endif
49645 if (DUK_TVAL_IS_NUMBER(tv_key)) {
49646 arr_idx = duk__tval_number_to_arr_idx(tv_key);
49647 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx));
49648 pop_count = 0;
49649 } else {
49650 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49651 DUK_ASSERT(key != NULL);
49652 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
49653 "coercion key is %!T, arr_idx %ld",
49654 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
49655 pop_count = 1;
49656 }
49657
49658 if (arr_idx != DUK__NO_ARRAY_INDEX &&
49659 arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
49660 duk_pop_n(ctx, pop_count);
49661 duk_push_uint(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h))[arr_idx]);
49662
49663 DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is an index inside buffer length "
49664 "after coercion -> return byte as number)",
49665 (duk_tval *) duk_get_tval(ctx, -1)));
49666 return 1;
49667 }
49668
49669 if (pop_count == 0) {
49670 /* This is a pretty awkward control flow, but we need to recheck the
49671 * key coercion here.
49672 */
49673 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49674 DUK_ASSERT(key != NULL);
49675 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
49676 "coercion key is %!T, arr_idx %ld",
49677 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
49678 }
49679
49680 if (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
49681 key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) {
49682 duk_pop(ctx); /* [key] -> [] */
49683 duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h)); /* [] -> [res] */
49684
49685 DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'length' or 'byteLength' "
49686 "after coercion -> return buffer length)",
49687 (duk_tval *) duk_get_tval(ctx, -1)));
49688 return 1;
49689 } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) {
49690 duk_pop(ctx); /* [key] -> [] */
49691 duk_push_uint(ctx, 0); /* [] -> [res] */
49692
49693 DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'byteOffset' after coercion -> "
49694 "return 0 for consistency with Buffer objects)",
49695 (duk_tval *) duk_get_tval(ctx, -1)));
49696 return 1;
49697 } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) {
49698 duk_pop(ctx); /* [key] -> [] */
49699 duk_push_uint(ctx, 1); /* [] -> [res] */
49700
49701 DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'BYTES_PER_ELEMENT' after coercion -> "
49702 "return 1 for consistency with Buffer objects)",
49703 (duk_tval *) duk_get_tval(ctx, -1)));
49704 return 1;
49705 }
49706
49707 DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype"));
49708 curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE];
49709 goto lookup; /* avoid double coercion */
49710 }
49711
49712 case DUK_TAG_POINTER: {
49713 DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype"));
49714 curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE];
49715 break;
49716 }
49717
49718 case DUK_TAG_LIGHTFUNC: {
49719 duk_int_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_obj);
49720
49721 /* Must coerce key: if key is an object, it may coerce to e.g. 'length'. */
49722 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49723
49724 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
49725 duk_int_t lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
49726 duk_pop(ctx);
49727 duk_push_int(ctx, lf_len);
49728 return 1;
49729 } else if (key == DUK_HTHREAD_STRING_NAME(thr)) {
49730 duk_pop(ctx);
49731 duk_push_lightfunc_name(ctx, tv_obj);
49732 return 1;
49733 }
49734
49735 DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype"));
49736 curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
49737 goto lookup; /* avoid double coercion */
49738 }
49739
49740#if defined(DUK_USE_FASTINT)
49741 case DUK_TAG_FASTINT:
49742#endif
49743 default: {
49744 /* number */
49745 DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype"));
49748 curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE];
49749 break;
49750 }
49751 }
49752
49753 /* key coercion (unless already coerced above) */
49754 DUK_ASSERT(key == NULL);
49755 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49756 DUK_ASSERT(key != NULL);
49757
49758 /*
49759 * Property lookup
49760 */
49761
49762 lookup:
49763 /* [key] (coerced) */
49764 DUK_ASSERT(curr != NULL);
49765 DUK_ASSERT(key != NULL);
49766
49768 do {
49769 if (!duk__get_own_propdesc_raw(thr, curr, key, arr_idx, &desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
49770 goto next_in_chain;
49771 }
49772
49773 if (desc.get != NULL) {
49774 /* accessor with defined getter */
49776
49777 duk_pop(ctx); /* [key undefined] -> [key] */
49778 duk_push_hobject(ctx, desc.get);
49779 duk_push_tval(ctx, tv_obj); /* note: original, uncoerced base */
49780#ifdef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
49781 duk_dup(ctx, -3);
49782 duk_call_method(ctx, 1); /* [key getter this key] -> [key retval] */
49783#else
49784 duk_call_method(ctx, 0); /* [key getter this] -> [key retval] */
49785#endif
49786 } else {
49787 /* [key value] or [key undefined] */
49788
49789 /* data property or accessor without getter */
49791 (desc.get == NULL));
49792
49793 /* if accessor without getter, return value is undefined */
49795 duk_is_undefined(ctx, -1));
49796
49797 /* Note: for an accessor without getter, falling through to
49798 * check for "caller" exotic behavior is unnecessary as
49799 * "undefined" will never activate the behavior. But it does
49800 * no harm, so we'll do it anyway.
49801 */
49802 }
49803
49804 goto found; /* [key result] */
49805
49806 next_in_chain:
49807 /* XXX: option to pretend property doesn't exist if sanity limit is
49808 * hit might be useful.
49809 */
49810 if (sanity-- == 0) {
49812 }
49813 curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
49814 } while (curr);
49815
49816 /*
49817 * Not found
49818 */
49819
49820 duk_to_undefined(ctx, -1); /* [key] -> [undefined] (default value) */
49821
49822 DUK_DDD(DUK_DDDPRINT("-> %!T (not found)", (duk_tval *) duk_get_tval(ctx, -1)));
49823 return 0;
49824
49825 /*
49826 * Found; post-processing (Function and arguments objects)
49827 */
49828
49829 found:
49830 /* [key result] */
49831
49832#if !defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
49833 /* Special behavior for 'caller' property of (non-bound) function objects
49834 * and non-strict Arguments objects: if 'caller' -value- (!) is a strict
49835 * mode function, throw a TypeError (E5 Sections 15.3.5.4, 10.6).
49836 * Quite interestingly, a non-strict function with no formal arguments
49837 * will get an arguments object -without- special 'caller' behavior!
49838 *
49839 * The E5.1 spec is a bit ambiguous if this special behavior applies when
49840 * a bound function is the base value (not the 'caller' value): Section
49841 * 15.3.4.5 (describing bind()) states that [[Get]] for bound functions
49842 * matches that of Section 15.3.5.4 ([[Get]] for Function instances).
49843 * However, Section 13.3.5.4 has "NOTE: Function objects created using
49844 * Function.prototype.bind use the default [[Get]] internal method."
49845 * The current implementation assumes this means that bound functions
49846 * should not have the special [[Get]] behavior.
49847 *
49848 * The E5.1 spec is also a bit unclear if the TypeError throwing is
49849 * applied if the 'caller' value is a strict bound function. The
49850 * current implementation will throw even for both strict non-bound
49851 * and strict bound functions.
49852 *
49853 * See test-dev-strict-func-as-caller-prop-value.js for quite extensive
49854 * tests.
49855 *
49856 * This exotic behavior is disabled when the non-standard 'caller' property
49857 * is enabled, as it conflicts with the free use of 'caller'.
49858 */
49859 if (key == DUK_HTHREAD_STRING_CALLER(thr) &&
49860 DUK_TVAL_IS_OBJECT(tv_obj)) {
49861 duk_hobject *orig = DUK_TVAL_GET_OBJECT(tv_obj);
49862 DUK_ASSERT(orig != NULL);
49863
49866 duk_hobject *h;
49867
49868 /* XXX: The TypeError is currently not applied to bound
49869 * functions because the 'strict' flag is not copied by
49870 * bind(). This may or may not be correct, the specification
49871 * only refers to the value being a "strict mode Function
49872 * object" which is ambiguous.
49873 */
#define DUK_BIDX_POINTER_PROTOTYPE
DUK_INTERNAL_DECL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv)
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)
#define DUK_BIDX_NUMBER_PROTOTYPE
#define DUK_STR_PROTOTYPE_CHAIN_LIMIT
#define DUK_BIDX_BOOLEAN_PROTOTYPE
#define DUK_BIDX_BUFFER_PROTOTYPE
#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags)
#define DUK_HTHREAD_STRING_CALLER(thr)

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 49883 of file duktape-1.5.2/src/duktape.c.

49900 {
49901 duk_context *ctx = (duk_context *) thr;
49902 duk_tval tv_key_copy;
49903 duk_hobject *obj;
49904 duk_hstring *key;
49905 duk_uint32_t arr_idx;
49906 duk_bool_t rc;
49907 duk_propdesc desc;
49908
49909 DUK_DDD(DUK_DDDPRINT("hasprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
49910 (void *) thr, (void *) tv_obj, (void *) tv_key,
49911 (duk_tval *) tv_obj, (duk_tval *) tv_key));
49912
49913 DUK_ASSERT(thr != NULL);
49914 DUK_ASSERT(thr->heap != NULL);
49915 DUK_ASSERT(tv_obj != NULL);
49916 DUK_ASSERT(tv_key != NULL);
49918
49919 DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
49920 tv_key = &tv_key_copy;
49921
49922 /*
49923 * The 'in' operator requires an object as its right hand side,
49924 * throwing a TypeError unconditionally if this is not the case.
49925 *
49926 * However, lightfuncs need to behave like fully fledged objects
49927 * here to be maximally transparent, so we need to handle them
49928 * here.
49929 */
49930
49931 /* XXX: Refactor key coercion so that it's only called once. It can't
49932 * be trivially lifted here because the object must be type checked
49933 * first.
49934 */
49935
49936 if (DUK_TVAL_IS_OBJECT(tv_obj)) {
49937 obj = DUK_TVAL_GET_OBJECT(tv_obj);
49938 DUK_ASSERT(obj != NULL);
49939
49940 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49941 } else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) {
49942 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
49943 if (duk__key_is_lightfunc_ownprop(thr, key)) {
49944 /* FOUND */
49945 rc = 1;
49946 goto pop_and_return;
49947 }
49948
49949 /* If not found, resume existence check from Function.prototype.
49950 * We can just substitute the value in this case; nothing will
49951 * need the original base value (as would be the case with e.g.
49952 * setters/getters.
49953 */
49954 obj = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
49955 } else {
49956 /* Note: unconditional throw */
49957 DUK_DDD(DUK_DDDPRINT("base object is not an object -> reject"));
49959 }
49960
49961 /* XXX: fast path for arrays? */
49962
49963 DUK_ASSERT(key != NULL);
49964 DUK_ASSERT(obj != NULL);
49965 DUK_UNREF(arr_idx);
49966
49967#if defined(DUK_USE_ES6_PROXY)
49969 duk_hobject *h_target;
49970 duk_bool_t tmp_bool;
49971
49972 /* XXX: the key in 'key in obj' is string coerced before we're called
49973 * (which is the required behavior in E5/E5.1/E6) so the key is a string
49974 * here already.
49975 */
49976
49977 if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_HAS, tv_key, &h_target)) {
49978 /* [ ... key trap handler ] */
49979 DUK_DDD(DUK_DDDPRINT("-> proxy object 'has' for key %!T", (duk_tval *) tv_key));
49980 duk_push_hobject(ctx, h_target); /* target */
49981 duk_push_tval(ctx, tv_key); /* P */
49982 duk_call_method(ctx, 2 /*nargs*/);
49983 tmp_bool = duk_to_boolean(ctx, -1);
49984 if (!tmp_bool) {
49985 /* Target object must be checked for a conflicting
49986 * non-configurable property.
49987 */
49988
49989 if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */
49990 DUK_DDD(DUK_DDDPRINT("proxy 'has': target has matching property %!O, check for "
49991 "conflicting property; desc.flags=0x%08lx, "
49992 "desc.get=%p, desc.set=%p",
49993 (duk_heaphdr *) key, (unsigned long) desc.flags,
49994 (void *) desc.get, (void *) desc.set));
49995 /* XXX: Extensibility check for target uses IsExtensible(). If we
49996 * implemented the isExtensible trap and didn't reject proxies as
49997 * proxy targets, it should be respected here.
49998 */
49999 if (!((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && /* property is configurable and */
50000 DUK_HOBJECT_HAS_EXTENSIBLE(h_target))) { /* ... target is extensible */
50002 }
50003 }
50004 }
50005
#define DUK_STRIDX_HAS

◆ 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 50019 of file duktape-1.5.2/src/duktape.c.

50019 :
50020 duk_pop(ctx); /* [ key ] -> [] */
50021 return rc;
50022}
50023
50024/*
50025 * HASPROP variant used internally.
50026 *
50027 * This primitive must never throw an error, callers rely on this.
50028 * In particular, don't throw an error for prototype loops; instead,
50029 * pretend like the property doesn't exist if a prototype sanity limit
50030 * 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 51948 of file duktape-1.5.2/src/duktape.c.

51953 {
51954 return (duk_uint32_t) val;
51955 }
51956 return 0;
51957}
51958
51959/*
51960 * Object.getOwnPropertyDescriptor() (E5 Sections 15.2.3.3, 8.10.4)
51961 *
51962 * This is an actual function call.
51963 */
51964
51966 duk_hthread *thr = (duk_hthread *) ctx;
51967 duk_hobject *obj;
51968 duk_hstring *key;
51969 duk_propdesc pd;
51970 duk_bool_t rc;
51971
51972 DUK_ASSERT(ctx != NULL);
51973 DUK_ASSERT(thr != NULL);
51974 DUK_ASSERT(thr->heap != NULL);
51975
51977 (void) duk_to_string(ctx, 1);
51978 key = duk_require_hstring(ctx, 1);
51979
51980 DUK_ASSERT(obj != NULL);
51981 DUK_ASSERT(key != NULL);
51982
51984
51986 if (!rc) {
51987 duk_push_undefined(ctx);
51988
51989 /* [obj key undefined] */
51990 return 1;
51991 }
51992
51993 duk_push_object(ctx);
51994
51995 /* [obj key value desc] */
51996
51997 if (DUK_PROPDESC_IS_ACCESSOR(&pd)) {
51998 /* If a setter/getter is missing (undefined), the descriptor must
51999 * still have the property present with the value 'undefined'.
52000 */
52001 if (pd.get) {
52002 duk_push_hobject(ctx, pd.get);
52003 } else {
52004 duk_push_undefined(ctx);
52005 }
52007 if (pd.set) {
52008 duk_push_hobject(ctx, pd.set);
52009 } else {
52010 duk_push_undefined(ctx);
52011 }
#define DUK_PROPDESC_IS_ACCESSOR(p)

◆ 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 53105 of file duktape-1.5.2/src/duktape.c.

53122 {
53124
53125 DUK_ASSERT(obj != NULL);
53126 DUK_UNREF(thr);
53127
53128 /* Note: no allocation pressure, no need to check refcounts etc */
53129
53130 /* must not be extensible */
53131 if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {
53132 return 0;
53133 }
53134
53135 /* all virtual properties are non-configurable and non-writable */
53136
53137 /* entry part must not contain any configurable properties, or
53138 * writable properties (if is_frozen).
53139 */
53140 for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
53141 duk_small_uint_t flags;
53142
53143 if (!DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i)) {
53144 continue;
53145 }
53146
53147 /* avoid multiple computations of flags address; bypasses macros */
53148 flags = (duk_small_uint_t) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i);
53149
53150 if (flags & DUK_PROPDESC_FLAG_CONFIGURABLE) {
53151 return 0;
53152 }
53153 if (is_frozen &&
53154 !(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 53009 of file duktape-1.5.2/src/duktape.c.

53009 :
53011 return;
53012
53013 fail_not_configurable:
53015 return;
53016
53017 fail_array_length_partial:
53019 return;
53020}
53021
53022/*
53023 * Object.prototype.hasOwnProperty() and Object.prototype.propertyIsEnumerable().
53024 */
53025
53027 duk_hthread *thr = (duk_hthread *) ctx;
#define DUK_STR_ARRAY_LENGTH_WRITE_FAILED
#define DUK_STR_NOT_EXTENSIBLE

◆ 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 53044 of file duktape-1.5.2/src/duktape.c.

53061 {
53063
53064 DUK_ASSERT(thr != NULL);
53065 DUK_ASSERT(thr->heap != NULL);
53066 DUK_ASSERT(obj != NULL);
53067
53069
53070#if defined(DUK_USE_ROM_OBJECTS)
53072 DUK_DD(DUK_DDPRINT("attempt to seal/freeze a readonly object, reject"));
53074 }
53075#endif
53076
53077 /*
53078 * Abandon array part because all properties must become non-configurable.
53079 * Note that this is now done regardless of whether this is always the case
53080 * (skips check, but performance problem if caller would do this many times
53081 * for the same object; not likely).
53082 */
53083
53086
53087 for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
53088 duk_uint8_t *fp;
53089
53090 /* since duk__abandon_array_checked() causes a resize, there should be no gaps in keys */
53091 DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != NULL);
53092

◆ 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 46935 of file duktape-1.5.2/src/duktape.c.

46952 {
46953 duk_context *ctx = (duk_context *) thr;
46954 duk_hbuffer_dynamic *h_buf;
46955 duk_bitencoder_ctx be_ctx_alloc;
46956 duk_bitencoder_ctx *be_ctx = &be_ctx_alloc;
46957 duk_uint32_t *hdr;
46958 duk_size_t new_size;
46959 duk_uint_fast32_t num_header_entries;
46960 duk_uint_fast32_t curr_offset;
46961 duk_int_fast32_t curr_line, next_line, diff_line;
46962 duk_uint_fast32_t curr_pc;
46963 duk_uint_fast32_t hdr_index;
46964
46966
46967 /* XXX: add proper spare handling to dynamic buffer, to minimize
46968 * reallocs; currently there is no spare at all.
46969 */
46970
46971 num_header_entries = (length + DUK_PC2LINE_SKIP - 1) / DUK_PC2LINE_SKIP;
46972 curr_offset = (duk_uint_fast32_t) (sizeof(duk_uint32_t) + num_header_entries * sizeof(duk_uint32_t) * 2);
46973
46974 duk_push_dynamic_buffer(ctx, (duk_size_t) curr_offset);
46975 h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
46976 DUK_ASSERT(h_buf != NULL);
46978
46979 hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
46980 DUK_ASSERT(hdr != NULL);
46981 hdr[0] = (duk_uint32_t) length; /* valid pc range is [0, length[ */
46982
46983 curr_pc = 0U;
46984 while (curr_pc < length) {
46985 new_size = (duk_size_t) (curr_offset + DUK_PC2LINE_MAX_DIFF_LENGTH);
46986 duk_hbuffer_resize(thr, h_buf, new_size);
46987
46988 hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
46989 DUK_ASSERT(hdr != NULL);
46990 DUK_ASSERT(curr_pc < length);
46991 hdr_index = 1 + (curr_pc / DUK_PC2LINE_SKIP) * 2;
46992 curr_line = (duk_int_fast32_t) instrs[curr_pc].line;
46993 hdr[hdr_index + 0] = (duk_uint32_t) curr_line;
46994 hdr[hdr_index + 1] = (duk_uint32_t) curr_offset;
46995
46996#if 0
46997 DUK_DDD(DUK_DDDPRINT("hdr[%ld]: pc=%ld line=%ld offset=%ld",
46998 (long) (curr_pc / DUK_PC2LINE_SKIP),
46999 (long) curr_pc,
47000 (long) hdr[hdr_index + 0],
47001 (long) hdr[hdr_index + 1]));
47002#endif
47003
47004 DUK_MEMZERO(be_ctx, sizeof(*be_ctx));
47005 be_ctx->data = ((duk_uint8_t *) hdr) + curr_offset;
47007
47008 for (;;) {
47009 curr_pc++;
47010 if ( ((curr_pc % DUK_PC2LINE_SKIP) == 0) || /* end of diff run */
47011 (curr_pc >= length) ) { /* end of bytecode */
47012 break;
47013 }
47014 DUK_ASSERT(curr_pc < length);
47015 next_line = (duk_int32_t) instrs[curr_pc].line;
47016 diff_line = next_line - curr_line;
47017
47018#if 0
47019 DUK_DDD(DUK_DDDPRINT("curr_line=%ld, next_line=%ld -> diff_line=%ld",
47020 (long) curr_line, (long) next_line, (long) diff_line));
47021#endif
47022
47023 if (diff_line == 0) {
47024 /* 0 */
47025 duk_be_encode(be_ctx, 0, 1);
47026 } else if (diff_line >= 1 && diff_line <= 4) {
47027 /* 1 0 <2 bits> */
47028 duk_be_encode(be_ctx, (0x02 << 2) + (diff_line - 1), 4);
47029 } else if (diff_line >= -0x80 && diff_line <= 0x7f) {
47030 /* 1 1 0 <8 bits> */
47031 DUK_ASSERT(diff_line + 0x80 >= 0 && diff_line + 0x80 <= 0xff);
47032 duk_be_encode(be_ctx, (0x06 << 8) + (diff_line + 0x80), 11);
47033 } else {
47034 /* 1 1 1 <32 bits>
47035 * Encode in two parts to avoid bitencode 24-bit limitation
47036 */
47037 duk_be_encode(be_ctx, (0x07 << 16) + ((next_line >> 16) & 0xffffU), 19);
47038 duk_be_encode(be_ctx, next_line & 0xffffU, 16);
47039 }
47040
47041 curr_line = next_line;
47042 }
47043
duk_int32_t duk_int_fast32_t
#define DUK_PC2LINE_MAX_DIFF_LENGTH
#define DUK_PC2LINE_SKIP

◆ 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 47147 of file duktape-1.5.2/src/duktape.c.

47149 {
47150 /* 0: no change */
47151 }
47152
47153 n--;
47154 }
47155
47156 DUK_DDD(DUK_DDDPRINT("pc2line lookup result: pc %ld -> line %ld", (long) pc, (long) curr_line));
47157 return curr_line;
47158
47159 error:
47160 DUK_D(DUK_DPRINT("pc2line conversion failed for pc=%ld", (long) pc));
47161 return 0;
47162}
47163
47165 duk_hbuffer_fixed *pc2line;
47166 duk_uint_fast32_t line;
47167
47168 /* 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 52029 of file duktape-1.5.2/src/duktape.c.

52051 {
52052 duk_hthread *thr = (duk_hthread *) ctx;
52053 duk_idx_t idx_value = -1;
52054 duk_hobject *getter = NULL;
52055 duk_hobject *setter = NULL;
52056 duk_bool_t is_data_desc = 0;
52057 duk_bool_t is_acc_desc = 0;
52058 duk_uint_t defprop_flags = 0;
52059
52060 DUK_ASSERT(ctx != NULL);
52061 DUK_ASSERT(out_defprop_flags != NULL);
52062 DUK_ASSERT(out_idx_value != NULL);
52063 DUK_ASSERT(out_getter != NULL);
52064 DUK_ASSERT(out_setter != NULL);
52065
52066 /* Must be an object, otherwise TypeError (E5.1 Section 8.10.5, step 1). */
52067 idx_in = duk_require_normalize_index(ctx, idx_in);
52068 (void) duk_require_hobject(ctx, idx_in);
52069
52070 /* The coercion order must match the ToPropertyDescriptor() algorithm
52071 * so that side effects in coercion happen in the correct order.
52072 * (This order also happens to be compatible with duk_def_prop(),
52073 * although it doesn't matter in practice.)
52074 */
52075
52076 if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_VALUE)) {
52077 is_data_desc = 1;
52078 defprop_flags |= DUK_DEFPROP_HAVE_VALUE;
52079 idx_value = duk_get_top_index(ctx);
52080 /* Leave 'value' on stack */
52081 } else {
52082 duk_pop(ctx);
52083 }
52084
52085 if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_WRITABLE)) {
52086 is_data_desc = 1;
52087 if (duk_to_boolean(ctx, -1)) {
52089 } else {
52090 defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE;
52091 }
52092 }
52093 duk_pop(ctx);
52094
52095 if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_GET)) {
52096 duk_tval *tv = duk_require_tval(ctx, -1);
52097 duk_hobject *h_get;
52098
52099 if (DUK_TVAL_IS_UNDEFINED(tv)) {
52100 /* undefined is accepted */
52101 DUK_ASSERT(getter == NULL);
52102 } else {
52103 /* NOTE: lightfuncs are coerced to full functions because
52104 * lightfuncs don't fit into a property value slot. This
52105 * has some side effects, see test-dev-lightfunc-accessor.js.
52106 */
52107 h_get = duk_get_hobject_or_lfunc_coerce(ctx, -1);
52108 if (h_get == NULL || !DUK_HOBJECT_IS_CALLABLE(h_get)) {
52109 goto type_error;
52110 }
52111 getter = h_get;
52112 }
52113 is_acc_desc = 1;
52114 defprop_flags |= DUK_DEFPROP_HAVE_GETTER;
52115 /* Leave 'getter' on stack */
52116 } else {
52117 duk_pop(ctx);
52118 }
52119
52120 if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_SET)) {
52121 duk_tval *tv = duk_require_tval(ctx, -1);
52122 duk_hobject *h_set;
52123
52124 if (DUK_TVAL_IS_UNDEFINED(tv)) {
52125 /* undefined is accepted */
52126 DUK_ASSERT(setter == NULL);
52127 } else {
52128 /* NOTE: lightfuncs are coerced to full functions because
52129 * lightfuncs don't fit into a property value slot. This
52130 * has some side effects, see test-dev-lightfunc-accessor.js.
52131 */
52132 h_set = duk_get_hobject_or_lfunc_coerce(ctx, -1);
52133 if (h_set == NULL || !DUK_HOBJECT_IS_CALLABLE(h_set)) {
52134 goto type_error;
52135 }
52136 setter = h_set;
52137 }
52138 is_acc_desc = 1;
52139 defprop_flags |= DUK_DEFPROP_HAVE_SETTER;
52140 /* Leave 'setter' on stack */
52141 } else {
52142 duk_pop(ctx);
52143 }
52144
52145 if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_ENUMERABLE)) {
52146 if (duk_to_boolean(ctx, -1)) {
52148 } else {
52149 defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE;
52150 }
52151 }
52152 duk_pop(ctx);
52153
52154 if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_CONFIGURABLE)) {
52155 if (duk_to_boolean(ctx, -1)) {
52157 } else {
52158 defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE;
52159 }
52160 }
#define DUK_DEFPROP_CONFIGURABLE
#define DUK_DEFPROP_HAVE_CONFIGURABLE
#define DUK_DEFPROP_ENUMERABLE
#define DUK_DEFPROP_HAVE_ENUMERABLE
#define DUK_DEFPROP_WRITABLE
#define DUK_STRIDX_WRITABLE
#define DUK_STRIDX_VALUE

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 46874 of file duktape-1.5.2/src/duktape.c.

46877 : %!T",
46878 (void *) obj, (duk_tval *) duk_get_tval(ctx, -1)));
46879 }
46880 duk_pop_2(ctx); /* -> [...] */
46881
46882 DUK_ASSERT_TOP(ctx, entry_top);
46883}
46884#line 1 "duk_hobject_misc.c"
46885/*
46886 * Misc support functions
46887 */
46888
46889/* include removed: duk_internal.h */
46890
46891DUK_INTERNAL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, duk_hobject *h, duk_hobject *p, duk_bool_t ignore_loop) {
46892 duk_uint_t sanity;
46893
46894 DUK_ASSERT(thr != NULL);
46895
46896 /* False if the object is NULL or the prototype 'p' is NULL.
46897 * In particular, false if both are NULL (don't compare equal).
46898 */
46899 if (h == NULL || p == NULL) {
46900 return 0;
46901 }
46902
46903 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 47489 of file duktape-1.5.2/src/duktape.c.

47493 :
47494 *
47495 * arr_idx > limit'' * ((old_size + 7) / 8)
47496 */
47497
47498 return (arr_idx > DUK_HOBJECT_A_FAST_RESIZE_LIMIT * ((old_size + 7) >> 3));
47499}
47500
47501/*
47502 * Proxy helpers
47503 */
47504
47505#if defined(DUK_USE_ES6_PROXY)
47507 duk_tval *tv_target;
47508 duk_tval *tv_handler;
47509 duk_hobject *h_target;
47510 duk_hobject *h_handler;
47511
47512 DUK_ASSERT(thr != NULL);
47513 DUK_ASSERT(obj != NULL);
47514 DUK_ASSERT(out_target != NULL);
47515 DUK_ASSERT(out_handler != NULL);
47516
47517 /* Caller doesn't need to check exotic proxy behavior (but does so for
47518 * some fast paths).
47519 */
47521 return 0;
47522 }
47523
47525 if (!tv_handler) {
47527 return 0;
47528 }
47529 DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_handler));
47530 h_handler = DUK_TVAL_GET_OBJECT(tv_handler);
#define DUK_HTHREAD_STRING_INT_HANDLER(thr)
#define DUK_HOBJECT_A_FAST_RESIZE_LIMIT
#define DUK_STR_PROXY_REVOKED

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 50409 of file duktape-1.5.2/src/duktape.c.

50410 :
50411 *
50412 * - Preprocessing before and postprocessing after an actual property
50413 * write. For example, array index write requires pre-checking the
50414 * array 'length' property for access control, and may require an
50415 * array 'length' update after the actual write has succeeded (but
50416 * not if it fails).
50417 *
50418 * - Deletion of multiple entries, as a result of array 'length' write.
50419 *
50420 * * Input values are taken as pointers which may point to the valstack.
50421 * If valstack is resized because of the put (this may happen at least
50422 * when the array part is abandoned), the pointers can be invalidated.
50423 * (We currently make a copy of all of the input values to avoid issues.)
50424 */
50425
50426DUK_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) {
50427 duk_context *ctx = (duk_context *) thr;
50428 duk_tval tv_obj_copy;
50429 duk_tval tv_key_copy;
50430 duk_tval tv_val_copy;
50431 duk_hobject *orig = NULL; /* NULL if tv_obj is primitive */
50432 duk_hobject *curr;
50433 duk_hstring *key = NULL;
50434 duk_propdesc desc;
50435 duk_tval *tv;
50436 duk_uint32_t arr_idx;
50437 duk_bool_t rc;
50438 duk_int_t e_idx;
50439 duk_uint_t sanity;
50440 duk_uint32_t new_array_length = 0; /* 0 = no update */
50441
50442 DUK_DDD(DUK_DDDPRINT("putprop: thr=%p, obj=%p, key=%p, val=%p, throw=%ld "
50443 "(obj -> %!T, key -> %!T, val -> %!T)",
50444 (void *) thr, (void *) tv_obj, (void *) tv_key, (void *) tv_val,
50445 (long) throw_flag, (duk_tval *) tv_obj, (duk_tval *) tv_key, (duk_tval *) tv_val));
50446
50447 DUK_ASSERT(thr != NULL);
50448 DUK_ASSERT(thr->heap != NULL);
50449 DUK_ASSERT(ctx != NULL);
50450 DUK_ASSERT(tv_obj != NULL);
50451 DUK_ASSERT(tv_key != NULL);
50452 DUK_ASSERT(tv_val != NULL);
50453
50455
50456 /*
50457 * Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of
50458 * them being invalidated by a valstack resize.
50459 *
50460 * XXX: this is an overkill for some paths, so optimize this later
50461 * (or maybe switch to a stack arguments model entirely).
50462 */
50463
50464 DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj);
50465 DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
50466 DUK_TVAL_SET_TVAL(&tv_val_copy, tv_val);
50467 tv_obj = &tv_obj_copy;
50468 tv_key = &tv_key_copy;
50469 tv_val = &tv_val_copy;
50470
50471 /*
50472 * Coercion and fast path processing.
50473 */
50474
50475 switch (DUK_TVAL_GET_TAG(tv_obj)) {
50476 case DUK_TAG_UNDEFINED:
50477 case DUK_TAG_NULL: {
50478 /* Note: unconditional throw */
50479 DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject (object=%!iT)",
50480 (duk_tval *) tv_obj));
50481#if defined(DUK_USE_PARANOID_ERRORS)
50483#else
50484 DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot write property %s of %s",
50486#endif
50487 return 0;
50488 }
50489
50490 case DUK_TAG_BOOLEAN: {
50491 DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype"));
50492 curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE];
50493 break;
50494 }
50495
50496 case DUK_TAG_STRING: {
50497 duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
50498
50499 /*
50500 * Note: currently no fast path for array index writes.
50501 * They won't be possible anyway as strings are immutable.
50502 */
50503
50504 DUK_ASSERT(key == NULL);
50505 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
50506 DUK_ASSERT(key != NULL);
50507
50508 if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
50509 goto fail_not_writable;
50510 }
50511
50512 if (arr_idx != DUK__NO_ARRAY_INDEX &&
50513 arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
50514 goto fail_not_writable;
50515 }
50516
50517 DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype"));
50518 curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE];
50519 goto lookup; /* avoid double coercion */
50520 }
50521
50522 case DUK_TAG_OBJECT: {
50523 orig = DUK_TVAL_GET_OBJECT(tv_obj);
50524 DUK_ASSERT(orig != NULL);
50525
50526#if defined(DUK_USE_ROM_OBJECTS)
50527 /* With this check in place fast paths won't need read-only
50528 * object checks. This is technically incorrect if there are
50529 * setters that cause no writes to ROM objects, but current
50530 * built-ins don't have such setters.
50531 */
50532 if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) orig)) {
50533 DUK_DD(DUK_DDPRINT("attempt to putprop on read-only target object"));
50534 goto fail_not_writable_no_pop; /* Must avoid duk_pop() in exit path */
50535 }
50536#endif
50537
50538 /* The fast path for array property put is not fully compliant:
50539 * If one places conflicting number-indexed properties into
50540 * Array.prototype (for example, a non-writable Array.prototype[7])
50541 * the fast path will incorrectly ignore them.
50542 *
50543 * This fast path could be made compliant by falling through
50544 * to the slow path if the previous value was UNUSED. This would
50545 * also remove the need to check for extensibility. Right now a
50546 * non-extensible array is slower than an extensible one as far
50547 * as writes are concerned.
50548 *
50549 * The fast path behavior is documented in more detail here:
50550 * tests/ecmascript/test-misc-array-fast-write.js
50551 */
50552
50553 if (duk__putprop_shallow_fastpath_array_tval(thr, orig, tv_key, tv_val, &desc) != 0) {
50554 DUK_DDD(DUK_DDDPRINT("array fast path success"));
50555 return 1;
50556 }
50557
50558 if (duk__putprop_fastpath_bufobj_tval(thr, orig, tv_key, tv_val) != 0) {
50559 DUK_DDD(DUK_DDDPRINT("base is bufobj, key is a number, bufferobject fast path"));
50560 return 1;
50561 }
50562
50563#if defined(DUK_USE_ES6_PROXY)
50565 duk_hobject *h_target;
50566 duk_bool_t tmp_bool;
50567
50568 if (duk__proxy_check_prop(thr, orig, DUK_STRIDX_SET, tv_key, &h_target)) {
50569 /* -> [ ... trap handler ] */
50570 DUK_DDD(DUK_DDDPRINT("-> proxy object 'set' for key %!T", (duk_tval *) tv_key));
50571 duk_push_hobject(ctx, h_target); /* target */
50572 duk_push_tval(ctx, tv_key); /* P */
50573 duk_push_tval(ctx, tv_val); /* V */
50574 duk_push_tval(ctx, tv_obj); /* Receiver: Proxy object */
50575 duk_call_method(ctx, 4 /*nargs*/);
50576 tmp_bool = duk_to_boolean(ctx, -1);
50577 duk_pop(ctx);
50578 if (!tmp_bool) {
50579 goto fail_proxy_rejected;
50580 }
50581
50582 /* Target object must be checked for a conflicting
50583 * non-configurable property.
50584 */
50585 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
50586 DUK_ASSERT(key != NULL);
50587
50588 if (duk__get_own_propdesc_raw(thr, h_target, key, arr_idx, &desc, DUK_GETDESC_FLAG_PUSH_VALUE)) {
50589 duk_tval *tv_targ = duk_require_tval(ctx, -1);
50590 duk_bool_t datadesc_reject;
50591 duk_bool_t accdesc_reject;
50592
50593 DUK_DDD(DUK_DDDPRINT("proxy 'set': target has matching property %!O, check for "
50594 "conflicting property; tv_val=%!T, tv_targ=%!T, desc.flags=0x%08lx, "
50595 "desc.get=%p, desc.set=%p",
50596 (duk_heaphdr *) key, (duk_tval *) tv_val, (duk_tval *) tv_targ,
50597 (unsigned long) desc.flags,
50598 (void *) desc.get, (void *) desc.set));
50599
50600 datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
50603 !duk_js_samevalue(tv_val, tv_targ);
50604 accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
50606 (desc.set == NULL);
50607 if (datadesc_reject || accdesc_reject) {
50609 }
50610
50611 duk_pop_2(ctx);
50612 } else {
50613 duk_pop(ctx);
50614 }
50615 return 1; /* success */
50616 }
50617
50618 orig = h_target; /* resume write to target */
50619 DUK_TVAL_SET_OBJECT(tv_obj, orig);
50620 }
50621#endif /* DUK_USE_ES6_PROXY */
50622
50623 curr = orig;
50624 break;
50625 }
50626
50627 case DUK_TAG_BUFFER: {
50628 duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
50629 duk_int_t pop_count = 0;
50630
50631 /*
50632 * Because buffer values may be looped over and read/written
50633 * from, an array index fast path is important.
50634 */
50635
50636#if defined(DUK_USE_FASTINT)
50637 if (DUK_TVAL_IS_FASTINT(tv_key)) {
50638 arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
50639 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
50640 pop_count = 0;
50641 } else
50642#endif
50643 if (DUK_TVAL_IS_NUMBER(tv_key)) {
50644 arr_idx = duk__tval_number_to_arr_idx(tv_key);
50645 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx));
50646 pop_count = 0;
50647 } else {
50648 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
50649 DUK_ASSERT(key != NULL);
50650 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
50651 "coercion key is %!T, arr_idx %ld",
50652 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
50653 pop_count = 1;
50654 }
50655
50656 if (arr_idx != DUK__NO_ARRAY_INDEX &&
50657 arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
50658 duk_uint8_t *data;
50659 DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx));
50660 data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);
50661
50662 /* XXX: duk_to_int() ensures we'll get 8 lowest bits as
50663 * as input is within duk_int_t range (capped outside it).
50664 */
50665#if defined(DUK_USE_FASTINT)
50666 /* Buffer writes are often integers. */
50667 if (DUK_TVAL_IS_FASTINT(tv_val)) {
50668 data[arr_idx] = (duk_uint8_t) DUK_TVAL_GET_FASTINT_U32(tv_val);
50669 }
50670 else
50671#endif
50672 {
50673 duk_push_tval(ctx, tv_val);
50674 data[arr_idx] = (duk_uint8_t) duk_to_uint32(ctx, -1);
50675 pop_count++;
50676 }
50677
50678 duk_pop_n(ctx, pop_count);
50679 DUK_DDD(DUK_DDDPRINT("result: success (buffer data write)"));
50680 return 1;
50681 }
50682
50683 if (pop_count == 0) {
50684 /* This is a pretty awkward control flow, but we need to recheck the
50685 * key coercion here.
50686 */
50687 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
50688 DUK_ASSERT(key != NULL);
50689 DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
50690 "coercion key is %!T, arr_idx %ld",
50691 (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
50692 }
50693
50694 if (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
50695 key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr) ||
50696 key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr) ||
50698 goto fail_not_writable;
50699 }
50700
50701 DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype"));
50702 curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE];
50703 goto lookup; /* avoid double coercion */
50704 }
50705
50706 case DUK_TAG_POINTER: {
50707 DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype"));
50708 curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE];
50709 break;
50710 }
50711
50712 case DUK_TAG_LIGHTFUNC: {
50713 /* All lightfunc own properties are non-writable and the lightfunc
50714 * is considered non-extensible. However, the write may be captured
50715 * by an inherited setter which means we can't stop the lookup here.
50716 */
50717
50718 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
50719
50720 if (duk__key_is_lightfunc_ownprop(thr, key)) {
50721 goto fail_not_writable;
50722 }
50723
50724 DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype"));
50725 curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
50726 goto lookup; /* avoid double coercion */
50727 }
50728
50729#if defined(DUK_USE_FASTINT)
50730 case DUK_TAG_FASTINT:
50731#endif
50732 default: {
50733 /* number */
50734 DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype"));
50736 curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE];
50737 break;
50738 }
50739 }
50740
50741 DUK_ASSERT(key == NULL);
50742 arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
50743 DUK_ASSERT(key != NULL);
50744
50745 lookup:
50746
50747 /*
50748 * Check whether the property already exists in the prototype chain.
50749 * Note that the actual write goes into the original base object
50750 * (except if an accessor property captures the write).
50751 */
50752
50753 /* [key] */
50754
50755 DUK_ASSERT(curr != NULL);
50757 do {
50758 if (!duk__get_own_propdesc_raw(thr, curr, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */
50759 goto next_in_chain;
50760 }
50761
50762 if (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
50763 /*
50764 * Found existing accessor property (own or inherited).
50765 * Call setter with 'this' set to orig, and value as the only argument.
50766 * Setter calls are OK even for ROM objects.
50767 *
50768 * Note: no exotic arguments object behavior, because [[Put]] never
50769 * calls [[DefineOwnProperty]] (E5 Section 8.12.5, step 5.b).
50770 */
50771
50772 duk_hobject *setter;
50773
50774 DUK_DD(DUK_DDPRINT("put to an own or inherited accessor, calling setter"));
50775
50776 setter = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, curr, desc.e_idx);
50777 if (!setter) {
50778 goto fail_no_setter;
50779 }
50780 duk_push_hobject(ctx, setter);
50781 duk_push_tval(ctx, tv_obj); /* note: original, uncoerced base */
50782 duk_push_tval(ctx, tv_val); /* [key setter this val] */
50783#ifdef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
50784 duk_dup(ctx, -4);
50785 duk_call_method(ctx, 2); /* [key setter this val key] -> [key retval] */
50786#else
50787 duk_call_method(ctx, 1); /* [key setter this val] -> [key retval] */
50788#endif
50789 duk_pop(ctx); /* ignore retval -> [key] */
50790 goto success_no_arguments_exotic;
50791 }
50792
50793 if (orig == NULL) {
50794 /*
50795 * Found existing own or inherited plain property, but original
50796 * base is a primitive value.
50797 */
50798 DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object"));
50799 goto fail_base_primitive;
50800 }
50801
50802 if (curr != orig) {
50803 /*
50804 * Found existing inherited plain property.
50805 * Do an access control check, and if OK, write
50806 * new property to 'orig'.
50807 */
50808 if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) {
50809 DUK_DD(DUK_DDPRINT("found existing inherited plain property, but original object is not extensible"));
50810 goto fail_not_extensible;
50811 }
50812 if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
50813 DUK_DD(DUK_DDPRINT("found existing inherited plain property, original object is extensible, but inherited property is not writable"));
50814 goto fail_not_writable;
50815 }
50816 DUK_DD(DUK_DDPRINT("put to new property, object extensible, inherited property found and is writable"));
50817 goto create_new;
50818 } else {
50819 /*
50820 * Found existing own (non-inherited) plain property.
50821 * Do an access control check and update in place.
50822 */
50823
50824 if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
50825 DUK_DD(DUK_DDPRINT("found existing own (non-inherited) plain property, but property is not writable"));
50826 goto fail_not_writable;
50827 }
50828 if (desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) {
50829 DUK_DD(DUK_DDPRINT("found existing own (non-inherited) virtual property, property is writable"));
50830 if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) {
50831 duk_hbufferobject *h_bufobj;
50832 duk_uint_t byte_off;
50833 duk_small_uint_t elem_size;
50834
50835 h_bufobj = (duk_hbufferobject *) curr;
50837
50838 DUK_DD(DUK_DDPRINT("writable virtual property is in buffer object"));
50839
50840 /* Careful with wrapping: arr_idx upshift may easily wrap, whereas
50841 * length downshift won't.
50842 */
50843 if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) {
50844 duk_uint8_t *data;
50845 DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx));
50846
50847 DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX); /* index/length check guarantees */
50848 byte_off = arr_idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */
50849 elem_size = 1 << h_bufobj->shift;
50850
50851 /* Coerce to number before validating pointers etc so that the
50852 * number coercions in duk_hbufferobject_validated_write() are
50853 * guaranteed to be side effect free and not invalidate the
50854 * pointer checks we do here.
50855 */
50856 duk_push_tval(ctx, tv_val);
50857 duk_to_number(ctx, -1);
50858
50859 if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) {
50860 data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off;
50861 duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size);
50862 } else {
50863 DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)"));
50864 }
50865 duk_pop(ctx);
50866 goto success_no_arguments_exotic;
50867 }
50868 }
50869
50870 goto fail_internal; /* should not happen */
50871 }
50872 DUK_DD(DUK_DDPRINT("put to existing own plain property, property is writable"));
50873 goto update_old;
50874 }
50876
50877 next_in_chain:
50878 /* XXX: option to pretend property doesn't exist if sanity limit is
50879 * hit might be useful.
50880 */
50881 if (sanity-- == 0) {
50883 }
50884 curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
50885 } while (curr);
50886
50887 /*
50888 * Property not found in prototype chain.
50889 */
50890
50891 DUK_DDD(DUK_DDDPRINT("property not found in prototype chain"));
50892
50893 if (orig == NULL) {
50894 DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object"));
50895 goto fail_base_primitive;
50896 }
50897
50898 if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) {
50899 DUK_DD(DUK_DDPRINT("put to a new property (not found in prototype chain), but original object not extensible"));
50900 goto fail_not_extensible;
50901 }
50902
50903 goto create_new;
50904
50905 update_old:
50906
50907 /*
50908 * Update an existing property of the base object.
50909 */
50910
50911 /* [key] */
50912
50913 DUK_DDD(DUK_DDDPRINT("update an existing property of the original object"));
50914
50915 DUK_ASSERT(orig != NULL);
50916#if defined(DUK_USE_ROM_OBJECTS)
50917 /* This should not happen because DUK_TAG_OBJECT case checks
50918 * for this already, but check just in case.
50919 */
50920 if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) orig)) {
50921 goto fail_not_writable;
50922 }
50923#endif
50924
50925 /* Although there are writable virtual properties (e.g. plain buffer
50926 * and buffer object number indices), they are handled before we come
50927 * here.
50928 */
50930 DUK_ASSERT(desc.a_idx >= 0 || desc.e_idx >= 0);
50931
50932 if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
50933 key == DUK_HTHREAD_STRING_LENGTH(thr)) {
50934 /*
50935 * Write to 'length' of an array is a very complex case
50936 * handled in a helper which updates both the array elements
50937 * and writes the new 'length'. The write may result in an
50938 * unconditional RangeError or a partial write (indicated
50939 * by a return code).
50940 *
50941 * Note: the helper has an unnecessary writability check
50942 * for 'length', we already know it is writable.
50943 */
50944
50945 DUK_DDD(DUK_DDDPRINT("writing existing 'length' property to array exotic, invoke complex helper"));
50946
50947 /* XXX: the helper currently assumes stack top contains new
50948 * 'length' value and the whole calling convention is not very
50949 * compatible with what we need.
50950 */
50951
50952 duk_push_tval(ctx, tv_val); /* [key val] */
50953 rc = duk__handle_put_array_length(thr, orig);
50954 duk_pop(ctx); /* [key val] -> [key] */
50955 if (!rc) {
50956 goto fail_array_length_partial;
50957 }
50958
50959 /* key is 'length', cannot match argument exotic behavior */
50960 goto success_no_arguments_exotic;
50961 }
50962
50963 if (desc.e_idx >= 0) {
50964 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
50965 DUK_DDD(DUK_DDDPRINT("previous entry value: %!iT", (duk_tval *) tv));
50966 DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val); /* side effects */
50967 /* don't touch property attributes or hash part */
50968 DUK_DD(DUK_DDPRINT("put to an existing entry at index %ld -> new value %!iT",
50969 (long) desc.e_idx, (duk_tval *) tv));
50970 } else {
50971 /* Note: array entries are always writable, so the writability check
50972 * above is pointless for them. The check could be avoided with some
50973 * refactoring but is probably not worth it.
50974 */
50975
50976 DUK_ASSERT(desc.a_idx >= 0);
50977 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, desc.a_idx);
50978 DUK_DDD(DUK_DDDPRINT("previous array value: %!iT", (duk_tval *) tv));
50979 DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val); /* side effects */
50980 DUK_DD(DUK_DDPRINT("put to an existing array entry at index %ld -> new value %!iT",
50981 (long) desc.a_idx, (duk_tval *) tv));
50982 }
50983
50984 /* Regardless of whether property is found in entry or array part,
50985 * it may have arguments exotic behavior (array indices may reside
50986 * in entry part for abandoned / non-existent array parts).
50987 */
50988 goto success_with_arguments_exotic;
50989
50990 create_new:
50991
50992 /*
50993 * Create a new property in the original object.
50994 *
50995 * Exotic properties need to be reconsidered here from a write
50996 * perspective (not just property attributes perspective).
50997 * However, the property does not exist in the object already,
50998 * so this limits the kind of exotic properties that apply.
50999 */
51000
51001 /* [key] */
51002
51003 DUK_DDD(DUK_DDDPRINT("create new property to original object"));
51004
51005 DUK_ASSERT(orig != NULL);
51006
51007#if defined(DUK_USE_ROM_OBJECTS)
51008 /* This should not happen because DUK_TAG_OBJECT case checks
51009 * for this already, but check just in case.
51010 */
51011 if (DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) orig)) {
51012 goto fail_not_writable;
51013 }
51014#endif
51015
51016 /* Not possible because array object 'length' is present
51017 * from its creation and cannot be deleted, and is thus
51018 * caught as an existing property above.
51019 */
51021 key == DUK_HTHREAD_STRING_LENGTH(thr)));
51022
51023 if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
51024 arr_idx != DUK__NO_ARRAY_INDEX) {
51025 /* automatic length update */
51026 duk_uint32_t old_len;
51027
51028 old_len = duk__get_old_array_length(thr, orig, &desc);
51029
51030 if (arr_idx >= old_len) {
51031 DUK_DDD(DUK_DDDPRINT("write new array entry requires length update "
51032 "(arr_idx=%ld, old_len=%ld)",
51033 (long) arr_idx, (long) old_len));
51034
51035 if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
51036 DUK_DD(DUK_DDPRINT("attempt to extend array, but array 'length' is not writable"));
51037 goto fail_not_writable;
51038 }
51039
51040 /* Note: actual update happens once write has been completed
51041 * without error below. The write should always succeed
51042 * from a specification viewpoint, but we may e.g. run out
51043 * of memory. It's safer in this order.
51044 */
51045
51046 DUK_ASSERT(arr_idx != 0xffffffffUL);
51047 new_array_length = arr_idx + 1; /* flag for later write */
51048 } else {
51049 DUK_DDD(DUK_DDDPRINT("write new array entry does not require length update "
51050 "(arr_idx=%ld, old_len=%ld)",
51051 (long) arr_idx, (long) old_len));
51052 }
51053 }
51054
51055 /* write_to_array_part: */
51056
51057 /*
51058 * Write to array part?
51059 *
51060 * Note: array abandonding requires a property resize which uses
51061 * 'rechecks' valstack for temporaries and may cause any existing
51062 * valstack pointers to be invalidated. To protect against this,
51063 * tv_obj, tv_key, and tv_val are copies of the original inputs.
51064 */
51065
51066 if (arr_idx != DUK__NO_ARRAY_INDEX &&
51068 if (arr_idx < DUK_HOBJECT_GET_ASIZE(orig)) {
51069 goto no_array_growth;
51070 }
51071
51072 /*
51073 * Array needs to grow, but we don't want it becoming too sparse.
51074 * If it were to become sparse, abandon array part, moving all
51075 * array entries into the entries part (for good).
51076 *
51077 * Since we don't keep track of actual density (used vs. size) of
51078 * the array part, we need to estimate somehow. The check is made
51079 * in two parts:
51080 *
51081 * - Check whether the resize need is small compared to the
51082 * current size (relatively); if so, resize without further
51083 * checking (essentially we assume that the original part is
51084 * "dense" so that the result would be dense enough).
51085 *
51086 * - Otherwise, compute the resize using an actual density
51087 * measurement based on counting the used array entries.
51088 */
51089
51090 DUK_DDD(DUK_DDDPRINT("write to new array requires array resize, decide whether to do a "
51091 "fast resize without abandon check (arr_idx=%ld, old_size=%ld)",
51092 (long) arr_idx, (long) DUK_HOBJECT_GET_ASIZE(orig)));
51093
51095 duk_uint32_t old_used;
51096 duk_uint32_t old_size;
51097
51098 DUK_DDD(DUK_DDDPRINT("=> fast check is NOT OK, do slow check for array abandon"));
51099
51100 duk__compute_a_stats(thr, orig, &old_used, &old_size);
51101
51102 DUK_DDD(DUK_DDDPRINT("abandon check, array stats: old_used=%ld, old_size=%ld, arr_idx=%ld",
51103 (long) old_used, (long) old_size, (long) arr_idx));
51104
51105 /* Note: intentionally use approximations to shave a few instructions:
51106 * a_used = old_used (accurate: old_used + 1)
51107 * a_size = arr_idx (accurate: arr_idx + 1)
51108 */
51109 if (duk__abandon_array_density_check(old_used, arr_idx)) {
51110 DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, "
51111 "decided to abandon array part (would become too sparse)"));
51112
51113 /* abandoning requires a props allocation resize and
51114 * 'rechecks' the valstack, invalidating any existing
51115 * valstack value pointers!
51116 */
51117 duk__abandon_array_checked(thr, orig);
51119
51120 goto write_to_entry_part;
51121 }
51122
51123 DUK_DDD(DUK_DDDPRINT("=> decided to keep array part"));
51124 } else {
51125 DUK_DDD(DUK_DDDPRINT("=> fast resize is OK"));
51126 }
51127
51128 DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, "
51129 "decided to extend current allocation"));
51130
51131 duk__grow_props_for_array_item(thr, orig, arr_idx);
51132
51133 no_array_growth:
51134
51135 /* Note: assume array part is comprehensive, so that either
51136 * the write goes to the array part, or we've abandoned the
51137 * array above (and will not come here).
51138 */
51139
51141 DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(orig));
51142
51143 tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx);
51144 /* prev value must be unused, no decref */
51146 DUK_TVAL_SET_TVAL(tv, tv_val);
51147 DUK_TVAL_INCREF(thr, tv);
51148 DUK_DD(DUK_DDPRINT("put to new array entry: %ld -> %!T",
51149 (long) arr_idx, (duk_tval *) tv));
51150
51151 /* Note: array part values are [[Writable]], [[Enumerable]],
51152 * and [[Configurable]] which matches the required attributes
51153 * here.
51154 */
51155 goto entry_updated;
51156 }
51157
51158 write_to_entry_part:
51159
51160 /*
51161 * Write to entry part
51162 */
51163
51164 /* entry allocation updates hash part and increases the key
51165 * refcount; may need a props allocation resize but doesn't
51166 * 'recheck' the valstack.
51167 */
51168 e_idx = duk__alloc_entry_checked(thr, orig, key);
51169 DUK_ASSERT(e_idx >= 0);
51170
51171 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, e_idx);
51172 /* prev value can be garbage, no decref */
51173 DUK_TVAL_SET_TVAL(tv, tv_val);
51174 DUK_TVAL_INCREF(thr, tv);
51175 DUK_HOBJECT_E_SET_FLAGS(thr->heap, orig, e_idx, DUK_PROPDESC_FLAGS_WEC);
51176 goto entry_updated;
51177
51178 entry_updated:
51179
51180 /*
51181 * Possible pending array length update, which must only be done
51182 * if the actual entry write succeeded.
51183 */
51184
51185 if (new_array_length > 0) {
51186 /*
51187 * Note: zero works as a "no update" marker because the new length
51188 * can never be zero after a new property is written.
51189 *
51190 * Note: must re-lookup because calls above (e.g. duk__alloc_entry_checked())
51191 * may realloc and compact properties and hence change e_idx.
51192 */
51193
51194 DUK_DDD(DUK_DDDPRINT("write successful, pending array length update to: %ld",
51195 (long) new_array_length));
51196
51197 rc = duk__get_own_propdesc_raw(thr, orig, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &desc, 0 /*flags*/); /* don't push value */
51198 DUK_UNREF(rc);
51199 DUK_ASSERT(rc != 0);
51200 DUK_ASSERT(desc.e_idx >= 0);
51201
51202 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
51204 /* no need for decref/incref because value is a number */
51205 DUK_TVAL_SET_FASTINT_U32(tv, new_array_length);
51206 }
51207
51208 /*
51209 * Arguments exotic behavior not possible for new properties: all
51210 * magically bound properties are initially present in the arguments
51211 * object, and if they are deleted, the binding is also removed from
51212 * parameter map.
51213 */
51214
51215 goto success_no_arguments_exotic;
51216
51217 success_with_arguments_exotic:
51218
51219 /*
51220 * Arguments objects have exotic [[DefineOwnProperty]] which updates
51221 * the internal 'map' of arguments for writes to currently mapped
51222 * arguments. More conretely, writes to mapped arguments generate
51223 * a write to a bound variable.
51224 *
51225 * The [[Put]] algorithm invokes [[DefineOwnProperty]] for existing
51226 * data properties and new properties, but not for existing accessors.
51227 * Hence, in E5 Section 10.6 ([[DefinedOwnProperty]] algorithm), we
51228 * have a Desc with 'Value' (and possibly other properties too), and
51229 * we end up in step 5.b.i.
51230 */
51231
51232 if (arr_idx != DUK__NO_ARRAY_INDEX &&
51234 /* Note: only numbered indices are relevant, so arr_idx fast reject
51235 * is good (this is valid unless there are more than 4**32-1 arguments).
51236 */
51237
51238 DUK_DDD(DUK_DDDPRINT("putprop successful, arguments exotic behavior needed"));
51239
51240 /* Note: we can reuse 'desc' here */
51241
51242 /* XXX: top of stack must contain value, which helper doesn't touch,
51243 * rework to use tv_val directly?
51244 */
51245
51246 duk_push_tval(ctx, tv_val);
51247 (void) duk__check_arguments_map_for_put(thr, orig, key, &desc, throw_flag);
51248 duk_pop(ctx);
51249 }
51250 /* fall thru */
51251
51252 success_no_arguments_exotic:
51253 /* shared exit path now */
51254 DUK_DDD(DUK_DDDPRINT("result: success"));
51255 duk_pop(ctx); /* remove key */
51256 return 1;
51257
51258#if defined(DUK_USE_ES6_PROXY)
51259 fail_proxy_rejected:
51260 DUK_DDD(DUK_DDDPRINT("result: error, proxy rejects"));
51261 if (throw_flag) {
51263 }
51264 /* Note: no key on stack */
51265 return 0;
51266#endif
51267
51268 fail_base_primitive:
51269 DUK_DDD(DUK_DDDPRINT("result: error, base primitive"));
51270 if (throw_flag) {
51271#if defined(DUK_USE_PARANOID_ERRORS)
51273#else
51274 DUK_ERROR_FMT2(thr, DUK_ERR_TYPE_ERROR, "cannot write property %s of %s",
51276#endif
51277 }
51278 duk_pop(ctx); /* remove key */
51279 return 0;
51280
51281 fail_not_extensible:
51282 DUK_DDD(DUK_DDDPRINT("result: error, not extensible"));
51283 if (throw_flag) {
51285 }
51286 duk_pop(ctx); /* remove key */
51287 return 0;
51288
51289 fail_not_writable:
51290 DUK_DDD(DUK_DDDPRINT("result: error, not writable"));
51291 if (throw_flag) {
51293 }
51294 duk_pop(ctx); /* remove key */
51295 return 0;
51296
51297#if defined(DUK_USE_ROM_OBJECTS)
51298 fail_not_writable_no_pop:
51299 DUK_DDD(DUK_DDDPRINT("result: error, not writable"));
51300 if (throw_flag) {
51302 }
51303 return 0;
51304#endif
51305
51306 fail_array_length_partial:
51307 DUK_DDD(DUK_DDDPRINT("result: error, array length write only partially successful"));
51308 if (throw_flag) {
51310 }
51311 duk_pop(ctx); /* remove key */
51312 return 0;
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 duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj)
DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required(duk_uint32_t arr_idx, duk_uint32_t old_size)

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 47537 of file duktape-1.5.2/src/duktape.c.

47554 {
47555 duk_hobject *h_target;
47556 duk_hobject *h_handler;
47557
47558 DUK_ASSERT(thr != NULL);
47559 DUK_ASSERT(obj != NULL);
47560

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 46811 of file duktape-1.5.2/src/duktape.c.

46811 {
46812 DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable"));
46813 return 0;
46814 }
46815 duk_dup(ctx, -2);
46817 DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer"));
46818 duk_call(ctx, 2); /* [ ... obj finalizer obj heapDestruct ] -> [ ... obj retval ] */
46819 DUK_DDD(DUK_DDDPRINT("finalizer finished successfully"));
46820 return 0;
46821
46822 /* Note: we rely on duk_safe_call() to fix up the stack for the caller,
46823 * so we don't need to pop stuff here. There is no return value;
46824 * caller determines rescued status based on object refcount.
46825 */
46826}
46827
46829 duk_context *ctx = (duk_context *) thr;
46830 duk_ret_t rc;
46831#ifdef DUK_USE_ASSERTIONS
46832 duk_idx_t entry_top;
46833#endif
46834
46835 DUK_DDD(DUK_DDDPRINT("running object finalizer for object: %p", (void *) obj));
46836
46837 DUK_ASSERT(thr != NULL);
46838 DUK_ASSERT(ctx != NULL);
46839 DUK_ASSERT(obj != NULL);
46841
46842#ifdef DUK_USE_ASSERTIONS
46843 entry_top = duk_get_top(ctx);
46844#endif
46845 /*
46846 * Get and call the finalizer. All of this must be wrapped
46847 * in a protected call, because even getting the finalizer
46848 * may trigger an error (getter may throw one, for instance).
46849 */
46850
46853 DUK_D(DUK_DPRINT("object already finalized, avoid running finalizer twice: %!O", obj));
46854 return;
46855 }
46856 DUK_HEAPHDR_SET_FINALIZED((duk_heaphdr *) obj); /* ensure never re-entered until rescue cycle complete */
46858 /* This shouldn't happen; call sites should avoid looking up
46859 * _Finalizer "through" a Proxy, but ignore if we come here
46860 * with a Proxy to avoid finalizer re-entry.
46861 */
46862 DUK_D(DUK_DPRINT("object is a proxy, skip finalizer call"));
46863 return;
46864 }
46865
46866 /* XXX: use a NULL error handler for the finalizer call? */
#define DUK_HEAPHDR_SET_FINALIZED(h)

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 51909 of file duktape-1.5.2/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 51922 of file duktape-1.5.2/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 46905 of file duktape-1.5.2/src/duktape.c.

46905 {
46906 return 1;
46907 }
46908
46909 if (sanity-- == 0) {
46910 if (ignore_loop) {
46911 break;
46912 } else {
46914 }
46915 }
46916 h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
46917 } while (h);
46918
46919 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 53178 of file duktape-1.5.2/src/duktape.c.

53195 {
53196 duk_uint32_t boff;
53197 const duk_uint8_t *p, *p_start, *p_end;
53199
53200 /* Caller must check character offset to be inside the string. */
53201 DUK_ASSERT(thr != NULL);
53202 DUK_ASSERT(h != NULL);
53203 DUK_ASSERT_DISABLE(pos >= 0); /* unsigned */
53205

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 46075 of file duktape-1.5.2/src/duktape.c.

46092 {
46093 duk_hthread *res;
46094
46095 res = (duk_hthread *) DUK_ALLOC(heap, sizeof(duk_hthread));
46096 if (!res) {
46097 return NULL;
46098 }
46099 DUK_MEMZERO(res, sizeof(duk_hthread));
46100
46101 duk__init_object_parts(heap, &res->obj, hobject_flags);
46102
46103#ifdef DUK_USE_EXPLICIT_NULL_INIT
46104 res->ptr_curr_pc = NULL;
46105 res->heap = NULL;
46106 res->valstack = NULL;
46107 res->valstack_end = NULL;
46108 res->valstack_bottom = NULL;
46109 res->valstack_top = NULL;
46110 res->callstack = NULL;
46111 res->catchstack = NULL;
46112 res->resumer = NULL;
46113 res->compile_ctx = NULL,
46114#ifdef DUK_USE_HEAPPTR16
46115 res->strs16 = NULL;
46116#else
46117 res->strs = NULL;
46118#endif

◆ duk_hthread_callstack_grow()

DUK_INTERNAL_DECL void duk_hthread_callstack_grow ( duk_hthread * thr)

Definition at line 54285 of file duktape-1.5.2/src/duktape.c.

54288 : This should be probably reworked so that there is a shared
54289 * unwind primitive which handles all stacks as requested, and knows
54290 * the proper order for unwinding.)
54291 *
54292 * Valstack entries above 'top' are always kept initialized to
54293 * "undefined unused". Callstack and catchstack entries above 'top'
54294 * are not zeroed and are left as garbage.
54295 *
54296 * Value stack handling is mostly a part of the API implementation.
54297 */
54298
54299/* include removed: duk_internal.h */
54300
54301/* check that there is space for at least one new entry */
54303 duk_activation *new_ptr;
54304 duk_size_t old_size;
54305 duk_size_t new_size;
54306
54307 DUK_ASSERT(thr != NULL);
54308 DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */
54310
54311 if (thr->callstack_top < thr->callstack_size) {
54312 return;
54313 }
54314
54315 old_size = thr->callstack_size;
54316 new_size = old_size + DUK_CALLSTACK_GROW_STEP;
54317
54318 /* this is a bit approximate (errors out before max is reached); this is OK */
54319 if (new_size >= thr->callstack_max) {
54321 }
54322
54323 DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size));
#define DUK_STR_CALLSTACK_LIMIT

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 54325 of file duktape-1.5.2/src/duktape.c.

54332 {
54333 /* No need for a NULL/zero-size check because new_size > 0) */
54335 }
54336 thr->callstack = new_ptr;
54337 thr->callstack_size = new_size;
54338
54339 /* note: any entries above the callstack top are garbage and not zeroed */
54340}
54341
54343 duk_size_t new_size;
54344 duk_activation *p;
54345
54346 DUK_ASSERT(thr != NULL);
54347 DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */
54349
54351 return;
54352 }
54353
54354 new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE;
54355 DUK_ASSERT(new_size >= thr->callstack_top);
54356
54357 DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size));
54358
54359 /*
54360 * Note: must use indirect variant of DUK_REALLOC() because underlying
54361 * pointer may be changed by mark-and-sweep.
#define DUK_CALLSTACK_SHRINK_THRESHOLD
#define DUK_CALLSTACK_SHRINK_SPARE

◆ duk_hthread_callstack_unwind()

DUK_INTERNAL_DECL void duk_hthread_callstack_unwind ( duk_hthread * thr,
duk_size_t new_top )

Definition at line 54363 of file duktape-1.5.2/src/duktape.c.

54366 {
54367 thr->callstack = p;
54368 thr->callstack_size = new_size;
54369 } else {
54370 /* Because new_size != 0, if condition doesn't need to be
54371 * (p != NULL || new_size == 0).
54372 */
54373 DUK_ASSERT(new_size != 0);
54374 DUK_D(DUK_DPRINT("callstack shrink failed, ignoring"));
54375 }
54376
54377 /* note: any entries above the callstack top are garbage and not zeroed */
54378}
54379
54381 duk_size_t idx;
54382
54383 DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld",
54384 (void *) thr,
54385 (thr != NULL ? (long) thr->callstack_top : (long) -1),
54386 (long) new_top));
54387
54388 DUK_ASSERT(thr);
54389 DUK_ASSERT(thr->heap);
54390 DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */
54391 DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top); /* cannot grow */
54392
54393 /*
54394 * The loop below must avoid issues with potential callstack
54395 * reallocations. A resize (and other side effects) may happen
54396 * e.g. due to finalizer/errhandler calls caused by a refzero or
54397 * mark-and-sweep. Arbitrary finalizers may run, because when
54398 * an environment record is refzero'd, it may refer to arbitrary
54399 * values which also become refzero'd.
54400 *
54401 * So, the pointer 'p' is re-looked-up below whenever a side effect
54402 * might have changed it.
54403 */
54404
54405 idx = thr->callstack_top;
54406 while (idx > new_top) {
54407 duk_activation *act;
54408 duk_hobject *func;
54409#ifdef DUK_USE_REFERENCE_COUNTING
54410 duk_hobject *tmp;
54411#endif
54412#ifdef DUK_USE_DEBUGGER_SUPPORT
54413 duk_heap *heap;
54414#endif
54415
54416 idx--;
54417 DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */
54418 DUK_ASSERT((duk_size_t) idx < thr->callstack_size); /* true, despite side effect resizes */
54419
54420 act = thr->callstack + idx;
54421 /* With lightfuncs, act 'func' may be NULL */
54422
54423#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
54424 /*
54425 * Restore 'caller' property for non-strict callee functions.
54426 */
54427
54428 func = DUK_ACT_GET_FUNC(act);
54429 if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) {
54430 duk_tval *tv_caller;
54431 duk_tval tv_tmp;
54432 duk_hobject *h_tmp;
54433
54435
54436 /* The act->prev_caller should only be set if the entry for 'caller'
54437 * exists (as it is only set in that case, and the property is not
54438 * configurable), but handle all the cases anyway.
54439 */
54440
54441 if (tv_caller) {
54442 DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller);
54443 if (act->prev_caller) {
54444 /* Just transfer the refcount from act->prev_caller to tv_caller,
54445 * so no need for a refcount update. This is the expected case.
54446 */
54447 DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller);
54448 act->prev_caller = NULL;
54449 } else {
54450 DUK_TVAL_SET_NULL(tv_caller); /* no incref needed */
54451 DUK_ASSERT(act->prev_caller == NULL);
54452 }
54453 DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */
54454 } else {
54455 h_tmp = act->prev_caller;
54456 if (h_tmp) {
54457 act->prev_caller = NULL;
54458 DUK_HOBJECT_DECREF(thr, h_tmp); /* side effects */
54459 }
54460 }
54461 act = thr->callstack + idx; /* avoid side effects */
54462 DUK_ASSERT(act->prev_caller == NULL);
54463 }
54464#endif
54465
54466 /*
54467 * Unwind debugger state. If we unwind while stepping
54468 * (either step over or step into), pause execution.
54469 */
54470
54471#if defined(DUK_USE_DEBUGGER_SUPPORT)
54472 heap = thr->heap;
54473 if (heap->dbg_step_thread == thr &&
54474 heap->dbg_step_csindex == idx) {
54475 /* Pause for all step types: step into, step over, step out.
54476 * This is the only place explicitly handling a step out.
54477 */
54478 DUK_HEAP_SET_PAUSED(heap);
54479 DUK_ASSERT(heap->dbg_step_thread == NULL);
54480 }
54481#endif
54482
54483 /*
54484 * Close environment record(s) if they exist.
54485 *
54486 * Only variable environments are closed. If lex_env != var_env, it
54487 * cannot currently contain any register bound declarations.
54488 *
54489 * Only environments created for a NEWENV function are closed. If an
54490 * environment is created for e.g. an eval call, it must not be closed.
54491 */
54492
54493 func = DUK_ACT_GET_FUNC(act);
54494 if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) {
54495 DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation"));
54496 goto skip_env_close;
54497 }
54498 /* func is NULL for lightfunc */
54499
54500 DUK_ASSERT(act->lex_env == act->var_env);
54501 if (act->var_env != NULL) {
54502 DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O",
54503 (void *) act->var_env, (duk_heaphdr *) act->var_env));
54504 duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom);
54505 act = thr->callstack + idx; /* avoid side effect issues */
54506 }
54507
54508#if 0
54509 if (act->lex_env != NULL) {
54510 if (act->lex_env == act->var_env) {
54511 /* common case, already closed, so skip */
54512 DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env "
54513 "already closed -> skip closing lex_env"));
54514 ;
54515 } else {
54516 DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O",
54517 (void *) act->lex_env, (duk_heaphdr *) act->lex_env));
54519 act = thr->callstack + idx; /* avoid side effect issues */
54520 }
54521 }
54522#endif
54523
54524 DUK_ASSERT((act->lex_env == NULL) ||
54529
54530 DUK_ASSERT((act->var_env == NULL) ||
54535
54536 skip_env_close:
54537
54538 /*
54539 * Update preventcount
54540 */
54541
54542 if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
54543 DUK_ASSERT(thr->callstack_preventcount >= 1);
54544 thr->callstack_preventcount--;
54545 }
54546
54547 /*
54548 * Reference count updates
54549 *
54550 * Note: careful manipulation of refcounts. The top is
54551 * not updated yet, so all the activations are reachable
54552 * for mark-and-sweep (which may be triggered by decref).
54553 * However, the pointers are NULL so this is not an issue.
54554 */
54555
54556#ifdef DUK_USE_REFERENCE_COUNTING
54557 tmp = act->var_env;
54558#endif
54559 act->var_env = NULL;
54560#ifdef DUK_USE_REFERENCE_COUNTING
54562 act = thr->callstack + idx; /* avoid side effect issues */
54563#endif
54564
54565#ifdef DUK_USE_REFERENCE_COUNTING
54566 tmp = act->lex_env;
54567#endif
54568 act->lex_env = NULL;
54569#ifdef DUK_USE_REFERENCE_COUNTING
54571 act = thr->callstack + idx; /* avoid side effect issues */
54572#endif
54573
54574 /* Note: this may cause a corner case situation where a finalizer
54575 * may see a currently reachable activation whose 'func' is NULL.
54576 */
54577#ifdef DUK_USE_REFERENCE_COUNTING
54578 tmp = DUK_ACT_GET_FUNC(act);
54579#endif
54580 act->func = NULL;
54581#ifdef DUK_USE_REFERENCE_COUNTING
54583 act = thr->callstack + idx; /* avoid side effect issues */
54584 DUK_UNREF(act);
54585#endif
54586 }
54587
54588 thr->callstack_top = new_top;
#define DUK_TVAL_SET_NULL(tv)
DUK_INTERNAL_DECL void duk_js_close_environment_record(duk_hthread *thr, duk_hobject *env, duk_hobject *func, duk_size_t regbase)

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 54590 of file duktape-1.5.2/src/duktape.c.

54595 {
54596 duk_activation *act = thr->callstack + thr->callstack_top - 1;
54597 act->idx_retval = 0;
54598 }
54599#endif
54600
54601 /* Note: any entries above the callstack top are garbage and not zeroed.
54602 * Also topmost activation idx_retval is garbage (not zeroed), and must
54603 * be ignored.
54604 */
54605}
54606
54608 duk_catcher *new_ptr;
54609 duk_size_t old_size;
54610 duk_size_t new_size;
54611
54612 DUK_ASSERT(thr != NULL);
54613 DUK_ASSERT_DISABLE(thr->catchstack_top); /* avoid warning (unsigned) */
54615
54616 if (thr->catchstack_top < thr->catchstack_size) {
54617 return;
54618 }
54619
54620 old_size = thr->catchstack_size;
54621 new_size = old_size + DUK_CATCHSTACK_GROW_STEP;
54622
54623 /* this is a bit approximate (errors out before max is reached); this is OK */
54624 if (new_size >= thr->catchstack_max) {
54626 }
54627
54628 DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size));
#define DUK_STR_CATCHSTACK_LIMIT
#define DUK_CATCHSTACK_GROW_STEP

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 54630 of file duktape-1.5.2/src/duktape.c.

54637 {
54638 /* No need for a NULL/zero-size check because new_size > 0) */
54640 }
54641 thr->catchstack = new_ptr;
54642 thr->catchstack_size = new_size;
54643
54644 /* note: any entries above the catchstack top are garbage and not zeroed */
54645}
54646
54648 duk_size_t new_size;
54649 duk_catcher *p;
54650
54651 DUK_ASSERT(thr != NULL);
54652 DUK_ASSERT_DISABLE(thr->catchstack_top >= 0); /* avoid warning (unsigned) */
54654
54656 return;
54657 }
54658
54660 DUK_ASSERT(new_size >= thr->catchstack_top);
54661
54662 DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size));
54663
54664 /*
54665 * Note: must use indirect variant of DUK_REALLOC() because underlying
54666 * pointer may be changed by mark-and-sweep.
#define DUK_CATCHSTACK_SHRINK_THRESHOLD
#define DUK_CATCHSTACK_SHRINK_SPARE

◆ duk_hthread_catchstack_unwind()

DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind ( duk_hthread * thr,
duk_size_t new_top )

Definition at line 54668 of file duktape-1.5.2/src/duktape.c.

54671 {
54672 thr->catchstack = p;
54673 thr->catchstack_size = new_size;
54674 } else {
54675 /* Because new_size != 0, if condition doesn't need to be
54676 * (p != NULL || new_size == 0).
54677 */
54678 DUK_ASSERT(new_size != 0);
54679 DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring"));
54680 }
54681
54682 /* note: any entries above the catchstack top are garbage and not zeroed */
54683}
54684
54686 duk_size_t idx;
54687
54688 DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld",
54689 (void *) thr,
54690 (thr != NULL ? (long) thr->catchstack_top : (long) -1),
54691 (long) new_top));
54692
54693 DUK_ASSERT(thr);
54694 DUK_ASSERT(thr->heap);
54695 DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */
54696 DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top); /* cannot grow */
54697
54698 /*
54699 * Since there are no references in the catcher structure,
54700 * unwinding is quite simple. The only thing we need to
54701 * look out for is popping a possible lexical environment
54702 * established for an active catch clause.
54703 */
54704
54705 idx = thr->catchstack_top;
54706 while (idx > new_top) {
54707 duk_catcher *p;
54708 duk_activation *act;
54709 duk_hobject *env;
54710
54711 idx--;
54712 DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */
54713 DUK_ASSERT((duk_size_t) idx < thr->catchstack_size);
54714
54715 p = thr->catchstack + idx;
54716
54718 DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active",
54719 (long) idx, (long) p->callstack_index, (long) thr->callstack_top));
54720
54721 /* XXX: Here we have a nasty dependency: the need to manipulate
54722 * the callstack means that catchstack must always be unwound by
54723 * the caller before unwinding the callstack. This should be fixed
54724 * later.
54725 */
54726
54727 /* Note that multiple catchstack entries may refer to the same
54728 * callstack entry.
54729 */
54730 act = thr->callstack + p->callstack_index;
54731 DUK_ASSERT(act >= thr->callstack);
54732 DUK_ASSERT(act < thr->callstack + thr->callstack_top);
54733
54734 DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO",
54735 (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 54142 of file duktape-1.5.2/src/duktape.c.

54142 {
54143 DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO",
54144 (long) i, (duk_heaphdr *) duk_require_hobject(ctx, i)));
54145 }
54146#endif
54147
54148 /*
54149 * 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 53523 of file duktape-1.5.2/src/duktape.c.

53526 {
53529
53530 for (i = 0; i < 8; i++) {
53531 /* Encoding endianness must match target memory layout,
53532 * build scripts and genbuiltins.py must ensure this.
53533 */
53534 du.uc[i] = (duk_uint8_t) duk_bd_decode(bd, 8);
53535 }
53536
53537 duk_push_number(ctx, du.d); /* push operation normalizes NaNs */
53538}
53539
53541 duk_context *ctx = (duk_context *) thr;
53542 duk_bitdecoder_ctx bd_ctx;
53543 duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
53544 duk_hobject *h;
53545 duk_small_uint_t i, j;
53546
53547 DUK_D(DUK_DPRINT("INITBUILTINS BEGIN: DUK_NUM_BUILTINS=%d, DUK_NUM_BUILTINS_ALL=%d", (int) DUK_NUM_BUILTINS, (int) DUK_NUM_ALL_BUILTINS));
53548
53549 DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
53550 bd->data = (const duk_uint8_t *) duk_builtins_data;
53551 bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
53552
53553 /*
53554 * First create all built-in bare objects on the empty valstack.
53555 *
53556 * Built-ins in the index range [0,DUK_NUM_BUILTINS-1] have value
53557 * stack indices matching their eventual thr->builtins[] index.
53558 *
53559 * Built-ins in the index range [DUK_NUM_BUILTINS,DUK_NUM_ALL_BUILTINS]
53560 * will exist on the value stack during init but won't be placed
53561 * into thr->builtins[]. These are objects referenced in some way
53562 * from thr->builtins[] roots but which don't need to be indexed by
53563 * Duktape through thr->builtins[] (e.g. user custom objects).
53564 */
53565
53567
53568 DUK_DD(DUK_DDPRINT("create empty built-ins"));
53569 DUK_ASSERT_TOP(ctx, 0);
53570 for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
53571 duk_small_uint_t class_num;
53572 duk_small_int_t len = -1; /* must be signed */
53573
53575 len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
53576
53577 if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
53578 duk_small_uint_t natidx;
53579 duk_int_t c_nargs; /* must hold DUK_VARARGS */
53580 duk_c_function c_func;
53581 duk_int16_t magic;
53582
53583 DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len));
53584 DUK_ASSERT(len >= 0);
53585
53587 c_func = duk_bi_native_functions[natidx];
53588
53589 c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
53590 if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
53591 c_nargs = DUK_VARARGS;
53592 }
53593
53594 /* XXX: set magic directly here? (it could share the c_nargs arg) */
53595 duk_push_c_function_noexotic(ctx, c_func, c_nargs);
53596
53597 h = duk_require_hobject(ctx, -1);
53598 DUK_ASSERT(h != NULL);
53599
53600 /* Currently all built-in native functions are strict.
53601 * duk_push_c_function() now sets strict flag, so
53602 * assert for it.
53603 */
53605
53606 /* XXX: function properties */
53607
53608 /* Built-in 'name' is not writable by default. Function '.name'
53609 * is writable to allow user code to set a '.name' on a native
53610 * function.
53611 */
53614 -2,
53618
53619 /* Almost all global level Function objects are constructable
53620 * but not all: Function.prototype is a non-constructable,
53621 * callable Function.
53622 */
53623 if (duk_bd_decode_flag(bd)) {
53625 } else {
53627 }
53628
53629 /* Cast converts magic to 16-bit signed value */
53630 magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
53631 ((duk_hnativefunction *) h)->magic = magic;
53632 } else {
53633 /* XXX: ARRAY_PART for Array prototype? */
53634
53637 -1); /* no prototype or class yet */
53638
53639 h = duk_require_hobject(ctx, -1);
53640 DUK_ASSERT(h != NULL);
53641 }
53642
53643 DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
53644
53645 if (i < DUK_NUM_BUILTINS) {
53646 thr->builtins[i] = h;
53647 DUK_HOBJECT_INCREF(thr, &h->hdr);
53648 }
53649
53650 if (len >= 0) {
53651 /*
53652 * For top-level objects, 'length' property has the following
53653 * default attributes: non-writable, non-enumerable, non-configurable
53654 * (E5 Section 15).
53655 *
53656 * However, 'length' property for Array.prototype has attributes
53657 * expected of an Array instance which are different: writable,
53658 * non-enumerable, non-configurable (E5 Section 15.4.5.2).
53659 *
53660 * This is currently determined implicitly based on class; there are
53661 * no attribute flags in the init data.
53662 */
53663
53664 duk_push_int(ctx, len);
53666 -2,
53668 (class_num == DUK_HOBJECT_CLASS_ARRAY ? /* only Array.prototype matches */
53670 }
53671
53672 /* enable exotic behaviors last */
53673
53674 if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
53676 }
53677 if (class_num == DUK_HOBJECT_CLASS_STRING) {
53679 }
53680
53681 /* some assertions */
53682
53684 /* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
53687 /* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
53689 DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h)); /* currently, even for Array.prototype */
53690 /* DUK_HOBJECT_FLAG_STRICT varies */
53691 DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) || /* all native functions have NEWENV */
53696 /* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */
53697 /* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */
53699
53700 DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len));
53701 }
53702
53703 /*
53704 * Then decode the builtins init data (see genbuiltins.py) to
53705 * init objects
53706 */
53707
53708 DUK_DD(DUK_DDPRINT("initialize built-in object properties"));
53709 for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
53711 duk_small_uint_t num;
53712
53713 DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i));
53714 h = duk_require_hobject(ctx, i);
53715 DUK_ASSERT(h != NULL);
53716
53718 if (t != DUK__NO_BIDX_MARKER) {
53719 DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t));
53721 }
53722
53724 if (t != DUK__NO_BIDX_MARKER) {
53725 /* 'prototype' property for all built-in objects (which have it) has attributes:
53726 * [[Writable]] = false,
53727 * [[Enumerable]] = false,
53728 * [[Configurable]] = false
53729 */
53730 DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t));
53732 }
53733
53735 if (t != DUK__NO_BIDX_MARKER) {
53736 /* 'constructor' property for all built-in objects (which have it) has attributes:
53737 * [[Writable]] = true,
53738 * [[Enumerable]] = false,
53739 * [[Configurable]] = true
53740 */
53741 DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t));
53743 }
53744
53745 /* normal valued properties */
53747 DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num));
53748 for (j = 0; j < num; j++) {
53749 duk_small_uint_t prop_flags;
53750
53752
53753 /*
53754 * Property attribute defaults are defined in E5 Section 15 (first
53755 * few pages); there is a default for all properties and a special
53756 * default for 'length' properties. Variation from the defaults is
53757 * signaled using a single flag bit in the bitstream.
53758 */
53759
53760 if (duk_bd_decode_flag(bd)) {
53762 } else {
53763 prop_flags = DUK_PROPDESC_FLAGS_WC;
53764 }
53765
53767
53768 DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, key %!T, flags 0x%02lx, type %ld",
53769 (long) i, (long) j, duk_get_tval(ctx, -1), (unsigned long) prop_flags, (long) t));
53770
53771 switch (t) {
53772 case DUK__PROP_TYPE_DOUBLE: {
53773 duk__push_double(ctx, bd);
53774 break;
53775 }
53776 case DUK__PROP_TYPE_STRING: {
53777 duk__push_string(ctx, bd);
53778 break;
53779 }
53780 case DUK__PROP_TYPE_STRIDX: {
53781 duk__push_stridx(ctx, bd);
53782 break;
53783 }
53785 duk_small_uint_t bidx;
53786
53789 duk_dup(ctx, (duk_idx_t) bidx);
53790 break;
53791 }
53793 duk_push_undefined(ctx);
53794 break;
53795 }
53797 duk_push_true(ctx);
53798 break;
53799 }
53801 duk_push_false(ctx);
53802 break;
53803 }
53807 duk_c_function c_func_getter;
53808 duk_c_function c_func_setter;
53809
53810 /* XXX: this is a bit awkward because there is no exposed helper
53811 * in the API style, only this internal helper.
53812 */
53813 DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, key=%!T, getteridx=%ld, setteridx=%ld, flags=0x%04lx",
53814 (long) i, duk_get_tval(ctx, -1), (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags));
53815
53816 c_func_getter = duk_bi_native_functions[natidx_getter];
53817 c_func_setter = duk_bi_native_functions[natidx_setter];
53818 duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0); /* always 0 args */
53819 duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1); /* always 1 arg */
53820
53821 /* XXX: magic for getter/setter? use duk_def_prop()? */
53822
53823 DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_WRITABLE) == 0); /* genbuiltins.py ensures */
53824
53825 prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */
53827 duk_require_hobject(ctx, i),
53828 duk_get_hstring(ctx, -3),
53829 duk_require_hobject(ctx, -2),
53830 duk_require_hobject(ctx, -1),
53831 prop_flags);
53832 duk_pop_3(ctx); /* key, getter and setter, now reachable through object */
53833 goto skip_value;
53834 }
53835 default: {
53836 /* exhaustive */
53838 }
53839 }
53840
53841 DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
53842 duk_xdef_prop(ctx, i, prop_flags);
53843
53844 skip_value:
53845 continue; /* avoid empty label at the end of a compound statement */
53846 }
53847
53848 /* native function properties */
53850 DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num));
53851 for (j = 0; j < num; j++) {
53852 duk_hstring *h_key;
53853 duk_small_uint_t natidx;
53854 duk_int_t c_nargs; /* must hold DUK_VARARGS */
53855 duk_small_uint_t c_length;
53856 duk_int16_t magic;
53857 duk_c_function c_func;
53858 duk_hnativefunction *h_func;
53859#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
53860 duk_small_int_t lightfunc_eligible;
53861#endif
53862
53864 h_key = duk_get_hstring(ctx, -1);
53865 DUK_ASSERT(h_key != NULL);
53866 DUK_UNREF(h_key);
53868
53870 c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
53871 if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
53872 c_nargs = DUK_VARARGS;
53873 }
53874
53875 c_func = duk_bi_native_functions[natidx];
53876
53877 DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, key %!O, natidx %ld, length %ld, nargs %ld",
53878 (long) i, (long) j, (duk_heaphdr *) h_key, (long) natidx, (long) c_length,
53879 (c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs)));
53880
53881 /* Cast converts magic to 16-bit signed value */
53882 magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
53883
53884#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
53885 lightfunc_eligible =
53886 ((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) &&
53887 (c_length <= DUK_LFUNC_LENGTH_MAX) &&
53888 (magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX);
53889
53890 if (h_key == DUK_HTHREAD_STRING_EVAL(thr) ||
53891 h_key == DUK_HTHREAD_STRING_YIELD(thr) ||
53892 h_key == DUK_HTHREAD_STRING_RESUME(thr) ||
53893 h_key == DUK_HTHREAD_STRING_REQUIRE(thr)) {
53894 /* These functions have trouble working as lightfuncs.
53895 * Some of them have specific asserts and some may have
53896 * additional properties (e.g. 'require.id' may be written).
53897 */
53898 DUK_D(DUK_DPRINT("reject as lightfunc: key=%!O, i=%d, j=%d", (duk_heaphdr *) h_key, (int) i, (int) j));
53899 lightfunc_eligible = 0;
53900 }
53901
53902 if (lightfunc_eligible) {
53903 duk_tval tv_lfunc;
53904 duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs);
53905 duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs);
53906 DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags);
53907 duk_push_tval(ctx, &tv_lfunc);
53908 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)));
53909 goto lightfunc_skip;
53910 }
53911
53912 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));
53913#endif /* DUK_USE_LIGHTFUNC_BUILTINS */
53914
53915 /* [ (builtin objects) name ] */
53916
53917 duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs);
53918 h_func = duk_require_hnativefunction(ctx, -1);
53919 DUK_UNREF(h_func);
53920
53921 /* Currently all built-in native functions are strict.
53922 * This doesn't matter for many functions, but e.g.
53923 * String.prototype.charAt (and other string functions)
53924 * rely on being strict so that their 'this' binding is
53925 * not automatically coerced.
53926 */
53928
53929 /* No built-in functions are constructable except the top
53930 * level ones (Number, etc).
53931 */
53933
53934 /* XXX: any way to avoid decoding magic bit; there are quite
53935 * many function properties and relatively few with magic values.
53936 */
53937 h_func->magic = magic;
53938
53939 /* [ (builtin objects) name func ] */
53940
53941 duk_push_int(ctx, c_length);
53943
53944 duk_dup(ctx, -2);
53946
53947 /* XXX: other properties of function instances; 'arguments', 'caller'. */
53948
53949 DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T",
53950 (long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1)));
53951
53952 /* [ (builtin objects) name func ] */
53953
53954 /*
53955 * The default property attributes are correct for all
53956 * function valued properties of built-in objects now.
53957 */
53958
53959#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
53960 lightfunc_skip:
53961#endif
53962
53964
53965 /* [ (builtin objects) ] */
53966 }
53967 }
53968
53969 /*
53970 * Special post-tweaks, for cases not covered by the init data format.
53971 *
53972 * - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
53973 * toGMTString is required to have the same Function object as
53974 * toUTCString in E5 Section B.2.6. Note that while Smjs respects
53975 * this, V8 does not (the Function objects are distinct).
53976 *
53977 * - Make DoubleError non-extensible.
53978 *
53979 * - Add info about most important effective compile options to Duktape.
53980 *
53981 * - Possibly remove some properties (values or methods) which are not
53982 * desirable with current feature options but are not currently
53983 * conditional in init data.
53984 */
53985
53988
53990 DUK_ASSERT(h != NULL);
53992
53993#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY)
53994 DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features"));
53996#endif
53997
53998#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF)
53999 DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features"));
54001#endif
54002
54003 /* XXX: relocate */
54004 duk_push_string(ctx,
54005 /* Endianness indicator */
54006#if defined(DUK_USE_INTEGER_LE)
54007 "l"
54008#elif defined(DUK_USE_INTEGER_BE)
54009 "b"
54010#elif defined(DUK_USE_INTEGER_ME) /* integer mixed endian not really used now */
54011 "m"
54012#else
54013 "?"
54014#endif
54015#if defined(DUK_USE_DOUBLE_LE)
54016 "l"
54017#elif defined(DUK_USE_DOUBLE_BE)
54018 "b"
54019#elif defined(DUK_USE_DOUBLE_ME)
54020 "m"
54021#else
54022 "?"
54023#endif
54024 " "
54025 /* Packed or unpacked tval */
54026#if defined(DUK_USE_PACKED_TVAL)
54027 "p"
54028#else
54029 "u"
54030#endif
54031#if defined(DUK_USE_FASTINT)
54032 "f"
54033#endif
54034 " "
54035 /* Low memory options */
54036#if defined(DUK_USE_STRTAB_CHAIN)
54037 "c" /* chain */
54038#elif defined(DUK_USE_STRTAB_PROBE)
54039 "p" /* probe */
54040#else
54041 "?"
54042#endif
54043#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16)
54044 "n"
54045#endif
54046#if defined(DUK_USE_HEAPPTR16)
54047 "h"
54048#endif
54049#if defined(DUK_USE_DATAPTR16)
54050 "d"
54051#endif
54052#if defined(DUK_USE_FUNCPTR16)
54053 "f"
54054#endif
54055#if defined(DUK_USE_REFCOUNT16)
54056 "R"
54057#endif
54058#if defined(DUK_USE_STRHASH16)
54059 "H"
54060#endif
54061#if defined(DUK_USE_STRLEN16)
54062 "S"
54063#endif
54064#if defined(DUK_USE_BUFLEN16)
54065 "B"
54066#endif
54067#if defined(DUK_USE_OBJSIZES16)
54068 "O"
54069#endif
54070#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
54071 "L"
54072#endif
54073#if defined(DUK_USE_ROM_STRINGS) || defined(DUK_USE_ROM_OBJECTS)
54074 /* XXX: This won't be shown in practice now
54075 * because this code is not run when builtins
54076 * are in ROM.
54077 */
54078 "Z"
54079#endif
54080 " "
54081 /* Object property allocation layout */
54082#if defined(DUK_USE_HOBJECT_LAYOUT_1)
54083 "p1"
54084#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
54085 "p2"
54086#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
54087 "p3"
54088#else
54089 "p?"
54090#endif
54091 " "
54092 /* Alignment guarantee */
54093#if (DUK_USE_ALIGN_BY == 4)
54094 "a4"
54095#elif (DUK_USE_ALIGN_BY == 8)
54096 "a8"
54097#elif (DUK_USE_ALIGN_BY == 1)
54098 "a1"
54099#else
54100#error invalid DUK_USE_ALIGN_BY
54101#endif
54102 " "
54103 /* Architecture, OS, and compiler strings */
54105 " "
54107 " "
54110
54111 /*
54112 * InitJS code - Ecmascript code evaluated from a built-in source
54113 * which provides e.g. backward compatibility. User can also provide
54114 * JS code to be evaluated at startup.
54115 */
54116
54117#ifdef DUK_USE_BUILTIN_INITJS
54118 /* XXX: compression */
54119 DUK_DD(DUK_DDPRINT("running built-in initjs"));
54120 duk_eval_string(ctx, (const char *) duk_initjs_data); /* initjs data is NUL terminated */
54121 duk_pop(ctx);
54122#endif /* DUK_USE_BUILTIN_INITJS */
54123
54124#ifdef DUK_USE_USER_INITJS
54125 /* XXX: compression (as an option) */
54126 DUK_DD(DUK_DDPRINT("running user initjs"));
54127 duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS);
54128#endif /* DUK_USE_USER_INITJS */
54129
54130 /*
54131 * Since built-ins are not often extended, compact them.
54132 */
54133
54134 DUK_DD(DUK_DDPRINT("compact built-ins"));
54135 for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
54137 }
54138
54139 DUK_D(DUK_DPRINT("INITBUILTINS END"));
#define duk_eval_string(ctx, src)
#define duk_eval_string_noresult(ctx, src)
#define DUK__NARGS_VARARGS_MARKER
#define DUK__PROP_FLAGS_BITS
DUK_INTERNAL const duk_uint8_t duk_initjs_data[204]
#define DUK_STRIDX_TO_UTC_STRING
#define DUK_LFUNC_NARGS_MAX
#define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h)
DUK_INTERNAL_DECL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs)
#define DUK__NUM_FUNC_PROPS_BITS
#define DUK_LFUNC_LENGTH_MAX
#define DUK_STRIDX_TO_GMT_STRING
DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value)
#define DUK_HTHREAD_STRING___PROTO__(thr)
#define DUK__LENGTH_PROP_BITS
#define DUK_HOBJECT_HAS_CONSTRUCTABLE(h)
#define DUK__PROP_TYPE_ACCESSOR
#define DUK_HTHREAD_STRING_YIELD(thr)
#define DUK_HOBJECT_SET_EXOTIC_ARRAY(h)
DUK_EXTERNAL void duk_pop_3(duk_context *ctx)
#define DUK_LFUNC_MAGIC_MIN
#define DUK__PROP_TYPE_BUILTIN
DUK_INTERNAL const duk_c_function duk_bi_native_functions[149]
DUK_LOCAL void duk__push_stridx(duk_context *ctx, duk_bitdecoder_ctx *bd)
#define DUK_HTHREAD_STRING_RESUME(thr)
#define DUK__NO_BIDX_MARKER
#define DUK_LFUNC_FLAGS_PACK(magic, length, nargs)
#define DUK__CLASS_BITS
#define DUK__BIDX_BITS
#define DUK_HTHREAD_STRING_REQUIRE(thr)
#define DUK__PROP_TYPE_BITS
DUK_LOCAL void duk__push_double(duk_context *ctx, duk_bitdecoder_ctx *bd)
#define DUK__PROP_TYPE_STRIDX
#define DUK__PROP_TYPE_STRING
#define DUK__MAGIC_BITS
#define DUK_LFUNC_NARGS_MIN
DUK_INTERNAL_DECL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs)
#define DUK_TVAL_SET_LIGHTFUNC(tv, fp, flags)
#define DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h)
#define DUK_STRIDX_ENV
#define DUK__NATIDX_BITS
#define DUK_LFUNC_MAGIC_MAX
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)
#define DUK__PROP_TYPE_DOUBLE
DUK_INTERNAL_DECL void duk_hthread_create_builtin_objects(duk_hthread *thr)
#define DUK__NUM_NORMAL_PROPS_BITS
#define DUK_HOBJECT_SET_CLASS_NUMBER(h, v)
#define DUK__PROP_TYPE_BOOLEAN_FALSE
#define DUK__PROP_TYPE_BOOLEAN_TRUE
#define DUK__NARGS_BITS
#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)
#define DUK__PROP_TYPE_UNDEFINED
#define DUK_NUM_ALL_BUILTINS

◆ 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 54213 of file duktape-1.5.2/src/duktape.c.

54214 {
54215 duk_instr_t *bcode;
54216
54217 DUK_ASSERT(thr != NULL);
54218 DUK_ASSERT(act != NULL);
54219 DUK_UNREF(thr);
54220
54221 /* XXX: store 'bcode' pointer to activation for faster lookup? */
54222 if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) {
54224 return (duk_uint_fast32_t) (act->curr_pc - bcode);
54225 }
54226 return 0;
54227}
54228#endif /* DUK_USE_DEBUGGER_SUPPORT */
54229

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 53302 of file duktape-1.5.2/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 53308 of file duktape-1.5.2/src/duktape.c.

◆ duk_hthread_get_current_activation()

DUK_INTERNAL_DECL duk_activation * duk_hthread_get_current_activation ( duk_hthread * thr)

Definition at line 54186 of file duktape-1.5.2/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 53296 of file duktape-1.5.2/src/duktape.c.

53300 :
53301

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 53230 of file duktape-1.5.2/src/duktape.c.

53247 {
53248 duk_size_t alloc_size;
53249 duk_size_t i;
53250
53251 DUK_ASSERT(heap != NULL);
53252 DUK_ASSERT(thr != NULL);
53253 DUK_ASSERT(thr->valstack == NULL);
53254 DUK_ASSERT(thr->valstack_end == NULL);
53256 DUK_ASSERT(thr->valstack_top == NULL);
53257 DUK_ASSERT(thr->callstack == NULL);
53258 DUK_ASSERT(thr->catchstack == NULL);
53259
53260 /* valstack */
53261 alloc_size = sizeof(duk_tval) * DUK_VALSTACK_INITIAL_SIZE;
53262 thr->valstack = (duk_tval *) DUK_ALLOC(heap, alloc_size);
53263 if (!thr->valstack) {
53264 goto fail;
53265 }
53266 DUK_MEMZERO(thr->valstack, alloc_size);
53268#if !defined(DUK_USE_PREFER_SIZE)
53270#endif
53271 thr->valstack_bottom = thr->valstack;
53272 thr->valstack_top = thr->valstack;
53273
53274 for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) {
53276 }
53277
53278 /* callstack */
53279 alloc_size = sizeof(duk_activation) * DUK_CALLSTACK_INITIAL_SIZE;
53280 thr->callstack = (duk_activation *) DUK_ALLOC(heap, alloc_size);
53281 if (!thr->callstack) {
53282 goto fail;
53283 }
53284 DUK_MEMZERO(thr->callstack, alloc_size);
53286 DUK_ASSERT(thr->callstack_top == 0);
53287
53288 /* catchstack */
53289 alloc_size = sizeof(duk_catcher) * DUK_CATCHSTACK_INITIAL_SIZE;
53290 thr->catchstack = (duk_catcher *) DUK_ALLOC(heap, alloc_size);
53291 if (!thr->catchstack) {
53292 goto fail;
#define DUK_VALSTACK_INITIAL_SIZE
#define DUK_CATCHSTACK_INITIAL_SIZE
struct duk_activation duk_activation
#define DUK_CALLSTACK_INITIAL_SIZE
struct duk_catcher duk_catcher

◆ duk_hthread_sync_and_null_currpc()

DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc ( duk_hthread * thr)

Definition at line 54246 of file duktape-1.5.2/src/duktape.c.

54250 {
54251 duk_activation *act;
54252
54253 DUK_ASSERT(thr != NULL);
54254
54255 if (thr->ptr_curr_pc != NULL) {
54256 /* ptr_curr_pc != NULL only when bytecode executor is active. */
54257 DUK_ASSERT(thr->callstack_top > 0);
54258 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 54233 of file duktape-1.5.2/src/duktape.c.

54238 {
54239 bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func));
54240 ret = (duk_uint_fast32_t) (act->curr_pc - bcode);
54241 if (ret > 0) {
54242 ret--;
54243 }
54244 return ret;

◆ duk_hthread_terminate()

DUK_INTERNAL_DECL void duk_hthread_terminate ( duk_hthread * thr)

Definition at line 54157 of file duktape-1.5.2/src/duktape.c.

54159 {
54161
54162 for (i = 0; i < DUK_NUM_BUILTINS; i++) {
54163 thr_to->builtins[i] = thr_from->builtins[i];
54164 DUK_HOBJECT_INCREF_ALLOWNULL(thr_to, thr_to->builtins[i]); /* side effect free */
54165 }
54166}
54167#line 1 "duk_hthread_misc.c"
54168/*
54169 * Thread support.
54170 */
54171
54172/* include removed: duk_internal.h */
54173
54175 DUK_ASSERT(thr != NULL);
54176
54177 /* Order of unwinding is important */
54178
54180
54181 duk_hthread_callstack_unwind(thr, 0); /* side effects, possibly errors */
54182
54183 thr->valstack_bottom = thr->valstack;
54184 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 15795 of file duktape-1.5.2/src/duktape.c.

15800 {
15801 DUK_ERROR_API_INDEX(thr, -1);
15802 return; /* unreachable */
15803 }
15804 tv_from = thr->valstack_top - 1;
15805 tv_to = thr->valstack_top++;
15806 DUK_ASSERT(tv_from != NULL);
15807 DUK_ASSERT(tv_to != NULL);
15808 DUK_TVAL_SET_TVAL(tv_to, tv_from);
15809 DUK_TVAL_INCREF(thr, tv_to); /* no side effects */
15810}
15811
15812DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) {
15813 duk_tval *p;
15814 duk_tval *q;
15815 duk_tval tv_tmp;
15816 duk_size_t nbytes;
15817
15819
15820 p = duk_require_tval(ctx, to_index);
15821 DUK_ASSERT(p != NULL);
15822 q = duk_require_tval(ctx, -1);
15823 DUK_ASSERT(q != NULL);
15824
15825 DUK_ASSERT(q >= p);
15826
15827 /* nbytes
15828 * <--------->
15829 * [ ... | p | x | x | q ]
15830 * => [ ... | q | p | x | x ]
15831 */
15832
15833 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 19374 of file duktape-1.5.2/src/duktape.c.

19379 {
19380 return 0;
19381 }
19382
19383 /* No coercions or other side effects, so safe */
19384 return duk_js_strict_equals(tv1, tv2);
19385}
19386
19387/*
19388 * instanceof
19389 */
19390
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 17746 of file duktape-1.5.2/src/duktape.c.

17748 {
17750 return duk__tag_check(ctx, index, DUK_TAG_BUFFER);
17751}
17752
17755 return duk__tag_check(ctx, index, DUK_TAG_POINTER);
17756}
DUK_EXTERNAL duk_bool_t duk_is_pointer(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_is_boolean()

DUK_EXTERNAL duk_bool_t duk_is_boolean ( duk_context * ctx,
duk_idx_t index )

Definition at line 17679 of file duktape-1.5.2/src/duktape.c.

17682 {

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 17788 of file duktape-1.5.2/src/duktape.c.

17791 {
DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false(duk_context *ctx, duk_idx_t index, duk_uint_t flag_mask)

◆ duk_is_buffer()

DUK_EXTERNAL duk_bool_t duk_is_buffer ( duk_context * ctx,
duk_idx_t index )

Definition at line 17731 of file duktape-1.5.2/src/duktape.c.

17732 {
17733 return 0;
17734 }

Referenced by duk__base64_encode_helper().

◆ duk_is_c_function()

DUK_EXTERNAL duk_bool_t duk_is_c_function ( duk_context * ctx,
duk_idx_t index )

Definition at line 17774 of file duktape-1.5.2/src/duktape.c.

17775 {
17776 duk_tval *tv;
17777
17779

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 12822 of file duktape-1.5.2/src/duktape.c.

◆ duk_is_dynamic_buffer()

DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer ( duk_context * ctx,
duk_idx_t index )

Definition at line 17816 of file duktape-1.5.2/src/duktape.c.

17819 {
17820 duk_tval *tv;
17821
17823
17824 tv = duk_get_tval(ctx, index);
17825 if (tv && DUK_TVAL_IS_BUFFER(tv)) {
17827 DUK_ASSERT(h != NULL);
17828 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 17781 of file duktape-1.5.2/src/duktape.c.

17781 {
17782 return 1;
17783 }
17785 index,

◆ duk_is_external_buffer()

DUK_EXTERNAL duk_bool_t duk_is_external_buffer ( duk_context * ctx,
duk_idx_t index )

Definition at line 17830 of file duktape-1.5.2/src/duktape.c.

17833 {
17834 duk_tval *tv;
17835
17837
17838 tv = duk_get_tval(ctx, index);
17839 if (tv && DUK_TVAL_IS_BUFFER(tv)) {
17841 DUK_ASSERT(h != NULL);
17842 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 17802 of file duktape-1.5.2/src/duktape.c.

17805 {
17808 index,
17810}
17811
DUK_EXTERNAL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index)

◆ duk_is_function()

DUK_EXTERNAL duk_bool_t duk_is_function ( duk_context * ctx,
duk_idx_t index )

Definition at line 17758 of file duktape-1.5.2/src/duktape.c.

17758 {
17761}
17762
17764 duk_hobject *obj;
17765
17767
17768 obj = duk_get_hobject(ctx, index);
17769 if (obj) {
17771 }
17772 return 0;
DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index)

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 17741 of file duktape-1.5.2/src/duktape.c.

17743 {

◆ duk_is_nan()

DUK_EXTERNAL duk_bool_t duk_is_nan ( duk_context * ctx,
duk_idx_t index )

Definition at line 17703 of file duktape-1.5.2/src/duktape.c.

17714 {
17715 return 0;
17716 }
17717 return DUK_TVAL_IS_NUMBER(tv);
17718}
17719

◆ duk_is_null()

DUK_EXTERNAL duk_bool_t duk_is_null ( duk_context * ctx,
duk_idx_t index )

Definition at line 17660 of file duktape-1.5.2/src/duktape.c.

17662 {
17663 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 17665 of file duktape-1.5.2/src/duktape.c.

17665 {
17668 }
17669 return 0;
17670}
17671
17675}
17676

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 17684 of file duktape-1.5.2/src/duktape.c.

17689 {
17690 return 0;
17691 }
17692 tag = DUK_TVAL_GET_TAG(tv);
17693 return (tag == DUK_TAG_UNDEFINED) || (tag == DUK_TAG_NULL);
17694}
17695
17698 return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN);
17699}
17700

◆ duk_is_object()

DUK_EXTERNAL duk_bool_t duk_is_object ( duk_context * ctx,
duk_idx_t index )

Definition at line 17726 of file duktape-1.5.2/src/duktape.c.

◆ duk_is_pointer()

DUK_EXTERNAL duk_bool_t duk_is_pointer ( duk_context * ctx,
duk_idx_t index )

Definition at line 17736 of file duktape-1.5.2/src/duktape.c.

17738 {

◆ duk_is_strict_call()

DUK_EXTERNAL duk_bool_t duk_is_strict_call ( duk_context * ctx)

Definition at line 12835 of file duktape-1.5.2/src/duktape.c.

12839 {
12840 duk_hthread *thr = (duk_hthread *) ctx;
12841 duk_activation *act;
12842
12844 DUK_ASSERT(thr != NULL);
12846
12848 DUK_ASSERT(act != NULL); /* because callstack_top > 0 */
12849 return ((act->flags & DUK_ACT_FLAG_CONSTRUCT) != 0 ? 1 : 0);
12850}
12851
12853 duk_hthread *thr = (duk_hthread *) ctx;
12854 duk_activation *act;
12855
12856 /* For user code this could just return 1 (strict) always
12857 * because all Duktape/C functions are considered strict,
12858 * and strict is also the default when nothing is running.
DUK_EXTERNAL duk_bool_t duk_is_strict_call(duk_context *ctx)

◆ duk_is_string()

DUK_EXTERNAL duk_bool_t duk_is_string ( duk_context * ctx,
duk_idx_t index )

◆ duk_is_thread()

DUK_EXTERNAL duk_bool_t duk_is_thread ( duk_context * ctx,
duk_idx_t index )

Definition at line 17795 of file duktape-1.5.2/src/duktape.c.

17798 {

◆ duk_is_undefined()

DUK_EXTERNAL duk_bool_t duk_is_undefined ( duk_context * ctx,
duk_idx_t index )

Definition at line 17655 of file duktape-1.5.2/src/duktape.c.

17657 {
17658 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 15235 of file duktape-1.5.2/src/duktape.c.

15236 {
15238 uindex = (duk_uidx_t) index;
15239 }
15240

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 19702 of file duktape-1.5.2/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 71793 of file duktape-1.5.2/src/duktape.c.

71810 {
71811 duk_context *ctx = (duk_context *) thr;
71813
71814 DUK_ASSERT(thr != NULL);
71815 DUK_ASSERT(env != NULL);
71816 /* func is NULL for lightfuncs */
71817
71819 DUK_DDD(DUK_DDDPRINT("environment record not a declarative record, "
71820 "or already closed: %!iO",
71821 (duk_heaphdr *) env));
71822 return;
71823 }
71824
71825 DUK_DDD(DUK_DDDPRINT("closing environment record: %!iO, func: %!iO, regbase: %ld",
71826 (duk_heaphdr *) env, (duk_heaphdr *) func, (long) regbase));
71827
71828 duk_push_hobject(ctx, env);
71829
71830 /* assertions: env must be closed in the same thread as where it runs */
71831#ifdef DUK_USE_ASSERTIONS
71832 {
71833 /* [... env] */
71834
71836 DUK_ASSERT(duk_is_object(ctx, -1));
71837 DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) func);
71838 }
71839 duk_pop(ctx);
71840
71842 DUK_ASSERT(duk_is_object(ctx, -1));
71843 DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) thr);
71844 }
71845 duk_pop(ctx);
71846
71848 DUK_ASSERT(duk_is_number(ctx, -1));
71849 DUK_ASSERT(duk_get_number(ctx, -1) == (double) regbase);
71850 }
71851 duk_pop(ctx);
71852
71853 /* [... env] */
71854 }
71855#endif
71856
71857 if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
71858 duk_hobject *varmap;
71859 duk_hstring *key;
71860 duk_tval *tv;
71861 duk_uint_t regnum;
71862
71863 /* XXX: additional conditions when to close variables? we don't want to do it
71864 * unless the environment may have "escaped" (referenced in a function closure).
71865 * With delayed environments, the existence is probably good enough of a check.
71866 */
71867
71868 /* XXX: any way to detect faster whether something needs to be closed?
71869 * We now look up _Callee and then skip the rest.
71870 */
71871
71872 /* Note: we rely on the _Varmap having a bunch of nice properties, like:
71873 * - being compacted and unmodified during this process
71874 * - not containing an array part
71875 * - having correct value types
71876 */
71877
71878 /* [... env] */
71879
71881 DUK_DDD(DUK_DDDPRINT("env has no callee property, nothing to close; re-delete the control properties just in case"));
71882 duk_pop(ctx);
71883 goto skip_varmap;
71884 }
71885
71886 /* [... env callee] */
71887
71889 DUK_DDD(DUK_DDDPRINT("callee has no varmap property, nothing to close; delete the control properties"));
71890 duk_pop_2(ctx);
71891 goto skip_varmap;
71892 }
71893 varmap = duk_require_hobject(ctx, -1);
71894 DUK_ASSERT(varmap != NULL);
71895
71896 DUK_DDD(DUK_DDDPRINT("varmap: %!O", (duk_heaphdr *) varmap));
71897
71898 /* [... env callee varmap] */
71899
71900 DUK_DDD(DUK_DDDPRINT("copying bound register values, %ld bound regs", (long) DUK_HOBJECT_GET_ENEXT(varmap)));
71901
71902 for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(varmap); i++) {
71903 key = DUK_HOBJECT_E_GET_KEY(thr->heap, varmap, i);
71904 DUK_ASSERT(key != NULL); /* assume keys are compacted */
71905
71906 DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, varmap, i)); /* assume plain values */
71907
71908 tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, varmap, i);
71909 DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); /* assume value is a number */
71910 regnum = (duk_uint_t) DUK_TVAL_GET_NUMBER(tv);
71911 DUK_ASSERT_DISABLE(regnum >= 0); /* unsigned */
71912 DUK_ASSERT(regnum < ((duk_hcompiledfunction *) func)->nregs); /* regnum is sane */
71913 DUK_ASSERT(thr->valstack + regbase + regnum >= thr->valstack);
71914 DUK_ASSERT(thr->valstack + regbase + regnum < thr->valstack_top);
71915
71916 /* XXX: slightly awkward */
71917 duk_push_hstring(ctx, key);
71918 duk_push_tval(ctx, thr->valstack + regbase + regnum);
71919 DUK_DDD(DUK_DDDPRINT("closing identifier '%s' -> reg %ld, value %!T",
71920 (const char *) duk_require_string(ctx, -2),
71921 (long) regnum,
71922 (duk_tval *) duk_get_tval(ctx, -1)));
71923
71924 /* [... env callee varmap key val] */
71925
71926 /* if property already exists, overwrites silently */
71927 duk_xdef_prop(ctx, -5, DUK_PROPDESC_FLAGS_WE); /* writable but not deletable */
71928 }
71929
71930 duk_pop_2(ctx);
71931
71932 /* [... env] */
#define DUK_STRIDX_INT_CALLEE
#define DUK_STRIDX_INT_REGBASE
#define DUK_STRIDX_INT_THREAD
#define DUK_PROPDESC_FLAGS_WE

◆ 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 70683 of file duktape-1.5.2/src/duktape.c.

70686 {
70687 /* Similar to String comparison. */
70688
70689 DUK_ASSERT(h1 != NULL);
70690 DUK_ASSERT(h2 != NULL);
70691 DUK_UNREF(heap);
70692
70693 return duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h1),
70694 (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h2),
70697}
70698#endif
70699
70701 duk_context *ctx = (duk_context *) thr;
70702 duk_double_t d1, d2;
70703 duk_small_int_t c1, c2;
70704 duk_small_int_t s1, s2;
70705 duk_small_int_t rc;
70706 duk_bool_t retval;
70707
70708 /* Fast path for fastints */
70709#if defined(DUK_USE_FASTINT)
70710 if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
70711 duk_int64_t v1 = DUK_TVAL_GET_FASTINT(tv_x);
70712 duk_int64_t v2 = DUK_TVAL_GET_FASTINT(tv_y);
70713 if (v1 < v2) {
70714 /* 'lt is true' */
70715 retval = 1;
70716 } else {
70717 retval = 0;
70718 }
70719 if (flags & DUK_COMPARE_FLAG_NEGATE) {
70720 retval ^= 1;
70721 }
70722 return retval;
70723 }
70724#endif /* DUK_USE_FASTINT */
70725
70726 /* Fast path for numbers (one of which may be a fastint) */
70727#if 1 /* XXX: make fast paths optional for size minimization? */
70728 if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
70729 d1 = DUK_TVAL_GET_NUMBER(tv_x);
70730 d2 = DUK_TVAL_GET_NUMBER(tv_y);
70731 c1 = DUK_FPCLASSIFY(d1);
70732 c2 = DUK_FPCLASSIFY(d2);
70733
70734 if (c1 == DUK_FP_NORMAL && c2 == DUK_FP_NORMAL) {
70735 /* XXX: this is a very narrow check, and doesn't cover
70736 * zeroes, subnormals, infinities, which compare normally.
70737 */
70738
70739 if (d1 < d2) {
70740 /* 'lt is true' */
70741 retval = 1;
70742 } else {
70743 retval = 0;
70744 }
70745 if (flags & DUK_COMPARE_FLAG_NEGATE) {
70746 retval ^= 1;
70747 }
70748 return retval;
70749 }
70750 }
70751#endif
70752
70753 /* Slow path */
70754
70755 duk_push_tval(ctx, tv_x);
70756 duk_push_tval(ctx, tv_y);
70757
70761 } else {
70764 }
70765
70766 /* Note: reuse variables */
70767 tv_x = DUK_GET_TVAL_NEGIDX(ctx, -2);
70768 tv_y = DUK_GET_TVAL_NEGIDX(ctx, -1);
70769
70770 if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
70771 duk_hstring *h1 = DUK_TVAL_GET_STRING(tv_x);
70772 duk_hstring *h2 = DUK_TVAL_GET_STRING(tv_y);
70773 DUK_ASSERT(h1 != NULL);
70774 DUK_ASSERT(h2 != NULL);
70775
70776 rc = duk_js_string_compare(h1, h2);
70777 if (rc < 0) {
70778 goto lt_true;
70779 } else {
70780 goto lt_false;
70781 }
70782 } else {
70783 /* Ordering should not matter (E5 Section 11.8.5, step 3.a) but
70784 * preserve it just in case.
70785 */
70786
70788 d1 = duk_to_number(ctx, -2);
70789 d2 = duk_to_number(ctx, -1);
70790 } else {
70791 d2 = duk_to_number(ctx, -1);
70792 d1 = duk_to_number(ctx, -2);
70793 }
70794
70796 s1 = (duk_small_int_t) DUK_SIGNBIT(d1);
70798 s2 = (duk_small_int_t) DUK_SIGNBIT(d2);
70799
70800 if (c1 == DUK_FP_NAN || c2 == DUK_FP_NAN) {
70801 goto lt_undefined;
70802 }
70803
70804 if (c1 == DUK_FP_ZERO && c2 == DUK_FP_ZERO) {
70805 /* For all combinations: +0 < +0, +0 < -0, -0 < +0, -0 < -0,
70806 * steps e, f, and g.
70807 */
70808 goto lt_false;
70809 }
70810
70811 if (d1 == d2) {
70812 goto lt_false;
70813 }
70814
70815 if (c1 == DUK_FP_INFINITE && s1 == 0) {
70816 /* x == +Infinity */
70817 goto lt_false;
70818 }
70819
70820 if (c2 == DUK_FP_INFINITE && s2 == 0) {
70821 /* y == +Infinity */
70822 goto lt_true;
70823 }
70824
70825 if (c2 == DUK_FP_INFINITE && s2 != 0) {
70826 /* y == -Infinity */
70827 goto lt_false;
70828 }
70829
70830 if (c1 == DUK_FP_INFINITE && s1 != 0) {
70831 /* x == -Infinity */
70832 goto lt_true;
70833 }
70834
70835 if (d1 < d2) {
70836 goto lt_true;
70837 }
70838
70839 goto lt_false;
70840 }
70841
70842 lt_undefined:
70843 /* Note: undefined from Section 11.8.5 always results in false
70844 * return (see e.g. Section 11.8.3) - hence special treatment here.
70845 */
70846 retval = 0;
70847 goto cleanup;
70848
70849 lt_true:
70850 if (flags & DUK_COMPARE_FLAG_NEGATE) {
70851 retval = 0;
70852 goto cleanup;
70853 } else {
70854 retval = 1;
70855 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 65294 of file duktape-1.5.2/src/duktape.c.

65311 {
65312 duk_context *ctx = (duk_context *) thr;
65313 duk__compiler_stkstate comp_stk;
65314 duk_compiler_ctx *prev_ctx;
65315 duk_ret_t safe_rc;
65316
65317 /* XXX: this illustrates that a C catchpoint implemented using duk_safe_call()
65318 * is a bit heavy at the moment. The wrapper compiles to ~180 bytes on x64.
65319 * Alternatives would be nice.
65320 */
65321
65322 DUK_ASSERT(thr != NULL);
65323 DUK_ASSERT(src_buffer != NULL);
65324
65325 /* preinitialize lexer state partially */
65326 DUK_MEMZERO(&comp_stk, sizeof(comp_stk));
65327 comp_stk.flags = flags;
65329 comp_stk.comp_ctx_alloc.lex.input = src_buffer;
#define DUK_LEXER_INITCTX(ctx)

◆ 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 70615 of file duktape-1.5.2/src/duktape.c.

70632 {
70633 duk_size_t prefix_len;
70634 duk_small_int_t rc;
70635
70636 prefix_len = (len1 <= len2 ? len1 : len2);
70637
70638 /* DUK_MEMCMP() is guaranteed to return zero (equal) for zero length
70639 * inputs so no zero length check is needed.
70640 */
70641 rc = DUK_MEMCMP((const void *) buf1,
70642 (const void *) buf2,
70643 (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 72997 of file duktape-1.5.2/src/duktape.c.

73007 :
73008 fail_not_extensible:
73009 DUK_ERROR_TYPE(thr, "declaration failed");
73010 return 0;
73011}
73012
73015 duk_activation *act,
73017 duk_tval *val,
73018 duk_small_int_t prop_flags,
73019 duk_bool_t is_func_decl) {
73020 duk_hobject *env;
73021 duk_tval tv_val_copy;
73022
73023 /*
73024 * Make a value copy of the input val. This ensures that
73025 * side effects cannot invalidate the pointer.
73026 */
73027
73028 DUK_TVAL_SET_TVAL(&tv_val_copy, val);
73029 val = &tv_val_copy;
73030

◆ 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 72707 of file duktape-1.5.2/src/duktape.c.

72708 : name=%!O "
72709 "(treated as silent success)",
72710 (duk_heaphdr *) name));
72711 return 1;
72712}

◆ 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 70383 of file duktape-1.5.2/src/duktape.c.

70391 {
70392 /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
70393 return 1;
70394 }
70395 return 0;
70396 }
70397#endif /* DUK_USE_PARANOID_MATH */
70398}
70399
70401 duk_context *ctx = (duk_context *) thr;
70402 duk_tval *tv_tmp;
70403
70404 /* If flags != 0 (strict or SameValue), thr can be NULL. For loose
70405 * equals comparison it must be != NULL.
70406 */
70407 DUK_ASSERT(flags != 0 || thr != NULL);
70408
70409 /*
70410 * Same type?
70411 *
70412 * Note: since number values have no explicit tag in the 8-byte
70413 * representation, need the awkward if + switch.
70414 */
70415
70416#if defined(DUK_USE_FASTINT)
70417 if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
70418 if (DUK_TVAL_GET_FASTINT(tv_x) == DUK_TVAL_GET_FASTINT(tv_y)) {
70419 return 1;
70420 } else {
70421 return 0;
70422 }
70423 }
70424 else
70425#endif
70426 if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
70427 /* Catches both doubles and cases where only one argument is a fastint */
70428 if (DUK_UNLIKELY((flags & DUK_EQUALS_FLAG_SAMEVALUE) != 0)) {
70429 /* SameValue */
70431 DUK_TVAL_GET_NUMBER(tv_y));
70432 } else {
70433 /* equals and strict equals */
70435 DUK_TVAL_GET_NUMBER(tv_y));
70436 }
70437 } else if (DUK_TVAL_GET_TAG(tv_x) == DUK_TVAL_GET_TAG(tv_y)) {
70438 switch (DUK_TVAL_GET_TAG(tv_x)) {
70439 case DUK_TAG_UNDEFINED:
70440 case DUK_TAG_NULL: {
70441 return 1;
70442 }
70443 case DUK_TAG_BOOLEAN: {
70444 return DUK_TVAL_GET_BOOLEAN(tv_x) == DUK_TVAL_GET_BOOLEAN(tv_y);
70445 }
70446 case DUK_TAG_POINTER: {
70447 return DUK_TVAL_GET_POINTER(tv_x) == DUK_TVAL_GET_POINTER(tv_y);
70448 }
70449 case DUK_TAG_STRING:
70450 case DUK_TAG_OBJECT: {
70451 /* heap pointer comparison suffices */
70452 return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
70453 }
70454 case DUK_TAG_BUFFER: {
70455 if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
70456 /* heap pointer comparison suffices */
70457 return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
70458 } else {
70459 /* non-strict equality for buffers compares contents */
70460 duk_hbuffer *h_x = DUK_TVAL_GET_BUFFER(tv_x);
70461 duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
70462 duk_size_t len_x = DUK_HBUFFER_GET_SIZE(h_x);
70463 duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
70464 void *buf_x;
70465 void *buf_y;
70466 if (len_x != len_y) {
70467 return 0;
70468 }
70469 buf_x = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_x);
70470 buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
70471 /* if len_x == len_y == 0, buf_x and/or buf_y may
70472 * be NULL, but that's OK.
70473 */
70474 DUK_ASSERT(len_x == len_y);
70475 DUK_ASSERT(len_x == 0 || buf_x != NULL);
70476 DUK_ASSERT(len_y == 0 || buf_y != NULL);
70477 return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0;
70478 }
70479 }
70480 case DUK_TAG_LIGHTFUNC: {
70481 /* At least 'magic' has a significant impact on function
70482 * identity.
70483 */
70484 duk_small_uint_t lf_flags_x;
70485 duk_small_uint_t lf_flags_y;
70486 duk_c_function func_x;
70487 duk_c_function func_y;
70488
70489 DUK_TVAL_GET_LIGHTFUNC(tv_x, func_x, lf_flags_x);
70490 DUK_TVAL_GET_LIGHTFUNC(tv_y, func_y, lf_flags_y);
70491 return ((func_x == func_y) && (lf_flags_x == lf_flags_y)) ? 1 : 0;
70492 }
70493#if defined(DUK_USE_FASTINT)
70494 case DUK_TAG_FASTINT:
70495#endif
70496 default: {
70502 return 0;
70503 }
70504 }
70505 }
70506
70507 if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
70508 return 0;
70509 }
70510
70511 DUK_ASSERT(flags == 0); /* non-strict equality from here on */
70512
70513 /*
70514 * Types are different; various cases for non-strict comparison
70515 *
70516 * Since comparison is symmetric, we use a "swap trick" to reduce
70517 * code size.
70518 */
70519
70520 /* Undefined/null are considered equal (e.g. "null == undefined" -> true). */
70521 if ((DUK_TVAL_IS_UNDEFINED(tv_x) && DUK_TVAL_IS_NULL(tv_y)) ||
70522 (DUK_TVAL_IS_NULL(tv_x) && DUK_TVAL_IS_UNDEFINED(tv_y))) {
70523 return 1;
70524 }
70525
70526 /* Number/string-or-buffer -> coerce string to number (e.g. "'1.5' == 1.5" -> true). */
70527 if (DUK_TVAL_IS_NUMBER(tv_x) && (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) {
70528 /* the next 'if' is guaranteed to match after swap */
70529 tv_tmp = tv_x;
70530 tv_x = tv_y;
70531 tv_y = tv_tmp;
70532 }
70533 if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) && DUK_TVAL_IS_NUMBER(tv_y)) {
70534 /* XXX: this is possible without resorting to the value stack */
70535 duk_double_t d1, d2;
70536 d2 = DUK_TVAL_GET_NUMBER(tv_y);
70537 duk_push_tval(ctx, tv_x);
70538 duk_to_string(ctx, -1); /* buffer values are coerced first to string here */
70539 duk_to_number(ctx, -1);
70540 d1 = duk_require_number(ctx, -1);
70541 duk_pop(ctx);
70542 return duk__js_equals_number(d1, d2);
70543 }
70544
70545 /* Buffer/string -> compare contents. */
70546 if (DUK_TVAL_IS_BUFFER(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
70547 tv_tmp = tv_x;
70548 tv_x = tv_y;
70549 tv_y = tv_tmp;
70550 }
70551 if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_BUFFER(tv_y)) {
70552 duk_hstring *h_x = DUK_TVAL_GET_STRING(tv_x);
70553 duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
70555 duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
70556 const void *buf_x;
70557 const void *buf_y;
70558 if (len_x != len_y) {
70559 return 0;
70560 }
70561 buf_x = (const void *) DUK_HSTRING_GET_DATA(h_x);
70562 buf_y = (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
70563 /* if len_x == len_y == 0, buf_x and/or buf_y may
70564 * be NULL, but that's OK.
70565 */
70566 DUK_ASSERT(len_x == len_y);
70567 DUK_ASSERT(len_x == 0 || buf_x != NULL);
70568 DUK_ASSERT(len_y == 0 || buf_y != NULL);
70569 return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0;
70570 }
70571
70572 /* Boolean/any -> coerce boolean to number and try again. If boolean is
70573 * compared to a pointer, the final comparison after coercion now always
70574 * yields false (as pointer vs. number compares to false), but this is
70575 * not special cased.
70576 */
70577 if (DUK_TVAL_IS_BOOLEAN(tv_x)) {
70578 tv_tmp = tv_x;
70579 tv_x = tv_y;
70580 tv_y = tv_tmp;
70581 }
70582 if (DUK_TVAL_IS_BOOLEAN(tv_y)) {
70583 /* ToNumber(bool) is +1.0 or 0.0. Tagged boolean value is always 0 or 1. */
70584 duk_bool_t rc;
70585 DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv_y) == 0 || DUK_TVAL_GET_BOOLEAN(tv_y) == 1);
70586 duk_push_tval(ctx, tv_x);
70588 rc = duk_js_equals_helper(thr,
70589 DUK_GET_TVAL_NEGIDX(ctx, -2),
70590 DUK_GET_TVAL_NEGIDX(ctx, -1),
70591 0 /*flags:nonstrict*/);
70592 duk_pop_2(ctx);
70593 return rc;
70594 }
70595
70596 /* String-number-buffer/object -> coerce object to primitive (apparently without hint), then try again. */
70597 if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_NUMBER(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) &&
70598 DUK_TVAL_IS_OBJECT(tv_y)) {
70599 tv_tmp = tv_x;
70600 tv_x = tv_y;
70601 tv_y = tv_tmp;
70602 }
DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index)
#define DUK_EQUALS_FLAG_SAMEVALUE
#define DUK_TVAL_GET_LIGHTFUNC(tv, out_fp, out_flags)

◆ duk_js_execute_bytecode()

DUK_INTERNAL_DECL void duk_js_execute_bytecode ( duk_hthread * exec_thr)

Definition at line 67355 of file duktape-1.5.2/src/duktape.c.

67355 {
67356 /* Restart bytecode execution, possibly with a changed thread. */
67357 ;
67358 } else {
67359 /* Rethrow error to calling state. */
67361
67362 /* Longjmp handling has restored jmpbuf_ptr. */
67363 DUK_ASSERT(heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr);
67364
67365 /* Thread may have changed, e.g. YIELD converted to THROW. */
67366 duk_err_longjmp(heap->curr_thread);
67368 }
67369}
67370
67371/* Outer executor with setjmp/longjmp handling. */
67373 /* Entry level info. */
67374 duk_hthread *entry_thread;
67375 duk_size_t entry_callstack_top;
67376 duk_int_t entry_call_recursion_depth;
67377 duk_jmpbuf *entry_jmpbuf_ptr;
67378 duk_jmpbuf our_jmpbuf;
67379 duk_heap *heap;
67380
67381 DUK_ASSERT(exec_thr != NULL);
67382 DUK_ASSERT(exec_thr->heap != NULL);
67383 DUK_ASSERT(exec_thr->heap->curr_thread != NULL);
67385 DUK_ASSERT(exec_thr->callstack_top >= 1); /* at least one activation, ours */
67386 DUK_ASSERT(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1) != NULL);
67388
67389 entry_thread = exec_thr;
67390 heap = entry_thread->heap;
67391 entry_callstack_top = entry_thread->callstack_top;
67392 entry_call_recursion_depth = entry_thread->heap->call_recursion_depth;
67393 entry_jmpbuf_ptr = entry_thread->heap->lj.jmpbuf_ptr;
67394
67395 /*
67396 * Note: we currently assume that the setjmp() catchpoint is
67397 * not re-entrant (longjmp() cannot be called more than once
67398 * for a single setjmp()).
67399 *
67400 * See doc/code-issues.rst for notes on variable assignment
67401 * before and after setjmp().
67402 */
67403
67404 for (;;) {
67405 heap->lj.jmpbuf_ptr = &our_jmpbuf;
67406 DUK_ASSERT(heap->lj.jmpbuf_ptr != NULL);
67407
67408#if defined(DUK_USE_CPP_EXCEPTIONS)
67409 try {
67410#else
67411 DUK_ASSERT(heap->lj.jmpbuf_ptr == &our_jmpbuf);
67412 if (DUK_SETJMP(our_jmpbuf.jb) == 0) {
67413#endif
67414 /* Execute bytecode until returned or longjmp(). */
67415 duk__js_execute_bytecode_inner(entry_thread, entry_callstack_top);
67416
67417 /* Successful return: restore jmpbuf and return to caller. */
67418 heap->lj.jmpbuf_ptr = entry_jmpbuf_ptr;
67419
67420 return;
67421#if defined(DUK_USE_CPP_EXCEPTIONS)
67422 } catch (duk_internal_exception &exc) {
67423#else
67424 } else {
67425#endif
67426#if defined(DUK_USE_CPP_EXCEPTIONS)
67427 DUK_UNREF(exc);
67428#endif
67429 DUK_DDD(DUK_DDDPRINT("longjmp caught by bytecode executor"));
67430
67432 entry_thread,
67433 entry_callstack_top,
67434 entry_call_recursion_depth,
67435 entry_jmpbuf_ptr);
67436 }
67437#if defined(DUK_USE_CPP_EXCEPTIONS)
67438 catch (std::exception &exc) {
67439 const char *what = exc.what();
67440 if (!what) {
67441 what = "unknown";
67442 }
67443 DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)"));
67444 try {
67445 DUK_ASSERT(heap->curr_thread != NULL);
67446 DUK_ERROR_FMT1(heap->curr_thread, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what);
67447 } catch (duk_internal_exception exc) {
67448 DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception"));
67449 DUK_UNREF(exc);
67451 entry_thread,
67452 entry_callstack_top,
67453 entry_call_recursion_depth,
67454 entry_jmpbuf_ptr);
67455 }
67456 } catch (...) {
67457 DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)"));
67458 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 72492 of file duktape-1.5.2/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 72484 of file duktape-1.5.2/src/duktape.c.

72489 {

◆ 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 71034 of file duktape-1.5.2/src/duktape.c.

71036 :
71037 duk_pop_2(ctx);
71038 return 1;
71039}
71040
71041/*
71042 * in
71043 */
71044
71045/*
71046 * E5 Sections 11.8.7, 8.12.6.
71047 *
71048 * Basically just a property existence check using [[HasProperty]].
71049 */
71050
71052 duk_context *ctx = (duk_context *) thr;
71053 duk_bool_t retval;
71054
71055 /*
71056 * Get the values onto the stack first. It would be possible to cover
71057 * some normal cases without resorting to the value stack (e.g. if
71058 * lval is already a string).
71059 */
71060
71061 /* XXX: The ES5/5.1/6 specifications require that the key in 'key in obj'
71062 * must be string coerced before the internal HasProperty() algorithm is
71063 * invoked. A fast path skipping coercion could be safely implemented for
71064 * numbers (as number-to-string coercion has no side effects). For ES6
71065 * proxy behavior, the trap 'key' argument must be in a string coerced
71066 * 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 71738 of file duktape-1.5.2/src/duktape.c.

71742 {
71743 duk_push_hthread(ctx, thr);
71745 duk_push_hobject(ctx, func);
71747 duk_push_size_t(ctx, idx_bottom);
71749 }
71750
71751 return env;
71752}
71753
71756 duk_activation *act) {
71757 duk_context *ctx = (duk_context *) thr;
71758 duk_hobject *func;
71759 duk_hobject *env;
71760
71761 func = DUK_ACT_GET_FUNC(act);
71762 DUK_ASSERT(func != NULL);
71763 DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); /* bound functions are never in act 'func' */
71764
71765 /*
71766 * Delayed initialization only occurs for 'NEWENV' functions.
71767 */
71768
71770 DUK_ASSERT(act->lex_env == NULL);
71771 DUK_ASSERT(act->var_env == NULL);
71772
71774 DUK_ASSERT(env != NULL);
71775
71776 DUK_DDD(DUK_DDDPRINT("created delayed fresh env: %!ipO", (duk_heaphdr *) env));
#define duk_push_hthread(ctx, h)

◆ 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 70877 of file duktape-1.5.2/src/duktape.c.

70894 {
70895 duk_context *ctx = (duk_context *) thr;
70896 duk_hobject *func;
70897 duk_hobject *val;
70899 duk_uint_t sanity;
70900
70901 /*
70902 * Get the values onto the stack first. It would be possible to cover
70903 * some normal cases without resorting to the value stack.
70904 *
70905 * The right hand side could be a light function (as they generally
70906 * behave like objects). Light functions never have a 'prototype'
70907 * property so E5.1 Section 15.3.5.3 step 3 always throws a TypeError.
70908 * Using duk_require_hobject() is thus correct (except for error msg).
70909 */
70910
70911 duk_push_tval(ctx, tv_x);
70912 duk_push_tval(ctx, tv_y);
70913 func = duk_require_hobject(ctx, -1);
70914
70915 /*
70916 * For bound objects, [[HasInstance]] just calls the target function
70917 * [[HasInstance]]. If that is again a bound object, repeat until
70918 * we find a non-bound Function object.
70919 */
70920
70921 /* XXX: this bound function resolution also happens elsewhere,
70922 * move into a shared helper.
70923 */
70924
70926 do {
70927 /* check func supports [[HasInstance]] (this is checked for every function
70928 * in the bound chain, including the final one)
70929 */
70930
70931 if (!DUK_HOBJECT_IS_CALLABLE(func)) {
70932 /*
70933 * Note: of native Ecmascript objects, only Function instances
70934 * have a [[HasInstance]] internal property. Custom objects might
70935 * also have it, but not in current implementation.
70936 *
70937 * XXX: add a separate flag, DUK_HOBJECT_FLAG_ALLOW_INSTANCEOF?
70938 */
70939 DUK_ERROR_TYPE(thr, "invalid instanceof rval");
70940 }
70941
70942 if (!DUK_HOBJECT_HAS_BOUND(func)) {
70943 break;
70944 }
70945
70946 /* [ ... lval rval ] */
70947
70948 duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET); /* -> [ ... lval rval new_rval ] */
70949 duk_replace(ctx, -1); /* -> [ ... lval new_rval ] */
70950 func = duk_require_hobject(ctx, -1);
70951
70952 /* func support for [[HasInstance]] checked in the beginning of the loop */
70953 } while (--sanity > 0);
70954
70955 if (sanity == 0) {
70957 }
70958
70959 /*
70960 * 'func' is now a non-bound object which supports [[HasInstance]]
70961 * (which here just means DUK_HOBJECT_FLAG_CALLABLE). Move on
70962 * to execute E5 Section 15.3.5.3.
70963 */
70964
70967
70968 /* [ ... lval rval(func) ] */
70969
70970 /* Handle lightfuncs through object coercion for now. */
70971 /* XXX: direct implementation */
70972 val = duk_get_hobject_or_lfunc_coerce(ctx, -2);
70973 if (!val) {
70974 goto pop_and_false;
70975 }
70976
70977 duk_get_prop_stridx(ctx, -1, DUK_STRIDX_PROTOTYPE); /* -> [ ... lval rval rval.prototype ] */
70978 proto = duk_require_hobject(ctx, -1);
70979 duk_pop(ctx); /* -> [ ... lval rval ] */
70980
70981 DUK_ASSERT(val != NULL);
70982
70983#if defined(DUK_USE_ES6_PROXY)
70984 val = duk_hobject_resolve_proxy_target(thr, val);
70985 DUK_ASSERT(val != NULL);
70986#endif
70987
70989 do {
70990 /*
70991 * Note: prototype chain is followed BEFORE first comparison. This
70992 * means that the instanceof lval is never itself compared to the
70993 * rval.prototype property. This is apparently intentional, see E5
70994 * Section 15.3.5.3, step 4.a.
70995 *
70996 * Also note:
70997 *
70998 * js> (function() {}) instanceof Function
70999 * true
71000 * js> Function instanceof Function
71001 * true
71002 *
71003 * For the latter, h_proto will be Function.prototype, which is the
71004 * built-in Function prototype. Because Function.[[Prototype]] is
71005 * also the built-in Function prototype, the result is true.
71006 */
71007
71008 DUK_ASSERT(val != NULL);
71009 val = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, val);
71010
71011 if (!val) {
71012 goto pop_and_false;
71013 }
71014
71015 DUK_ASSERT(val != NULL);
71016#if defined(DUK_USE_ES6_PROXY)
71017 val = duk_hobject_resolve_proxy_target(thr, val);
71018#endif
71019
71020 if (val == proto) {
71021 goto pop_and_true;
71022 }
DUK_INTERNAL_DECL duk_hobject * duk_hobject_resolve_proxy_target(duk_hthread *thr, duk_hobject *obj)

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 71327 of file duktape-1.5.2/src/duktape.c.

71328 : if fun_temp has NEWENV, i.e. a new lexical and variable declaration
71329 * is created when the function is called, only outer_lex_env matters
71330 * (outer_var_env is ignored and may or may not be same as outer_lex_env).
71331 */
71332
71333DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[] = {
71334 /* order: most frequent to least frequent */
71341};
71342
71345 duk_hcompiledfunction *fun_temp,
71346 duk_hobject *outer_var_env,
71347 duk_hobject *outer_lex_env,
71348 duk_bool_t add_auto_proto) {
71349 duk_context *ctx = (duk_context *) thr;
71350 duk_hcompiledfunction *fun_clos;
71352 duk_uint_t len_value;
71353
71354 DUK_ASSERT(fun_temp != NULL);
71358 DUK_ASSERT(outer_var_env != NULL);
71359 DUK_ASSERT(outer_lex_env != NULL);
71360 DUK_UNREF(len_value);
71361
71363 duk_push_hobject(ctx, &fun_temp->obj); /* -> [ ... closure template ] */
71364
71365 fun_clos = (duk_hcompiledfunction *) duk_get_hcompiledfunction(ctx, -2);
71366 DUK_ASSERT(fun_clos != NULL);
71371
71375
71376 /* Note: all references inside 'data' need to get their refcounts
71377 * upped too. This is the case because refcounts are decreased
71378 * through every function referencing 'data' independently.
71379 */
71380
71382 duk__inc_data_inner_refcounts(thr, fun_temp);
71383
71384 fun_clos->nregs = fun_temp->nregs;
71385 fun_clos->nargs = fun_temp->nargs;
71386#if defined(DUK_USE_DEBUGGER_SUPPORT)
71387 fun_clos->start_line = fun_temp->start_line;
71388 fun_clos->end_line = fun_temp->end_line;
71389#endif
71390
71394
71395 /* XXX: could also copy from template, but there's no way to have any
71396 * other value here now (used code has no access to the template).
71397 */
71399
71400 /*
71401 * Init/assert flags, copying them where appropriate. Some flags
71402 * (like NEWENV) are processed separately below.
71403 */
71404
71405 /* XXX: copy flags using a mask */
71406
71408 DUK_HOBJECT_SET_CONSTRUCTABLE(&fun_clos->obj); /* Note: not set in template (has no "prototype") */
71410 DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&fun_clos->obj));
71414 /* DUK_HOBJECT_FLAG_ARRAY_PART: don't care */
71415 if (DUK_HOBJECT_HAS_STRICT(&fun_temp->obj)) {
71416 DUK_HOBJECT_SET_STRICT(&fun_clos->obj);
71417 }
71418 if (DUK_HOBJECT_HAS_NOTAIL(&fun_temp->obj)) {
71419 DUK_HOBJECT_SET_NOTAIL(&fun_clos->obj);
71420 }
71421 /* DUK_HOBJECT_FLAG_NEWENV: handled below */
71422 if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) {
71423 /* Although NAMEBINDING is not directly needed for using
71424 * function instances, it's needed by bytecode dump/load
71425 * so copy it too.
71426 */
71427 DUK_HOBJECT_SET_NAMEBINDING(&fun_clos->obj);
71428 }
71429 if (DUK_HOBJECT_HAS_CREATEARGS(&fun_temp->obj)) {
71430 DUK_HOBJECT_SET_CREATEARGS(&fun_clos->obj);
71431 }
71435
71436 /*
71437 * Setup environment record properties based on the template and
71438 * its flags.
71439 *
71440 * If DUK_HOBJECT_HAS_NEWENV(fun_temp) is true, the environment
71441 * records represent identifiers "outside" the function; the
71442 * "inner" environment records are created on demand. Otherwise,
71443 * the environment records are those that will be directly used
71444 * (e.g. for declarations).
71445 *
71446 * _Lexenv is always set; _Varenv defaults to _Lexenv if missing,
71447 * so _Varenv is only set if _Lexenv != _Varenv.
71448 *
71449 * This is relatively complex, see doc/identifier-handling.rst.
71450 */
71451
71452 if (DUK_HOBJECT_HAS_NEWENV(&fun_temp->obj)) {
71453 DUK_HOBJECT_SET_NEWENV(&fun_clos->obj);
71454
71455 if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) {
71457
71458 /*
71459 * Named function expression, name needs to be bound
71460 * in an intermediate environment record. The "outer"
71461 * lexical/variable environment will thus be:
71462 *
71463 * a) { funcname: <func>, __prototype: outer_lex_env }
71464 * b) { funcname: <func>, __prototype: <globalenv> } (if outer_lex_env missing)
71465 */
71466
71467 DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_NAME)); /* required if NAMEBINDING set */
71468
71469 if (outer_lex_env) {
71470 proto = outer_lex_env;
71471 } else {
71473 }
71474
71475 /* -> [ ... closure template env ] */
71479 proto);
71480
71481 /* It's important that duk_xdef_prop() is a 'raw define' so that any
71482 * properties in an ancestor are never an issue (they should never be
71483 * e.g. non-writable, but just in case).
71484 */
71485 duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME); /* -> [ ... closure template env funcname ] */
71486 duk_dup(ctx, -4); /* -> [ ... closure template env funcname closure ] */
71487 duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ ... closure template env ] */
71488 /* env[funcname] = closure */
71489
71490 /* [ ... closure template env ] */
71491
71493 /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
71494 * will be ignored anyway
71495 */
71496
71497 /* [ ... closure template ] */
71498 } else {
71499 /*
71500 * Other cases (function declaration, anonymous function expression,
71501 * strict direct eval code). The "outer" environment will be whatever
71502 * the caller gave us.
71503 */
71504
71505 duk_push_hobject(ctx, outer_lex_env); /* -> [ ... closure template env ] */
71507 /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
71508 * will be ignored anyway
71509 */
71510
71511 /* [ ... closure template ] */
71512 }
71513 } else {
71514 /*
71515 * Function gets no new environment when called. This is the
71516 * case for global code, indirect eval code, and non-strict
71517 * direct eval code. There is no direct correspondence to the
71518 * E5 specification, as global/eval code is not exposed as a
71519 * function.
71520 */
71521
71523
71524 duk_push_hobject(ctx, outer_lex_env); /* -> [ ... closure template env ] */
71526
71527 if (outer_var_env != outer_lex_env) {
71528 duk_push_hobject(ctx, outer_var_env); /* -> [ ... closure template env ] */
71530 }
71531 }
71532#ifdef DUK_USE_DDDPRINT
71535 DUK_DDD(DUK_DDDPRINT("closure varenv -> %!ipT, lexenv -> %!ipT",
71536 (duk_tval *) duk_get_tval(ctx, -2),
71537 (duk_tval *) duk_get_tval(ctx, -1)));
71538 duk_pop_2(ctx);
71539#endif
71540
71541 /*
71542 * Copy some internal properties directly
71543 *
71544 * The properties will be writable and configurable, but not enumerable.
71545 */
71546
71547 /* [ ... closure template ] */
71548
71549 DUK_DDD(DUK_DDDPRINT("copying properties: closure=%!iT, template=%!iT",
71550 (duk_tval *) duk_get_tval(ctx, -2),
71551 (duk_tval *) duk_get_tval(ctx, -1)));
71552
71553 for (i = 0; i < (duk_small_uint_t) (sizeof(duk__closure_copy_proplist) / sizeof(duk_uint16_t)); i++) {
71555 if (duk_get_prop_stridx(ctx, -1, stridx)) {
71556 /* [ ... closure template val ] */
71557 DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> found", (long) stridx));
71559 } else {
71560 DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> not found", (long) stridx));
71561 duk_pop(ctx);
71562 }
71563 }
71564
71565 /*
71566 * "length" maps to number of formals (E5 Section 13.2) for function
71567 * declarations/expressions (non-bound functions). Note that 'nargs'
71568 * is NOT necessarily equal to the number of arguments.
71569 */
71570
71571 /* [ ... closure template ] */
71572
71573 len_value = 0;
71574
71575 /* XXX: use helper for size optimization */
71577 /* [ ... closure template formals ] */
71579 DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_UINT_MAX); /* formal arg limits */
71580 len_value = (duk_uint_t) duk_get_length(ctx, -1);
71581 } else {
71582 /* XXX: what to do if _Formals is not empty but compiler has
71583 * optimized it away -- read length from an explicit property
71584 * then?
71585 */
71586 }
71587 duk_pop(ctx);
71588
71589 duk_push_uint(ctx, len_value); /* [ ... closure template len_value ] */
71591
71592 /*
71593 * "prototype" is, by default, a fresh object with the "constructor"
71594 * property.
71595 *
71596 * Note that this creates a circular reference for every function
71597 * instance (closure) which prevents refcount-based collection of
71598 * function instances.
71599 *
71600 * XXX: Try to avoid creating the default prototype object, because
71601 * many functions are not used as constructors and the default
71602 * prototype is unnecessary. Perhaps it could be created on-demand
71603 * when it is first accessed?
71604 */
71605
71606 /* [ ... closure template ] */
71607
71608 if (add_auto_proto) {
71609 duk_push_object(ctx); /* -> [ ... closure template newobj ] */
71610 duk_dup(ctx, -3); /* -> [ ... closure template newobj closure ] */
71611 duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC); /* -> [ ... closure template newobj ] */
71612 duk_compact(ctx, -1); /* compact the prototype */
71613 duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W); /* -> [ ... closure template ] */
71614 }
71615
71616 /*
71617 * "arguments" and "caller" must be mapped to throwers for strict
71618 * mode and bound functions (E5 Section 15.3.5).
71619 *
71620 * XXX: This is expensive to have for every strict function instance.
71621 * Try to implement as virtual properties or on-demand created properties.
71622 */
71623
71624 /* [ ... closure template ] */
71625
71626 if (DUK_HOBJECT_HAS_STRICT(&fun_clos->obj)) {
71629 } else {
71630#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
71631 DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property in use, add initial 'null' value"));
71632 duk_push_null(ctx);
71634#else
71635 DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property not used"));
71636#endif
71637 }
71638
71639 /*
71640 * "name" is a non-standard property found in at least V8, Rhino, smjs.
71641 * For Rhino and smjs it is non-writable, non-enumerable, and non-configurable;
71642 * for V8 it is writable, non-enumerable, non-configurable. It is also defined
71643 * for an anonymous function expression in which case the value is an empty string.
71644 * We could also leave name 'undefined' for anonymous functions but that would
71645 * differ from behavior of other engines, so use an empty string.
71646 *
71647 * XXX: make optional? costs something per function.
71648 */
71649
71650 /* [ ... closure template ] */
71651
71652 if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME)) {
71653 /* [ ... closure template name ] */
71654 DUK_ASSERT(duk_is_string(ctx, -1));
71655 } else {
71656 /* [ ... closure template undefined ] */
71657 duk_pop(ctx);
71659 }
71660 duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); /* -> [ ... closure template ] */
71661
71662 /*
71663 * Compact the closure, in most cases no properties will be added later.
71664 * Also, without this the closures end up having unused property slots
71665 * (e.g. in Duktape 0.9.0, 8 slots would be allocated and only 7 used).
71666 * A better future solution would be to allocate the closure directly
71667 * to correct size (and setup the properties directly without going
71668 * through the API).
71669 */
71670
71671 duk_compact(ctx, -2);
71672
71673 /*
71674 * Some assertions (E5 Section 13.2).
71675 */
71676
71681 DUK_ASSERT(add_auto_proto == 0 || duk_has_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE) != 0);
71682 DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_NAME) != 0); /* non-standard */
71683 DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(&fun_clos->obj) ||
71684 duk_has_prop_stridx(ctx, -2, DUK_STRIDX_CALLER) != 0);
DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[]
#define DUK_HOBJECT_SET_CONSTRUCTABLE(h)
DUK_LOCAL void duk__inc_data_inner_refcounts(duk_hthread *thr, duk_hcompiledfunction *f)

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 72622 of file duktape-1.5.2/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 72613 of file duktape-1.5.2/src/duktape.c.

72613 {
72614 DUK_DDD(DUK_DDDPRINT("identifier binding not found, strict => reference error"));
72615 DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "identifier not defined");
72616 }
72617
72618 DUK_DDD(DUK_DDDPRINT("identifier binding not found, not strict => set to global"));
72619

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 70645 of file duktape-1.5.2/src/duktape.c.

70645 {
70646 return -1;
70647 } else if (rc > 0) {
70648 return 1;
70649 }
70650
70651 /* prefix matches, lengths matter now */
70652 if (len1 < len2) {
70653 /* e.g. "x" < "xx" */
70654 return -1;
70655 } else if (len1 > len2) {
70656 return 1;
70657 }
70658
70659 return 0;
70660}
70661
70663 /*
70664 * String comparison (E5 Section 11.8.5, step 4), which
70665 * needs to compare codepoint by codepoint.
70666 *

◆ 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 71155 of file duktape-1.5.2/src/duktape.c.

71172 {
71173 duk_uarridx_t res, new_res;
71174
71175 if (blen == 0 || blen > 10) {
71176 goto parse_fail;
71177 }
71178 if (str[0] == (duk_uint8_t) '0' && blen > 1) {
71179 goto parse_fail;
71180 }
71181
71182 /* Accept 32-bit decimal integers, no leading zeroes, signs, etc.
71183 * Leading zeroes are not accepted (zero index "0" is an exception
71184 * handled above).
71185 */
71186
71187 res = 0;
71188 while (blen-- > 0) {
71189 duk_uint8_t c = *str++;
71190 if (c >= (duk_uint8_t) '0' && c <= (duk_uint8_t) '9') {
71191 new_res = res * 10 + (duk_uint32_t) (c - (duk_uint8_t) '0');

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 71194 of file duktape-1.5.2/src/duktape.c.

71197 {
71198 goto parse_fail;
71199 }
71200 }
71201
71202 *out_idx = res;
71203 return 1;
71204
71205 parse_fail:
71206 *out_idx = DUK_HSTRING_NO_ARRAY_INDEX;
71207 return 0;
71208}

◆ duk_js_toboolean()

DUK_INTERNAL_DECL duk_bool_t duk_js_toboolean ( duk_tval * tv)

Definition at line 69903 of file duktape-1.5.2/src/duktape.c.

69920 {
69921 switch (DUK_TVAL_GET_TAG(tv)) {
69922 case DUK_TAG_UNDEFINED:
69923 case DUK_TAG_NULL:
69924 return 0;
69925 case DUK_TAG_BOOLEAN:
69926 return DUK_TVAL_GET_BOOLEAN(tv);
69927 case DUK_TAG_STRING: {
69929 DUK_ASSERT(h != NULL);
69930 return (DUK_HSTRING_GET_BYTELEN(h) > 0 ? 1 : 0);
69931 }
69932 case DUK_TAG_OBJECT: {
69933 return 1;
69934 }
69935 case DUK_TAG_BUFFER: {
69936 /* mimic semantics for strings */
69938 DUK_ASSERT(h != NULL);
69939 return (DUK_HBUFFER_GET_SIZE(h) > 0 ? 1 : 0);
69940 }
69941 case DUK_TAG_POINTER: {
69942 void *p = DUK_TVAL_GET_POINTER(tv);
69943 return (p != NULL ? 1 : 0);
69944 }
69945 case DUK_TAG_LIGHTFUNC: {
69946 return 1;
69947 }
69948#if defined(DUK_USE_FASTINT)
69949 case DUK_TAG_FASTINT:
69950 if (DUK_TVAL_GET_FASTINT(tv) != 0) {
69951 return 1;
69952 } else {
69953 return 0;
69954 }
69955#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 70165 of file duktape-1.5.2/src/duktape.c.

70166 {
70167 x += DUK_DOUBLE_2TO32;
70168 }
70169 /* -> x in [0, 2**32[ */
70170
70171 if (is_toint32) {
70172 if (x >= DUK_DOUBLE_2TO31) {
70173 /* x in [2**31, 2**32[ */
70174
70175 x -= DUK_DOUBLE_2TO32; /* -> x in [-2**31,2**31[ */
70176 }
70177 }
70178
70179 return x;
70180}

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 70116 of file duktape-1.5.2/src/duktape.c.

70116 {
70117 return 0.0;
70118 } else if (c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
70119 /* XXX: FP_ZERO check can be removed, the else clause handles it
70120 * correctly (preserving sign).

◆ duk_js_tointeger_number()

DUK_INTERNAL_DECL duk_double_t duk_js_tointeger_number ( duk_double_t x)

Definition at line 70096 of file duktape-1.5.2/src/duktape.c.

70097 : {
70098 /* number */
70101 return DUK_TVAL_GET_DOUBLE(tv);
70102 }
70103 }
70104
70106}
70107
70108/*
70109 * ToInteger() (E5 Section 9.4)
70110 */
70111
70112/* exposed, used by e.g. duk_bi_date.c */

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 70013 of file duktape-1.5.2/src/duktape.c.

70030 {
70031 duk_context *ctx = (duk_hthread *) thr;
70032
70033 DUK_ASSERT(thr != NULL);
70034 DUK_ASSERT(tv != NULL);
70035
70036 switch (DUK_TVAL_GET_TAG(tv)) {
70037 case DUK_TAG_UNDEFINED: {
70038 /* return a specific NaN (although not strictly necessary) */
70042 return du.d;
70043 }
70044 case DUK_TAG_NULL: {
70045 /* +0.0 */
70046 return 0.0;
70047 }
70048 case DUK_TAG_BOOLEAN: {
70049 if (DUK_TVAL_IS_BOOLEAN_TRUE(tv)) {
70050 return 1.0;
70051 }
70052 return 0.0;
70053 }
70054 case DUK_TAG_STRING: {
70056 duk_push_hstring(ctx, h);
70057 return duk__tonumber_string_raw(thr);
70058 }
70059 case DUK_TAG_OBJECT: {
70060 /* Note: ToPrimitive(object,hint) == [[DefaultValue]](object,hint),
70061 * so use [[DefaultValue]] directly.
70062 */
70063 duk_double_t d;
70064 duk_push_tval(ctx, tv);
70065 duk_to_defaultvalue(ctx, -1, DUK_HINT_NUMBER); /* 'tv' becomes invalid */
70066
70067 /* recursive call for a primitive value (guaranteed not to cause second
70068 * recursion).
70069 */
70070 d = duk_js_tonumber(thr, duk_require_tval(ctx, -1));
70071
70072 duk_pop(ctx);
70073 return d;
70074 }
70075 case DUK_TAG_BUFFER: {
70076 /* Coerce like a string. This makes sense because addition also treats
70077 * buffers like strings.
70078 */
70080 duk_push_hbuffer(ctx, h);
70081 duk_to_string(ctx, -1); /* XXX: expensive, but numconv now expects to see a string */
70082 return duk__tonumber_string_raw(thr);
70083 }
70084 case DUK_TAG_POINTER: {
70085 /* Coerce like boolean */
70086 void *p = DUK_TVAL_GET_POINTER(tv);
70087 return (p != NULL ? 1.0 : 0.0);
70088 }
70089 case DUK_TAG_LIGHTFUNC: {
#define DUK_DBLUNION_SET_NAN(u)
DUK_LOCAL duk_double_t duk__tonumber_string_raw(duk_hthread *thr)
#define DUK_TVAL_IS_BOOLEAN_TRUE(tv)
DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint)

◆ duk_js_touint16()

DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16 ( duk_hthread * thr,
duk_tval * tv )

Definition at line 70201 of file duktape-1.5.2/src/duktape.c.

70204 {

◆ duk_js_touint32()

DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32 ( duk_hthread * thr,
duk_tval * tv )

Definition at line 70183 of file duktape-1.5.2/src/duktape.c.

70186 {
70187 return DUK_TVAL_GET_FASTINT_I32(tv);
70188 }
70189#endif
70190
70191 d = duk_js_tonumber(thr, tv); /* invalidates tv */
70194 DUK_ASSERT(d >= -2147483648.0 && d <= 2147483647.0); /* [-0x80000000,0x7fffffff] */
70195 DUK_ASSERT(d == ((duk_double_t) ((duk_int32_t) d))); /* whole, won't clip */
70196 return (duk_int32_t) d;
70197}
70198
70199

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 71082 of file duktape-1.5.2/src/duktape.c.

71099 {
71100 duk_small_int_t stridx = 0;
71101
71102 DUK_UNREF(thr);
71103
71104 switch (DUK_TVAL_GET_TAG(tv_x)) {
71105 case DUK_TAG_UNDEFINED: {
71106 stridx = DUK_STRIDX_LC_UNDEFINED;
71107 break;
71108 }
71109 case DUK_TAG_NULL: {
71110 /* Note: not a typo, "object" is returned for a null value */
71111 stridx = DUK_STRIDX_LC_OBJECT;
71112 break;
71113 }
71114 case DUK_TAG_BOOLEAN: {
71115 stridx = DUK_STRIDX_LC_BOOLEAN;
71116 break;
71117 }
71118 case DUK_TAG_POINTER: {
71119 /* implementation specific */
71120 stridx = DUK_STRIDX_LC_POINTER;
71121 break;
71122 }
71123 case DUK_TAG_STRING: {
71124 stridx = DUK_STRIDX_LC_STRING;
71125 break;
71126 }
71127 case DUK_TAG_OBJECT: {
71128 duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_x);
71129 DUK_ASSERT(obj != NULL);
71130 if (DUK_HOBJECT_IS_CALLABLE(obj)) {
71131 stridx = DUK_STRIDX_LC_FUNCTION;
71132 } else {
71133 stridx = DUK_STRIDX_LC_OBJECT;
71134 }
71135 break;
71136 }
71137 case DUK_TAG_BUFFER: {
71138 /* implementation specific */
71139 stridx = DUK_STRIDX_LC_BUFFER;
71140 break;
71141 }
71142 case DUK_TAG_LIGHTFUNC: {
71143 stridx = DUK_STRIDX_LC_FUNCTION;
#define DUK_STRIDX_LC_POINTER
#define DUK_STRIDX_LC_FUNCTION
#define DUK_STRIDX_LC_BOOLEAN
#define DUK_STRIDX_LC_STRING
#define DUK_STRIDX_LC_OBJECT

◆ duk_json_decode()

DUK_EXTERNAL void duk_json_decode ( duk_context * ctx,
duk_idx_t index )

Definition at line 13547 of file duktape-1.5.2/src/duktape.c.

13564 {
13565#ifdef DUK_USE_ASSERTIONS

◆ duk_json_encode()

DUK_EXTERNAL const char * duk_json_encode ( duk_context * ctx,
duk_idx_t index )

Definition at line 13521 of file duktape-1.5.2/src/duktape.c.

13524 {
13525 goto type_error;
13526 }
13527 buf[i >> 1] = (duk_uint8_t) t;
13528 }
13529#endif /* DUK_USE_HEX_FASTPATH */
13530
13531 duk_replace(ctx, index);
13532 return;
13533
13534 type_error:
13536}
13537
13539#ifdef DUK_USE_ASSERTIONS
13540 duk_idx_t top_at_entry;
13541#endif
13542 const char *ret;
13543
13545#ifdef DUK_USE_ASSERTIONS
DUK_EXTERNAL const char * duk_json_encode(duk_context *ctx, duk_idx_t index)

◆ duk_lexer_initctx()

DUK_INTERNAL_DECL void duk_lexer_initctx ( duk_lexer_ctx * lex_ctx)

Definition at line 73594 of file duktape-1.5.2/src/duktape.c.

73598 {
73599 duk_context *ctx = (duk_context *) lex_ctx->thr;
73600
73601 DUK_ASSERT(valstack_idx == lex_ctx->slot1_idx || valstack_idx == lex_ctx->slot2_idx);
73602
73603 DUK_BW_PUSH_AS_STRING(lex_ctx->thr, &lex_ctx->bw);
73604 duk_replace(ctx, valstack_idx);
73605}
73606
#define DUK_BW_PUSH_AS_STRING(thr, bw_ctx)

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 73732 of file duktape-1.5.2/src/duktape.c.

73752 {
73753 duk_codepoint_t x; /* temporary, must be signed and 32-bit to hold Unicode code points */
73754 duk_small_uint_t advtok = 0; /* (advance << 8) + token_type, updated at function end,
73755 * init is unnecessary but suppresses "may be used uninitialized" warnings.
73756 */
73757 duk_bool_t got_lineterm = 0; /* got lineterm preceding non-whitespace, non-lineterm token */
73758
73759 if (++lex_ctx->token_count >= lex_ctx->token_limit) {
73760 DUK_ERROR_RANGE(lex_ctx->thr, "token limit");
73761 return; /* unreachable */
73762 }
73763
73764 out_token->t = DUK_TOK_EOF;
73765 out_token->t_nores = -1; /* marker: copy t if not changed */
73766#if 0 /* not necessary to init, disabled for faster parsing */
73767 out_token->num = DUK_DOUBLE_NAN;
73768 out_token->str1 = NULL;
73769 out_token->str2 = NULL;
73770#endif
73771 out_token->num_escapes = 0;
73772 /* out_token->lineterm set by caller */
73773
73774 /* This would be nice, but parsing is faster without resetting the
73775 * value slots. The only side effect is that references to temporary
73776 * string values may linger until lexing is finished; they're then
73777 * freed normally.
73778 */
73779#if 0
73780 duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
73781 duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx);
73782#endif
73783
73784 /* 'advtok' indicates how much to advance and which token id to assign
73785 * at the end. This shared functionality minimizes code size. All
73786 * code paths are required to set 'advtok' to some value, so no default
73787 * init value is used. Code paths calling DUK_ERROR() never return so
73788 * they don't need to set advtok.
73789 */
73790
73791 /*
73792 * Matching order:
73793 *
73794 * Punctuator first chars, also covers comments, regexps
73795 * LineTerminator
73796 * Identifier or reserved word, also covers null/true/false literals
73797 * NumericLiteral
73798 * StringLiteral
73799 * EOF
73800 *
73801 * The order does not matter as long as the longest match is
73802 * always correctly identified. There are order dependencies
73803 * in the clauses, so it's not trivial to convert to a switch.
73804 */
73805
73806 restart_lineupdate:
73807 out_token->start_line = lex_ctx->window[0].line;
73808
73809 restart:
73810 out_token->start_offset = lex_ctx->window[0].offset;
73811
73812 x = DUK__L0();
73813
73814 switch (x) {
73815 case DUK_ASC_SPACE:
73816 case DUK_ASC_HT: /* fast paths for space and tab */
73817 DUK__ADVANCECHARS(lex_ctx, 1);
73818 goto restart;
73819 case DUK_ASC_LF: /* LF line terminator; CR LF and Unicode lineterms are handled in slow path */
73820 DUK__ADVANCECHARS(lex_ctx, 1);
73821 got_lineterm = 1;
73822 goto restart_lineupdate;
73823 case DUK_ASC_SLASH: /* '/' */
73824 if (DUK__L1() == '/') {
73825 /*
73826 * E5 Section 7.4, allow SourceCharacter (which is any 16-bit
73827 * code point).
73828 */
73829
73830 /* DUK__ADVANCECHARS(lex_ctx, 2) would be correct here, but it unnecessary */
73831 for (;;) {
73832 x = DUK__L0();
73833 if (x < 0 || duk_unicode_is_line_terminator(x)) {
73834 break;
73835 }
73836 DUK__ADVANCECHARS(lex_ctx, 1);
73837 }
73838 goto restart; /* line terminator will be handled on next round */
73839 } else if (DUK__L1() == '*') {
73840 /*
73841 * E5 Section 7.4. If the multi-line comment contains a newline,
73842 * it is treated like a single line terminator for automatic
73843 * semicolon insertion.
73844 */
73845
73846 duk_bool_t last_asterisk = 0;
73847 DUK__ADVANCECHARS(lex_ctx, 2);
73848 for (;;) {
73849 x = DUK__L0();
73850 if (x < 0) {
73851 DUK_ERROR_SYNTAX(lex_ctx->thr, "eof in multiline comment");
73852 }
73853 DUK__ADVANCECHARS(lex_ctx, 1);
73854 if (last_asterisk && x == '/') {
73855 break;
73856 }
73858 got_lineterm = 1;
73859 }
73860 last_asterisk = (x == '*');
73861 }
73862 goto restart_lineupdate;
73863 } else if (regexp_mode) {
73864#if defined(DUK_USE_REGEXP_SUPPORT)
73865 /*
73866 * "/" followed by something in regexp mode. See E5 Section 7.8.5.
73867 *
73868 * RegExp parsing is a bit complex. First, the regexp body is delimited
73869 * by forward slashes, but the body may also contain forward slashes as
73870 * part of an escape sequence or inside a character class (delimited by
73871 * square brackets). A mini state machine is used to implement these.
73872 *
73873 * Further, an early (parse time) error must be thrown if the regexp
73874 * would cause a run-time error when used in the expression new RegExp(...).
73875 * Parsing here simply extracts the (candidate) regexp, and also accepts
73876 * invalid regular expressions (which are delimited properly). The caller
73877 * (compiler) must perform final validation and regexp compilation.
73878 *
73879 * RegExp first char may not be '/' (single line comment) or '*' (multi-
73880 * line comment). These have already been checked above, so there is no
73881 * need below for special handling of the first regexp character as in
73882 * the E5 productions.
73883 *
73884 * About unicode escapes within regexp literals:
73885 *
73886 * E5 Section 7.8.5 grammar does NOT accept \uHHHH escapes.
73887 * However, Section 6 states that regexps accept the escapes,
73888 * see paragraph starting with "In string literals...".
73889 * The regexp grammar, which sees the decoded regexp literal
73890 * (after lexical parsing) DOES have a \uHHHH unicode escape.
73891 * So, for instance:
73892 *
73893 * /\u1234/
73894 *
73895 * should first be parsed by the lexical grammar as:
73896 *
73897 * '\' 'u' RegularExpressionBackslashSequence
73898 * '1' RegularExpressionNonTerminator
73899 * '2' RegularExpressionNonTerminator
73900 * '3' RegularExpressionNonTerminator
73901 * '4' RegularExpressionNonTerminator
73902 *
73903 * and the escape itself is then parsed by the regexp engine.
73904 * This is the current implementation.
73905 *
73906 * Minor spec inconsistency:
73907 *
73908 * E5 Section 7.8.5 RegularExpressionBackslashSequence is:
73909 *
73910 * \ RegularExpressionNonTerminator
73911 *
73912 * while Section A.1 RegularExpressionBackslashSequence is:
73913 *
73914 * \ NonTerminator
73915 *
73916 * The latter is not normative and a typo.
73917 *
73918 */
73919
73920 /* first, parse regexp body roughly */
73921
73922 duk_small_int_t state = 0; /* 0=base, 1=esc, 2=class, 3=class+esc */
73923
73924 DUK__INITBUFFER(lex_ctx);
73925 for (;;) {
73926 DUK__ADVANCECHARS(lex_ctx, 1); /* skip opening slash on first loop */
73927 x = DUK__L0();
73928 if (x < 0 || duk_unicode_is_line_terminator(x)) {
73929 DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in regexp");
73930 }
73931 x = DUK__L0(); /* re-read to avoid spill / fetch */
73932 if (state == 0) {
73933 if (x == '/') {
73934 DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing slash */
73935 break;
73936 } else if (x == '\\') {
73937 state = 1;
73938 } else if (x == '[') {
73939 state = 2;
73940 }
73941 } else if (state == 1) {
73942 state = 0;
73943 } else if (state == 2) {
73944 if (x == ']') {
73945 state = 0;
73946 } else if (x == '\\') {
73947 state = 3;
73948 }
73949 } else { /* state == 3 */
73950 state = 2;
73951 }
73952 DUK__APPENDBUFFER(lex_ctx, x);
73953 }
73954 duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
73955 out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
73956
73957 /* second, parse flags */
73958
73959 DUK__INITBUFFER(lex_ctx);
73960 for (;;) {
73961 x = DUK__L0();
73963 break;
73964 }
73965 x = DUK__L0(); /* re-read to avoid spill / fetch */
73966 DUK__APPENDBUFFER(lex_ctx, x);
73967 DUK__ADVANCECHARS(lex_ctx, 1);
73968 }
73969 duk__internbuffer(lex_ctx, lex_ctx->slot2_idx);
73970 out_token->str2 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx);
73971
73972 DUK__INITBUFFER(lex_ctx); /* free some memory */
73973
73974 /* validation of the regexp is caller's responsibility */
73975
73976 advtok = DUK__ADVTOK(0, DUK_TOK_REGEXP);
73977#else
73978 DUK_ERROR_SYNTAX(lex_ctx->thr, "regexp support disabled");
73979#endif
73980 } else if (DUK__L1() == '=') {
73981 /* "/=" and not in regexp mode */
73982 advtok = DUK__ADVTOK(2, DUK_TOK_DIV_EQ);
73983 } else {
73984 /* "/" and not in regexp mode */
73985 advtok = DUK__ADVTOK(1, DUK_TOK_DIV);
73986 }
73987 break;
73988 case DUK_ASC_LCURLY: /* '{' */
73989 advtok = DUK__ADVTOK(1, DUK_TOK_LCURLY);
73990 break;
73991 case DUK_ASC_RCURLY: /* '}' */
73992 advtok = DUK__ADVTOK(1, DUK_TOK_RCURLY);
73993 break;
73994 case DUK_ASC_LPAREN: /* '(' */
73995 advtok = DUK__ADVTOK(1, DUK_TOK_LPAREN);
73996 break;
73997 case DUK_ASC_RPAREN: /* ')' */
73998 advtok = DUK__ADVTOK(1, DUK_TOK_RPAREN);
73999 break;
74000 case DUK_ASC_LBRACKET: /* '[' */
74001 advtok = DUK__ADVTOK(1, DUK_TOK_LBRACKET);
74002 break;
74003 case DUK_ASC_RBRACKET: /* ']' */
74004 advtok = DUK__ADVTOK(1, DUK_TOK_RBRACKET);
74005 break;
74006 case DUK_ASC_PERIOD: /* '.' */
74007 if (DUK__ISDIGIT(DUK__L1())) {
74008 /* Period followed by a digit can only start DecimalLiteral
74009 * (handled in slow path). We could jump straight into the
74010 * DecimalLiteral handling but should avoid goto to inside
74011 * a block.
74012 */
74013 goto slow_path;
74014 }
74015 advtok = DUK__ADVTOK(1, DUK_TOK_PERIOD);
74016 break;
74017 case DUK_ASC_SEMICOLON: /* ';' */
74018 advtok = DUK__ADVTOK(1, DUK_TOK_SEMICOLON);
74019 break;
74020 case DUK_ASC_COMMA: /* ',' */
74021 advtok = DUK__ADVTOK(1, DUK_TOK_COMMA);
74022 break;
74023 case DUK_ASC_LANGLE: /* '<' */
74024 if (DUK__L1() == '<' && DUK__L2() == '=') {
74025 advtok = DUK__ADVTOK(3, DUK_TOK_ALSHIFT_EQ);
74026 } else if (DUK__L1() == '=') {
74027 advtok = DUK__ADVTOK(2, DUK_TOK_LE);
74028 } else if (DUK__L1() == '<') {
74029 advtok = DUK__ADVTOK(2, DUK_TOK_ALSHIFT);
74030 } else {
74031 advtok = DUK__ADVTOK(1, DUK_TOK_LT);
74032 }
74033 break;
74034 case DUK_ASC_RANGLE: /* '>' */
74035 if (DUK__L1() == '>' && DUK__L2() == '>' && DUK__L3() == '=') {
74036 advtok = DUK__ADVTOK(4, DUK_TOK_RSHIFT_EQ);
74037 } else if (DUK__L1() == '>' && DUK__L2() == '>') {
74038 advtok = DUK__ADVTOK(3, DUK_TOK_RSHIFT);
74039 } else if (DUK__L1() == '>' && DUK__L2() == '=') {
74040 advtok = DUK__ADVTOK(3, DUK_TOK_ARSHIFT_EQ);
74041 } else if (DUK__L1() == '=') {
74042 advtok = DUK__ADVTOK(2, DUK_TOK_GE);
74043 } else if (DUK__L1() == '>') {
74044 advtok = DUK__ADVTOK(2, DUK_TOK_ARSHIFT);
74045 } else {
74046 advtok = DUK__ADVTOK(1, DUK_TOK_GT);
74047 }
74048 break;
74049 case DUK_ASC_EQUALS: /* '=' */
74050 if (DUK__L1() == '=' && DUK__L2() == '=') {
74051 advtok = DUK__ADVTOK(3, DUK_TOK_SEQ);
74052 } else if (DUK__L1() == '=') {
74053 advtok = DUK__ADVTOK(2, DUK_TOK_EQ);
74054 } else {
74055 advtok = DUK__ADVTOK(1, DUK_TOK_EQUALSIGN);
74056 }
74057 break;
74058 case DUK_ASC_EXCLAMATION: /* '!' */
74059 if (DUK__L1() == '=' && DUK__L2() == '=') {
74060 advtok = DUK__ADVTOK(3, DUK_TOK_SNEQ);
74061 } else if (DUK__L1() == '=') {
74062 advtok = DUK__ADVTOK(2, DUK_TOK_NEQ);
74063 } else {
74064 advtok = DUK__ADVTOK(1, DUK_TOK_LNOT);
74065 }
74066 break;
74067 case DUK_ASC_PLUS: /* '+' */
74068 if (DUK__L1() == '+') {
74069 advtok = DUK__ADVTOK(2, DUK_TOK_INCREMENT);
74070 } else if (DUK__L1() == '=') {
74071 advtok = DUK__ADVTOK(2, DUK_TOK_ADD_EQ);
74072 } else {
74073 advtok = DUK__ADVTOK(1, DUK_TOK_ADD);
74074 }
74075 break;
74076 case DUK_ASC_MINUS: /* '-' */
74077 if (DUK__L1() == '-') {
74078 advtok = DUK__ADVTOK(2, DUK_TOK_DECREMENT);
74079 } else if (DUK__L1() == '=') {
74080 advtok = DUK__ADVTOK(2, DUK_TOK_SUB_EQ);
74081 } else {
74082 advtok = DUK__ADVTOK(1, DUK_TOK_SUB);
74083 }
74084 break;
74085 case DUK_ASC_STAR: /* '*' */
74086 if (DUK__L1() == '=') {
74087 advtok = DUK__ADVTOK(2, DUK_TOK_MUL_EQ);
74088 } else {
74089 advtok = DUK__ADVTOK(1, DUK_TOK_MUL);
74090 }
74091 break;
74092 case DUK_ASC_PERCENT: /* '%' */
74093 if (DUK__L1() == '=') {
74094 advtok = DUK__ADVTOK(2, DUK_TOK_MOD_EQ);
74095 } else {
74096 advtok = DUK__ADVTOK(1, DUK_TOK_MOD);
74097 }
74098 break;
74099 case DUK_ASC_AMP: /* '&' */
74100 if (DUK__L1() == '&') {
74101 advtok = DUK__ADVTOK(2, DUK_TOK_LAND);
74102 } else if (DUK__L1() == '=') {
74103 advtok = DUK__ADVTOK(2, DUK_TOK_BAND_EQ);
74104 } else {
74105 advtok = DUK__ADVTOK(1, DUK_TOK_BAND);
74106 }
74107 break;
74108 case DUK_ASC_PIPE: /* '|' */
74109 if (DUK__L1() == '|') {
74110 advtok = DUK__ADVTOK(2, DUK_TOK_LOR);
74111 } else if (DUK__L1() == '=') {
74112 advtok = DUK__ADVTOK(2, DUK_TOK_BOR_EQ);
74113 } else {
74114 advtok = DUK__ADVTOK(1, DUK_TOK_BOR);
74115 }
74116 break;
74117 case DUK_ASC_CARET: /* '^' */
74118 if (DUK__L1() == '=') {
74119 advtok = DUK__ADVTOK(2, DUK_TOK_BXOR_EQ);
74120 } else {
74121 advtok = DUK__ADVTOK(1, DUK_TOK_BXOR);
74122 }
74123 break;
74124 case DUK_ASC_TILDE: /* '~' */
74125 advtok = DUK__ADVTOK(1, DUK_TOK_BNOT);
74126 break;
74127 case DUK_ASC_QUESTION: /* '?' */
74128 advtok = DUK__ADVTOK(1, DUK_TOK_QUESTION);
74129 break;
74130 case DUK_ASC_COLON: /* ':' */
74131 advtok = DUK__ADVTOK(1, DUK_TOK_COLON);
74132 break;
74133 case DUK_ASC_DOUBLEQUOTE: /* '"' */
74134 case DUK_ASC_SINGLEQUOTE: { /* '\'' */
74135 duk_small_int_t quote = x; /* Note: duk_uint8_t type yields larger code */
74136 duk_small_int_t adv;
74137
74138 DUK__INITBUFFER(lex_ctx);
74139 for (;;) {
74140 DUK__ADVANCECHARS(lex_ctx, 1); /* eat opening quote on first loop */
74141 x = DUK__L0();
74142 if (x < 0 || duk_unicode_is_line_terminator(x)) {
74143 DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in string literal");
74144 }
74145 if (x == quote) {
74146 DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing quote */
74147 break;
74148 }
74149 if (x == '\\') {
74150 /* DUK__L0 -> '\' char
74151 * DUK__L1 ... DUK__L5 -> more lookup
74152 */
74153
74154 x = DUK__L1();
74155
74156 /* How much to advance before next loop; note that next loop
74157 * will advance by 1 anyway, so -1 from the total escape
74158 * length (e.g. len('\uXXXX') - 1 = 6 - 1). As a default,
74159 * 1 is good.
74160 */
74161 adv = 2 - 1; /* note: long live range */
74162
74163 if (x < 0) {
74164 DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in string literal");
74165 }
74167 /* line continuation */
74168 if (x == 0x000d && DUK__L2() == 0x000a) {
74169 /* CR LF again a special case */
74170 adv = 3 - 1;
74171 }
74172 } else if (x == '\'') {
74173 DUK__APPENDBUFFER(lex_ctx, 0x0027);
74174 } else if (x == '"') {
74175 DUK__APPENDBUFFER(lex_ctx, 0x0022);
74176 } else if (x == '\\') {
74177 DUK__APPENDBUFFER(lex_ctx, 0x005c);
74178 } else if (x == 'b') {
74179 DUK__APPENDBUFFER(lex_ctx, 0x0008);
74180 } else if (x == 'f') {
74181 DUK__APPENDBUFFER(lex_ctx, 0x000c);
74182 } else if (x == 'n') {
74183 DUK__APPENDBUFFER(lex_ctx, 0x000a);
74184 } else if (x == 'r') {
74185 DUK__APPENDBUFFER(lex_ctx, 0x000d);
74186 } else if (x == 't') {
74187 DUK__APPENDBUFFER(lex_ctx, 0x0009);
74188 } else if (x == 'v') {
74189 DUK__APPENDBUFFER(lex_ctx, 0x000b);
74190 } else if (x == 'x') {
74191 adv = 4 - 1;
74193 } else if (x == 'u') {
74194 adv = 6 - 1;
74196 } else if (DUK__ISDIGIT(x)) {
74197 duk_codepoint_t ch = 0; /* initialized to avoid warnings of unused var */
74198
74199 /*
74200 * Octal escape or zero escape:
74201 * \0 (lookahead not DecimalDigit)
74202 * \1 ... \7 (lookahead not DecimalDigit)
74203 * \ZeroToThree OctalDigit (lookahead not DecimalDigit)
74204 * \FourToSeven OctalDigit (no lookahead restrictions)
74205 * \ZeroToThree OctalDigit OctalDigit (no lookahead restrictions)
74206 *
74207 * Zero escape is part of the standard syntax. Octal escapes are
74208 * defined in E5 Section B.1.2, and are only allowed in non-strict mode.
74209 * Any other productions starting with a decimal digit are invalid.
74210 */
74211
74212 if (x == '0' && !DUK__ISDIGIT(DUK__L2())) {
74213 /* Zero escape (also allowed in non-strict mode) */
74214 ch = 0;
74215 /* adv = 2 - 1 default OK */
74216#if defined(DUK_USE_OCTAL_SUPPORT)
74217 } else if (strict_mode) {
74218 /* No other escape beginning with a digit in strict mode */
74219 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid escape in string literal");
74220 } else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(DUK__L2()) && DUK__ISOCTDIGIT(DUK__L3())) {
74221 /* Three digit octal escape, digits validated. */
74222 adv = 4 - 1;
74223 ch = (duk__hexval(lex_ctx, x) << 6) +
74224 (duk__hexval(lex_ctx, DUK__L2()) << 3) +
74225 duk__hexval(lex_ctx, DUK__L3());
74226 } else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) &&
74228 /* Two digit octal escape, digits validated.
74229 *
74230 * The if-condition is a bit tricky. We could catch e.g.
74231 * '\039' in the three-digit escape and fail it there (by
74232 * validating the digits), but we want to avoid extra
74233 * additional validation code.
74234 */
74235 adv = 3 - 1;
74236 ch = (duk__hexval(lex_ctx, x) << 3) +
74237 duk__hexval(lex_ctx, DUK__L2());
74238 } else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(DUK__L2())) {
74239 /* One digit octal escape, digit validated. */
74240 /* adv = 2 default OK */
74241 ch = duk__hexval(lex_ctx, x);
74242#else
74243 /* fall through to error */
74244#endif
74245 } else {
74246 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid escape in string literal");
74247 }
74248
74249 DUK__APPENDBUFFER(lex_ctx, ch);
74250 } else {
74251 /* escaped NonEscapeCharacter */
74252 DUK__APPENDBUFFER(lex_ctx, x);
74253 }
74254 DUK__ADVANCECHARS(lex_ctx, adv);
74255
74256 /* Track number of escapes; count not really needed but directive
74257 * prologues need to detect whether there were any escapes or line
74258 * continuations or not.
74259 */
74260 out_token->num_escapes++;
74261 } else {
74262 /* part of string */
74263 DUK__APPENDBUFFER(lex_ctx, x);
74264 }
74265 }
74266
74267 duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
74268 out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
74269
74270 DUK__INITBUFFER(lex_ctx); /* free some memory */
74271
74272 advtok = DUK__ADVTOK(0, DUK_TOK_STRING);
74273 break;
74274 }
74275 default:
74276 goto slow_path;
74277 } /* switch */
74278
74279 goto skip_slow_path;
74280
74281 slow_path:
74283 if (x == 0x000d && DUK__L1() == 0x000a) {
74284 /*
74285 * E5 Section 7.3: CR LF is detected as a single line terminator for
74286 * line numbers. Here we also detect it as a single line terminator
74287 * token.
74288 */
74289 DUK__ADVANCECHARS(lex_ctx, 2);
74290 } else {
74291 DUK__ADVANCECHARS(lex_ctx, 1);
74292 }
74293 got_lineterm = 1;
74294 goto restart_lineupdate;
74295 } else if (duk_unicode_is_identifier_start(x) || x == '\\') {
74296 /*
74297 * Parse an identifier and then check whether it is:
74298 * - reserved word (keyword or other reserved word)
74299 * - "null" (NullLiteral)
74300 * - "true" (BooleanLiteral)
74301 * - "false" (BooleanLiteral)
74302 * - anything else => identifier
74303 *
74304 * This does not follow the E5 productions cleanly, but is
74305 * useful and compact.
74306 *
74307 * Note that identifiers may contain Unicode escapes,
74308 * see E5 Sections 6 and 7.6. They must be decoded first,
74309 * and the result checked against allowed characters.
74310 * The above if-clause accepts an identifier start and an
74311 * '\' character -- no other token can begin with a '\'.
74312 *
74313 * Note that "get" and "set" are not reserved words in E5
74314 * specification so they are recognized as plain identifiers
74315 * (the tokens DUK_TOK_GET and DUK_TOK_SET are actually not
74316 * used now). The compiler needs to work around this.
74317 *
74318 * Strictly speaking, following Ecmascript longest match
74319 * specification, an invalid escape for the first character
74320 * should cause a syntax error. However, an invalid escape
74321 * for IdentifierParts should just terminate the identifier
74322 * early (longest match), and let the next tokenization
74323 * fail. For instance Rhino croaks with 'foo\z' when
74324 * parsing the identifier. This has little practical impact.
74325 */
74326
74327 duk_small_int_t i, i_end;
74328 duk_bool_t first = 1;
74329 duk_hstring *str;
74330
74331 DUK__INITBUFFER(lex_ctx);
74332 for (;;) {
74333 /* re-lookup first char on first loop */
74334 if (DUK__L0() == '\\') {
74335 duk_codepoint_t ch;
74336 if (DUK__L1() != 'u') {
74337 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid unicode escape in identifier");
74338 }
74339
74340 ch = duk__decode_uniesc_from_window(lex_ctx, 2);
74341
74342 /* IdentifierStart is stricter than IdentifierPart, so if the first
74343 * character is escaped, must have a stricter check here.
74344 */
74346 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid unicode escape in identifier");
74347 }
74348 DUK__APPENDBUFFER(lex_ctx, ch);
74349 DUK__ADVANCECHARS(lex_ctx, 6);
74350
74351 /* Track number of escapes: necessary for proper keyword
74352 * detection.
74353 */
74354 out_token->num_escapes++;
74355 } else {
74356 /* Note: first character is checked against this. But because
74357 * IdentifierPart includes all IdentifierStart characters, and
74358 * the first character (if unescaped) has already been checked
74359 * in the if condition, this is OK.
74360 */
74362 break;
74363 }
74364 DUK__APPENDBUFFER(lex_ctx, DUK__L0());
74365 DUK__ADVANCECHARS(lex_ctx, 1);
74366 }
74367 first = 0;
74368 }
74369
74370 duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
74371 out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
74372 str = out_token->str1;
74373 DUK_ASSERT(str != NULL);
74374 out_token->t_nores = DUK_TOK_IDENTIFIER;
74375
74376 DUK__INITBUFFER(lex_ctx); /* free some memory */
74377
74378 /*
74379 * Interned identifier is compared against reserved words, which are
74380 * currently interned into the heap context. See genbuiltins.py.
74381 *
74382 * Note that an escape in the identifier disables recognition of
74383 * keywords; e.g. "\u0069f = 1;" is a valid statement (assigns to
74384 * identifier named "if"). This is not necessarily compliant,
74385 * see test-dec-escaped-char-in-keyword.js.
74386 *
74387 * Note: "get" and "set" are awkward. They are not officially
74388 * ReservedWords (and indeed e.g. "var set = 1;" is valid), and
74389 * must come out as DUK_TOK_IDENTIFIER. The compiler needs to
74390 * work around this a bit.
74391 */
74392
74393 /* XXX: optimize by adding the token numbers directly into the
74394 * always interned duk_hstring objects (there should be enough
74395 * flag bits free for that)?
74396 */
74397
74399
74400 advtok = DUK__ADVTOK(0, DUK_TOK_IDENTIFIER);
74401 if (out_token->num_escapes == 0) {
74402 for (i = DUK_STRIDX_START_RESERVED; i < i_end; i++) {
74403 DUK_ASSERT(i >= 0 && i < DUK_HEAP_NUM_STRINGS);
74404 if (DUK_HTHREAD_GET_STRING(lex_ctx->thr, i) == str) {
74405 advtok = DUK__ADVTOK(0, DUK_STRIDX_TO_TOK(i));
74406 break;
74407 }
74408 }
74409 }
74410 } else if (DUK__ISDIGIT(x) || (x == '.')) {
74411 /* Note: decimal number may start with a period, but must be followed by a digit */
74412
74413 /*
74414 * DecimalLiteral, HexIntegerLiteral, OctalIntegerLiteral
74415 * "pre-parsing", followed by an actual, accurate parser step.
74416 *
74417 * Note: the leading sign character ('+' or '-') is -not- part of
74418 * the production in E5 grammar, and that the a DecimalLiteral
74419 * starting with a '0' must be followed by a non-digit. Leading
74420 * zeroes are syntax errors and must be checked for.
74421 *
74422 * XXX: the two step parsing process is quite awkward, it would
74423 * be more straightforward to allow numconv to parse the longest
74424 * valid prefix (it already does that, it only needs to indicate
74425 * where the input ended). However, the lexer decodes characters
74426 * using a lookup window, so this is not a trivial change.
74427 */
74428
74429 /* XXX: because of the final check below (that the literal is not
74430 * followed by a digit), this could maybe be simplified, if we bail
74431 * out early from a leading zero (and if there are no periods etc).
74432 * Maybe too complex.
74433 */
74434
74435 duk_double_t val;
74436 duk_bool_t int_only = 0;
74437 duk_bool_t allow_hex = 0;
74438 duk_small_int_t state; /* 0=before period/exp,
74439 * 1=after period, before exp
74440 * 2=after exp, allow '+' or '-'
74441 * 3=after exp and exp sign
74442 */
74443 duk_small_uint_t s2n_flags;
74445
74446 DUK__INITBUFFER(lex_ctx);
74447 y = DUK__L1();
74448 if (x == '0' && (y == 'x' || y == 'X')) {
74449 DUK__APPENDBUFFER(lex_ctx, x);
74450 DUK__APPENDBUFFER(lex_ctx, y);
74451 DUK__ADVANCECHARS(lex_ctx, 2);
74452 int_only = 1;
74453 allow_hex = 1;
74454#if defined(DUK_USE_OCTAL_SUPPORT)
74455 } else if (!strict_mode && x == '0' && DUK__ISDIGIT(y)) {
74456 /* Note: if DecimalLiteral starts with a '0', it can only be
74457 * followed by a period or an exponent indicator which starts
74458 * with 'e' or 'E'. Hence the if-check above ensures that
74459 * OctalIntegerLiteral is the only valid NumericLiteral
74460 * alternative at this point (even if y is, say, '9').
74461 */
74462
74463 DUK__APPENDBUFFER(lex_ctx, x);
74464 DUK__ADVANCECHARS(lex_ctx, 1);
74465 int_only = 1;
74466#endif
74467 }
74468
74469 state = 0;
74470 for (;;) {
74471 x = DUK__L0(); /* re-lookup curr char on first round */
74472 if (DUK__ISDIGIT(x)) {
74473 /* Note: intentionally allow leading zeroes here, as the
74474 * actual parser will check for them.
74475 */
74476 if (state == 2) {
74477 state = 3;
74478 }
74479 } else if (allow_hex && DUK__ISHEXDIGIT(x)) {
74480 /* Note: 'e' and 'E' are also accepted here. */
74481 ;
74482 } else if (x == '.') {
74483 if (state >= 1 || int_only) {
74484 break;
74485 } else {
74486 state = 1;
74487 }
74488 } else if (x == 'e' || x == 'E') {
74489 if (state >= 2 || int_only) {
74490 break;
74491 } else {
74492 state = 2;
74493 }
74494 } else if (x == '-' || x == '+') {
74495 if (state != 2) {
74496 break;
74497 } else {
74498 state = 3;
74499 }
74500 } else {
74501 break;
74502 }
74503 DUK__APPENDBUFFER(lex_ctx, x);
74504 DUK__ADVANCECHARS(lex_ctx, 1);
74505 }
74506
74507 /* XXX: better coercion */
74508 duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
74509
74510 s2n_flags = DUK_S2N_FLAG_ALLOW_EXP |
74514#if defined(DUK_USE_OCTAL_SUPPORT)
74515 (strict_mode ? 0 : DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) |
74516#endif
74518
74519 duk_dup((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
74520 duk_numconv_parse((duk_context *) lex_ctx->thr, 10 /*radix*/, s2n_flags);
74521 val = duk_to_number((duk_context *) lex_ctx->thr, -1);
74522 if (DUK_ISNAN(val)) {
74523 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid numeric literal");
74524 }
74525 duk_replace((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); /* could also just pop? */
74526
74527 DUK__INITBUFFER(lex_ctx); /* free some memory */
74528
74529 /* Section 7.8.3 (note): NumericLiteral must be followed by something other than
74530 * IdentifierStart or DecimalDigit.
74531 */
74532
74534 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid numeric literal");
74535 }
74536
74537 out_token->num = val;
74538 advtok = DUK__ADVTOK(0, DUK_TOK_NUMBER);
74539 } else if (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) {
74540 DUK__ADVANCECHARS(lex_ctx, 1);
74541 goto restart;
74542 } else if (x < 0) {
74543 advtok = DUK__ADVTOK(0, DUK_TOK_EOF);
74544 } else {
74545 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid token");
74546 }
74547 skip_slow_path:
74548
74549 /*
74550 * Shared exit path
74551 */
74552
#define DUK__ISHEXDIGIT(x)
#define DUK__ISDIGIT(x)
#define DUK_ASC_LPAREN
#define DUK_S2N_FLAG_ALLOW_FRAC
#define DUK_ASC_EXCLAMATION
#define DUK__ADVTOK(advbytes, tok)
DUK_LOCAL duk_codepoint_t duk__hexval(duk_lexer_ctx *lex_ctx, duk_codepoint_t x)
#define DUK_ASC_RANGLE
#define DUK__L3()
#define DUK__INITBUFFER(lex_ctx)
#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC
#define DUK__ISOCTDIGIT(x)
#define DUK__L0()
#define DUK__ADVANCECHARS(lex_ctx, count)
#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC
#define DUK_ASC_SEMICOLON
#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT
#define DUK_ASC_LANGLE
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_identifier_part(duk_codepoint_t cp)
DUK_LOCAL void duk__internbuffer(duk_lexer_ctx *lex_ctx, duk_idx_t valstack_idx)
#define DUK__L2()
#define DUK_ASC_STAR
#define DUK__L1()
#define DUK__ISDIGIT03(x)
#define DUK_ASC_HT
#define DUK__ISDIGIT47(x)
#define DUK_ASC_EQUALS
DUK_LOCAL duk_codepoint_t duk__decode_uniesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset)
#define DUK_STRIDX_TO_TOK(x)
#define DUK__LOOKUP(lex_ctx, index)
#define DUK_ASC_TILDE
DUK_LOCAL duk_codepoint_t duk__decode_hexesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset)
#define DUK_ASC_CARET
#define DUK_S2N_FLAG_ALLOW_EXP
#define DUK__APPENDBUFFER(lex_ctx, x)

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 74916 of file duktape-1.5.2/src/duktape.c.

74920 {
74921 const duk_uint16_t *ranges_end;
74922
74923 DUK_UNREF(lex_ctx);
74924
74925 ranges_end = ranges + num;
74926 while (ranges < ranges_end) {
74927 /* mark range 'direct', bypass canonicalization (see Wiki) */
74928 gen_range(userdata, (duk_codepoint_t) ranges[0], (duk_codepoint_t) ranges[1], 1);
74929 ranges += 2;
74930 }
74931}
74932
74933DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata) {
74934 duk_codepoint_t start = -1;
74935 duk_codepoint_t ch;
74937 duk_bool_t dash = 0;
74938
74939 DUK_DD(DUK_DDPRINT("parsing regexp ranges"));
74940
74941 for (;;) {
74942 x = DUK__L0();
74943 DUK__ADVANCECHARS(lex_ctx, 1);
74944
74945 ch = -1; /* not strictly necessary, but avoids "uninitialized variable" warnings */
74946 DUK_UNREF(ch);
74947
74948 if (x < 0) {
74949 DUK_ERROR_SYNTAX(lex_ctx->thr, "eof in character class");
74950 } else if (x == ']') {
74951 DUK_ASSERT(!dash); /* lookup should prevent this */
74952 if (start >= 0) {
74953 gen_range(userdata, start, start, 0);
74954 }
74955 break;
74956 } else if (x == '-') {
74957 if (start >= 0 && !dash && DUK__L0() != ']') {
74958 /* '-' as a range indicator */
74959 dash = 1;
74960 continue;
74961 } else {
74962 /* '-' verbatim */
74963 ch = x;
74964 }
74965 } else if (x == '\\') {
74966 /*
74967 * The escapes are same as outside a character class, except that \b has a
74968 * different meaning, and \B and backreferences are prohibited (see E5
74969 * Section 15.10.2.19). However, it's difficult to share code because we
74970 * handle e.g. "\n" very differently: here we generate a single character
74971 * range for it.
74972 */
74973
74974 x = DUK__L0();
74975 DUK__ADVANCECHARS(lex_ctx, 1);
74976
74977 if (x == 'b') {
74978 /* Note: '\b' in char class is different than outside (assertion),
74979 * '\B' is not allowed and is caught by the duk_unicode_is_identifier_part()
74980 * check below.
74981 */
74982 ch = 0x0008;
74983 } else if (x == 'f') {
74984 ch = 0x000c;
74985 } else if (x == 'n') {
74986 ch = 0x000a;
74987 } else if (x == 't') {
74988 ch = 0x0009;
74989 } else if (x == 'r') {
74990 ch = 0x000d;
74991 } else if (x == 'v') {
74992 ch = 0x000b;
74993 } else if (x == 'c') {
74994 x = DUK__L0();
74995 DUK__ADVANCECHARS(lex_ctx, 1);
74996 if ((x >= 'a' && x <= 'z') ||
74997 (x >= 'A' && x <= 'Z')) {
74998 ch = (x % 32);
74999 } else {
75000 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
75001 return; /* never reached, but avoids warnings of
75002 * potentially unused variables.
75003 */
75004 }
75005 } else if (x == 'x') {
75006 ch = duk__decode_hexesc_from_window(lex_ctx, 0);
75007 DUK__ADVANCECHARS(lex_ctx, 2);
75008 } else if (x == 'u') {
75009 ch = duk__decode_uniesc_from_window(lex_ctx, 0);
75010 DUK__ADVANCECHARS(lex_ctx, 4);
75011 } else if (x == 'd') {
75013 gen_range,
75014 userdata,
75016 sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t));
75017 ch = -1;
75018 } else if (x == 'D') {
75020 gen_range,
75021 userdata,
75023 sizeof(duk_unicode_re_ranges_not_digit) / sizeof(duk_uint16_t));
75024 ch = -1;
75025 } else if (x == 's') {
75027 gen_range,
75028 userdata,
75030 sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t));
75031 ch = -1;
75032 } else if (x == 'S') {
75034 gen_range,
75035 userdata,
75037 sizeof(duk_unicode_re_ranges_not_white) / sizeof(duk_uint16_t));
75038 ch = -1;
75039 } else if (x == 'w') {
75041 gen_range,
75042 userdata,
75044 sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t));
75045 ch = -1;
75046 } else if (x == 'W') {
75048 gen_range,
75049 userdata,
75051 sizeof(duk_unicode_re_ranges_not_wordchar) / sizeof(duk_uint16_t));
75052 ch = -1;
75053 } else if (DUK__ISDIGIT(x)) {
75054 /* DecimalEscape, only \0 is allowed, no leading zeroes are allowed */
75055 if (x == '0' && !DUK__ISDIGIT(DUK__L0())) {
75056 ch = 0x0000;
75057 } else {
75058 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
75059 }
75060 } else if (!duk_unicode_is_identifier_part(x)
75062 || x == '$'
75063#endif
75064 ) {
75065 /* IdentityEscape */
75066 ch = x;
75067 } else {
75068 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
75069 }
75070 } else {
75071 /* character represents itself */
75072 ch = x;
75073 }
75074
75075 /* ch is a literal character here or -1 if parsed entity was
75076 * an escape such as "\s".
75077 */
75078
75079 if (ch < 0) {
75080 /* multi-character sets not allowed as part of ranges, see
75081 * E5 Section 15.10.2.15, abstract operation CharacterRange.
75082 */
75083 if (start >= 0) {
75084 if (dash) {
75085 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid range");
75086 } else {
75087 gen_range(userdata, start, start, 0);
75088 start = -1;
75089 /* dash is already 0 */
75090 }
75091 }
75092 } else {
75093 if (start >= 0) {
75094 if (dash) {
75095 if (start > ch) {
75096 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid range");
#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_white[24]
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_digit[4]
DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_not_wordchar[10]
void(* duk_re_range_callback)(void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct)
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)

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 74565 of file duktape-1.5.2/src/duktape.c.

74566 {
74567 out_token->allow_auto_semi = 0;
74568 }
74569}
74570
74571#if defined(DUK_USE_REGEXP_SUPPORT)
74572
74573/*
74574 * Parse a RegExp token. The grammar is described in E5 Section 15.10.
74575 * Terminal constructions (such as quantifiers) are parsed directly here.
74576 *
74577 * 0xffffffffU is used as a marker for "infinity" in quantifiers. Further,
74578 * DUK__MAX_RE_QUANT_DIGITS limits the maximum number of digits that
74579 * will be accepted for a quantifier.
74580 */
74581
74583 duk_small_int_t advtok = 0; /* init is unnecessary but suppresses "may be used uninitialized" warnings */
74584 duk_codepoint_t x, y;
74585
74586 if (++lex_ctx->token_count >= lex_ctx->token_limit) {
74587 DUK_ERROR_RANGE(lex_ctx->thr, "token limit");
74588 return; /* unreachable */
74589 }
74590
74591 DUK_MEMZERO(out_token, sizeof(*out_token));
74592
74593 x = DUK__L0();
74594 y = DUK__L1();
74595
74596 DUK_DDD(DUK_DDDPRINT("parsing regexp token, L0=%ld, L1=%ld", (long) x, (long) y));
74597
74598 switch (x) {
74599 case '|': {
74601 break;
74602 }
74603 case '^': {
74605 break;
74606 }
74607 case '$': {
74608 advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_END);
74609 break;
74610 }
74611 case '?': {
74612 out_token->qmin = 0;
74613 out_token->qmax = 1;
74614 if (y == '?') {
74615 advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
74616 out_token->greedy = 0;
74617 } else {
74618 advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
74619 out_token->greedy = 1;
74620 }
74621 break;
74622 }
74623 case '*': {
74624 out_token->qmin = 0;
74625 out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
74626 if (y == '?') {
74627 advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
74628 out_token->greedy = 0;
74629 } else {
74630 advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
74631 out_token->greedy = 1;
74632 }
74633 break;
74634 }
74635 case '+': {
74636 out_token->qmin = 1;
74637 out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
74638 if (y == '?') {
74639 advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
74640 out_token->greedy = 0;
74641 } else {
74642 advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
74643 out_token->greedy = 1;
74644 }
74645 break;
74646 }
74647 case '{': {
74648 /* Production allows 'DecimalDigits', including leading zeroes */
74649 duk_uint_fast32_t val1 = 0;
74651 duk_small_int_t digits = 0;
74652#if defined(DUK_USE_ES6_REGEXP_BRACES)
74653 duk_lexer_point lex_pt;
74654#endif
74655
74656#if defined(DUK_USE_ES6_REGEXP_BRACES)
74657 /* Store lexer position, restoring if quantifier is invalid. */
74658 DUK_LEXER_GETPOINT(lex_ctx, &lex_pt);
74659#endif
74660
74661 for (;;) {
74662 DUK__ADVANCECHARS(lex_ctx, 1); /* eat '{' on entry */
74663 x = DUK__L0();
74664 if (DUK__ISDIGIT(x)) {
74665 digits++;
74666 val1 = val1 * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x);
74667 } else if (x == ',') {
74668 if (digits > DUK__MAX_RE_QUANT_DIGITS) {
74669 goto invalid_quantifier;
74670 }
74671 if (val2 != DUK_RE_QUANTIFIER_INFINITE) {
74672 goto invalid_quantifier;
74673 }
74674 if (DUK__L1() == '}') {
74675 /* form: { DecimalDigits , }, val1 = min count */
74676 if (digits == 0) {
74677 goto invalid_quantifier;
74678 }
74679 out_token->qmin = val1;
74680 out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
74681 DUK__ADVANCECHARS(lex_ctx, 2);
74682 break;
74683 }
74684 val2 = val1;
74685 val1 = 0;
74686 digits = 0; /* not strictly necessary because of lookahead '}' above */
74687 } else if (x == '}') {
74688 if (digits > DUK__MAX_RE_QUANT_DIGITS) {
74689 goto invalid_quantifier;
74690 }
74691 if (digits == 0) {
74692 goto invalid_quantifier;
74693 }
74694 if (val2 != DUK_RE_QUANTIFIER_INFINITE) {
74695 /* val2 = min count, val1 = max count */
74696 out_token->qmin = val2;
74697 out_token->qmax = val1;
74698 } else {
74699 /* val1 = count */
74700 out_token->qmin = val1;
74701 out_token->qmax = val1;
74702 }
74703 DUK__ADVANCECHARS(lex_ctx, 1);
74704 break;
74705 } else {
74706 goto invalid_quantifier;
74707 }
74708 }
74709 if (DUK__L0() == '?') {
74710 out_token->greedy = 0;
74711 DUK__ADVANCECHARS(lex_ctx, 1);
74712 } else {
74713 out_token->greedy = 1;
74714 }
74715 advtok = DUK__ADVTOK(0, DUK_RETOK_QUANTIFIER);
74716 break;
74717 invalid_quantifier:
74718#if defined(DUK_USE_ES6_REGEXP_BRACES)
74719 /* Failed to match the quantifier, restore lexer and parse
74720 * opening brace as a literal.
74721 */
74722 DUK_LEXER_SETPOINT(lex_ctx, &lex_pt);
74723 advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_CHAR);
74724 out_token->num = '{';
74725#else
74726 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp quantifier");
74727#endif
74728 break;
74729 }
74730 case '.': {
74732 break;
74733 }
74734 case '\\': {
74735 /* The E5.1 specification does not seem to allow IdentifierPart characters
74736 * to be used as identity escapes. Unfortunately this includes '$', which
74737 * cannot be escaped as '\$'; it needs to be escaped e.g. as '\u0024'.
74738 * Many other implementations (including V8 and Rhino, for instance) do
74739 * accept '\$' as a valid identity escape, which is quite pragmatic.
74740 * See: test-regexp-identity-escape-dollar.js.
74741 */
74742
74743 advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR); /* default: char escape (two chars) */
74744 if (y == 'b') {
74746 } else if (y == 'B') {
74748 } else if (y == 'f') {
74749 out_token->num = 0x000c;
74750 } else if (y == 'n') {
74751 out_token->num = 0x000a;
74752 } else if (y == 't') {
74753 out_token->num = 0x0009;
74754 } else if (y == 'r') {
74755 out_token->num = 0x000d;
74756 } else if (y == 'v') {
74757 out_token->num = 0x000b;
74758 } else if (y == 'c') {
74759 x = DUK__L2();
74760 if ((x >= 'a' && x <= 'z') ||
74761 (x >= 'A' && x <= 'Z')) {
74762 out_token->num = (x % 32);
74763 advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_CHAR);
74764 } else {
74765 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
74766 }
74767 } else if (y == 'x') {
74768 out_token->num = duk__decode_hexesc_from_window(lex_ctx, 2);
74769 advtok = DUK__ADVTOK(4, DUK_RETOK_ATOM_CHAR);
74770 } else if (y == 'u') {
74771 out_token->num = duk__decode_uniesc_from_window(lex_ctx, 2);
74772 advtok = DUK__ADVTOK(6, DUK_RETOK_ATOM_CHAR);
74773 } else if (y == 'd') {
74774 advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_DIGIT);
74775 } else if (y == 'D') {
74777 } else if (y == 's') {
74778 advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WHITE);
74779 } else if (y == 'S') {
74781 } else if (y == 'w') {
74783 } else if (y == 'W') {
74785 } else if (DUK__ISDIGIT(y)) {
74786 /* E5 Section 15.10.2.11 */
74787 if (y == '0') {
74788 if (DUK__ISDIGIT(DUK__L2())) {
74789 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
74790 }
74791 out_token->num = 0x0000;
74792 advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR);
74793 } else {
74794 /* XXX: shared parsing? */
74795 duk_uint_fast32_t val = 0;
74797 for (i = 0; ; i++) {
74798 if (i >= DUK__MAX_RE_DECESC_DIGITS) {
74799 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
74800 }
74801 DUK__ADVANCECHARS(lex_ctx, 1); /* eat backslash on entry */
74802 x = DUK__L0();
74803 if (!DUK__ISDIGIT(x)) {
74804 break;
74805 }
74806 val = val * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x);
74807 }
74808 /* DUK__L0() cannot be a digit, because the loop doesn't terminate if it is */
74810 out_token->num = val;
74811 }
74812 } else if ((y >= 0 && !duk_unicode_is_identifier_part(y)) ||
74814 y == '$' ||
74815#endif
74816 y == DUK_UNICODE_CP_ZWNJ ||
74817 y == DUK_UNICODE_CP_ZWJ) {
74818 /* IdentityEscape, with dollar added as a valid additional
74819 * non-standard escape (see test-regexp-identity-escape-dollar.js).
74820 * Careful not to match end-of-buffer (<0) here.
74821 */
74822 out_token->num = y;
74823 } else {
74824 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape");
74825 }
74826 break;
74827 }
74828 case '(': {
74829 /* XXX: naming is inconsistent: ATOM_END_GROUP ends an ASSERT_START_LOOKAHEAD */
74830
74831 if (y == '?') {
74832 if (DUK__L2() == '=') {
74833 /* (?= */
74835 } else if (DUK__L2() == '!') {
74836 /* (?! */
74838 } else if (DUK__L2() == ':') {
74839 /* (?: */
74841 }
74842 } else {
74843 /* ( */
74845 }
74846 break;
74847 }
74848 case ')': {
74850 break;
74851 }
74852 case '[': {
74853 /*
74854 * To avoid creating a heavy intermediate value for the list of ranges,
74855 * only the start token ('[' or '[^') is parsed here. The regexp
74856 * compiler parses the ranges itself.
74857 */
74859 if (y == '^') {
74861 }
74862 break;
74863 }
74864#if !defined(DUK_USE_ES6_REGEXP_BRACES)
74865 case '}':
74866#endif
74867 case ']': {
74868 /* Although these could be parsed as PatternCharacters unambiguously (here),
74869 * E5 Section 15.10.1 grammar explicitly forbids these as PatternCharacters.
74870 */
74871 DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp character");
74872 break;
74873 }
74874 case -1: {
74875 /* EOF */
74876 advtok = DUK__ADVTOK(0, DUK_TOK_EOF);
#define DUK__MAX_RE_QUANT_DIGITS
#define DUK_UNICODE_CP_ZWNJ
#define DUK_UNICODE_CP_ZWJ
#define DUK__MAX_RE_DECESC_DIGITS

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 73614 of file duktape-1.5.2/src/duktape.c.

◆ duk_load_function()

DUK_EXTERNAL void duk_load_function ( duk_context * ctx)

Definition at line 12314 of file duktape-1.5.2/src/duktape.c.

12326 : %!T", duk_get_tval(ctx, -1)));
12327
12328 duk_remove(ctx, -2); /* [ ... func buf ] -> [ ... buf ] */
12329}
12330
12331DUK_EXTERNAL void duk_load_function(duk_context *ctx) {
12332 duk_hthread *thr;
12333 duk_uint8_t *p_buf, *p, *p_end;
12334 duk_size_t sz;
12335
12336 DUK_ASSERT(ctx != NULL);
12337 thr = (duk_hthread *) ctx;
12338 DUK_UNREF(ctx);
12339
12340 p_buf = (duk_uint8_t *) duk_require_buffer(ctx, -1, &sz);
12341 DUK_ASSERT(p_buf != NULL);
12342
12343 /* The caller is responsible for being sure that bytecode being loaded
12344 * is valid and trusted. Invalid bytecode can cause memory unsafe
12345 * behavior directly during loading or later during bytecode execution
12346 * (instruction validation would be quite complex to implement).
12347 *
12348 * This signature check is the only sanity check for detecting
12349 * accidental invalid inputs. The initial 0xFF byte ensures no
12350 * ordinary string will be accepted by accident.
12351 */
12352 p = p_buf;

◆ duk_log()

DUK_EXTERNAL void duk_log ( duk_context * ctx,
duk_int_t level,
const char * fmt,
... )

Definition at line 14204 of file duktape-1.5.2/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 14171 of file duktape-1.5.2/src/duktape.c.

14188 {
14189 /* stridx_logfunc[] must be static to allow initializer with old compilers like BCC */
14190 static const duk_uint16_t stridx_logfunc[6] = {
14193 };
14194
14196
14197 if (level < 0) {
14198 level = 0;
14199 } else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) {
14200 level = (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1;
14201 }
14202
#define DUK_STRIDX_LC_TRACE
#define DUK_STRIDX_LC_WARN
#define DUK_STRIDX_LC_INFO
#define DUK_STRIDX_LC_DEBUG
#define DUK_STRIDX_LC_ERROR
#define DUK_STRIDX_LC_FATAL

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 19736 of file duktape-1.5.2/src/duktape.c.

19744 {
19745 if (p >= p_end) {
19746 break;
19747 }
19748 cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
19749 callback(udata, cp);
19750 }
19751}
19752
19754 duk_hthread *thr = (duk_hthread *) ctx;
19755 duk_hstring *h_input;
19756 duk_bufwriter_ctx bw_alloc;
19758 const duk_uint8_t *p, *p_start, *p_end;
19759 duk_codepoint_t cp;
19760
19762
19764
19765 h_input = duk_require_hstring(ctx, index);
19766 DUK_ASSERT(h_input != NULL);
19767
19768 bw = &bw_alloc;
19769 DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* reasonable output estimate */
19770
19771 p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
19772 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
19773 p = p_start;
19774
19775 for (;;) {
duk_codepoint_t(* duk_map_char_function)(void *udata, duk_codepoint_t codepoint)
DUK_EXTERNAL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata)

◆ duk_new()

DUK_EXTERNAL void duk_new ( duk_context * ctx,
duk_idx_t nargs )

Definition at line 12596 of file duktape-1.5.2/src/duktape.c.

12599 {
12600 /* See comments in duk_pcall(). */
12602 return DUK_EXEC_ERROR; /* unreachable */
12603 }
12604
12605 rc = duk_handle_safe_call(thr, /* thread */
12606 func, /* func */
12607 nargs, /* num_stack_args */
12608 nrets); /* num_stack_res */
12609
12610 return rc;
12611}
12612
12613DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) {
12614 /*
12615 * There are two [[Construct]] operations in the specification:
12616 *
12617 * - E5 Section 13.2.2: for Function objects
12618 * - E5 Section 15.3.4.5.2: for "bound" Function objects
12619 *
12620 * The chain of bound functions is resolved in Section 15.3.4.5.2,
12621 * with arguments "piling up" until the [[Construct]] internal
12622 * method is called on the final, actual Function object. Note
12623 * that the "prototype" property is looked up *only* from the
12624 * final object, *before* calling the constructor.
12625 *
12626 * Currently we follow the bound function chain here to get the
12627 * "prototype" property value from the final, non-bound function.
12628 * However, we let duk_handle_call() handle the argument "piling"
12629 * when the constructor is called. The bound function chain is
12630 * thus now processed twice.
12631 *
12632 * When constructing new Array instances, an unnecessary object is
12633 * created and discarded now: the standard [[Construct]] creates an
12634 * object, and calls the Array constructor. The Array constructor
12635 * returns an Array instance, which is used as the result value for
12636 * the "new" operation; the object created before the Array constructor
12637 * call is discarded.
12638 *
12639 * This would be easy to fix, e.g. by knowing that the Array constructor
12640 * will always create a replacement object and skip creating the fallback
12641 * object in that case.
12642 *
12643 * Note: functions called via "new" need to know they are called as a
12644 * constructor. For instance, built-in constructors behave differently
12645 * depending on how they are called.
12646 */
12647
12648 /* XXX: merge this with duk_js_call.c, as this function implements
12649 * core semantics (or perhaps merge the two files altogether).
12650 */
12651
12652 duk_hthread *thr = (duk_hthread *) ctx;
12654 duk_hobject *cons;
12655 duk_hobject *fallback;
12656 duk_idx_t idx_cons;
12657 duk_small_uint_t call_flags;
12658
12660
12661 /* [... constructor arg1 ... argN] */
12662
12663 idx_cons = duk_require_normalize_index(ctx, -nargs - 1);
12664
12665 DUK_DDD(DUK_DDDPRINT("top=%ld, nargs=%ld, idx_cons=%ld",
12666 (long) duk_get_top(ctx), (long) nargs, (long) idx_cons));
12667
12668 /* XXX: code duplication */
12669
12670 /*
12671 * Figure out the final, non-bound constructor, to get "prototype"
12672 * property.
12673 */
12674
12675 duk_dup(ctx, idx_cons);
12676 for (;;) {
12677 duk_tval *tv;
12678 tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
12679 DUK_ASSERT(tv != NULL);
12680
12681 if (DUK_TVAL_IS_OBJECT(tv)) {
12682 cons = DUK_TVAL_GET_OBJECT(tv);
12683 DUK_ASSERT(cons != NULL);
12685 /* Checking callability of the immediate target
12686 * is important, same for constructability.
12687 * Checking it for functions down the bound
12688 * function chain is not strictly necessary
12689 * because .bind() should normally reject them.
12690 * But it's good to check anyway because it's
12691 * technically possible to edit the bound function
12692 * chain via internal keys.
12693 */
12694 goto not_constructable;
12695 }
12696 if (!DUK_HOBJECT_HAS_BOUND(cons)) {
12697 break;
12698 }
12699 } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
12700 /* Lightfuncs cannot be bound. */
12701 break;
12702 } else {
12703 /* Anything else is not constructable. */
12704 goto not_constructable;
12705 }
12706 duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET); /* -> [... cons target] */
12707 duk_remove(ctx, -2); /* -> [... target] */
12708 }
12709 DUK_ASSERT(duk_is_callable(ctx, -1));
12710 DUK_ASSERT(duk_is_lightfunc(ctx, -1) ||
12711 (duk_get_hobject(ctx, -1) != NULL && !DUK_HOBJECT_HAS_BOUND(duk_get_hobject(ctx, -1))));
12712
12713 /* [... constructor arg1 ... argN final_cons] */
12714
12715 /*
12716 * Create "fallback" object to be used as the object instance,
12717 * unless the constructor returns a replacement value.
12718 * Its internal prototype needs to be set based on "prototype"
12719 * property of the constructor.
12720 */
12721
12722 duk_push_object(ctx); /* class Object, extensible */
12723
12724 /* [... constructor arg1 ... argN final_cons fallback] */
12725
12727 proto = duk_get_hobject(ctx, -1);
12728 if (!proto) {
12729 DUK_DDD(DUK_DDDPRINT("constructor has no 'prototype' property, or value not an object "
12730 "-> leave standard Object prototype as fallback prototype"));
12731 } else {
12732 DUK_DDD(DUK_DDDPRINT("constructor has 'prototype' property with object value "
12733 "-> set fallback prototype to that value: %!iO", (duk_heaphdr *) proto));
12734 fallback = duk_get_hobject(ctx, -2);
12735 DUK_ASSERT(fallback != NULL);
12737 }
12738 duk_pop(ctx);
12739
12740 /* [... constructor arg1 ... argN final_cons fallback] */
12741
12742 /*
12743 * Manipulate callstack for the call.
12744 */
12745
12746 duk_dup_top(ctx);
12747 duk_insert(ctx, idx_cons + 1); /* use fallback as 'this' value */
12748 duk_insert(ctx, idx_cons); /* also stash it before constructor,
12749 * in case we need it (as the fallback value)
12750 */
12751 duk_pop(ctx); /* pop final_cons */
12752
12753
12754 /* [... fallback constructor fallback(this) arg1 ... argN];
12755 * Note: idx_cons points to first 'fallback', not 'constructor'.
12756 */
12757
12758 DUK_DDD(DUK_DDDPRINT("before call, idx_cons+1 (constructor) -> %!T, idx_cons+2 (fallback/this) -> %!T, "
12759 "nargs=%ld, top=%ld",
12760 (duk_tval *) duk_get_tval(ctx, idx_cons + 1),
12761 (duk_tval *) duk_get_tval(ctx, idx_cons + 2),
12762 (long) nargs,
12763 (long) duk_get_top(ctx)));
12764
12765 /*
12766 * Call the constructor function (called in "constructor mode").
12767 */
12768
12769 call_flags = DUK_CALL_FLAG_CONSTRUCTOR_CALL; /* not protected, respect reclimit, is a constructor call */
12770
12771 duk_handle_call_unprotected(thr, /* thread */
12772 nargs, /* num_stack_args */
12773 call_flags); /* call_flags */
12774
12775 /* [... fallback retval] */
12776
12777 DUK_DDD(DUK_DDDPRINT("constructor call finished, fallback=%!iT, retval=%!iT",
12778 (duk_tval *) duk_get_tval(ctx, -2),
12779 (duk_tval *) duk_get_tval(ctx, -1)));
12780
12781 /*
12782 * Determine whether to use the constructor return value as the created
12783 * object instance or not.
12784 */
12785
12786 if (duk_is_object(ctx, -1)) {
12787 duk_remove(ctx, -2);
12788 } else {
12789 duk_pop(ctx);
12790 }
12791
12792 /*
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_next()

DUK_EXTERNAL duk_bool_t duk_next ( duk_context * ctx,
duk_idx_t enum_index,
duk_bool_t get_value )

Definition at line 14781 of file duktape-1.5.2/src/duktape.c.

14782 {
14783 /* Note: this may fail, caller should protect the call if necessary */
14784 duk_hobject_compact_props(thr, obj);
14785 }
14786}
14787

◆ 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 15111 of file duktape-1.5.2/src/duktape.c.

15112 {
15114 /* not reachable */
15115 }
15116 return 0;
15117}
15118
15119/*
15120 * Stack index validation/normalization and getting a stack duk_tval ptr.
15121 *
15122 * These are called by many API entrypoints so the implementations must be
15123 * fast and "inlined".
15124 *
15125 * There's some repetition because of this; keep the functions in sync.
15126 */
15127
15129 duk_hthread *thr = (duk_hthread *) ctx;
15130 duk_uidx_t vs_size;
15131 duk_uidx_t uindex;
15132
15135
15136 /* Care must be taken to avoid pointer wrapping in the index
15137 * validation. For instance, on a 32-bit platform with 8-byte
15138 * duk_tval the index 0x20000000UL would wrap the memory space
15139 * once.
15140 */
15141
15142 /* Assume value stack sizes (in elements) fits into duk_idx_t. */
15144 vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
15145 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 76843 of file duktape-1.5.2/src/duktape.c.

76860 {
76861 duk_hthread *thr = (duk_hthread *) ctx;
76862 duk__numconv_stringify_ctx nc_ctx_alloc; /* large context; around 2kB now */
76863 duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc;
76864 duk_double_t res;
76865 duk_hstring *h_str;
76866 duk_small_int_t expt;
76867 duk_small_int_t expt_neg;
76868 duk_small_int_t expt_adj;
76869 duk_small_int_t neg;
76870 duk_small_int_t dig;
76871 duk_small_int_t dig_whole;
76872 duk_small_int_t dig_lzero;
76873 duk_small_int_t dig_frac;
76874 duk_small_int_t dig_expt;
76875 duk_small_int_t dig_prec;
76876 const duk__exp_limits *explim;
76877 const duk_uint8_t *p;
76878 duk_small_int_t ch;
76879
76880 /* This seems to waste a lot of stack frame entries, but good compilers
76881 * will compute these as needed below. Some of these initial flags are
76882 * also modified in the code below, so they can't all be removed.
76883 */
76884 duk_small_int_t trim_white = (flags & DUK_S2N_FLAG_TRIM_WHITE);
76885 duk_small_int_t allow_expt = (flags & DUK_S2N_FLAG_ALLOW_EXP);
76886 duk_small_int_t allow_garbage = (flags & DUK_S2N_FLAG_ALLOW_GARBAGE);
76887 duk_small_int_t allow_plus = (flags & DUK_S2N_FLAG_ALLOW_PLUS);
76888 duk_small_int_t allow_minus = (flags & DUK_S2N_FLAG_ALLOW_MINUS);
76889 duk_small_int_t allow_infinity = (flags & DUK_S2N_FLAG_ALLOW_INF);
76890 duk_small_int_t allow_frac = (flags & DUK_S2N_FLAG_ALLOW_FRAC);
76891 duk_small_int_t allow_naked_frac = (flags & DUK_S2N_FLAG_ALLOW_NAKED_FRAC);
76892 duk_small_int_t allow_empty_frac = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_FRAC);
76893 duk_small_int_t allow_empty = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO);
76894 duk_small_int_t allow_leading_zero = (flags & DUK_S2N_FLAG_ALLOW_LEADING_ZERO);
76895 duk_small_int_t allow_auto_hex_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT);
76896 duk_small_int_t allow_auto_oct_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT);
76897
76898 DUK_DDD(DUK_DDDPRINT("parse number: %!T, radix=%ld, flags=0x%08lx",
76899 (duk_tval *) duk_get_tval(ctx, -1),
76900 (long) radix, (unsigned long) flags));
76901
76902 DUK_ASSERT(radix >= 2 && radix <= 36);
76904
76905 /*
76906 * Preliminaries: trim, sign, Infinity check
76907 *
76908 * We rely on the interned string having a NUL terminator, which will
76909 * cause a parse failure wherever it is encountered. As a result, we
76910 * don't need separate pointer checks.
76911 *
76912 * There is no special parsing for 'NaN' in the specification although
76913 * 'Infinity' (with an optional sign) is allowed in some contexts.
76914 * Some contexts allow plus/minus sign, while others only allow the
76915 * minus sign (like JSON.parse()).
76916 *
76917 * Automatic hex number detection (leading '0x' or '0X') and octal
76918 * number detection (leading '0' followed by at least one octal digit)
76919 * is done here too.
76920 */
76921
76922 if (trim_white) {
76923 /* Leading / trailing whitespace is sometimes accepted and
76924 * sometimes not. After white space trimming, all valid input
76925 * characters are pure ASCII.
76926 */
76927 duk_trim(ctx, -1);
76928 }
76929 h_str = duk_require_hstring(ctx, -1);
76930 DUK_ASSERT(h_str != NULL);
76931 p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_str);
76932
76933 neg = 0;
76934 ch = *p;
76935 if (ch == (duk_small_int_t) '+') {
76936 if (!allow_plus) {
76937 DUK_DDD(DUK_DDDPRINT("parse failed: leading plus sign not allowed"));
76938 goto parse_fail;
76939 }
76940 p++;
76941 } else if (ch == (duk_small_int_t) '-') {
76942 if (!allow_minus) {
76943 DUK_DDD(DUK_DDDPRINT("parse failed: leading minus sign not allowed"));
76944 goto parse_fail;
76945 }
76946 p++;
76947 neg = 1;
76948 }
76949
76950 ch = *p;
76951 if (allow_infinity && ch == (duk_small_int_t) 'I') {
76952 /* Don't check for Infinity unless the context allows it.
76953 * 'Infinity' is a valid integer literal in e.g. base-36:
76954 *
76955 * parseInt('Infinity', 36)
76956 * 1461559270678
76957 */
76958
76959 const duk_uint8_t *q;
76960
76961 /* borrow literal Infinity from builtin string */
76962 q = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(DUK_HTHREAD_STRING_INFINITY(thr));
76963 if (DUK_STRNCMP((const char *) p, (const char *) q, 8) == 0) {
76964 if (!allow_garbage && (p[8] != (duk_uint8_t) 0)) {
76965 DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage after matching 'Infinity' not allowed"));
76966 goto parse_fail;
76967 } else {
76968 res = DUK_DOUBLE_INFINITY;
76969 goto negcheck_and_ret;
76970 }
76971 }
76972 }
76973 if (ch == (duk_small_int_t) '0') {
76974 duk_small_int_t detect_radix = 0;
76975 ch = p[1];
76976 if (allow_auto_hex_int && (ch == (duk_small_int_t) 'x' || ch == (duk_small_int_t) 'X')) {
76977 DUK_DDD(DUK_DDDPRINT("detected 0x/0X hex prefix, changing radix and preventing fractions and exponent"));
76978 detect_radix = 16;
76979 allow_empty = 0; /* interpret e.g. '0x' and '0xg' as a NaN (= parse error) */
76980 p += 2;
76981 } else if (allow_auto_oct_int && (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9')) {
76982 DUK_DDD(DUK_DDDPRINT("detected 0n oct prefix, changing radix and preventing fractions and exponent"));
76983 detect_radix = 8;
76984 allow_empty = 1; /* interpret e.g. '09' as '0', not NaN */
76985 p += 1;
76986 }
76987 if (detect_radix > 0) {
76988 radix = detect_radix;
76989 allow_expt = 0;
76990 allow_frac = 0;
76991 allow_naked_frac = 0;
76992 allow_empty_frac = 0;
76993 allow_leading_zero = 1; /* allow e.g. '0x0009' and '00077' */
76994 }
76995 }
76996
76997 /*
76998 * Scan number and setup for Dragon4.
76999 *
77000 * The fast path case is detected during setup: an integer which
77001 * can be converted without rounding, no net exponent. The fast
77002 * path could be implemented as a separate scan, but may not really
77003 * be worth it: the multiplications for building 'f' are not
77004 * expensive when 'f' is small.
77005 *
77006 * The significand ('f') must contain enough bits of (apparent)
77007 * accuracy, so that Dragon4 will generate enough binary output digits.
77008 * For decimal numbers, this means generating a 20-digit significand,
77009 * which should yield enough practical accuracy to parse IEEE doubles.
77010 * In fact, the Ecmascript specification explicitly allows an
77011 * implementation to treat digits beyond 20 as zeroes (and even
77012 * to round the 20th digit upwards). For non-decimal numbers, the
77013 * appropriate number of digits has been precomputed for comparable
77014 * accuracy.
77015 *
77016 * Digit counts:
77017 *
77018 * [ dig_lzero ]
77019 * |
77020 * .+-..---[ dig_prec ]----.
77021 * | || |
77022 * 0000123.456789012345678901234567890e+123456
77023 * | | | | | |
77024 * `--+--' `------[ dig_frac ]-------' `-+--'
77025 * | |
77026 * [ dig_whole ] [ dig_expt ]
77027 *
77028 * dig_frac and dig_expt are -1 if not present
77029 * dig_lzero is only computed for whole number part
77030 *
77031 * Parsing state
77032 *
77033 * Parsing whole part dig_frac < 0 AND dig_expt < 0
77034 * Parsing fraction part dig_frac >= 0 AND dig_expt < 0
77035 * Parsing exponent part dig_expt >= 0 (dig_frac may be < 0 or >= 0)
77036 *
77037 * Note: in case we hit an implementation limit (like exponent range),
77038 * we should throw an error, NOT return NaN or Infinity. Even with
77039 * very large exponent (or significand) values the final result may be
77040 * finite, so NaN/Infinity would be incorrect.
77041 */
77042
77043 duk__bi_set_small(&nc_ctx->f, 0);
77044 dig_prec = 0;
77045 dig_lzero = 0;
77046 dig_whole = 0;
77047 dig_frac = -1;
77048 dig_expt = -1;
77049 expt = 0;
77050 expt_adj = 0; /* essentially tracks digit position of lowest 'f' digit */
77051 expt_neg = 0;
77052 for (;;) {
77053 ch = *p++;
77054
77055 DUK_DDD(DUK_DDDPRINT("parse digits: p=%p, ch='%c' (%ld), expt=%ld, expt_adj=%ld, "
77056 "dig_whole=%ld, dig_frac=%ld, dig_expt=%ld, dig_lzero=%ld, dig_prec=%ld",
77057 (const void *) p, (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : '?'), (long) ch,
77058 (long) expt, (long) expt_adj, (long) dig_whole, (long) dig_frac,
77059 (long) dig_expt, (long) dig_lzero, (long) dig_prec));
77060 DUK__BI_PRINT("f", &nc_ctx->f);
77061
77062 /* Most common cases first. */
77063 if (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9') {
77064 dig = (int) ch - '0' + 0;
77065 } else if (ch == (duk_small_int_t) '.') {
77066 /* A leading digit is not required in some cases, e.g. accept ".123".
77067 * In other cases (JSON.parse()) a leading digit is required. This
77068 * is checked for after the loop.
77069 */
77070 if (dig_frac >= 0 || dig_expt >= 0) {
77071 if (allow_garbage) {
77072 DUK_DDD(DUK_DDDPRINT("garbage termination (invalid period)"));
77073 break;
77074 } else {
77075 DUK_DDD(DUK_DDDPRINT("parse failed: period not allowed"));
77076 goto parse_fail;
77077 }
77078 }
77079
77080 if (!allow_frac) {
77081 /* Some contexts don't allow fractions at all; this can't be a
77082 * post-check because the state ('f' and expt) would be incorrect.
77083 */
77084 if (allow_garbage) {
77085 DUK_DDD(DUK_DDDPRINT("garbage termination (invalid first period)"));
77086 break;
77087 } else {
77088 DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed"));
77089 }
77090 }
77091
77092 DUK_DDD(DUK_DDDPRINT("start fraction part"));
77093 dig_frac = 0;
77094 continue;
77095 } else if (ch == (duk_small_int_t) 0) {
77096 DUK_DDD(DUK_DDDPRINT("NUL termination"));
77097 break;
77098 } else if (allow_expt && dig_expt < 0 && (ch == (duk_small_int_t) 'e' || ch == (duk_small_int_t) 'E')) {
77099 /* Note: we don't parse back exponent notation for anything else
77100 * than radix 10, so this is not an ambiguous check (e.g. hex
77101 * exponent values may have 'e' either as a significand digit
77102 * or as an exponent separator).
77103 *
77104 * If the exponent separator occurs twice, 'e' will be interpreted
77105 * as a digit (= 14) and will be rejected as an invalid decimal
77106 * digit.
77107 */
77108
77109 DUK_DDD(DUK_DDDPRINT("start exponent part"));
77110
77111 /* Exponent without a sign or with a +/- sign is accepted
77112 * by all call sites (even JSON.parse()).
77113 */
77114 ch = *p;
77115 if (ch == (duk_small_int_t) '-') {
77116 expt_neg = 1;
77117 p++;
77118 } else if (ch == (duk_small_int_t) '+') {
77119 p++;
77120 }
77121 dig_expt = 0;
77122 continue;
77123 } else if (ch >= (duk_small_int_t) 'a' && ch <= (duk_small_int_t) 'z') {
77124 dig = (duk_small_int_t) (ch - (duk_small_int_t) 'a' + 0x0a);
77125 } else if (ch >= (duk_small_int_t) 'A' && ch <= (duk_small_int_t) 'Z') {
77126 dig = (duk_small_int_t) (ch - (duk_small_int_t) 'A' + 0x0a);
77127 } else {
77128 dig = 255; /* triggers garbage digit check below */
77129 }
77130 DUK_ASSERT((dig >= 0 && dig <= 35) || dig == 255);
77131
77132 if (dig >= radix) {
77133 if (allow_garbage) {
77134 DUK_DDD(DUK_DDDPRINT("garbage termination"));
77135 break;
77136 } else {
77137 DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage or invalid digit"));
77138 goto parse_fail;
77139 }
77140 }
77141
77142 if (dig_expt < 0) {
77143 /* whole or fraction digit */
77144
77145 if (dig_prec < duk__str2num_digits_for_radix[radix - 2]) {
77146 /* significant from precision perspective */
77147
77148 duk_small_int_t f_zero = duk__bi_is_zero(&nc_ctx->f);
77149 if (f_zero && dig == 0) {
77150 /* Leading zero is not counted towards precision digits; not
77151 * in the integer part, nor in the fraction part.
77152 */
77153 if (dig_frac < 0) {
77154 dig_lzero++;
77155 }
77156 } else {
77157 /* XXX: join these ops (multiply-accumulate), but only if
77158 * code footprint decreases.
77159 */
77160 duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, radix);
77161 duk__bi_add_small(&nc_ctx->f, &nc_ctx->t1, dig);
77162 dig_prec++;
77163 }
77164 } else {
77165 /* Ignore digits beyond a radix-specific limit, but note them
77166 * in expt_adj.
77167 */
77168 expt_adj++;
77169 }
77170
77171 if (dig_frac >= 0) {
77172 dig_frac++;
77173 expt_adj--;
77174 } else {
77175 dig_whole++;
77176 }
77177 } else {
77178 /* exponent digit */
77179
77180 expt = expt * radix + dig;
77181 if (expt > DUK_S2N_MAX_EXPONENT) {
77182 /* impose a reasonable exponent limit, so that exp
77183 * doesn't need to get tracked using a bigint.
77184 */
77185 DUK_DDD(DUK_DDDPRINT("parse failed: exponent too large"));
77186 goto parse_explimit_error;
77187 }
77188 dig_expt++;
77189 }
77190 }
77191
77192 /* Leading zero. */
77193
77194 if (dig_lzero > 0 && dig_whole > 1) {
77195 if (!allow_leading_zero) {
77196 DUK_DDD(DUK_DDDPRINT("parse failed: leading zeroes not allowed in integer part"));
77197 goto parse_fail;
77198 }
77199 }
77200
77201 /* Validity checks for various fraction formats ("0.1", ".1", "1.", "."). */
77202
77203 if (dig_whole == 0) {
77204 if (dig_frac == 0) {
77205 /* "." is not accepted in any format */
77206 DUK_DDD(DUK_DDDPRINT("parse failed: plain period without leading or trailing digits"));
77207 goto parse_fail;
77208 } else if (dig_frac > 0) {
77209 /* ".123" */
77210 if (!allow_naked_frac) {
77211 DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed without "
77212 "leading integer digit(s)"));
77213 goto parse_fail;
77214 }
77215 } else {
77216 /* empty ("") is allowed in some formats (e.g. Number(''), as zero */
77217 if (!allow_empty) {
77218 DUK_DDD(DUK_DDDPRINT("parse failed: empty string not allowed (as zero)"));
77219 goto parse_fail;
77220 }
77221 }
77222 } else {
77223 if (dig_frac == 0) {
77224 /* "123." is allowed in some formats */
77225 if (!allow_empty_frac) {
77226 DUK_DDD(DUK_DDDPRINT("parse failed: empty fractions"));
77227 goto parse_fail;
77228 }
77229 } else if (dig_frac > 0) {
77230 /* "123.456" */
77231 ;
77232 } else {
77233 /* "123" */
77234 ;
77235 }
77236 }
77237
77238 /* Exponent without digits (e.g. "1e" or "1e+"). If trailing garbage is
77239 * allowed, ignore exponent part as garbage (= parse as "1", i.e. exp 0).
77240 */
77241
77242 if (dig_expt == 0) {
77243 if (!allow_garbage) {
77244 DUK_DDD(DUK_DDDPRINT("parse failed: empty exponent"));
77245 goto parse_fail;
77246 }
77247 DUK_ASSERT(expt == 0);
77248 }
77249
77250 if (expt_neg) {
77251 expt = -expt;
77252 }
77253 DUK_DDD(DUK_DDDPRINT("expt=%ld, expt_adj=%ld, net exponent -> %ld",
77254 (long) expt, (long) expt_adj, (long) (expt + expt_adj)));
77255 expt += expt_adj;
77256
77257 /* Fast path check. */
77258
77259 if (nc_ctx->f.n <= 1 && /* 32-bit value */
77260 expt == 0 /* no net exponent */) {
77261 /* Fast path is triggered for no exponent and also for balanced exponent
77262 * and fraction parts, e.g. for "1.23e2" == "123". Remember to respect
77263 * zero sign.
77264 */
77265
77266 /* XXX: could accept numbers larger than 32 bits, e.g. up to 53 bits? */
77267 DUK_DDD(DUK_DDDPRINT("fast path number parse"));
77268 if (nc_ctx->f.n == 1) {
77269 res = (double) nc_ctx->f.v[0];
77270 } else {
77271 res = 0.0;
77272 }
77273 goto negcheck_and_ret;
77274 }
77275
77276 /* Significand ('f') padding. */
77277
77278 while (dig_prec < duk__str2num_digits_for_radix[radix - 2]) {
77279 /* Pad significand with "virtual" zero digits so that Dragon4 will
77280 * have enough (apparent) precision to work with.
77281 */
77282 DUK_DDD(DUK_DDDPRINT("dig_prec=%ld, pad significand with zero", (long) dig_prec));
77283 duk__bi_mul_small_copy(&nc_ctx->f, radix, &nc_ctx->t1);
77284 DUK__BI_PRINT("f", &nc_ctx->f);
77285 expt--;
77286 dig_prec++;
77287 }
77288
77289 DUK_DDD(DUK_DDDPRINT("final exponent: %ld", (long) expt));
77290
77291 /* Detect zero special case. */
77292
77293 if (nc_ctx->f.n == 0) {
77294 /* This may happen even after the fast path check, if exponent is
77295 * not balanced (e.g. "0e1"). Remember to respect zero sign.
77296 */
77297 DUK_DDD(DUK_DDDPRINT("significand is zero"));
77298 res = 0.0;
77299 goto negcheck_and_ret;
77300 }
77301
77302
77303 /* Quick reject of too large or too small exponents. This check
77304 * would be incorrect for zero (e.g. "0e1000" is zero, not Infinity)
77305 * so zero check must be above.
77306 */
77307
77308 explim = &duk__str2num_exp_limits[radix - 2];
77309 if (expt > explim->upper) {
77310 DUK_DDD(DUK_DDDPRINT("exponent too large -> infinite"));
77312 goto negcheck_and_ret;
77313 } else if (expt < explim->lower) {
77314 DUK_DDD(DUK_DDDPRINT("exponent too small -> zero"));
77315 res = (duk_double_t) 0.0;
77316 goto negcheck_and_ret;
77317 }
77318
77319 nc_ctx->is_s2n = 1;
77320 nc_ctx->e = expt;
77321 nc_ctx->b = radix;
77322 nc_ctx->B = 2;
77323 nc_ctx->is_fixed = 1;
77324 nc_ctx->abs_pos = 0;
77325 nc_ctx->req_digits = 53 + 1;
77326
77327 DUK__BI_PRINT("f", &nc_ctx->f);
77328 DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e));
77329
77330 /*
77331 * Dragon4 slow path (binary) digit generation.
77332 * An extra digit is generated for rounding.
77333 */
77334
77335 duk__dragon4_prepare(nc_ctx); /* setup many variables in nc_ctx */
77336
77337 DUK_DDD(DUK_DDDPRINT("after prepare:"));
77338 DUK__BI_PRINT("r", &nc_ctx->r);
77339 DUK__BI_PRINT("s", &nc_ctx->s);
77340 DUK__BI_PRINT("mp", &nc_ctx->mp);
77341 DUK__BI_PRINT("mm", &nc_ctx->mm);
77342
77343 duk__dragon4_scale(nc_ctx);
77344
77345 DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k));
77346 DUK__BI_PRINT("r", &nc_ctx->r);
77347 DUK__BI_PRINT("s", &nc_ctx->s);
77348 DUK__BI_PRINT("mp", &nc_ctx->mp);
77349 DUK__BI_PRINT("mm", &nc_ctx->mm);
77350
77351 duk__dragon4_generate(nc_ctx);
77352
77353 DUK_ASSERT(nc_ctx->count == 53 + 1);
77354
77355 /*
77356 * Convert binary digits into an IEEE double. Need to handle
77357 * denormals and rounding correctly.
77358 */
77359
77360 duk__dragon4_ctx_to_double(nc_ctx, &res);
77361 goto negcheck_and_ret;
77362
77363 negcheck_and_ret:
77364 if (neg) {
77365 res = -res;
DUK_LOCAL void duk__bi_add_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z)
DUK_LOCAL int duk__bi_is_zero(duk__bigint *x)
DUK_LOCAL const duk__exp_limits duk__str2num_exp_limits[]
DUK_LOCAL const duk_uint8_t duk__str2num_digits_for_radix[]
#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO
#define DUK_S2N_MAX_EXPONENT
#define DUK_S2N_FLAG_ALLOW_INF
DUK_LOCAL void duk__dragon4_scale(duk__numconv_stringify_ctx *nc_ctx)
#define DUK_HTHREAD_STRING_INFINITY(thr)

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 76640 of file duktape-1.5.2/src/duktape.c.

76643 : %08lx %08lx",
76644 (unsigned long) DUK_DBLUNION_GET_HIGH32(&u),
76645 (unsigned long) DUK_DBLUNION_GET_LOW32(&u)));
76646
76647 *x = DUK_DBLUNION_GET_DOUBLE(&u);
76648}
76649
76650/*
76651 * Exposed number-to-string API
76652 *
76653 * Input: [ number ]
76654 * Output: [ string ]
76655 */
76656
76657DUK_INTERNAL void duk_numconv_stringify(duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags) {
76658 duk_double_t x;
76659 duk_small_int_t c;
76660 duk_small_int_t neg;
76661 duk_uint32_t uval;
76662 duk__numconv_stringify_ctx nc_ctx_alloc; /* large context; around 2kB now */
76663 duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc;
76664
76665 x = (duk_double_t) duk_require_number(ctx, -1);
76666 duk_pop(ctx);
76667
76668 /*
76669 * Handle special cases (NaN, infinity, zero).
76670 */
76671
76672 c = (duk_small_int_t) DUK_FPCLASSIFY(x);
76673 if (DUK_SIGNBIT((double) x)) {
76674 x = -x;
76675 neg = 1;
76676 } else {
76677 neg = 0;
76678 }
76679
76680 /* NaN sign bit is platform specific with unpacked, un-normalized NaNs */
76681 DUK_ASSERT(c == DUK_FP_NAN || DUK_SIGNBIT((double) x) == 0);
76682
76683 if (c == DUK_FP_NAN) {
76684 duk_push_hstring_stridx(ctx, DUK_STRIDX_NAN);
76685 return;
76686 } else if (c == DUK_FP_INFINITE) {
76687 if (neg) {
76688 /* -Infinity */
76689 duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_INFINITY);
76690 } else {
76691 /* Infinity */
76692 duk_push_hstring_stridx(ctx, DUK_STRIDX_INFINITY);
76693 }
76694 return;
76695 } else if (c == DUK_FP_ZERO) {
76696 /* We can't shortcut zero here if it goes through special formatting
76697 * (such as forced exponential notation).
76698 */
76699 ;
76700 }
76701
76702 /*
76703 * Handle integers in 32-bit range (that is, [-(2**32-1),2**32-1])
76704 * specially, as they're very likely for embedded programs. This
76705 * is now done for all radix values. We must be careful not to use
76706 * the fast path when special formatting (e.g. forced exponential)
76707 * is in force.
76708 *
76709 * XXX: could save space by supporting radix 10 only and using
76710 * sprintf "%lu" for the fast path and for exponent formatting.
76711 */
76712
76713 uval = (unsigned int) x;
76714 if (((double) uval) == x && /* integer number in range */
76715 flags == 0) { /* no special formatting */
76716 /* use bigint area as a temp */
76717 duk_uint8_t *buf = (duk_uint8_t *) (&nc_ctx->f);
76718 duk_uint8_t *p = buf;
76719
76720 DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= 32 + 1); /* max size: radix=2 + sign */
76721 if (neg && uval != 0) {
76722 /* no negative sign for zero */
76723 *p++ = (duk_uint8_t) '-';
76724 }
76725 p += duk__dragon4_format_uint32(p, uval, radix);
76726 duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (p - buf));
76727 return;
76728 }
76729
76730 /*
76731 * Dragon4 setup.
76732 *
76733 * Convert double from IEEE representation for conversion;
76734 * normal finite values have an implicit leading 1-bit. The
76735 * slow path algorithm doesn't handle zero, so zero is special
76736 * cased here but still creates a valid nc_ctx, and goes
76737 * through normal formatting in case special formatting has
76738 * been requested (e.g. forced exponential format: 0 -> "0e+0").
76739 */
76740
76741 /* Would be nice to bulk clear the allocation, but the context
76742 * is 1-2 kilobytes and nothing should rely on it being zeroed.
76743 */
76744#if 0
76745 DUK_MEMZERO((void *) nc_ctx, sizeof(*nc_ctx)); /* slow init, do only for slow path cases */
76746#endif
76747
76748 nc_ctx->is_s2n = 0;
76749 nc_ctx->b = 2;
76750 nc_ctx->B = radix;
76751 nc_ctx->abs_pos = 0;
76752 if (flags & DUK_N2S_FLAG_FIXED_FORMAT) {
76753 nc_ctx->is_fixed = 1;
76754 if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) {
76755 /* absolute req_digits; e.g. digits = 1 -> last digit is 0,
76756 * but add an extra digit for rounding.
76757 */
76758 nc_ctx->abs_pos = 1;
76759 nc_ctx->req_digits = (-digits + 1) - 1;
76760 } else {
76761 nc_ctx->req_digits = digits + 1;
76762 }
76763 } else {
76764 nc_ctx->is_fixed = 0;
76765 nc_ctx->req_digits = 0;
76766 }
76767
76768 if (c == DUK_FP_ZERO) {
76769 /* Zero special case: fake requested number of zero digits; ensure
76770 * no sign bit is printed. Relative and absolute fixed format
76771 * require separate handling.
76772 */
76773 duk_small_int_t count;
76774 if (nc_ctx->is_fixed) {
76775 if (nc_ctx->abs_pos) {
76776 count = digits + 2; /* lead zero + 'digits' fractions + 1 for rounding */
76777 } else {
76778 count = digits + 1; /* + 1 for rounding */
76779 }
76780 } else {
76781 count = 1;
76782 }
76783 DUK_DDD(DUK_DDDPRINT("count=%ld", (long) count));
76784 DUK_ASSERT(count >= 1);
76785 DUK_MEMZERO((void *) nc_ctx->digits, count);
76786 nc_ctx->count = count;
76787 nc_ctx->k = 1; /* 0.000... */
76788 neg = 0;
76789 goto zero_skip;
76790 }
76791
76792 duk__dragon4_double_to_ctx(nc_ctx, x); /* -> sets 'f' and 'e' */
76793 DUK__BI_PRINT("f", &nc_ctx->f);
76794 DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e));
76795
76796 /*
76797 * Dragon4 slow path digit generation.
76798 */
76799
76800 duk__dragon4_prepare(nc_ctx); /* setup many variables in nc_ctx */
76801
76802 DUK_DDD(DUK_DDDPRINT("after prepare:"));
76803 DUK__BI_PRINT("r", &nc_ctx->r);
76804 DUK__BI_PRINT("s", &nc_ctx->s);
76805 DUK__BI_PRINT("mp", &nc_ctx->mp);
76806 DUK__BI_PRINT("mm", &nc_ctx->mm);
76807
76808 duk__dragon4_scale(nc_ctx);
76809
76810 DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k));
76811 DUK__BI_PRINT("r", &nc_ctx->r);
76812 DUK__BI_PRINT("s", &nc_ctx->s);
76813 DUK__BI_PRINT("mp", &nc_ctx->mp);
76814 DUK__BI_PRINT("mm", &nc_ctx->mm);
76815
76816 duk__dragon4_generate(nc_ctx);
76817
76818 /*
76819 * Convert and push final string.
76820 */
76821
76822 zero_skip:
76823
76824 if (flags & DUK_N2S_FLAG_FIXED_FORMAT) {
76825 /* Perform fixed-format rounding. */
76826 duk_small_int_t roundpos;
76827 if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) {
76828 /* 'roundpos' is relative to nc_ctx->k and increases to the right
76829 * (opposite of how 'k' changes).
76830 */
76831 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 12474 of file duktape-1.5.2/src/duktape.c.

12474 {
12475 /*
12476 * XXX: if duk_handle_call() took values through indices, this could be
12477 * made much more sensible. However, duk_handle_call() needs to fudge
12478 * the 'this' and 'func' values to handle bound function chains, which
12479 * is now done "in-place", so this is not a trivial change.
12480 */
12481
12483
12484 obj_index = duk_require_normalize_index(ctx, obj_index); /* make absolute */
12485
12486 duk__call_prop_prep_stack(ctx, obj_index, nargs);
12487
12488 duk_call_method(ctx, nargs);
12489}
12490
12492 duk_hthread *thr = (duk_hthread *) ctx;
12493 duk_small_uint_t call_flags;
12494 duk_idx_t idx_func;
12495 duk_int_t rc;
12496
12498 DUK_ASSERT(thr != NULL);
12499
12500 idx_func = duk_get_top(ctx) - nargs - 1; /* must work for nargs <= 0 */
12501 if (idx_func < 0 || nargs < 0) {
12502 /* We can't reliably pop anything here because the stack input
12503 * shape is incorrect. So we throw an error; if the caller has
12504 * no catch point for this, a fatal error will occur. Another
12505 * alternative would be to just return an error. But then the
12506 * stack would be in an unknown state which might cause some
12507 * very hard to diagnose problems later on. Also note that even
12508 * if we did not throw an error here, the underlying call handler
12509 * might STILL throw an out-of-memory error or some other internal
12510 * fatal error.

References duk__call_prop_prep_stack(), DUK_ASSERT_CTX_VALID, duk_call_method(), and duk_require_normalize_index().

◆ duk_pcall_method()

DUK_EXTERNAL duk_int_t duk_pcall_method ( duk_context * ctx,
duk_idx_t nargs )

Definition at line 12512 of file duktape-1.5.2/src/duktape.c.

12529 {
12530 duk_hthread *thr = (duk_hthread *) ctx;
12531 duk_small_uint_t call_flags;
12532 duk_idx_t idx_func;
12533 duk_int_t rc;
12534

◆ 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 12557 of file duktape-1.5.2/src/duktape.c.

◆ duk_pnew()

DUK_EXTERNAL duk_int_t duk_pnew ( duk_context * ctx,
duk_idx_t nargs )

Definition at line 12804 of file duktape-1.5.2/src/duktape.c.

12807 :
12809}
12810
12812 duk_uint_t nargs;
12813
12814 nargs = duk_to_uint(ctx, -1);
12815 duk_pop(ctx);
12816
12817 duk_new(ctx, nargs);
12818 return 1;
12819}
12820
DUK_LOCAL duk_ret_t duk__pnew_helper(duk_context *ctx)
#define DUK_STR_NOT_CONSTRUCTABLE
DUK_EXTERNAL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index)

◆ duk_pop()

◆ duk_pop_2()

◆ duk_pop_3()

DUK_EXTERNAL void duk_pop_3 ( duk_context * ctx)

Definition at line 19227 of file duktape-1.5.2/src/duktape.c.

◆ duk_pop_n()

DUK_EXTERNAL void duk_pop_n ( duk_context * ctx,
duk_idx_t count )

Definition at line 19143 of file duktape-1.5.2/src/duktape.c.

19147 {
19148 duk_hthread *thr = (duk_hthread *) ctx;
19150 DUK_ASSERT(thr != NULL);
19151 DUK_ASSERT(builtin_idx >= 0 && builtin_idx < DUK_NUM_BUILTINS);
19152 DUK_ASSERT(thr->builtins[builtin_idx] != NULL);
19153 duk_push_hobject(ctx, thr->builtins[builtin_idx]);
19154}
19155
19156/*
19157 * Poppers
19158 */
19159
19160DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) {
19161 duk_hthread *thr = (duk_hthread *) ctx;
19162 duk_tval *tv;
19163
19165
19166 if (DUK_UNLIKELY(count < 0)) {
19168 return;
19169 }
19170
19172 if (DUK_UNLIKELY((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count)) {
19174 }
19175
19176 /*
19177 * Must be very careful here, every DECREF may cause reallocation
19178 * of our valstack.
19179 */
19180
19181 /* XXX: inlined DECREF macro would be nice here: no NULL check,
19182 * refzero queueing but no refzero algorithm run (= no pointer
19183 * instability), inline code.
19184 */
19185
19186 /* XXX: optimize loops */
19187
19188#if defined(DUK_USE_REFERENCE_COUNTING)
19189 while (count > 0) {
19190 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 18513 of file duktape-1.5.2/src/duktape.c.

18521 {
18523
18524 return duk_push_object_helper(ctx,
18528}
18529
18531 duk_hthread *thr = (duk_hthread *) ctx;
18532 duk_hobject *obj;
18533 duk_idx_t ret;
18534
18536
18537 ret = duk_push_object_helper(ctx,
18542
18543 obj = duk_require_hobject(ctx, ret);
18544
18545 /*
18546 * An array must have a 'length' property (E5 Section 15.4.5.2).
18547 * The special array behavior flag must only be enabled once the
18548 * length property has been added.
18549 *
#define DUK_BIDX_ARRAY_PROTOTYPE

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 17928 of file duktape-1.5.2/src/duktape.c.

17934 {
17935 duk_hthread *thr;
17936 duk_tval *tv_slot;
17937
17939 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 18849 of file duktape-1.5.2/src/duktape.c.

18860 {
18862};
18863#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
18864#undef DUK__PACK_ARGS
18865
18866DUK_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) {
18867 duk_hthread *thr;
18868 duk_hbufferobject *h_bufobj;
18869 duk_hbuffer *h_val;
18870 duk_uint32_t tmp;
18871 duk_uint_t classnum;
18872 duk_uint_t protobidx;
18873 duk_uint_t lookupidx;
18874 duk_uint_t uint_offset, uint_length, uint_added;
18875
18877 thr = (duk_hthread *) ctx;
18878 DUK_UNREF(thr);
18879
18880 /* The underlying types for offset/length in duk_hbufferobject is
18881 * duk_uint_t; make sure argument values fit and that offset + length
18882 * does not wrap.
18883 */
18884 uint_offset = (duk_uint_t) byte_offset;
18885 uint_length = (duk_uint_t) byte_length;
18886 if (sizeof(duk_size_t) != sizeof(duk_uint_t)) {
18887 if ((duk_size_t) uint_offset != byte_offset || (duk_size_t) uint_length != byte_length) {
18888 goto range_error;
18889 }
18890 }
18891 uint_added = uint_offset + uint_length;
18892 if (uint_added < uint_offset) {
18893 goto range_error;
18894 }
18895 DUK_ASSERT(uint_added >= uint_offset && uint_added >= uint_length);
18896
18897 DUK_ASSERT_DISABLE(flags >= 0); /* flags is unsigned */
18898 lookupidx = flags & 0x0f; /* 4 low bits */
18899 if (lookupidx >= sizeof(duk__bufobj_flags_lookup) / sizeof(duk_uint32_t)) {
18900 goto arg_error;
18901 }
18902 tmp = duk__bufobj_flags_lookup[lookupidx];
18903 classnum = tmp >> 24;
18904 protobidx = (tmp >> 16) & 0xff;
18905
18906 h_val = duk_require_hbuffer(ctx, idx_buffer);
18907 DUK_ASSERT(h_val != NULL);
18908
18909 h_bufobj = duk_push_bufferobject_raw(ctx,
18913 protobidx);
18914 DUK_ASSERT(h_bufobj != NULL);
18915
18916 h_bufobj->buf = h_val;
18917 DUK_HBUFFER_INCREF(thr, h_val);
18918 h_bufobj->offset = uint_offset;
18919 h_bufobj->length = uint_length;
18920 h_bufobj->shift = (tmp >> 4) & 0x0f;
18921 h_bufobj->elem_type = (tmp >> 8) & 0xff;
18922 h_bufobj->is_view = tmp & 0x0f;
18924
18925#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
18926 /* TypedArray views need an automatic ArrayBuffer which must be
18927 * provided as .buffer property of the view. Just create a new
18928 * ArrayBuffer sharing the same underlying buffer.
18929 */
18930 if (flags & DUK_BUFOBJ_CREATE_ARRBUF) {
18931 h_bufobj = duk_push_bufferobject_raw(ctx,
18936
18937 DUK_ASSERT(h_bufobj != NULL);
18938
18939 h_bufobj->buf = h_val;
18940 DUK_HBUFFER_INCREF(thr, h_val);
18941 h_bufobj->offset = uint_offset;
18942 h_bufobj->length = uint_length;
18943 DUK_ASSERT(h_bufobj->shift == 0);
18945 DUK_ASSERT(h_bufobj->is_view == 0);
#define DUK_BUFOBJ_CREATE_ARRBUF
#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE
#define DUK__PACK_ARGS(classnum, protobidx, elemtype, elemshift, isview)
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)
static const duk_uint32_t duk__bufobj_flags_lookup[]
DUK_INTERNAL_DECL duk_hbuffer * duk_require_hbuffer(duk_context *ctx, duk_idx_t index)

◆ 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 19029 of file duktape-1.5.2/src/duktape.c.

19029 {
19030 const char *filename = duk_api_global_filename;
19032 va_list ap;
19033 duk_idx_t ret;
19034
19036
19039 va_start(ap, fmt);
19040 ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
19041 va_end(ap);
19042 return ret;
19043}
19044#endif /* DUK_USE_VARIADIC_MACROS */
19045
19047 duk_hthread *thr = (duk_hthread *) ctx;
19048 duk_tval *tv_slot;
19049 duk_hbuffer *h;
19050 void *buf_data;
19051
19053
19054 /* check stack first */
19055 if (thr->valstack_top >= thr->valstack_end) {
19057 }
19058

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 18790 of file duktape-1.5.2/src/duktape.c.

18792 {
18793 goto api_error;
18794 }
18795
18796 lf_flags = DUK_LFUNC_FLAGS_PACK(magic, length, nargs);
18797 DUK_TVAL_SET_LIGHTFUNC(&tv_tmp, func, lf_flags);
18798 duk_push_tval(ctx, &tv_tmp); /* XXX: direct valstack write */
18799 DUK_ASSERT(thr->valstack_top != thr->valstack_bottom);
18800 return ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
18801
18802 api_error:
18804 return 0; /* not reached */
18805}
18806
18807DUK_INTERNAL duk_hbufferobject *duk_push_bufferobject_raw(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) {
18808 duk_hthread *thr = (duk_hthread *) ctx;
18809 duk_hbufferobject *obj;
18810 duk_tval *tv_slot;
18811
18812 DUK_ASSERT(ctx != NULL);
18813 DUK_ASSERT(prototype_bidx >= 0);
18814
18815 /* check stack first */
18816 if (thr->valstack_top >= thr->valstack_end) {

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 18705 of file duktape-1.5.2/src/duktape.c.

18717 :
18719 return 0; /* not reached */
18720}

Referenced by duk_put_number_list().

◆ duk_push_c_function_noconstruct_noexotic()

◆ duk_push_c_function_noexotic()

◆ 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 18753 of file duktape-1.5.2/src/duktape.c.

18755 {
18756 duk_uint_t flags;
18757
18759
18766
18767 (void) duk__push_c_function_raw(ctx, func, nargs, flags);
18768}
18769
18771 duk_hthread *thr = (duk_hthread *) ctx;
18772 duk_tval tv_tmp;
18773 duk_small_uint_t lf_flags;
18774
18776
18777 /* check stack first */
18778 if (thr->valstack_top >= thr->valstack_end) {
18780 }
18781
18782 if (nargs >= DUK_LFUNC_NARGS_MIN && nargs <= DUK_LFUNC_NARGS_MAX) {
18783 /* as is */
18784 } else if (nargs == DUK_VARARGS) {
18786 } else {
18787 goto api_error;
18788 }
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_push_compiledfunction()

DUK_INTERNAL_DECL duk_idx_t duk_push_compiledfunction ( duk_context * ctx)

Definition at line 18614 of file duktape-1.5.2/src/duktape.c.

18615 {
18617 }
18618
18619 /* default prototype (Note: 'obj' must be reachable) */
18621
18622 /* Initial stack size satisfies the stack spare constraints so there
18623 * is no need to require stack here.
18624 */
18627
18628 return ret;
18629}
18630
18632 duk_hthread *thr = (duk_hthread *) ctx;
18634 duk_idx_t ret;
18635 duk_tval *tv_slot;
18636
18638
18639 /* check stack first */
18640 if (thr->valstack_top >= thr->valstack_end) {
18642 }
18643
18644 /* Template functions are not strictly constructable (they don't
18645 * have a "prototype" property for instance), so leave the
18646 * DUK_HOBJECT_FLAG_CONSRUCTABLE flag cleared here.
18647 */
18648
#define DUK_BIDX_THREAD_PROTOTYPE
DUK_INTERNAL_DECL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to)

◆ duk_push_context_dump()

DUK_EXTERNAL void duk_push_context_dump ( duk_context * ctx)

Definition at line 13768 of file duktape-1.5.2/src/duktape.c.

13785 {
13786 duk_idx_t idx;
13787 duk_idx_t top;
13788
13790
13791 /* We don't duk_require_stack() here now, but rely on the caller having
13792 * enough space.
13793 */
13794
13795 top = duk_get_top(ctx);
13796 duk_push_array(ctx);
13797 for (idx = 0; idx < top; idx++) {
13798 duk_dup(ctx, idx);
13799 duk_put_prop_index(ctx, -2, idx);
13800 }

◆ duk_push_current_function()

DUK_EXTERNAL void duk_push_current_function ( duk_context * ctx)

Definition at line 18275 of file duktape-1.5.2/src/duktape.c.

18279 {
18280 duk_hthread *thr;
18281
18282 DUK_ASSERT(ctx != NULL);
18283 thr = (duk_hthread *) ctx;
18284
18285 DUK_ASSERT(thr->callstack_top > 0); /* caller required to know */
18286 DUK_ASSERT(thr->valstack_bottom > thr->valstack); /* consequence of above */
18287 DUK_ASSERT(thr->valstack_bottom - 1 >= thr->valstack); /* 'this' binding exists */
18288
18289 return thr->valstack_bottom - 1;
18290}

◆ duk_push_current_thread()

DUK_EXTERNAL void duk_push_current_thread ( duk_context * ctx)

◆ 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 18999 of file duktape-1.5.2/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 19012 of file duktape-1.5.2/src/duktape.c.

19016 {
19017 va_list ap;
19018 duk_idx_t ret;
19019
19021
19022 va_start(ap, fmt);
19023 ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
19024 va_end(ap);
19025 return ret;
19026}

◆ 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 18947 of file duktape-1.5.2/src/duktape.c.

18955 :
18957 return; /* not reached */
18958
18959 arg_error:
18961 return; /* not reached */
18962}
18963
18964DUK_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) {
18965 duk_hthread *thr = (duk_hthread *) ctx;
18966 duk_idx_t ret;
18968#ifdef DUK_USE_AUGMENT_ERROR_CREATE
18969 duk_bool_t noblame_fileline;
18970#endif
18971
18973 DUK_ASSERT(thr != NULL);
18974 DUK_UNREF(filename);
18975 DUK_UNREF(line);
18976
18977 /* Error code also packs a tracedata related flag. */
18978#ifdef DUK_USE_AUGMENT_ERROR_CREATE
18979 noblame_fileline = err_code & DUK_ERRCODE_FLAG_NOBLAME_FILELINE;
18980#endif
18981 err_code = err_code & (~DUK_ERRCODE_FLAG_NOBLAME_FILELINE);
18982
18983 /* error gets its 'name' from the prototype */
18984 proto = duk_error_prototype_from_code(thr, err_code);
18988 proto);
18989
18990 /* ... and its 'message' from an instance property */
18991 if (fmt) {
18992 duk_push_vsprintf(ctx, fmt, ap);
18994 } else {
18995 /* If no explicit message given, put error code into message field
18996 * (as a number). This is not fully in keeping with the Ecmascript
18997 * error model because messages are supposed to be strings (Error
DUK_EXTERNAL const char * duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap)

Referenced by duk_push_buffer_raw().

◆ duk_push_false()

DUK_EXTERNAL void duk_push_false ( duk_context * ctx)

Definition at line 17952 of file duktape-1.5.2/src/duktape.c.

17953 : 0); /* ensure value is 1 or 0 (not other non-zero) */
17954 tv_slot = thr->valstack_top++;
17955 DUK_TVAL_SET_BOOLEAN(tv_slot, b);
17956}
17957
17959 duk_hthread *thr;
17960 duk_tval *tv_slot;
17961

◆ duk_push_global_object()

DUK_EXTERNAL void duk_push_global_object ( duk_context * ctx)

Definition at line 18305 of file duktape-1.5.2/src/duktape.c.

18309 {

◆ duk_push_global_stash()

DUK_EXTERNAL void duk_push_global_stash ( duk_context * ctx)

Definition at line 18334 of file duktape-1.5.2/src/duktape.c.

◆ duk_push_hbuffer()

DUK_INTERNAL_DECL void duk_push_hbuffer ( duk_context * ctx,
duk_hbuffer * h )

Definition at line 19122 of file duktape-1.5.2/src/duktape.c.

19124 {
19125 duk_hthread *thr = (duk_hthread *) ctx;
19126 DUK_UNREF(thr);
19127 DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS);
19128 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 18324 of file duktape-1.5.2/src/duktape.c.

18329 {
18332 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 19060 of file duktape-1.5.2/src/duktape.c.

19060 {
19062 }
19063
19064 h = duk_hbuffer_alloc(thr->heap, size, flags, &buf_data);
19065 if (!h) {
19067 }
19068
19069 tv_slot = thr->valstack_top;
19070 DUK_TVAL_SET_BUFFER(tv_slot, h);
19071 DUK_HBUFFER_INCREF(thr, h);
19072 thr->valstack_top++;
19073
19074 return (void *) buf_data;
19075}
19076
19078 duk_hthread *thr = (duk_hthread *) ctx;
19079 duk_idx_t ret;
19080
19082
19083 ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
19084
19085 if (ptr == NULL) {
19086 goto push_undefined;
19087 }
19088
19089 switch ((int) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) {
19090 case DUK_HTYPE_STRING:
#define DUK_TVAL_SET_BUFFER(tv, hptr)
DUK_INTERNAL_DECL duk_hbuffer * duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata)
DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr)

References DUK_ERROR_RANGE, and DUK_STR_BUFFER_TOO_LONG.

◆ duk_push_hobject()

DUK_INTERNAL_DECL void duk_push_hobject ( duk_context * ctx,
duk_hobject * h )

◆ duk_push_hobject_bidx()

DUK_INTERNAL_DECL void duk_push_hobject_bidx ( duk_context * ctx,
duk_small_int_t builtin_idx )

Definition at line 19130 of file duktape-1.5.2/src/duktape.c.

19131 {
19132 duk_tval tv;
19134 DUK_ASSERT(h != NULL);
19135 DUK_TVAL_SET_OBJECT(&tv, h);
19136 duk_push_tval(ctx, &tv);
19137}

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 17056 of file duktape-1.5.2/src/duktape.c.

17057 {
17058 duk_hobject *h_obj;
17059
17060 duk_to_object(ctx, -1);
17061 h_obj = duk_get_hobject(ctx, -1);
17062 DUK_ASSERT(h_obj != NULL);
17063
17064 h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_obj);
17065 }
17066 DUK_ASSERT(h_strclass != NULL);
17067
17068 duk_pop(ctx);
#define DUK_HOBJECT_GET_CLASS_STRING(heap, h)

◆ duk_push_hstring()

DUK_INTERNAL_DECL void duk_push_hstring ( duk_context * ctx,
duk_hstring * h )

Definition at line 19099 of file duktape-1.5.2/src/duktape.c.

19099 :
19100 goto push_undefined;
19101 }
19102 return ret;
19103
19104 push_undefined:
19105 duk_push_undefined(ctx);

Referenced by duk__get_own_propdesc_raw(), duk__parse_var_decl(), and duk__realloc_props().

◆ duk_push_hstring_stridx()

◆ duk_push_int()

DUK_EXTERNAL void duk_push_int ( duk_context * ctx,
duk_int_t val )

Definition at line 17978 of file duktape-1.5.2/src/duktape.c.

17981 {
17982 duk_hthread *thr;
17983 duk_tval *tv_slot;
17985
17987 thr = (duk_hthread *) ctx;
17989 du.d = val;
17991 tv_slot = thr->valstack_top++;
17992 DUK_TVAL_SET_NUMBER(tv_slot, du.d);
17993}
17994
17996#if defined(DUK_USE_FASTINT)
17997 duk_hthread *thr;
17998 duk_tval *tv_slot;
17999
18001 thr = (duk_hthread *) ctx;
18003 tv_slot = thr->valstack_top++;
18004#if DUK_INT_MAX <= 0x7fffffffL
18005 DUK_TVAL_SET_FASTINT_I32(tv_slot, (duk_int32_t) val);
18006#else
18007 if (val >= DUK_FASTINT_MIN && val <= DUK_FASTINT_MAX) {
18008 DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
18009 } else {
#define DUK_TVAL_SET_FASTINT_I32(tv, val)

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 19397 of file duktape-1.5.2/src/duktape.c.

19414 {
19415 duk_c_function func;
19416
19418
19419 /* 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 19421 of file duktape-1.5.2/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 18059 of file duktape-1.5.2/src/duktape.c.

18062 {
18063 duk_hthread *thr;
18064 duk_tval *tv_slot;
18066
18068 thr = (duk_hthread *) ctx;
18072 tv_slot = thr->valstack_top++;
18073 DUK_TVAL_SET_NUMBER(tv_slot, du.d);
18074}
18075
18076DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len) {
18077 duk_hthread *thr = (duk_hthread *) ctx;
18078 duk_hstring *h;
18079 duk_tval *tv_slot;
18080
18082
18083 /* check stack before interning (avoid hanging temp) */
18084 if (thr->valstack_top >= thr->valstack_end) {
18086 }
18087
18088 /* NULL with zero length represents an empty string; NULL with higher
18089 * length is also now trated like an empty string although it is
18090 * a bit dubious. This is unlike duk_push_string() which pushes a
18091 * 'null' if the input string is a NULL.
18092 */
18093 if (!str) {

Referenced by duk_push_string_file_raw().

◆ duk_push_nan()

DUK_EXTERNAL void duk_push_nan ( duk_context * ctx)

Definition at line 18045 of file duktape-1.5.2/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 17917 of file duktape-1.5.2/src/duktape.c.

17920 {
17921 duk_hthread *thr;
17922
17924 thr = (duk_hthread *) ctx;
17926

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 17964 of file duktape-1.5.2/src/duktape.c.

17969 {
17970 duk_hthread *thr;
17971 duk_tval *tv_slot;
17972
17974 thr = (duk_hthread *) ctx;
17976 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 18504 of file duktape-1.5.2/src/duktape.c.

18506 {
18507 duk_hthread *thr = (duk_hthread *) ctx;
18508 duk_idx_t ret;
18509 duk_hobject *h;
18510

◆ 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 18449 of file duktape-1.5.2/src/duktape.c.

18452 {
18453 va_list ap;
18454 const char *ret;
18455
18457
18458 /* allow fmt==NULL */
18459 va_start(ap, fmt);
18460 ret = duk_push_vsprintf(ctx, fmt, ap);
18461 va_end(ap);
18462
18463 return ret;
18464}
18465
18466DUK_INTERNAL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) {
18467 duk_hthread *thr = (duk_hthread *) ctx;
18468 duk_tval *tv_slot;
18469 duk_hobject *h;
18470 duk_idx_t ret;
18471
18473 DUK_ASSERT(prototype_bidx == -1 ||
18474 (prototype_bidx >= 0 && prototype_bidx < DUK_NUM_BUILTINS));
18475
18476 /* check stack first */
18477 if (thr->valstack_top >= thr->valstack_end) {
18479 }
18480
18481 h = duk_hobject_alloc(thr->heap, hobject_flags_and_class);
18482 if (!h) {
18484 }
18485
18486 DUK_DDD(DUK_DDDPRINT("created object with flags: 0x%08lx", (unsigned long) h->hdr.h_flags));
18487

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 18489 of file duktape-1.5.2/src/duktape.c.

18496 {
18497 DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[prototype_bidx]);
18498 } else {
18499 DUK_ASSERT(prototype_bidx == -1);
18500 DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL);
18501 }
18502

◆ duk_push_object_internal()

DUK_INTERNAL_DECL duk_idx_t duk_push_object_internal ( duk_context * ctx)

Definition at line 19092 of file duktape-1.5.2/src/duktape.c.

19093 :
19094 duk_push_hobject(ctx, (duk_hobject *) ptr);
19095 break;
19096 case DUK_HTYPE_BUFFER:
19097 duk_push_hbuffer(ctx, (duk_hbuffer *) ptr);

◆ duk_push_pointer()

DUK_EXTERNAL void duk_push_pointer ( duk_context * ctx,
void * val )

Definition at line 18176 of file duktape-1.5.2/src/duktape.c.

18177 {
18178 duk_hthread *thr = (duk_hthread *) ctx;
18180 DUK_UNREF(path);
18181
18182 if (flags != 0) {
18183 DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE); /* only flag now */
18184 duk_push_undefined(ctx);
18185 } else {
#define DUK_STRING_PUSH_SAFE

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 18435 of file duktape-1.5.2/src/duktape.c.

18437 {
18439 }
18440 }
18441
18442 /* Cannot use duk_to_string() on the buffer because it is usually
18443 * larger than 'len'. Also, 'buf' is usually a stack buffer.
18444 */
18445 res = duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len); /* [ buf? res ] */
18446 if (pushed_buf) {
18447 duk_remove(ctx, -2);
#define DUK_STR_SPRINTF_TOO_LONG

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 18095 of file duktape-1.5.2/src/duktape.c.

18098 {
18100 }
18101
18102 h = duk_heap_string_intern_checked(thr, (const duk_uint8_t *) str, (duk_uint32_t) len);
18103 DUK_ASSERT(h != NULL);
18104
#define DUK_STR_STRING_TOO_LONG
DUK_INTERNAL_DECL duk_hstring * duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len)

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 18111 of file duktape-1.5.2/src/duktape.c.

18112 {
18114
18115 if (str) {
18116 return duk_push_lstring(ctx, str, DUK_STRLEN(str));
18117 } else {
18118 duk_push_null(ctx);
18119 return NULL;
18120 }
18121}
18122
18123#ifdef DUK_USE_FILE_IO
18124/* This is a bit clunky because it is ANSI C portable. Should perhaps
18125 * relocate to another file because this is potentially platform
18126 * dependent.
18127 */
18128DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) {
18129 duk_hthread *thr = (duk_hthread *) ctx;
18130 duk_file *f = NULL;
18131 char *buf;
18132 long sz; /* ANSI C typing */
18133
18135
18136 if (!path) {
18137 goto fail;
18138 }
18139 f = DUK_FOPEN(path, "rb");
18140 if (!f) {
18141 goto fail;
18142 }
18143 if (DUK_FSEEK(f, 0, SEEK_END) < 0) {
18144 goto fail;
18145 }
18146 sz = DUK_FTELL(f);
18147 if (sz < 0) {
18148 goto fail;
18149 }
18150 if (DUK_FSEEK(f, 0, SEEK_SET) < 0) {
18151 goto fail;
18152 }
18153 buf = (char *) duk_push_fixed_buffer(ctx, (duk_size_t) sz);
18154 DUK_ASSERT(buf != NULL);
18155 if ((duk_size_t) DUK_FREAD(buf, 1, (size_t) sz, f) != (duk_size_t) sz) {
18156 goto fail;
18157 }
18158 (void) DUK_FCLOSE(f); /* ignore fclose() error */
DUK_EXTERNAL const char * duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags)

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 19437 of file duktape-1.5.2/src/duktape.c.

19438 {
19440
19441 duk_push_string(ctx, "function ");
19442 duk_push_lightfunc_name(ctx, tv);
19443 duk_push_string(ctx, "() {\"light\"}");
19444 duk_concat(ctx, 3);
19445}
19446
19447/*
19448 * Function pointers
19449 *
19450 * Printing function pointers is non-portable, so we do that by hex printing
19451 * bytes from memory.
19452 */
19453
19454DUK_INTERNAL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz) {
19455 duk_uint8_t buf[32 * 2];
19456 duk_uint8_t *p, *q;
19459
19460 DUK_ASSERT(sz <= 32); /* sanity limit for function pointer size */
19461
19462 p = buf;
DUK_INTERNAL_DECL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz)

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 19578 of file duktape-1.5.2/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 19531 of file duktape-1.5.2/src/duktape.c.

19534 {
19535 q += duk_unicode_encode_xutf8(cp, q);
19536 }
19537 } else {
19538 p++; /* advance manually */
19539 *q++ = (duk_uint8_t) DUK_ASC_QUESTION;
19540 }
19541 nchars++;
19542 }
19543 *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE;
19544
19545 duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (q - buf));
19546}
19547
19549 duk_hthread *thr;
19550
19552 thr = (duk_hthread *) ctx;
19553 DUK_UNREF(thr);
19554
19555 if (tv == NULL) {
19556 duk_push_string(ctx, "none");
19557 } else {
19558 switch (DUK_TVAL_GET_TAG(tv)) {
19559 case DUK_TAG_STRING: {
19561 break;
19562 }
19563 case DUK_TAG_OBJECT: {
19565 DUK_ASSERT(h != NULL);
19567 break;
19568 }
19569 case DUK_TAG_BUFFER: {
19570 /* XXX: Hex encoded, length limited buffer summary here? */
19572 DUK_ASSERT(h != NULL);
19573 duk_push_sprintf(ctx, "[buffer:%ld]", (long) DUK_HBUFFER_GET_SIZE(h));
19574 break;
19575 }
19576 case DUK_TAG_POINTER: {
DUK_LOCAL void duk__push_hstring_readable_unicode(duk_context *ctx, duk_hstring *h_input)
DUK_INTERNAL_DECL void duk_push_hobject_class_string(duk_context *ctx, duk_hobject *h)

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 18226 of file duktape-1.5.2/src/duktape.c.

18229 {
18230 /* 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 18232 of file duktape-1.5.2/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 18238 of file duktape-1.5.2/src/duktape.c.

18239 :
18241}
18242
18245
18246 duk__push_this_helper(ctx, 0 /*check_object_coercible*/);
18247}
18248
#define DUK_STR_NOT_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 18250 of file duktape-1.5.2/src/duktape.c.

18255 {
18256 duk_hobject *h;
18257
18259
18260 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 18551 of file duktape-1.5.2/src/duktape.c.

18568 {
18569 duk_hthread *thr = (duk_hthread *) ctx;
18570 duk_hthread *obj;
18571 duk_idx_t ret;
18572 duk_tval *tv_slot;
18573
18575
18576 /* check stack first */
18577 if (thr->valstack_top >= thr->valstack_end) {
18579 }
18580
18581 obj = duk_hthread_alloc(thr->heap,
18585 if (!obj) {
18587 }
18589#if defined(DUK_USE_ROM_STRINGS)
18590 /* Nothing to initialize, strs[] is in ROM. */
18591#else
18592#if defined(DUK_USE_HEAPPTR16)
18593 obj->strs16 = thr->strs16;
18594#else
18595 obj->strs = thr->strs;
18596#endif
18597#endif
18598 DUK_DDD(DUK_DDDPRINT("created thread object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
18599
18600 /* make the new thread reachable */
18601 tv_slot = thr->valstack_top;
18602 DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
18603 DUK_HTHREAD_INCREF(thr, obj);
18604 ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
18605 thr->valstack_top++;
18606
18607 /* important to do this *after* pushing, to make the thread reachable for gc */
18608 if (!duk_hthread_init_stacks(thr->heap, obj)) {
18610 }
18611
18612 /* initialize built-ins - either by copying or creating new ones */
DUK_INTERNAL_DECL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr)
#define DUK_HTHREAD_INCREF(thr, h)

◆ duk_push_thread_stash()

DUK_EXTERNAL void duk_push_thread_stash ( duk_context * ctx,
duk_context * target_ctx )

Definition at line 18340 of file duktape-1.5.2/src/duktape.c.

18341 {
18342 duk_hthread *thr = (duk_hthread *) ctx;
18343 duk_heap *heap;
18345 heap = thr->heap;
18346 DUK_ASSERT(heap->heap_object != NULL);
18347 duk_push_hobject(ctx, heap->heap_object);
18348 duk__push_stash(ctx);
18349}

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 17941 of file duktape-1.5.2/src/duktape.c.

17945 {
17946 duk_hthread *thr;
17947 duk_tval *tv_slot;
17949

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 17890 of file duktape-1.5.2/src/duktape.c.

17890 {
17891 return DUK_ERR_URI_ERROR;
17892 }
17893 if (h == thr->builtins[DUK_BIDX_ERROR_PROTOTYPE]) {
17894 return DUK_ERR_ERROR;
17895 }
17896
17897 h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
17898 } while (--sanity > 0);
17899
17900 return DUK_ERR_NONE;
17901}

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 18011 of file duktape-1.5.2/src/duktape.c.

18028 {
18029#if defined(DUK_USE_FASTINT)
18030 duk_hthread *thr;
18031 duk_tval *tv_slot;
18032
18034 thr = (duk_hthread *) ctx;
18036 tv_slot = thr->valstack_top++;
18037#if DUK_UINT_MAX <= 0xffffffffUL
18038 DUK_TVAL_SET_FASTINT_U32(tv_slot, (duk_uint32_t) val);
18039#else
18040 if (val <= DUK_FASTINT_MAX) { /* val is unsigned so >= 0 */
18041 /* XXX: take advantage of val being unsigned, no need to mask */
18042 DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
18043 } 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)

◆ duk_push_vsprintf()

DUK_EXTERNAL const char * duk_push_vsprintf ( duk_context * ctx,
const char * fmt,
va_list ap )

Definition at line 18369 of file duktape-1.5.2/src/duktape.c.

18369 {
18370 duk_int_t len;
18371
18373 DUK_UNREF(ctx);
18374
18375 /* NUL terminator handling doesn't matter here */
18376 len = DUK_VSNPRINTF((char *) buf, sz, fmt, ap);
18377 if (len < (duk_int_t) sz) {
18378 /* Return value of 'sz' or more indicates output was (potentially)
18379 * truncated.
18380 */
18381 return (duk_int_t) len;
18382 }
18383 return -1;
18384}
18385
18386DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap) {
18387 duk_hthread *thr = (duk_hthread *) ctx;
18388 duk_uint8_t stack_buf[DUK_PUSH_SPRINTF_INITIAL_SIZE];
18390 duk_bool_t pushed_buf = 0;
18391 void *buf;
18392 duk_int_t len; /* XXX: duk_ssize_t */
18393 const char *res;
18394
18396
18397 /* special handling of fmt==NULL */
18398 if (!fmt) {
18399 duk_hstring *h_str;
18401 h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr); /* rely on interning, must be this string */
18402 return (const char *) DUK_HSTRING_GET_DATA(h_str);
18403 }
18404
18405 /* initial estimate based on format string */
18406 sz = DUK_STRLEN(fmt) + 16; /* format plus something to avoid just missing */
18409 }
18410 DUK_ASSERT(sz > 0);
18411
18412 /* Try to make do with a stack buffer to avoid allocating a temporary buffer.
18413 * This works 99% of the time which is quite nice.
18414 */
18415 for (;;) {
18416 va_list ap_copy; /* copied so that 'ap' can be reused */
18417
18418 if (sz <= sizeof(stack_buf)) {
18419 buf = stack_buf;
18420 } else if (!pushed_buf) {
18421 pushed_buf = 1;
18422 buf = duk_push_dynamic_buffer(ctx, sz);
18423 } else {
18424 buf = duk_resize_buffer(ctx, -1, sz);
18425 }
18426 DUK_ASSERT(buf != NULL);
18427
18428 DUK_VA_COPY(ap_copy, ap);
18429 len = duk__try_push_vsprintf(ctx, buf, sz, fmt, ap_copy);
18430 va_end(ap_copy);
18431 if (len >= 0) {
18432 break;
18433 }
#define DUK_VA_COPY(dest, src)
DUK_LOCAL duk_int_t duk__try_push_vsprintf(duk_context *ctx, void *buf, duk_size_t sz, const char *fmt, va_list ap)
#define DUK_PUSH_SPRINTF_INITIAL_SIZE

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 14793 of file duktape-1.5.2/src/duktape.c.

14798 {
14800
14801 duk_require_hobject(ctx, enum_index);
14802 duk_dup(ctx, enum_index);
14803 return duk_hobject_enumerator_next(ctx, get_value);
14804}
14805
14806/*

◆ duk_put_global_string()

DUK_EXTERNAL duk_bool_t duk_put_global_string ( duk_context * ctx,
const char * key )

Definition at line 14842 of file duktape-1.5.2/src/duktape.c.

14844 {
14845 duk_hthread *thr = (duk_hthread *) ctx;
14846 duk_bool_t ret;
14847
14850
14851 /* XXX: direct implementation */
14852
14854 ret = duk_get_prop_string(ctx, -1, key);
14855 duk_remove(ctx, -2);
14856 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_put_prop()

DUK_EXTERNAL duk_bool_t duk_put_prop ( duk_context * ctx,
duk_idx_t obj_idx )

◆ 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 14450 of file duktape-1.5.2/src/duktape.c.

14454 {
14456 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 14458 of file duktape-1.5.2/src/duktape.c.

14467 {
14469

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 14437 of file duktape-1.5.2/src/duktape.c.

Referenced by duk_put_number_list().

◆ duk_put_var()

DUK_EXTERNAL void duk_put_var ( duk_context * ctx)

Definition at line 19959 of file duktape-1.5.2/src/duktape.c.

19976 {
19977 duk_hthread *thr = (duk_hthread *) ctx;
19978 duk_activation *act;
19979 duk_hstring *h_varname;
19980 duk_tval *tv_val;
19981 duk_small_int_t throw_flag;
19982
19984
19985 h_varname = duk_require_hstring(ctx, -2); /* XXX: tostring? */
19986 DUK_ASSERT(h_varname != NULL);
19987
19988 tv_val = duk_require_tval(ctx, -1);
19989
19990 throw_flag = duk_is_strict_call(ctx);
19991

◆ duk_raw_read_double_be()

DUK_INTERNAL_DECL duk_double_t duk_raw_read_double_be ( duk_uint8_t ** p)

Definition at line 86501 of file duktape-1.5.2/src/duktape.c.

86506 {
86507 union {
86508 duk_uint8_t b[4];
86509 duk_uint32_t x;
86510 } u;
86511
86512 DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
86513 u.x = DUK_NTOH32(u.x);
86514 *p += 4;
86515 return u.x;
86516}
86517

◆ duk_raw_read_u16_be()

DUK_INTERNAL_DECL duk_uint16_t duk_raw_read_u16_be ( duk_uint8_t ** p)

Definition at line 86477 of file duktape-1.5.2/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 86489 of file duktape-1.5.2/src/duktape.c.

86494 {
86495 union {
86496 duk_uint8_t b[2];
86497 duk_uint16_t x;
86498 } u;
86499

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 86541 of file duktape-1.5.2/src/duktape.c.

86547 {
86548 union {
86549 duk_uint8_t b[4];
86550 duk_uint32_t x;
86551 } u;
86552
86553 u.x = DUK_HTON32(val);
86554 DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4);
86555 *p += 4;
86556}

◆ 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 86519 of file duktape-1.5.2/src/duktape.c.

86520 {
86521 duk_uint8_t b[4];
86522 duk_uint32_t x;
86523 } u;
86524
86525 DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
86526 u.x = DUK_NTOH32(u.x);
86527 du.ui[DUK_DBL_IDX_UI0] = u.x;
86528 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 86530 of file duktape-1.5.2/src/duktape.c.

86536 {
86537 union {
86538 duk_uint8_t b[2];
86539 duk_uint16_t x;

◆ duk_realloc()

DUK_EXTERNAL void * duk_realloc ( duk_context * ctx,
void * ptr,
duk_size_t size )

Definition at line 14260 of file duktape-1.5.2/src/duktape.c.

14261 {
14262 duk_hthread *thr = (duk_hthread *) ctx;
14263
14265
14266 return DUK_ALLOC(thr->heap, size);
14267}
14268
14269DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) {
14270 duk_hthread *thr = (duk_hthread *) ctx;
14271
14273
14274 DUK_FREE(thr->heap, ptr);
14275}
14276
DUK_EXTERNAL void duk_free(duk_context *ctx, void *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 14236 of file duktape-1.5.2/src/duktape.c.

14237 {
14238 duk_hthread *thr = (duk_hthread *) ctx;
14239
14241
14242 return DUK_ALLOC_RAW(thr->heap, size);
#define DUK_ALLOC_RAW(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 78262 of file duktape-1.5.2/src/duktape.c.

78279 {
78280 duk_context *ctx = (duk_context *) thr;
78281 duk_re_compiler_ctx re_ctx;
78282 duk_lexer_point lex_point;
78283 duk_hstring *h_pattern;
78284 duk_hstring *h_flags;
78285 duk__re_disjunction_info ign_disj;
78286
78287 DUK_ASSERT(thr != NULL);
78288 DUK_ASSERT(ctx != NULL);
78289
78290 /*
78291 * Args validation
78292 */
78293
78294 /* TypeError if fails */
78295 h_pattern = duk_require_hstring(ctx, -2);
78296 h_flags = duk_require_hstring(ctx, -1);
78297
78298 /*
78299 * Create normalized 'source' property (E5 Section 15.10.3).
78300 */
78301
78302 /* [ ... pattern flags ] */
78303
78305
78306 /* [ ... pattern flags escaped_source ] */
78307
78308 /*
78309 * Init compilation context
78310 */
78311
78312 /* [ ... pattern flags escaped_source buffer ] */
78313
78314 DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
78315 DUK_LEXER_INITCTX(&re_ctx.lex); /* duplicate zeroing, expect for (possible) NULL inits */
78316 re_ctx.thr = thr;
78317 re_ctx.lex.thr = thr;
78318 re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern);
78319 re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern);
78322 re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags);
78323
78325
78326 DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld",
78327 (unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit));
78328
78329 /*
78330 * Init lexer
78331 */
78332
78333 lex_point.offset = 0; /* expensive init, just want to fill window */
78334 lex_point.line = 1;
78335 DUK_LEXER_SETPOINT(&re_ctx.lex, &lex_point);
78336
78337 /*
78338 * Compilation
78339 */
78340
78341 DUK_DD(DUK_DDPRINT("starting regexp compilation"));
78342
78344 duk__append_u32(&re_ctx, 0);
78345 duk__parse_disjunction(&re_ctx, 1 /*expect_eof*/, &ign_disj);
78347 duk__append_u32(&re_ctx, 1);
78349
78350 /*
78351 * Check for invalid backreferences; note that it is NOT an error
78352 * to back-reference a capture group which has not yet been introduced
78353 * in the pattern (as in /\1(foo)/); in fact, the backreference will
78354 * always match! It IS an error to back-reference a capture group
78355 * which will never be introduced in the pattern. Thus, we can check
78356 * for such references only after parsing is complete.
78357 */
78358
78359 if (re_ctx.highest_backref > re_ctx.captures) {
78361 }
78362
78363 /*
78364 * Emit compiled regexp header: flags, ncaptures
78365 * (insertion order inverted on purpose)
78366 */
78367
78368 duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2);
78369 duk__insert_u32(&re_ctx, 0, re_ctx.re_flags);
78370
#define DUK_USE_REGEXP_COMPILER_RECLIMIT
DUK_LOCAL duk_uint32_t duk__parse_regexp_flags(duk_hthread *thr, duk_hstring *h)
#define DUK_RE_COMPILE_TOKEN_LIMIT
DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern)
#define DUK__RE_INITIAL_BUFSIZE
#define DUK_STR_INVALID_BACKREFS

◆ duk_regexp_create_instance()

DUK_INTERNAL_DECL void duk_regexp_create_instance ( duk_hthread * thr)

Definition at line 78382 of file duktape-1.5.2/src/duktape.c.

78385 : %!T, escaped source: %!T",
78386 (duk_tval *) duk_get_tval(ctx, -1), (duk_tval *) duk_get_tval(ctx, -2)));
78387}
78388
78389/*
78390 * Create a RegExp instance (E5 Section 15.10.7).
78391 *
78392 * Note: the output stack left by duk_regexp_compile() is directly compatible
78393 * with the input here.
78394 *
78395 * Input stack: [ escaped_source bytecode ] (both as strings)
78396 * Output stack: [ RegExp ]
78397 */
78398
78399DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) {
78400 duk_context *ctx = (duk_context *) thr;
78401 duk_hobject *h;
78402 duk_hstring *h_bc;
78403 duk_small_int_t re_flags;
78404
78405 /* [ ... escape_source bytecode ] */
78406
78407 h_bc = duk_get_hstring(ctx, -1);
78408 DUK_ASSERT(h_bc != NULL);
78409 DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1); /* always at least the header */
78410 DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
78411 DUK_ASSERT((duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80); /* flags always encodes to 1 byte */
78412 re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
78413
78414 /* [ ... escaped_source bytecode ] */
78415
78416 duk_push_object(ctx);
78417 h = duk_get_hobject(ctx, -1);
78418 DUK_ASSERT(h != NULL);
78419 duk_insert(ctx, -3);
78420
78421 /* [ ... regexp_object escaped_source bytecode ] */
78422
78423 DUK_HOBJECT_SET_CLASS_NUMBER(h, DUK_HOBJECT_CLASS_REGEXP);
78424 DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[DUK_BIDX_REGEXP_PROTOTYPE]);
78425
78426 duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_BYTECODE, DUK_PROPDESC_FLAGS_NONE);
78427
78428 /* [ ... regexp_object escaped_source ] */
78429
78430 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 79432 of file duktape-1.5.2/src/duktape.c.

◆ duk_regexp_match_force_global()

DUK_INTERNAL_DECL void duk_regexp_match_force_global ( duk_hthread * thr)

Definition at line 79439 of file duktape-1.5.2/src/duktape.c.

◆ duk_remove()

DUK_EXTERNAL void duk_remove ( duk_context * ctx,
duk_idx_t index )

Definition at line 15875 of file duktape-1.5.2/src/duktape.c.

15875 {
15876 duk_hthread *thr = (duk_hthread *) ctx;
15877 duk_tval *tv1;
15878 duk_tval *tv2;
15879
15881 DUK_UNREF(thr); /* w/o refcounting */
15882
15883 tv1 = duk_require_tval(ctx, from_index);
15884 DUK_ASSERT(tv1 != NULL);
15885 tv2 = duk_require_tval(ctx, to_index);
15886 DUK_ASSERT(tv2 != NULL);
15887
15888 /* For tv1 == tv2, this is a no-op (no explicit check needed). */
15889 DUK_TVAL_SET_TVAL_UPDREF(thr, tv2, tv1); /* side effects */
15890}
15891
15893 duk_hthread *thr = (duk_hthread *) ctx;
15894 duk_tval *p;
15895 duk_tval *q;
15896#ifdef DUK_USE_REFERENCE_COUNTING
15897 duk_tval tv_tmp;
15898#endif
15899 duk_size_t nbytes;
15900
15902
15903 p = duk_require_tval(ctx, index);
15904 DUK_ASSERT(p != NULL);
15905 q = duk_require_tval(ctx, -1);
15906 DUK_ASSERT(q != NULL);
15907
15908 DUK_ASSERT(q >= p);
15909
15910 /* nbytes zero size case
15911 * <--------->
15912 * [ ... | p | x | x | q ] [ ... | p==q ]
15913 * => [ ... | 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 8661 of file duktape-1.5.2/src/duktape.c.

8678 {
8680 duk_uint_fast16_t expt;
8681 duk_small_int_t mzero;
8682
8683 u.d = x;
8684 expt = (duk_uint_fast16_t) (u.us[DUK_DBL_IDX_US0] & 0x7ff0UL);
8685 if (expt > 0x0000UL && expt < 0x7ff0UL) {
8686 /* expt values [0x001,0x7fe] = normal */
8687 return DUK_FP_NORMAL;
8688 }
8689
duk_uint16_t duk_uint_fast16_t

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 8701 of file duktape-1.5.2/src/duktape.c.

8702 {
8703 return DUK_FP_NAN;
8704 }
8705 }
8706}
8707#endif
8708

◆ duk_repl_isinf()

DUK_INTERNAL int duk_repl_isinf ( double x)

Definition at line 8719 of file duktape-1.5.2/src/duktape.c.

8720 {
8721 return 0;
8722 } else {

◆ duk_repl_isnan()

DUK_INTERNAL int duk_repl_isnan ( double x)

Definition at line 8712 of file duktape-1.5.2/src/duktape.c.

◆ duk_repl_signbit()

DUK_INTERNAL int duk_repl_signbit ( double x)

Definition at line 8693 of file duktape-1.5.2/src/duktape.c.

8693 {
8694 return DUK_FP_ZERO;
8695 } else {
8696 return DUK_FP_SUBNORMAL;
8697 }

References DUK_FP_ZERO.

◆ duk_replace()

DUK_EXTERNAL void duk_replace ( duk_context * ctx,
duk_idx_t to_index )

Definition at line 15835 of file duktape-1.5.2/src/duktape.c.

15835 : to_index=%ld, p=%p, q=%p, nbytes=%lu",
15836 (long) to_index, (void *) p, (void *) q, (unsigned long) nbytes));
15837
15838 /* No net refcount changes. */
15839
15840 if (nbytes > 0) {
15841 DUK_TVAL_SET_TVAL(&tv_tmp, q);
15842 DUK_ASSERT(nbytes > 0);
15843 DUK_MEMMOVE((void *) (p + 1), (const void *) p, (size_t) nbytes);
15844 DUK_TVAL_SET_TVAL(p, &tv_tmp);
15845 } else {
15846 /* nop: insert top to top */
15847 DUK_ASSERT(nbytes == 0);
15848 DUK_ASSERT(p == q);
15849 }
15850}
15851
15852DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) {
15853 duk_hthread *thr = (duk_hthread *) ctx;
15854 duk_tval *tv1;
15855 duk_tval *tv2;
15856 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 16035 of file duktape-1.5.2/src/duktape.c.

16037 {
16038 duk_bool_t ret = 0; /* default: false */
16039 duk_tval *tv;
16040
16042
16043 tv = duk_get_tval(ctx, index);
16044 if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
16045 ret = DUK_TVAL_GET_BOOLEAN(tv);
16046 }
16047
16048 DUK_ASSERT(ret == 0 || ret == 1);
16049 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 16256 of file duktape-1.5.2/src/duktape.c.

16257 {
16258 *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 16318 of file duktape-1.5.2/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 16459 of file duktape-1.5.2/src/duktape.c.

16461 {
16462 return NULL;
16463 }
16464 h = DUK_TVAL_GET_OBJECT(tv);
16465 DUK_ASSERT(h != NULL);
16466
16468 return NULL;
16469 }

◆ duk_require_context()

DUK_EXTERNAL duk_context * duk_require_context ( duk_context * ctx,
duk_idx_t index )

Definition at line 16484 of file duktape-1.5.2/src/duktape.c.

◆ duk_require_function()

DUK_EXTERNAL void duk_require_function ( duk_context * ctx,
duk_idx_t index )

Definition at line 16472 of file duktape-1.5.2/src/duktape.c.

16476 {

◆ duk_require_hbuffer()

DUK_INTERNAL_DECL duk_hbuffer * duk_require_hbuffer ( duk_context * ctx,
duk_idx_t index )

◆ duk_require_hcompiledfunction()

DUK_INTERNAL_DECL duk_hcompiledfunction * duk_require_hcompiledfunction ( duk_context * ctx,
duk_idx_t index )

◆ duk_require_heapptr()

DUK_EXTERNAL void * duk_require_heapptr ( duk_context * ctx,
duk_idx_t index )

Definition at line 16506 of file duktape-1.5.2/src/duktape.c.

16507 {
16508 duk_tval *tv;
16509 void *ret;
16510
16512
16513 tv = duk_get_tval(ctx, index);
16514 if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
16515 ret = (void *) DUK_TVAL_GET_HEAPHDR(tv);
16516 DUK_ASSERT(ret != NULL);
16517 return ret;
16518 }
16519
16520 return (void *) NULL;
16521}
16522
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_require_hobject()

◆ 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 16558 of file duktape-1.5.2/src/duktape.c.

16562 {
16563 return DUK_TVAL_GET_OBJECT(tv);
16564 } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
16565 duk_to_object(ctx, index);
16566 return duk_require_hobject(ctx, index);
16567 }
16568
16569 return NULL;
16570}
16571
16572/* Useful for internal call sites where we either expect an object (function)
16573 * 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 16579 of file duktape-1.5.2/src/duktape.c.

16583 {
16584 return DUK_TVAL_GET_OBJECT(tv);
16585 } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
16586 return NULL;
16587 }
16589 return NULL; /* not reachable */
16590}
16591
16592/* Useful for internal call sites where we either expect an object (function)
16593 * or a lightfunc. Accepts an object (returned as is) or a lightfunc (coerced
16594 * to an object). Return value is never NULL.
#define DUK_STR_NOT_OBJECT

◆ 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 16610 of file duktape-1.5.2/src/duktape.c.

16613 {
16614 duk_hobject *h;
16615
16617 DUK_ASSERT_DISABLE(classnum >= 0); /* unsigned */
16618 DUK_ASSERT(classnum <= DUK_HOBJECT_CLASS_MAX);
16619
16621 if (h != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(h) != classnum) {
16622 h = NULL;
16623 }
16624 return h;
16625}
16626
16628 duk_hthread *thr;
#define DUK_HOBJECT_CLASS_MAX

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 16347 of file duktape-1.5.2/src/duktape.c.

16350 {
16351 duk_heaphdr *ret;
16352 ret = DUK_TVAL_GET_HEAPHDR(tv);
16353 DUK_ASSERT(ret != NULL); /* tagged null pointers should never occur */
16354 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 16390 of file duktape-1.5.2/src/duktape.c.

16390 {
16391 duk_heaphdr *h;
16393 if (h == NULL) {
16395 }
16396 return (duk_hbuffer *) h;
16397}

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 16107 of file duktape-1.5.2/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 16147 of file duktape-1.5.2/src/duktape.c.

16149 {
16150 /* Here we rely on duk_hstring instances always being zero
16151 * terminated even if the actual string is not.
16152 */
16154 DUK_ASSERT(h != NULL);
16155 ret = (const char *) DUK_HSTRING_GET_DATA(h);
16156 if (out_len) {
16157 *out_len = DUK_HSTRING_GET_BYTELEN(h);
16158 }
16159 }
16160
16161 return ret;
16162}

◆ duk_require_normalize_index()

DUK_EXTERNAL duk_idx_t duk_require_normalize_index ( duk_context * ctx,
duk_idx_t index )

Definition at line 15147 of file duktape-1.5.2/src/duktape.c.

15147 {
15148 uindex = vs_size + (duk_uidx_t) index;
15149 } else {
15150 /* since index non-negative */
15152 uindex = (duk_uidx_t) index;
15153 }
15154
15155 /* DUK_INVALID_INDEX won't be accepted as a valid index. */
15156 DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
15157
15158 if (DUK_LIKELY(uindex < vs_size)) {
15159 return (duk_idx_t) uindex;
15160 }
15161 return DUK_INVALID_INDEX;
15162}
15163
15165 duk_hthread *thr = (duk_hthread *) ctx;
15166 duk_uidx_t vs_size;
15167 duk_uidx_t uindex;
15168
15171
15173 vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
15174 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_pcall(), 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 16006 of file duktape-1.5.2/src/duktape.c.

16009 {
16010 duk_hthread *thr = (duk_hthread *) ctx;
16011 duk_tval *tv;
16012
16014
16015 tv = duk_get_tval(ctx, index);
16016 if (tv && DUK_TVAL_IS_UNDEFINED(tv)) {
16017 return;
16018 }

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 16072 of file duktape-1.5.2/src/duktape.c.

16076 {
16077 ret.d = DUK_TVAL_GET_NUMBER(tv);
16078 }
16079
16080 /*
16081 * Number should already be in NaN-normalized form, but let's
16082 * normalize anyway.
16083 */
16084
16086 return ret.d;
16087}
16088
16090 duk_hthread *thr = (duk_hthread *) ctx;
16091 duk_tval *tv;
16092

◆ duk_require_pointer()

DUK_EXTERNAL void * duk_require_pointer ( duk_context * ctx,
duk_idx_t index )

Definition at line 16190 of file duktape-1.5.2/src/duktape.c.

16193 {
16194 duk_tval *tv;
16195
16197
16198 tv = duk_get_tval(ctx, index);
16199 if (tv && DUK_TVAL_IS_POINTER(tv)) {
16200 void *p = DUK_TVAL_GET_POINTER(tv); /* may be NULL */
16201 return (void *) p;
16202 }
16203
16204 return NULL;
16205}
16206

◆ duk_require_stack()

DUK_EXTERNAL void duk_require_stack ( duk_context * ctx,
duk_idx_t extra )

Definition at line 15667 of file duktape-1.5.2/src/duktape.c.

15669 {
15670 /* Clamping to zero makes the API more robust to calling code
15671 * calculation errors.
15672 */
15673 extra = 0;
15674 }
15675
15676 min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
15677 return duk_valstack_resize_raw(ctx,
15678 min_new_size, /* min_new_size */
15679 0 /* no shrink */ | /* flags */
15680 0 /* no compact */ |
15681 0 /* no throw */);
15682}
15683
15685 duk_hthread *thr = (duk_hthread *) ctx;
15686 duk_size_t min_new_size;
15687

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 15709 of file duktape-1.5.2/src/duktape.c.

15711 {
15712 /* Clamping to zero makes the API more robust to calling code
15713 * calculation errors.
15714 */
15715 top = 0;
15716 }
15717
15718 min_new_size = top + DUK_VALSTACK_INTERNAL_EXTRA;
15719 return duk_valstack_resize_raw(ctx,
15720 min_new_size, /* min_new_size */
15721 0 /* no shrink */ | /* flags */
15722 0 /* no compact */ |
15723 0 /* no throw */);
15724}
15725
15727 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 16170 of file duktape-1.5.2/src/duktape.c.

16174 {

◆ duk_require_top_index()

DUK_EXTERNAL duk_idx_t duk_require_top_index ( duk_context * ctx)

Definition at line 15379 of file duktape-1.5.2/src/duktape.c.

15379 {
15380 duk_hthread *thr = (duk_hthread *) ctx;
15381 duk_idx_t ret;
15382
15384
15385 ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
15386 if (DUK_UNLIKELY(ret < 0)) {
15387 /* Return invalid index; if caller uses this without checking
15388 * in another API call, the index won't map to a valid stack
15389 * entry.
15390 */
15391 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 15204 of file duktape-1.5.2/src/duktape.c.

15205 {
15206 uindex = vs_size + (duk_uidx_t) index;
15207 } else {
15209 uindex = (duk_uidx_t) index;
15210 }
15211
15212 /* DUK_INVALID_INDEX won't be accepted as a valid index. */
15213 DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
15214
15215 if (DUK_LIKELY(uindex < vs_size)) {
15216 return thr->valstack_bottom + uindex;
15217 }
15218 return NULL;
15219}
15220
15222 duk_hthread *thr = (duk_hthread *) ctx;
15223 duk_uidx_t vs_size;
15224 duk_uidx_t uindex;
15225
15228
15230 vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
15231 DUK_ASSERT_DISABLE(vs_size >= 0); /* unsigned */
15232

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 16113 of file duktape-1.5.2/src/duktape.c.

◆ duk_require_undefined()

DUK_EXTERNAL void duk_require_undefined ( duk_context * ctx,
duk_idx_t index )

Definition at line 15992 of file duktape-1.5.2/src/duktape.c.

15997 {
15998 p--;
16000 /* XXX: fast primitive to set a bunch of values to UNDEFINED */
16001 }
16002 }
16003}
16004

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 15243 of file duktape-1.5.2/src/duktape.c.

15244 {
15245 return thr->valstack_bottom + uindex;
15246 }
15248 return NULL;
15249}
15250
15251/* Non-critical. */

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 11576 of file duktape-1.5.2/src/duktape.c.

11580 {
11581 DUK_DDD(DUK_DDDPRINT("default free function: %p", (void *) ptr));
11582 DUK_UNREF(udata);
11583 DUK_ANSI_FREE(ptr);
11584}
11585#endif /* DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS */
11586#line 1 "duk_api_buffer.c"
11587/*
11588 * Buffer
11589 */
11590
11591/* include removed: duk_internal.h */
11592

◆ 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 12575 of file duktape-1.5.2/src/duktape.c.

12592 {
12593 duk_hthread *thr = (duk_hthread *) ctx;
12594 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 16984 of file duktape-1.5.2/src/duktape.c.

16987 {
16989
16990 (void) duk_to_string(ctx, index);
16991 return duk_require_lstring(ctx, index, out_len);
16992}
16993
16996
16997 duk_to_string(ctx, -1);
16998 return 1;
16999}
17000
17003
17005
17006 /* We intentionally ignore the duk_safe_call() return value and only
17007 * check the output type. This way we don't also need to check that
17008 * the returned value is indeed a string in the success case.
17009 */
17010
17011 duk_dup(ctx, index);
17012 (void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/);
17013 if (!duk_is_string(ctx, -1)) {
17014 /* Error: try coercing error to string once. */
DUK_EXTERNAL const char * duk_safe_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_set_finalizer()

DUK_EXTERNAL void duk_set_finalizer ( duk_context * ctx,
duk_idx_t index )

Definition at line 14923 of file duktape-1.5.2/src/duktape.c.

◆ duk_set_global_object()

DUK_EXTERNAL void duk_set_global_object ( duk_context * ctx)

Definition at line 14098 of file duktape-1.5.2/src/duktape.c.

14101 {
14102 duk_hthread *thr = (duk_hthread *) ctx;
14103 duk_heap *heap;
14104
14105 if (!ctx) {
14106 return;
14107 }
14108 heap = thr->heap;
14109 DUK_ASSERT(heap != NULL);
14110
14111 duk_heap_free(heap);
14112}
14113
14114/* XXX: better place for this */
14116 duk_hthread *thr = (duk_hthread *) ctx;
14117 duk_hobject *h_glob;
14118 duk_hobject *h_prev_glob;
14119 duk_hobject *h_env;
14120 duk_hobject *h_prev_env;
14121
14122 DUK_D(DUK_DPRINT("replace global object with: %!T", duk_get_tval(ctx, -1)));
14123
14124 h_glob = duk_require_hobject(ctx, -1);
14125 DUK_ASSERT(h_glob != NULL);
14126
14127 /*
14128 * Replace global object.
14129 */
14130
14131 h_prev_glob = thr->builtins[DUK_BIDX_GLOBAL];
14132 DUK_UNREF(h_prev_glob);
14133 thr->builtins[DUK_BIDX_GLOBAL] = h_glob;
14134 DUK_HOBJECT_INCREF(thr, h_glob);
14135 DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_glob); /* side effects, in theory (referenced by global env) */
14136
14137 /*
14138 * Replace lexical environment for global scope
14139 *
14140 * Create a new object environment for the global lexical scope.
14141 * We can't just reset the _Target property of the current one,
14142 * because the lexical scope is shared by other threads with the
14143 * same (initial) built-ins.
14144 */
14145
14146 (void) duk_push_object_helper(ctx,
14149 -1); /* no prototype, updated below */
14150
14151 duk_dup(ctx, -2);
14152 duk_dup(ctx, -3);
14153
14154 /* [ ... new_glob new_env new_glob new_glob ] */
14155
14158
14159 /* [ ... new_glob new_env ] */
DUK_EXTERNAL void duk_set_global_object(duk_context *ctx)

◆ duk_set_length()

DUK_INTERNAL_DECL void duk_set_length ( duk_context * ctx,
duk_idx_t index,
duk_size_t length )

Definition at line 16679 of file duktape-1.5.2/src/duktape.c.

16684 :
16685#endif
16686 default:
16687 /* number */
16690 return 0;
16691 }

◆ duk_set_magic()

DUK_EXTERNAL void duk_set_magic ( duk_context * ctx,
duk_idx_t index,
duk_int_t magic )

Definition at line 12918 of file duktape-1.5.2/src/duktape.c.

12920 {
12921 goto type_error;
12922 }
12923 return (duk_int_t) ((duk_hnativefunction *) h)->magic;
12924 } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
12926 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 14882 of file duktape-1.5.2/src/duktape.c.

14892 {
14893 duk_push_hobject(ctx, proto);
14894 } else {
14895 duk_push_undefined(ctx);
14896 }
14897}
14898
14900 duk_hthread *thr = (duk_hthread *) ctx;
14901 duk_hobject *obj;
14903
14905
14906 obj = duk_require_hobject(ctx, index);
DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index)

◆ duk_set_top()

DUK_EXTERNAL void duk_set_top ( duk_context * ctx,
duk_idx_t index )

Definition at line 15271 of file duktape-1.5.2/src/duktape.c.

15276 {
15277 duk_hthread *thr = (duk_hthread *) ctx;
15278
15280
15281 return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
15282}
15283
15284/* Set stack top within currently allocated range, but don't reallocate.
15285 * This is performance critical especially for call handling, so whenever
15286 * changing, profile and look at generated code.
15287 */
15289 duk_hthread *thr = (duk_hthread *) ctx;
15290 duk_uidx_t vs_size;
15291 duk_uidx_t vs_limit;
15292 duk_uidx_t uindex;
15293 duk_tval *tv;
15294
15297
15300 vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
15301 vs_limit = (duk_uidx_t) (thr->valstack_end - thr->valstack_bottom);
15302
15303 if (index < 0) {
15304 /* Negative indices are always within allocated stack but
15305 * must not go below zero index.
15306 */
15307 uindex = vs_size + (duk_uidx_t) index;
15308 } else {
15309 /* Positive index can be higher than valstack top but must
15310 * not go above allocated stack (equality is OK).
15311 */
15312 uindex = (duk_uidx_t) index;
15313 }
15314
15315 /* DUK_INVALID_INDEX won't be accepted as a valid index. */
15316 DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
15317 DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_limit);
15318
15319#if defined(DUK_USE_VALSTACK_UNSAFE)
15320 DUK_ASSERT(uindex <= vs_limit);
15321 DUK_UNREF(vs_limit);
15322#else
15323 if (DUK_UNLIKELY(uindex > vs_limit)) {
15325 return; /* unreachable */
15326 }
15327#endif
15328 DUK_ASSERT(uindex <= vs_limit);
15329
15330 /* Handle change in value stack top. Respect value stack
15331 * initialization policy: 'undefined' above top. Note that
15332 * DECREF may cause a side effect that reallocates valstack,
15333 * so must relookup after DECREF.
15334 */
15335
15336 if (uindex >= vs_size) {
15337 /* Stack size increases or stays the same. */
15338#if defined(DUK_USE_ASSERTIONS)
15339 duk_uidx_t count;
15340
15341 count = uindex - vs_size;
15342 while (count != 0) {
15343 count--;
15344 tv = thr->valstack_top + count;
15346 }
15347#endif
15348 thr->valstack_top = thr->valstack_bottom + uindex;
15349 } else {
15350 /* Stack size decreases. */
15351#if defined(DUK_USE_REFERENCE_COUNTING)
15352 duk_uidx_t count;
15353
15354 count = vs_size - uindex;
15355 DUK_ASSERT(count > 0);
15356 while (count > 0) {
15357 count--;
15358 tv = --thr->valstack_top; /* tv -> value just before prev top value; must relookup */
15359 DUK_ASSERT(tv >= thr->valstack_bottom);
15360 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 11595 of file duktape-1.5.2/src/duktape.c.

11602 {
11604 }
11605
11606 /* maximum size check is handled by callee */
11607 duk_hbuffer_resize(thr, h, new_size);
11608
11609 return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h);
11610}
11611
11613 duk_hthread *thr = (duk_hthread *) ctx;
11615 void *ptr;
11616 duk_size_t sz;
11617
11618 DUK_ASSERT(ctx != NULL);
11619
11621 DUK_ASSERT(h != NULL);
11622
#define DUK_STR_WRONG_BUFFER_TYPE

Referenced by duk__realloc_props().

◆ 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 19355 of file duktape-1.5.2/src/duktape.c.

19362 {
19363 return 0;
19364 }
19365
19366 /* Coercion may be needed, the helper handles that by pushing the
19367 * tagged values to the stack.
19368 */

◆ 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 19777 of file duktape-1.5.2/src/duktape.c.

19780 {
19781 break;
19782 }
19783 cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
19784 cp = callback(udata, cp);
19785
19786 DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp);
19787 }
19788
19789 DUK_BW_COMPACT(thr, bw);
19790 duk_to_string(ctx, -1);
19791 duk_replace(ctx, index);
19792}
19793
19794DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset) {
19795 duk_hthread *thr = (duk_hthread *) ctx;
19796 duk_hstring *h;
19797 duk_hstring *res;
19798 duk_size_t start_byte_offset;
19799 duk_size_t end_byte_offset;
19800
19802
19804 h = duk_require_hstring(ctx, index);
19805 DUK_ASSERT(h != NULL);
19806
19807 if (end_offset >= DUK_HSTRING_GET_CHARLEN(h)) {
19808 end_offset = DUK_HSTRING_GET_CHARLEN(h);
19809 }
19810 if (start_offset > end_offset) {
19811 start_offset = end_offset;
19812 }
19813
19814 DUK_ASSERT_DISABLE(start_offset >= 0);
19815 DUK_ASSERT(start_offset <= end_offset && start_offset <= DUK_HSTRING_GET_CHARLEN(h));
19816 DUK_ASSERT_DISABLE(end_offset >= 0);
19817 DUK_ASSERT(end_offset >= start_offset && end_offset <= DUK_HSTRING_GET_CHARLEN(h));
19818
19819 /* guaranteed by string limits */
#define DUK_BW_WRITE_ENSURE_XUTF8(thr, bw_ctx, cp)

Referenced by duk__get_own_propdesc_raw().

◆ duk_swap()

DUK_EXTERNAL void duk_swap ( duk_context * ctx,
duk_idx_t index1,
duk_idx_t index2 )

Definition at line 15733 of file duktape-1.5.2/src/duktape.c.

◆ duk_swap_top()

DUK_EXTERNAL void duk_swap_top ( duk_context * ctx,
duk_idx_t index )

Definition at line 15751 of file duktape-1.5.2/src/duktape.c.

◆ duk_throw()

DUK_EXTERNAL void duk_throw ( duk_context * ctx)

Definition at line 19236 of file duktape-1.5.2/src/duktape.c.

19239 {
19241 duk_pop_n(ctx, 2);
19242}
19243
19246 duk_pop_n(ctx, 3);
19247}
19248
19249/*
19250 * Error throwing
19251 */
19252
19254 duk_hthread *thr = (duk_hthread *) ctx;
19255
19256 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
19258 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
19259
19260 if (thr->valstack_top == thr->valstack_bottom) {
19262 }
19263
19264 /* Errors are augmented when they are created, not when they are
19265 * thrown or re-thrown. The current error handler, however, runs
19266 * just before an error is thrown.
19267 */
19268
19269 /* Sync so that augmentation sees up-to-date activations, NULL
19270 * thr->ptr_curr_pc so that it's not used if side effects occur
19271 * in augmentation or longjmp handling.
19272 */

◆ duk_to_boolean()

DUK_EXTERNAL duk_bool_t duk_to_boolean ( duk_context * ctx,
duk_idx_t index )

◆ 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 17241 of file duktape-1.5.2/src/duktape.c.

17245 :
17246 return duk_require_string(ctx, index);
17247}
17248
17250 duk_hstring *ret;
17252 duk_to_string(ctx, index);
17253 ret = duk_get_hstring(ctx, index);
17254 DUK_ASSERT(ret != NULL);
17255 return ret;
17256}
17257
17259 duk_hthread *thr = (duk_hthread *) ctx;
17260 duk_hbuffer *h_buf;
17261 const duk_uint8_t *src_data;
17262 duk_size_t src_size;
17263 duk_uint8_t *dst_data;
17264
17266 DUK_UNREF(thr);
17267
17269
17270 h_buf = duk_get_hbuffer(ctx, index);
17271 if (h_buf != NULL) {
17272 /* Buffer is kept as is, with the fixed/dynamic nature of the
17273 * buffer only changed if requested. An external buffer
17274 * is converted into a non-external dynamic buffer in a
17275 * duk_to_dynamic_buffer() call.
17276 */
17277 duk_uint_t tmp;
17278 duk_uint8_t *tmp_ptr;
17279
17280 tmp_ptr = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf);
17281 src_data = (const duk_uint8_t *) tmp_ptr;
17282 src_size = DUK_HBUFFER_GET_SIZE(h_buf);
17283
17285 if ((tmp == mode && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)) ||
17286 mode == DUK_BUF_MODE_DONTCARE) {
17287 /* Note: src_data may be NULL if input is a zero-size
17288 * dynamic buffer.
17289 */
17290 dst_data = tmp_ptr;
17291 goto skip_copy;
17292 }
17293 } else {
17294 /* Non-buffer value is first ToString() coerced, then converted
17295 * to a buffer (fixed buffer is used unless a dynamic buffer is
17296 * explicitly requested).
17297 */
17298
17299 src_data = (const duk_uint8_t *) duk_to_lstring(ctx, index, &src_size);
17300 }
17301
#define DUK_BUF_MODE_DONTCARE
#define DUK_BUF_MODE_DYNAMIC
DUK_EXTERNAL void * duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t mode)

◆ duk_to_defaultvalue()

DUK_EXTERNAL void duk_to_defaultvalue ( duk_context * ctx,
duk_idx_t index,
duk_int_t hint )

Definition at line 16720 of file duktape-1.5.2/src/duktape.c.

16720 {
16721 if (duk_get_prop_stridx(ctx, index, func_stridx)) {
16722 /* [ ... func ] */
16723 if (duk_is_callable(ctx, -1)) {
16724 duk_dup(ctx, index); /* -> [ ... func this ] */
16725 duk_call_method(ctx, 0); /* -> [ ... retval ] */
16726 if (duk_is_primitive(ctx, -1)) {
16727 duk_replace(ctx, index);
16728 return 1;
16729 }
16730 /* [ ... retval ]; popped below */
16731 }
16732 }
16733 duk_pop(ctx); /* [ ... func/retval ] -> [ ... ] */
16734 return 0;
16735}
16736
16738 duk_hthread *thr = (duk_hthread *) ctx;
16739 duk_hobject *obj;
16740 /* inline initializer for coercers[] is not allowed by old compilers like BCC */
16741 duk_small_int_t coercers[2];
16742
16744 DUK_ASSERT(thr != NULL);
16745
16746 coercers[0] = DUK_STRIDX_VALUE_OF;
16747 coercers[1] = DUK_STRIDX_TO_STRING;
16748
16751
16752 if (hint == DUK_HINT_NONE) {
16754 hint = DUK_HINT_STRING;
16755 } else {
16756 hint = DUK_HINT_NUMBER;
16757 }
#define duk_is_primitive(ctx, index)
#define DUK_STRIDX_VALUE_OF

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 17232 of file duktape-1.5.2/src/duktape.c.

◆ duk_to_int()

◆ duk_to_int32()

DUK_EXTERNAL duk_int32_t duk_to_int32 ( duk_context * ctx,
duk_idx_t index )

Definition at line 16882 of file duktape-1.5.2/src/duktape.c.

16890 {
16891 /* Value coercion (in stack): ToInteger(), E5 Section 9.4
16892 * API return value coercion: custom
16893 */
16896 return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/);
16897}
DUK_LOCAL duk_double_t duk__to_int_uint_helper(duk_context *ctx, duk_idx_t index, duk__toint_coercer coerce_func)

◆ 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 17140 of file duktape-1.5.2/src/duktape.c.

17140 {
17141 *out_clamped = clamped;
17142 } 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 17135 of file duktape-1.5.2/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 17072 of file duktape-1.5.2/src/duktape.c.

17073 {
17074 duk_hthread *thr;
17075 duk_hstring *h_strclass;
17076
17078 DUK_ASSERT(h != NULL);
17079 thr = (duk_hthread *) ctx;
17080 DUK_UNREF(thr);
17081
17082 h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h);
17083 DUK_ASSERT(h_strclass != NULL);
17084 duk_push_sprintf(ctx, "[object %s]", (const char *) DUK_HSTRING_GET_DATA(h_strclass));
17085}
17086#endif /* !DUK_USE_PARANOID_ERRORS */
17087
17088/* XXX: other variants like uint, u32 etc */
17090 duk_hthread *thr = (duk_hthread *) ctx;
17091 duk_tval *tv;
17092 duk_tval tv_tmp;
17093 duk_double_t d, dmin, dmax;
17094 duk_int_t res;
17095 duk_bool_t clamped = 0;
17096
17098
17099 tv = duk_require_tval(ctx, index);
17100 DUK_ASSERT(tv != NULL);
17101 d = duk_js_tointeger(thr, tv); /* E5 Section 9.4, ToInteger() */
17102
17103 dmin = (duk_double_t) minval;
17104 dmax = (duk_double_t) maxval;
17105
17106 if (d < dmin) {
17107 clamped = 1;
17108 res = minval;
17109 d = dmin;
17110 } else if (d > dmax) {
17111 clamped = 1;
17112 res = maxval;
17113 d = dmax;
17114 } else {
17115 res = (duk_int_t) d;
17116 }
17117 DUK_UNREF(d); /* SCANBUILD: with suitable dmin/dmax limits 'd' is unused */
17118 /* 'd' and 'res' agree here */
17119
17120 /* Relookup in case duk_js_tointeger() ends up e.g. coercing an object. */
17121 tv = duk_get_tval(ctx, index);
17122 DUK_ASSERT(tv != NULL); /* not popped by side effect */
17123 DUK_TVAL_SET_TVAL(&tv_tmp, tv);
17124#if defined(DUK_USE_FASTINT)
17125#if (DUK_INT_MAX <= 0x7fffffffL)
17126 DUK_TVAL_SET_FASTINT_I32(tv, res);
17127#else
17128 /* Clamping needed if duk_int_t is 64 bits. */
17129 if (res >= DUK_FASTINT_MIN && res <= DUK_FASTINT_MAX) {
17130 DUK_TVAL_SET_FASTINT(tv, res);
17131 } else {
17132 DUK_TVAL_SET_NUMBER(tv, d);
17133 }
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)

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 16970 of file duktape-1.5.2/src/duktape.c.

16973 {
16974 /* Exact halfway, round to even. */
16975 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 16771 of file duktape-1.5.2/src/duktape.c.

16776 {
16777 duk_hthread *thr = (duk_hthread *) ctx;
16778 duk_tval *tv;
16779
16781 DUK_UNREF(thr);

◆ duk_to_number()

◆ duk_to_object()

DUK_EXTERNAL void duk_to_object ( duk_context * ctx,
duk_idx_t index )

Definition at line 17354 of file duktape-1.5.2/src/duktape.c.

17356 :
17357#endif
17358 default:
17359 /* number */
17362 res = NULL;
17363 break;
17364 }
17365
17366 duk_push_pointer(ctx, res);
17367 duk_replace(ctx, index);
17368 return res;
17369}
17370
17372 duk_hthread *thr = (duk_hthread *) ctx;
17373 duk_tval *tv;
17374 duk_uint_t flags = 0; /* shared flags for a subset of types */
17376
17378
17380
17381 tv = duk_require_tval(ctx, index);
17382 DUK_ASSERT(tv != NULL);
17383
17384 switch (DUK_TVAL_GET_TAG(tv)) {
17385 case DUK_TAG_UNDEFINED:
17386 case DUK_TAG_NULL: {
17388 break;
17389 }
17390 case DUK_TAG_BOOLEAN: {
17394 goto create_object;
17395 }
17396 case DUK_TAG_STRING: {
17401 goto create_object;
17402 }
17403 case DUK_TAG_OBJECT: {
17404 /* nop */
17405 break;
17406 }
17407 case DUK_TAG_BUFFER: {
17408 /* A plain buffer coerces to a Duktape.Buffer because it's the
17409 * object counterpart of the plain buffer value. But it might
17410 * still make more sense to produce an ArrayBuffer here?
17411 */
17412
17413 duk_hbufferobject *h_bufobj;
17414 duk_hbuffer *h_val;
17415
17416 h_val = DUK_TVAL_GET_BUFFER(tv);
17417 DUK_ASSERT(h_val != NULL);
17418
17419 h_bufobj = duk_push_bufferobject_raw(ctx,
17424 DUK_ASSERT(h_bufobj != NULL);
17427
17428 h_bufobj->buf = h_val;
17429 DUK_HBUFFER_INCREF(thr, h_val);
17430 DUK_ASSERT(h_bufobj->offset == 0);
17431 h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val);
17432 DUK_ASSERT(h_bufobj->shift == 0);
17434
17436 goto replace_value;
17437 }
17438 case DUK_TAG_POINTER: {
17442 goto create_object;
17443 }
17444 case DUK_TAG_LIGHTFUNC: {
17445 /* Lightfunc coerces to a Function instance with concrete
17446 * properties. Since 'length' is virtual for Duktape/C
17447 * functions, don't need to define that.
17448 *
17449 * The result is made extensible to mimic what happens to
17450 * strings:
17451 * > Object.isExtensible(Object('foo'))
17452 * true
17453 */
17454 duk_small_uint_t lf_flags;
17455 duk_idx_t nargs;
17456 duk_small_uint_t lf_len;
17457 duk_c_function func;
17459
17460 DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags);
17461
17462 nargs = (duk_idx_t) DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
17463 if (nargs == DUK_LFUNC_NARGS_VARARGS) {
17464 nargs = (duk_idx_t) DUK_VARARGS;
17465 }
17472 /* DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC: omitted here intentionally */
17474 (void) duk__push_c_function_raw(ctx, func, nargs, flags);
17475
17476 lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
17477 if ((duk_idx_t) lf_len != nargs) {
17478 /* Explicit length is only needed if it differs from 'nargs'. */
17479 duk_push_int(ctx, (duk_int_t) lf_len);
17481 }
17482 duk_push_lightfunc_name(ctx, tv);
17484
17485 nf = duk_get_hnativefunction(ctx, -1);
17486 DUK_ASSERT(nf != NULL);
17487 nf->magic = (duk_int16_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
17488
17489 /* Enable DUKFUNC exotic behavior once properties are set up. */
17491 goto replace_value;
17492 }
17493#if defined(DUK_USE_FASTINT)
17494 case DUK_TAG_FASTINT:
17495#endif
17496 default: {
17502 goto create_object;
17503 }
17504 }
17505 return;
DUK_INTERNAL_DECL duk_hnativefunction * duk_get_hnativefunction(duk_context *ctx, duk_idx_t index)
#define DUK_HOBJECT_SET_EXOTIC_DUKFUNC(h)

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 17026 of file duktape-1.5.2/src/duktape.c.

17034 {
17035 (void) duk_safe_to_string(ctx, index);
17038 return duk_get_hstring(ctx, index);
17039}
17040#endif
17041
17042/* Coerce top into Object.prototype.toString() output. */
17044 duk_hthread *thr;
17045 duk_uint_t typemask;
17046 duk_hstring *h_strclass;
17047
17049 thr = (duk_hthread *) ctx;
17050 DUK_UNREF(thr);
17051
17052 typemask = duk_get_type_mask(ctx, -1);
17053 if (typemask & DUK_TYPE_MASK_UNDEFINED) {
#define duk_safe_to_string(ctx, index)
DUK_INTERNAL_DECL void duk_to_object_class_string_top(duk_context *ctx)

◆ duk_to_pointer()

DUK_EXTERNAL void * duk_to_pointer ( duk_context * ctx,
duk_idx_t index )

Definition at line 17303 of file duktape-1.5.2/src/duktape.c.

17303 {
17304 /* When src_size == 0, src_data may be NULL (if source
17305 * buffer is dynamic), and dst_data may be NULL (if
17306 * target buffer is dynamic). Avoid zero-size memcpy()
17307 * with an invalid pointer.
17308 */
17309 DUK_MEMCPY((void *) dst_data, (const void *) src_data, (size_t) src_size);
17310 }
17311 duk_replace(ctx, index);
17312 skip_copy:
17313
17314 if (out_size) {
17315 *out_size = src_size;
17316 }
17317 return dst_data;
17318}
17319
17321 duk_tval *tv;
17322 void *res;
17323
17325
17327
17328 tv = duk_require_tval(ctx, index);
17329 DUK_ASSERT(tv != NULL);
17330
17331 switch (DUK_TVAL_GET_TAG(tv)) {
17332 case DUK_TAG_UNDEFINED:
17333 case DUK_TAG_NULL:
17334 case DUK_TAG_BOOLEAN:
17335 res = NULL;
17336 break;
17337 case DUK_TAG_POINTER:
17338 res = DUK_TVAL_GET_POINTER(tv);
17339 break;
17340 case DUK_TAG_STRING:
17341 case DUK_TAG_OBJECT:
17342 case DUK_TAG_BUFFER:
17343 /* Heap allocated: return heap pointer which is NOT useful
17344 * for the caller, except for debugging.
17345 */
17346 res = (void *) DUK_TVAL_GET_HEAPHDR(tv);
17347 break;
17348 case DUK_TAG_LIGHTFUNC:
17349 /* Function pointers do not always cast correctly to void *
17350 * (depends on memory and segmentation model for instance),
17351 * so they coerce to NULL.
17352 */

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 16784 of file duktape-1.5.2/src/duktape.c.

16788 {
16789 duk_hthread *thr = (duk_hthread *) ctx;
16790 duk_tval *tv;
16791
16793 DUK_UNREF(thr);
16794
16795 tv = duk_require_tval(ctx, index);
16796 DUK_ASSERT(tv != NULL);

◆ duk_to_string()

DUK_EXTERNAL const char * duk_to_string ( duk_context * ctx,
duk_idx_t index )

Definition at line 17144 of file duktape-1.5.2/src/duktape.c.

17144 {
17146 }
17147 }
17148
17149 return res;
17150}
17151
17154 return duk_to_int_clamped_raw(ctx, index, minval, maxval, &dummy);
17155}
17156
17158 return duk_to_int_clamped_raw(ctx, index, minval, maxval, NULL); /* out_clamped==NULL -> RangeError if outside range */
17159}
17160
17162 duk_hthread *thr = (duk_hthread *) ctx;
17163 duk_tval *tv;
17164
17166 DUK_UNREF(thr);
17167
17169
17170 tv = duk_require_tval(ctx, index);
17171 DUK_ASSERT(tv != NULL);
17172
17173 switch (DUK_TVAL_GET_TAG(tv)) {
17174 case DUK_TAG_UNDEFINED: {
17176 break;
17177 }
17178 case DUK_TAG_NULL: {
17180 break;
17181 }
17182 case DUK_TAG_BOOLEAN: {
17183 if (DUK_TVAL_GET_BOOLEAN(tv)) {
17185 } else {
17187 }
17188 break;
17189 }
17190 case DUK_TAG_STRING: {
17191 /* nop */
17192 goto skip_replace;
17193 }
17194 case DUK_TAG_OBJECT: {
17196 return duk_to_string(ctx, index); /* Note: recursive call */
17197 }
17198 case DUK_TAG_BUFFER: {
17200
17201 /* Note: this allows creation of internal strings. */
17202
17203 DUK_ASSERT(h != NULL);
17204 duk_push_lstring(ctx,
17205 (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h),
17207 break;
17208 }
17209 case DUK_TAG_POINTER: {
17210 void *ptr = DUK_TVAL_GET_POINTER(tv);
17211 if (ptr != NULL) {
17212 duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) ptr);
17213 } else {
17214 /* Represent a null pointer as 'null' to be consistent with
17215 * the JX format variant. Native '%p' format for a NULL
17216 * pointer may be e.g. '(nil)'.
17217 */
17219 }
17220 break;
17221 }
17222 case DUK_TAG_LIGHTFUNC: {
17223 /* Should match Function.prototype.toString() */
17225 break;
17226 }
17227#if defined(DUK_USE_FASTINT)
17228 case DUK_TAG_FASTINT:
17229#endif
17230 default: {
#define DUK_STR_NUMBER_OUTSIDE_RANGE

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 16873 of file duktape-1.5.2/src/duktape.c.

◆ duk_to_uint16()

DUK_EXTERNAL duk_uint16_t duk_to_uint16 ( duk_context * ctx,
duk_idx_t index )

Definition at line 16916 of file duktape-1.5.2/src/duktape.c.

16916 {
16917 duk_hthread *thr = (duk_hthread *) ctx;
16918 duk_tval *tv;
16919 duk_uint32_t ret;
16920
16922
16923 tv = duk_require_tval(ctx, index);
16924 DUK_ASSERT(tv != NULL);
16925 ret = duk_js_touint32(thr, tv);
16926
16927 /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
16928 tv = duk_require_tval(ctx, index);
16929 DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv, ret); /* side effects */
16930 return ret;
16931}

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 16899 of file duktape-1.5.2/src/duktape.c.

16899 {
16900 duk_hthread *thr = (duk_hthread *) ctx;
16901 duk_tval *tv;
16902 duk_int32_t ret;
16903
16905
16906 tv = duk_require_tval(ctx, index);
16907 DUK_ASSERT(tv != NULL);
16908 ret = duk_js_toint32(thr, tv);
16909
16910 /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
16911 tv = duk_require_tval(ctx, index);
16912 DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv, ret); /* side effects */
16913 return ret;
16914}

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 16935 of file duktape-1.5.2/src/duktape.c.

16952 {
16953 duk_double_t d;
16954 duk_double_t t;
16955 duk_uint8_t ret;
16956
16957 /* XXX: Simplify this algorithm, should be possible to come up with
16958 * a shorter and faster algorithm by inspecting IEEE representation
16959 * directly.
16960 */
16961
16962 d = duk_to_number(ctx, index);
16963 if (d <= 0.0) {
16964 return 0;
16965 } else if (d >= 255) {
16966 return 255;
16967 } else if (DUK_ISNAN(d)) {

◆ duk_to_undefined()

DUK_EXTERNAL void duk_to_undefined ( duk_context * ctx,
duk_idx_t index )

Definition at line 16759 of file duktape-1.5.2/src/duktape.c.

16760 {
16761 coercers[0] = DUK_STRIDX_TO_STRING;
16762 coercers[1] = DUK_STRIDX_VALUE_OF;
16763 }
16764
16765 if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[0])) {
16766 return;
16767 }
16768
16769 if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[1])) {
DUK_LOCAL duk_bool_t duk__defaultvalue_coerce_attempt(duk_context *ctx, duk_idx_t index, duk_small_int_t func_stridx)

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 19824 of file duktape-1.5.2/src/duktape.c.

19841 {
19842 duk_hthread *thr = (duk_hthread *) ctx;
19843 duk_hstring *h;
19844 const duk_uint8_t *p, *p_start, *p_end, *p_tmp1, *p_tmp2; /* pointers for scanning */
19845 const duk_uint8_t *q_start, *q_end; /* start (incl) and end (excl) of trimmed part */
19846 duk_codepoint_t cp;
19847
19849
19851 h = duk_require_hstring(ctx, index);
19852 DUK_ASSERT(h != NULL);
19853
19854 p_start = DUK_HSTRING_GET_DATA(h);
19855 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h);
19856
19857 p = p_start;
19858 while (p < p_end) {
19859 p_tmp1 = p;
19860 cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp1, p_start, p_end);
19862 break;
19863 }
19864 p = p_tmp1;
19865 }
19866 q_start = p;
19867 if (p == p_end) {
19868 /* entire string is whitespace */
19869 q_end = p;
19870 goto scan_done;
19871 }
19872
19873 p = p_end;
19874 while (p > p_start) {
19875 p_tmp1 = p;
19876 while (p > p_start) {
19877 p--;
19878 if (((*p) & 0xc0) != 0x80) {
19879 break;
19880 }
19881 }
19882 p_tmp2 = p;
19883
19884 cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp2, p_start, p_end);
19886 p = p_tmp1;
19887 break;
19888 }
19889 }
19890 q_end = p;
19891
19892 scan_done:
19893 /* This may happen when forward and backward scanning disagree
19894 * (possible for non-extended-UTF-8 strings).
19895 */
19896 if (q_end < q_start) {
19897 q_end = q_start;
19898 }

◆ duk_tval_decref()

◆ duk_unicode_case_convert_string()

DUK_INTERNAL_DECL void duk_unicode_case_convert_string ( duk_hthread * thr,
duk_bool_t uppercase )

Definition at line 10929 of file duktape-1.5.2/src/duktape.c.

10929 :
10930 if (bw != NULL) {
10932 }
10933 return cp;
10934
10935 /* unused now, not needed until Turkish/Azeri */
10936#if 0
10937 nochar:
10938 return -1;
10939#endif
10940}
10941
10942/*
10943 * Replace valstack top with case converted version.
10944 */
10945
10947 duk_context *ctx = (duk_context *) thr;
10948 duk_hstring *h_input;
10949 duk_bufwriter_ctx bw_alloc;
10951 const duk_uint8_t *p, *p_start, *p_end;
10952 duk_codepoint_t prev, curr, next;
10953
10954 h_input = duk_require_hstring(ctx, -1);
10955 DUK_ASSERT(h_input != NULL);
10956
10957 bw = &bw_alloc;
10959
10960 /* [ ... input buffer ] */
10961
10962 p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
10963 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
10964 p = p_start;
10965
10966 prev = -1; DUK_UNREF(prev);
10967 curr = -1;
10968 next = -1;
10969 for (;;) {
10970 prev = curr;
10971 curr = next;
10972 next = -1;
10973 if (p < p_end) {
10974 next = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
10975 } else {
10976 /* end of input and last char has been processed */
10977 if (curr < 0) {
10978 break;
10979 }
10980 }
10981
10982 /* on first round, skip */
10983 if (curr >= 0) {
10984 /* XXX: could add a fast path to process chunks of input codepoints,
10985 * but relative benefit would be quite small.
10986 */

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 10109 of file duktape-1.5.2/src/duktape.c.

10126 {
10127 const duk_uint8_t *p;
10128 duk_uint32_t res;
10131
10132 DUK_UNREF(thr);
10133
10134 p = *ptr;
10135 if (p < ptr_start || p >= ptr_end) {
10136 goto fail;
10137 }
10138
10139 /*
10140 * UTF-8 decoder which accepts longer than standard byte sequences.
10141 * This allows full 32-bit code points to be used.
10142 */
10143
10144 ch = (duk_uint_fast8_t) (*p++);
10145 if (ch < 0x80) {
10146 /* 0xxx xxxx [7 bits] */
10147 res = (duk_uint32_t) (ch & 0x7f);
10148 n = 0;
10149 } else if (ch < 0xc0) {
10150 /* 10xx xxxx -> invalid */
10151 goto fail;
10152 } else if (ch < 0xe0) {
10153 /* 110x xxxx 10xx xxxx [11 bits] */
10154 res = (duk_uint32_t) (ch & 0x1f);
10155 n = 1;
10156 } else if (ch < 0xf0) {
10157 /* 1110 xxxx 10xx xxxx 10xx xxxx [16 bits] */
10158 res = (duk_uint32_t) (ch & 0x0f);
10159 n = 2;
10160 } else if (ch < 0xf8) {
10161 /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx [21 bits] */
10162 res = (duk_uint32_t) (ch & 0x07);
10163 n = 3;
10164 } else if (ch < 0xfc) {
10165 /* 1111 10xx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [26 bits] */
10166 res = (duk_uint32_t) (ch & 0x03);
10167 n = 4;
10168 } else if (ch < 0xfe) {
10169 /* 1111 110x 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [31 bits] */
10170 res = (duk_uint32_t) (ch & 0x01);
10171 n = 5;
10172 } else if (ch < 0xff) {
10173 /* 1111 1110 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [36 bits] */
10174 res = (duk_uint32_t) (0);
10175 n = 6;
10176 } else {
10177 /* 8-byte format could be:
10178 * 1111 1111 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [41 bits]
10179 *
10180 * However, this format would not have a zero bit following the
10181 * leading one bits and would not allow 0xFF to be used as an
10182 * "invalid xutf-8" marker for internal keys. Further, 8-byte
10183 * encodings (up to 41 bit code points) are not currently needed.
10184 */
10185 goto fail;
10186 }
10187
10188 DUK_ASSERT(p >= ptr_start); /* verified at beginning */
10189 if (p + n > ptr_end) {
10190 /* 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 10193 of file duktape-1.5.2/src/duktape.c.

10194 {
10195 DUK_ASSERT(p >= ptr_start && p < ptr_end);
10196 res = res << 6;
10197 res += (duk_uint32_t) ((*p++) & 0x3f);
10198 n--;
10199 }
10200
10201 *ptr = p;
10202 *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 10049 of file duktape-1.5.2/src/duktape.c.

10050 {
10051 /* Note: masking of 'x' is not necessary because of
10052 * range check and shifting -> no bits overlapping
10053 * the marker should be set.
10054 */
10055 out[0] = (duk_uint8_t) (marker + x);
10056 }
10057 } while (i > 0);
10058
10059 return len;
10060}
10061
10062/* Encode to CESU-8; 'out' must have space for at least
10063 * DUK_UNICODE_MAX_CESU8_LENGTH bytes; codepoints above U+10FFFF
10064 * will encode to garbage but won't overwrite the output buffer.
10065 */
10068 duk_small_int_t len;
10069
10070 if (x < 0x80UL) {
10071 out[0] = (duk_uint8_t) x;
10072 len = 1;
10073 } else if (x < 0x800UL) {
10074 out[0] = (duk_uint8_t) (0xc0 + ((x >> 6) & 0x1f));
10075 out[1] = (duk_uint8_t) (0x80 + (x & 0x3f));
10076 len = 2;
10077 } else if (x < 0x10000UL) {
10078 /* surrogate pairs get encoded here */
10079 out[0] = (duk_uint8_t) (0xe0 + ((x >> 12) & 0x0f));
10080 out[1] = (duk_uint8_t) (0x80 + ((x >> 6) & 0x3f));
10081 out[2] = (duk_uint8_t) (0x80 + (x & 0x3f));
10082 len = 3;
10083 } else {
10084 /*
10085 * Unicode codepoints above U+FFFF are encoded as surrogate
10086 * pairs here. This ensures that all CESU-8 codepoints are
10087 * 16-bit values as expected in Ecmascript. The surrogate
10088 * pairs always get a 3-byte encoding (each) in CESU-8.
10089 * See: http://en.wikipedia.org/wiki/Surrogate_pair
10090 *
10091 * 20-bit codepoint, 10 bits (A and B) per surrogate pair:
10092 *
10093 * x = 0b00000000 0000AAAA AAAAAABB BBBBBBBB
10094 * sp1 = 0b110110AA AAAAAAAA (0xd800 + ((x >> 10) & 0x3ff))
10095 * sp2 = 0b110111BB BBBBBBBB (0xdc00 + (x & 0x3ff))
10096 *
10097 * Encoded into CESU-8:
10098 *
10099 * sp1 -> 0b11101101 (0xe0 + ((sp1 >> 12) & 0x0f))
10100 * -> 0b1010AAAA (0x80 + ((sp1 >> 6) & 0x3f))
10101 * -> 0b10AAAAAA (0x80 + (sp1 & 0x3f))
10102 * sp2 -> 0b11101101 (0xe0 + ((sp2 >> 12) & 0x0f))
10103 * -> 0b1011BBBB (0x80 + ((sp2 >> 6) & 0x3f))
10104 * -> 0b10BBBBBB (0x80 + (sp2 & 0x3f))
10105 *
10106 * 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 10015 of file duktape-1.5.2/src/duktape.c.

10024 {
10025 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
10026};
10027
10028/* Encode to extended UTF-8; 'out' must have space for at least
10029 * DUK_UNICODE_MAX_XUTF8_LENGTH bytes. Allows encoding of any
10030 * 32-bit (unsigned) codepoint.
10031 */
10034 duk_small_int_t len;
10035 duk_uint8_t marker;
10037
10039 DUK_ASSERT(len > 0);
10040
10041 marker = duk_unicode_xutf8_markers[len - 1]; /* 64-bit OK because always >= 0 */
10042
10043 i = len;
DUK_INTERNAL const duk_uint8_t duk_unicode_xutf8_markers[7]

◆ duk_unicode_get_xutf8_length()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length ( duk_ucodepoint_t cp)

Definition at line 9959 of file duktape-1.5.2/src/duktape.c.

9959 : IdentifierPart only
9960 */
9961 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00...0x0f */
9962 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10...0x1f */
9963 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20...0x2f */
9964 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, /* 0x30...0x3f */
9965 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40...0x4f */
9966 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 0x50...0x5f */
9967 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60...0x6f */
9968 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 /* 0x70...0x7f */
9969};
9970#endif
9971
9972/*
9973 * XUTF-8 and CESU-8 encoding/decoding
9974 */
9975
9978 if (x < 0x80UL) {
9979 /* 7 bits */
9980 return 1;
9981 } else if (x < 0x800UL) {
9982 /* 11 bits */
9983 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 10562 of file duktape-1.5.2/src/duktape.c.

10562 {
10563 return 1;
10564 }
10565 return 0;
10566 } else {
10567 /* without explicit non-BMP support, assume non-BMP characters
10568 * are always accepted as identifier characters.
10569 */
10570 return 1;
10571 }
10572#endif
10573}
10574
10575/*
10576 * "IdentifierPart" production check.
10577 */
10578
10580 /*
10581 * E5 Section 7.6:
10582 *
10583 * IdentifierPart:
10584 * IdentifierStart
10585 * UnicodeCombiningMark
10586 * UnicodeDigit
10587 * UnicodeConnectorPunctuation
10588 * <ZWNJ> [U+200C]
10589 * <ZWJ> [U+200D]
10590 *
10591 * IdentifierPart production has one multi-character production
10592 * as part of its IdentifierStart alternative. The '\' character
10593 * of an escape sequence is not matched here, see discussion in
10594 * duk_unicode_is_identifier_start().
10595 *
10596 * To match non-ASCII characters (codepoints >= 0x80), a very slow
10597 * linear range-by-range scan is used. The codepoint is first compared
10598 * to the IdentifierStart ranges, and if it doesn't match, then to a
10599 * set consisting of code points in IdentifierPart but not in
10600 * IdentifierStart. This is done to keep the unicode range data small,
10601 * at the expense of speed.
10602 *
10603 * The ASCII fast path consists of:
10604 *
10605 * 0x0030 ... 0x0039 ['0' ... '9', UnicodeDigit]
10606 * 0x0041 ... 0x005a ['A' ... 'Z', IdentifierStart]
10607 * 0x0061 ... 0x007a ['a' ... 'z', IdentifierStart]
10608 * 0x0024 ['$', IdentifierStart]
10609 * 0x005f ['_', IdentifierStart and
10610 * UnicodeConnectorPunctuation]
10611 *
10612 * UnicodeCombiningMark has no code points <= 0x7f.
10613 *
10614 * The matching code reuses the "identifier start" tables, and then
10615 * consults a separate range set for characters in "identifier part"
10616 * but not in "identifier start". These can be extracted with the
10617 * "src/extract_chars.py" script.
10618 *
10619 * UnicodeCombiningMark -> categories Mn, Mc
10620 * UnicodeDigit -> categories Nd
10621 * UnicodeConnectorPunctuation -> categories Pc
10622 */
10623
10624 /* ASCII (and EOF) fast path -- quick accept and reject */
10625 if (cp <= 0x7fL) {
10626#if defined(DUK_USE_IDCHAR_FASTPATH)
10627 return (cp >= 0) && (duk_is_idchar_tab[cp] != 0);
10628#else
10629 if ((cp >= 'a' && cp <= 'z') ||
10630 (cp >= 'A' && cp <= 'Z') ||
10631 (cp >= '0' && cp <= '9') ||
10632 cp == '_' || cp == '$') {
10633 return 1;
10634 }
10635 return 0;
10636#endif
10637 }
10638
10639 /* Non-ASCII slow path (range-by-range linear comparison), very slow */
10640
10641#ifdef DUK_USE_SOURCE_NONBMP
10643 sizeof(duk_unicode_ids_noa),
10644 (duk_codepoint_t) cp) ||
10647 (duk_codepoint_t) cp)) {
10648 return 1;
10649 }
10650 return 0;
10651#else
10652 if (cp < 0x10000L) {
const duk_uint8_t duk_unicode_idp_m_ids_noa[397]
const duk_uint8_t duk_unicode_ids_noa[791]
DUK_INTERNAL const duk_int8_t duk_is_idchar_tab[128]

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 10483 of file duktape-1.5.2/src/duktape.c.

10489 {
10490 return 1;
10491 }
10492
10493 return 0;
10494}
10495
10496/*
10497 * "IdentifierStart" production check.
10498 */
10499
10501 /*
10502 * E5 Section 7.6:
10503 *
10504 * IdentifierStart:
10505 * UnicodeLetter
10506 * $
10507 * _
10508 * \ UnicodeEscapeSequence
10509 *
10510 * IdentifierStart production has one multi-character production:
10511 *
10512 * \ UnicodeEscapeSequence
10513 *
10514 * The '\' character is -not- matched by this function. Rather, the caller
10515 * should decode the escape and then call this function to check whether the
10516 * decoded character is acceptable (see discussion in E5 Section 7.6).
10517 *
10518 * The "UnicodeLetter" alternative of the production allows letters
10519 * from various Unicode categories. These can be extracted with the
10520 * "src/extract_chars.py" script.
10521 *
10522 * Because the result has hundreds of Unicode codepoint ranges, matching
10523 * for any values >= 0x80 are done using a very slow range-by-range scan
10524 * and a packed range format.
10525 *
10526 * The ASCII portion (codepoints 0x00 ... 0x7f) is fast-pathed below because
10527 * it matters the most. The ASCII related ranges of IdentifierStart are:
10528 *
10529 * 0x0041 ... 0x005a ['A' ... 'Z']
10530 * 0x0061 ... 0x007a ['a' ... 'z']
10531 * 0x0024 ['$']
10532 * 0x005f ['_']
10533 */
10534
10535 /* ASCII (and EOF) fast path -- quick accept and reject */
10536 if (cp <= 0x7fL) {
10537#if defined(DUK_USE_IDCHAR_FASTPATH)
10538 return (cp >= 0) && (duk_is_idchar_tab[cp] > 0);
10539#else
10540 if ((cp >= 'a' && cp <= 'z') ||
10541 (cp >= 'A' && cp <= 'Z') ||
10542 cp == '_' || cp == '$') {
10543 return 1;
10544 }
10545 return 0;
10546#endif
10547 }
10548
10549 /* Non-ASCII slow path (range-by-range linear comparison), very slow */
10550
10551#ifdef DUK_USE_SOURCE_NONBMP
10554 (duk_codepoint_t) cp)) {
10555 return 1;
10556 }

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 10658 of file duktape-1.5.2/src/duktape.c.

10658 {
10659 return 1;
10660 }
10661 return 0;
10662 } else {
10663 /* without explicit non-BMP support, assume non-BMP characters
10664 * are always accepted as identifier characters.
10665 */
10666 return 1;
10667 }
10668#endif
10669}
10670
10671/*
10672 * Unicode letter check.
10673 */
10674
10676 /*
10677 * Unicode letter is now taken to be the categories:
10678 *
10679 * Lu, Ll, Lt, Lm, Lo
10680 *
10681 * (Not sure if this is exactly correct.)
10682 *
10683 * The ASCII fast path consists of:
10684 *
10685 * 0x0041 ... 0x005a ['A' ... 'Z']
10686 * 0x0061 ... 0x007a ['a' ... 'z']
10687 */
10688
10689 /* ASCII (and EOF) fast path -- quick accept and reject */
10690 if (cp <= 0x7fL) {
10691 if ((cp >= 'a' && cp <= 'z') ||
10692 (cp >= 'A' && cp <= 'Z')) {
10693 return 1;
10694 }
10695 return 0;
10696 }
10697
10698 /* Non-ASCII slow path (range-by-range linear comparison), very slow */
10699
10700#ifdef DUK_USE_SOURCE_NONBMP
10702 sizeof(duk_unicode_ids_noa),
10703 (duk_codepoint_t) cp) &&
10706 (duk_codepoint_t) cp)) {
10707 return 1;
10708 }
10709 return 0;
10710#else
10711 if (cp < 0x10000L) {
const duk_uint8_t duk_unicode_ids_m_let_noa[42]

◆ duk_unicode_is_line_terminator()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator ( duk_codepoint_t cp)

Definition at line 10463 of file duktape-1.5.2/src/duktape.c.

10464 {
10465 if (lo <= 0x0aU || lo == 0x2fU || lo == 0x5fU) {
10466 return 1;
10467 }
10468 } else if (cp == 0x1680L || cp == 0x180eL || cp == 0x3000L ||
10469 cp == 0xfeffL) {
10470 return 1;
10471 }
10472
10473 return 0;
10474}
10475
10476/*
10477 * "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 10383 of file duktape-1.5.2/src/duktape.c.

10386 : cp=%06lx range=[0x%06lx,0x%06lx]",
10387 (unsigned long) cp, (unsigned long) r1, (unsigned long) r2));
10388 if (cp >= r1 && cp <= r2) {
10389 return 1;
10390 }
10391 }
10392
10393 return 0;
10394}
10395
10396/*
10397 * "WhiteSpace" production check.
10398 */
10399
10400DUK_INTERNAL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp) {
10401 /*
10402 * E5 Section 7.2 specifies six characters specifically as
10403 * white space:
10404 *
10405 * 0009;<control>;Cc;0;S;;;;;N;CHARACTER TABULATION;;;;
10406 * 000B;<control>;Cc;0;S;;;;;N;LINE TABULATION;;;;
10407 * 000C;<control>;Cc;0;WS;;;;;N;FORM FEED (FF);;;;
10408 * 0020;SPACE;Zs;0;WS;;;;;N;;;;;
10409 * 00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
10410 * FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;;
10411 *
10412 * It also specifies any Unicode category 'Zs' characters as white
10413 * space. These can be extracted with the "src/extract_chars.py" script.
10414 * Current result:
10415 *
10416 * RAW OUTPUT:
10417 * ===========
10418 * 0020;SPACE;Zs;0;WS;;;;;N;;;;;
10419 * 00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
10420 * 1680;OGHAM SPACE MARK;Zs;0;WS;;;;;N;;;;;
10421 * 180E;MONGOLIAN VOWEL SEPARATOR;Zs;0;WS;;;;;N;;;;;
10422 * 2000;EN QUAD;Zs;0;WS;2002;;;;N;;;;;
10423 * 2001;EM QUAD;Zs;0;WS;2003;;;;N;;;;;
10424 * 2002;EN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10425 * 2003;EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10426 * 2004;THREE-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10427 * 2005;FOUR-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10428 * 2006;SIX-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10429 * 2007;FIGURE SPACE;Zs;0;WS;<noBreak> 0020;;;;N;;;;;
10430 * 2008;PUNCTUATION SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10431 * 2009;THIN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10432 * 200A;HAIR SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10433 * 202F;NARROW NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;;;;;
10434 * 205F;MEDIUM MATHEMATICAL SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10435 * 3000;IDEOGRAPHIC SPACE;Zs;0;WS;<wide> 0020;;;;N;;;;;
10436 *
10437 * RANGES:
10438 * =======
10439 * 0x0020
10440 * 0x00a0
10441 * 0x1680
10442 * 0x180e
10443 * 0x2000 ... 0x200a
10444 * 0x202f
10445 * 0x205f
10446 * 0x3000
10447 *
10448 * A manual decoder (below) is probably most compact for this.
10449 */
10450
10451 duk_uint_fast8_t lo;
10452 duk_uint_fast32_t hi;
10453
10454 /* cp == -1 (EOF) never matches and causes return value 0 */
10455
10456 lo = (duk_uint_fast8_t) (cp & 0xff);
10457 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 10997 of file duktape-1.5.2/src/duktape.c.

11014 {
11015#if defined(DUK_USE_REGEXP_CANON_WORKAROUND)
11016 /* Fast canonicalization lookup at the cost of 128kB footprint. */
11017 DUK_ASSERT(cp >= 0);
11018 DUK_UNREF(thr);
11019 if (DUK_LIKELY(cp < 0x10000L)) {
11020 return (duk_codepoint_t) duk_unicode_re_canon_lookup[cp];
11021 }
11022 return cp;
11023#else /* DUK_USE_REGEXP_CANON_WORKAROUND */
11025

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 11032 of file duktape-1.5.2/src/duktape.c.

11033 {
11034 /* multiple codepoint conversion or non-ASCII mapped to ASCII
11035 * --> leave as is.
11036 */
11037 return cp;
11038 }
11039
11040 return y;
11041#endif /* DUK_USE_REGEXP_CANON_WORKAROUND */
11042}
11043
11044/*

◆ 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 10245 of file duktape-1.5.2/src/duktape.c.

10245 {
10246 duk_uint8_t x;
10247 x = *p++;
10248 if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) {
10249 ncont++;
10250 }
10251 }
10252
10253 DUK_ASSERT(ncont <= blen);
10254 clen = blen - ncont;
10255 DUK_ASSERT(clen <= blen);
10256 return clen;
10257}
10258#else /* DUK_USE_PREFER_SIZE */
10259/* This seems like a good overall approach. Fast path for ASCII in 4 byte
10260 * blocks.
10261 */
10263 const duk_uint8_t *p;
10264 const duk_uint8_t *p_end;
10265 const duk_uint32_t *p32_end;
10266 const duk_uint32_t *p32;
10267 duk_size_t ncont;
10268 duk_size_t clen;
10269
10270 ncont = 0; /* number of continuation (non-initial) bytes in [0x80,0xbf] */
10271 p = data;
10272 p_end = data + blen;
10273 if (blen < 16) {
10274 goto skip_fastpath;
10275 }
10276
10277 /* Align 'p' to 4; the input data may have arbitrary alignment.
10278 * End of string check not needed because blen >= 16.
10279 */
10280 while (((duk_size_t) (const void *) p) & 0x03U) {
10281 duk_uint8_t x;
10282 x = *p++;
10283 if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) {
10284 ncont++;
10285 }
10286 }
10287
10288 /* Full, aligned 4-byte reads. */
10289 p32_end = (const duk_uint32_t *) (const void *) (p + ((duk_size_t) (p_end - p) & (duk_size_t) (~0x03)));
10290 p32 = (const duk_uint32_t *) (const void *) p;
10291 while (p32 != (const duk_uint32_t *) p32_end) {
10292 duk_uint32_t x;
10293 x = *p32++;
10294 if (DUK_LIKELY((x & 0x80808080UL) == 0)) {
10295 ; /* ASCII fast path */
10296 } else {
10297 /* Flip highest bit of each byte which changes
10298 * the bit pattern 10xxxxxx into 00xxxxxx which
10299 * allows an easy bit mask test.
10300 */
10301 x ^= 0x80808080UL;
10302 if (DUK_UNLIKELY(!(x & 0xc0000000UL))) {
10303 ncont++;
10304 }
10305 if (DUK_UNLIKELY(!(x & 0x00c00000UL))) {
10306 ncont++;
10307 }
10308 if (DUK_UNLIKELY(!(x & 0x0000c000UL))) {
10309 ncont++;
10310 }
10311 if (DUK_UNLIKELY(!(x & 0x000000c0UL))) {
10312 ncont++;
10313 }
10314 }
10315 }

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 11368 of file duktape-1.5.2/src/duktape.c.

11380 {
11381 2, 3, 5, 7, 11, 13, 19, 31, 41, 47, 59, 67, 73, 79, 89, 101, 103, 107,
11382 109, 127, 137, 139, 149, 157, 163, 167, 173, 181, 191, 193, 197, 199
11383};
11384
11385DUK_INTERNAL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size) {
11386 const duk_int8_t *p = duk__hash_size_corrections;
11387 duk_uint32_t curr;
11388
11389 curr = (duk_uint32_t) *p++;
11390 for (;;) {
11392 if (t < 0) {
11393 /* may happen if size is very close to 2^32-1 */
11394 break;
11395 }
11396
11397 /* prediction: portable variant using doubles if 64-bit values not available */
11398#ifdef DUK_USE_64BIT_OPS
DUK_LOCAL const duk_int8_t duk__hash_size_corrections[]

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 86633 of file duktape-1.5.2/src/duktape.c.

86643 { \
86644 (rnd) += ((rnd) * (rnd)) | 0x05; \
86645 (rnd) = ((rnd) & 0xffffffffU); /* if duk_uint32_t is exactly 32 bits, this is a NOP */ \
86646 } while (0)
86647
86648#define DUK__RND_BIT(rnd) ((rnd) >> 31) /* only use the highest bit */
86649

◆ duk_util_tinyrandom_get_double()

DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double ( duk_hthread * thr)

Definition at line 86651 of file duktape-1.5.2/src/duktape.c.

86657 {
86658 DUK__UPDATE_RND(rnd);
86659 res <<= 1;
86660 res += DUK__RND_BIT(rnd);
86661 }
86662
86663 thr->heap->rnd_state = rnd;
86664
86665 return res;
86666}
86667
86669 duk_double_t t;
86671 duk_uint32_t rnd;
86672
86673 /*
86674 * XXX: could make this a lot faster if we create the double memory
86675 * representation directly. Feasible easily (must be uniform random).
86676 */
86677
86678 rnd = thr->heap->rnd_state;
DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr)
#define DUK__UPDATE_RND(rnd)
#define DUK__RND_BIT(rnd)

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 15546 of file duktape-1.5.2/src/duktape.c.

15553 {
15555 p++;
15556 }
15557#endif
15558
15559 return 1;
15560}
15561
15564 duk_size_t min_new_size,
15565 duk_small_uint_t flags) {
15566 duk_hthread *thr = (duk_hthread *) ctx;
15567 duk_size_t old_size;
15568 duk_size_t new_size;
15569 duk_bool_t is_shrink = 0;
15570 duk_small_uint_t shrink_flag = (flags & DUK_VSRESIZE_FLAG_SHRINK);
15571 duk_small_uint_t compact_flag = (flags & DUK_VSRESIZE_FLAG_COMPACT);
15572 duk_small_uint_t throw_flag = (flags & DUK_VSRESIZE_FLAG_THROW);
15573
15574 DUK_DDD(DUK_DDDPRINT("check valstack resize: min_new_size=%lu, curr_size=%ld, curr_top=%ld, "
15575 "curr_bottom=%ld, shrink=%d, compact=%d, throw=%d",
15576 (unsigned long) min_new_size,
15577 (long) (thr->valstack_end - thr->valstack),
15578 (long) (thr->valstack_top - thr->valstack),
15579 (long) (thr->valstack_bottom - thr->valstack),
15580 (int) shrink_flag, (int) compact_flag, (int) throw_flag));
15581
15583 DUK_ASSERT(thr != NULL);
15584 DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
15586 DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
15587
15588#if defined(DUK_USE_PREFER_SIZE)
15589 old_size = (duk_size_t) (thr->valstack_end - thr->valstack);
15590#else
15591 DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
15592 old_size = thr->valstack_size;
15593#endif
15594
15595 if (min_new_size <= old_size) {
15596 is_shrink = 1;
15597 if (!shrink_flag ||
15598 old_size - min_new_size < DUK_VALSTACK_SHRINK_THRESHOLD) {
15599 DUK_DDD(DUK_DDDPRINT("no need to grow or shrink valstack"));
15600 return 1;
15601 }
15602 }
15603
15604 new_size = min_new_size;
15605 if (!compact_flag) {
15606 if (is_shrink) {
15607 /* shrink case; leave some spare */
15608 new_size += DUK_VALSTACK_SHRINK_SPARE;
15609 }
15610
15611 /* round up roughly to next 'grow step' */
15612 new_size = (new_size / DUK_VALSTACK_GROW_STEP + 1) * DUK_VALSTACK_GROW_STEP;
15613 }
15614
15615 DUK_DD(DUK_DDPRINT("want to %s valstack: %lu -> %lu elements (min_new_size %lu)",
15616 (const char *) (new_size > old_size ? "grow" : "shrink"),
15617 (unsigned long) old_size, (unsigned long) new_size,
15618 (unsigned long) min_new_size));
15619
15620 if (new_size > thr->valstack_max) {
15621 /* Note: may be triggered even if minimal new_size would not reach the limit,
15622 * plan limit accordingly (taking DUK_VALSTACK_GROW_STEP into account).
15623 */
15624 if (throw_flag) {
15626 } else {
15627 return 0;
15628 }
15629 }
15630
15631 /*
15632 * When resizing the valstack, a mark-and-sweep may be triggered for
15633 * the allocation of the new valstack. If the mark-and-sweep needs
15634 * to use our thread for something, it may cause *the same valstack*
15635 * to be resized recursively. This happens e.g. when mark-and-sweep
15636 * finalizers are called. This is taken into account carefully in
15637 * duk__resize_valstack().
15638 *
15639 * 'new_size' is known to be <= valstack_max, which ensures that
15640 * size_t and pointer arithmetic won't wrap in duk__resize_valstack().
15641 */
15642
15643 if (!duk__resize_valstack(ctx, new_size)) {
#define DUK_VALSTACK_SHRINK_THRESHOLD
DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size)
#define DUK_STR_VALSTACK_LIMIT
#define DUK_VALSTACK_GROW_STEP
#define DUK_VALSTACK_SHRINK_SPARE

◆ 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 15919 of file duktape-1.5.2/src/duktape.c.

15936 {
15937 duk_hthread *to_thr = (duk_hthread *) to_ctx;
15938 duk_hthread *from_thr = (duk_hthread *) from_ctx;
15939 void *src;
15940 duk_size_t nbytes;
15941 duk_tval *p;
15942 duk_tval *q;
15943
15944 /* XXX: several pointer comparison issues here */
15945
15946 DUK_ASSERT_CTX_VALID(to_ctx);
15947 DUK_ASSERT_CTX_VALID(from_ctx);
15948 DUK_ASSERT(to_ctx != NULL);
15949 DUK_ASSERT(from_ctx != NULL);
15950
15951 if (to_ctx == from_ctx) {
15953 return;
15954 }
15955 if ((count < 0) ||
15956 (count > (duk_idx_t) to_thr->valstack_max)) {
15957 /* Maximum value check ensures 'nbytes' won't wrap below. */
15959 return;
15960 }
15961
15962 nbytes = sizeof(duk_tval) * count;
15963 if (nbytes == 0) {
15964 return;
15965 }
15966 DUK_ASSERT(to_thr->valstack_top <= to_thr->valstack_end);
15967 if ((duk_size_t) ((duk_uint8_t *) to_thr->valstack_end - (duk_uint8_t *) to_thr->valstack_top) < nbytes) {
15969 }
15970 src = (void *) ((duk_uint8_t *) from_thr->valstack_top - nbytes);
15971 if (src < (void *) from_thr->valstack_bottom) {
15973 }
15974
15975 /* copy values (no overlap even if to_ctx == from_ctx; that's not
15976 * allowed now anyway)
15977 */
15978 DUK_ASSERT(nbytes > 0);
15979 DUK_MEMCPY((void *) to_thr->valstack_top, (const void *) src, (size_t) nbytes);
15980
15981 p = to_thr->valstack_top;
15982 to_thr->valstack_top = (duk_tval *) (void *) (((duk_uint8_t *) p) + nbytes);
15983
15984 if (is_copy) {
15985 /* Incref copies, keep originals. */
15986 q = to_thr->valstack_top;
#define DUK_STR_INVALID_CONTEXT

◆ 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 14582 of file duktape-1.5.2/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 14600 of file duktape-1.5.2/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 14613 of file duktape-1.5.2/src/duktape.c.

14617 {
14618 duk_hthread *thr = (duk_hthread *) ctx;
14619 duk_hobject *obj;
14620
14622
14623 obj = duk_require_hobject(ctx, obj_index);
14624 DUK_ASSERT(obj != NULL);
14625
14626 duk_hobject_define_property_internal_arridx(thr, obj, arr_index, desc_flags);
14627 /* value popped by call */
14628}
14629

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 14632 of file duktape-1.5.2/src/duktape.c.

14649 {
14650 duk_hthread *thr = (duk_hthread *) ctx;
14651 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 14658 of file duktape-1.5.2/src/duktape.c.

Variable Documentation

◆ duk__buffer_class_from_elemtype

◆ duk__buffer_elemtype_copy_compatible

duk_uint16_t duk__buffer_elemtype_copy_compatible[9]
static

Definition at line 21586 of file duktape-1.5.2/src/duktape.c.

21586 {
21587 1, /* DUK__FLD_8BIT */
21588 2, /* DUK__FLD_16BIT */
21589 4, /* DUK__FLD_32BIT */
21590 4, /* DUK__FLD_FLOAT */
21591 8, /* DUK__FLD_DOUBLE */
21592 0 /* DUK__FLD_VARINT; not relevant here */
21593};
21594#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
21595
21596#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
21597/* Bitfield for each DUK_HBUFFEROBJECT_ELEM_xxx indicating which element types
21598 * are compatible with a blind byte copy for the TypedArray set() method (also
21599 * used for TypedArray constructor). Array index is target buffer elem type,
21600 * bitfield indicates compatible source types. The types must have same byte
21601 * size and they must be coercion compatible.
21602 */
21603static duk_uint16_t duk__buffer_elemtype_copy_compatible[9] = {
21604 /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8 */
21608
21609 /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED
21610 * Note: INT8 is -not- copy compatible, e.g. -1 would coerce to 0x00.
21611 */
21614
21615 /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT8 */
21619
21620 /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT16 */
21623
21624 /* 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:
= {
1,
2,
4,
4,
8,
0
}

Definition at line 21569 of file duktape-1.5.2/src/duktape.c.

◆ duk__buffer_proto_from_elemtype

◆ duk__bufferobject_virtual_props

DUK_LOCAL const duk_uint16_t duk__bufferobject_virtual_props[]
Initial value:

Definition at line 46156 of file duktape-1.5.2/src/duktape.c.

46159 :
46160 * non-snapshot-based approaches are difficult to reconcile with mutating
46161 * the enumeration target, running multiple long-lived enumerators at the

◆ duk__bufobj_flags_lookup

const duk_uint32_t duk__bufobj_flags_lookup[]
static

◆ duk__closure_copy_proplist

DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[]

◆ 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)
}
#define DUK__YEAR(x)

Definition at line 24466 of file duktape-1.5.2/src/duktape.c.

24469 { \
24470 DUK_D(DUK_DPRINT("dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
24471 (double) (dparts)[0], (double) (dparts)[1], \
24472 (double) (dparts)[2], (double) (dparts)[3], \
24473 (double) (dparts)[4], (double) (dparts)[5], \
24474 (double) (dparts)[6], (double) (dparts)[7])); \
24475 } while (0)
24476
24477/* Equivalent year for DST calculations outside [1970,2038[ range, see
24478 * E5 Section 15.9.1.8. Equivalent year has the same leap-year-ness and
24479 * starts with the same weekday on Jan 1.
24480 * https://bugzilla.mozilla.org/show_bug.cgi?id=351066
24481 */
24482#define DUK__YEAR(x) ((duk_uint8_t) ((x) - 1970))
24483DUK_LOCAL duk_uint8_t duk__date_equivyear[14] = {
24484#if 1
24485 /* This is based on V8 EquivalentYear() algorithm (see src/genequivyear.py):
24486 * http://code.google.com/p/v8/source/browse/trunk/src/date.h#146
24487 */
24488
24489 /* non-leap year: sunday, monday, ... */
24490 DUK__YEAR(2023), DUK__YEAR(2035), DUK__YEAR(2019), DUK__YEAR(2031),
24491 DUK__YEAR(2015), DUK__YEAR(2027), DUK__YEAR(2011),
24492
24493 /* leap year: sunday, monday, ... */
24494 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 25705 of file duktape-1.5.2/src/duktape.c.

25722 {
25723 /* 0: toString */
25725
25726 /* 1: toDateString */
25728
25729 /* 2: toTimeString */
25731
25732 /* 3: toLocaleString */
25734
25735 /* 4: toLocaleDateString */
25737
25738 /* 5: toLocaleTimeString */
25740
25741 /* 6: toUTCString */
25743
25744 /* 7: toISOString */
25746
25747 /* 8: getFullYear */
25749
25750 /* 9: getUTCFullYear */
25752
25753 /* 10: getMonth */
25755
25756 /* 11: getUTCMonth */
25758
25759 /* 12: getDate */
25761
25762 /* 13: getUTCDate */
25764
25765 /* 14: getDay */
25767
25768 /* 15: getUTCDay */
25770
25771 /* 16: getHours */
25773
25774 /* 17: getUTCHours */
25776
25777 /* 18: getMinutes */
25779
25780 /* 19: getUTCMinutes */
25782
25783 /* 20: getSeconds */
25785
25786 /* 21: getUTCSeconds */
25788
25789 /* 22: getMilliseconds */
25791
25792 /* 23: getUTCMilliseconds */
25794
25795 /* 24: setMilliseconds */
25797
25798 /* 25: setUTCMilliseconds */
25800
25801 /* 26: setSeconds */
25803
25804 /* 27: setUTCSeconds */
25806
25807 /* 28: setMinutes */
25809
25810 /* 29: setUTCMinutes */
25812
25813 /* 30: setHours */
25815
25816 /* 31: setUTCHours */
25818
25819 /* 32: setDate */
25821
25822 /* 33: setUTCDate */
25823 0 + (1 << DUK_DATE_FLAG_VALUE_SHIFT),
25824
25825 /* 34: setMonth */
#define DUK_DATE_FLAG_TOSTRING_DATE

◆ 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 24826 of file duktape-1.5.2/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),
}
#define DUK__MKBITS(a, b, c, d, e, f, g, h)

Definition at line 27657 of file duktape-1.5.2/src/duktape.c.

27662 {
27663 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */
27664 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */
27665 DUK__MKBITS(0, 0, 0, 1, 1, 0, 1, 0), DUK__MKBITS(0, 0, 0, 1, 1, 0, 0, 1), /* 0x20-0x2f */
27666 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 27645 of file duktape-1.5.2/src/duktape.c.

27650 {
27651 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */
27652 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */
27653 DUK__MKBITS(0, 1, 0, 0, 0, 0, 0, 1), DUK__MKBITS(1, 1, 1, 0, 0, 1, 1, 0), /* 0x20-0x2f */
27654 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 27633 of file duktape-1.5.2/src/duktape.c.

27638 {
27639 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */
27640 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */
27641 DUK__MKBITS(0, 1, 0, 1, 1, 0, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x20-0x2f */
27642 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 27621 of file duktape-1.5.2/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 27670 of file duktape-1.5.2/src/duktape.c.

27674 {
27675 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */
27676 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */
27677 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x20-0x2f */
27678 DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x30-0x3f */
27679 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 11348 of file duktape-1.5.2/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 29049 of file duktape-1.5.2/src/duktape.c.

29066 {
29067 /* 0x00: finish (not part of number)
29068 * 0x01: continue
29069 */

◆ 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 29001 of file duktape-1.5.2/src/duktape.c.

29009 {
29014};
29015#endif /* DUK_USE_JSON_QUOTESTRING_FASTPATH */
29016
29017#if defined(DUK_USE_JSON_DECSTRING_FASTPATH)
29018DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256] = {
29019 /* 0x00: slow path
29020 * other: as is
29021 */

◆ 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 29025 of file duktape-1.5.2/src/duktape.c.

29042 {
29043 /* 0x00: finish (non-white)
29044 * 0x01: continue
29045 */

◆ 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 28967 of file duktape-1.5.2/src/duktape.c.

28984 {
28985 /* 0x00 ... 0x7f: as is
28986 * 0x80: escape generically
28987 * 0x81: slow path
28988 * 0xa0 ... 0xff: backslash + one char
28989 */
28990

◆ 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 32036 of file duktape-1.5.2/src/duktape.c.

◆ duk__one_arg_funcs

DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[]

Definition at line 32570 of file duktape-1.5.2/src/duktape.c.

32572 {
32573 return DUK_SIN(x);
32574}
32575DUK_LOCAL double duk__sqrt(double x) {
32576 return DUK_SQRT(x);
32577}
32578DUK_LOCAL double duk__tan(double x) {
32579 return DUK_TAN(x);
32580}
32581DUK_LOCAL double duk__atan2(double x, double y) {
32582 return DUK_ATAN2(x, y);
32583}
32584#endif /* DUK_USE_AVOID_PLATFORM_FUNCPTRS */
32585
32586/* order must match constants in genbuiltins.py */
32588#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
32589 duk__fabs,
32590 duk__acos,
32591 duk__asin,
32592 duk__atan,
32593 duk__ceil,
32594 duk__cos,
32595 duk__exp,
32596 duk__floor,
32597 duk__log,
32599 duk__sin,
32600 duk__sqrt,
DUK_LOCAL double duk__asin(double x)
DUK_LOCAL double duk__atan(double x)
DUK_LOCAL double duk__log(double x)
DUK_LOCAL double duk__sin(double x)
DUK_LOCAL double duk__ceil(double x)
DUK_LOCAL double duk__floor(double x)
DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[]
DUK_LOCAL double duk__exp(double x)
DUK_LOCAL double duk__fabs(double x)
DUK_LOCAL double duk__acos(double x)
DUK_LOCAL double duk__tan(double x)
DUK_LOCAL double duk__cos(double x)
DUK_LOCAL double duk__sqrt(double x)

◆ duk__parse_iso8601_control

DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[]
Initial value:
= {
}
#define DUK__PM_SECOND
#define DUK__SM_PERIOD
#define DUK__PM_MINUTE
#define DUK__PM_TZHOUR
#define DUK__PM_DAY
#define DUK__SM_PLUS
#define DUK__PM_YEAR
#define DUK__SM_SPACE
#define DUK__PM_MONTH
#define DUK__SM_COLON
#define DUK__PACK_RULE(partmask, sepmask, nextpart, flags)
#define DUK__PI_SECOND
#define DUK__SM_T
#define DUK__SM_MINUS
#define DUK__PM_HOUR
#define DUK__PM_MILLISECOND
#define DUK__SM_Z

Definition at line 24571 of file duktape-1.5.2/src/duktape.c.

24574 { \
24575 (var_nextidx) = (duk_small_uint_t) (((rule) >> 17) & 0x0f); \
24576 (var_flags) = (duk_small_uint_t) ((rule) >> 21); \
24577 } while (0)
24578
24579#define DUK__RULE_MASK_PART_SEP 0x1ffffUL
24580
24581/* Matching separator index is used in the control table */
24582DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[] = {
24583 DUK_ASC_PLUS /*0*/, DUK_ASC_MINUS /*1*/, DUK_ASC_UC_T /*2*/, DUK_ASC_SPACE /*3*/,
24584 DUK_ASC_COLON /*4*/, DUK_ASC_PERIOD /*5*/, DUK_ASC_UC_Z /*6*/, DUK_ASC_NUL /*7*/
24585};
24586
24587/* Rule table: first matching rule is used to determine what to do next. */
24588DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[] = {

◆ duk__parse_iso8601_seps

DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[]

◆ 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 75134 of file duktape-1.5.2/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 75146 of file duktape-1.5.2/src/duktape.c.

75151 {
75152 69, 44, 35, 30, 27, 25, 23, 22, 20, 20, /* 2 to 11 */
75153 20, 19, 19, 18, 18, 17, 17, 17, 16, 16, /* 12 to 21 */
75154 16, 16, 16, 15, 15, 15, 15, 15, 15, 14, /* 22 to 31 */
75155 14, 14, 14, 14, 14 /* 31 to 36 */
75156};

◆ duk__token_lbp

DUK_LOCAL const duk_uint8_t duk__token_lbp[]

Definition at line 57737 of file duktape-1.5.2/src/duktape.c.

57754 {
57755 DUK__MK_LBP(DUK__BP_EOF), /* DUK_TOK_EOF */
57757 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_BREAK */
57758 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CASE */
57759 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CATCH */
57760 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CONTINUE */
57761 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DEBUGGER */
57762 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DEFAULT */
57763 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DELETE */
57764 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DO */
57765 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_ELSE */
57766 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_FINALLY */
57767 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_FOR */
57768 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_FUNCTION */
57769 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_IF */
57770 DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_IN */
57771 DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_INSTANCEOF */
57772 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_NEW */
57773 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_RETURN */
57774 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SWITCH */
57776 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_THROW */
57777 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_TRY */
57778 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_TYPEOF */
57779 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_VAR */
57780 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CONST */
57781 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_VOID */
57782 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_WHILE */
57783 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_WITH */
57784 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CLASS */
57785 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_ENUM */
57786 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_EXPORT */
57787 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_EXTENDS */
57788 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_IMPORT */
57789 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SUPER */
57793 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_GET */
57794 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SET */
57795 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_IMPLEMENTS */
57796 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_INTERFACE */
57797 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LET */
57798 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PACKAGE */
57799 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PRIVATE */
57800 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PROTECTED */
57801 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PUBLIC */
57802 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_STATIC */
57803 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_YIELD */
57804 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LCURLY */
57806 DUK__MK_LBP(DUK__BP_MEMBER), /* DUK_TOK_LBRACKET */
57808 DUK__MK_LBP(DUK__BP_CALL), /* DUK_TOK_LPAREN */
57810 DUK__MK_LBP(DUK__BP_MEMBER), /* DUK_TOK_PERIOD */
57811 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SEMICOLON */
57812 DUK__MK_LBP(DUK__BP_COMMA), /* DUK_TOK_COMMA */
57813 DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_LT */
57814 DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_GT */
57815 DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_LE */
57816 DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_GE */
57817 DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_EQ */
57818 DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_NEQ */
57819 DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_SEQ */
57820 DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_SNEQ */
57821 DUK__MK_LBP(DUK__BP_ADDITIVE), /* DUK_TOK_ADD */
57822 DUK__MK_LBP(DUK__BP_ADDITIVE), /* DUK_TOK_SUB */
57823 DUK__MK_LBP(DUK__BP_MULTIPLICATIVE), /* DUK_TOK_MUL */
57824 DUK__MK_LBP(DUK__BP_MULTIPLICATIVE), /* DUK_TOK_DIV */
57825 DUK__MK_LBP(DUK__BP_MULTIPLICATIVE), /* DUK_TOK_MOD */
57826 DUK__MK_LBP(DUK__BP_POSTFIX), /* DUK_TOK_INCREMENT */
57827 DUK__MK_LBP(DUK__BP_POSTFIX), /* DUK_TOK_DECREMENT */
57828 DUK__MK_LBP(DUK__BP_SHIFT), /* DUK_TOK_ALSHIFT */
57829 DUK__MK_LBP(DUK__BP_SHIFT), /* DUK_TOK_ARSHIFT */
57830 DUK__MK_LBP(DUK__BP_SHIFT), /* DUK_TOK_RSHIFT */
57831 DUK__MK_LBP(DUK__BP_BAND), /* DUK_TOK_BAND */
57832 DUK__MK_LBP(DUK__BP_BOR), /* DUK_TOK_BOR */
57833 DUK__MK_LBP(DUK__BP_BXOR), /* DUK_TOK_BXOR */
57834 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LNOT */
57835 DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_BNOT */
57836 DUK__MK_LBP(DUK__BP_LAND), /* DUK_TOK_LAND */
57837 DUK__MK_LBP(DUK__BP_LOR), /* DUK_TOK_LOR */
57838 DUK__MK_LBP(DUK__BP_CONDITIONAL), /* DUK_TOK_QUESTION */
#define DUK__MK_LBP(bp)
#define DUK__BP_CONDITIONAL
#define DUK__MK_LBP_FLAGS(bp, flags)
#define DUK__BP_POSTFIX
#define DUK__BP_MEMBER
#define DUK__BP_EOF
#define DUK__BP_INVALID
#define DUK__BP_CLOSING

◆ duk__two_arg_funcs

DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[]
Initial value:

Definition at line 32603 of file duktape-1.5.2/src/duktape.c.

◆ duk_api_global_filename

DUK_EXTERNAL const char* duk_api_global_filename = NULL

Definition at line 14954 of file duktape-1.5.2/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 14955 of file duktape-1.5.2/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 11282 of file duktape-1.5.2/src/duktape.c.

11286 {
11287 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, /* A...P */
11288 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, /* Q...f */
11289 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, /* g...v */
11290 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f /* w.../ */
11291};
11292#endif /* DUK_USE_BASE64_FASTPATH */
11293
11294/*
11295 * Table for base-64 decoding
11296 */
11297
11298#if defined(DUK_USE_BASE64_FASTPATH)
11299DUK_INTERNAL const duk_int8_t duk_base64_dectab[256] = {
11300 /* -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 11269 of file duktape-1.5.2/src/duktape.c.

◆ duk_bi_native_functions

DUK_INTERNAL const duk_c_function duk_bi_native_functions[149]

Definition at line 9053 of file duktape-1.5.2/src/duktape.c.

9070 {
DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_encoding(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_object_constructor_seal_freeze_shared(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_global_object_encode_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_array_prototype_splice(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_date_prototype_set_time(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_error_prototype_filename_setter(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_filename_getter(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_global_object_parse_int(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_array_prototype_pop(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_buffer_readfield(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_json_object_stringify(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_date_prototype_tostring_shared(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_math_object_onearg_shared(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_pointer_prototype_tostring_shared(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_string_constructor(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_nodejs_buffer_byte_length(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_array_prototype_unshift(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_object_constructor_is_sealed_frozen_shared(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_math_object_min(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_object_prototype_property_is_enumerable(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_function_prototype_bind(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_global_object_decode_uri(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_math_object_twoarg_shared(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_object_constructor_is_extensible(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_prototype_concat(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_error_prototype_stack_setter(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_array_prototype_shift(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_nodejs_buffer_constructor(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_arraybuffer_isview(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_array_prototype_iter_shared(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_array_prototype_reverse(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_boolean_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_object_constructor_define_property(duk_context *ctx)
DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx)

◆ duk_class_number_to_stridx

DUK_INTERNAL duk_uint8_t duk_class_number_to_stridx[32]

Definition at line 11500 of file duktape-1.5.2/src/duktape.c.

11517 {
11518 DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */
#define DUK_STRIDX_UC_ARGUMENTS
#define DUK_STRIDX_ARRAY
#define DUK_STRIDX_UC_BOOLEAN
#define DUK_STRIDX_MATH
#define DUK_STRIDX_UC_NUMBER
#define DUK_STRIDX_DEC_ENV
#define DUK_STRIDX_REG_EXP
#define DUK_STRIDX_UC_STRING
#define DUK_STRIDX_UC_OBJECT
#define DUK_STRIDX_DATE
#define DUK_STRIDX_JSON
#define DUK_STRIDX_OBJ_ENV
#define DUK_STRIDX_UC_ERROR
#define DUK_STRIDX_UC_FUNCTION

◆ 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 11135 of file duktape-1.5.2/src/duktape.c.

11141 {
11146};
11147
11148/*
11149 * Table for hex decoding ASCII hex digits
11150 */
11151
11152DUK_INTERNAL const duk_int8_t duk_hex_dectab[256] = {
11153 /* -1 if invalid */
#define DUK_ASC_2
#define DUK_ASC_8
#define DUK_ASC_5
#define DUK_ASC_6
#define DUK_ASC_7
#define DUK_ASC_1
#define DUK_ASC_4
#define DUK_ASC_3

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 11157 of file duktape-1.5.2/src/duktape.c.

11174 {

◆ duk_hex_enctab

DUK_INTERNAL const duk_uint16_t duk_hex_enctab[256]

Definition at line 11193 of file duktape-1.5.2/src/duktape.c.

11210 {
11211#if defined(DUK_USE_INTEGER_BE)
11212 0x3030U, 0x3031U, 0x3032U, 0x3033U, 0x3034U, 0x3035U, 0x3036U, 0x3037U,
11213 0x3038U, 0x3039U, 0x3061U, 0x3062U, 0x3063U, 0x3064U, 0x3065U, 0x3066U,
11214 0x3130U, 0x3131U, 0x3132U, 0x3133U, 0x3134U, 0x3135U, 0x3136U, 0x3137U,
11215 0x3138U, 0x3139U, 0x3161U, 0x3162U, 0x3163U, 0x3164U, 0x3165U, 0x3166U,
11216 0x3230U, 0x3231U, 0x3232U, 0x3233U, 0x3234U, 0x3235U, 0x3236U, 0x3237U,
11217 0x3238U, 0x3239U, 0x3261U, 0x3262U, 0x3263U, 0x3264U, 0x3265U, 0x3266U,
11218 0x3330U, 0x3331U, 0x3332U, 0x3333U, 0x3334U, 0x3335U, 0x3336U, 0x3337U,
11219 0x3338U, 0x3339U, 0x3361U, 0x3362U, 0x3363U, 0x3364U, 0x3365U, 0x3366U,
11220 0x3430U, 0x3431U, 0x3432U, 0x3433U, 0x3434U, 0x3435U, 0x3436U, 0x3437U,
11221 0x3438U, 0x3439U, 0x3461U, 0x3462U, 0x3463U, 0x3464U, 0x3465U, 0x3466U,
11222 0x3530U, 0x3531U, 0x3532U, 0x3533U, 0x3534U, 0x3535U, 0x3536U, 0x3537U,
11223 0x3538U, 0x3539U, 0x3561U, 0x3562U, 0x3563U, 0x3564U, 0x3565U, 0x3566U,
11224 0x3630U, 0x3631U, 0x3632U, 0x3633U, 0x3634U, 0x3635U, 0x3636U, 0x3637U,
11225 0x3638U, 0x3639U, 0x3661U, 0x3662U, 0x3663U, 0x3664U, 0x3665U, 0x3666U,
11226 0x3730U, 0x3731U, 0x3732U, 0x3733U, 0x3734U, 0x3735U, 0x3736U, 0x3737U,
11227 0x3738U, 0x3739U, 0x3761U, 0x3762U, 0x3763U, 0x3764U, 0x3765U, 0x3766U,
11228 0x3830U, 0x3831U, 0x3832U, 0x3833U, 0x3834U, 0x3835U, 0x3836U, 0x3837U,
11229 0x3838U, 0x3839U, 0x3861U, 0x3862U, 0x3863U, 0x3864U, 0x3865U, 0x3866U,
11230 0x3930U, 0x3931U, 0x3932U, 0x3933U, 0x3934U, 0x3935U, 0x3936U, 0x3937U,
11231 0x3938U, 0x3939U, 0x3961U, 0x3962U, 0x3963U, 0x3964U, 0x3965U, 0x3966U,
11232 0x6130U, 0x6131U, 0x6132U, 0x6133U, 0x6134U, 0x6135U, 0x6136U, 0x6137U,
11233 0x6138U, 0x6139U, 0x6161U, 0x6162U, 0x6163U, 0x6164U, 0x6165U, 0x6166U,
11234 0x6230U, 0x6231U, 0x6232U, 0x6233U, 0x6234U, 0x6235U, 0x6236U, 0x6237U,
11235 0x6238U, 0x6239U, 0x6261U, 0x6262U, 0x6263U, 0x6264U, 0x6265U, 0x6266U,
11236 0x6330U, 0x6331U, 0x6332U, 0x6333U, 0x6334U, 0x6335U, 0x6336U, 0x6337U,
11237 0x6338U, 0x6339U, 0x6361U, 0x6362U, 0x6363U, 0x6364U, 0x6365U, 0x6366U,
11238 0x6430U, 0x6431U, 0x6432U, 0x6433U, 0x6434U, 0x6435U, 0x6436U, 0x6437U,
11239 0x6438U, 0x6439U, 0x6461U, 0x6462U, 0x6463U, 0x6464U, 0x6465U, 0x6466U,
11240 0x6530U, 0x6531U, 0x6532U, 0x6533U, 0x6534U, 0x6535U, 0x6536U, 0x6537U,
11241 0x6538U, 0x6539U, 0x6561U, 0x6562U, 0x6563U, 0x6564U, 0x6565U, 0x6566U,
11242 0x6630U, 0x6631U, 0x6632U, 0x6633U, 0x6634U, 0x6635U, 0x6636U, 0x6637U,
11243 0x6638U, 0x6639U, 0x6661U, 0x6662U, 0x6663U, 0x6664U, 0x6665U, 0x6666U
11244#else /* DUK_USE_INTEGER_BE */
11245 0x3030U, 0x3130U, 0x3230U, 0x3330U, 0x3430U, 0x3530U, 0x3630U, 0x3730U,
11246 0x3830U, 0x3930U, 0x6130U, 0x6230U, 0x6330U, 0x6430U, 0x6530U, 0x6630U,
11247 0x3031U, 0x3131U, 0x3231U, 0x3331U, 0x3431U, 0x3531U, 0x3631U, 0x3731U,
11248 0x3831U, 0x3931U, 0x6131U, 0x6231U, 0x6331U, 0x6431U, 0x6531U, 0x6631U,
11249 0x3032U, 0x3132U, 0x3232U, 0x3332U, 0x3432U, 0x3532U, 0x3632U, 0x3732U,
11250 0x3832U, 0x3932U, 0x6132U, 0x6232U, 0x6332U, 0x6432U, 0x6532U, 0x6632U,
11251 0x3033U, 0x3133U, 0x3233U, 0x3333U, 0x3433U, 0x3533U, 0x3633U, 0x3733U,
11252 0x3833U, 0x3933U, 0x6133U, 0x6233U, 0x6333U, 0x6433U, 0x6533U, 0x6633U,
11253 0x3034U, 0x3134U, 0x3234U, 0x3334U, 0x3434U, 0x3534U, 0x3634U, 0x3734U,
11254 0x3834U, 0x3934U, 0x6134U, 0x6234U, 0x6334U, 0x6434U, 0x6534U, 0x6634U,
11255 0x3035U, 0x3135U, 0x3235U, 0x3335U, 0x3435U, 0x3535U, 0x3635U, 0x3735U,
11256 0x3835U, 0x3935U, 0x6135U, 0x6235U, 0x6335U, 0x6435U, 0x6535U, 0x6635U,
11257 0x3036U, 0x3136U, 0x3236U, 0x3336U, 0x3436U, 0x3536U, 0x3636U, 0x3736U,
11258 0x3836U, 0x3936U, 0x6136U, 0x6236U, 0x6336U, 0x6436U, 0x6536U, 0x6636U,
11259 0x3037U, 0x3137U, 0x3237U, 0x3337U, 0x3437U, 0x3537U, 0x3637U, 0x3737U,
11260 0x3837U, 0x3937U, 0x6137U, 0x6237U, 0x6337U, 0x6437U, 0x6537U, 0x6637U,
11261 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 9205 of file duktape-1.5.2/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 9939 of file duktape-1.5.2/src/duktape.c.

◆ duk_lc_digits

DUK_INTERNAL const duk_uint8_t duk_lc_digits[36]
Initial value:
= {
}
#define DUK_ASC_LC_M
#define DUK_ASC_LC_Z
#define DUK_ASC_LC_C
#define DUK_ASC_LC_L
#define DUK_ASC_LC_J
#define DUK_ASC_LC_Y
#define DUK_ASC_LC_P
#define DUK_ASC_LC_K
#define DUK_ASC_LC_D
#define DUK_ASC_LC_H
#define DUK_ASC_LC_G
#define DUK_ASC_LC_I
#define DUK_ASC_LC_O
#define DUK_ASC_LC_Q
#define DUK_ASC_LC_W
#define DUK_ASC_LC_S
#define DUK_ASC_LC_A
#define DUK_ASC_LC_V

Definition at line 11112 of file duktape-1.5.2/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 8755 of file duktape-1.5.2/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 8780 of file duktape-1.5.2/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 8764 of file duktape-1.5.2/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 8779 of file duktape-1.5.2/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 8827 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_buffer_too_long

DUK_INTERNAL const char* duk_str_buffer_too_long = "buffer too long"

Definition at line 8753 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_bytecode_limit

DUK_INTERNAL const char* duk_str_bytecode_limit = "bytecode limit"

Definition at line 8830 of file duktape-1.5.2/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 8828 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_callstack_limit

DUK_INTERNAL const char* duk_str_callstack_limit = "callstack limit"

Definition at line 8824 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_cannot_delete_identifier

DUK_INTERNAL const char* duk_str_cannot_delete_identifier = "cannot delete identifier"

Definition at line 8793 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_catchstack_limit

DUK_INTERNAL const char* duk_str_catchstack_limit = "catchstack limit"

Definition at line 8825 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_compiler_recursion_limit

DUK_INTERNAL const char* duk_str_compiler_recursion_limit = "compiler recursion limit"

Definition at line 8829 of file duktape-1.5.2/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 8761 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_const_limit

DUK_INTERNAL const char* duk_str_const_limit = "const limit"

Definition at line 8833 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_cyclic_input

DUK_INTERNAL const char* duk_str_cyclic_input = "cyclic input"

Definition at line 8771 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_decode_failed

DUK_INTERNAL const char* duk_str_decode_failed = "decode failed"

Definition at line 8759 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_defaultvalue_coerce_failed

DUK_INTERNAL const char* duk_str_defaultvalue_coerce_failed = "[[DefaultValue]] coerce failed"

Definition at line 8749 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_duplicate_label

DUK_INTERNAL const char* duk_str_duplicate_label = "duplicate label"

Definition at line 8788 of file duktape-1.5.2/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 8797 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_encode_failed

DUK_INTERNAL const char* duk_str_encode_failed = "encode failed"

Definition at line 8758 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_expected_identifier

DUK_INTERNAL const char* duk_str_expected_identifier = "expected identifier"

Definition at line 8796 of file duktape-1.5.2/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 8768 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_fmt_ptr

DUK_INTERNAL const char* duk_str_fmt_ptr = "%p"

Definition at line 8767 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_func_limit

DUK_INTERNAL const char* duk_str_func_limit = "function limit"

Definition at line 8834 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_func_name_required

DUK_INTERNAL const char* duk_str_func_name_required = "function name required"

Definition at line 8810 of file duktape-1.5.2/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 8805 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_internal_error

DUK_INTERNAL const char* duk_str_internal_error = "internal error"

Definition at line 8736 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_arg_name

DUK_INTERNAL const char* duk_str_invalid_arg_name = "invalid argument name"

Definition at line 8807 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_array_length

DUK_INTERNAL const char* duk_str_invalid_array_length = "invalid array length"

Definition at line 8778 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_array_literal

DUK_INTERNAL const char* duk_str_invalid_array_literal = "invalid array literal"

Definition at line 8790 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_backrefs

DUK_INTERNAL const char* duk_str_invalid_backrefs = "invalid backreference(s)"

Definition at line 8820 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_base

DUK_INTERNAL const char* duk_str_invalid_base = "invalid base value"

Definition at line 8775 of file duktape-1.5.2/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 8800 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_call_args

DUK_INTERNAL const char* duk_str_invalid_call_args = "invalid call args"

Definition at line 8738 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_context

DUK_INTERNAL const char* duk_str_invalid_context = "invalid context"

Definition at line 8745 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_count

DUK_INTERNAL const char* duk_str_invalid_count = "invalid count"

Definition at line 8737 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_descriptor

DUK_INTERNAL const char* duk_str_invalid_descriptor = "invalid descriptor"

Definition at line 8783 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_expression

DUK_INTERNAL const char* duk_str_invalid_expression = "invalid expression"

Definition at line 8794 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_for

DUK_INTERNAL const char* duk_str_invalid_for = "invalid for statement"

Definition at line 8798 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_func_name

DUK_INTERNAL const char* duk_str_invalid_func_name = "invalid function name"

Definition at line 8808 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_getset_name

DUK_INTERNAL const char* duk_str_invalid_getset_name = "invalid getter/setter name"

Definition at line 8809 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_label

DUK_INTERNAL const char* duk_str_invalid_label = "invalid label"

Definition at line 8789 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_lvalue

DUK_INTERNAL const char* duk_str_invalid_lvalue = "invalid lvalue"

Definition at line 8795 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_object_literal

DUK_INTERNAL const char* duk_str_invalid_object_literal = "invalid object literal"

Definition at line 8791 of file duktape-1.5.2/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 8813 of file duktape-1.5.2/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 8814 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_regexp_flags

DUK_INTERNAL const char* duk_str_invalid_regexp_flags = "invalid regexp flags"

Definition at line 8819 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_return

DUK_INTERNAL const char* duk_str_invalid_return = "invalid return"

Definition at line 8801 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_switch

DUK_INTERNAL const char* duk_str_invalid_switch = "invalid switch statement"

Definition at line 8799 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_throw

DUK_INTERNAL const char* duk_str_invalid_throw = "invalid throw"

Definition at line 8803 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_try

DUK_INTERNAL const char* duk_str_invalid_try = "invalid try"

Definition at line 8802 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_invalid_var_declaration

DUK_INTERNAL const char* duk_str_invalid_var_declaration = "invalid variable declaration"

Definition at line 8792 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_jsondec_reclimit

DUK_INTERNAL const char* duk_str_jsondec_reclimit = "json decode recursion limit"

Definition at line 8769 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_jsonenc_reclimit

DUK_INTERNAL const char* duk_str_jsonenc_reclimit = "json encode recursion limit"

Definition at line 8770 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_no_sourcecode

DUK_INTERNAL const char* duk_str_no_sourcecode = "no sourcecode"

Definition at line 8760 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_buffer

DUK_INTERNAL const char* duk_str_not_buffer = "not buffer"

Definition at line 8747 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_callable

DUK_INTERNAL const char* duk_str_not_callable = "not callable"

Definition at line 8740 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_configurable

DUK_INTERNAL const char* duk_str_not_configurable = "not configurable"

Definition at line 8743 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_constructable

DUK_INTERNAL const char* duk_str_not_constructable = "not constructable"

Definition at line 8739 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_extensible

DUK_INTERNAL const char* duk_str_not_extensible = "not extensible"

Definition at line 8741 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_object_coercible

DUK_INTERNAL const char* duk_str_not_object_coercible = "not object coercible"

Definition at line 8751 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_not_writable

DUK_INTERNAL const char* duk_str_not_writable = "not writable"

Definition at line 8742 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_number_outside_range

DUK_INTERNAL const char* duk_str_number_outside_range = "number outside range"

Definition at line 8750 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_parse_error

DUK_INTERNAL const char* duk_str_parse_error = "parse error"

Definition at line 8787 of file duktape-1.5.2/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 8756 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_property_is_virtual

DUK_INTERNAL const char* duk_str_property_is_virtual = "property is virtual"

Definition at line 8784 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_prototype_chain_limit

DUK_INTERNAL const char* duk_str_prototype_chain_limit = "prototype chain limit"

Definition at line 8826 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_proxy_rejected

DUK_INTERNAL const char* duk_str_proxy_rejected = "proxy rejected"

Definition at line 8777 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_proxy_revoked

DUK_INTERNAL const char* duk_str_proxy_revoked = "proxy revoked"

Definition at line 8774 of file duktape-1.5.2/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 8746 of file duktape-1.5.2/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 8815 of file duktape-1.5.2/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 8782 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_reg_limit

DUK_INTERNAL const char* duk_str_reg_limit = "register limit"

Definition at line 8831 of file duktape-1.5.2/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 8835 of file duktape-1.5.2/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 8836 of file duktape-1.5.2/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 8837 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_setter_undefined

DUK_INTERNAL const char* duk_str_setter_undefined = "setter undefined"

Definition at line 8781 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_sprintf_too_long

DUK_INTERNAL const char* duk_str_sprintf_too_long = "sprintf message too long"

Definition at line 8754 of file duktape-1.5.2/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 8776 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_string_too_long

DUK_INTERNAL const char* duk_str_string_too_long = "string too long"

Definition at line 8752 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_temp_limit

DUK_INTERNAL const char* duk_str_temp_limit = "temp limit"

Definition at line 8832 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_unexpected_closing_paren

DUK_INTERNAL const char* duk_str_unexpected_closing_paren = "unexpected closing parenthesis"

Definition at line 8816 of file duktape-1.5.2/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 8817 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_unexpected_regexp_token

DUK_INTERNAL const char* duk_str_unexpected_regexp_token = "unexpected token in regexp"

Definition at line 8818 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_unexpected_type

DUK_INTERNAL const char* duk_str_unexpected_type = "unexpected type"

Definition at line 8748 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_unimplemented

DUK_INTERNAL const char* duk_str_unimplemented = "unimplemented"

Definition at line 8762 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_unsupported

DUK_INTERNAL const char* duk_str_unsupported = "unsupported"

Definition at line 8763 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_unterminated_stmt

DUK_INTERNAL const char* duk_str_unterminated_stmt = "unterminated statement"

Definition at line 8806 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_valstack_limit

DUK_INTERNAL const char* duk_str_valstack_limit = "valstack limit"

Definition at line 8823 of file duktape-1.5.2/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 8804 of file duktape-1.5.2/src/duktape.c.

◆ duk_str_wrong_buffer_type

DUK_INTERNAL const char* duk_str_wrong_buffer_type = "wrong buffer type"

Definition at line 8757 of file duktape-1.5.2/src/duktape.c.

◆ duk_strings_data

DUK_INTERNAL const duk_uint8_t duk_strings_data[1049]

Definition at line 8995 of file duktape-1.5.2/src/duktape.c.

9012 {
901379,104,209,144,168,105,6,78,182,139,90,122,8,154,140,35,103,35,117,193,73,
90145,52,116,180,104,166,135,52,189,4,98,12,27,178,156,80,211,31,161,115,150,
901564,52,221,109,24,18,68,157,24,38,67,118,36,55,73,119,151,164,140,93,18,117,
9016128,153,201,228,201,205,2,250,8,196,24,232,104,82,146,40,232,193,48,118,
9017168,37,147,212,54,127,113,208,70,32,194,187,68,54,127,113,208,70,32,196,
9018123,68,54,127,113,209,44,12,121,7,208,70,32,194,186,134,207,236,126,219,
9019160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253,159,217,
9020116,17,136,48,190,209,13,159,217,253,151,65,24,131,12,233,86,224,79,236,
9021254,203,160,140,65,134,116,171,112,39,246,223,105,208,70,32,193,140,183,4,
902211,55,92,20,244,141,169,186,50,11,164,109,77,208,208,165,36,79,215,185,13,
9023153,34,110,204,241,32,6,66,84,11,112,200,84,52,157,124,92,242,70,120,45,64,
9024186,17,22,138,38,0,172,140,19,154,84,26,145,0,86,69,17,180,97,34,0,172,132,
902575,144,215,77,221,91,132,5,147,178,156,80,211,30,160,93,9,215,21,115,119,
9026169,49,75,211,138,26,101,205,222,68,157,47,78,40,105,151,55,120,204,156,
9027189,56,161,166,52,157,72,136,138,65,154,232,147,162,4,136,150,81,115,66,
9028208,210,37,96,148,250,134,140,151,39,212,125,255,221,125,73,80,209,146,233,
9029124,93,55,79,15,34,196,230,202,113,160,166,232,157,132,148,128,98,28,46,
9030114,200,6,153,180,96,73,19,74,113,67,76,103,5,36,20,211,70,140,133,67,72,
903149,245,160,235,81,212,52,168,106,39,132,253,111,80,210,161,168,158,5,245,
9032191,96,31,172,15,208,23,226,190,131,232,62,131,232,11,251,127,93,245,223,
903393,251,172,234,27,80,45,3,250,14,140,19,34,65,19,81,132,108,228,97,1,107,
903433,12,32,45,100,136,206,9,12,196,155,134,69,146,100,235,226,231,146,51,194,
903572,218,48,145,4,200,119,89,189,81,49,39,72,147,235,226,233,186,120,121,58,
9036226,167,90,124,93,55,107,71,137,33,68,68,130,64,206,75,189,209,156,144,84,
903744,141,3,8,137,187,178,156,80,211,26,110,242,100,230,146,120,121,8,48,76,6,
903889,26,105,157,65,196,201,213,145,166,153,212,28,76,157,113,75,34,78,62,14,
903938,73,105,228,142,136,178,48,141,152,228,73,150,83,0,148,39,137,75,67,73,
9040214,209,129,36,85,190,206,32,17,6,9,128,141,3,8,130,161,100,235,64,194,24,
904152,41,73,19,189,200,108,201,19,111,181,2,232,66,239,173,37,230,157,244,56,
9042153,4,225,145,27,233,93,22,1,114,62,251,80,69,128,121,247,213,146,228,109,
904379,190,212,17,35,106,125,246,78,164,68,68,111,175,23,217,45,13,33,119,208,
904468,210,38,250,192,61,91,233,80,208,45,25,36,81,190,156,13,26,201,19,239,
9045162,2,214,66,31,125,153,226,64,13,27,236,72,96,130,68,62,251,48,68,196,153,
9046119,217,157,18,56,156,199,161,100,42,26,250,77,36,140,122,40,144,19,34,9,

◆ duk_uc_nybbles

◆ 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 80215 of file duktape-1.5.2/src/duktape.c.

80232 {
80233144,3,0,3,128,184,6,192,7,192,112,24,144,37,96,64,54,32,81,64,128,226,0,
80234235,65,129,199,1,230,130,3,145,3,177,34,7,70,7,134,36,15,244,13,236,24,32,
802350,34,129,0,65,0,67,4,0,166,32,172,41,132,40,11,64,19,15,132,15,128,8,31,24,
8023631,16,12,62,80,62,64,32,124,224,124,192,64,250,64,250,0,97,246,129,246,1,3,
80237241,3,240,2,7,230,7,228,4,15,212,15,208,8,31,184,31,176,4,63,116,62,224,8,
80238127,32,125,200,32,254,192,254,128,33,253,161,247,96,67,253,3,252,0,135,250,
80239135,222,129,15,252,15,188,2,31,250,31,124,4,66,192,66,224,64,146,216,147,
8024064,209,96,1,97,130,242,199,224,35,240,95,228,63,232,38,161,1,0,1,1,48,2,
80241100,2,102,12,4,228,4,232,64,10,80,10,89,112,23,144,23,160,96,48,64,48,96,
80242128,104,0,104,65,128,217,128,218,2,1,203,1,204,18,3,188,3,190,36,7,200,7,
80243204,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 80154 of file duktape-1.5.2/src/duktape.c.

80171 {
80172132,3,128,3,0,184,7,192,6,192,112,35,242,199,224,64,74,192,49,32,128,162,
80173128,108,65,1,189,129,254,131,3,173,3,136,6,7,98,7,34,68,15,12,14,140,72,30,
80174104,28,112,32,67,0,65,4,0,138,0,128,4,1,88,65,76,83,15,128,15,132,8,31,16,
8017531,24,12,62,64,62,80,32,124,192,124,224,64,250,0,250,64,97,246,1,246,129,3,
80176238,3,247,64,135,220,135,242,2,15,187,15,237,2,31,120,31,248,4,62,244,63,
80177212,8,125,240,127,232,16,253,128,253,192,33,253,1,253,128,67,252,3,253,0,
80178136,92,8,88,8,18,104,18,91,26,44,48,44,0,94,90,0,33,64,155,253,7,252,132,
80179212,0,32,32,32,6,0,76,192,76,129,128,157,0,156,136,1,75,1,74,46,2,244,2,
80180242,12,6,12,6,8,16,13,8,13,0,48,27,64,27,48,64,57,192,57,162,0,119,192,119,
80181132,128,252,128,252,20,2,35,2,34,18,4,142,4,140,20,13,196,13,192,16,30,200,
8018230,192,192,70,16,70,2,32,145,96,145,70,193,48,129,48,67,130,104,130,104,44,
8018330,1,30,0,150,61,66,61,64,192,125,68,125,100,33,99,65,99,56,50,200,18,200,
801846,69,157,133,157,96,169,144,105,144,11,211,64,211,64,12,167,35,167,34,15,
8018578,103,78,100,126,157,234,157,228,21,59,253,59,240,90,122,26,122,0,163,128,
80186214,128,214,2,1,197,1,196,6,3,140,3,136,12,7,200,7,196,16,20,0,13,48,32,63,
80187128,63,112,69,142,101,142,64,130,1,136,1,135,4,3,114,3,112,8,26,120,202,
80188120,176,65,1,30,1,29,130,2,105,1,150,5,255,96,22,160,115,128,31,224,47,0,
8018938,32,9,32,47,224,10,96,48,0,72,96,50,64,50,32,50,160,62,192,51,32,51,0,51,
8019064,71,160,51,192,68,0,53,0,52,224,55,224,62,224,59,160,49,192,62,96,62,32,
8019174,5,141,224,74,37,141,160,74,69,142,0,74,96,48,32,74,128,48,192,75,32,49,
80192224,75,96,50,0,76,0,50,96,76,96,50,128,76,180,241,160,77,0,50,224,77,101,
80193140,64,78,37,141,192,78,64,51,160,78,160,51,224,79,165,140,128,81,0,53,192,
8019481,32,72,128,81,128,72,160,82,64,54,224,104,160,115,32,110,224,110,192,117,
80195128,112,192,120,64,116,96,121,128,113,128,122,0,114,64,122,32,115,0,122,
80196160,116,192,122,192,116,0,122,224,121,224,126,0,115,64,126,32,116,32,126,
8019764,127,32,126,160,114,160,153,224,152,3,175,52,239,163,175,165,140,99,211,
8019899,204,3,247,192,115,35,252,163,253,132,41,196,38,68,48,132,48,101,140,37,
80199140,5,140,160,71,69,140,192,71,217,128,55,224,5,48,5,48,20,152,10,240,1,56,
802007,194,0,74,3,12,3,144,192,230,64,194,0,192,64,236,48,58,80,48,128,48,16,88,
80201120,20,212,21,72,122,90,0,72,3,49,30,151,128,21,0,194,7,166,32,5,112,48,
80202161,233,152,1,100,12,40,122,106,0,65,2,190,31,80,128,233,64,196,199,212,
80203176,58,80,49,48,48,1,245,76,14,148,12,76,12,4,125,91,3,165,3,19,3,66,31,
80204128,135,194,0,230,71,224,97,240,144,57,145,248,40,124,40,14,100,126,14,31,
8020511,3,153,31,132,135,195,0,230,71,225,97,240,208,57,145,248,104,124,56,14,
80206100,126,30,31,15,3,153,31,136,135,194,0,230,71,226,97,240,144,57,145,248,
80207168,124,40,14,100,126,46,31,11,3,153,31,140,135,195,0,230,71,227,97,240,
80208208,57,145,248,232,124,56,14,100,126,62,31,15,3,153,31,144,135,202,0,230,
8020971,228,97,242,144,57,145,249,40,124,168,14,100,126,78,31,43,3,153,31,148,
80210135,203,0,230,71,229,97,242,208,57,145,249,104,124,184,14,100,126,94,31,47,
802113,153,31,152,135,202,0,230,71,230,97,242,144,57,145,249,168,124,168,14,100,
80212126,110,31,43,3,153,31,156,135,203,0,230,71,231,97,242,208,57,145,249,232,
80213124,184,14,100,126,126,31,47,3,153,31,160,135,218,0,230,71,232,97,246,144,
8021457,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 80094 of file duktape-1.5.2/src/duktape.c.

80098 {
80099255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89,
80100249,0,
80101};
80102#endif
80103
80104#ifdef DUK_USE_SOURCE_NONBMP
80105/* IdentifierPart production with IdentifierStart and ASCII excluded */
80106/* duk_unicode_idp_m_ids_noa[] */
80107/*
80108 * Automatically generated by extract_chars.py, do not edit!
80109 */
80110
80111const duk_uint8_t duk_unicode_idp_m_ids_noa[397] = {
80112255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112,
80113245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34,
8011436,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 80070 of file duktape-1.5.2/src/duktape.c.

◆ duk_unicode_ids_noa

const duk_uint8_t duk_unicode_ids_noa[791]

Definition at line 79987 of file duktape-1.5.2/src/duktape.c.

80004 {
80005249,176,176,80,111,7,47,15,47,254,11,197,191,0,72,2,15,115,66,19,57,2,34,2,
80006240,66,244,50,247,185,248,234,241,99,8,241,127,58,240,182,47,31,241,191,21,
8000718,245,50,15,1,24,27,35,15,2,2,240,239,15,244,156,15,10,241,26,21,6,240,
80008101,10,4,15,9,240,159,157,242,100,15,4,8,159,1,98,102,115,19,240,98,98,4,
8000952,15,2,14,18,47,0,31,5,85,19,240,98,98,18,18,31,17,50,15,5,47,2,130,34,
80010240,98,98,18,68,15,4,15,1,31,21,115,19,240,98,98,18,68,15,16,18,47,1,15,3,
800112,84,34,52,18,2,20,20,36,191,8,15,38,114,34,240,114,146,68,15,12,23,31,21,
80012114,34,240,114,146,68,15,18,2,31,1,31,4,114,34,241,147,15,2,15,3,31,10,86,
80013240,36,240,130,130,3,111,44,242,2,29,111,44,18,3,18,3,7,50,98,34,2,3,18,50,
8001426,3,66,15,7,31,20,15,49,114,241,79,13,79,101,241,191,6,15,2,85,52,4,24,37,
80015205,15,3,241,107,241,178,4,255,224,59,35,54,32,35,63,25,35,63,17,35,54,32,
8001635,62,47,41,35,63,51,241,127,0,240,47,69,223,254,21,227,240,18,240,166,243,
80017180,47,1,194,63,0,240,47,0,240,47,0,194,47,1,242,79,21,5,15,53,244,137,241,
80018146,6,243,107,240,223,37,240,227,76,241,207,7,111,42,240,122,242,95,68,15,
8001979,241,255,3,111,41,240,238,31,2,241,111,12,241,79,27,43,241,79,93,50,63,0,
80020251,15,50,255,224,8,53,63,22,53,55,32,32,32,47,15,63,37,38,32,66,38,67,53,
8002192,98,38,246,96,224,240,44,245,112,80,57,32,68,112,32,32,35,42,51,100,80,
80022240,63,25,255,233,107,241,242,241,242,247,87,63,3,241,107,242,106,15,2,240,
80023122,98,98,98,98,98,98,98,111,66,15,254,12,146,240,184,132,52,95,70,114,47,
8002474,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 11051 of file duktape-1.5.2/src/duktape.c.

11051 : the description in E5 Section 15.10.2.6 has a typo, it
11052 * contains 'A' twice and lacks 'a'; the intent is [0-9a-zA-Z_].
11053 */

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 11073 of file duktape-1.5.2/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 11077 of file duktape-1.5.2/src/duktape.c.

11084 {
11085 (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
11086 (duk_uint16_t) 0x0041UL, (duk_uint16_t) 0x005AUL,
11087 (duk_uint16_t) 0x005FUL, (duk_uint16_t) 0x005FUL,
11088 (duk_uint16_t) 0x0061UL, (duk_uint16_t) 0x007AUL,
11089};
11090DUK_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 11091 of file duktape-1.5.2/src/duktape.c.

11094 {
11095 (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x0008UL,
11096 (duk_uint16_t) 0x000EUL, (duk_uint16_t) 0x001FUL,
11097 (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 11054 of file duktape-1.5.2/src/duktape.c.

11057 {
11058 return 1;
11059 }
11060 return 0;
11061}
11062
11063/*
11064 * Regexp range tables
11065 */
11066

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 11067 of file duktape-1.5.2/src/duktape.c.

11068 {
11069 (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
11070};
11071DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_white[22] = {
11072 (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 10007 of file duktape-1.5.2/src/duktape.c.

10008 {
10009 /* 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 11363 of file duktape-1.5.2/src/duktape.c.

11365 {
11366 17, /* minimum prime */