|
NetSurf
|
#include "duktape.h"Go to the source code of this file.
| #define DUK__ADVANCEBYTES | ( | lex_ctx, | |
| count | |||
| ) | duk__advance_bytes((lex_ctx), (count)) |
| #define DUK__ADVANCECHARS | ( | lex_ctx, | |
| count | |||
| ) | duk__advance_chars((lex_ctx), (count)) |
| #define DUK__ADVTOK | ( | advbytes, | |
| tok | |||
| ) | ((((advbytes) * sizeof(duk_lexer_codepoint)) << 8) + (tok)) |
| #define DUK__ALLOCTEMP | ( | comp_ctx | ) | duk__alloctemp((comp_ctx)) |
| #define DUK__ALLOCTEMPS | ( | comp_ctx, | |
| count | |||
| ) | duk__alloctemps((comp_ctx), (count)) |
| #define DUK__ALLOW_AUTO_SEMI_ALWAYS (1 << 2) /* allow automatic semicolon even without lineterm (compatibility) */ |
| #define DUK__APPENDBUFFER | ( | lex_ctx, | |
| x | |||
| ) | duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x)) |
| #define DUK__APPENDBUFFER_ASCII | ( | lex_ctx, | |
| x | |||
| ) | duk__appendbuffer_ascii((lex_ctx), (duk_codepoint_t) (x)) |
| #define DUK__ASSERT_LEFT | ( | n | ) |
| #define DUK__ASSERT_SPACE | ( | ) |
| #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__BYTEOFF_A | ( | ins | ) | (((ins) >> DUK__SHIFT_A) & DUK__MASK_A) |
| #define DUK__BYTEOFF_B | ( | ins | ) | (((ins) >> DUK__SHIFT_B) & DUK__MASK_B) |
| #define DUK__BYTEOFF_BC | ( | ins | ) | (((ins) >> DUK__SHIFT_BC) & DUK__MASK_BC) |
| #define DUK__BYTEOFF_C | ( | ins | ) | (((ins) >> DUK__SHIFT_C) & DUK__MASK_C) |
| #define DUK__CF_ACCEPT_NUL (1 << 2) /* accept string if next char is NUL (otherwise reject) */ |
| #define DUK__CF_NEG (1 << 0) /* continue matching, set neg_tzoffset flag */ |
| #define DUK__CHECK_BITMASK | ( | table, | |
| cp | |||
| ) | ((table)[(cp) >> 3] & (1 << ((cp) &0x07))) |
| #define DUK__CHECK_SPACE | ( | ) |
| #define DUK__COMPARE_BODY | ( | arg1, | |
| arg2, | |||
| flags | |||
| ) |
| #define DUK__CONST_MARKER DUK_REGCONST_CONST_MARKER |
| #define DUK__CONSTP_A | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) consts + DUK__BYTEOFF_A((ins)))) |
| #define DUK__CONSTP_B | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) consts + DUK__BYTEOFF_B((ins)))) |
| #define DUK__CONSTP_BC | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) consts + DUK__BYTEOFF_BC((ins)))) |
| #define DUK__CONSTP_C | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) consts + DUK__BYTEOFF_C((ins)))) |
| #define DUK__CP_CONTINUE (-1) /* continue to next byte, no completed codepoint */ |
| #define DUK__CP_RETRY (-3) /* decoding error; retry last byte */ |
| #define DUK__DBLUNION_IS_ANYINF | ( | u | ) | ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x7ff00000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_IS_ANYZERO | ( | u | ) | ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x00000000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_IS_NAN_FULL | ( | u | ) |
| #define DUK__DBLUNION_IS_NAN_NOTFULL | ( | u | ) |
| #define DUK__DBLUNION_IS_NEGINF | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] == 0xfff00000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_IS_NEGZERO | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] == 0x80000000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL | ( | u | ) |
| #define DUK__DBLUNION_IS_POSINF | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff00000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_IS_POSZERO | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] == 0x00000000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) |
| #define DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL | ( | u | ) |
| #define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL | ( | u | ) |
| #define DUK__DBLUNION_SET_NAN_FULL | ( | u | ) |
| #define DUK__DBLUNION_SET_NAN_NOTFULL | ( | u | ) |
| #define DUK__DECREF_ASSERTS | ( | ) |
| #define DUK__DECREF_SHARED | ( | ) |
| #define DUK__DELPROP_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__DIGITCHAR | ( | x | ) | duk_lc_digits[(x)] |
| #define DUK__DOUBLE_INT_CAST1 | ( | tname, | |
| minval, | |||
| maxval | |||
| ) |
| #define DUK__DOUBLE_INT_CAST2 | ( | tname, | |
| minval, | |||
| maxval | |||
| ) |
| #define DUK__DOUBLE_INT_CAST3 | ( | tname, | |
| minval, | |||
| maxval | |||
| ) |
| #define DUK__DOUBLE_INT_CAST4 | ( | tname, | |
| minval, | |||
| maxval | |||
| ) |
| #define DUK__DPRINT_DPARTS | ( | dparts | ) |
| #define DUK__DPRINT_PARTS | ( | parts | ) |
| #define DUK__DPRINT_PARTS_AND_DPARTS | ( | parts, | |
| dparts | |||
| ) |
| #define DUK__DRAGON4_OUTPUT_PREINC | ( | nc_ctx, | |
| preinc_idx, | |||
| x | |||
| ) |
| #define DUK__DUMP_ISPEC | ( | comp_ctx, | |
| x | |||
| ) |
| #define DUK__DUMP_IVALUE | ( | comp_ctx, | |
| x | |||
| ) |
| #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_CSTR | ( | js_ctx, | |
| p | |||
| ) | duk__emit_cstring((js_ctx), (p)) |
| #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_BC_REGCONST (1 << 14) /* slots B and C are reg/const */ |
| #define DUK__EMIT_FLAG_C_IS_TARGET (1 << 13) /* slot C is a target (default: source) */ |
| #define DUK__EMIT_FLAG_RESERVE_JUMPSLOT (1 << 15) /* reserve a jumpslot after instr before target spilling, used for NEXTENUM */ |
| #define DUK__EMIT_HSTR | ( | js_ctx, | |
| h | |||
| ) | duk__emit_hstring((js_ctx), (h)) |
| #define DUK__EMIT_STRIDX | ( | js_ctx, | |
| i | |||
| ) | duk__emit_stridx((js_ctx), (i)) |
| #define DUK__EQ_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__ERRFMT_BUFSIZE 256 /* size for formatting buffers */ |
| #define DUK__ERROR_STASH_SHARED | ( | code | ) |
| #define DUK__EXPR_FLAG_ALLOW_EMPTY (1 << 9) /* allow empty expression */ |
| #define DUK__EXPR_FLAG_REJECT_IN (1 << 8) /* reject 'in' token (used for for-in) */ |
| #define DUK__EXPR_FLAG_REQUIRE_INIT (1 << 10) /* require initializer for var/const */ |
| #define DUK__FLOAT_MAX 340282346638528859811704183484516925440.0 |
| #define DUK__FLOAT_ROUND_LIMIT 340282356779733623858607532500980858880.0 |
| #define DUK__FUN | ( | ) | ((duk_hcompfunc *) DUK_ACT_GET_FUNC((thr)->callstack_curr)) |
| #define DUK__FUNC_FLAG_DECL (1 << 0) /* Parsing a function declaration. */ |
| #define DUK__FUNC_FLAG_GETSET (1 << 1) /* Parsing an object literal getter/setter. */ |
| #define DUK__FUNC_FLAG_METDEF (1 << 2) /* Parsing an object literal method definition shorthand. */ |
| #define DUK__FUNC_FLAG_PUSHNAME_PASS1 (1 << 3) /* Push function name when creating template (first pass only). */ |
| #define DUK__FUNC_FLAG_USE_PREVTOKEN (1 << 4) /* Use prev_token to start function parsing (workaround for object literal). */ |
| #define DUK__GE_BODY | ( | barg, | |
| carg | |||
| ) | DUK__COMPARE_BODY((barg), (carg), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST | DUK_COMPARE_FLAG_NEGATE) |
| #define DUK__GETPROP_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__GETPROPC_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__GETTEMP | ( | comp_ctx | ) | ((comp_ctx)->curr_func.temp_next) |
| #define DUK__GT_BODY | ( | barg, | |
| carg | |||
| ) | DUK__COMPARE_BODY((carg), (barg), 0) |
| #define DUK__HAS_TERM (1 << 1) /* stmt has explicit/implicit semicolon terminator */ |
| #define DUK__HAS_VAL (1 << 0) /* stmt has non-empty value */ |
| #define DUK__HASH_DELETED DUK_HOBJECT_HASHIDX_DELETED |
| #define DUK__HASH_UNUSED DUK_HOBJECT_HASHIDX_UNUSED |
| #define DUK__HEAP_CLEAR_FLAGS | ( | heap, | |
| bits | |||
| ) |
| #define DUK__HEAP_HAS_FLAGS | ( | heap, | |
| bits | |||
| ) | ((heap)->flags & (bits)) |
| #define DUK__HEAP_SET_FLAGS | ( | heap, | |
| bits | |||
| ) |
| #define DUK__IEEE_DOUBLE_EXP_MIN (-1022) /* biased exp == 0 -> denormal, exp -1022 */ |
| #define DUK__IN_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__INCREF_SHARED | ( | ) |
| #define DUK__INITBUFFER | ( | lex_ctx | ) | duk__initbuffer((lex_ctx)) |
| #define DUK__INSTOF_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__INT_NOACTION 0 /* no specific action, resume normal execution */ |
| #define DUK__INT_RESTART 1 /* must "goto restart_execution", e.g. breakpoints changed */ |
| #define DUK__INTERNAL_ERROR | ( | msg | ) |
| #define DUK__ISHEXDIGIT | ( | x | ) | duk__is_hex_digit((x)) |
| #define DUK__ISREG_NOTTEMP | ( | comp_ctx, | |
| x | |||
| ) |
| #define DUK__ISREG_TEMP | ( | comp_ctx, | |
| x | |||
| ) |
| #define DUK__IVAL_FLAG_ALLOW_CONST (1 << 0) /* allow a constant to be returned */ |
| #define DUK__IVAL_FLAG_REQUIRE_SHORT (1 << 2) /* require a short (8-bit) reg/const which fits into bytecode B/C slot */ |
| #define DUK__IVAL_FLAG_REQUIRE_TEMP (1 << 1) /* require a (mutable) temporary as a result (or a const if allowed) */ |
| #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__LE_BODY | ( | barg, | |
| carg | |||
| ) | DUK__COMPARE_BODY((carg), (barg), DUK_COMPARE_FLAG_NEGATE) |
| #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__LOOKUP | ( | lex_ctx, | |
| idx | |||
| ) | ((lex_ctx)->window[(idx)].codepoint) |
| #define DUK__LOOKUP_INDIRECT | ( | idx | ) |
| #define DUK__LT_BODY | ( | barg, | |
| carg | |||
| ) | DUK__COMPARE_BODY((barg), (carg), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) |
| #define DUK__MASK_A (DUK_BC_UNSHIFTED_MASK_A << DUK__TVAL_SHIFT) |
| #define DUK__MASK_B (DUK_BC_UNSHIFTED_MASK_B << DUK__TVAL_SHIFT) |
| #define DUK__MASK_BC (DUK_BC_UNSHIFTED_MASK_BC << DUK__TVAL_SHIFT) |
| #define DUK__MASK_C (DUK_BC_UNSHIFTED_MASK_C << DUK__TVAL_SHIFT) |
| #define DUK__MAX_CONSTS DUK_BC_BC_MAX |
| #define DUK__MAX_FORMATTED_LENGTH 1040 /* (-Number.MAX_VALUE).toString(2).length == 1025, + slack */ |
| #define DUK__MAX_FUNCS DUK_BC_BC_MAX |
| #define DUK__MAX_OUTPUT_DIGITS 1040 /* (Number.MAX_VALUE).toString(2).length == 1024, + slack */ |
| #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__MK_LBP | ( | bp | ) | ((bp) >> 1) /* bp is assumed to be even */ |
| #define DUK__MK_LBP_FLAGS | ( | bp, | |
| flags | |||
| ) | (((bp) >> 1) | (flags)) |
| #define DUK__MKBITS | ( | a, | |
| b, | |||
| c, | |||
| d, | |||
| e, | |||
| f, | |||
| g, | |||
| h | |||
| ) | ((duk_uint8_t) (((a) << 0) | ((b) << 1) | ((c) << 2) | ((d) << 3) | ((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7))) |
| #define DUK__MKESC | ( | nybbles, | |
| esc1, | |||
| esc2 | |||
| ) | (((duk_uint_fast32_t) (nybbles)) << 16) | (((duk_uint_fast32_t) (esc1)) << 8) | ((duk_uint_fast32_t) (esc2)) |
| #define DUK__NEQ_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__NO_ARRAY_INDEX DUK_HSTRING_NO_ARRAY_INDEX |
| #define DUK__NO_EXP (65536) /* arbitrary marker, outside valid exp range */ |
| #define DUK__NUMCONV_CTX_BIGINTS_SIZE (sizeof(duk__bigint) * DUK__NUMCONV_CTX_NUM_BIGINTS) |
| #define DUK__OBJ_LIT_KEY_GET (1 << 1) /* key encountered as a getter */ |
| #define DUK__OBJ_LIT_KEY_PLAIN (1 << 0) /* key encountered as a plain property */ |
| #define DUK__OBJ_LIT_KEY_SET (1 << 2) /* key encountered as a setter */ |
| #define DUK__PACK_ARGS | ( | classnum, | |
| protobidx, | |||
| elemtype, | |||
| elemshift, | |||
| istypedarray | |||
| ) | (((classnum) << 24) | ((protobidx) << 16) | ((elemtype) << 8) | ((elemshift) << 4) | (istypedarray)) |
| #define DUK__PACK_RULE | ( | partmask, | |
| sepmask, | |||
| nextpart, | |||
| flags | |||
| ) |
| #define DUK__PM_DAY (1 << DUK__PI_DAY) |
| #define DUK__PM_HOUR (1 << DUK__PI_HOUR) |
| #define DUK__PM_MILLISECOND (1 << DUK__PI_MILLISECOND) |
| #define DUK__PM_MINUTE (1 << DUK__PI_MINUTE) |
| #define DUK__PM_MONTH (1 << DUK__PI_MONTH) |
| #define DUK__PM_SECOND (1 << DUK__PI_SECOND) |
| #define DUK__PM_TZHOUR (1 << DUK__PI_TZHOUR) |
| #define DUK__PM_TZMINUTE (1 << DUK__PI_TZMINUTE) |
| #define DUK__PM_YEAR (1 << DUK__PI_YEAR) |
| #define DUK__PUTPROP_BODY | ( | aarg, | |
| barg, | |||
| carg | |||
| ) |
| #define DUK__RCBIT_B DUK_BC_REGCONST_B |
| #define DUK__RCBIT_C DUK_BC_REGCONST_C |
| #define DUK__RE_BUFLEN | ( | re_ctx | ) | DUK_BW_GET_SIZE(re_ctx->thr, &re_ctx->bw) |
| #define DUK__READABLE_ERRMSG_MAXCHARS 96 /* for error messages */ |
| #define DUK__READABLE_STRING_MAXCHARS 32 /* for strings/symbols */ |
| #define DUK__READABLE_SUMMARY_MAXCHARS 96 /* maximum supported by helper */ |
| #define DUK__RECURSION_DECREASE | ( | comp_ctx, | |
| thr | |||
| ) |
| #define DUK__RECURSION_INCREASE | ( | comp_ctx, | |
| thr | |||
| ) |
| #define DUK__REGCONSTP_B | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) (((ins) &DUK__RCBIT_B) ? consts : thr->valstack_bottom) + DUK__BYTEOFF_B((ins)))) |
| #define DUK__REGCONSTP_C | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) (((ins) &DUK__RCBIT_C) ? consts : thr->valstack_bottom) + DUK__BYTEOFF_C((ins)))) |
| #define DUK__REGP_A | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) thr->valstack_bottom + DUK__BYTEOFF_A((ins)))) |
| #define DUK__REGP_B | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) thr->valstack_bottom + DUK__BYTEOFF_B((ins)))) |
| #define DUK__REGP_BC | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) thr->valstack_bottom + DUK__BYTEOFF_BC((ins)))) |
| #define DUK__REGP_C | ( | ins | ) | ((duk_tval *) (void *) ((duk_uint8_t *) thr->valstack_bottom + DUK__BYTEOFF_C((ins)))) |
| #define DUK__REMOVECONST | ( | x | ) | ((x) & ~DUK__CONST_MARKER) |
| #define DUK__REPLACE_BOOL_A_BREAK | ( | bval | ) |
| #define DUK__REPLACE_TO_TVPTR | ( | thr, | |
| tv_ptr | |||
| ) |
| #define DUK__REPLACE_TOP_A_BREAK | ( | ) |
| #define DUK__REPLACE_TOP_BC_BREAK | ( | ) |
| #define DUK__RETHAND_FINISHED 1 /* exit bytecode execution with return value */ |
| #define DUK__RETHAND_RESTART 0 /* state updated, restart bytecode execution */ |
| #define DUK__RETURN_SHARED | ( | ) |
| #define DUK__RND_BIT | ( | rnd | ) | ((rnd) >> 31) /* only use the highest bit */ |
| #define DUK__RZ_BUFFER | ( | ) |
| #define DUK__RZ_INLINE DUK_ALWAYS_INLINE |
| #define DUK__RZ_OBJECT | ( | ) |
| #define DUK__RZ_STRING | ( | ) |
| #define DUK__RZ_SUPPRESS_ASSERT1 | ( | ) |
| #define DUK__RZ_SUPPRESS_ASSERT2 | ( | ) |
| #define DUK__RZ_SUPPRESS_CHECK | ( | ) |
| #define DUK__RZ_SUPPRESS_COND | ( | ) | (heap->ms_running != 0) |
| #define DUK__SEQ_BODY | ( | barg, | |
| carg | |||
| ) |
| #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__SHIFT_A (DUK_BC_SHIFT_A - DUK__TVAL_SHIFT) |
| #define DUK__SHIFT_B (DUK_BC_SHIFT_B - DUK__TVAL_SHIFT) |
| #define DUK__SHIFT_BC (DUK_BC_SHIFT_BC - DUK__TVAL_SHIFT) |
| #define DUK__SHIFT_C (DUK_BC_SHIFT_C - DUK__TVAL_SHIFT) |
| #define DUK__SM_COLON (1 << DUK__SI_COLON) |
| #define DUK__SM_MINUS (1 << DUK__SI_MINUS) |
| #define DUK__SM_NUL (1 << DUK__SI_NUL) |
| #define DUK__SM_PERIOD (1 << DUK__SI_PERIOD) |
| #define DUK__SM_PLUS (1 << DUK__SI_PLUS) |
| #define DUK__SM_SPACE (1 << DUK__SI_SPACE) |
| #define DUK__SNEQ_BODY | ( | barg, | |
| carg | |||
| ) |
| #define DUK__STILL_PROLOGUE (1 << 3) /* statement does not terminate directive prologue */ |
| #define DUK__STRICT | ( | ) | ((duk_small_uint_t) DUK_HOBJECT_HAS_STRICT((duk_hobject *) DUK__FUN())) |
| #define DUK__STRTAB_U32_MAX_STRLEN 10 /* 4'294'967'295 */ |
| #define DUK__SYNC_AND_NULL_CURR_PC | ( | ) |
| #define DUK__SYNC_CURR_PC | ( | ) |
| #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) /* unused */ |
| #define DUK__TOKEN_LBP_GET_BP | ( | x | ) | ((duk_small_uint_t) (((x) &DUK__TOKEN_LBP_BP_MASK) * 2)) |
| #define DUK__TVAL_SHIFT 4 /* sizeof(duk_tval) == 16; not always the case so also asserted for */ |
| #define DUK__UNEMIT_1 | ( | js_ctx | ) | duk__unemit_1((js_ctx)) |
| #define DUK__UNPACK_RULE | ( | rule, | |
| var_nextidx, | |||
| var_flags | |||
| ) |
| #define DUK__UPDATE_RND | ( | rnd | ) |
| #define DUK__WEEKDAY_MOD_ADDER (20000000 * 7) /* 0x08583b00 */ |
| #define DUK_ACT_FLAG_BREAKPOINT_ACTIVE (1U << 6) /* activation has active breakpoint(s) */ |
| #define DUK_ACT_FLAG_CONSTRUCT (1U << 2) /* function executes as a constructor (called via "new") */ |
| #define DUK_ACT_FLAG_CONSTRUCT_PROXY (1U << 5) /* activation is for Proxy 'construct' call, special return value handling */ |
| #define DUK_ACT_FLAG_DIRECT_EVAL (1U << 4) /* activation is a direct eval call */ |
| #define DUK_ACT_FLAG_PREVENT_YIELD (1U << 3) /* activation prevents yield (native call or "new") */ |
| #define DUK_ACT_FLAG_STRICT (1U << 0) /* function executes in strict mode */ |
| #define DUK_ACT_FLAG_TAILCALLED (1U << 1) /* activation has tail called one or more times */ |
| #define DUK_ALLOC | ( | heap, | |
| size | |||
| ) | duk_heap_mem_alloc((heap), (size)) |
| #define DUK_ALLOC_CHECKED | ( | thr, | |
| size | |||
| ) | duk_heap_mem_alloc_checked((thr), (size)) |
| #define DUK_ALLOC_CHECKED_ZEROED | ( | thr, | |
| size | |||
| ) | duk_heap_mem_alloc_checked_zeroed((thr), (size)) |
| #define DUK_ALLOC_RAW | ( | heap, | |
| size | |||
| ) | ((heap)->alloc_func((heap)->heap_udata, (size))) |
| #define DUK_ALLOC_ZEROED | ( | heap, | |
| size | |||
| ) | duk_heap_mem_alloc_zeroed((heap), (size)) |
| #define DUK_ALWAYS_INLINE_PERF DUK_ALWAYS_INLINE |
| #define DUK_ASSERT | ( | x | ) |
| #define DUK_ASSERT_API_ENTRY | ( | thr | ) |
| #define DUK_ASSERT_BIDX_VALID | ( | val | ) | DUK_ASSERT((duk_uint_t) (val) < DUK_NUM_BUILTINS) |
| #define DUK_ASSERT_DISABLE | ( | x | ) |
| #define DUK_ASSERT_DOUBLE_IS_NORMALIZED | ( | dval | ) | /* nop */ |
| #define DUK_ASSERT_LJSTATE_SET | ( | heap | ) |
| #define DUK_ASSERT_LJSTATE_UNSET | ( | heap | ) |
| #define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR | ( | h | ) | /* no refcount check */ |
| #define DUK_ASSERT_REFCOUNT_NONZERO_TVAL | ( | tv | ) | /* no refcount check */ |
| #define DUK_ASSERT_SET_GARBAGE | ( | ptr, | |
| size | |||
| ) |
| #define DUK_ASSERT_STRIDX_VALID | ( | val | ) | DUK_ASSERT((duk_uint_t) (val) < DUK_HEAP_NUM_STRINGS) |
| #define DUK_ASSERT_TOP | ( | ctx, | |
| n | |||
| ) | DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n)) |
| #define DUK_ASSERT_VALID_NEGIDX | ( | thr, | |
| idx | |||
| ) | (DUK_ASSERT_EXPR((duk_int_t) (idx) < 0), DUK_ASSERT_EXPR(duk_is_valid_index((thr), (idx)))) |
| #define DUK_ASSERT_VALID_POSIDX | ( | thr, | |
| idx | |||
| ) | (DUK_ASSERT_EXPR((duk_int_t) (idx) >= 0), DUK_ASSERT_EXPR(duk_is_valid_index((thr), (idx)))) |
| #define DUK_ASSERT_VALSTACK_SPACE | ( | thr, | |
| n | |||
| ) | /* no valstack space check */ |
| #define DUK_ASSERT_VS_SPACE | ( | thr | ) | DUK_ASSERT(thr->valstack_top < thr->valstack_end) |
| #define DUK_AUGMENT_FLAG_NOBLAME_FILELINE (1U << 0) /* if set, don't blame C file/line for .fileName and .lineNumber */ |
| #define DUK_AUGMENT_FLAG_SKIP_ONE (1U << 1) /* if set, skip topmost activation in traceback construction */ |
| #define DUK_BC_DECLVAR_FLAG_FUNC_DECL (1U << 4) /* function declaration */ |
| #define DUK_BC_SHIFT_ABC DUK_BC_SHIFT_A |
| #define DUK_BC_SHIFT_BC DUK_BC_SHIFT_B |
| #define DUK_BC_SHIFTED_MASK_A (DUK_BC_UNSHIFTED_MASK_A << DUK_BC_SHIFT_A) |
| #define DUK_BC_SHIFTED_MASK_ABC (DUK_BC_UNSHIFTED_MASK_ABC << DUK_BC_SHIFT_ABC) |
| #define DUK_BC_SHIFTED_MASK_B (DUK_BC_UNSHIFTED_MASK_B << DUK_BC_SHIFT_B) |
| #define DUK_BC_SHIFTED_MASK_BC (DUK_BC_UNSHIFTED_MASK_BC << DUK_BC_SHIFT_BC) |
| #define DUK_BC_SHIFTED_MASK_C (DUK_BC_UNSHIFTED_MASK_C << DUK_BC_SHIFT_C) |
| #define DUK_BC_SHIFTED_MASK_OP (DUK_BC_UNSHIFTED_MASK_OP << DUK_BC_SHIFT_OP) |
| #define DUK_BW_ADD_PTR | ( | thr, | |
| bw_ctx, | |||
| delta | |||
| ) |
| #define DUK_BW_ASSERT_SPACE | ( | thr, | |
| bw_ctx, | |||
| sz | |||
| ) |
| #define DUK_BW_ASSERT_SPACE_EXPR | ( | thr, | |
| bw_ctx, | |||
| sz | |||
| ) |
| #define DUK_BW_ASSERT_VALID | ( | thr, | |
| bw_ctx | |||
| ) |
| #define DUK_BW_ASSERT_VALID_EXPR | ( | thr, | |
| bw_ctx | |||
| ) | DUK_ASSERT_EXPR(1) |
| #define DUK_BW_COMPACT | ( | thr, | |
| bw_ctx | |||
| ) |
| #define DUK_BW_ENSURE | ( | thr, | |
| bw_ctx, | |||
| sz | |||
| ) |
| #define DUK_BW_ENSURE_GETPTR | ( | thr, | |
| bw_ctx, | |||
| sz | |||
| ) | DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p) |
| #define DUK_BW_ENSURE_RAW | ( | thr, | |
| bw_ctx, | |||
| sz, | |||
| ptr | |||
| ) | (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? (ptr) : ((bw_ctx)->p = (ptr), duk_bw_resize((thr), (bw_ctx), (sz)))) |
| #define DUK_BW_GET_BASEPTR | ( | thr, | |
| bw_ctx | |||
| ) | ((bw_ctx)->p_base) |
| #define DUK_BW_GET_BUFFER | ( | thr, | |
| bw_ctx | |||
| ) | ((bw_ctx)->buf) |
| #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_INIT_PUSHBUF | ( | thr, | |
| bw_ctx, | |||
| sz | |||
| ) |
| #define DUK_BW_INIT_WITHBUF | ( | thr, | |
| bw_ctx, | |||
| buf | |||
| ) |
| #define DUK_BW_INSERT_ENSURE_AREA | ( | thr, | |
| bw, | |||
| off, | |||
| 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_RAW_AREA | ( | thr, | |
| bw, | |||
| off, | |||
| len | |||
| ) | duk_bw_insert_raw_area((thr), (bw), (off), (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_PUSH_AS_STRING | ( | thr, | |
| bw_ctx | |||
| ) |
| #define DUK_BW_REMOVE_ENSURE_SLICE | ( | 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_RESET_SIZE | ( | thr, | |
| bw_ctx | |||
| ) |
| #define DUK_BW_SET_PTR | ( | thr, | |
| bw_ctx, | |||
| ptr | |||
| ) |
| #define DUK_BW_SET_SIZE | ( | thr, | |
| bw_ctx, | |||
| sz | |||
| ) |
| #define DUK_BW_SETPTR_AND_COMPACT | ( | thr, | |
| bw_ctx, | |||
| ptr | |||
| ) |
| #define DUK_BW_SLACK_SHIFT 2 /* 2^2 -> 1/4 = 25% slack */ |
| #define DUK_BW_WRITE_ENSURE_BYTES | ( | thr, | |
| bw_ctx, | |||
| valptr, | |||
| valsz | |||
| ) |
| #define DUK_BW_WRITE_ENSURE_CESU8 | ( | thr, | |
| bw_ctx, | |||
| cp | |||
| ) |
| #define DUK_BW_WRITE_ENSURE_CSTRING | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_ENSURE_HBUFFER | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_ENSURE_HSTRING | ( | 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_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_RAW_BYTES | ( | thr, | |
| bw_ctx, | |||
| valptr, | |||
| valsz | |||
| ) |
| #define DUK_BW_WRITE_RAW_CESU8 | ( | thr, | |
| bw_ctx, | |||
| cp | |||
| ) |
| #define DUK_BW_WRITE_RAW_CSTRING | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_RAW_HBUFFER | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_RAW_HBUFFER_FIXED | ( | thr, | |
| bw_ctx, | |||
| val | |||
| ) |
| #define DUK_BW_WRITE_RAW_HSTRING | ( | 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_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_CALL_FLAG_ALLOW_ECMATOECMA (1U << 3) /* ecma-to-ecma call with executor reuse is possible */ |
| #define DUK_CALL_FLAG_CALLED_AS_EVAL (1U << 2) /* call was made using the identifier 'eval' */ |
| #define DUK_CALL_FLAG_CONSTRUCT (1U << 1) /* constructor call (i.e. called as 'new Foo()') */ |
| #define DUK_CALL_FLAG_CONSTRUCT_PROXY (1U << 5) /* handled via 'construct' proxy trap, check return value invariant(s) */ |
| #define DUK_CALL_FLAG_DEFAULT_INSTANCE_UPDATED (1U << 6) /* prototype of 'default instance' updated, temporary flag in call handling */ |
| #define DUK_CALL_FLAG_DIRECT_EVAL (1U << 4) /* call is a direct eval call */ |
| #define DUK_CALL_FLAG_TAILCALL (1U << 0) /* setup for a tail call */ |
| #define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED | ( | c | ) |
| #define DUK_CAT_CLEAR_CATCH_ENABLED | ( | c | ) |
| #define DUK_CAT_CLEAR_FINALLY_ENABLED | ( | c | ) |
| #define DUK_CAT_CLEAR_LEXENV_ACTIVE | ( | c | ) |
| #define DUK_CAT_FLAG_CATCH_BINDING_ENABLED (1U << 6) /* request to create catch binding */ |
| #define DUK_CAT_FLAG_CATCH_ENABLED (1U << 4) /* catch part will catch */ |
| #define DUK_CAT_FLAG_FINALLY_ENABLED (1U << 5) /* finally part will catch */ |
| #define DUK_CAT_FLAG_LEXENV_ACTIVE (1U << 7) /* catch or with binding is currently active */ |
| #define DUK_CAT_GET_LABEL | ( | c | ) | (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT) |
| #define DUK_CAT_GET_TYPE | ( | c | ) | ((c)->flags & DUK_CAT_TYPE_MASK) |
| #define DUK_CAT_HAS_CATCH_BINDING_ENABLED | ( | c | ) | ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED) |
| #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_LEXENV_ACTIVE | ( | c | ) | ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE) |
| #define DUK_CAT_SET_CATCH_BINDING_ENABLED | ( | c | ) |
| #define DUK_CAT_SET_CATCH_ENABLED | ( | c | ) |
| #define DUK_CAT_SET_FINALLY_ENABLED | ( | c | ) |
| #define DUK_CAT_SET_LEXENV_ACTIVE | ( | c | ) |
| #define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST (1U << 1) /* eval left argument first */ |
| #define DUK_COMPARE_FLAG_NEGATE (1U << 0) /* negate result */ |
| #define DUK_COMPILER_MAX_BYTECODE_LENGTH (256L * 1024L * 1024L) /* 1 GB */ |
| #define DUK_COMPILER_TOKEN_LIMIT 100000000L /* 1e8: protects against deeply nested inner functions */ |
| #define DUK_CTX_ASSERT_VALID | ( | thr | ) |
| #define DUK_DBG_CMD_UNUSED_2 0x02 /* Duktape 1.x: print notify */ |
| #define DUK_DBG_CMD_UNUSED_3 0x03 /* Duktape 1.x: alert notify */ |
| #define DUK_DBG_CMD_UNUSED_4 0x04 /* Duktape 1.x: log notify */ |
| #define DUK_DBLUNION_BSWAP64 | ( | u | ) |
| #define DUK_DBLUNION_DOUBLE_NTOH | ( | u | ) | DUK_DBLUNION_DOUBLE_HTON((u)) |
| #define DUK_DBLUNION_GET_HIGH32 | ( | u | ) | ((u)->ui[DUK_DBL_IDX_UI0]) |
| #define DUK_DBLUNION_GET_LOW32 | ( | u | ) | ((u)->ui[DUK_DBL_IDX_UI1]) |
| #define DUK_DBLUNION_GET_SIGNBIT | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] >> 31U)) |
| #define DUK_DBLUNION_HAS_SIGNBIT | ( | u | ) | (((u)->ui[DUK_DBL_IDX_UI0] & 0x80000000UL) != 0) |
| #define DUK_DBLUNION_IS_ANYINF | ( | u | ) | DUK__DBLUNION_IS_ANYINF((u)) |
| #define DUK_DBLUNION_IS_ANYZERO | ( | u | ) | DUK__DBLUNION_IS_ANYZERO((u)) |
| #define DUK_DBLUNION_IS_NAN | ( | u | ) | DUK__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */ |
| #define DUK_DBLUNION_IS_NEGINF | ( | u | ) | DUK__DBLUNION_IS_NEGINF((u)) |
| #define DUK_DBLUNION_IS_NEGZERO | ( | u | ) | DUK__DBLUNION_IS_NEGZERO((u)) |
| #define DUK_DBLUNION_IS_NORMALIZED | ( | u | ) | 1 /* all doubles are considered normalized */ |
| #define DUK_DBLUNION_IS_NORMALIZED_NAN | ( | u | ) | DUK__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */ |
| #define DUK_DBLUNION_IS_POSINF | ( | u | ) | DUK__DBLUNION_IS_POSINF((u)) |
| #define DUK_DBLUNION_IS_POSZERO | ( | u | ) | DUK__DBLUNION_IS_POSZERO((u)) |
| #define DUK_DBLUNION_NORMALIZE_NAN_CHECK | ( | u | ) | /* nop: no need to normalize */ |
| #define DUK_DBLUNION_SET_DOUBLE | ( | u, | |
| v | |||
| ) |
| #define DUK_DBLUNION_SET_HIGH32 | ( | u, | |
| v | |||
| ) |
| #define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32 | ( | u, | |
| v | |||
| ) |
| #define DUK_DBLUNION_SET_LOW32 | ( | u, | |
| v | |||
| ) |
| #define DUK_DBLUNION_SET_NAN | ( | u | ) |
| #define DUK_DCERROR_INTERNAL | ( | thr | ) |
| #define DUK_DCERROR_RANGE_INVALID_ARGS | ( | thr | ) |
| #define DUK_DCERROR_RANGE_INVALID_COUNT | ( | thr | ) |
| #define DUK_DCERROR_RANGE_INVALID_LENGTH | ( | thr | ) |
| #define DUK_DCERROR_TYPE_INVALID_ARGS | ( | thr | ) |
| #define DUK_DCERROR_TYPE_INVALID_STATE | ( | thr | ) |
| #define DUK_DCERROR_TYPE_INVALID_TRAP_RESULT | ( | thr | ) |
| #define DUK_DCERROR_UNSUPPORTED | ( | thr | ) |
| #define DUK_DDD | ( | x | ) |
| #define duk_del_prop_stridx_short | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) | duk_del_prop_stridx((thr), (obj_idx), (stridx)) |
| #define DUK_DPRINT 0 && /* args go here as a comma expression in parens */ |
| #define DUK_ENC_OP | ( | op | ) | ((duk_instr_t) (op)) |
| #define DUK_ENC_OP_A | ( | op, | |
| a | |||
| ) | DUK_ENC_OP_A_B_C((op), (a), 0, 0) |
| #define DUK_ENC_OP_A_B | ( | op, | |
| a, | |||
| b | |||
| ) | DUK_ENC_OP_A_B_C((op), (a), (b), 0) |
| #define DUK_ENC_OP_A_B_C | ( | op, | |
| a, | |||
| b, | |||
| c | |||
| ) |
| #define DUK_ENC_OP_A_BC | ( | op, | |
| a, | |||
| bc | |||
| ) | ((duk_instr_t) ((((duk_instr_t) (bc)) << 16) | (((duk_instr_t) (a)) << 8) | ((duk_instr_t) (op)))) |
| #define DUK_ENC_OP_ABC | ( | op, | |
| abc | |||
| ) | ((duk_instr_t) ((((duk_instr_t) (abc)) << 8) | ((duk_instr_t) (op)))) |
| #define DUK_ENC_OP_BC | ( | op, | |
| bc | |||
| ) | DUK_ENC_OP_A_BC((op), 0, (bc)) |
| #define DUK_EQUALS_FLAG_SAMEVALUE (1U << 0) /* use SameValue instead of non-strict equality */ |
| #define DUK_EQUALS_FLAG_STRICT (1U << 1) /* use strict equality instead of non-strict equality */ |
| #define DUK_ERROR | ( | thr, | |
| err, | |||
| msg | |||
| ) |
| #define DUK_ERROR_ALLOC_FAILED | ( | thr | ) |
| #define DUK_ERROR_ERROR | ( | thr, | |
| msg | |||
| ) |
| #define DUK_ERROR_EVAL | ( | thr, | |
| msg | |||
| ) |
| #define DUK_ERROR_FMT1 | ( | thr, | |
| err, | |||
| fmt, | |||
| arg1 | |||
| ) |
| #define DUK_ERROR_FMT2 | ( | thr, | |
| err, | |||
| fmt, | |||
| arg1, | |||
| arg2 | |||
| ) |
| #define DUK_ERROR_FMT3 | ( | thr, | |
| err, | |||
| fmt, | |||
| arg1, | |||
| arg2, | |||
| arg3 | |||
| ) |
| #define DUK_ERROR_FMT4 | ( | thr, | |
| err, | |||
| fmt, | |||
| arg1, | |||
| arg2, | |||
| arg3, | |||
| arg4 | |||
| ) |
| #define DUK_ERROR_INTERNAL | ( | thr | ) |
| #define DUK_ERROR_RANGE | ( | thr, | |
| msg | |||
| ) |
| #define DUK_ERROR_RANGE_INDEX | ( | thr, | |
| idx | |||
| ) |
| #define DUK_ERROR_RANGE_INVALID_ARGS | ( | thr | ) |
| #define DUK_ERROR_RANGE_INVALID_COUNT | ( | thr | ) |
| #define DUK_ERROR_RANGE_INVALID_LENGTH | ( | thr | ) |
| #define DUK_ERROR_RANGE_PUSH_BEYOND | ( | thr | ) |
| #define DUK_ERROR_RAW | ( | thr, | |
| file, | |||
| line, | |||
| err, | |||
| msg | |||
| ) |
| #define DUK_ERROR_RAW_FMT1 | ( | thr, | |
| file, | |||
| line, | |||
| err, | |||
| fmt, | |||
| arg1 | |||
| ) |
| #define DUK_ERROR_RAW_FMT2 | ( | thr, | |
| file, | |||
| line, | |||
| err, | |||
| fmt, | |||
| arg1, | |||
| arg2 | |||
| ) |
| #define DUK_ERROR_RAW_FMT3 | ( | thr, | |
| file, | |||
| line, | |||
| err, | |||
| fmt, | |||
| arg1, | |||
| arg2, | |||
| arg3 | |||
| ) |
| #define DUK_ERROR_RAW_FMT4 | ( | thr, | |
| file, | |||
| line, | |||
| err, | |||
| fmt, | |||
| arg1, | |||
| arg2, | |||
| arg3, | |||
| arg4 | |||
| ) |
| #define DUK_ERROR_REFERENCE | ( | thr, | |
| msg | |||
| ) |
| #define DUK_ERROR_REQUIRE_TYPE_INDEX | ( | thr, | |
| idx, | |||
| expectname, | |||
| lowmemstr | |||
| ) |
| #define DUK_ERROR_SYNTAX | ( | thr, | |
| msg | |||
| ) |
| #define DUK_ERROR_TYPE | ( | thr, | |
| msg | |||
| ) |
| #define DUK_ERROR_TYPE_INVALID_ARGS | ( | thr | ) |
| #define DUK_ERROR_TYPE_INVALID_STATE | ( | thr | ) |
| #define DUK_ERROR_TYPE_INVALID_TRAP_RESULT | ( | thr | ) |
| #define DUK_ERROR_UNSUPPORTED | ( | thr | ) |
| #define DUK_ERROR_URI | ( | thr, | |
| msg | |||
| ) |
| #define DUK_EXEC_ALWAYS_INLINE_PERF DUK_ALWAYS_INLINE |
| #define DUK_EXEC_INLINE_PERF DUK_INLINE |
| #define DUK_EXEC_NOINLINE_PERF DUK_NOINLINE |
| #define DUK_FASTINT_MAX (DUK_I64_CONSTANT(0x7fffffffffff)) |
| #define DUK_FASTINT_MIN (DUK_I64_CONSTANT(-0x800000000000)) |
| #define DUK_FATAL_WITHOUT_CONTEXT | ( | msg | ) | duk_default_fatal_handler(NULL, (msg)) |
| #define DUK_FREE | ( | heap, | |
| ptr | |||
| ) | duk_heap_mem_free((heap), (ptr)) |
| #define DUK_FREE_CHECKED | ( | thr, | |
| ptr | |||
| ) | duk_heap_mem_free((thr)->heap, (ptr)) |
| #define DUK_FREE_RAW | ( | heap, | |
| ptr | |||
| ) | ((heap)->free_func((heap)->heap_udata, (void *) (ptr))) |
| #define DUK_GET_HOBJECT_NEGIDX | ( | thr, | |
| idx | |||
| ) | (DUK_ASSERT_VALID_NEGIDX((thr), (idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_top + (idx))) |
| #define DUK_GET_HOBJECT_POSIDX | ( | thr, | |
| idx | |||
| ) | (DUK_ASSERT_VALID_POSIDX((thr), (idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_bottom + (idx))) |
| #define duk_get_hobject_promote_lfunc | ( | thr, | |
| idx | |||
| ) | duk_get_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC) |
| #define duk_get_prop_stridx_short | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) |
| #define DUK_GET_THIS_TVAL_PTR | ( | thr | ) | (DUK_ASSERT_EXPR((thr)->valstack_bottom > (thr)->valstack), (thr)->valstack_bottom - 1) |
| #define DUK_GET_TVAL_NEGIDX | ( | thr, | |
| idx | |||
| ) | (DUK_ASSERT_VALID_NEGIDX((thr), (idx)), ((duk_hthread *) (thr))->valstack_top + (idx)) |
| #define DUK_GET_TVAL_POSIDX | ( | thr, | |
| idx | |||
| ) | (DUK_ASSERT_VALID_POSIDX((thr), (idx)), ((duk_hthread *) (thr))->valstack_bottom + (idx)) |
| #define DUK_GETDESC_FLAG_IGNORE_PROTOLOOP (1U << 1) /* don't throw for prototype loop */ |
| #define DUK_GETDESC_FLAG_PUSH_VALUE (1U << 0) /* push value to stack */ |
| #define DUK_HARRAY_ASSERT_VALID | ( | h | ) |
| #define DUK_HARRAY_LENGTH_NONWRITABLE | ( | h | ) | ((h)->length_nonwritable) |
| #define DUK_HARRAY_LENGTH_WRITABLE | ( | h | ) | (!(h)->length_nonwritable) |
| #define DUK_HARRAY_SET_LENGTH_NONWRITABLE | ( | h | ) |
| #define DUK_HARRAY_SET_LENGTH_WRITABLE | ( | h | ) |
| #define duk_has_prop_stridx_short | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) | duk_has_prop_stridx((thr), (obj_idx), (stridx)) |
| #define DUK_HBOUNDFUNC_ASSERT_VALID | ( | h | ) |
| #define DUK_HBUFFER_ADD_SIZE | ( | x, | |
| dv | |||
| ) |
| #define DUK_HBUFFER_ASSERT_VALID | ( | h | ) |
| #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_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hbuffer_refzero, duk_hbuffer *) |
| #define DUK_HBUFFER_DECREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HBUFFER_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hbuffer_refzero, duk_hbuffer *) /* no 'norz' variant */ |
| #define DUK_HBUFFER_DECREF_NORZ_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HBUFFER_DECREF_NORZ_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HBUFFER_DECREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HBUFFER_DYNAMIC_ADD_SIZE | ( | x, | |
| dv | |||
| ) | DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv)) |
| #define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR | ( | heap, | |
| x | |||
| ) | ((x)->curr_alloc) |
| #define DUK_HBUFFER_DYNAMIC_GET_SIZE | ( | x | ) | DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x)) |
| #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR | ( | heap, | |
| x, | |||
| v | |||
| ) |
| #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL | ( | heap, | |
| x | |||
| ) |
| #define DUK_HBUFFER_DYNAMIC_SET_SIZE | ( | x, | |
| v | |||
| ) | DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v)) |
| #define DUK_HBUFFER_DYNAMIC_SUB_SIZE | ( | x, | |
| dv | |||
| ) | DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv)) |
| #define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR | ( | heap, | |
| x | |||
| ) | ((void *) (x)->curr_alloc) |
| #define DUK_HBUFFER_EXTERNAL_GET_SIZE | ( | x | ) | DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x)) |
| #define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR | ( | heap, | |
| x, | |||
| v | |||
| ) |
| #define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL | ( | heap, | |
| x | |||
| ) |
| #define DUK_HBUFFER_EXTERNAL_SET_SIZE | ( | x, | |
| v | |||
| ) | DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v)) |
| #define DUK_HBUFFER_FIXED_GET_DATA_PTR | ( | heap, | |
| x | |||
| ) | ((duk_uint8_t *) (((duk_hbuffer_fixed *) (void *) (x)) + 1)) |
| #define DUK_HBUFFER_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_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_GET_DATA_PTR | ( | heap, | |
| x | |||
| ) |
| #define DUK_HBUFFER_GET_SIZE | ( | x | ) | (((duk_hbuffer *) (x))->size) |
| #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_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)) |
| #define DUK_HBUFFER_INCREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HBUFFER_INCREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #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_SET_SIZE | ( | x, | |
| v | |||
| ) |
| #define DUK_HBUFFER_SUB_SIZE | ( | x, | |
| dv | |||
| ) |
| #define DUK_HBUFOBJ_ASSERT_VALID | ( | h | ) |
| #define DUK_HBUFOBJ_CLAMP_BYTELENGTH | ( | h, | |
| len | |||
| ) | (DUK_ASSERT_EXPR((h) != NULL), duk_hbufobj_clamp_bytelength((h), (len))) |
| #define DUK_HBUFOBJ_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *) |
| #define DUK_HBUFOBJ_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *) |
| #define DUK_HBUFOBJ_FULL_SLICE | ( | h | ) |
| #define DUK_HBUFOBJ_GET_SLICE_BASE | ( | heap, | |
| h | |||
| ) |
| #define DUK_HBUFOBJ_HAS_VIRTUAL_INDICES | ( | h | ) | ((h)->is_typedarray) |
| #define DUK_HBUFOBJ_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj) |
| #define DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL | ( | h, | |
| off | |||
| ) | (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), ((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf))) |
| #define DUK_HBUFOBJ_VALID_BYTEOFFSET_INCL | ( | h, | |
| off | |||
| ) | (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), ((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf))) |
| #define DUK_HBUFOBJ_VALID_SLICE | ( | h | ) |
| #define DUK_HCOMPFUNC_ASSERT_VALID | ( | h | ) |
| #define DUK_HCOMPFUNC_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *) |
| #define DUK_HCOMPFUNC_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *) |
| #define DUK_HCOMPFUNC_GET_BUFFER_BASE | ( | heap, | |
| h | |||
| ) | DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPFUNC_GET_DATA((heap), (h))) |
| #define DUK_HCOMPFUNC_GET_BYTECODE | ( | heap, | |
| h | |||
| ) | ((h)->bytecode) |
| #define DUK_HCOMPFUNC_GET_CODE_BASE | ( | heap, | |
| h | |||
| ) | DUK_HCOMPFUNC_GET_BYTECODE((heap), (h)) |
| #define DUK_HCOMPFUNC_GET_CODE_COUNT | ( | heap, | |
| h | |||
| ) | ((duk_size_t) (DUK_HCOMPFUNC_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t))) |
| #define DUK_HCOMPFUNC_GET_CODE_END | ( | heap, | |
| h | |||
| ) |
| #define DUK_HCOMPFUNC_GET_CODE_SIZE | ( | heap, | |
| h | |||
| ) |
| #define DUK_HCOMPFUNC_GET_CONSTS_BASE | ( | heap, | |
| h | |||
| ) | ((duk_tval *) (void *) DUK_HCOMPFUNC_GET_BUFFER_BASE((heap), (h))) |
| #define DUK_HCOMPFUNC_GET_CONSTS_COUNT | ( | heap, | |
| h | |||
| ) | ((duk_size_t) (DUK_HCOMPFUNC_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval))) |
| #define DUK_HCOMPFUNC_GET_CONSTS_END | ( | heap, | |
| h | |||
| ) | ((duk_tval *) (void *) DUK_HCOMPFUNC_GET_FUNCS((heap), (h))) |
| #define DUK_HCOMPFUNC_GET_CONSTS_SIZE | ( | heap, | |
| h | |||
| ) |
| #define DUK_HCOMPFUNC_GET_DATA | ( | heap, | |
| h | |||
| ) | ((duk_hbuffer_fixed *) (void *) (h)->data) |
| #define DUK_HCOMPFUNC_GET_FUNCS_BASE | ( | heap, | |
| h | |||
| ) | DUK_HCOMPFUNC_GET_FUNCS((heap), (h)) |
| #define DUK_HCOMPFUNC_GET_FUNCS_COUNT | ( | heap, | |
| h | |||
| ) | ((duk_size_t) (DUK_HCOMPFUNC_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *))) |
| #define DUK_HCOMPFUNC_GET_FUNCS_END | ( | heap, | |
| h | |||
| ) | ((duk_hobject **) (void *) DUK_HCOMPFUNC_GET_BYTECODE((heap), (h))) |
| #define DUK_HCOMPFUNC_GET_FUNCS_SIZE | ( | heap, | |
| h | |||
| ) |
| #define DUK_HCOMPFUNC_GET_LEXENV | ( | heap, | |
| h | |||
| ) | ((h)->lex_env) |
| #define DUK_HCOMPFUNC_GET_VARENV | ( | heap, | |
| h | |||
| ) | ((h)->var_env) |
| #define DUK_HCOMPFUNC_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj) |
| #define DUK_HCOMPFUNC_SET_BYTECODE | ( | heap, | |
| h, | |||
| v | |||
| ) |
| #define DUK_HCOMPFUNC_SET_DATA | ( | heap, | |
| h, | |||
| v | |||
| ) |
| #define DUK_HCOMPFUNC_SET_FUNCS | ( | heap, | |
| h, | |||
| v | |||
| ) |
| #define DUK_HCOMPFUNC_SET_LEXENV | ( | heap, | |
| h, | |||
| v | |||
| ) |
| #define DUK_HCOMPFUNC_SET_VARENV | ( | heap, | |
| h, | |||
| v | |||
| ) |
| #define DUK_HDECENV_ASSERT_VALID | ( | h | ) |
| #define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT |
| #define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT |
| #define DUK_HEAP_ASSERT_VALID | ( | heap | ) |
| #define DUK_HEAP_CLEAR_DEBUGGER_PAUSED | ( | heap | ) | DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED) |
| #define DUK_HEAP_CLEAR_FINALIZER_NORESCUE | ( | heap | ) | DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) |
| #define DUK_HEAP_CLEAR_INTERRUPT_RUNNING | ( | heap | ) | DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) |
| #define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED | ( | heap | ) | DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) |
| #define DUK_HEAP_FLAG_DEBUGGER_PAUSED (1U << 3) /* debugger is paused: talk with debug client until step/resume */ |
| #define DUK_HEAP_FLAG_FINALIZER_NORESCUE (1U << 2) /* heap destruction ongoing, finalizer rescue no longer possible */ |
| #define DUK_HEAP_FLAG_INTERRUPT_RUNNING (1U << 1) /* executor interrupt running (used to avoid nested interrupts) */ |
| #define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED (1U << 0) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */ |
| #define DUK_HEAP_GET_STRING | ( | heap, | |
| idx | |||
| ) | ((heap)->strs[(idx)]) |
| #define DUK_HEAP_HAS_DEBUGGER_PAUSED | ( | heap | ) | DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED) |
| #define DUK_HEAP_HAS_FINALIZER_NORESCUE | ( | heap | ) | DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) |
| #define DUK_HEAP_HAS_INTERRUPT_RUNNING | ( | heap | ) | DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) |
| #define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED | ( | heap | ) | DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) |
| #define DUK_HEAP_INSERT_INTO_FINALIZE_LIST | ( | heap, | |
| hdr | |||
| ) | duk_heap_insert_into_finalize_list((heap), (hdr)) |
| #define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED | ( | heap, | |
| hdr | |||
| ) | duk_heap_insert_into_heap_allocated((heap), (hdr)) |
| #define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT 12800L /* 50x heap size */ |
| #define DUK_HEAP_REMOVE_FROM_FINALIZE_LIST | ( | heap, | |
| hdr | |||
| ) | duk_heap_remove_from_finalize_list((heap), (hdr)) |
| #define DUK_HEAP_REMOVE_FROM_HEAP_ALLOCATED | ( | heap, | |
| hdr | |||
| ) | duk_heap_remove_from_heap_allocated((heap), (hdr)) |
| #define DUK_HEAP_SET_DEBUGGER_PAUSED | ( | heap | ) | DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED) |
| #define DUK_HEAP_SET_FINALIZER_NORESCUE | ( | heap | ) | DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) |
| #define DUK_HEAP_SET_INTERRUPT_RUNNING | ( | heap | ) | DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) |
| #define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED | ( | heap | ) | DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) |
| #define DUK_HEAP_STRING___PROTO__ | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__) |
| #define DUK_HEAP_STRING_APPLY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY) |
| #define DUK_HEAP_STRING_ARRAY_BUFFER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) |
| #define DUK_HEAP_STRING_BASE64 | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64) |
| #define DUK_HEAP_STRING_BRACKETED_ELLIPSIS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS) |
| #define DUK_HEAP_STRING_BREAK | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK) |
| #define DUK_HEAP_STRING_CALLEE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE) |
| #define DUK_HEAP_STRING_CALLER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER) |
| #define DUK_HEAP_STRING_CASE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE) |
| #define DUK_HEAP_STRING_CATCH | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH) |
| #define DUK_HEAP_STRING_CLASS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) |
| #define DUK_HEAP_STRING_COMMA | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA) |
| #define DUK_HEAP_STRING_COMPILE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE) |
| #define DUK_HEAP_STRING_CONFIGURABLE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE) |
| #define DUK_HEAP_STRING_CONST | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) |
| #define DUK_HEAP_STRING_CONSTRUCT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCT) |
| #define DUK_HEAP_STRING_CONSTRUCTOR | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR) |
| #define DUK_HEAP_STRING_CONTINUE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE) |
| #define DUK_HEAP_STRING_DATA | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) |
| #define DUK_HEAP_STRING_DATA_VIEW | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) |
| #define DUK_HEAP_STRING_DEBUGGER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER) |
| #define DUK_HEAP_STRING_DEC_ENV | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) |
| #define DUK_HEAP_STRING_DEFAULT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT) |
| #define DUK_HEAP_STRING_DELETE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE) |
| #define DUK_HEAP_STRING_DELETE_PROPERTY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY) |
| #define DUK_HEAP_STRING_DO | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO) |
| #define DUK_HEAP_STRING_ELSE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE) |
| #define DUK_HEAP_STRING_EMPTY_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) |
| #define DUK_HEAP_STRING_ENUM | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) |
| #define DUK_HEAP_STRING_ENUMERABLE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE) |
| #define DUK_HEAP_STRING_ENV | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV) |
| #define DUK_HEAP_STRING_ERR_CREATE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE) |
| #define DUK_HEAP_STRING_ERR_THROW | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW) |
| #define DUK_HEAP_STRING_EVAL | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL) |
| #define DUK_HEAP_STRING_EXPORT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) |
| #define DUK_HEAP_STRING_EXTENDS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS) |
| #define DUK_HEAP_STRING_FALSE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE) |
| #define DUK_HEAP_STRING_FILE_NAME | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME) |
| #define DUK_HEAP_STRING_FINALLY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY) |
| #define DUK_HEAP_STRING_FLAGS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLAGS) |
| #define DUK_HEAP_STRING_FLOAT32_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) |
| #define DUK_HEAP_STRING_FLOAT64_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) |
| #define DUK_HEAP_STRING_FOR | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR) |
| #define DUK_HEAP_STRING_GET | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET) |
| #define DUK_HEAP_STRING_GLOBAL | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) |
| #define DUK_HEAP_STRING_HAS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS) |
| #define DUK_HEAP_STRING_HEX | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX) |
| #define DUK_HEAP_STRING_IF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF) |
| #define DUK_HEAP_STRING_IGNORE_CASE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE) |
| #define DUK_HEAP_STRING_IMPLEMENTS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS) |
| #define DUK_HEAP_STRING_IMPORT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT) |
| #define DUK_HEAP_STRING_IN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN) |
| #define DUK_HEAP_STRING_INDEX | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX) |
| #define DUK_HEAP_STRING_INFINITY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY) |
| #define DUK_HEAP_STRING_INPUT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT) |
| #define DUK_HEAP_STRING_INSTANCEOF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF) |
| #define DUK_HEAP_STRING_INT16_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) |
| #define DUK_HEAP_STRING_INT32_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) |
| #define DUK_HEAP_STRING_INT8_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) |
| #define DUK_HEAP_STRING_INT_BYTECODE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE) |
| #define DUK_HEAP_STRING_INT_FINALIZER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER) |
| #define DUK_HEAP_STRING_INT_FORMALS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS) |
| #define DUK_HEAP_STRING_INT_MAP | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP) |
| #define DUK_HEAP_STRING_INT_NEXT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT) |
| #define DUK_HEAP_STRING_INT_PC2LINE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE) |
| #define DUK_HEAP_STRING_INT_SOURCE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE) |
| #define DUK_HEAP_STRING_INT_TARGET | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET) |
| #define DUK_HEAP_STRING_INT_TRACEDATA | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) |
| #define DUK_HEAP_STRING_INT_VALUE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE) |
| #define DUK_HEAP_STRING_INT_VARENV | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV) |
| #define DUK_HEAP_STRING_INT_VARMAP | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP) |
| #define DUK_HEAP_STRING_INTERFACE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE) |
| #define DUK_HEAP_STRING_INVALID_DATE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE) |
| #define DUK_HEAP_STRING_JC | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC) |
| #define DUK_HEAP_STRING_JOIN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN) |
| #define DUK_HEAP_STRING_JSON | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON) |
| #define DUK_HEAP_STRING_JSON_EXT_FUNCTION1 | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1) |
| #define DUK_HEAP_STRING_JSON_EXT_FUNCTION2 | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2) |
| #define DUK_HEAP_STRING_JSON_EXT_NAN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN) |
| #define DUK_HEAP_STRING_JSON_EXT_NEGINF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF) |
| #define DUK_HEAP_STRING_JSON_EXT_POSINF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF) |
| #define DUK_HEAP_STRING_JSON_EXT_UNDEFINED | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED) |
| #define DUK_HEAP_STRING_JX | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX) |
| #define DUK_HEAP_STRING_LAST_INDEX | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX) |
| #define DUK_HEAP_STRING_LC_ARGUMENTS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS) |
| #define DUK_HEAP_STRING_LC_BOOLEAN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN) |
| #define DUK_HEAP_STRING_LC_BUFFER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) |
| #define DUK_HEAP_STRING_LC_FUNCTION | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION) |
| #define DUK_HEAP_STRING_LC_NULL | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL) |
| #define DUK_HEAP_STRING_LC_NUMBER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER) |
| #define DUK_HEAP_STRING_LC_OBJECT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT) |
| #define DUK_HEAP_STRING_LC_POINTER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) |
| #define DUK_HEAP_STRING_LC_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING) |
| #define DUK_HEAP_STRING_LC_SYMBOL | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_SYMBOL) |
| #define DUK_HEAP_STRING_LC_UNDEFINED | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED) |
| #define DUK_HEAP_STRING_LENGTH | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH) |
| #define DUK_HEAP_STRING_LET | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET) |
| #define DUK_HEAP_STRING_LINE_NUMBER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) |
| #define DUK_HEAP_STRING_MATH | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH) |
| #define DUK_HEAP_STRING_MESSAGE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE) |
| #define DUK_HEAP_STRING_MINUS_INFINITY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY) |
| #define DUK_HEAP_STRING_MINUS_ZERO | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO) |
| #define DUK_HEAP_STRING_MULTILINE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE) |
| #define DUK_HEAP_STRING_NAME | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME) |
| #define DUK_HEAP_STRING_NAN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN) |
| #define DUK_HEAP_STRING_NEW | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW) |
| #define DUK_HEAP_STRING_NEWLINE_4SPACE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_4SPACE) |
| #define DUK_HEAP_STRING_OBJ_ENV | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) |
| #define DUK_HEAP_STRING_OWN_KEYS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS) |
| #define DUK_HEAP_STRING_PACKAGE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE) |
| #define DUK_HEAP_STRING_PC | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC) |
| #define DUK_HEAP_STRING_PRIVATE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE) |
| #define DUK_HEAP_STRING_PROTECTED | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED) |
| #define DUK_HEAP_STRING_PROTOTYPE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE) |
| #define DUK_HEAP_STRING_PUBLIC | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC) |
| #define DUK_HEAP_STRING_REG_EXP | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP) |
| #define DUK_HEAP_STRING_RETURN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN) |
| #define DUK_HEAP_STRING_SET | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET) |
| #define DUK_HEAP_STRING_SET_PROTOTYPE_OF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF) |
| #define DUK_HEAP_STRING_SOURCE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE) |
| #define DUK_HEAP_STRING_STACK | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK) |
| #define DUK_HEAP_STRING_STATIC | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC) |
| #define DUK_HEAP_STRING_SUPER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER) |
| #define DUK_HEAP_STRING_SWITCH | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH) |
| #define DUK_HEAP_STRING_THIS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS) |
| #define DUK_HEAP_STRING_THROW | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW) |
| #define DUK_HEAP_STRING_TO_GMT_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING) |
| #define DUK_HEAP_STRING_TO_ISO_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING) |
| #define DUK_HEAP_STRING_TO_JSON | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON) |
| #define DUK_HEAP_STRING_TO_LOCALE_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING) |
| #define DUK_HEAP_STRING_TO_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING) |
| #define DUK_HEAP_STRING_TO_UTC_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING) |
| #define DUK_HEAP_STRING_TRUE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE) |
| #define DUK_HEAP_STRING_TRY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY) |
| #define DUK_HEAP_STRING_TYPE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) |
| #define DUK_HEAP_STRING_TYPEOF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF) |
| #define DUK_HEAP_STRING_UC_ARGUMENTS | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS) |
| #define DUK_HEAP_STRING_UC_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARRAY) |
| #define DUK_HEAP_STRING_UC_BOOLEAN | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN) |
| #define DUK_HEAP_STRING_UC_BUFFER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) |
| #define DUK_HEAP_STRING_UC_DATE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_DATE) |
| #define DUK_HEAP_STRING_UC_ERROR | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR) |
| #define DUK_HEAP_STRING_UC_FUNCTION | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION) |
| #define DUK_HEAP_STRING_UC_NULL | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL) |
| #define DUK_HEAP_STRING_UC_NUMBER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER) |
| #define DUK_HEAP_STRING_UC_OBJECT | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT) |
| #define DUK_HEAP_STRING_UC_POINTER | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) |
| #define DUK_HEAP_STRING_UC_STRING | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING) |
| #define DUK_HEAP_STRING_UC_SYMBOL | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_SYMBOL) |
| #define DUK_HEAP_STRING_UC_THREAD | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD) |
| #define DUK_HEAP_STRING_UC_UNDEFINED | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED) |
| #define DUK_HEAP_STRING_UINT16_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) |
| #define DUK_HEAP_STRING_UINT32_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) |
| #define DUK_HEAP_STRING_UINT8_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) |
| #define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) |
| #define DUK_HEAP_STRING_VALUE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE) |
| #define DUK_HEAP_STRING_VALUE_OF | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF) |
| #define DUK_HEAP_STRING_VAR | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) |
| #define DUK_HEAP_STRING_VOID | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) |
| #define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_HAS_INSTANCE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_HAS_INSTANCE) |
| #define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE) |
| #define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_TO_PRIMITIVE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_PRIMITIVE) |
| #define DUK_HEAP_STRING_WELLKNOWN_SYMBOL_TO_STRING_TAG | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_STRING_TAG) |
| #define DUK_HEAP_STRING_WHILE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) |
| #define DUK_HEAP_STRING_WITH | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH) |
| #define DUK_HEAP_STRING_WRITABLE | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE) |
| #define DUK_HEAP_STRING_YIELD | ( | heap | ) | DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) |
| #define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT 16 /* strings up to the this length are not cached */ |
| #define DUK_HEAP_SWITCH_THREAD | ( | heap, | |
| newthr | |||
| ) | duk_heap_switch_thread((heap), (newthr)) |
| #define DUK_HEAPHDR_ASSERT_LINKS | ( | heap, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_ASSERT_VALID | ( | h | ) |
| #define DUK_HEAPHDR_CHECK_FLAG_BITS | ( | h, | |
| bits | |||
| ) | (((h)->h_flags & (bits)) != 0) |
| #define DUK_HEAPHDR_CLEAR_FINALIZABLE | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS((h), DUK_HEAPHDR_FLAG_FINALIZABLE) |
| #define DUK_HEAPHDR_CLEAR_FINALIZED | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS((h), DUK_HEAPHDR_FLAG_FINALIZED) |
| #define DUK_HEAPHDR_CLEAR_FLAG_BITS | ( | h, | |
| bits | |||
| ) |
| #define DUK_HEAPHDR_CLEAR_REACHABLE | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS((h), DUK_HEAPHDR_FLAG_REACHABLE) |
| #define DUK_HEAPHDR_CLEAR_READONLY | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS((h), DUK_HEAPHDR_FLAG_READONLY) |
| #define DUK_HEAPHDR_CLEAR_TEMPROOT | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS((h), DUK_HEAPHDR_FLAG_TEMPROOT) |
| #define DUK_HEAPHDR_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero, duk_heaphdr *) |
| #define DUK_HEAPHDR_DECREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_DECREF_FAST | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero, duk_heaphdr *) |
| #define DUK_HEAPHDR_DECREF_FAST_RAW | ( | thr, | |
| h, | |||
| rzcall, | |||
| rzcast | |||
| ) |
| #define DUK_HEAPHDR_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero_norz, duk_heaphdr *) |
| #define DUK_HEAPHDR_DECREF_NORZ_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_DECREF_NORZ_FAST | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero_norz, duk_heaphdr *) |
| #define DUK_HEAPHDR_DECREF_NORZ_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_DECREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #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_REACHABLE DUK_HEAPHDR_HEAP_FLAG(0) /* mark-and-sweep: reachable */ |
| #define DUK_HEAPHDR_FLAG_READONLY DUK_HEAPHDR_HEAP_FLAG(4) /* read-only object, in code section */ |
| #define DUK_HEAPHDR_FLAG_TEMPROOT DUK_HEAPHDR_HEAP_FLAG(1) /* mark-and-sweep: children not processed */ |
| #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_GET_FLAG_RANGE | ( | h, | |
| m, | |||
| n | |||
| ) | (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL)) |
| #define DUK_HEAPHDR_GET_FLAGS | ( | h | ) | ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK) |
| #define DUK_HEAPHDR_GET_TYPE | ( | h | ) | ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK) |
| #define DUK_HEAPHDR_HAS_FINALIZABLE | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS((h), DUK_HEAPHDR_FLAG_FINALIZABLE) |
| #define DUK_HEAPHDR_HAS_FINALIZED | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS((h), DUK_HEAPHDR_FLAG_FINALIZED) |
| #define DUK_HEAPHDR_HAS_REACHABLE | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS((h), DUK_HEAPHDR_FLAG_REACHABLE) |
| #define DUK_HEAPHDR_HAS_READONLY | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS((h), DUK_HEAPHDR_FLAG_READONLY) |
| #define DUK_HEAPHDR_HAS_TEMPROOT | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS((h), DUK_HEAPHDR_FLAG_TEMPROOT) |
| #define DUK_HEAPHDR_HEAP_FLAG | ( | n | ) | (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n))) |
| #define DUK_HEAPHDR_HEAP_FLAG_NUMBER | ( | n | ) | (DUK_HEAPHDR_FLAGS_HEAP_START + (n)) |
| #define DUK_HEAPHDR_HTYPE_VALID | ( | h | ) | (DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX) |
| #define DUK_HEAPHDR_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF_FAST((thr), (h)) |
| #define DUK_HEAPHDR_INCREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_INCREF_FAST | ( | thr, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_INCREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HEAPHDR_INIT_NULLS | ( | h | ) |
| #define DUK_HEAPHDR_IS_BUFFER | ( | h | ) | (DUK_HEAPHDR_GET_TYPE((h)) == DUK_HTYPE_BUFFER) |
| #define DUK_HEAPHDR_IS_OBJECT | ( | h | ) | ((h)->h_flags & 0x01UL) |
| #define DUK_HEAPHDR_IS_STRING | ( | h | ) | (DUK_HEAPHDR_GET_TYPE((h)) == DUK_HTYPE_STRING) |
| #define DUK_HEAPHDR_PREDEC_REFCOUNT | ( | h | ) | (--(h)->h_refcount) /* result: updated refcount */ |
| #define DUK_HEAPHDR_PREINC_REFCOUNT | ( | h | ) | (++(h)->h_refcount) /* result: updated refcount */ |
| #define DUK_HEAPHDR_SET_FINALIZABLE | ( | h | ) | DUK_HEAPHDR_SET_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_SET_FLAG_BITS | ( | h, | |
| bits | |||
| ) |
| #define DUK_HEAPHDR_SET_FLAG_RANGE | ( | h, | |
| m, | |||
| n, | |||
| v | |||
| ) |
| #define DUK_HEAPHDR_SET_FLAGS | ( | h, | |
| val | |||
| ) |
| #define DUK_HEAPHDR_SET_FLAGS_RAW | ( | h, | |
| val | |||
| ) |
| #define DUK_HEAPHDR_SET_NEXT | ( | heap, | |
| h, | |||
| val | |||
| ) |
| #define DUK_HEAPHDR_SET_PREV | ( | heap, | |
| h, | |||
| val | |||
| ) |
| #define DUK_HEAPHDR_SET_REACHABLE | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS((h), DUK_HEAPHDR_FLAG_REACHABLE) |
| #define DUK_HEAPHDR_SET_READONLY | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS((h), DUK_HEAPHDR_FLAG_READONLY) |
| #define DUK_HEAPHDR_SET_REFCOUNT | ( | h, | |
| val | |||
| ) |
| #define DUK_HEAPHDR_SET_TEMPROOT | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS((h), DUK_HEAPHDR_FLAG_TEMPROOT) |
| #define DUK_HEAPHDR_SET_TYPE | ( | h, | |
| val | |||
| ) |
| #define DUK_HEAPHDR_SET_TYPE_AND_FLAGS | ( | h, | |
| tval, | |||
| fval | |||
| ) |
| #define DUK_HEAPHDR_STRING_INIT_NULLS | ( | h | ) |
| #define DUK_HEAPHDR_USER_FLAG | ( | n | ) | (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n))) |
| #define DUK_HEAPHDR_USER_FLAG_NUMBER | ( | n | ) | (DUK_HEAPHDR_FLAGS_USER_START + (n)) |
| #define DUK_HNATFUNC_ASSERT_VALID | ( | h | ) |
| #define DUK_HNATFUNC_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *) |
| #define DUK_HNATFUNC_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *) |
| #define DUK_HNATFUNC_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj) |
| #define DUK_HOBJECT_A_GET_BASE | ( | heap, | |
| h | |||
| ) |
| #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_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_ALLOWS_FASTREFS | ( | h | ) | (!DUK_HOBJECT_PROHIBITS_FASTREFS((h))) |
| #define DUK_HOBJECT_ASSERT_VALID | ( | h | ) |
| #define DUK_HOBJECT_CLASS_ARRAYBUFFER 19 /* implies DUK_HOBJECT_IS_BUFOBJ */ |
| #define DUK_HOBJECT_CLASS_AS_FLAGS | ( | v | ) | (((duk_uint_t) (v)) << DUK_HOBJECT_FLAG_CLASS_BASE) |
| #define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX | ( | n | ) | duk_class_number_to_stridx[(n)] |
| #define DUK_HOBJECT_CLASS_THREAD 18 /* custom; implies DUK_HOBJECT_IS_THREAD */ |
| #define DUK_HOBJECT_CLEAR_ARRAY_PART | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) |
| #define DUK_HOBJECT_CLEAR_BOUNDFUNC | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC) |
| #define DUK_HOBJECT_CLEAR_BUFOBJ | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ) |
| #define DUK_HOBJECT_CLEAR_CALLABLE | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE) |
| #define DUK_HOBJECT_CLEAR_COMPFUNC | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC) |
| #define DUK_HOBJECT_CLEAR_CONSTRUCTABLE | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE) |
| #define DUK_HOBJECT_CLEAR_CREATEARGS | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS) |
| #define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) |
| #define DUK_HOBJECT_CLEAR_EXOTIC_ARRAY | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY) |
| #define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) |
| #define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) |
| #define DUK_HOBJECT_CLEAR_EXTENSIBLE | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) |
| #define DUK_HOBJECT_CLEAR_FASTREFS | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS) |
| #define DUK_HOBJECT_CLEAR_HAVE_FINALIZER | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER) |
| #define DUK_HOBJECT_CLEAR_NAMEBINDING | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING) |
| #define DUK_HOBJECT_CLEAR_NATFUNC | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC) |
| #define DUK_HOBJECT_CLEAR_NEWENV | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV) |
| #define DUK_HOBJECT_CLEAR_NOTAIL | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL) |
| #define DUK_HOBJECT_CLEAR_SPECIAL_CALL | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL) |
| #define DUK_HOBJECT_CLEAR_STRICT | ( | h | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) |
| #define DUK_HOBJECT_CMASK_ALL ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL) |
| #define DUK_HOBJECT_CMASK_ALL_BUFOBJS |
| #define DUK_HOBJECT_CMASK_ARGUMENTS (1UL << DUK_HOBJECT_CLASS_ARGUMENTS) |
| #define DUK_HOBJECT_CMASK_ARRAY (1UL << DUK_HOBJECT_CLASS_ARRAY) |
| #define DUK_HOBJECT_CMASK_ARRAYBUFFER (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER) |
| #define DUK_HOBJECT_CMASK_BOOLEAN (1UL << DUK_HOBJECT_CLASS_BOOLEAN) |
| #define DUK_HOBJECT_CMASK_DATAVIEW (1UL << DUK_HOBJECT_CLASS_DATAVIEW) |
| #define DUK_HOBJECT_CMASK_DATE (1UL << DUK_HOBJECT_CLASS_DATE) |
| #define DUK_HOBJECT_CMASK_DECENV (1UL << DUK_HOBJECT_CLASS_DECENV) |
| #define DUK_HOBJECT_CMASK_ERROR (1UL << DUK_HOBJECT_CLASS_ERROR) |
| #define DUK_HOBJECT_CMASK_FLOAT32ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY) |
| #define DUK_HOBJECT_CMASK_FLOAT64ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY) |
| #define DUK_HOBJECT_CMASK_FUNCTION (1UL << DUK_HOBJECT_CLASS_FUNCTION) |
| #define DUK_HOBJECT_CMASK_GLOBAL (1UL << DUK_HOBJECT_CLASS_GLOBAL) |
| #define DUK_HOBJECT_CMASK_INT16ARRAY (1UL << DUK_HOBJECT_CLASS_INT16ARRAY) |
| #define DUK_HOBJECT_CMASK_INT32ARRAY (1UL << DUK_HOBJECT_CLASS_INT32ARRAY) |
| #define DUK_HOBJECT_CMASK_INT8ARRAY (1UL << DUK_HOBJECT_CLASS_INT8ARRAY) |
| #define DUK_HOBJECT_CMASK_JSON (1UL << DUK_HOBJECT_CLASS_JSON) |
| #define DUK_HOBJECT_CMASK_MATH (1UL << DUK_HOBJECT_CLASS_MATH) |
| #define DUK_HOBJECT_CMASK_NONE (1UL << DUK_HOBJECT_CLASS_NONE) |
| #define DUK_HOBJECT_CMASK_NUMBER (1UL << DUK_HOBJECT_CLASS_NUMBER) |
| #define DUK_HOBJECT_CMASK_OBJECT (1UL << DUK_HOBJECT_CLASS_OBJECT) |
| #define DUK_HOBJECT_CMASK_OBJENV (1UL << DUK_HOBJECT_CLASS_OBJENV) |
| #define DUK_HOBJECT_CMASK_POINTER (1UL << DUK_HOBJECT_CLASS_POINTER) |
| #define DUK_HOBJECT_CMASK_REGEXP (1UL << DUK_HOBJECT_CLASS_REGEXP) |
| #define DUK_HOBJECT_CMASK_STRING (1UL << DUK_HOBJECT_CLASS_STRING) |
| #define DUK_HOBJECT_CMASK_SYMBOL (1UL << DUK_HOBJECT_CLASS_SYMBOL) |
| #define DUK_HOBJECT_CMASK_UINT16ARRAY (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY) |
| #define DUK_HOBJECT_CMASK_UINT32ARRAY (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY) |
| #define DUK_HOBJECT_CMASK_UINT8ARRAY (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY) |
| #define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY) |
| #define DUK_HOBJECT_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *) |
| #define DUK_HOBJECT_DECREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HOBJECT_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *) |
| #define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HOBJECT_DECREF_NORZ_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HOBJECT_DECREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HOBJECT_E_CLEAR_FLAG_BITS | ( | heap, | |
| h, | |||
| i, | |||
| mask | |||
| ) |
| #define DUK_HOBJECT_E_FLAG_PADDING | ( | e_sz | ) | ((8 - (e_sz)) & 0x07) |
| #define DUK_HOBJECT_E_GET_FLAGS | ( | heap, | |
| h, | |||
| i | |||
| ) | (DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)]) |
| #define DUK_HOBJECT_E_GET_FLAGS_BASE | ( | heap, | |
| h | |||
| ) |
| #define DUK_HOBJECT_E_GET_FLAGS_PTR | ( | heap, | |
| h, | |||
| i | |||
| ) | (&DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)]) |
| #define DUK_HOBJECT_E_GET_KEY | ( | heap, | |
| h, | |||
| i | |||
| ) | (DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)]) |
| #define DUK_HOBJECT_E_GET_KEY_BASE | ( | heap, | |
| h | |||
| ) | ((duk_hstring **) (void *) (DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue))) |
| #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_BASE | ( | heap, | |
| h | |||
| ) | ((duk_propvalue *) (void *) (DUK_HOBJECT_GET_PROPS((heap), (h)))) |
| #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_PTR | ( | heap, | |
| h, | |||
| i | |||
| ) | (&DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)]) |
| #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_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_SET_FLAG_BITS | ( | heap, | |
| h, | |||
| i, | |||
| mask | |||
| ) |
| #define DUK_HOBJECT_E_SET_FLAGS | ( | heap, | |
| h, | |||
| i, | |||
| f | |||
| ) |
| #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_GETTER | ( | heap, | |
| h, | |||
| i, | |||
| v | |||
| ) |
| #define DUK_HOBJECT_E_SET_VALUE_SETTER | ( | heap, | |
| h, | |||
| i, | |||
| v | |||
| ) |
| #define DUK_HOBJECT_E_SET_VALUE_TVAL | ( | heap, | |
| h, | |||
| i, | |||
| v | |||
| ) |
| #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_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_ENUMERABLE | ( | heap, | |
| h, | |||
| i | |||
| ) | DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i), DUK_PROPDESC_FLAG_ENUMERABLE) |
| #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_IS_ACCESSOR | ( | heap, | |
| h, | |||
| i | |||
| ) | ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ACCESSOR) != 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_ENUMERABLE | ( | heap, | |
| h, | |||
| i | |||
| ) | ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ENUMERABLE) != 0) |
| #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_SET_ACCESSOR | ( | heap, | |
| h, | |||
| i | |||
| ) | DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i), DUK_PROPDESC_FLAG_ACCESSOR) |
| #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_ENUMERABLE | ( | heap, | |
| h, | |||
| i | |||
| ) | DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i), DUK_PROPDESC_FLAG_ENUMERABLE) |
| #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_EXOTIC_BEHAVIOR_FLAGS |
| #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_BOUNDFUNC DUK_HEAPHDR_USER_FLAG(3) /* object established using Function.prototype.bind() */ |
| #define DUK_HOBJECT_FLAG_BUFOBJ DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufobj) (always exotic) */ |
| #define DUK_HOBJECT_FLAG_CALLABLE DUK_HEAPHDR_USER_FLAG(2) /* object is callable */ |
| #define DUK_HOBJECT_FLAG_CLASS_BASE DUK_HEAPHDR_USER_FLAG_NUMBER(20) |
| #define DUK_HOBJECT_FLAG_COMPFUNC DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompfunc) */ |
| #define DUK_HOBJECT_FLAG_CONSTRUCTABLE DUK_HEAPHDR_USER_FLAG(1) /* object is constructable */ |
| #define DUK_HOBJECT_FLAG_CREATEARGS DUK_HEAPHDR_USER_FLAG(13) /* function: create an arguments object on function call */ |
| #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_ARRAY DUK_HEAPHDR_USER_FLAG(15) /* 'Array' object, array length and index exotic behavior */ |
| #define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ DUK_HEAPHDR_USER_FLAG(18) /* 'Proxy' object */ |
| #define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ DUK_HEAPHDR_USER_FLAG(16) /* 'String' object, array index exotic behavior */ |
| #define DUK_HOBJECT_FLAG_EXTENSIBLE DUK_HEAPHDR_USER_FLAG(0) /* object is extensible */ |
| #define DUK_HOBJECT_FLAG_FASTREFS DUK_HEAPHDR_USER_FLAG(7) /* object has no fields needing DECREF/marking beyond base duk_hobject header */ |
| #define DUK_HOBJECT_FLAG_HAVE_FINALIZER DUK_HEAPHDR_USER_FLAG(14) /* object has a callable (own) finalizer property */ |
| #define DUK_HOBJECT_FLAG_NAMEBINDING |
| #define DUK_HOBJECT_FLAG_NATFUNC DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnatfunc) */ |
| #define DUK_HOBJECT_FLAG_NEWENV DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompfunc) */ |
| #define DUK_HOBJECT_FLAG_NOTAIL DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */ |
| #define DUK_HOBJECT_FLAG_SPECIAL_CALL DUK_HEAPHDR_USER_FLAG(19) /* special casing in call behavior, for .call(), .apply(), etc. */ |
| #define DUK_HOBJECT_FLAG_STRICT DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */ |
| #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_GET_CLASS_NUMBER | ( | h | ) | DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS) |
| #define DUK_HOBJECT_GET_CLASS_STRING | ( | heap, | |
| h | |||
| ) | DUK_HEAP_GET_STRING((heap), DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(DUK_HOBJECT_GET_CLASS_NUMBER((h)))) |
| #define DUK_HOBJECT_GET_PROTOTYPE | ( | heap, | |
| h | |||
| ) | ((h)->prototype) |
| #define DUK_HOBJECT_H_GET_BASE | ( | heap, | |
| h | |||
| ) |
| #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_H_SET_INDEX | ( | heap, | |
| h, | |||
| i, | |||
| v | |||
| ) |
| #define DUK_HOBJECT_HAS_ARRAY_PART | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) |
| #define DUK_HOBJECT_HAS_BOUNDFUNC | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC) |
| #define DUK_HOBJECT_HAS_BUFOBJ | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ) |
| #define DUK_HOBJECT_HAS_CALLABLE | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE) |
| #define DUK_HOBJECT_HAS_COMPFUNC | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC) |
| #define DUK_HOBJECT_HAS_CONSTRUCTABLE | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE) |
| #define DUK_HOBJECT_HAS_CREATEARGS | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS) |
| #define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) |
| #define DUK_HOBJECT_HAS_EXOTIC_ARRAY | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY) |
| #define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS) |
| #define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) |
| #define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) |
| #define DUK_HOBJECT_HAS_EXTENSIBLE | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) |
| #define DUK_HOBJECT_HAS_FASTREFS | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS) |
| #define DUK_HOBJECT_HAS_FINALIZER_FAST | ( | heap, | |
| h | |||
| ) | duk_hobject_has_finalizer_fast_raw((h)) |
| #define DUK_HOBJECT_HAS_HAVE_FINALIZER | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER) |
| #define DUK_HOBJECT_HAS_NAMEBINDING | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING) |
| #define DUK_HOBJECT_HAS_NATFUNC | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC) |
| #define DUK_HOBJECT_HAS_NEWENV | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV) |
| #define DUK_HOBJECT_HAS_NOTAIL | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL) |
| #define DUK_HOBJECT_HAS_SPECIAL_CALL | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL) |
| #define DUK_HOBJECT_HAS_STRICT | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) |
| #define DUK_HOBJECT_HAS_VIRTUAL_PROPERTIES | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS) |
| #define DUK_HOBJECT_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)) |
| #define DUK_HOBJECT_INCREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HOBJECT_INCREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HOBJECT_IS_ARRAY | ( | h | ) | DUK_HOBJECT_HAS_EXOTIC_ARRAY((h)) /* Rely on class Array <=> exotic Array */ |
| #define DUK_HOBJECT_IS_BOUNDFUNC | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC) |
| #define DUK_HOBJECT_IS_BUFOBJ | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ) |
| #define DUK_HOBJECT_IS_CALLABLE | ( | h | ) | DUK_HOBJECT_HAS_CALLABLE((h)) |
| #define DUK_HOBJECT_IS_COMPFUNC | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC) |
| #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_FUNCTION | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC | DUK_HOBJECT_FLAG_COMPFUNC | DUK_HOBJECT_FLAG_NATFUNC) |
| #define DUK_HOBJECT_IS_NATFUNC | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC) |
| #define DUK_HOBJECT_IS_NONBOUND_FUNCTION | ( | h | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC | DUK_HOBJECT_FLAG_NATFUNC) |
| #define DUK_HOBJECT_IS_OBJENV | ( | h | ) | (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV) |
| #define DUK_HOBJECT_IS_PROXY | ( | h | ) | DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ((h)) |
| #define DUK_HOBJECT_IS_THREAD | ( | h | ) | (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_THREAD) |
| #define DUK_HOBJECT_MAX_PROPERTIES 0x3fffffffUL /* 2**30-1 ~= 1G properties */ |
| #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_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_PROHIBITS_FASTREFS | ( | h | ) |
| #define DUK_HOBJECT_SET_ARRAY_PART | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) |
| #define DUK_HOBJECT_SET_ASIZE | ( | h, | |
| v | |||
| ) |
| #define DUK_HOBJECT_SET_BOUNDFUNC | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC) |
| #define DUK_HOBJECT_SET_BUFOBJ | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ) |
| #define DUK_HOBJECT_SET_CALLABLE | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE) |
| #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_SET_COMPFUNC | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC) |
| #define DUK_HOBJECT_SET_CONSTRUCTABLE | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE) |
| #define DUK_HOBJECT_SET_CREATEARGS | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS) |
| #define DUK_HOBJECT_SET_ENEXT | ( | h, | |
| v | |||
| ) |
| #define DUK_HOBJECT_SET_ESIZE | ( | h, | |
| v | |||
| ) |
| #define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) |
| #define DUK_HOBJECT_SET_EXOTIC_ARRAY | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY) |
| #define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) |
| #define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) |
| #define DUK_HOBJECT_SET_EXTENSIBLE | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) |
| #define DUK_HOBJECT_SET_FASTREFS | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS) |
| #define DUK_HOBJECT_SET_HAVE_FINALIZER | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER) |
| #define DUK_HOBJECT_SET_HSIZE | ( | h, | |
| v | |||
| ) |
| #define DUK_HOBJECT_SET_NAMEBINDING | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING) |
| #define DUK_HOBJECT_SET_NATFUNC | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC) |
| #define DUK_HOBJECT_SET_NEWENV | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV) |
| #define DUK_HOBJECT_SET_NOTAIL | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL) |
| #define DUK_HOBJECT_SET_PROPS | ( | heap, | |
| h, | |||
| x | |||
| ) |
| #define DUK_HOBJECT_SET_PROTOTYPE | ( | heap, | |
| h, | |||
| x | |||
| ) |
| #define DUK_HOBJECT_SET_PROTOTYPE_INIT_INCREF | ( | thr, | |
| h, | |||
| proto | |||
| ) |
| #define DUK_HOBJECT_SET_PROTOTYPE_UPDREF | ( | thr, | |
| h, | |||
| p | |||
| ) | duk_hobject_set_prototype_updref((thr), (h), (p)) |
| #define DUK_HOBJECT_SET_SPECIAL_CALL | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL) |
| #define DUK_HOBJECT_SET_STRICT | ( | h | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) |
| #define DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | DUK_HOBJECT_FLAG_BUFOBJ) |
| #define DUK_HOBJENV_ASSERT_VALID | ( | h | ) |
| #define DUK_HPROXY_ASSERT_VALID | ( | h | ) |
| #define DUK_HSTRING_ASSERT_VALID | ( | h | ) |
| #define DUK_HSTRING_CLEAR_ARRIDX | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) |
| #define DUK_HSTRING_CLEAR_ASCII | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII) |
| #define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) |
| #define DUK_HSTRING_CLEAR_EXTDATA | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) |
| #define DUK_HSTRING_CLEAR_HIDDEN | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN) |
| #define DUK_HSTRING_CLEAR_PINNED_LITERAL | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL) |
| #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_SYMBOL | ( | x | ) | DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL) |
| #define DUK_HSTRING_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hstring_refzero, duk_hstring *) |
| #define DUK_HSTRING_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hstring_refzero, duk_hstring *) /* no 'norz' variant */ |
| #define DUK_HSTRING_DECREF_NORZ_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HSTRING_DECREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HSTRING_FLAG_ARRIDX DUK_HEAPHDR_USER_FLAG(1) /* string is a valid array index */ |
| #define DUK_HSTRING_FLAG_ASCII DUK_HEAPHDR_USER_FLAG(0) /* string is ASCII, clen == blen */ |
| #define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS DUK_HEAPHDR_USER_FLAG(6) /* string is 'eval' or 'arguments' */ |
| #define DUK_HSTRING_FLAG_EXTDATA DUK_HEAPHDR_USER_FLAG(7) /* string data is external (duk_hstring_external) */ |
| #define DUK_HSTRING_FLAG_HIDDEN DUK_HEAPHDR_USER_FLAG(3) /* string is a hidden symbol (implies symbol, Duktape 1.x internal string) */ |
| #define DUK_HSTRING_FLAG_PINNED_LITERAL DUK_HEAPHDR_USER_FLAG(8) /* string is a literal, and pinned */ |
| #define DUK_HSTRING_FLAG_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(4) /* string is a reserved word (non-strict) */ |
| #define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(5) /* string is a reserved word (strict) */ |
| #define DUK_HSTRING_FLAG_SYMBOL DUK_HEAPHDR_USER_FLAG(2) /* string is a symbol (invalid utf-8) */ |
| #define DUK_HSTRING_GET_CHARLEN | ( | x | ) | duk_hstring_get_charlen((x)) |
| #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_HAS_ARRIDX | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) |
| #define DUK_HSTRING_HAS_ASCII | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII) |
| #define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) |
| #define DUK_HSTRING_HAS_EXTDATA | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) |
| #define DUK_HSTRING_HAS_HIDDEN | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN) |
| #define DUK_HSTRING_HAS_PINNED_LITERAL | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL) |
| #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_SYMBOL | ( | x | ) | DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL) |
| #define DUK_HSTRING_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)) |
| #define DUK_HSTRING_INCREF_SLOW | ( | thr, | |
| h | |||
| ) |
| #define DUK_HSTRING_IS_ASCII | ( | x | ) | DUK_HSTRING_HAS_ASCII((x)) /* lazily set! */ |
| #define DUK_HSTRING_IS_EMPTY | ( | x | ) | (DUK_HSTRING_GET_BYTELEN((x)) == 0) |
| #define DUK_HSTRING_SET_ARRIDX | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) |
| #define DUK_HSTRING_SET_ASCII | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII) |
| #define DUK_HSTRING_SET_BYTELEN | ( | x, | |
| v | |||
| ) |
| #define DUK_HSTRING_SET_CHARLEN | ( | x, | |
| v | |||
| ) |
| #define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) |
| #define DUK_HSTRING_SET_EXTDATA | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) |
| #define DUK_HSTRING_SET_HASH | ( | x, | |
| v | |||
| ) |
| #define DUK_HSTRING_SET_HIDDEN | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN) |
| #define DUK_HSTRING_SET_PINNED_LITERAL | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL) |
| #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_SYMBOL | ( | x | ) | DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL) |
| #define DUK_HTHREAD_ASSERT_VALID | ( | thr | ) |
| #define DUK_HTHREAD_DECREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *) |
| #define DUK_HTHREAD_DECREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HTHREAD_DECREF_NORZ | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *) |
| #define DUK_HTHREAD_DECREF_NORZ_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HTHREAD_GET_STRING | ( | thr, | |
| idx | |||
| ) | ((thr)->strs[(idx)]) |
| #define DUK_HTHREAD_INCREF | ( | thr, | |
| h | |||
| ) | DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj) |
| #define DUK_HTHREAD_INCREF_ALLOWNULL | ( | thr, | |
| h | |||
| ) |
| #define DUK_HTHREAD_STATE_INACTIVE 1 /* thread not currently running */ |
| #define DUK_HTHREAD_STATE_RESUMED 3 /* thread resumed another thread (active but not running) */ |
| #define DUK_HTHREAD_STATE_RUNNING 2 /* thread currently running (only one at a time) */ |
| #define DUK_HTHREAD_STATE_TERMINATED 5 /* thread has terminated */ |
| #define DUK_HTHREAD_STATE_YIELDED 4 /* thread has yielded */ |
| #define DUK_HTHREAD_STRING___PROTO__ | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__) |
| #define DUK_HTHREAD_STRING_APPLY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY) |
| #define DUK_HTHREAD_STRING_ARRAY_BUFFER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) |
| #define DUK_HTHREAD_STRING_BASE64 | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64) |
| #define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS) |
| #define DUK_HTHREAD_STRING_BREAK | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK) |
| #define DUK_HTHREAD_STRING_CALLEE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE) |
| #define DUK_HTHREAD_STRING_CALLER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER) |
| #define DUK_HTHREAD_STRING_CASE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE) |
| #define DUK_HTHREAD_STRING_CATCH | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH) |
| #define DUK_HTHREAD_STRING_CLASS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) |
| #define DUK_HTHREAD_STRING_COMMA | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA) |
| #define DUK_HTHREAD_STRING_COMPILE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE) |
| #define DUK_HTHREAD_STRING_CONFIGURABLE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE) |
| #define DUK_HTHREAD_STRING_CONST | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) |
| #define DUK_HTHREAD_STRING_CONSTRUCT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCT) |
| #define DUK_HTHREAD_STRING_CONSTRUCTOR | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR) |
| #define DUK_HTHREAD_STRING_CONTINUE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE) |
| #define DUK_HTHREAD_STRING_DATA | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) |
| #define DUK_HTHREAD_STRING_DATA_VIEW | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) |
| #define DUK_HTHREAD_STRING_DEBUGGER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER) |
| #define DUK_HTHREAD_STRING_DEC_ENV | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) |
| #define DUK_HTHREAD_STRING_DEFAULT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT) |
| #define DUK_HTHREAD_STRING_DELETE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE) |
| #define DUK_HTHREAD_STRING_DELETE_PROPERTY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY) |
| #define DUK_HTHREAD_STRING_DO | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO) |
| #define DUK_HTHREAD_STRING_ELSE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE) |
| #define DUK_HTHREAD_STRING_EMPTY_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) |
| #define DUK_HTHREAD_STRING_ENUM | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) |
| #define DUK_HTHREAD_STRING_ENUMERABLE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE) |
| #define DUK_HTHREAD_STRING_ENV | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV) |
| #define DUK_HTHREAD_STRING_ERR_CREATE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE) |
| #define DUK_HTHREAD_STRING_ERR_THROW | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW) |
| #define DUK_HTHREAD_STRING_EVAL | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL) |
| #define DUK_HTHREAD_STRING_EXPORT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT) |
| #define DUK_HTHREAD_STRING_EXTENDS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS) |
| #define DUK_HTHREAD_STRING_FALSE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE) |
| #define DUK_HTHREAD_STRING_FILE_NAME | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME) |
| #define DUK_HTHREAD_STRING_FINALLY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY) |
| #define DUK_HTHREAD_STRING_FLAGS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLAGS) |
| #define DUK_HTHREAD_STRING_FLOAT32_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) |
| #define DUK_HTHREAD_STRING_FLOAT64_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) |
| #define DUK_HTHREAD_STRING_FOR | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR) |
| #define DUK_HTHREAD_STRING_GET | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET) |
| #define DUK_HTHREAD_STRING_GLOBAL | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL) |
| #define DUK_HTHREAD_STRING_HAS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS) |
| #define DUK_HTHREAD_STRING_HEX | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX) |
| #define DUK_HTHREAD_STRING_IF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF) |
| #define DUK_HTHREAD_STRING_IGNORE_CASE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE) |
| #define DUK_HTHREAD_STRING_IMPLEMENTS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS) |
| #define DUK_HTHREAD_STRING_IMPORT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT) |
| #define DUK_HTHREAD_STRING_IN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN) |
| #define DUK_HTHREAD_STRING_INDEX | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX) |
| #define DUK_HTHREAD_STRING_INFINITY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY) |
| #define DUK_HTHREAD_STRING_INPUT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT) |
| #define DUK_HTHREAD_STRING_INSTANCEOF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF) |
| #define DUK_HTHREAD_STRING_INT16_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) |
| #define DUK_HTHREAD_STRING_INT32_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) |
| #define DUK_HTHREAD_STRING_INT8_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) |
| #define DUK_HTHREAD_STRING_INT_BYTECODE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE) |
| #define DUK_HTHREAD_STRING_INT_FINALIZER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER) |
| #define DUK_HTHREAD_STRING_INT_FORMALS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS) |
| #define DUK_HTHREAD_STRING_INT_MAP | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP) |
| #define DUK_HTHREAD_STRING_INT_NEXT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT) |
| #define DUK_HTHREAD_STRING_INT_PC2LINE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE) |
| #define DUK_HTHREAD_STRING_INT_SOURCE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE) |
| #define DUK_HTHREAD_STRING_INT_TARGET | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET) |
| #define DUK_HTHREAD_STRING_INT_TRACEDATA | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) |
| #define DUK_HTHREAD_STRING_INT_VALUE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) |
| #define DUK_HTHREAD_STRING_INT_VARENV | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV) |
| #define DUK_HTHREAD_STRING_INT_VARMAP | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP) |
| #define DUK_HTHREAD_STRING_INTERFACE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE) |
| #define DUK_HTHREAD_STRING_INVALID_DATE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE) |
| #define DUK_HTHREAD_STRING_JC | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC) |
| #define DUK_HTHREAD_STRING_JOIN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN) |
| #define DUK_HTHREAD_STRING_JSON | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON) |
| #define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1 | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1) |
| #define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2 | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2) |
| #define DUK_HTHREAD_STRING_JSON_EXT_NAN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN) |
| #define DUK_HTHREAD_STRING_JSON_EXT_NEGINF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF) |
| #define DUK_HTHREAD_STRING_JSON_EXT_POSINF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF) |
| #define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED) |
| #define DUK_HTHREAD_STRING_JX | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX) |
| #define DUK_HTHREAD_STRING_LAST_INDEX | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX) |
| #define DUK_HTHREAD_STRING_LC_ARGUMENTS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS) |
| #define DUK_HTHREAD_STRING_LC_BOOLEAN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN) |
| #define DUK_HTHREAD_STRING_LC_BUFFER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) |
| #define DUK_HTHREAD_STRING_LC_FUNCTION | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION) |
| #define DUK_HTHREAD_STRING_LC_NULL | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL) |
| #define DUK_HTHREAD_STRING_LC_NUMBER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER) |
| #define DUK_HTHREAD_STRING_LC_OBJECT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT) |
| #define DUK_HTHREAD_STRING_LC_POINTER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) |
| #define DUK_HTHREAD_STRING_LC_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING) |
| #define DUK_HTHREAD_STRING_LC_SYMBOL | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_SYMBOL) |
| #define DUK_HTHREAD_STRING_LC_UNDEFINED | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED) |
| #define DUK_HTHREAD_STRING_LENGTH | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH) |
| #define DUK_HTHREAD_STRING_LET | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET) |
| #define DUK_HTHREAD_STRING_LINE_NUMBER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER) |
| #define DUK_HTHREAD_STRING_MATH | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH) |
| #define DUK_HTHREAD_STRING_MESSAGE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE) |
| #define DUK_HTHREAD_STRING_MINUS_INFINITY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY) |
| #define DUK_HTHREAD_STRING_MINUS_ZERO | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO) |
| #define DUK_HTHREAD_STRING_MULTILINE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE) |
| #define DUK_HTHREAD_STRING_NAME | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME) |
| #define DUK_HTHREAD_STRING_NAN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN) |
| #define DUK_HTHREAD_STRING_NEW | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW) |
| #define DUK_HTHREAD_STRING_NEWLINE_4SPACE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_4SPACE) |
| #define DUK_HTHREAD_STRING_OBJ_ENV | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) |
| #define DUK_HTHREAD_STRING_OWN_KEYS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS) |
| #define DUK_HTHREAD_STRING_PACKAGE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE) |
| #define DUK_HTHREAD_STRING_PC | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC) |
| #define DUK_HTHREAD_STRING_PRIVATE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE) |
| #define DUK_HTHREAD_STRING_PROTECTED | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED) |
| #define DUK_HTHREAD_STRING_PROTOTYPE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE) |
| #define DUK_HTHREAD_STRING_PUBLIC | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC) |
| #define DUK_HTHREAD_STRING_REG_EXP | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP) |
| #define DUK_HTHREAD_STRING_RETURN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN) |
| #define DUK_HTHREAD_STRING_SET | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET) |
| #define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF) |
| #define DUK_HTHREAD_STRING_SOURCE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE) |
| #define DUK_HTHREAD_STRING_STACK | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK) |
| #define DUK_HTHREAD_STRING_STATIC | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC) |
| #define DUK_HTHREAD_STRING_SUPER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER) |
| #define DUK_HTHREAD_STRING_SWITCH | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH) |
| #define DUK_HTHREAD_STRING_THIS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS) |
| #define DUK_HTHREAD_STRING_THROW | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW) |
| #define DUK_HTHREAD_STRING_TO_GMT_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING) |
| #define DUK_HTHREAD_STRING_TO_ISO_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING) |
| #define DUK_HTHREAD_STRING_TO_JSON | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON) |
| #define DUK_HTHREAD_STRING_TO_LOCALE_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING) |
| #define DUK_HTHREAD_STRING_TO_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING) |
| #define DUK_HTHREAD_STRING_TO_UTC_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING) |
| #define DUK_HTHREAD_STRING_TRUE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE) |
| #define DUK_HTHREAD_STRING_TRY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY) |
| #define DUK_HTHREAD_STRING_TYPE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) |
| #define DUK_HTHREAD_STRING_TYPEOF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) |
| #define DUK_HTHREAD_STRING_UC_ARGUMENTS | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS) |
| #define DUK_HTHREAD_STRING_UC_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARRAY) |
| #define DUK_HTHREAD_STRING_UC_BOOLEAN | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN) |
| #define DUK_HTHREAD_STRING_UC_BUFFER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) |
| #define DUK_HTHREAD_STRING_UC_DATE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_DATE) |
| #define DUK_HTHREAD_STRING_UC_ERROR | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR) |
| #define DUK_HTHREAD_STRING_UC_FUNCTION | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION) |
| #define DUK_HTHREAD_STRING_UC_NULL | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL) |
| #define DUK_HTHREAD_STRING_UC_NUMBER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER) |
| #define DUK_HTHREAD_STRING_UC_OBJECT | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT) |
| #define DUK_HTHREAD_STRING_UC_POINTER | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) |
| #define DUK_HTHREAD_STRING_UC_STRING | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING) |
| #define DUK_HTHREAD_STRING_UC_SYMBOL | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_SYMBOL) |
| #define DUK_HTHREAD_STRING_UC_THREAD | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) |
| #define DUK_HTHREAD_STRING_UC_UNDEFINED | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED) |
| #define DUK_HTHREAD_STRING_UINT16_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) |
| #define DUK_HTHREAD_STRING_UINT32_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) |
| #define DUK_HTHREAD_STRING_UINT8_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) |
| #define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) |
| #define DUK_HTHREAD_STRING_VALUE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE) |
| #define DUK_HTHREAD_STRING_VALUE_OF | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF) |
| #define DUK_HTHREAD_STRING_VAR | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) |
| #define DUK_HTHREAD_STRING_VOID | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) |
| #define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_HAS_INSTANCE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_HAS_INSTANCE) |
| #define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE) |
| #define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_TO_PRIMITIVE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_PRIMITIVE) |
| #define DUK_HTHREAD_STRING_WELLKNOWN_SYMBOL_TO_STRING_TAG | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WELLKNOWN_SYMBOL_TO_STRING_TAG) |
| #define DUK_HTHREAD_STRING_WHILE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE) |
| #define DUK_HTHREAD_STRING_WITH | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) |
| #define DUK_HTHREAD_STRING_WRITABLE | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE) |
| #define DUK_HTHREAD_STRING_YIELD | ( | thr | ) | DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) |
| #define DUK_HTHREAD_THIS_PTR | ( | thr | ) | (DUK_ASSERT_EXPR((thr) != NULL), DUK_ASSERT_EXPR((thr)->valstack_bottom > (thr)->valstack), (thr)->valstack_bottom - 1) |
| #define DUK_INLINE_PERF DUK_INLINE |
| #define DUK_IS_POWER_OF_TWO | ( | x | ) | ((x) != 0U && ((x) & ((x) -1U)) == 0U) |
| #define DUK_ISPEC_REGCONST 2 /* value resides in a register or constant */ |
| #define DUK_ISPEC_VALUE 1 /* value resides in 'valstack_idx' */ |
| #define DUK_IVAL_ARITH 2 /* binary arithmetic; DUK_OP_ADD, DUK_OP_EQ, other binary ops */ |
| #define DUK_IVAL_PLAIN 1 /* register, constant, or value */ |
| #define duk_js_equals | ( | thr, | |
| tv_x, | |||
| tv_y | |||
| ) | duk_js_equals_helper((thr), (tv_x), (tv_y), 0) |
| #define duk_js_greaterthan | ( | thr, | |
| tv_x, | |||
| tv_y | |||
| ) | duk_js_compare_helper((thr), (tv_y), (tv_x), 0) |
| #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_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_lessthanorequal | ( | thr, | |
| tv_x, | |||
| tv_y | |||
| ) | duk_js_compare_helper((thr), (tv_y), (tv_x), DUK_COMPARE_FLAG_NEGATE) |
| #define duk_js_samevalue | ( | tv_x, | |
| tv_y | |||
| ) | duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_SAMEVALUE) |
| #define duk_js_strict_equals | ( | tv_x, | |
| tv_y | |||
| ) | duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_STRICT) |
| #define DUK_JSON_FLAG_ASCII_ONLY (1U << 0) /* escape any non-ASCII characters */ |
| #define DUK_JSON_FLAG_AVOID_KEY_QUOTES (1U << 1) /* avoid key quotes when key is an ASCII Identifier */ |
| #define DUK_JSON_FLAG_EXT_COMPATIBLE (1U << 3) /* extended types: compatible encoding */ |
| #define DUK_JSON_FLAG_EXT_CUSTOM (1U << 2) /* extended types: custom encoding */ |
| #define DUK_LEXER_GETPOINT | ( | ctx, | |
| pt | |||
| ) | duk_lexer_getpoint((ctx), (pt)) |
| #define DUK_LEXER_INITCTX | ( | ctx | ) | duk_lexer_initctx((ctx)) |
| #define DUK_LEXER_SETPOINT | ( | ctx, | |
| pt | |||
| ) | duk_lexer_setpoint((ctx), (pt)) |
| #define DUK_LFUNC_FLAGS_GET_LENGTH | ( | lf_flags | ) | (((lf_flags) >> 4) & 0x0fU) |
| #define DUK_LFUNC_FLAGS_GET_MAGIC | ( | lf_flags | ) | ((duk_int32_t) (duk_int8_t) (((duk_uint16_t) (lf_flags)) >> 8)) |
| #define DUK_LFUNC_FLAGS_GET_NARGS | ( | lf_flags | ) | ((lf_flags) &0x0fU) |
| #define DUK_LFUNC_FLAGS_PACK | ( | magic, | |
| length, | |||
| nargs | |||
| ) | ((((duk_small_uint_t) (magic)) & 0xffU) << 8) | ((length) << 4) | (nargs) |
| #define DUK_LFUNC_NARGS_MAX 0x0e /* max, excl. varargs marker */ |
| #define DUK_LFUNC_NARGS_VARARGS 0x0f /* varargs marker */ |
| #define DUK_LJ_TYPE_RESUME 3 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */ |
| #define DUK_LJ_TYPE_YIELD 2 /* value1 -> yield value, iserror -> error / normal */ |
| #define duk_memcpy | ( | dst, | |
| src, | |||
| len | |||
| ) |
| #define duk_memcpy_unsafe | ( | dst, | |
| src, | |||
| len | |||
| ) |
| #define duk_memmove | ( | dst, | |
| src, | |||
| len | |||
| ) |
| #define duk_memmove_unsafe | ( | dst, | |
| src, | |||
| len | |||
| ) |
| #define duk_memset | ( | dst, | |
| val, | |||
| len | |||
| ) |
| #define duk_memset_unsafe | ( | dst, | |
| val, | |||
| len | |||
| ) |
| #define duk_memzero | ( | dst, | |
| len | |||
| ) |
| #define duk_memzero_unsafe | ( | dst, | |
| len | |||
| ) |
| #define DUK_NOINLINE_PERF DUK_NOINLINE |
| #define DUK_OP_CALL0 176 /* DUK_OP_CALL0 & 0x0F must be zero. */ |
| #define DUK_OP_NONE 256 /* dummy value used as marker (doesn't fit in 8-bit field) */ |
| #define DUK_OP_PREDECR 121 /* see duk_js_executor.c and duk_js_compiler.c. */ |
| #define DUK_OP_PREINCP 128 /* pre/post inc/dec prop opcodes have constraints */ |
| #define DUK_OP_PREINCR 120 /* pre/post opcode values have constraints, */ |
| #define DUK_OP_RETCONSTN 160 /* return const without incref (e.g. number) */ |
| #define DUK_PAUSE_FLAG_CAUGHT_ERROR (1U << 5) /* pause when about to throw an error that is caught */ |
| #define DUK_PAUSE_FLAG_FUNC_ENTRY (1U << 3) /* pause when entering a function */ |
| #define DUK_PAUSE_FLAG_FUNC_EXIT (1U << 4) /* pause when exiting current function */ |
| #define DUK_PAUSE_FLAG_LINE_CHANGE (1U << 2) /* pause when current line number changes */ |
| #define DUK_PAUSE_FLAG_ONE_OPCODE (1U << 0) /* pause when a single opcode has been executed */ |
| #define DUK_PAUSE_FLAG_ONE_OPCODE_ACTIVE (1U << 1) /* one opcode pause actually active; artifact of current implementation */ |
| #define DUK_PAUSE_FLAG_UNCAUGHT_ERROR (1U << 6) /* pause when about to throw an error that won't be caught */ |
| #define DUK_PC2LINE_MAX_DIFF_LENGTH (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8) |
| #define DUK_PROPDESC_FLAG_ACCESSOR (1U << 3) /* accessor */ |
| #define DUK_PROPDESC_FLAG_CONFIGURABLE (1U << 2) /* E5 Section 8.6.1 */ |
| #define DUK_PROPDESC_FLAG_ENUMERABLE (1U << 1) /* E5 Section 8.6.1 */ |
| #define DUK_PROPDESC_FLAG_NO_OVERWRITE (1U << 4) /* internal define property: skip write silently if exists */ |
| #define DUK_PROPDESC_FLAG_VIRTUAL |
| #define DUK_PROPDESC_FLAG_WRITABLE (1U << 0) /* E5 Section 8.6.1 */ |
| #define DUK_PROPDESC_FLAGS_C (DUK_PROPDESC_FLAG_CONFIGURABLE) |
| #define DUK_PROPDESC_FLAGS_E (DUK_PROPDESC_FLAG_ENUMERABLE) |
| #define DUK_PROPDESC_FLAGS_EC (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE) |
| #define DUK_PROPDESC_FLAGS_MASK (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE | DUK_PROPDESC_FLAG_ACCESSOR) |
| #define DUK_PROPDESC_FLAGS_W (DUK_PROPDESC_FLAG_WRITABLE) |
| #define DUK_PROPDESC_FLAGS_WC (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE) |
| #define DUK_PROPDESC_FLAGS_WE (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE) |
| #define DUK_PROPDESC_FLAGS_WEC (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE) |
| #define DUK_PROPDESC_IS_ACCESSOR | ( | p | ) | (((p)->flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0) |
| #define DUK_PROPDESC_IS_CONFIGURABLE | ( | p | ) | (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0) |
| #define DUK_PROPDESC_IS_ENUMERABLE | ( | p | ) | (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0) |
| #define DUK_PROPDESC_IS_WRITABLE | ( | p | ) | (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0) |
| #define duk_push_hnatfunc | ( | thr, | |
| h | |||
| ) | duk_push_hobject((thr), (duk_hobject *) (h)) |
| #define duk_push_hthread | ( | thr, | |
| h | |||
| ) | duk_push_hobject((thr), (duk_hobject *) (h)) |
| #define duk_push_i32 | ( | thr, | |
| val | |||
| ) | duk_push_int((thr), (duk_int_t) (val)) |
| #define duk_push_i64 | ( | thr, | |
| val | |||
| ) | duk_push_number((thr), (duk_double_t) (val)) |
| #define duk_push_idx | ( | thr, | |
| val | |||
| ) | duk_push_int((thr), (duk_int_t) (val)) |
| #define duk_push_size_t | ( | thr, | |
| val | |||
| ) | duk_push_uint((thr), (duk_uint_t) (val)) /* XXX: assumed to fit for now */ |
| #define DUK_PUSH_SPRINTF_SANITY_LIMIT (1L * 1024L * 1024L * 1024L) |
| #define duk_push_u32 | ( | thr, | |
| val | |||
| ) | duk_push_uint((thr), (duk_uint_t) (val)) |
| #define duk_push_u64 | ( | thr, | |
| val | |||
| ) | duk_push_number((thr), (duk_double_t) (val)) |
| #define duk_push_uarridx | ( | thr, | |
| val | |||
| ) | duk_push_uint((thr), (duk_uint_t) (val)) |
| #define duk_put_prop_stridx_short | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) |
| #define DUK_RAW_READ_DOUBLE_BE | ( | ptr | ) | duk_raw_read_double_be((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_READINC_DOUBLE_BE | ( | ptr | ) | duk_raw_readinc_double_be(&(ptr)); |
| #define DUK_RAW_READINC_U16_BE | ( | ptr | ) | duk_raw_readinc_u16_be(&(ptr)); |
| #define DUK_RAW_READINC_U32_BE | ( | ptr | ) | duk_raw_readinc_u32_be(&(ptr)); |
| #define DUK_RAW_READINC_U8 | ( | ptr | ) | ((duk_uint8_t) (*(ptr)++)) |
| #define DUK_RAW_WRITE_DOUBLE_BE | ( | ptr, | |
| val | |||
| ) | duk_raw_write_double_be((ptr), (duk_double_t) (val)) |
| #define DUK_RAW_WRITE_FLOAT_BE | ( | ptr, | |
| val | |||
| ) | duk_raw_write_float_be((ptr), (duk_float_t) (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_U8 | ( | ptr, | |
| val | |||
| ) |
| #define DUK_RAW_WRITE_XUTF8 | ( | ptr, | |
| val | |||
| ) | duk_raw_write_xutf8((ptr), (duk_ucodepoint_t) (val)) |
| #define DUK_RAW_WRITEINC_CESU8 | ( | ptr, | |
| val | |||
| ) | duk_raw_writeinc_cesu8(&(ptr), (duk_ucodepoint_t) (val)) |
| #define DUK_RAW_WRITEINC_DOUBLE_BE | ( | ptr, | |
| val | |||
| ) | duk_raw_writeinc_double_be(&(ptr), (duk_double_t) (val)) |
| #define DUK_RAW_WRITEINC_FLOAT_BE | ( | ptr, | |
| val | |||
| ) | duk_raw_writeinc_float_be(&(ptr), (duk_float_t) (val)) |
| #define DUK_RAW_WRITEINC_U16_BE | ( | ptr, | |
| val | |||
| ) | duk_raw_writeinc_u16_be(&(ptr), (duk_uint16_t) (val)) |
| #define DUK_RAW_WRITEINC_U32_BE | ( | ptr, | |
| val | |||
| ) | duk_raw_writeinc_u32_be(&(ptr), (duk_uint32_t) (val)) |
| #define DUK_RAW_WRITEINC_U8 | ( | ptr, | |
| val | |||
| ) |
| #define DUK_RAW_WRITEINC_XUTF8 | ( | ptr, | |
| val | |||
| ) | duk_raw_writeinc_xutf8(&(ptr), (duk_ucodepoint_t) (val)) |
| #define DUK_RE_QUANTIFIER_INFINITE ((duk_uint32_t) 0xffffffffUL) |
| #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_REALLOC_RAW | ( | heap, | |
| ptr, | |||
| newsize | |||
| ) | ((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize))) |
| #define DUK_REFZERO_CHECK_FAST | ( | thr | ) |
| #define DUK_REFZERO_CHECK_SLOW | ( | thr | ) |
| #define DUK_REGCONST_CONST_MARKER DUK_INT32_MIN /* = -0x80000000 */ |
| #define duk_require_hobject_promote_lfunc | ( | thr, | |
| idx | |||
| ) | duk_require_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC) |
| #define DUK_RETOK_ATOM_DIGIT 11 /* assumptions in regexp compiler */ |
| #define DUK_S2N_FLAG_ALLOW_AUTO_LEGACY_OCT_INT (1U << 12) |
| #define DUK_STATS_INC | ( | heap, | |
| fieldname | |||
| ) |
| #define DUK_STR_BASE64_DECODE_FAILED "base64 decode failed" |
| #define DUK_STR_BASE64_ENCODE_FAILED "base64 encode failed" |
| #define DUK_STR_BOUND_CHAIN_LIMIT "function call bound chain limit" |
| #define DUK_STR_CANNOT_DELETE_IDENTIFIER "cannot delete identifier" |
| #define DUK_STR_CANNOT_NUMBER_COERCE_SYMBOL "cannot number coerce Symbol" |
| #define DUK_STR_CANNOT_STRING_COERCE_SYMBOL "cannot string coerce Symbol" |
| #define DUK_STR_COMPILER_RECURSION_LIMIT "compiler recursion limit" |
| #define DUK_STR_CONSTRUCT_ONLY "constructor requires 'new'" |
| #define DUK_STR_EMPTY_EXPR_NOT_ALLOWED "empty expression not allowed" |
| #define DUK_STR_EXPECTED_IDENTIFIER "expected identifier" |
| #define DUK_STR_FMT_INVALID_JSON "invalid json (at offset %ld)" |
| #define DUK_STR_FUNC_NAME_REQUIRED "function name required" |
| #define DUK_STR_FUNC_STMT_NOT_ALLOWED "function statement not allowed" |
| #define DUK_STR_INVALID_ARRAY_LENGTH "invalid array length" |
| #define DUK_STR_INVALID_ARRAY_LITERAL "invalid array literal" |
| #define DUK_STR_INVALID_BACKREFS "invalid backreference(s)" |
| #define DUK_STR_INVALID_BREAK_CONT_LABEL "invalid break/continue label" |
| #define DUK_STR_INVALID_FUNC_NAME "invalid function name" |
| #define DUK_STR_INVALID_GETSET_NAME "invalid getter/setter name" |
| #define DUK_STR_INVALID_INSTANCEOF_RVAL "invalid instanceof rval" |
| #define DUK_STR_INVALID_INSTANCEOF_RVAL_NOPROTO "instanceof rval has no .prototype" |
| #define DUK_STR_INVALID_NUMBER_LITERAL "invalid number literal" |
| #define DUK_STR_INVALID_OBJECT_LITERAL "invalid object literal" |
| #define DUK_STR_INVALID_QUANTIFIER "invalid regexp quantifier" |
| #define DUK_STR_INVALID_QUANTIFIER_NO_ATOM "quantifier without preceding atom" |
| #define DUK_STR_INVALID_QUANTIFIER_VALUES "quantifier values invalid (qmin > qmax)" |
| #define DUK_STR_INVALID_REGEXP_CHARACTER "invalid regexp character" |
| #define DUK_STR_INVALID_REGEXP_ESCAPE "invalid regexp escape" |
| #define DUK_STR_INVALID_REGEXP_FLAGS "invalid regexp flags" |
| #define DUK_STR_INVALID_REGEXP_GROUP "invalid regexp group" |
| #define DUK_STR_INVALID_SWITCH "invalid switch statement" |
| #define DUK_STR_INVALID_TRAP_RESULT "invalid trap result" |
| #define DUK_STR_INVALID_VAR_DECLARATION "invalid variable declaration" |
| #define DUK_STR_NOT_BUFFER "not buffer" /* still in use with verbose messages */ |
| #define DUK_STR_NOT_OBJECT_COERCIBLE "not object coercible" |
| #define DUK_STR_NUMBER_OUTSIDE_RANGE "number outside range" |
| #define DUK_STR_PROTOTYPE_CHAIN_LIMIT "prototype chain limit" |
| #define DUK_STR_PUSH_BEYOND_ALLOC_STACK "cannot push beyond allocated stack" |
| #define DUK_STR_QUANTIFIER_TOO_MANY_COPIES "quantifier requires too many atom copies" |
| #define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT "regexp compiler recursion limit" |
| #define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT "regexp executor recursion limit" |
| #define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT "regexp step limit" |
| #define DUK_STR_REGEXP_SUPPORT_DISABLED "regexp support disabled" |
| #define DUK_STR_SOURCE_DECODE_FAILED "source decode failed" |
| #define DUK_STR_STRICT_CALLER_READ "cannot read strict 'caller'" |
| #define DUK_STR_TOPRIMITIVE_FAILED "coercion to primitive failed" |
| #define DUK_STR_UNEXPECTED_CLOSING_PAREN "unexpected closing parenthesis" |
| #define DUK_STR_UNEXPECTED_END_OF_PATTERN "unexpected end of pattern" |
| #define DUK_STR_UNEXPECTED_REGEXP_TOKEN "unexpected token in regexp" |
| #define DUK_STR_UNTERMINATED_CHARCLASS "unterminated character class" |
| #define DUK_STR_UNTERMINATED_COMMENT "unterminated comment" |
| #define DUK_STR_UNTERMINATED_REGEXP "unterminated regexp" |
| #define DUK_STR_UNTERMINATED_STMT "unterminated statement" |
| #define DUK_STR_UNTERMINATED_STRING "unterminated string" |
| #define DUK_STR_WITH_IN_STRICT_MODE "with in strict mode" |
| #define DUK_STRIDX_DELETE_PROPERTY 72 /* 'deleteProperty' */ |
| #define DUK_STRIDX_END_RESERVED 167 /* exclusive endpoint */ |
| #define DUK_STRIDX_INT_FINALIZER 105 /* '\x82Finalizer' */ |
| #define DUK_STRIDX_INT_TRACEDATA 92 /* '\x82Tracedata' */ |
| #define DUK_STRIDX_JSON_EXT_FUNCTION1 120 /* '{"_func":true}' */ |
| #define DUK_STRIDX_JSON_EXT_FUNCTION2 121 /* '{_func:true}' */ |
| #define DUK_STRIDX_JSON_EXT_NAN 117 /* '{"_nan":true}' */ |
| #define DUK_STRIDX_JSON_EXT_NEGINF 119 /* '{"_ninf":true}' */ |
| #define DUK_STRIDX_JSON_EXT_POSINF 118 /* '{"_inf":true}' */ |
| #define DUK_STRIDX_JSON_EXT_UNDEFINED 116 /* '{"_undef":true}' */ |
| #define DUK_STRIDX_SET_PROTOTYPE_OF 80 /* 'setPrototypeOf' */ |
| #define DUK_STRIDX_TO_LOCALE_STRING 39 /* 'toLocaleString' */ |
| #define DUK_STRIDX_TO_TOK | ( | x | ) | ((x) -DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED) |
| #define DUK_STRIDX_UINT8_CLAMPED_ARRAY 20 /* 'Uint8ClampedArray' */ |
| #define DUK_STRIDX_WELLKNOWN_SYMBOL_HAS_INSTANCE 77 /* '\x81Symbol.hasInstance\xff' */ |
| #define DUK_STRIDX_WELLKNOWN_SYMBOL_IS_CONCAT_SPREADABLE 79 /* '\x81Symbol.isConcatSpreadable\xff' */ |
| #define DUK_STRIDX_WELLKNOWN_SYMBOL_TO_PRIMITIVE 76 /* '\x81Symbol.toPrimitive\xff' */ |
| #define DUK_STRIDX_WELLKNOWN_SYMBOL_TO_STRING_TAG 78 /* '\x81Symbol.toStringTag\xff' */ |
| #define DUK_TAG_NUMBER 0 /* DUK_TAG_NUMBER only defined for non-packed duk_tval */ |
| #define DUK_TAG_STRING 8 /* first heap allocated, match bit boundary */ |
| #define DUK_TAG_UNUSED 7 /* marker; not actual tagged type */ |
| #define DUK_TB_FLAG_NOBLAME_FILELINE (1U << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */ |
| #define DUK_TOK_ALSHIFT 74 /* named "arithmetic" because result is signed */ |
| #define DUK_TOK_INVALID DUK_SMALL_UINT_MAX |
| #define DUK_TVAL_ASSERT_VALID | ( | tv | ) |
| #define DUK_TVAL_CHKFAST_INPLACE_FAST | ( | tv | ) |
| #define DUK_TVAL_CHKFAST_INPLACE_SLOW | ( | tv | ) |
| #define DUK_TVAL_DECREF | ( | thr, | |
| tv | |||
| ) | DUK_TVAL_DECREF_FAST((thr), (tv)) |
| #define DUK_TVAL_DECREF_FAST | ( | thr, | |
| tv | |||
| ) |
| #define DUK_TVAL_DECREF_NORZ | ( | thr, | |
| tv | |||
| ) | DUK_TVAL_DECREF_NORZ_FAST((thr), (tv)) |
| #define DUK_TVAL_DECREF_NORZ_FAST | ( | thr, | |
| tv | |||
| ) |
| #define DUK_TVAL_DECREF_NORZ_SLOW | ( | thr, | |
| tv | |||
| ) |
| #define DUK_TVAL_DECREF_SLOW | ( | thr, | |
| tv | |||
| ) |
| #define DUK_TVAL_GET_BOOLEAN | ( | tv | ) | ((duk_small_uint_t) (tv)->v.i) |
| #define DUK_TVAL_GET_FASTINT_I32 | ( | tv | ) | ((duk_int32_t) ((tv)->v.fi)) |
| #define DUK_TVAL_GET_FASTINT_U32 | ( | tv | ) | ((duk_uint32_t) ((tv)->v.fi)) |
| #define DUK_TVAL_GET_LIGHTFUNC | ( | tv, | |
| out_fp, | |||
| out_flags | |||
| ) |
| #define DUK_TVAL_GET_LIGHTFUNC_FLAGS | ( | tv | ) | ((duk_small_uint_t) ((tv)->v_extra)) |
| #define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR | ( | tv | ) | ((tv)->v.lightfunc) |
| #define DUK_TVAL_GET_NUMBER | ( | tv | ) | (DUK_TVAL_IS_FASTINT((tv)) ? duk_tval_get_number_unpacked_fastint((tv)) : DUK_TVAL_GET_DOUBLE((tv))) |
| #define DUK_TVAL_INCREF | ( | thr, | |
| tv | |||
| ) | DUK_TVAL_INCREF_FAST((thr), (tv)) |
| #define DUK_TVAL_INCREF_FAST | ( | thr, | |
| tv | |||
| ) |
| #define DUK_TVAL_INCREF_SLOW | ( | thr, | |
| tv | |||
| ) |
| #define DUK_TVAL_IS_BOOLEAN | ( | tv | ) | ((tv)->t == DUK_TAG_BOOLEAN) |
| #define DUK_TVAL_IS_BOOLEAN_FALSE | ( | tv | ) | (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i == 0)) |
| #define DUK_TVAL_IS_BOOLEAN_TRUE | ( | tv | ) | (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0)) |
| #define DUK_TVAL_IS_BUFFER | ( | tv | ) | ((tv)->t == DUK_TAG_BUFFER) |
| #define DUK_TVAL_IS_DOUBLE | ( | tv | ) | ((tv)->t == DUK_TAG_NUMBER) |
| #define DUK_TVAL_IS_FASTINT | ( | tv | ) | ((tv)->t == DUK_TAG_FASTINT) |
| #define DUK_TVAL_IS_HEAP_ALLOCATED | ( | tv | ) | ((tv)->t & 0x08) |
| #define DUK_TVAL_IS_LIGHTFUNC | ( | tv | ) | ((tv)->t == DUK_TAG_LIGHTFUNC) |
| #define DUK_TVAL_IS_NULL | ( | tv | ) | ((tv)->t == DUK_TAG_NULL) |
| #define DUK_TVAL_IS_NUMBER | ( | tv | ) | ((tv)->t == DUK_TAG_NUMBER || (tv)->t == DUK_TAG_FASTINT) |
| #define DUK_TVAL_IS_OBJECT | ( | tv | ) | ((tv)->t == DUK_TAG_OBJECT) |
| #define DUK_TVAL_IS_POINTER | ( | tv | ) | ((tv)->t == DUK_TAG_POINTER) |
| #define DUK_TVAL_IS_STRING | ( | tv | ) | ((tv)->t == DUK_TAG_STRING) |
| #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_VALID_TAG | ( | tv | ) | (DUK_TVAL_GET_TAG((tv)) - DUK_TAG_MIN <= DUK_TAG_MAX - DUK_TAG_MIN) |
| #define DUK_TVAL_NEEDS_REFCOUNT_UPDATE | ( | tv | ) | DUK_TVAL_IS_HEAP_ALLOCATED((tv)) |
| #define DUK_TVAL_SET_BOOLEAN | ( | tv, | |
| val | |||
| ) |
| #define DUK_TVAL_SET_BOOLEAN_FALSE | ( | tv | ) | DUK_TVAL_SET_BOOLEAN((tv), 0) |
| #define DUK_TVAL_SET_BOOLEAN_TRUE | ( | tv | ) | DUK_TVAL_SET_BOOLEAN((tv), 1) |
| #define DUK_TVAL_SET_BOOLEAN_UPDREF DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0 |
| #define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_BUFFER | ( | tv, | |
| hptr | |||
| ) |
| #define DUK_TVAL_SET_BUFFER_UPDREF DUK_TVAL_SET_BUFFER_UPDREF_ALT0 |
| #define DUK_TVAL_SET_BUFFER_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_DOUBLE | ( | tv, | |
| val | |||
| ) |
| #define DUK_TVAL_SET_DOUBLE_UPDREF DUK_TVAL_SET_DOUBLE_UPDREF_ALT0 |
| #define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_FASTINT | ( | tv, | |
| i | |||
| ) | DUK_TVAL_SET_I48((tv), (i)) /* alias */ |
| #define DUK_TVAL_SET_FASTINT_UPDREF DUK_TVAL_SET_I48_UPDREF /* convenience */ |
| #define DUK_TVAL_SET_I32 | ( | tv, | |
| val | |||
| ) |
| #define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_I32_UPDREF_ALT0 |
| #define DUK_TVAL_SET_I32_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_I48 | ( | tv, | |
| val | |||
| ) |
| #define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_I48_UPDREF_ALT0 |
| #define DUK_TVAL_SET_I48_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_LIGHTFUNC | ( | tv, | |
| fp, | |||
| flags | |||
| ) |
| #define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0 |
| #define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| lf_v, | |||
| lf_fp, | |||
| lf_flags | |||
| ) |
| #define DUK_TVAL_SET_NAN | ( | tv | ) |
| #define DUK_TVAL_SET_NAN_UPDREF DUK_TVAL_SET_NAN_UPDREF_ALT0 |
| #define DUK_TVAL_SET_NAN_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst | |||
| ) |
| #define DUK_TVAL_SET_NULL | ( | tv | ) |
| #define DUK_TVAL_SET_NULL_UPDREF DUK_TVAL_SET_NULL_UPDREF_ALT0 |
| #define DUK_TVAL_SET_NULL_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst | |||
| ) |
| #define DUK_TVAL_SET_NUMBER | ( | tv, | |
| val | |||
| ) | DUK_TVAL_SET_DOUBLE((tv), (val)) |
| #define DUK_TVAL_SET_NUMBER_CHKFAST_FAST | ( | tv, | |
| d | |||
| ) | duk_tval_set_number_chkfast_fast((tv), (d)) |
| #define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW | ( | tv, | |
| d | |||
| ) | duk_tval_set_number_chkfast_slow((tv), (d)) |
| #define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0 |
| #define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_NUMBER_UPDREF DUK_TVAL_SET_NUMBER_UPDREF_ALT0 |
| #define DUK_TVAL_SET_NUMBER_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_OBJECT | ( | tv, | |
| hptr | |||
| ) |
| #define DUK_TVAL_SET_OBJECT_UPDREF DUK_TVAL_SET_OBJECT_UPDREF_ALT0 |
| #define DUK_TVAL_SET_OBJECT_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_POINTER | ( | tv, | |
| hptr | |||
| ) |
| #define DUK_TVAL_SET_POINTER_UPDREF DUK_TVAL_SET_POINTER_UPDREF_ALT0 |
| #define DUK_TVAL_SET_POINTER_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_STRING | ( | tv, | |
| hptr | |||
| ) |
| #define DUK_TVAL_SET_STRING_UPDREF DUK_TVAL_SET_STRING_UPDREF_ALT0 |
| #define DUK_TVAL_SET_STRING_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_TVAL | ( | tv, | |
| x | |||
| ) |
| #define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT1 |
| #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_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT1 |
| #define DUK_TVAL_SET_TVAL_UPDREF_NORZ | ( | thr, | |
| tv_dst, | |||
| tv_src | |||
| ) |
| #define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0 |
| #define DUK_TVAL_SET_U32 | ( | tv, | |
| val | |||
| ) |
| #define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_U32_UPDREF_ALT0 |
| #define DUK_TVAL_SET_U32_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst, | |||
| newval | |||
| ) |
| #define DUK_TVAL_SET_U32_UPDREF_NORZ | ( | thr, | |
| tv_dst, | |||
| val | |||
| ) |
| #define DUK_TVAL_SET_UNDEFINED | ( | tv | ) |
| #define DUK_TVAL_SET_UNDEFINED_UPDREF DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0 |
| #define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst | |||
| ) |
| #define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0 |
| #define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0 | ( | thr, | |
| tvptr_dst | |||
| ) |
| #define DUK_TVAL_SET_UNUSED | ( | tv | ) |
| #define DUK_TVAL_SET_UNUSED_UPDREF DUK_TVAL_SET_UNUSED_UPDREF_ALT0 |
| #define DUK_TVAL_SET_UNUSED_UPDREF_ALT0 | ( | thr, | |
| tvptr_dst | |||
| ) |
| #define DUK_TVAL_STRING_IS_SYMBOL | ( | tv | ) | DUK_HSTRING_HAS_SYMBOL(DUK_TVAL_GET_STRING((tv))) |
| #define DUK_TVAL_UNUSED_INITIALIZER | ( | ) | { DUK_TAG_UNUSED, 0, 0.0 } |
| #define DUK_UNICODE_CP_REPLACEMENT_CHARACTER |
| #define DUK_UNICODE_CP_ZWJ 0x200dL /* zero-width joiner */ |
| #define DUK_UNICODE_CP_ZWNJ 0x200cL /* zero-width non-joiner */ |
| #define DUK_UNICODE_MAX_CESU8_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_XUTF8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */ |
| #define DUK_UNICODE_MAX_XUTF8_LENGTH 7 /* up to 36 bit codepoints */ |
| #define DUK_VALSTACK_API_ENTRY_MINIMUM DUK_API_ENTRY_STACK |
| #define DUK_VALSTACK_ASSERT_EXTRA |
| #define duk_xdef_prop_index_wec | ( | thr, | |
| obj_idx, | |||
| arr_idx | |||
| ) | duk_xdef_prop_index((thr), (obj_idx), (arr_idx), DUK_PROPDESC_FLAGS_WEC) |
| #define duk_xdef_prop_stridx_short | ( | thr, | |
| obj_idx, | |||
| stridx, | |||
| desc_flags | |||
| ) |
| #define duk_xdef_prop_stridx_short_wec | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) | duk_xdef_prop_stridx_short((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC) |
| #define duk_xdef_prop_stridx_wec | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) | duk_xdef_prop_stridx((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC) |
| #define duk_xdef_prop_wec | ( | thr, | |
| obj_idx | |||
| ) | duk_xdef_prop((thr), (obj_idx), DUK_PROPDESC_FLAGS_WEC) |
| #define duk_xget_owndataprop_stridx_short | ( | thr, | |
| obj_idx, | |||
| stridx | |||
| ) |
| typedef struct duk__compile_raw_args duk__compile_raw_args |
| typedef struct duk__pcall_args duk__pcall_args |
| typedef struct duk__pcall_method_args duk__pcall_method_args |
| typedef struct duk__pcall_prop_args duk__pcall_prop_args |
| typedef duk_double_t duk__sort_key_t |
| 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 union duk__u16_union duk__u16_union |
| typedef union duk__u32_union duk__u32_union |
| typedef struct duk_activation duk_activation |
| typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx |
| typedef struct duk_bitencoder_ctx duk_bitencoder_ctx |
| typedef struct duk_breakpoint duk_breakpoint |
| typedef struct duk_bufwriter_ctx duk_bufwriter_ctx |
| typedef struct duk_catcher duk_catcher |
| typedef struct duk_compiler_ctx duk_compiler_ctx |
| typedef struct duk_compiler_func duk_compiler_func |
| typedef struct duk_compiler_instr duk_compiler_instr |
| typedef union duk_double_union duk_double_union |
| typedef union duk_float_union duk_float_union |
| typedef struct duk_harray duk_harray |
| typedef struct duk_hboundfunc duk_hboundfunc |
| typedef struct duk_hbuffer duk_hbuffer |
| typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic |
| typedef struct duk_hbuffer_external duk_hbuffer_external |
| typedef struct duk_hbuffer_fixed duk_hbuffer_fixed |
| typedef struct duk_hbufobj duk_hbufobj |
| typedef struct duk_hcompfunc duk_hcompfunc |
| typedef struct duk_hdecenv duk_hdecenv |
| typedef struct duk_heaphdr duk_heaphdr |
| typedef struct duk_heaphdr_string duk_heaphdr_string |
| typedef struct duk_hnatfunc duk_hnatfunc |
| typedef struct duk_hobject duk_hobject |
| typedef struct duk_hobjenv duk_hobjenv |
| typedef struct duk_hproxy duk_hproxy |
| typedef struct duk_hstring duk_hstring |
| typedef struct duk_hstring_external duk_hstring_external |
| typedef struct duk_hthread duk_hthread |
| typedef duk_uint32_t duk_instr_t |
| typedef struct duk_internal_thread_state duk_internal_thread_state |
| typedef struct duk_jmpbuf duk_jmpbuf |
| typedef struct duk_lexer_codepoint duk_lexer_codepoint |
| typedef struct duk_lexer_ctx duk_lexer_ctx |
| typedef struct duk_lexer_point duk_lexer_point |
| typedef struct duk_litcache_entry duk_litcache_entry |
| typedef struct duk_ljstate duk_ljstate |
| typedef void *(* duk_mem_getptr) (duk_heap *heap, void *ud) |
| typedef struct duk_propaccessor duk_propaccessor |
| typedef struct duk_propdesc duk_propdesc |
| typedef union duk_propvalue duk_propvalue |
| typedef struct duk_re_compiler_ctx duk_re_compiler_ctx |
| typedef struct duk_re_matcher_ctx duk_re_matcher_ctx |
| typedef void(* duk_re_range_callback) (void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct) |
| typedef struct duk_re_token duk_re_token |
| typedef duk_int32_t duk_regconst_t |
| typedef struct duk_strcache_entry duk_strcache_entry |
| typedef struct duk_strtab_entry duk_strtab_entry |
| typedef struct duk_tval_struct duk_tval |
| DUK_LOCAL duk_bool_t duk__abandon_array_check | ( | duk_hthread * | thr, |
| duk_uint32_t | arr_idx, | ||
| duk_hobject * | obj | ||
| ) |
| DUK_LOCAL duk_bool_t duk__abandon_array_density_check | ( | duk_uint32_t | a_used, |
| duk_uint32_t | a_size | ||
| ) |
| DUK_LOCAL void duk__abandon_array_part | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
Definition at line 59111 of file duktape.c.
References DUK_UINT16_MAX.
Referenced by duk_hobject_define_property_helper().
| DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required | ( | duk_uint32_t | arr_idx, |
| duk_uint32_t | old_size | ||
| ) |
Definition at line 58243 of file duktape.c.
References DUK_USE_HOBJECT_ARRAY_ABANDON_LIMIT.
| DUK_LOCAL void duk__activation_unwind_nofree_norz | ( | duk_hthread * | thr | ) |
Definition at line 65675 of file duktape.c.
References duk__hthread_activation_alloc_slow().
| DUK_LOCAL void duk__add_compiler_error_line | ( | duk_hthread * | thr | ) |
| DUK_LOCAL void duk__add_enum_key | ( | duk_hthread * | thr, |
| duk_hstring * | k | ||
| ) |
| DUK_LOCAL void duk__add_enum_key_stridx | ( | duk_hthread * | thr, |
| duk_small_uint_t | stridx | ||
| ) |
| DUK_LOCAL void duk__add_label | ( | duk_compiler_ctx * | comp_ctx, |
| duk_hstring * | h_label, | ||
| duk_int_t | pc_label, | ||
| duk_int_t | label_id | ||
| ) |
| DUK_LOCAL void duk__add_traceback | ( | duk_hthread * | thr, |
| duk_hthread * | thr_callstack, | ||
| const char * | c_filename, | ||
| duk_int_t | c_line, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL void duk__advance | ( | duk_compiler_ctx * | ctx | ) |
Definition at line 69561 of file duktape.c.
Referenced by duk__parse_func_body(), and duk__parse_var_decl().
| DUK_LOCAL void duk__advance_bytes | ( | duk_lexer_ctx * | lex_ctx, |
| duk_small_uint_t | count_bytes | ||
| ) |
| DUK_LOCAL void duk__advance_chars | ( | duk_lexer_ctx * | lex_ctx, |
| duk_small_uint_t | count_chars | ||
| ) |
Definition at line 86211 of file duktape.c.
References duk_lexer_ctx::input_line.
| DUK_LOCAL void duk__advance_expect | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_int_t | expect | ||
| ) |
Definition at line 69556 of file duktape.c.
Referenced by duk__parse_func_body().
| DUK_LOCAL void duk__advance_helper | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_int_t | expect | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__alloctemp | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL duk_regconst_t duk__alloctemps | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_int_t | num | ||
| ) |
| DUK_LOCAL duk_int_t duk__api_coerce_d2i | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | def_value, | ||
| duk_bool_t | require | ||
| ) |
Definition at line 18789 of file duktape.c.
Referenced by duk_get_int_default(), duk_opt_int(), and duk_require_int().
| DUK_LOCAL duk_uint_t duk__api_coerce_d2ui | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | def_value, | ||
| duk_bool_t | require | ||
| ) |
Definition at line 18850 of file duktape.c.
Referenced by duk_get_uint_default(), and duk_require_uint().
| DUK_LOCAL void duk__append_7bit | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_uint32_t | x | ||
| ) |
| DUK_LOCAL duk_uint32_t duk__append_jump_offset | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_int32_t | skip | ||
| ) |
| DUK_LOCAL void duk__append_range_atom_matcher | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_small_uint_t | re_op, | ||
| const duk_uint16_t * | ranges, | ||
| duk_small_uint_t | count | ||
| ) |
| DUK_LOCAL void duk__append_reop | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_uint32_t | reop | ||
| ) |
| 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__append_u16_list | ( | duk_re_compiler_ctx * | re_ctx, |
| const duk_uint16_t * | values, | ||
| duk_uint32_t | count | ||
| ) |
| DUK_LOCAL void duk__append_u32 | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_uint32_t | x | ||
| ) |
Definition at line 90593 of file duktape.c.
Referenced by duk__insert_slice(), and duk__re_canon_next_discontinuity().
| DUK_LOCAL void duk__appendbuffer | ( | duk_lexer_ctx * | lex_ctx, |
| duk_codepoint_t | x | ||
| ) |
Definition at line 86237 of file duktape.c.
References duk_lexer_codepoint::codepoint, duk_lexer_ctx::input_line, duk_lexer_ctx::input_offset, duk_lexer_codepoint::line, and duk_lexer_codepoint::offset.
| DUK_LOCAL void duk__appendbuffer_ascii | ( | duk_lexer_ctx * | lex_ctx, |
| duk_codepoint_t | x | ||
| ) |
| DUK_LOCAL duk_ret_t duk__array_pop_fastpath | ( | duk_hthread * | thr, |
| duk_harray * | h_arr | ||
| ) |
| DUK_LOCAL duk_ret_t duk__array_push_fastpath | ( | duk_hthread * | thr, |
| duk_harray * | h_arr | ||
| ) |
| DUK_LOCAL void duk__array_qsort | ( | duk_hthread * | thr, |
| duk_int_t | lo, | ||
| duk_int_t | hi | ||
| ) |
| DUK_LOCAL duk_small_int_t duk__array_sort_compare | ( | duk_hthread * | thr, |
| duk_int_t | idx1, | ||
| duk_int_t | idx2 | ||
| ) |
| DUK_LOCAL void duk__array_sort_swap | ( | duk_hthread * | thr, |
| duk_int_t | l, | ||
| duk_int_t | r | ||
| ) |
| DUK_LOCAL void duk__arraybuffer_plain_slice | ( | duk_hthread * | thr, |
| duk_hbuffer * | h_val | ||
| ) |
Definition at line 29666 of file duktape.c.
References duk__clamp_startend_negidx_shifted(), DUK_ASSERT, DUK_HBUFFER_GET_SIZE, and duk_push_fixed_buffer_nozero().
| DUK_LOCAL duk_harray * duk__arraypart_fastpath_this | ( | duk_hthread * | thr | ) |
| DUK_LOCAL double duk__atan2_fixed | ( | double | x, |
| double | y | ||
| ) |
Definition at line 40829 of file duktape.c.
References DUK_LOG.
Referenced by duk_bi_math_object_onearg_shared().
| DUK_LOCAL duk_hstring * duk__auto_unbox_symbol | ( | duk_hthread * | thr, |
| duk_tval * | tv_arg | ||
| ) |
| DUK_LOCAL duk_hbufobj * duk__autospawn_arraybuffer | ( | duk_hthread * | thr, |
| duk_hbuffer * | h_buf | ||
| ) |
| 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_LOCAL DUK_ALWAYS_INLINE void duk__base64_encode_fast_1 | ( | const duk_uint8_t * | src, |
| duk_uint8_t * | dst | ||
| ) |
Definition at line 15845 of file duktape.c.
References duk__base64_enctab_fast, and DUK_ASC_EQUALS.
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__base64_encode_fast_2 | ( | const duk_uint8_t * | src, |
| duk_uint8_t * | dst | ||
| ) |
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__base64_encode_fast_3 | ( | const duk_uint8_t * | src, |
| duk_uint8_t * | dst | ||
| ) |
| DUK_LOCAL void duk__base64_encode_helper | ( | const duk_uint8_t * | src, |
| duk_size_t | srclen, | ||
| duk_uint8_t * | dst | ||
| ) |
| DUK_LOCAL duk_int32_t duk__bc_get_i32 | ( | duk_re_matcher_ctx * | re_ctx, |
| const duk_uint8_t ** | pc | ||
| ) |
| DUK_LOCAL duk_uint32_t duk__bc_get_u32 | ( | duk_re_matcher_ctx * | re_ctx, |
| const duk_uint8_t ** | pc | ||
| ) |
| DUK_LOCAL void duk__bi_add | ( | duk__bigint * | x, |
| duk__bigint * | y, | ||
| duk__bigint * | z | ||
| ) |
Definition at line 88383 of file duktape.c.
References DUK__BI_MAX_PARTS, DUK_ASSERT, duk__bigint::n, and duk__bigint::v.
Referenced by duk__bi_sub().
| DUK_LOCAL void duk__bi_add_small | ( | duk__bigint * | x, |
| duk__bigint * | y, | ||
| duk_uint32_t | z | ||
| ) |
Definition at line 88439 of file duktape.c.
References DUK__BI_MAX_PARTS, DUK_ASSERT, and duk__bigint::v.
| DUK_LOCAL int duk__bi_compare | ( | duk__bigint * | x, |
| duk__bigint * | y | ||
| ) |
Definition at line 88307 of file duktape.c.
References DUK_ASSERT, duk__bigint::n, and duk__bigint::v.
| DUK_LOCAL void duk__bi_copy | ( | duk__bigint * | x, |
| duk__bigint * | y | ||
| ) |
Definition at line 88284 of file duktape.c.
Referenced by duk__bi_exp_small(), and duk__bi_sub().
| 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 88743 of file duktape.c.
References duk__bi_copy(), and duk__bi_mul_small().
| DUK_LOCAL duk_small_int_t duk__bi_is_2to52 | ( | duk__bigint * | x | ) |
| DUK_LOCAL int duk__bi_is_even | ( | duk__bigint * | x | ) |
| DUK_LOCAL int duk__bi_is_zero | ( | duk__bigint * | x | ) |
| DUK_LOCAL void duk__bi_mul | ( | duk__bigint * | x, |
| duk__bigint * | y, | ||
| duk__bigint * | z | ||
| ) |
| DUK_LOCAL void duk__bi_mul_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 | ||
| ) |
Definition at line 88685 of file duktape.c.
Referenced by duk__bi_exp_small().
| DUK_LOCAL void duk__bi_mul_small_copy | ( | duk__bigint * | x, |
| duk_uint32_t | y, | ||
| duk__bigint * | t | ||
| ) |
| DUK_LOCAL void duk__bi_normalize | ( | duk__bigint * | x | ) |
Definition at line 88269 of file duktape.c.
References DUK__BI_MAX_PARTS.
| DUK_LOCAL void duk__bi_set_small | ( | duk__bigint * | x, |
| duk_uint32_t | v | ||
| ) |
Definition at line 88293 of file duktape.c.
References DUK_SPRINTF.
| DUK_LOCAL void duk__bi_sub | ( | duk__bigint * | x, |
| duk__bigint * | y, | ||
| duk__bigint * | z | ||
| ) |
Definition at line 88492 of file duktape.c.
References duk__bi_add(), and duk__bi_copy().
| DUK_LOCAL void duk__bi_sub_copy | ( | duk__bigint * | x, |
| duk__bigint * | y, | ||
| duk__bigint * | t | ||
| ) |
| DUK_LOCAL void duk__bi_twoexp | ( | duk__bigint * | x, |
| duk_small_int_t | y | ||
| ) |
| 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 100153 of file duktape.c.
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.
Referenced by duk_bw_insert_raw_bytes().
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__call_c_recursion_limit_check | ( | duk_hthread * | thr | ) |
Definition at line 66145 of file duktape.c.
References duk_heap::augmenting_error, duk_heap::call_recursion_depth, duk_heap::call_recursion_limit, DUK__AUGMENT_CALL_RELAX_COUNT, DUK_D, DUK_DPRINT, and duk_hthread::heap.
Referenced by duk__handle_call_raw().
| DUK_LOCAL DUK_NOINLINE void duk__call_c_recursion_limit_check_slowpath | ( | duk_hthread * | thr | ) |
Definition at line 66127 of file duktape.c.
References DUK_ERROR_RANGE, DUK_STR_NATIVE_STACK_LIMIT, and DUK_UNREF.
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__call_callstack_limit_check | ( | duk_hthread * | thr | ) |
Definition at line 66183 of file duktape.c.
References duk_hthread::callstack_top, DUK__AUGMENT_CALL_RELAX_COUNT, DUK_D, DUK_DPRINT, and DUK_USE_CALLSTACK_LIMIT.
| DUK_LOCAL DUK_NOINLINE void duk__call_callstack_limit_check_slowpath | ( | duk_hthread * | thr | ) |
| DUK_LOCAL void duk__call_env_setup | ( | duk_hthread * | thr, |
| duk_hobject * | func, | ||
| duk_activation * | act, | ||
| duk_idx_t | idx_args | ||
| ) |
Definition at line 67901 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_LOCAL duk_idx_t duk__call_get_idx_func | ( | duk_hthread * | thr, |
| duk_idx_t | nargs, | ||
| duk_idx_t | other | ||
| ) |
| DUK_LOCAL duk_idx_t duk__call_get_idx_func_unvalidated | ( | duk_hthread * | thr, |
| duk_idx_t | nargs, | ||
| duk_idx_t | other | ||
| ) |
Definition at line 15259 of file duktape.c.
References DUK_ERROR_TYPE_INVALID_ARGS, and DUK_WO_NORETURN.
| DUK_LOCAL void duk__call_prop_prep_stack | ( | duk_hthread * | thr, |
| duk_idx_t | normalized_obj_idx, | ||
| duk_idx_t | nargs | ||
| ) |
| DUK_LOCAL duk_small_uint_t duk__call_setup_act_attempt_tailcall | ( | duk_hthread * | thr, |
| duk_small_uint_t | call_flags, | ||
| duk_idx_t | idx_func, | ||
| duk_hobject * | func, | ||
| duk_size_t | entry_valstack_bottom_byteoff, | ||
| duk_size_t | entry_valstack_end_byteoff, | ||
| duk_idx_t * | out_nargs, | ||
| duk_idx_t * | out_nregs, | ||
| duk_size_t * | out_vs_min_bytes, | ||
| duk_activation ** | out_act | ||
| ) |
Definition at line 67522 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_LOCAL void duk__call_setup_act_not_tailcall | ( | duk_hthread * | thr, |
| duk_small_uint_t | call_flags, | ||
| duk_idx_t | idx_func, | ||
| duk_hobject * | func, | ||
| duk_size_t | entry_valstack_bottom_byteoff, | ||
| duk_size_t | entry_valstack_end_byteoff, | ||
| duk_idx_t * | out_nargs, | ||
| duk_idx_t * | out_nregs, | ||
| duk_size_t * | out_vs_min_bytes, | ||
| duk_activation ** | out_act | ||
| ) |
Definition at line 67745 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_LOCAL void duk__call_thread_state_update | ( | duk_hthread * | thr | ) |
Definition at line 67964 of file duktape.c.
Referenced by duk__handle_call_raw().
| 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 13630 of file duktape.c.
References duk_bitdecoder_ctx::data, duk__slow_case_conversion(), DUK_BW_WRITE_RAW_U8, DUK_BW_WRITE_RAW_XUTF8, duk_memzero, duk_unicode_caseconv_lc, duk_unicode_caseconv_uc, duk_unicode_is_letter(), and duk_bitdecoder_ctx::length.
| DUK_LOCAL void duk__cbor_decode | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | decode_flags | ||
| ) |
| DUK_LOCAL duk_uint32_t duk__cbor_decode_aival_uint32 | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | ib | ||
| ) |
Definition at line 31661 of file duktape.c.
References duk__cbor_decode_error().
| DUK_LOCAL void duk__cbor_decode_and_join_strbuf | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | expected_base | ||
| ) |
| DUK_LOCAL duk_bool_t duk__cbor_decode_array | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | ib, | ||
| duk_uint8_t | ai | ||
| ) |
| DUK_LOCAL void duk__cbor_decode_buffer | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | expected_base | ||
| ) |
| DUK_LOCAL int duk__cbor_decode_checkbreak | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31521 of file duktape.c.
References duk_cbor_decode_context::buf, duk__cbor_decode_error(), DUK_ASSERT, DUK_LIKELY, duk_cbor_decode_context::len, and duk_cbor_decode_context::off.
| DUK_LOCAL const duk_uint8_t * duk__cbor_decode_consume | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_size_t | len | ||
| ) |
| DUK_LOCAL duk_double_t duk__cbor_decode_double | ( | duk_cbor_decode_context * | dec_ctx | ) |
| DUK_LOCAL void duk__cbor_decode_error | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31428 of file duktape.c.
Referenced by duk__cbor_decode_aival_uint32(), duk__cbor_decode_checkbreak(), duk__cbor_decode_half_float(), duk__cbor_decode_peekbyte(), and duk__cbor_decode_read_u32().
| DUK_LOCAL duk_double_t duk__cbor_decode_float | ( | duk_cbor_decode_context * | dec_ctx | ) |
| DUK_LOCAL duk_double_t duk__cbor_decode_half_float | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31773 of file duktape.c.
References duk__cbor_decode_error().
| DUK_LOCAL void duk__cbor_decode_join_buffers | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_idx_t | count | ||
| ) |
| DUK_LOCAL duk_bool_t duk__cbor_decode_map | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | ib, | ||
| duk_uint8_t | ai | ||
| ) |
| DUK_LOCAL void duk__cbor_decode_objarr_entry | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31436 of file duktape.c.
References duk_type_error, and duk_cbor_decode_context::thr.
| DUK_LOCAL void duk__cbor_decode_objarr_exit | ( | duk_cbor_decode_context * | dec_ctx | ) |
| DUK_LOCAL duk_uint8_t duk__cbor_decode_peekbyte | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31489 of file duktape.c.
References duk__cbor_decode_error(), DUK_ASSERT, DUK_UNLIKELY, duk_cbor_decode_context::len, and duk_cbor_decode_context::off.
Referenced by duk__cbor_decode_push_aival_int().
| DUK_LOCAL void duk__cbor_decode_push_aival_int | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | ib, | ||
| duk_bool_t | negative | ||
| ) |
Definition at line 31533 of file duktape.c.
References duk__cbor_decode_peekbyte(), duk__cbor_decode_readbyte(), DUK_ASSERT, duk_cbor_decode_context::len, and duk_cbor_decode_context::off.
| DUK_LOCAL duk_uint16_t duk__cbor_decode_read_u16 | ( | duk_cbor_decode_context * | dec_ctx | ) |
| DUK_LOCAL duk_uint32_t duk__cbor_decode_read_u32 | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31477 of file duktape.c.
References duk_cbor_decode_context::buf, duk__cbor_decode_error(), DUK_ASSERT, DUK_RAW_READ_U16_BE, DUK_UNLIKELY, duk_cbor_decode_context::len, and duk_cbor_decode_context::off.
| DUK_LOCAL duk_uint8_t duk__cbor_decode_readbyte | ( | duk_cbor_decode_context * | dec_ctx | ) |
Definition at line 31457 of file duktape.c.
References DUK_ERROR_RANGE, DUK_STR_DEC_RECLIMIT, and DUK_WO_NORETURN.
Referenced by duk__cbor_decode_push_aival_int().
| DUK_LOCAL void duk__cbor_decode_req_stack | ( | duk_cbor_decode_context * | dec_ctx | ) |
| DUK_LOCAL void duk__cbor_decode_rewind | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_size_t | len | ||
| ) |
| DUK_LOCAL void duk__cbor_decode_skip_aival_int | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | ib | ||
| ) |
Definition at line 31646 of file duktape.c.
References DUK_INT_MIN, duk_push_int(), duk_push_number(), and duk_cbor_decode_context::thr.
| DUK_LOCAL void duk__cbor_decode_string | ( | duk_cbor_decode_context * | dec_ctx, |
| duk_uint8_t | ib, | ||
| duk_uint8_t | ai | ||
| ) |
| DUK_LOCAL void duk__cbor_decode_value | ( | duk_cbor_decode_context * | dec_ctx | ) |
| DUK_LOCAL duk_uint32_t duk__cbor_double_to_uint32 | ( | double | d | ) |
| DUK_LOCAL void duk__cbor_encode | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | encode_flags | ||
| ) |
Definition at line 32535 of file duktape.c.
Referenced by duk_bi_cbor_encode().
| DUK_LOCAL void duk__cbor_encode_buffer | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_double | ( | duk_cbor_encode_context * | enc_ctx, |
| double | d | ||
| ) |
| DUK_LOCAL void duk__cbor_encode_double_fp | ( | duk_cbor_encode_context * | enc_ctx, |
| double | d | ||
| ) |
| DUK_LOCAL DUK_INLINE void duk__cbor_encode_ensure | ( | duk_cbor_encode_context * | enc_ctx, |
| duk_size_t | len | ||
| ) |
| DUK_LOCAL DUK_NOINLINE void duk__cbor_encode_ensure_slowpath | ( | duk_cbor_encode_context * | enc_ctx, |
| duk_size_t | len | ||
| ) |
Definition at line 30836 of file duktape.c.
References DUK_ASSERT, and duk_cbor_encode_context::recursion_depth.
| DUK_LOCAL void duk__cbor_encode_error | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_lightfunc | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_objarr_entry | ( | duk_cbor_encode_context * | enc_ctx | ) |
Definition at line 30805 of file duktape.c.
References duk_type_error, and duk_cbor_encode_context::thr.
| DUK_LOCAL void duk__cbor_encode_objarr_exit | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_object | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_pointer | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_req_stack | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_sizet_uint32_check | ( | duk_cbor_encode_context * | enc_ctx, |
| duk_size_t | len | ||
| ) |
| DUK_LOCAL void duk__cbor_encode_string_top | ( | duk_cbor_encode_context * | enc_ctx | ) |
| DUK_LOCAL void duk__cbor_encode_uint32 | ( | duk_cbor_encode_context * | enc_ctx, |
| duk_uint32_t | u, | ||
| duk_uint8_t | base | ||
| ) |
| DUK_LOCAL void duk__cbor_encode_value | ( | duk_cbor_encode_context * | enc_ctx | ) |
Definition at line 31354 of file duktape.c.
References duk__cbor_get_reserve(), DUK_ASSERT, and duk_cbor_encode_context::ptr.
| DUK_LOCAL duk_size_t duk__cbor_get_reserve | ( | duk_cbor_encode_context * | enc_ctx | ) |
Definition at line 30889 of file duktape.c.
Referenced by duk__cbor_encode_value().
| DUK_LOCAL double duk__cbrt | ( | double | x | ) |
Definition at line 40695 of file duktape.c.
References DUK_SIGNBIT.
| DUK_LOCAL double duk__ceil | ( | double | x | ) |
| DUK_LOCAL void duk__check_arguments_map_for_delete | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_propdesc * | temp_desc | ||
| ) |
| DUK_LOCAL duk_bool_t duk__check_arguments_map_for_get | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_propdesc * | temp_desc | ||
| ) |
| DUK_LOCAL 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 59660 of file duktape.c.
Referenced by duk_hobject_putprop().
| DUK_LOCAL void duk__clamp_startend_negidx_shifted | ( | duk_hthread * | thr, |
| duk_int_t | buffer_length, | ||
| duk_uint8_t | buffer_shift, | ||
| 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 28114 of file duktape.c.
Referenced by duk__arraybuffer_plain_slice().
| DUK_LOCAL duk_int_t duk__cleanup_varmap | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 52591 of file duktape.c.
References DUK_ASSERT, DUK_DD, DUK_DDPRINT, DUK_HEAPHDR_CLEAR_REACHABLE, DUK_HEAPHDR_HAS_FINALIZABLE, and duk_heap::finalize_list.
| DUK_LOCAL DUK_INLINE void duk__coerce_nonstrict_this_binding | ( | duk_hthread * | thr, |
| duk_idx_t | idx_this | ||
| ) |
Definition at line 67173 of file duktape.c.
References duk_hthread::builtins, DUK_ASSERT, DUK_BIDX_GLOBAL, DUK_DDD, DUK_DDDPRINT, DUK_HOBJECT_INCREF, DUK_LIKELY, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_UNDEFINED, DUK_TVAL_GET_TAG, DUK_TVAL_IS_HEAP_ALLOCATED, DUK_TVAL_SET_OBJECT, and duk_hthread::valstack_bottom.
| DUK_LOCAL void duk__comp_recursion_decrease | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL void duk__comp_recursion_increase | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL void duk__compact_object_list | ( | duk_heap * | heap, |
| duk_hthread * | thr, | ||
| duk_heaphdr * | start | ||
| ) |
| DUK_LOCAL duk_bool_t duk__compare_fastint | ( | duk_bool_t | retval, |
| duk_int64_t | v1, | ||
| duk_int64_t | v2 | ||
| ) |
Definition at line 83239 of file duktape.c.
References DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, and duk_js_data_compare().
| DUK_LOCAL duk_bool_t duk__compare_number | ( | duk_bool_t | retval, |
| duk_double_t | d1, | ||
| duk_double_t | d2 | ||
| ) |
| 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_EXEC_ALWAYS_INLINE_PERF duk_double_t duk__compute_exp | ( | duk_double_t | d1, |
| duk_double_t | d2 | ||
| ) |
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF duk_double_t duk__compute_mod | ( | duk_double_t | d1, |
| duk_double_t | d2 | ||
| ) |
| DUK_LOCAL void duk__concat_and_join_helper | ( | duk_hthread * | thr, |
| duk_idx_t | count_in, | ||
| duk_bool_t | is_join | ||
| ) |
Definition at line 25599 of file duktape.c.
References count(), DUK_ASSERT, DUK_CTX_ASSERT_VALID, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_RANGE_INVALID_COUNT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_HSTRING_MAX_BYTELEN, duk_memcpy, duk_pop_n(), duk_push_fixed_buffer_nozero(), duk_push_hstring_empty(), duk_replace(), duk_require_hstring(), duk_to_hstring(), DUK_UNLIKELY, and DUK_WO_NORETURN.
Referenced by duk_concat_2(), and duk_decode_string().
| DUK_LOCAL duk_bool_t duk__const_needs_refcount | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | rc | ||
| ) |
Definition at line 71100 of file duktape.c.
References DUK__CONST_MARKER, DUK_DDD, DUK_DDDPRINT, and duk_pop().
| DUK_LOCAL duk_ret_t duk__construct_from_codepoints | ( | duk_hthread * | thr, |
| duk_bool_t | nonbmp | ||
| ) |
| DUK_LOCAL void duk__convert_to_func_template | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL void duk__copy_ispec | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ispec * | src, | ||
| duk_ispec * | dst | ||
| ) |
| DUK_LOCAL void duk__copy_ivalue | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | src, | ||
| duk_ivalue * | dst | ||
| ) |
| DUK_LOCAL double duk__cos | ( | double | x | ) |
| DUK_LOCAL duk_uint32_t duk__count_used_e_keys | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
Definition at line 58170 of file duktape.c.
References DUK_ASSERT, DUK_USE_HOBJECT_ENTRY_MINGROW_ADD, and DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR.
| DUK_LOCAL void duk__create_arguments_object | ( | duk_hthread * | thr, |
| duk_hobject * | func, | ||
| duk_hobject * | varenv, | ||
| duk_idx_t | idx_args | ||
| ) |
| DUK_LOCAL void duk__create_escaped_source | ( | duk_hthread * | thr, |
| int | idx_pattern | ||
| ) |
| DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic | ( | duk_hthread * | thr | ) |
Definition at line 34158 of file duktape.c.
Referenced by duk_bi_date_prototype_get_timezone_offset(), duk_bi_date_prototype_set_time(), and duk_bi_date_prototype_value_of().
| DUK_LOCAL duk_bool_t duk__declvar_helper | ( | duk_hthread * | thr, |
| duk_hobject * | env, | ||
| duk_hstring * | name, | ||
| duk_tval * | val, | ||
| duk_small_uint_t | prop_flags, | ||
| duk_bool_t | is_func_decl | ||
| ) |
Definition at line 85440 of file duktape.c.
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_entry(), DUK_HOBJECT_GET_CLASS_NUMBER, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, duk_push_tval(), DUK_TVAL_INCREF, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_UNDEFINED_UPDREF, DUK_UNREF, duk_hthread::heap, and duk__id_lookup_result::holder.
| DUK_LOCAL duk_ret_t duk__decode_helper | ( | duk_hthread * | thr, |
| duk__decode_context * | dec_ctx | ||
| ) |
| DUK_LOCAL duk_small_int_t duk__decode_hex_escape | ( | const duk_uint8_t * | p, |
| duk_small_int_t | n | ||
| ) |
| DUK_LOCAL void duk__decref_tvals_norz | ( | duk_hthread * | thr, |
| duk_tval * | tv, | ||
| duk_idx_t | count | ||
| ) |
| DUK_LOCAL duk_bool_t duk__defaultvalue_coerce_attempt | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_small_uint_t | func_stridx | ||
| ) |
| DUK_LOCAL duk_bool_t duk__delvar_helper | ( | duk_hthread * | thr, |
| duk_hobject * | env, | ||
| duk_activation * | act, | ||
| duk_hstring * | name | ||
| ) |
Definition at line 33187 of file duktape.c.
References DUK_DOUBLE_NAN.
| DUK_LOCAL duk_ret_t duk__do_compile | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| DUK_LOCAL void duk__dragon4_convert_and_push | ( | duk__numconv_stringify_ctx * | nc_ctx, |
| duk_hthread * | thr, | ||
| 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_ctx_to_double | ( | duk__numconv_stringify_ctx * | nc_ctx, |
| duk_double_t * | x | ||
| ) |
| DUK_LOCAL void duk__dragon4_double_to_ctx | ( | duk__numconv_stringify_ctx * | nc_ctx, |
| duk_double_t | x | ||
| ) |
Definition at line 89544 of file duktape.c.
References duk__dragon4_format_uint32().
| 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 89318 of file duktape.c.
References DUK_DDD, and DUK_DDDPRINT.
| 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 88846 of file duktape.c.
References count(), and DUK__MAX_OUTPUT_DIGITS.
Referenced by duk__dragon4_double_to_ctx().
| DUK_LOCAL void duk__dragon4_generate | ( | duk__numconv_stringify_ctx * | nc_ctx | ) |
| DUK_LOCAL void duk__dragon4_prepare | ( | duk__numconv_stringify_ctx * | nc_ctx | ) |
Definition at line 88880 of file duktape.c.
References DUK__DIGITCHAR, DUK_ASSERT, and duk_memmove.
| DUK_LOCAL void duk__dragon4_scale | ( | duk__numconv_stringify_ctx * | nc_ctx | ) |
| 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_formals | ( | duk_hthread * | thr, |
| duk_uint8_t * | p, | ||
| duk_bufwriter_ctx * | bw_ctx, | ||
| duk_hobject * | func | ||
| ) |
|
static |
| 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_hstring_raw | ( | duk_uint8_t * | p, |
| duk_hstring * | h | ||
| ) |
Definition at line 14462 of file duktape.c.
References DUK_ASSERT, duk_memcpy, duk_push_fixed_buffer_nozero(), and DUK_RAW_READINC_U32_BE.
| 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_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 void duk__emit | ( | duk_compiler_ctx * | comp_ctx, |
| duk_instr_t | ins | ||
| ) |
Definition at line 70165 of file duktape.c.
References duk_compiler_func::bw_code, duk_compiler_ctx::curr_func, DUK_BW_GET_SIZE, and duk_compiler_ctx::thr.
| DUK_LOCAL void duk__emit_1 | ( | duk_json_enc_ctx * | js_ctx, |
| duk_uint_fast8_t | ch | ||
| ) |
| DUK_LOCAL void duk__emit_2 | ( | duk_json_enc_ctx * | js_ctx, |
| duk_uint_fast8_t | ch1, | ||
| duk_uint_fast8_t | ch2 | ||
| ) |
| DUK_LOCAL void duk__emit_a_b | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op_flags, | ||
| duk_regconst_t | a, | ||
| duk_regconst_t | b | ||
| ) |
| DUK_LOCAL void duk__emit_a_b_c | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op_flags, | ||
| duk_regconst_t | a, | ||
| duk_regconst_t | b, | ||
| duk_regconst_t | c | ||
| ) |
Definition at line 70265 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__objlit_load_key().
| DUK_LOCAL void duk__emit_a_bc | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op_flags, | ||
| duk_regconst_t | a, | ||
| duk_regconst_t | bc | ||
| ) |
Definition at line 70567 of file duktape.c.
Referenced by duk__emit_load_int32(), and duk__init_varmap_and_prologue_for_pass2().
| DUK_LOCAL void duk__emit_abc | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op, | ||
| duk_regconst_t | abc | ||
| ) |
| DUK_LOCAL void duk__emit_b_c | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op_flags, | ||
| duk_regconst_t | b, | ||
| duk_regconst_t | c | ||
| ) |
| DUK_LOCAL void duk__emit_bc | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op, | ||
| duk_regconst_t | bc | ||
| ) |
Definition at line 70625 of file duktape.c.
Referenced by duk__parse_func_body(), and duk__parse_stmt().
| DUK_LOCAL void duk__emit_cstring | ( | duk_json_enc_ctx * | js_ctx, |
| const char * | p | ||
| ) |
| DUK_LOCAL duk_uint8_t * duk__emit_esc_auto_fast | ( | duk_json_enc_ctx * | js_ctx, |
| duk_uint_fast32_t | cp, | ||
| duk_uint8_t * | q | ||
| ) |
| DUK_LOCAL void duk__emit_hstring | ( | duk_json_enc_ctx * | js_ctx, |
| duk_hstring * | h | ||
| ) |
| DUK_LOCAL void duk__emit_if_false_skip | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | regconst | ||
| ) |
| DUK_LOCAL void duk__emit_if_true_skip | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | regconst | ||
| ) |
| DUK_LOCAL void duk__emit_invalid | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 70859 of file duktape.c.
Referenced by duk__parse_stmt().
| DUK_LOCAL void duk__emit_jump | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | target_pc | ||
| ) |
Definition at line 70712 of file duktape.c.
References duk__emit_load_int32_raw().
| DUK_LOCAL duk_int_t duk__emit_jump_empty | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 70723 of file duktape.c.
References duk__emit_load_int32(), DUK_ASSERT, and DUK_BC_A_MAX.
| DUK_LOCAL void duk__emit_load_int32 | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | reg, | ||
| duk_int32_t | val | ||
| ) |
Definition at line 70691 of file duktape.c.
References duk__emit_a_bc(), DUK_BC_LDINT_BIAS, DUK_DDD, DUK_DDDPRINT, and DUK_OP_LDINT.
Referenced by duk__emit_jump_empty().
| DUK_LOCAL void duk__emit_load_int32_noshuffle | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | reg, | ||
| duk_int32_t | val | ||
| ) |
| DUK_LOCAL void duk__emit_load_int32_raw | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | reg, | ||
| duk_int32_t | val, | ||
| duk_small_uint_t | op_flags | ||
| ) |
Definition at line 70664 of file duktape.c.
Referenced by duk__emit_jump().
| DUK_LOCAL void duk__emit_op_only | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | op | ||
| ) |
Definition at line 70260 of file duktape.c.
References line().
Referenced by duk__parse_func_body().
| DUK_LOCAL void duk__emit_stridx | ( | duk_json_enc_ctx * | js_ctx, |
| duk_small_uint_t | stridx | ||
| ) |
| 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__err_augment_builtin_create | ( | duk_hthread * | thr, |
| duk_hthread * | thr_callstack, | ||
| const char * | c_filename, | ||
| duk_int_t | c_line, | ||
| duk_hobject * | obj, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 49453 of file duktape.c.
Referenced by duk_err_augment_error_create().
| DUK_LOCAL void duk__err_augment_user | ( | duk_hthread * | thr, |
| duk_small_uint_t | stridx_cb | ||
| ) |
Definition at line 49035 of file duktape.c.
References duk_heap::augmenting_error, duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_STRIDX_VALID, DUK_ASSERT_VALSTACK_SPACE, DUK_BIDX_DUKTAPE, DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_hobject_find_entry_tval_ptr_stridx(), duk_insert(), duk_pcall_method(), duk_push_tval(), duk_push_undefined(), DUK_UNREF, and duk_hthread::heap.
| DUK_LOCAL duk_ret_t duk__error_getter_helper | ( | duk_hthread * | thr, |
| duk_small_int_t | output_type | ||
| ) |
Definition at line 35899 of file duktape.c.
References DUK__OUTPUT_TYPE_FILENAME, DUK__OUTPUT_TYPE_LINENUMBER, DUK__OUTPUT_TYPE_TRACEBACK, 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_double_to_int_t(), duk_double_to_uint_t(), DUK_FLOOR, DUK_FMOD, duk_get_hobject(), duk_get_hstring_notsymbol(), duk_get_prop_index(), duk_get_prop_stridx_short, duk_get_string(), duk_get_string_notsymbol(), duk_get_top_index(), duk_get_type(), DUK_HOBJECT_HAS_NATFUNC, duk_hobject_pc2line_query(), DUK_HSTRING_GET_DATA, DUK_HTHREAD_STRING_EMPTY_STRING, duk_is_string_notsymbol(), duk_pop(), duk_pop_2(), duk_pop_3(), duk_push_hstring_stridx(), duk_push_int(), duk_push_sprintf(), duk_push_this(), duk_push_uint(), 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_m1(), DUK_TYPE_LIGHTFUNC, DUK_TYPE_OBJECT, DUK_TYPE_STRING, DUK_USE_TRACEBACK_DEPTH, duk_xget_owndataprop_stridx_short, and line().
Referenced by duk_bi_error_prototype_linenumber_getter().
| DUK_LOCAL duk_ret_t duk__error_setter_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | stridx_key | ||
| ) |
| DUK_LOCAL duk_bool_t duk__executor_handle_call | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_idx_t | nargs, | ||
| duk_small_uint_t | call_flags | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF DUK_COLD duk_small_uint_t duk__executor_interrupt | ( | duk_hthread * | thr | ) |
Definition at line 79121 of file duktape.c.
References DUK__INT_RESTART, DUK_D, and DUK_DPRINT.
| DUK_LOCAL double duk__exp | ( | double | x | ) |
| DUK_LOCAL void duk__expr | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
| DUK_LOCAL duk_bool_t duk__expr_is_empty | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL duk_small_uint_t duk__expr_lbp | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL void duk__expr_led | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | left, | ||
| duk_ivalue * | res | ||
| ) |
Definition at line 72923 of file duktape.c.
References duk__ivalue_plain_fromstack().
| DUK_LOCAL void duk__expr_nud | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL void duk__expr_toforcedreg | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags, | ||
| duk_regconst_t | forced_reg | ||
| ) |
| DUK_LOCAL void duk__expr_toplain | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
Definition at line 74055 of file duktape.c.
References DUK_ASSERT.
| DUK_LOCAL void duk__expr_toplain_ignore | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__expr_toregconst | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
| DUK_LOCAL void duk__exprtop | ( | duk_compiler_ctx * | ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
Definition at line 73994 of file duktape.c.
Referenced by duk__exprtop_toregconst(), and duk__parse_var_decl().
| DUK_LOCAL void duk__exprtop_toforcedreg | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags, | ||
| duk_regconst_t | forced_reg | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__exprtop_toreg | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__exprtop_toregconst | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | rbp_flags | ||
| ) |
Definition at line 74086 of file duktape.c.
References duk__exprtop(), and duk__ivalue_toreg().
| DUK_LOCAL void duk__fill_lexer_buffer | ( | duk_lexer_ctx * | lex_ctx, |
| duk_small_uint_t | start_offset_bytes | ||
| ) |
Definition at line 85885 of file duktape.c.
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.
| DUK_LOCAL duk_ret_t duk__finalize_helper | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
Definition at line 51825 of file duktape.c.
References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_dup_m2(), duk_get_prop_stridx_short, DUK_STRIDX_INT_FINALIZER, and DUK_UNREF.
| DUK_LOCAL double duk__floor | ( | double | x | ) |
| DUK_LOCAL double duk__fmin_fixed | ( | double | x, |
| double | y | ||
| ) |
Definition at line 40653 of file duktape.c.
References DUK_DOUBLE_NAN.
| 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 50482 of file duktape.c.
References DUK_DDD, DUK_DDDPRINT, and DUK_HEAPHDR_GET_NEXT.
| DUK_LOCAL DUK_ALWAYS_INLINE duk_bool_t duk__get_boolean_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_bool_t | def_value | ||
| ) |
Definition at line 20212 of file duktape.c.
Referenced by duk_require_boolean().
| DUK_LOCAL void * duk__get_buffer_helper | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| void * | def_ptr, | ||
| duk_size_t | def_size, | ||
| duk_bool_t | throw_flag | ||
| ) |
Definition at line 20635 of file duktape.c.
Referenced by duk_get_buffer_data_raw().
| DUK_LOCAL duk_hbufobj * duk__get_bufobj_this | ( | duk_hthread * | thr | ) |
| DUK_LOCAL duk_int_t duk__get_current_pc | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL duk_uint32_t duk__get_default_h_size | ( | duk_uint32_t | e_size | ) |
| DUK_LOCAL duk_hobject * duk__get_hobject_promote_mask_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | type_mask | ||
| ) |
Definition at line 21160 of file duktape.c.
Referenced by duk_require_hobject_promote_mask().
| 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 84775 of file duktape.c.
Referenced by duk__declvar_helper().
| DUK_LOCAL duk_compiler_instr * duk__get_instr_ptr | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | pc | ||
| ) |
| DUK_LOCAL duk_uint32_t duk__get_min_grow_a | ( | duk_uint32_t | a_size | ) |
| DUK_LOCAL duk_uint32_t duk__get_min_grow_e | ( | duk_uint32_t | e_size | ) |
| DUK_LOCAL DUK_ALWAYS_INLINE duk_double_t duk__get_number_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_double_t | def_value | ||
| ) |
| DUK_LOCAL 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 59769 of file duktape.c.
References duk_propdesc::a_idx, duk_hbufobj::buf, DUK__NO_ARRAY_INDEX, DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_SET_GARBAGE, DUK_ASSERT_VALSTACK_SPACE, DUK_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, DUK_GETDESC_FLAG_PUSH_VALUE, DUK_HARRAY_ASSERT_VALID, DUK_HARRAY_LENGTH_WRITABLE, DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFOBJ_ASSERT_VALID, DUK_HBUFOBJ_HAS_VIRTUAL_INDICES, duk_hbufobj_push_validated_read(), DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_CLASS_ARRAYBUFFER, 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_entry(), DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_GET_CLASS_NUMBER, duk_hobject_get_internal_value_string(), DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ, DUK_HOBJECT_HAS_VIRTUAL_PROPERTIES, DUK_HOBJECT_IS_BUFOBJ, DUK_HSTRING_GET_CHARLEN, 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_tval(), duk_push_uint(), duk_push_undefined(), DUK_STATS_INC, duk_substring(), DUK_TVAL_IS_UNUSED, DUK_UNLIKELY, duk_propdesc::e_idx, duk_propdesc::flags, duk_propdesc::get, duk_propdesc::h_idx, duk_hthread::heap, duk_hbufobj::length, duk_harray::length, duk_hbufobj::offset, duk_propdesc::set, and duk_hbufobj::shift.
Referenced by duk__get_propdesc(), duk_hobject_define_property_helper(), and duk_hobject_putprop().
| DUK_LOCAL duk_ret_t duk__get_part_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | flags_and_idx | ||
| ) |
Definition at line 33822 of file duktape.c.
Referenced by duk_bi_date_prototype_get_timezone_offset().
| DUK_LOCAL void * duk__get_pointer_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| void * | def_value | ||
| ) |
| DUK_LOCAL duk_bool_t duk__get_propdesc | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_propdesc * | out_desc, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 60137 of file duktape.c.
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_STATS_INC, DUK_STR_PROTOTYPE_CHAIN_LIMIT, DUK_UNLIKELY, DUK_WO_NORETURN, and duk_hthread::heap.
| DUK_LOCAL duk_small_uint_t duk__get_symbol_type | ( | duk_hstring * | h | ) |
Definition at line 18753 of file duktape.c.
References DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, and DUK_HSTRING_HAS_SYMBOL.
| DUK_LOCAL const char * duk__get_symbol_type_string | ( | duk_hstring * | h | ) |
| DUK_LOCAL duk_heaphdr * duk__get_tagged_heaphdr_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | tag | ||
| ) |
Definition at line 20817 of file duktape.c.
Referenced by duk_require_hcompfunc(), duk_require_hnatfunc(), duk_require_hstring(), and duk_require_hthread().
| DUK_LOCAL duk__decode_context * duk__get_textdecoder_context | ( | duk_hthread * | thr | ) |
| DUK_LOCAL void duk__get_this_regexp | ( | duk_hthread * | thr | ) |
Definition at line 42466 of file duktape.c.
Referenced by duk_bi_regexp_prototype_test().
| DUK_LOCAL duk_regconst_t duk__getconst | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 71056 of file duktape.c.
References duk_compiler_ctx::curr_func, duk_compiler_func::temp_max, and duk_compiler_func::temp_next.
Referenced by duk__init_varmap_and_prologue_for_pass2().
| 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__getid_open_decl_env_regs | ( | duk_hthread * | thr, |
| duk_hstring * | name, | ||
| duk_hdecenv * | env, | ||
| duk__id_lookup_result * | out | ||
| ) |
| DUK_LOCAL duk_bool_t duk__getprop_fastpath_bufobj_tval | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_tval * | tv_key | ||
| ) |
| DUK_LOCAL duk_tval * duk__getprop_shallow_fastpath_array_tval | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_tval * | tv_key | ||
| ) |
Definition at line 60216 of file duktape.c.
References duk__tval_fastint_to_arr_idx(), duk__tval_number_to_arr_idx(), DUK_DDD, DUK_DDDPRINT, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ, DUK_HOBJECT_IS_BUFOBJ, DUK_HOBJECT_IS_PROXY, DUK_TVAL_IS_DOUBLE, DUK_TVAL_IS_FASTINT, and DUK_UNREF.
| DUK_LOCAL duk_heaphdr * duk__getrequire_bufobj_this | ( | duk_hthread * | thr, |
| duk_small_uint_t | flags | ||
| ) |
Definition at line 27917 of file duktape.c.
Referenced by duk__require_bufobj_value().
| 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__grow_props_for_array_item | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_uint32_t | highest_arr_idx | ||
| ) |
Definition at line 59070 of file duktape.c.
References DUK_UINT16_MAX.
| DUK_LOCAL void duk__grow_props_for_new_entry_item | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
| DUK_LOCAL void duk__handle_bound_chain_for_call | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_bool_t | is_constructor_call | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF void duk__handle_break_or_continue | ( | duk_hthread * | thr, |
| duk_uint_t | label_id, | ||
| duk_small_uint_t | lj_type | ||
| ) |
| DUK_LOCAL duk_int_t duk__handle_call_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_small_uint_t | call_flags | ||
| ) |
Definition at line 68014 of file duktape.c.
References duk_heap::call_recursion_depth, duk_heap::call_recursion_limit, duk_hthread::callstack_curr, duk_hthread::callstack_preventcount, duk_hthread::callstack_top, duk_activation::cat, duk_activation::curr_pc, duk_heap::curr_thread, duk__call_c_recursion_limit_check(), duk__call_env_setup(), DUK__CALL_HANDLING_REQUIRE_STACK, duk__call_setup_act_attempt_tailcall(), duk__call_setup_act_not_tailcall(), duk__call_thread_state_update(), duk__resolve_target_fastpath_check(), duk__resolve_target_func_and_this_binding(), DUK_ACT_FLAG_PREVENT_YIELD, DUK_ACT_GET_FUNC, DUK_ASSERT, duk_call_construct_postprocess(), DUK_CALL_FLAG_ALLOW_ECMATOECMA, DUK_CALL_FLAG_CONSTRUCT, DUK_CALL_FLAG_CONSTRUCT_PROXY, DUK_CALL_FLAG_TAILCALL, DUK_CAT_GET_TYPE, DUK_CAT_TYPE_LABEL, DUK_CTX_ASSERT_VALID, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_error_throw_from_negative_rc(), DUK_ERROR_TYPE, duk_get_top(), DUK_HCOMPFUNC_GET_CODE_BASE, DUK_HEAP_SWITCH_THREAD, DUK_HOBJECT_HAS_BOUNDFUNC, DUK_HOBJECT_HAS_COMPFUNC, DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_IS_NATFUNC, duk_hthread_activation_unwind_norz(), DUK_HTHREAD_STATE_INACTIVE, DUK_HTHREAD_STATE_RUNNING, duk_hthread_sync_and_null_currpc(), duk_is_valid_index(), duk_js_execute_bytecode(), DUK_LIKELY, DUK_REFZERO_CHECK_FAST, duk_require_stack(), duk_set_top_and_wipe(), duk_set_top_unsafe(), DUK_STATS_INC, DUK_STR_INVALID_CFUNC_RC, DUK_TVAL_CHKFAST_INPLACE_FAST, DUK_TVAL_GET_LIGHTFUNC_FUNCPTR, DUK_TVAL_IS_LIGHTFUNC, DUK_TVAL_IS_UNDEFINED, DUK_TVAL_SET_TVAL_UPDREF, duk_valstack_grow_check_throw(), DUK_WO_NORETURN, duk_activation::flags, duk_hthread::heap, duk_activation::parent, duk_catcher::parent, duk_hthread::ptr_curr_pc, duk_activation::reserve_byteoff, duk_hthread::state, duk_activation::tv_func, duk_hthread::valstack, duk_hthread::valstack_alloc_end, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.
| DUK_LOCAL void duk__handle_catch_part1 | ( | duk_hthread * | thr, |
| duk_tval * | tv_val_unstable, | ||
| duk_small_uint_t | lj_type, | ||
| volatile duk_bool_t * | out_delayed_catch_setup | ||
| ) |
| DUK_LOCAL void duk__handle_catch_part2 | ( | duk_hthread * | thr | ) |
Definition at line 78087 of file duktape.c.
References DUK_DDD, and DUK_DDDPRINT.
| DUK_LOCAL void duk__handle_createargs_for_call | ( | duk_hthread * | thr, |
| duk_hobject * | func, | ||
| duk_hobject * | env, | ||
| duk_idx_t | idx_args | ||
| ) |
| DUK_LOCAL void duk__handle_executor_error | ( | duk_heap * | heap, |
| duk_activation * | entry_act, | ||
| duk_int_t | entry_call_recursion_depth, | ||
| duk_jmpbuf * | entry_jmpbuf_ptr, | ||
| volatile duk_bool_t * | out_delayed_catch_setup | ||
| ) |
Definition at line 80032 of file duktape.c.
References duk_heap::call_recursion_depth, duk_heap::curr_thread, duk__handle_longjmp(), DUK_ASSERT, duk_ljstate::jmpbuf_ptr, duk_heap::lj, duk_heap::pf_prevent_count, and duk_hthread::ptr_curr_pc.
| DUK_LOCAL void duk__handle_finally | ( | duk_hthread * | thr, |
| duk_tval * | tv_val_unstable, | ||
| duk_small_uint_t | lj_type | ||
| ) |
| DUK_LOCAL void duk__handle_label | ( | duk_hthread * | thr, |
| duk_small_uint_t | lj_type | ||
| ) |
| DUK_LOCAL duk_small_uint_t duk__handle_longjmp | ( | duk_hthread * | thr, |
| duk_activation * | entry_act, | ||
| volatile duk_bool_t * | out_delayed_catch_setup | ||
| ) |
Definition at line 78256 of file duktape.c.
Referenced by duk__handle_executor_error().
| DUK_LOCAL void duk__handle_oldenv_for_call | ( | duk_hthread * | thr, |
| duk_hobject * | func, | ||
| duk_activation * | act | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF duk_instr_t * duk__handle_op_endcatch | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF duk_small_uint_t duk__handle_op_endfin | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins, | ||
| duk_activation * | entry_act | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF duk_instr_t * duk__handle_op_endtry | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF void duk__handle_op_initenum | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF void duk__handle_op_initset_initget | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins | ||
| ) |
Definition at line 79371 of file duktape.c.
References DUK_ASSERT, duk_hthread::interrupt_counter, and duk_hthread::interrupt_init.
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF duk_small_uint_t duk__handle_op_nextenum | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins | ||
| ) |
| DUK_LOCAL DUK_EXEC_NOINLINE_PERF void duk__handle_op_trycatch | ( | duk_hthread * | thr, |
| duk_uint_fast32_t | ins, | ||
| duk_instr_t * | curr_pc | ||
| ) |
| DUK_LOCAL void duk__handle_proxy_for_call | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_hproxy * | h_proxy, | ||
| duk_small_uint_t * | call_flags | ||
| ) |
| DUK_LOCAL duk_bool_t duk__handle_put_array_length | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
Definition at line 61377 of file duktape.c.
Referenced by duk_hobject_putprop().
| DUK_LOCAL duk_bool_t duk__handle_put_array_length_smaller | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_uint32_t | old_len, | ||
| duk_uint32_t | new_len, | ||
| duk_bool_t | force_flag, | ||
| duk_uint32_t * | out_result_len | ||
| ) |
Definition at line 61184 of file duktape.c.
Referenced by duk_hobject_define_property_helper().
| DUK_LOCAL duk_small_uint_t duk__handle_return | ( | duk_hthread * | thr, |
| duk_activation * | entry_act | ||
| ) |
| DUK_LOCAL void duk__handle_safe_call_error | ( | duk_hthread * | thr, |
| duk_activation * | entry_act, | ||
| duk_hthread * | entry_curr_thread, | ||
| duk_uint_fast8_t | entry_thread_state, | ||
| duk_idx_t | idx_retbase, | ||
| duk_idx_t | num_stack_rets, | ||
| duk_size_t | entry_valstack_bottom_byteoff, | ||
| duk_jmpbuf * | old_jmpbuf_ptr | ||
| ) |
| DUK_LOCAL void duk__handle_safe_call_inner | ( | duk_hthread * | thr, |
| duk_safe_call_function | func, | ||
| void * | udata, | ||
| duk_hthread * | entry_curr_thread, | ||
| duk_uint_fast8_t | entry_thread_state, | ||
| duk_idx_t | idx_retbase, | ||
| duk_idx_t | num_stack_rets | ||
| ) |
| DUK_LOCAL void duk__handle_safe_call_shared_unwind | ( | 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_instr_t ** | entry_ptr_curr_pc | ||
| ) |
| DUK_LOCAL duk_bool_t duk__handle_specialfuncs_for_call | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_hobject * | func, | ||
| duk_small_uint_t * | call_flags, | ||
| duk_bool_t | first | ||
| ) |
| DUK_LOCAL void duk__handle_temproot | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
Definition at line 52469 of file duktape.c.
References duk__handle_temproot(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_HEAPHDR_HAS_TEMPROOT, and DUK_LOCAL.
Referenced by duk__handle_temproot().
| DUK_LOCAL void duk__handle_yield | ( | duk_hthread * | thr, |
| duk_hthread * | resumer, | ||
| duk_tval * | tv_val_unstable | ||
| ) |
| DUK_LOCAL DUK__RZ_INLINE void duk__hbuffer_refzero_helper | ( | duk_hthread * | thr, |
| duk_hbuffer * | h | ||
| ) |
| DUK_LOCAL duk_hbuffer * duk__hbufobj_fixed_from_argvalue | ( | duk_hthread * | thr | ) |
Definition at line 28314 of file duktape.c.
Referenced by duk_bi_uint8array_plainof().
| DUK_LOCAL duk_hbufobj * duk__hbufobj_promote_this | ( | duk_hthread * | thr | ) |
| DUK_LOCAL duk_size_t duk__heap_free_activation_freelist | ( | duk_heap * | heap | ) |
Definition at line 50394 of file duktape.c.
References duk_heap::activation_free, and duk_activation::parent.
| DUK_LOCAL duk_size_t duk__heap_free_catcher_freelist | ( | duk_heap * | heap | ) |
| DUK_LOCAL DUK_NOINLINE_PERF DUK_COLD void * duk__heap_mem_alloc_slowpath | ( | duk_heap * | heap, |
| duk_size_t | size | ||
| ) |
| DUK_LOCAL DUK_NOINLINE_PERF DUK_COLD void * duk__heap_mem_realloc_indirect_slowpath | ( | duk_heap * | heap, |
| duk_mem_getptr | cb, | ||
| void * | ud, | ||
| duk_size_t | newsize | ||
| ) |
| DUK_LOCAL DUK_NOINLINE_PERF DUK_COLD void * duk__heap_mem_realloc_slowpath | ( | duk_heap * | heap, |
| void * | ptr, | ||
| duk_size_t | newsize | ||
| ) |
| DUK_LOCAL DUK__RZ_INLINE void duk__heaphdr_refzero_helper | ( | duk_hthread * | thr, |
| duk_heaphdr * | h, | ||
| duk_bool_t | skip_free_pending | ||
| ) |
Definition at line 54768 of file duktape.c.
Referenced by duk_hobject_refzero_norz().
| DUK_LOCAL duk_codepoint_t duk__hexval | ( | duk_codepoint_t | x | ) |
Definition at line 86333 of file duktape.c.
References duk_lexer_point::line, duk_lexer_codepoint::line, duk_lexer_point::offset, duk_lexer_codepoint::offset, and duk_lexer_ctx::window.
| DUK_LOCAL duk_codepoint_t duk__hexval_validate | ( | duk_codepoint_t | x | ) |
Definition at line 86316 of file duktape.c.
References duk_lexer_ctx::buf, DUK_ASSERT, duk_memzero, duk_lexer_ctx::input, duk_lexer_ctx::thr, and duk_lexer_ctx::window.
| DUK_LOCAL duk_int_t duk__hobject_alloc_entry_checked | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key | ||
| ) |
Definition at line 59406 of file duktape.c.
Referenced by duk_hobject_define_property_helper(), and duk_hobject_putprop().
| DUK_LOCAL void * duk__hobject_alloc_init | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags, | ||
| duk_size_t | size | ||
| ) |
Definition at line 56524 of file duktape.c.
Referenced by duk_hthread_alloc_unchecked().
| DUK_LOCAL duk_hobject * duk__hobject_get_entry_object_stridx | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_small_uint_t | stridx | ||
| ) |
Definition at line 59515 of file duktape.c.
Referenced by duk__lookup_arguments_map().
| 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 DUK__RZ_INLINE void duk__hobject_refzero_helper | ( | duk_hthread * | thr, |
| duk_hobject * | h, | ||
| duk_bool_t | skip_free_pending | ||
| ) |
| DUK_LOCAL DUK_COLD duk_size_t duk__hstring_get_charlen_slowpath | ( | duk_hstring * | h | ) |
Definition at line 64369 of file duktape.c.
References DUK_HSTRING_SET_ASCII.
| DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments | ( | duk_compiler_ctx * | comp_ctx, |
| duk_hstring * | h | ||
| ) |
Definition at line 69477 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk__parse_func_body().
| 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 69483 of file duktape.c.
Referenced by duk__parse_var_decl().
| DUK_LOCAL DUK__RZ_INLINE void duk__hstring_refzero_helper | ( | duk_hthread * | thr, |
| duk_hstring * | h | ||
| ) |
| DUK_LOCAL duk__sort_key_t duk__hstring_sort_key | ( | duk_hstring * | x | ) |
| DUK_LOCAL DUK_NOINLINE duk_activation * duk__hthread_activation_alloc_slow | ( | duk_hthread * | thr | ) |
Definition at line 65631 of file duktape.c.
Referenced by duk__activation_unwind_nofree_norz(), and duk_hthread_activation_free().
| DUK_LOCAL DUK_NOINLINE duk_catcher * duk__hthread_catcher_alloc_slow | ( | duk_hthread * | thr | ) |
Definition at line 65586 of file duktape.c.
References duk_activation::cat, and DUK_ASSERT.
Referenced by duk_hthread_catcher_free().
| DUK_LOCAL void duk__inc_data_inner_refcounts | ( | duk_hthread * | thr, |
| duk_hcompfunc * | f | ||
| ) |
| DUK_LOCAL void duk__init_func_valstack_slots | ( | duk_compiler_ctx * | comp_ctx | ) |
| 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 void duk__init_lexer_window | ( | duk_lexer_ctx * | lex_ctx | ) |
| DUK_LOCAL void duk__init_object_parts | ( | duk_heap * | heap, |
| duk_uint_t | hobject_flags, | ||
| duk_hobject * | obj | ||
| ) |
Definition at line 56496 of file duktape.c.
Referenced by duk_hobject_alloc_unchecked().
| DUK_LOCAL void duk__init_varmap_and_prologue_for_pass2 | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t * | out_stmt_value_reg | ||
| ) |
Definition at line 75989 of file duktape.c.
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_BC_REGCONST, 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_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_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_known_hstring(), 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_TVAL_IS_FASTINT, DUK_TVAL_IS_NULL, DUK_WO_NORETURN, 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, 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_LOCAL void duk__initbuffer | ( | duk_lexer_ctx * | lex_ctx | ) |
| 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_cp | ( | duk_re_matcher_ctx * | re_ctx, |
| const duk_uint8_t ** | sp | ||
| ) |
| DUK_LOCAL duk_codepoint_t duk__inp_get_prev_cp | ( | duk_re_matcher_ctx * | re_ctx, |
| const duk_uint8_t * | sp | ||
| ) |
| 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__insert_jump_entry | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | jump_pc | ||
| ) |
| 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 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 90635 of file duktape.c.
References duk_re_compiler_ctx::bw, duk__append_u32(), DUK_ASSERT, DUK_BW_WRITE_ENSURE_U8, and duk_re_compiler_ctx::thr.
| DUK_LOCAL duk_uint32_t duk__insert_u32 | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_uint32_t | offset, | ||
| duk_uint32_t | x | ||
| ) |
| DUK_LOCAL void duk__inspect_multiple_uint | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| duk_int_t * | vals | ||
| ) |
Definition at line 17296 of file duktape.c.
Referenced by duk_inspect_value().
| DUK_LOCAL duk_hstring * duk__internbuffer | ( | duk_lexer_ctx * | lex_ctx, |
| duk_idx_t | valstack_idx | ||
| ) |
Definition at line 86266 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_LOCAL duk_bool_t duk__is_hex_digit | ( | duk_codepoint_t | x | ) |
| DUK_LOCAL void duk__ispec_toforcedreg | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ispec * | x, | ||
| duk_regconst_t | forced_reg | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__ispec_toregconst_raw | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ispec * | x, | ||
| duk_regconst_t | forced_reg, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL void duk__ivalue_plain_fromstack | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
Definition at line 70990 of file duktape.c.
Referenced by duk__expr_led().
| DUK_LOCAL void duk__ivalue_regconst | ( | duk_ivalue * | x, |
| duk_regconst_t | regconst | ||
| ) |
Definition at line 70984 of file duktape.c.
Referenced by duk__ivalue_toplain().
| DUK_LOCAL void duk__ivalue_toforcedreg | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x, | ||
| duk_int_t | forced_reg | ||
| ) |
Definition at line 71586 of file duktape.c.
Referenced by duk__parse_var_decl().
| DUK_LOCAL void duk__ivalue_toplain | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
Definition at line 71518 of file duktape.c.
References duk__ivalue_regconst().
| DUK_LOCAL void duk__ivalue_toplain_ignore | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
| DUK_LOCAL void duk__ivalue_toplain_raw | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x, | ||
| duk_regconst_t | forced_reg | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__ivalue_toreg | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
Definition at line 71576 of file duktape.c.
Referenced by duk__exprtop_toregconst(), and duk__parse_var_decl().
| DUK_LOCAL duk_regconst_t duk__ivalue_toregconst | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
| DUK_LOCAL duk_regconst_t duk__ivalue_toregconst_raw | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x, | ||
| duk_regconst_t | forced_reg, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 71541 of file duktape.c.
Referenced by duk__lookup_active_register_binding().
| DUK_LOCAL duk_regconst_t duk__ivalue_totempconst | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
| DUK_LOCAL void duk__ivalue_var_fromstack | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x | ||
| ) |
| DUK_LOCAL_DECL void duk__ivalue_var_hstring | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | x, | ||
| duk_hstring * | h | ||
| ) |
Definition at line 71002 of file duktape.c.
References DUK_ISPEC_REGCONST, DUK_IVAL_PLAIN, duk_ispec::t, duk_ivalue::t, and duk_ivalue::x1.
| DUK_LOCAL duk_ret_t duk__js_compile_raw | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| DUK_LOCAL duk_bool_t duk__js_equals_number | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
| DUK_LOCAL DUK_NOINLINE DUK_HOT void duk__js_execute_bytecode_inner | ( | duk_hthread * | entry_thread, |
| duk_activation * | entry_act | ||
| ) |
Definition at line 80221 of file duktape.c.
References duk_heap::curr_thread, DUK_ASSERT, DUK_ERROR_TYPE, and DUK_WO_NORETURN.
| DUK_LOCAL duk_bool_t duk__js_instanceof_helper | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y, | ||
| duk_bool_t | skip_sym_check | ||
| ) |
| DUK_LOCAL duk_bool_t duk__js_samevalue_number | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
Definition at line 82909 of file duktape.c.
References DUK_ASSERT, duk_double_equals(), DUK_FP_NAN, DUK_FP_ZERO, and DUK_FPCLASSIFY.
| DUK_LOCAL void duk__json_dec_array | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_buffer | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL duk_uint_fast32_t duk__json_dec_decode_hex_escape | ( | duk_json_dec_ctx * | js_ctx, |
| duk_small_uint_t | n | ||
| ) |
Definition at line 37610 of file duktape.c.
References DUK_ASSERT, duk_json_dec_ctx::p, and duk_json_dec_ctx::p_end.
| DUK_LOCAL void duk__json_dec_eat_white | ( | duk_json_dec_ctx * | js_ctx | ) |
Definition at line 37562 of file duktape.c.
References DUK_ERR_SYNTAX_ERROR, DUK_ERROR_FMT1, DUK_STR_FMT_INVALID_JSON, DUK_WO_NORETURN, duk_json_dec_ctx::p, duk_json_dec_ctx::p_start, and duk_json_dec_ctx::thr.
| DUK_LOCAL duk_uint8_t duk__json_dec_get | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL duk_uint8_t duk__json_dec_get_nonwhite | ( | duk_json_dec_ctx * | js_ctx | ) |
Definition at line 37604 of file duktape.c.
References DUK_ASSERT, duk_json_dec_ctx::p, and duk_json_dec_ctx::p_end.
| DUK_LOCAL void duk__json_dec_number | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_objarr_entry | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_objarr_exit | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_object | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL duk_uint8_t duk__json_dec_peek | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_plain_string | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_pointer | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_req_stridx | ( | duk_json_dec_ctx * | js_ctx, |
| duk_small_uint_t | stridx | ||
| ) |
| DUK_LOCAL void duk__json_dec_reviver_walk | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_string | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL duk_small_int_t duk__json_dec_string_escape | ( | duk_json_dec_ctx * | js_ctx, |
| duk_uint8_t ** | ext_p | ||
| ) |
| DUK_LOCAL void duk__json_dec_syntax_error | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_dec_value | ( | duk_json_dec_ctx * | js_ctx | ) |
| DUK_LOCAL duk_bool_t duk__json_enc_allow_into_proplist | ( | duk_tval * | tv | ) |
| DUK_LOCAL void duk__json_enc_array | ( | duk_json_enc_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_enc_buffer_data | ( | duk_json_enc_ctx * | js_ctx, |
| duk_uint8_t * | buf_data, | ||
| duk_size_t | buf_len | ||
| ) |
Definition at line 38865 of file duktape.c.
References duk_lc_digits.
| DUK_LOCAL duk_uint8_t * duk__json_enc_buffer_data_hex | ( | const duk_uint8_t * | src, |
| duk_size_t | src_len, | ||
| duk_uint8_t * | dst | ||
| ) |
| DUK_LOCAL void duk__json_enc_buffer_jx_jc | ( | duk_json_enc_ctx * | js_ctx, |
| duk_hbuffer * | h | ||
| ) |
| DUK_LOCAL void duk__json_enc_bufobj | ( | duk_json_enc_ctx * | js_ctx, |
| duk_hbufobj * | h_bufobj | ||
| ) |
| DUK_LOCAL void duk__json_enc_double | ( | duk_json_enc_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_enc_fastint_tval | ( | duk_json_enc_ctx * | js_ctx, |
| duk_tval * | tv | ||
| ) |
| DUK_LOCAL void duk__json_enc_key_autoquote | ( | duk_json_enc_ctx * | js_ctx, |
| duk_hstring * | k | ||
| ) |
Definition at line 38514 of file duktape.c.
References duk_lc_digits.
| DUK_LOCAL void duk__json_enc_newline_indent | ( | duk_json_enc_ctx * | js_ctx, |
| duk_uint_t | depth | ||
| ) |
Definition at line 39041 of file duktape.c.
References DUK__EMIT_1, DUK__EMIT_HSTR, DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, and duk_json_enc_ctx::h_gap.
| DUK_LOCAL void duk__json_enc_objarr_entry | ( | duk_json_enc_ctx * | js_ctx, |
| duk_idx_t * | entry_top | ||
| ) |
| DUK_LOCAL void duk__json_enc_objarr_exit | ( | duk_json_enc_ctx * | js_ctx, |
| duk_idx_t * | entry_top | ||
| ) |
Definition at line 39150 of file duktape.c.
References DUK_ERROR_RANGE, DUK_STR_ENC_RECLIMIT, and DUK_WO_NORETURN.
| DUK_LOCAL void duk__json_enc_object | ( | duk_json_enc_ctx * | js_ctx | ) |
| DUK_LOCAL void duk__json_enc_pointer | ( | duk_json_enc_ctx * | js_ctx, |
| void * | ptr | ||
| ) |
| DUK_LOCAL void duk__json_enc_quote_string | ( | duk_json_enc_ctx * | js_ctx, |
| duk_hstring * | h_str | ||
| ) |
| DUK_LOCAL duk_bool_t duk__json_enc_value | ( | duk_json_enc_ctx * | js_ctx, |
| duk_idx_t | idx_holder | ||
| ) |
| DUK_LOCAL duk_bool_t duk__key_is_plain_buf_ownprop | ( | duk_hthread * | thr, |
| duk_hbuffer * | buf, | ||
| duk_hstring * | key, | ||
| duk_uint32_t | arr_idx | ||
| ) |
| DUK_LOCAL duk_heaphdr * duk__known_heaphdr | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21336 of file duktape.c.
Referenced by duk_known_hbuffer(), duk_known_hcompfunc(), duk_known_hnatfunc(), and duk_set_length().
| DUK_LOCAL duk_codepoint_t duk__lexer_parse_escape | ( | duk_lexer_ctx * | lex_ctx, |
| duk_bool_t | allow_es6 | ||
| ) |
Definition at line 86354 of file duktape.c.
References duk_hex_dectab, and DUK_LIKELY.
Referenced by duk_lexer_parse_js_input_element().
| DUK_LOCAL duk_codepoint_t duk__lexer_parse_legacy_octal | ( | duk_lexer_ctx * | lex_ctx, |
| duk_small_uint_t * | out_adv, | ||
| duk_bool_t | reject_annex_b | ||
| ) |
| DUK_LOCAL void duk__lexer_parse_string_literal | ( | duk_lexer_ctx * | lex_ctx, |
| duk_token * | out_token, | ||
| duk_small_int_t | quote, | ||
| duk_bool_t | strict_mode | ||
| ) |
Definition at line 86514 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_LOCAL void duk__lexer_skip_to_endofline | ( | duk_lexer_ctx * | lex_ctx | ) |
Definition at line 86655 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_LOCAL const duk_uint8_t * duk__load_buffer_raw | ( | duk_hthread * | thr, |
| const duk_uint8_t * | p | ||
| ) |
Definition at line 14450 of file duktape.c.
References duk_push_lstring(), and DUK_RAW_READINC_U32_BE.
Referenced by duk__load_func().
|
static |
Definition at line 14799 of file duktape.c.
References duk_hthread::builtins, DUK__ASSERT_LEFT, duk__load_buffer_raw(), duk__load_func(), duk__load_string_raw(), DUK__NO_FORMALS, DUK__SER_NUMBER, DUK__SER_STRING, DUK_ASSERT, DUK_BIDX_FUNCTION_PROTOTYPE, DUK_BIDX_GLOBAL_ENV, duk_compact_m1(), DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_dup(), duk_dup_m2(), duk_get_length(), duk_get_top(), duk_get_tval(), DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_INCREF, DUK_HCOMPFUNC_GET_BYTECODE, DUK_HCOMPFUNC_GET_DATA, DUK_HCOMPFUNC_GET_FUNCS, DUK_HCOMPFUNC_SET_BYTECODE, DUK_HCOMPFUNC_SET_DATA, DUK_HCOMPFUNC_SET_FUNCS, DUK_HCOMPFUNC_SET_LEXENV, DUK_HCOMPFUNC_SET_VARENV, duk_hdecenv_alloc(), DUK_HDECENV_ASSERT_VALID, DUK_HEAPHDR_GET_TYPE, DUK_HEAPHDR_SET_FLAGS, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_DECENV, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_BOUNDFUNC, DUK_HOBJECT_HAS_COMPFUNC, DUK_HOBJECT_HAS_CONSTRUCTABLE, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ, DUK_HOBJECT_HAS_NAMEBINDING, DUK_HOBJECT_HAS_NATFUNC, DUK_HOBJECT_INCREF, DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_IS_PROXY, DUK_HOBJECT_IS_THREAD, DUK_HOBJECT_SET_PROTOTYPE, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_HTYPE_OBJECT, duk_is_bare_object(), duk_known_hbuffer(), duk_memcpy, duk_memcpy_unsafe, duk_pop(), DUK_PROPDESC_FLAGS_C, DUK_PROPDESC_FLAGS_NONE, DUK_PROPDESC_FLAGS_W, DUK_PROPDESC_FLAGS_WC, duk_push_bare_array(), duk_push_bare_object(), duk_push_fixed_buffer_nozero(), duk_push_hcompfunc(), duk_push_hobject(), duk_push_object(), duk_push_tval(), duk_push_u32, duk_put_prop(), duk_put_prop_index(), DUK_RAW_READINC_DOUBLE_BE, DUK_RAW_READINC_U16_BE, DUK_RAW_READINC_U32_BE, DUK_RAW_READINC_U8, duk_require_stack(), duk_set_top(), DUK_STRIDX_CONSTRUCTOR, DUK_STRIDX_FILE_NAME, DUK_STRIDX_INT_FORMALS, DUK_STRIDX_INT_PC2LINE, DUK_STRIDX_INT_VARMAP, DUK_STRIDX_LENGTH, DUK_STRIDX_NAME, DUK_STRIDX_PROTOTYPE, DUK_TVAL_GET_OBJECT, DUK_TVAL_INCREF_FAST, DUK_TVAL_IS_OBJECT, DUK_TVAL_SET_NUMBER_CHKFAST_SLOW, duk_xdef_prop(), duk_xdef_prop_stridx_short, duk_hthread::heap, duk_hcompfunc::nargs, duk_hcompfunc::nregs, duk_hcompfunc::obj, duk_hdecenv::regbase_byteoff, duk_hdecenv::thread, and duk_hdecenv::varmap.
Referenced by duk__load_func().
| DUK_LOCAL const duk_uint8_t * duk__load_string_raw | ( | duk_hthread * | thr, |
| const duk_uint8_t * | p | ||
| ) |
Definition at line 14441 of file duktape.c.
Referenced by duk__load_func().
| DUK_LOCAL double duk__log | ( | double | x | ) |
| DUK_LOCAL 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 duk_regconst_t duk__lookup_active_register_binding | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 71611 of file duktape.c.
References DUK__IVAL_FLAG_ALLOW_CONST, and duk__ivalue_toregconst_raw().
| 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 59560 of file duktape.c.
References duk__hobject_get_entry_object_stridx(), DUK_STRIDX_INT_VARMAP, and duk_hthread::heap.
Referenced by duk_hobject_define_property_helper().
| DUK_LOCAL duk_bool_t duk__lookup_lhs | ( | duk_compiler_ctx * | ctx, |
| duk_regconst_t * | out_reg_varbind, | ||
| duk_regconst_t * | out_rc_varname | ||
| ) |
Definition at line 71691 of file duktape.c.
Referenced by duk__parse_var_decl().
| DUK_LOCAL duk_double_t duk__make_day | ( | duk_double_t | year, |
| duk_double_t | month, | ||
| duk_double_t | day | ||
| ) |
Definition at line 52361 of file duktape.c.
References duk__mark_heaphdr_nonnull(), DUK_ASSERT, DUK_DD, DUK_DDPRINT, DUK_HEAPHDR_GET_NEXT, DUK_HEAPHDR_HAS_FINALIZABLE, DUK_HEAPHDR_HAS_FINALIZED, DUK_HEAPHDR_HAS_REACHABLE, DUK_HEAPHDR_HAS_READONLY, DUK_HEAPHDR_IS_OBJECT, DUK_HEAPHDR_SET_FINALIZABLE, DUK_HOBJECT_HAS_FINALIZER_FAST, duk_heap::heap_allocated, and duk_heap::heap_thread.
| DUK_LOCAL void duk__mark_heaphdr | ( | duk_heap * | heap, |
| duk_heaphdr * | h | ||
| ) |
Definition at line 52225 of file duktape.c.
Referenced by duk__mark_roots_heap().
| DUK_LOCAL void duk__mark_heaphdr_nonnull | ( | duk_heap * | heap, |
| duk_heaphdr * | h | ||
| ) |
Definition at line 52314 of file duktape.c.
Referenced by duk__mark_finalizable().
| DUK_LOCAL void duk__mark_hobject | ( | duk_heap * | heap, |
| duk_hobject * | h | ||
| ) |
Definition at line 52079 of file duktape.c.
References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_HSTRING_ASSERT_VALID, and DUK_UNREF.
| DUK_LOCAL void duk__mark_hstring | ( | duk_heap * | heap, |
| duk_hstring * | h | ||
| ) |
Definition at line 52325 of file duktape.c.
References duk__mark_heaphdr().
| 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 91959 of file duktape.c.
References DUK_RE_FLAG_IGNORE_CASE, duk_unicode_decode_xutf8_checked(), duk_unicode_re_canonicalize_char(), duk_re_matcher_ctx::input, duk_re_matcher_ctx::input_end, duk_re_matcher_ctx::re_flags, and duk_re_matcher_ctx::thr.
| DUK_LOCAL duk_ret_t duk__math_minmax | ( | duk_hthread * | thr, |
| duk_double_t | initial, | ||
| duk__two_arg_func | min_max | ||
| ) |
Definition at line 40622 of file duktape.c.
References duk_get_top(), and duk_to_number().
| DUK_LOCAL void duk__nud_array_literal | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
Definition at line 71934 of file duktape.c.
References duk_compiler_ctx::curr_func, duk_hbuffer_resize(), duk_set_length(), duk_compiler_func::h_labelinfos, duk_compiler_func::labelnames_idx, and duk_compiler_ctx::thr.
| DUK_LOCAL void duk__nud_object_literal | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL DUK_NOINLINE void duk__numconv_parse_raw | ( | duk_hthread * | thr, |
| duk_small_int_t | radix, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL DUK_NOINLINE void duk__numconv_stringify_raw | ( | duk_hthread * | thr, |
| duk_small_int_t | radix, | ||
| duk_small_int_t | digits, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | flag_mask | ||
| ) |
Definition at line 22486 of file duktape.c.
References DUK_ASSERT, duk_get_tval_or_unused(), and DUK_TVAL_GET_TAG.
| DUK_LOCAL void duk__objlit_flush_keys | ( | duk_compiler_ctx * | comp_ctx, |
| duk__objlit_state * | st | ||
| ) |
| DUK_LOCAL duk_bool_t duk__objlit_load_key | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_token * | tok, | ||
| duk_regconst_t | reg_temp | ||
| ) |
Definition at line 72117 of file duktape.c.
References duk__emit_a_b_c(), DUK__EMIT_FLAG_A_IS_SOURCE, DUK__EMIT_FLAG_NO_SHUFFLE_C, DUK_ASSERT, DUK_OP_MPUTOBJ, duk__objlit_state::num_pairs, duk__objlit_state::num_total_pairs, duk__objlit_state::reg_obj, and duk__objlit_state::temp_start.
| DUK_LOCAL DUK_INLINE duk_tval * duk__obtain_arridx_slot | ( | duk_hthread * | thr, |
| duk_uint32_t | arr_idx, | ||
| duk_hobject * | obj | ||
| ) |
Definition at line 58366 of file duktape.c.
References DUK_ASSERT, and DUK_HOBJECT_HAS_ARRAY_PART.
Referenced by duk_hobject_define_property_helper(), and duk_hobject_putprop().
| DUK_LOCAL duk_tval * duk__obtain_arridx_slot_slowpath | ( | duk_hthread * | thr, |
| duk_uint32_t | arr_idx, | ||
| duk_hobject * | obj | ||
| ) |
Definition at line 58321 of file duktape.c.
References DUK_DD, and DUK_DDPRINT.
| DUK_LOCAL duk_int_t duk__parse_arguments | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL void duk__parse_break_or_continue_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| 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 91017 of file duktape.c.
References duk_unicode_re_ranges_digit, duk_unicode_re_ranges_white, and duk_unicode_re_ranges_wordchar.
| DUK_LOCAL void duk__parse_do_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_int_t | pc_label_site | ||
| ) |
| DUK_LOCAL void duk__parse_for_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_int_t | pc_label_site | ||
| ) |
| DUK_LOCAL void duk__parse_func_body | ( | duk_compiler_ctx * | comp_ctx, |
| duk_bool_t | expect_eof, | ||
| duk_bool_t | implicit_return_value, | ||
| duk_bool_t | regexp_after, | ||
| duk_small_int_t | expect_token | ||
| ) |
Definition at line 76300 of file duktape.c.
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_bc(), duk__emit_op_only(), DUK__FUNCTION_BODY_REQUIRE_SLOTS, DUK__GETTEMP, duk__hstring_is_eval_or_arguments(), duk__init_varmap_and_prologue_for_pass2(), DUK__ISREG, 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_D, DUK_DDD, DUK_DDDPRINT, DUK_DPRINT, DUK_ERROR_INTERNAL, DUK_ERROR_SYNTAX, DUK_HSTRING_HAS_RESERVED_WORD, DUK_HSTRING_HAS_STRICT_RESERVED_WORD, DUK_INT_MAX, DUK_LEXER_GETPOINT, DUK_LEXER_SETPOINT, DUK_OP_LDUNDEF, DUK_OP_RETREG, DUK_OP_RETUNDEF, duk_require_stack(), DUK_STR_INVALID_FUNC_NAME, DUK_TOK_LCURLY, DUK_WO_NORETURN, duk_compiler_func::h_name, duk_compiler_func::id_access_arguments, duk_compiler_func::id_access_slow, duk_compiler_func::id_access_slow_own, 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, 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_LOCAL void duk__parse_func_formals | ( | duk_compiler_ctx * | comp_ctx | ) |
| DUK_LOCAL duk_int_t duk__parse_func_like_fnum | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL void duk__parse_func_like_raw | ( | duk_compiler_ctx * | comp_ctx, |
| duk_small_uint_t | flags | ||
| ) |
Definition at line 76628 of file duktape.c.
References DUK_ERROR_SYNTAX, DUK_STR_EXPECTED_IDENTIFIER, and DUK_WO_NORETURN.
| DUK_LOCAL void duk__parse_if_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL duk_uint32_t duk__parse_regexp_flags | ( | duk_hthread * | thr, |
| duk_hstring * | h | ||
| ) |
| DUK_LOCAL void duk__parse_return_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL void duk__parse_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_bool_t | allow_source_elem | ||
| ) |
Definition at line 75378 of file duktape.c.
References duk_compiler_ctx::curr_func, duk__emit_bc(), duk__emit_invalid(), DUK_DDD, DUK_DDDPRINT, DUK_OP_LABEL, and duk_compiler_func::label_next.
| DUK_LOCAL void duk__parse_stmts | ( | duk_compiler_ctx * | comp_ctx, |
| duk_bool_t | allow_source_elem, | ||
| duk_bool_t | expect_eof, | ||
| duk_bool_t | regexp_after | ||
| ) |
Definition at line 75890 of file duktape.c.
Referenced by duk__parse_func_body().
| DUK_LOCAL duk_ret_t duk__parse_string | ( | duk_hthread * | thr, |
| const char * | str | ||
| ) |
Definition at line 33090 of file duktape.c.
References duk__parse_string_iso8601_subset(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, and duk_push_nan().
| DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset | ( | duk_hthread * | thr, |
| const char * | str | ||
| ) |
Definition at line 32889 of file duktape.c.
Referenced by duk__parse_string().
| DUK_LOCAL void duk__parse_switch_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_int_t | pc_label_site | ||
| ) |
| DUK_LOCAL void duk__parse_throw_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL void duk__parse_try_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
| DUK_LOCAL void duk__parse_var_decl | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | expr_flags, | ||
| duk_regconst_t * | out_reg_varbind, | ||
| duk_regconst_t * | out_rc_varname | ||
| ) |
Definition at line 74134 of file duktape.c.
References duk_compiler_ctx::curr_func, duk_compiler_ctx::curr_token, duk_compiler_func::decls_idx, duk__advance(), DUK__BP_COMMA, 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_push_hstring(), duk_push_int(), duk_put_prop_index(), DUK_TOK_EQUALSIGN, DUK_TOK_IDENTIFIER, duk_compiler_func::in_scanning, duk_token::str1, duk_token::t, and duk_compiler_ctx::thr.
| DUK_LOCAL void duk__parse_var_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_small_uint_t | expr_flags | ||
| ) |
| DUK_LOCAL void duk__parse_while_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res, | ||
| duk_int_t | pc_label_site | ||
| ) |
| DUK_LOCAL void duk__parse_with_stmt | ( | duk_compiler_ctx * | comp_ctx, |
| duk_ivalue * | res | ||
| ) |
Definition at line 75316 of file duktape.c.
References duk__patch_jump(), and DUK_ASSERT.
| DUK_LOCAL void duk__patch_jump | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | jump_pc, | ||
| duk_int_t | target_pc | ||
| ) |
Definition at line 70768 of file duktape.c.
Referenced by duk__parse_with_stmt().
| DUK_LOCAL void duk__patch_jump_here | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | jump_pc | ||
| ) |
Definition at line 70794 of file duktape.c.
References DUK_DDD, and DUK_DDDPRINT.
| DUK_LOCAL void duk__patch_trycatch | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | ldconst_pc, | ||
| duk_int_t | trycatch_pc, | ||
| duk_regconst_t | reg_catch, | ||
| duk_regconst_t | const_varname, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL duk_ret_t duk__pcall_method_raw | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| DUK_LOCAL duk_ret_t duk__pcall_prop_raw | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| DUK_LOCAL duk_ret_t duk__pcall_raw | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| DUK_LOCAL void duk__peephole_optimize_bytecode | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 70870 of file duktape.c.
Referenced by duk__parse_func_body().
| DUK_LOCAL duk_ret_t duk__pnew_helper | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__pop_2_unsafe_raw | ( | duk_hthread * | thr | ) |
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__pop_n_unsafe_raw | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 24593 of file duktape.c.
References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_API_ENTRY, DUK_NUM_BUILTINS, and duk_push_hobject().
| DUK_LOCAL DUK_ALWAYS_INLINE void duk__pop_unsafe_raw | ( | duk_hthread * | thr | ) |
| DUK_LOCAL void duk__preallocate_env_entries | ( | duk_hthread * | thr, |
| duk_hobject * | varmap, | ||
| duk_hobject * | env | ||
| ) |
| DUK_LOCAL const duk_uint8_t * duk__prep_codec_arg | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len | ||
| ) |
Definition at line 15731 of file duktape.c.
References DUK_ASSERT, duk_get_buffer_data_raw(), duk_is_valid_index(), duk_to_lstring(), and DUK_UNLIKELY.
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF void duk__prepost_incdec_reg_helper | ( | duk_hthread * | thr, |
| duk_tval * | tv_dst, | ||
| duk_tval * | tv_src, | ||
| duk_small_uint_t | op | ||
| ) |
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF void duk__prepost_incdec_var_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | idx_dst, | ||
| duk_tval * | tv_id, | ||
| duk_small_uint_t | op, | ||
| duk_small_uint_t | is_strict | ||
| ) |
| DUK_LOCAL int duk__protected_compact_object | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| 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 58431 of file duktape.c.
References DUK_ASSERT, DUK_HPROXY_ASSERT_VALID, and duk_hproxy::target.
Referenced by duk_hobject_putprop().
| DUK_LOCAL duk_idx_t duk__push_c_function_raw | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_idx_t | nargs, | ||
| duk_uint_t | flags, | ||
| duk_small_uint_t | proto_bidx | ||
| ) |
| DUK_LOCAL void duk__push_double | ( | duk_hthread * | thr, |
| duk_bitdecoder_ctx * | bd | ||
| ) |
| DUK_LOCAL void duk__push_func_from_lightfunc | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_small_uint_t | lf_flags | ||
| ) |
| DUK_LOCAL void duk__push_hstring_readable_unicode | ( | duk_hthread * | thr, |
| duk_hstring * | h_input, | ||
| duk_small_uint_t | maxchars | ||
| ) |
Definition at line 25366 of file duktape.c.
References DUK__READABLE_SUMMARY_MAXCHARS, DUK_ASC_BACKSLASH, DUK_ASC_LC_X, DUK_ASC_PERIOD, DUK_ASC_SINGLEQUOTE, DUK_ASSERT, DUK_CTX_ASSERT_VALID, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_lc_digits, duk_unicode_decode_xutf8(), duk_unicode_encode_xutf8(), and DUK_UNICODE_MAX_XUTF8_LENGTH.
| DUK_LOCAL void duk__push_stash | ( | duk_hthread * | thr | ) |
Definition at line 23364 of file duktape.c.
Referenced by duk__try_push_vsprintf().
| DUK_LOCAL void duk__push_stridx | ( | duk_hthread * | thr, |
| duk_bitdecoder_ctx * | bd | ||
| ) |
Definition at line 64677 of file duktape.c.
References DUK_ASSERT, and DUK_LOSE_CONST.
| DUK_LOCAL void duk__push_stridx_or_string | ( | duk_hthread * | thr, |
| duk_bitdecoder_ctx * | bd | ||
| ) |
| DUK_LOCAL void duk__push_string | ( | duk_hthread * | thr, |
| duk_bitdecoder_ctx * | bd | ||
| ) |
| DUK_LOCAL const char * duk__push_string_tval_readable | ( | duk_hthread * | thr, |
| duk_tval * | tv, | ||
| duk_bool_t | error_aware | ||
| ) |
| DUK_LOCAL duk_double_t duk__push_this_get_timeval | ( | duk_hthread * | thr, |
| duk_small_uint_t | flags | ||
| ) |
Definition at line 33654 of file duktape.c.
Referenced by duk_bi_date_prototype_to_json().
| DUK_LOCAL duk_double_t duk__push_this_get_timeval_tzoffset | ( | duk_hthread * | thr, |
| duk_small_uint_t | flags, | ||
| duk_int_t * | out_tzoffset | ||
| ) |
| DUK_LOCAL void duk__push_this_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | check_object_coercible | ||
| ) |
Definition at line 23219 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_push_uint(), and duk_to_hstring_m1().
Referenced by duk_push_this_coercible_to_object(), and duk_push_this_coercible_to_string().
| DUK_LOCAL duk_double_t duk__push_this_number_plain | ( | duk_hthread * | thr | ) |
| DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32 | ( | duk_hthread * | thr | ) |
Definition at line 26140 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), and duk_bi_array_prototype_join_shared().
| DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32_limited | ( | duk_hthread * | thr | ) |
Definition at line 26153 of file duktape.c.
Referenced by duk_bi_array_prototype_splice().
| DUK_LOCAL duk_uint32_t duk__push_tval_to_property_key | ( | duk_hthread * | thr, |
| duk_tval * | tv_key, | ||
| duk_hstring ** | out_h | ||
| ) |
Definition at line 58092 of file duktape.c.
Referenced by duk_hobject_putprop().
| DUK_LOCAL duk_bool_t duk__put_prop_shared | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_idx_t | idx_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 | ||
| ) |
Definition at line 60400 of file duktape.c.
Referenced by duk_hobject_putprop().
| 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 | ||
| ) |
Definition at line 60275 of file duktape.c.
Referenced by duk_hobject_putprop().
| 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 85190 of file duktape.c.
References DUK_ERR_REFERENCE_ERROR, DUK_ERROR_FMT1, DUK_HSTRING_GET_DATA, and DUK_WO_NORETURN.
| DUK_LOCAL duk_codepoint_t duk__re_canon_next_discontinuity | ( | duk_codepoint_t | start, |
| duk_codepoint_t | end | ||
| ) |
Definition at line 90820 of file duktape.c.
References duk__append_u32(), DUK_ASSERT, and duk_re_compiler_ctx::nranges.
| DUK_LOCAL void duk__reconfig_valstack_ecma_catcher | ( | duk_hthread * | thr, |
| duk_activation * | act | ||
| ) |
| DUK_LOCAL void duk__reconfig_valstack_ecma_return | ( | duk_hthread * | thr | ) |
Definition at line 77947 of file duktape.c.
References duk_hthread::callstack_curr, DUK_ACT_GET_FUNC, DUK_ASSERT, and DUK_HOBJECT_IS_COMPFUNC.
Definition at line 54444 of file duktape.c.
References count(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_HEAPHDR_GET_PREV, DUK_HEAPHDR_GET_TYPE, duk_hobject_refcount_finalize_norz(), DUK_HTYPE_OBJECT, and duk_heap::refzero_list.
| DUK_LOCAL DUK_INLINE void duk__refcount_refzero_hbuffer | ( | duk_heap * | heap, |
| duk_hbuffer * | buf | ||
| ) |
| DUK_LOCAL DUK_INLINE void duk__refcount_refzero_hobject | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_bool_t | skip_free_pending | ||
| ) |
| DUK_LOCAL DUK_INLINE void duk__refcount_refzero_hstring | ( | duk_heap * | heap, |
| duk_hstring * | str | ||
| ) |
| DUK_LOCAL void duk__regexp_emit_range | ( | duk_re_compiler_ctx * | re_ctx, |
| duk_codepoint_t | r1, | ||
| duk_codepoint_t | r2 | ||
| ) |
| DUK_LOCAL void duk__regexp_generate_ranges | ( | void * | userdata, |
| duk_codepoint_t | r1, | ||
| duk_codepoint_t | r2, | ||
| duk_bool_t | direct | ||
| ) |
Definition at line 90871 of file duktape.c.
References DUK_ASSERT, DUK_CANON_BITMAP_BLKSHIFT, and duk_unicode_re_canon_bitmap.
| DUK_LOCAL void duk__regexp_match_helper | ( | duk_hthread * | thr, |
| duk_small_int_t | force_global | ||
| ) |
| 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 90646 of file duktape.c.
References duk_re_compiler_ctx::bw, DUK_BW_WRITE_ENSURE_U8_2, and duk_re_compiler_ctx::thr.
| DUK_LOCAL duk_hbufobj * duk__require_bufobj_this | ( | duk_hthread * | thr | ) |
Definition at line 27967 of file duktape.c.
Referenced by duk_bi_buffer_readfield(), and duk_bi_typedarray_set().
| DUK_LOCAL duk_hbufobj * duk__require_bufobj_value | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 27972 of file duktape.c.
References DUK__BUFOBJ_FLAG_PROMOTE, and duk__getrequire_bufobj_this().
| DUK_LOCAL void duk__reset_func_for_pass2 | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 69633 of file duktape.c.
Referenced by duk__parse_func_body().
| DUK_LOCAL void duk__reset_labels_to_length | ( | duk_compiler_ctx * | comp_ctx, |
| duk_size_t | len | ||
| ) |
| DUK_LOCAL DUK_COLD DUK_NOINLINE duk_bool_t duk__resize_valstack | ( | duk_hthread * | thr, |
| duk_size_t | new_size | ||
| ) |
Definition at line 19346 of file duktape.c.
References DUK_ASSERT, DUK_D, DUK_DPRINT, DUK_HTHREAD_ASSERT_VALID, duk_hthread_get_valstack_ptr(), DUK_REALLOC_INDIRECT, DUK_SIZE_MAX, DUK_TVAL_SET_UNDEFINED, DUK_UNLIKELY, DUK_UNREF, DUK_USE_VALSTACK_LIMIT, duk_hthread::heap, duk_heap::pf_prevent_count, duk_hthread::valstack, duk_hthread::valstack_alloc_end, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.
| DUK_LOCAL void duk__resolve_offset_opt_length | ( | duk_hthread * | thr, |
| duk_hbufobj * | 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 DUK_ALWAYS_INLINE duk_bool_t duk__resolve_target_fastpath_check | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_hobject ** | out_func, | ||
| duk_small_uint_t | call_flags | ||
| ) |
Definition at line 67213 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_LOCAL duk_hobject * duk__resolve_target_func_and_this_binding | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_small_uint_t * | call_flags | ||
| ) |
Definition at line 67259 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_LOCAL double duk__round_fixed | ( | double | x | ) |
| 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_ret_t duk__safe_to_stacktrace_raw | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
Definition at line 21835 of file duktape.c.
References duk_get_prop_string(), duk_is_string(), duk_pop(), and duk_replace().
| DUK_LOCAL duk_ret_t duk__safe_to_string_raw | ( | duk_hthread * | thr, |
| void * | udata | ||
| ) |
| 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 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 55054 of file duktape.c.
References DUK_DD, DUK_DDPRINT, and duk_strcache_entry::h.
| DUK_LOCAL void duk__set_bufobj_buffer | ( | duk_hthread * | thr, |
| duk_hbufobj * | h_bufobj, | ||
| duk_hbuffer * | h_val | ||
| ) |
| DUK_LOCAL void duk__set_catcher_regs_norz | ( | duk_hthread * | thr, |
| duk_catcher * | cat, | ||
| duk_tval * | tv_val_unstable, | ||
| duk_small_uint_t | lj_type | ||
| ) |
| DUK_LOCAL duk_ret_t duk__set_part_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | flags_and_maxnargs | ||
| ) |
Definition at line 33854 of file duktape.c.
Referenced by duk_bi_date_prototype_set_time().
| DUK_LOCAL void duk__set_parts_from_args | ( | duk_hthread * | thr, |
| duk_double_t * | dparts, | ||
| duk_idx_t | nargs | ||
| ) |
| DUK_LOCAL duk_ret_t duk__set_this_timeval_from_dparts | ( | duk_hthread * | thr, |
| duk_double_t * | dparts, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 33662 of file duktape.c.
Referenced by duk__twodigit_year_fixup().
| DUK_LOCAL void duk__settemp_checkmax | ( | duk_compiler_ctx * | comp_ctx, |
| duk_regconst_t | temp_next | ||
| ) |
Definition at line 71048 of file duktape.c.
References DUK_ERROR_RANGE, DUK_STR_TEMP_LIMIT, DUK_WO_NORETURN, and duk_compiler_ctx::thr.
| DUK_LOCAL double duk__sin | ( | double | x | ) |
| 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 13524 of file duktape.c.
References count(), DUK_ASSERT, duk_bd_decode(), DUK_BW_WRITE_RAW_XUTF8, DUK_DDD, DUK_DDDPRINT, and DUK_UNREF.
Referenced by duk__case_transform_helper().
| DUK_LOCAL duk_bool_t duk__sort_compare_es6 | ( | duk_hstring * | a, |
| duk_hstring * | b, | ||
| duk__sort_key_t | val_b | ||
| ) |
| DUK_LOCAL void duk__sort_enum_keys_es6 | ( | duk_hthread * | thr, |
| duk_hobject * | h_obj, | ||
| duk_int_fast32_t | idx_start, | ||
| duk_int_fast32_t | idx_end | ||
| ) |
| DUK_LOCAL double duk__sqrt | ( | double | x | ) |
| DUK_LOCAL duk_int_t duk__stmt_label_site | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | label_id | ||
| ) |
| DUK_LOCAL duk_int_t duk__str_search_shared | ( | duk_hthread * | thr, |
| duk_hstring * | h_this, | ||
| duk_hstring * | h_search, | ||
| duk_int_t | start_cpos, | ||
| duk_bool_t | backwards | ||
| ) |
Definition at line 42721 of file duktape.c.
References DUK_ERROR_TYPE_INVALID_ARGS, and DUK_WO_NORETURN.
| DUK_LOCAL duk_hstring * duk__str_tostring_notregexp | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_LOCAL duk_hstring * duk__strtable_alloc_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_hstring * duk__strtable_do_intern | ( | duk_heap * | heap, |
| const duk_uint8_t * | str, | ||
| duk_uint32_t | blen, | ||
| duk_uint32_t | strhash | ||
| ) |
| DUK_LOCAL duk_uint_t duk__strtable_litcache_key | ( | const duk_uint8_t * | str, |
| duk_uint32_t | blen | ||
| ) |
Definition at line 56157 of file duktape.c.
References DUK_ASSERT, duk_heap_strtable_intern(), and duk_hthread::heap.
| DUK_LOCAL DUK_COLD DUK_NOINLINE void duk__strtable_resize_check | ( | duk_heap * | heap | ) |
| DUK_LOCAL void duk__sweep_heap | ( | duk_heap * | heap, |
| duk_small_uint_t | flags, | ||
| duk_size_t * | out_count_keep | ||
| ) |
| DUK_LOCAL void duk__sweep_stringtable | ( | duk_heap * | heap, |
| duk_size_t * | out_count_keep | ||
| ) |
| DUK_LOCAL duk_bool_t duk__tag_check | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_small_uint_t | tag | ||
| ) |
Definition at line 22478 of file duktape.c.
Referenced by duk_is_buffer_data(), and duk_is_symbol().
| DUK_LOCAL double duk__tan | ( | double | x | ) |
| DUK_LOCAL void duk__throw_error_from_stash | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | fmt, | ||
| va_list | ap | ||
| ) |
| DUK_LOCAL duk_double_t duk__timeclip | ( | duk_double_t | x | ) |
Definition at line 33171 of file duktape.c.
References DUK_DATE_MSEC_100M_DAYS.
| DUK_LOCAL duk_double_t duk__to_int_uint_helper | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk__toint_coercer | coerce_func | ||
| ) |
| DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
Definition at line 61126 of file duktape.c.
Referenced by duk_hobject_define_property_helper().
| DUK_LOCAL void duk__to_primitive_helper | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | hint, | ||
| duk_bool_t | check_symbol | ||
| ) |
Definition at line 21440 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_require_tval(), and DUK_TVAL_SET_NULL_UPDREF.
Referenced by duk_to_boolean().
| DUK_LOCAL duk_uint32_t duk__to_property_key | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_hstring ** | out_h | ||
| ) |
| DUK_LOCAL void duk__to_regexp_helper | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_bool_t | force_new | ||
| ) |
| DUK_LOCAL duk_ret_t duk__to_string_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | flags | ||
| ) |
Definition at line 33766 of file duktape.c.
Referenced by duk_bi_date_prototype_value_of().
| DUK_LOCAL duk_double_t duk__toint32_touint32_helper | ( | duk_double_t | x, |
| duk_bool_t | is_toint32 | ||
| ) |
| DUK_LOCAL duk_double_t duk__tonumber_string_raw | ( | duk_hthread * | thr | ) |
| DUK_LOCAL void duk__transform_callback_decode_uri | ( | duk__transform_context * | tfm_ctx, |
| const void * | udata, | ||
| duk_codepoint_t | cp | ||
| ) |
Definition at line 36846 of file duktape.c.
Referenced by duk_bi_global_object_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 36779 of file duktape.c.
References duk_unicode_decode_xutf8_checked(), duk__transform_context::p, duk__transform_context::p_end, and duk__transform_context::p_start.
Referenced by duk_bi_global_object_escape(), and duk_bi_global_object_unescape().
| 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 int duk__transform_helper | ( | duk_hthread * | thr, |
| duk__transform_callback | callback, | ||
| const void * | udata | ||
| ) |
Definition at line 36752 of file duktape.c.
Referenced by duk_bi_global_object_encode_uri(), duk_bi_global_object_escape(), and duk_bi_global_object_unescape().
| DUK_LOCAL duk_int_t duk__try_push_vsprintf | ( | duk_hthread * | thr, |
| void * | buf, | ||
| duk_size_t | sz, | ||
| const char * | fmt, | ||
| va_list | ap | ||
| ) |
Definition at line 23404 of file duktape.c.
References duk__push_stash(), DUK_ASSERT_API_ENTRY, DUK_ERROR_TYPE_INVALID_ARGS, duk_push_hobject(), DUK_UNLIKELY, and DUK_WO_NORETURN.
Definition at line 58031 of file duktape.c.
Referenced by duk__getprop_shallow_fastpath_array_tval(), and duk_hobject_putprop().
Definition at line 58008 of file duktape.c.
Referenced by duk__getprop_shallow_fastpath_array_tval(), and duk_hobject_putprop().
| DUK_LOCAL void duk__twodigit_year_fixup | ( | duk_hthread * | thr, |
| duk_idx_t | idx_val | ||
| ) |
Definition at line 33953 of file duktape.c.
References duk__set_this_timeval_from_dparts().
| DUK_LOCAL void duk__uncaught_error_aware | ( | duk_hthread * | thr | ) |
| DUK_LOCAL void duk__unemit_1 | ( | duk_json_enc_ctx * | js_ctx | ) |
| 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 void duk__update_default_instance_proto | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func | ||
| ) |
Definition at line 66542 of file duktape.c.
References DUK_ASSERT, and duk_is_constructable().
| DUK_LOCAL void duk__update_label_flags | ( | duk_compiler_ctx * | comp_ctx, |
| duk_int_t | label_id, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_LOCAL void duk__update_lineinfo_currtoken | ( | duk_compiler_ctx * | comp_ctx | ) |
Definition at line 70241 of file duktape.c.
Referenced by duk__parse_func_body().
| 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 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 91847 of file duktape.c.
References duk_re_matcher_ctx::bytecode, duk_re_matcher_ctx::bytecode_end, duk_unicode_decode_xutf8_checked(), and duk_re_matcher_ctx::thr.
| DUK_LOCAL void duk__utf8_decode_init | ( | duk__decode_context * | dec_ctx | ) |
| DUK_LOCAL duk_codepoint_t duk__utf8_decode_next | ( | duk__decode_context * | dec_ctx, |
| duk_uint8_t | x | ||
| ) |
Definition at line 35310 of file duktape.c.
References duk__decode_context::bom_handled, duk__decode_context::codepoint, duk__decode_context::lower, duk__decode_context::needed, and duk__decode_context::upper.
| DUK_LOCAL duk_uint8_t * duk__utf8_emit_repl | ( | duk_uint8_t * | ptr | ) |
| DUK_LOCAL void duk__utf8_encode_char | ( | void * | udata, |
| duk_codepoint_t | codepoint | ||
| ) |
| DUK_LOCAL DUK_COLD DUK_NOINLINE duk_bool_t duk__valstack_grow | ( | duk_hthread * | thr, |
| duk_size_t | min_bytes, | ||
| duk_bool_t | throw_on_error | ||
| ) |
Definition at line 19509 of file duktape.c.
References DUK_ASSERT, and DUK_TVAL_IS_UNDEFINED.
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF 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 77235 of file duktape.c.
References duk_js_arith_mod().
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF void duk__vm_arith_binary_op | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y, | ||
| duk_uint_fast_t | idx_z, | ||
| duk_small_uint_fast_t | opcode | ||
| ) |
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF void duk__vm_arith_unary_op | ( | duk_hthread * | thr, |
| duk_uint_fast_t | idx_src, | ||
| duk_uint_fast_t | idx_dst, | ||
| duk_small_uint_fast_t | opcode | ||
| ) |
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF 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 DUK_EXEC_ALWAYS_INLINE_PERF void duk__vm_bitwise_not | ( | duk_hthread * | thr, |
| duk_uint_fast_t | idx_src, | ||
| duk_uint_fast_t | idx_dst | ||
| ) |
| DUK_LOCAL DUK_EXEC_ALWAYS_INLINE_PERF void duk__vm_logical_not | ( | duk_hthread * | thr, |
| duk_uint_fast_t | idx_src, | ||
| duk_uint_fast_t | idx_dst | ||
| ) |
| DUK_LOCAL duk_int_t duk__year_from_day | ( | duk_int_t | day, |
| duk_small_int_t * | out_day_within_year | ||
| ) |
| DUK_EXTERNAL void * duk_alloc | ( | duk_hthread * | thr, |
| duk_size_t | size | ||
| ) |
Definition at line 17582 of file duktape.c.
References DUK_ASSERT_API_ENTRY, DUK_FREE_RAW, and duk_hthread::heap.
| DUK_EXTERNAL void * duk_alloc_raw | ( | duk_hthread * | thr, |
| duk_size_t | size | ||
| ) |
| DUK_EXTERNAL void duk_base64_decode | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL const char * duk_base64_encode | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_uint32_t duk_bd_decode | ( | duk_bitdecoder_ctx * | ctx, |
| duk_small_int_t | bits | ||
| ) |
Definition at line 99942 of file duktape.c.
Referenced by duk__slow_case_conversion(), and duk_bd_decode_bitpacked_string().
| DUK_INTERNAL duk_small_uint_t duk_bd_decode_bitpacked_string | ( | duk_bitdecoder_ctx * | bd, |
| duk_uint8_t * | out | ||
| ) |
Definition at line 100048 of file duktape.c.
References duk_bd_decode().
| DUK_INTERNAL duk_small_uint_t duk_bd_decode_flag | ( | duk_bitdecoder_ctx * | ctx | ) |
| DUK_INTERNAL duk_uint32_t duk_bd_decode_flagged | ( | duk_bitdecoder_ctx * | ctx, |
| duk_small_int_t | bits, | ||
| duk_uint32_t | def_value | ||
| ) |
| DUK_INTERNAL duk_int32_t duk_bd_decode_flagged_signed | ( | duk_bitdecoder_ctx * | ctx, |
| duk_small_int_t | bits, | ||
| duk_int32_t | def_value | ||
| ) |
| DUK_INTERNAL duk_uint32_t duk_bd_decode_varuint | ( | duk_bitdecoder_ctx * | ctx | ) |
| DUK_INTERNAL void duk_be_encode | ( | duk_bitencoder_ctx * | ctx, |
| duk_uint32_t | data, | ||
| duk_small_int_t | bits | ||
| ) |
| DUK_INTERNAL void duk_be_finish | ( | duk_bitencoder_ctx * | ctx | ) |
Definition at line 100127 of file duktape.c.
References duk_bitencoder_ctx::currbits, duk_bitencoder_ctx::currval, and DUK_ASSERT.
| DUK_INTERNAL duk_ret_t duk_bi_array_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_constructor_is_array | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_concat | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_indexof_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared | ( | duk_context * | ctx | ) |
Definition at line 27518 of file duktape.c.
References DUK__ITER_EVERY, DUK__ITER_FILTER, DUK__ITER_FOREACH, DUK__ITER_MAP, DUK__ITER_SOME, duk__push_this_obj_len_u32(), DUK_ASSERT, DUK_ASSERT_TOP, duk_call_method(), duk_dup_0(), duk_dup_1(), duk_dup_2(), duk_dup_m2(), duk_dup_m3(), duk_dup_top(), duk_get_current_magic(), duk_get_prop_index(), duk_is_array(), duk_pop_2_unsafe(), duk_pop_undefined(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_false(), duk_push_true(), duk_push_u32, duk_push_undefined(), duk_require_callable, DUK_STRIDX_LENGTH, duk_to_boolean(), DUK_UNREACHABLE, duk_xdef_prop_index_wec, and duk_xdef_prop_stridx_short.
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_join_shared | ( | duk_context * | ctx | ) |
Definition at line 26443 of file duktape.c.
References count(), DUK__ARRAY_MID_JOIN_LIMIT, duk__push_this_obj_len_u32(), duk_call_method(), DUK_DDD, DUK_DDDPRINT, duk_dup_0(), duk_get_current_magic(), duk_get_prop_index(), duk_get_prop_stridx_short, duk_get_tval(), duk_insert(), duk_is_null_or_undefined, duk_is_undefined(), duk_join(), duk_pop_nodecref_unsafe(), duk_pop_undefined(), duk_push_hstring_empty(), duk_push_hstring_stridx(), duk_require_stack(), duk_set_top(), DUK_STRIDX_COMMA, DUK_STRIDX_TO_LOCALE_STRING, duk_to_object(), and duk_to_string().
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_pop | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_push | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reduce_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reverse | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_shift | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_slice | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_sort | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_splice | ( | duk_context * | ctx | ) |
Definition at line 27026 of file duktape.c.
References duk__push_this_obj_len_u32_limited(), DUK_ASSERT, DUK_ASSERT_TOP, DUK_D, DUK_DCERROR_RANGE_INVALID_LENGTH, duk_del_prop_index(), DUK_DPRINT, duk_dup(), duk_get_prop_index(), duk_get_top(), duk_pop_undefined(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_u32, duk_put_prop_index(), duk_set_top(), DUK_STRIDX_LENGTH, duk_to_int_clamped(), DUK_UINT32_MAX, DUK_UNREF, duk_xdef_prop_index_wec, and duk_xdef_prop_stridx_short.
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_to_string | ( | duk_context * | ctx | ) |
Definition at line 26269 of file duktape.c.
References DUK_ASSERT_TOP, DUK_GET_TVAL_POSIDX, duk_js_isarray(), and duk_push_boolean().
| DUK_INTERNAL duk_ret_t duk_bi_array_prototype_unshift | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_isview | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_boolean_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_boolean_prototype_tostring_shared | ( | duk_context * | ctx | ) |
Definition at line 27747 of file duktape.c.
References DUK_ASSERT, duk_get_current_magic(), duk_get_tval(), DUK_HOBJECT_CLASS_BOOLEAN, DUK_HOBJECT_GET_CLASS_NUMBER, duk_is_boolean(), duk_push_this(), DUK_STRIDX_INT_VALUE, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_BOOLEAN, DUK_TVAL_IS_OBJECT, and duk_xget_owndataprop_stridx_short.
| DUK_INTERNAL duk_ret_t duk_bi_buffer_compare_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_buffer_readfield | ( | duk_context * | ctx | ) |
Definition at line 30054 of file duktape.c.
References duk_hbufobj::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_HBUFOBJ_CLAMP_BYTELENGTH, DUK_HBUFOBJ_GET_SLICE_BASE, duk_memcpy, duk_push_i64, duk_push_int(), duk_push_number(), duk_push_uint(), duk_to_boolean(), duk_to_int(), duk_double_union::f, duk_hthread::heap, duk_hbufobj::length, duk_double_union::uc, duk_double_union::ui, and duk_double_union::us.
| DUK_INTERNAL duk_ret_t duk_bi_buffer_slice_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_buffer_writefield | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_cbor_decode | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_cbor_encode | ( | duk_context * | ctx | ) |
Definition at line 32624 of file duktape.c.
References duk__cbor_encode(), and DUK_ASSERT_API_ENTRY.
| DUK_INTERNAL duk_ret_t duk_bi_dataview_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_constructor | ( | duk_context * | ctx | ) |
Definition at line 34169 of file duktape.c.
References duk__date_magics, DUK_ASSERT, and duk_get_current_magic().
| DUK_INTERNAL duk_ret_t duk_bi_date_constructor_now | ( | duk_context * | ctx | ) |
Definition at line 34241 of file duktape.c.
References duk_push_nan().
| DUK_INTERNAL duk_ret_t duk_bi_date_constructor_parse | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_int_t duk_bi_date_get_local_tzoffset_gmtime | ( | duk_double_t | d | ) |
| DUK_INTERNAL duk_double_t duk_bi_date_get_now_time | ( | void | ) |
| DUK_INTERNAL duk_double_t duk_bi_date_get_timeval_from_dparts | ( | duk_double_t * | dparts, |
| duk_small_uint_t | flags | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_bi_date_is_leap_year | ( | duk_int_t | year | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_timezone_offset | ( | duk_context * | ctx | ) |
Definition at line 34371 of file duktape.c.
References duk__date_get_indirect_magic(), and duk__get_part_helper().
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_time | ( | duk_context * | ctx | ) |
Definition at line 34456 of file duktape.c.
References duk__date_get_indirect_magic(), and duk__set_part_helper().
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_to_json | ( | duk_context * | ctx | ) |
Definition at line 34300 of file duktape.c.
References duk__push_this_get_timeval(), DUK_ASSERT, DUK_ISFINITE, DUK_ISNAN, and duk_push_number().
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_toprimitive | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_tostring_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_date_prototype_value_of | ( | duk_context * | ctx | ) |
Definition at line 34289 of file duktape.c.
References duk__date_get_indirect_magic(), and duk__to_string_helper().
| DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_leeway_range | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_valid_range | ( | duk_double_t | x | ) |
| DUK_INTERNAL void duk_bi_date_timeval_to_parts | ( | duk_double_t | d, |
| duk_int_t * | parts, | ||
| duk_double_t * | dparts, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_bi_date_year_in_valid_range | ( | duk_double_t | year | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_act | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_compact | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_dec | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_enc | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_fin | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_gc | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_duktape_object_info | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_constructor_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_setter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter | ( | duk_context * | ctx | ) |
Definition at line 36107 of file duktape.c.
References duk__error_getter_helper(), and DUK__OUTPUT_TYPE_TRACEBACK.
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_setter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_setter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string | ( | duk_context * | ctx | ) |
Definition at line 35830 of file duktape.c.
References DUK_AUGMENT_FLAG_NOBLAME_FILELINE, and duk_err_augment_error_create().
| DUK_INTERNAL duk_ret_t duk_bi_function_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_function_prototype | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_function_prototype_apply | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_function_prototype_bind | ( | duk_context * | ctx | ) |
Definition at line 36386 of file duktape.c.
References DUK_RET_TYPE_ERROR, and DUK_UNREF.
| DUK_INTERNAL duk_ret_t duk_bi_function_prototype_call | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_function_prototype_hasinstance | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_function_prototype_to_string | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri | ( | duk_context * | ctx | ) |
Definition at line 37325 of file duktape.c.
References DUK_ISFINITE, duk_push_boolean(), and duk_to_number().
| DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri_component | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri | ( | duk_context * | ctx | ) |
Definition at line 37335 of file duktape.c.
References duk__decode_uri_reserved_table, duk__transform_callback_decode_uri(), and duk__transform_helper().
| DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri_component | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_global_object_escape | ( | duk_context * | ctx | ) |
Definition at line 37346 of file duktape.c.
References duk__encode_uriunescaped_table, duk__transform_callback_encode_uri(), and duk__transform_helper().
| DUK_INTERNAL duk_ret_t duk_bi_global_object_eval | ( | duk_context * | ctx | ) |
Definition at line 37058 of file duktape.c.
References duk_activation::bottom_byteoff, duk_hthread::builtins, duk_hthread::callstack_curr, duk_hthread::callstack_top, DUK_ACT_FLAG_DIRECT_EVAL, DUK_ACT_FLAG_STRICT, DUK_ASSERT, DUK_BIDX_GLOBAL, DUK_BIDX_GLOBAL_ENV, DUK_CALL_FLAG_DIRECT_EVAL, DUK_COMPILE_EVAL, DUK_COMPILE_STRICT, DUK_DDD, DUK_DDDPRINT, duk_get_hstring_notsymbol(), duk_get_int(), duk_get_top(), duk_get_tval(), duk_hdecenv_alloc(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_DECENV, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_NEWENV, DUK_HOBJECT_HAS_STRICT, DUK_HOBJECT_INCREF_ALLOWNULL, DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_SET_PROTOTYPE, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_hthread_get_activation_for_level(), duk_insert(), duk_is_number(), duk_js_compile(), duk_js_init_activation_environment_records_delayed(), duk_js_push_closure(), duk_known_hobject(), duk_push_hobject(), duk_push_hobject_bidx(), duk_push_hstring_stridx(), duk_push_tval(), DUK_STRIDX_INPUT, duk_activation::flags, duk_hthread::heap, duk_activation::lex_env, duk_hthread::valstack, and duk_activation::var_env.
| DUK_INTERNAL duk_ret_t duk_bi_global_object_is_finite | ( | duk_context * | ctx | ) |
Definition at line 37313 of file duktape.c.
References DUK_ISNAN, duk_push_boolean(), and duk_to_number().
| DUK_INTERNAL duk_ret_t duk_bi_global_object_is_nan | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_float | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_int | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape | ( | duk_context * | ctx | ) |
Definition at line 37350 of file duktape.c.
References duk__encode_uricomponent_unescaped_table, duk__transform_callback_encode_uri(), and duk__transform_helper().
| DUK_INTERNAL duk_ret_t duk_bi_json_object_parse | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_json_object_stringify | ( | duk_context * | ctx | ) |
Definition at line 40580 of file duktape.c.
References duk_bi_json_parse_helper().
| DUK_INTERNAL void duk_bi_json_parse_helper | ( | duk_hthread * | thr, |
| duk_idx_t | idx_value, | ||
| duk_idx_t | idx_reviver, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 40144 of file duktape.c.
Referenced by duk_bi_json_object_stringify().
| DUK_INTERNAL void duk_bi_json_stringify_helper | ( | duk_hthread * | thr, |
| duk_idx_t | idx_value, | ||
| duk_idx_t | idx_replacer, | ||
| duk_idx_t | idx_space, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_clz32 | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_hypot | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_imul | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_max | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_min | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared | ( | duk_context * | ctx | ) |
Definition at line 40890 of file duktape.c.
References duk__atan2_fixed(), and duk_js_arith_pow().
| DUK_INTERNAL duk_ret_t duk_bi_math_object_random | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_sign | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_native_function_length | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_native_function_name | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_byte_length | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_concat | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_copy | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_fill | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_buffer | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_encoding | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tojson | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_write | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_check_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_exponential | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_fixed | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_locale_string | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_precision | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_string | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_number_prototype_value_of | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor | ( | duk_context * | ctx | ) |
Definition at line 41374 of file duktape.c.
References DUK_HTHREAD_THIS_PTR, and duk_push_class_string_tval().
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_assign | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_properties | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_property | ( | duk_context * | ctx | ) |
Definition at line 41809 of file duktape.c.
References DUK_DCERROR_TYPE_INVALID_ARGS.
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor | ( | duk_context * | ctx | ) |
Definition at line 41884 of file duktape.c.
References duk_push_hobject().
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_extensible | ( | duk_context * | ctx | ) |
Definition at line 41900 of file duktape.c.
References duk_to_object().
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared | ( | duk_context * | ctx | ) |
Definition at line 41570 of file duktape.c.
References DUK_ASSERT_TOP, duk_get_current_magic(), and duk_seal_freeze_raw().
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_constructor_seal_freeze_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared | ( | duk_context * | ctx | ) |
Definition at line 41659 of file duktape.c.
References duk_hobject_object_ownprop_helper(), and DUK_PROPDESC_FLAG_ENUMERABLE.
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_defineaccessor | ( | duk_context * | ctx | ) |
Definition at line 42064 of file duktape.c.
References duk_push_true().
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_has_own_property | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_lookupaccessor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_property_is_enumerable | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_locale_string | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_string | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_prototype_value_of | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_performance_now | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_pointer_constructor | ( | duk_context * | ctx | ) |
Definition at line 42153 of file duktape.c.
References DUK_ASSERT, DUK_BIDX_POINTER_PROTOTYPE, duk_get_top(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_POINTER, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_FASTREFS, duk_is_constructor_call(), duk_is_pointer(), duk_push_object_helper(), duk_push_pointer(), duk_set_top(), and duk_to_pointer().
| DUK_INTERNAL duk_ret_t duk_bi_pointer_prototype_tostring_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_reflect_apply | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_reflect_construct | ( | duk_context * | ctx | ) |
Definition at line 36374 of file duktape.c.
References DUK_RET_TYPE_ERROR, and DUK_UNREF.
| DUK_INTERNAL duk_ret_t duk_bi_reflect_object_delete_property | ( | duk_context * | ctx | ) |
Definition at line 42370 of file duktape.c.
References DUK_ASSERT_TOP, and duk_require_hobject().
| DUK_INTERNAL duk_ret_t duk_bi_reflect_object_get | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_reflect_object_has | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_reflect_object_set | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor | ( | duk_context * | ctx | ) |
Definition at line 42477 of file duktape.c.
References DUK_ASSERT, DUK_HOBJECT_CLASS_REGEXP, duk_insert(), duk_push_this(), duk_require_hobject_with_class(), and DUK_UNREF.
| DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_flags | ( | duk_context * | ctx | ) |
Definition at line 42585 of file duktape.c.
References DUK_ASSERT_TOP, duk_concat(), duk_dup_m2(), duk_get_prop_stridx(), duk_push_literal, duk_push_this(), DUK_STRIDX_FLAGS, and DUK_STRIDX_SOURCE.
| DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_shared_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test | ( | duk_context * | ctx | ) |
Definition at line 42558 of file duktape.c.
References duk__get_this_regexp(), and duk_regexp_match().
| DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_tostring | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_code_point | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_caseconv_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_at | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_code_at | ( | duk_context * | ctx | ) |
Definition at line 42981 of file duktape.c.
References duk_push_hstring_empty().
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_concat | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_includes | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_indexof_shared | ( | duk_context * | ctx | ) |
Definition at line 43159 of file duktape.c.
References duk_get_current_magic(), duk_push_this_coercible_to_string(), and duk_unicode_case_convert_string().
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_locale_compare | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match | ( | duk_context * | ctx | ) |
Definition at line 43939 of file duktape.c.
References duk_push_int().
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_repeat | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace | ( | duk_context * | ctx | ) |
Definition at line 43204 of file duktape.c.
References DUK_ASC_0, DUK_ASC_9, DUK_ASC_AMP, DUK_ASC_DOLLAR, DUK_ASC_GRAVE, DUK_ASC_SINGLEQUOTE, DUK_ASSERT, DUK_ASSERT_TOP, DUK_BW_COMPACT, DUK_BW_INIT_PUSHBUF, DUK_BW_WRITE_ENSURE_BYTES, DUK_BW_WRITE_ENSURE_HSTRING, DUK_BW_WRITE_ENSURE_U8, duk_call(), DUK_DCERROR_UNSUPPORTED, DUK_DDD, DUK_DDDPRINT, duk_dup_0(), duk_dup_1(), duk_dup_2(), duk_get_hobject_with_class(), duk_get_length(), duk_get_prop_index(), duk_get_prop_stridx_boolean(), duk_get_prop_stridx_short, duk_get_top(), duk_get_uint(), duk_heap_strcache_offset_char2byte(), DUK_HOBJECT_CLASS_REGEXP, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_CHARLEN, DUK_HSTRING_GET_DATA, DUK_INT_MAX, duk_is_function(), duk_is_number(), duk_is_object(), duk_is_string(), duk_known_hstring(), duk_memcmp(), duk_pop(), duk_push_int(), duk_push_this_coercible_to_string(), duk_push_uint(), duk_put_prop_stridx_short, duk_regexp_match(), duk_require_stack(), DUK_STRIDX_GLOBAL, DUK_STRIDX_INDEX, DUK_STRIDX_LAST_INDEX, duk_to_hstring(), duk_to_hstring_m1(), and duk_to_string().
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_slice | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_split | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_startswith_endswith | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substring | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_to_string | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_string_prototype_trim | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_symbol_constructor_shared | ( | duk_context * | ctx | ) |
Definition at line 44309 of file duktape.c.
References DUK_ASSERT, duk_get_current_magic(), duk_is_undefined(), duk_memcpy_unsafe, duk_push_fixed_buffer, DUK_SPRINTF, duk_to_lstring(), duk_hthread::heap, and duk_heap::sym_counter.
| DUK_INTERNAL duk_ret_t duk_bi_symbol_key_for | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_symbol_toprimitive | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_symbol_tostring_shared | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_textdecoder_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_textdecoder_prototype_decode | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_textdecoder_prototype_shared_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_textencoder_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_textencoder_prototype_encode | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_textencoder_prototype_encoding_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_thread_constructor | ( | duk_context * | ctx | ) |
Definition at line 44480 of file duktape.c.
References DUK_ASSERT, DUK_HTHREAD_STATE_INACTIVE, duk_known_hobject(), duk_push_hobject(), duk_push_thread, duk_require_callable, duk_require_hobject_promote_lfunc, and duk_hthread::state.
| DUK_INTERNAL duk_ret_t duk_bi_thread_current | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_thread_resume | ( | duk_context * | ctx | ) |
Definition at line 44522 of file duktape.c.
References duk_hthread::callstack_curr, duk_hthread::callstack_top, duk_heap::curr_thread, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_TOP, DUK_D, DUK_DCERROR_TYPE_INVALID_STATE, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_err_augment_error_throw(), duk_err_longjmp(), duk_get_top(), duk_get_tval(), DUK_GET_TVAL_NEGIDX, DUK_HOBJECT_IS_CALLABLE, DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_IS_NATFUNC, DUK_HTHREAD_STATE_INACTIVE, DUK_HTHREAD_STATE_RUNNING, DUK_HTHREAD_STATE_YIELDED, DUK_LJ_TYPE_RESUME, duk_pop(), duk_push_tval(), duk_require_hobject(), duk_require_hthread(), duk_resolve_nonbound_function(), duk_to_boolean_top_pop(), DUK_TVAL_CHKFAST_INPLACE_SLOW, DUK_TVAL_SET_TVAL_UPDREF, DUK_UNREACHABLE, duk_hthread::heap, duk_ljstate::iserror, duk_ljstate::jmpbuf_ptr, duk_heap::lj, duk_heap::ms_running, duk_activation::parent, duk_hthread::state, duk_ljstate::type, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_top, duk_ljstate::value1, and duk_ljstate::value2.
| DUK_INTERNAL duk_ret_t duk_bi_thread_yield | ( | duk_context * | ctx | ) |
Definition at line 44686 of file duktape.c.
References duk_hthread::callstack_curr, duk_hthread::callstack_preventcount, duk_hthread::callstack_top, duk_heap::curr_thread, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_TOP, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_err_augment_error_throw(), duk_get_top(), duk_get_tval(), DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_IS_NATFUNC, DUK_HTHREAD_STATE_RESUMED, DUK_HTHREAD_STATE_RUNNING, DUK_LJ_TYPE_YIELD, duk_to_boolean_top_pop(), DUK_TVAL_CHKFAST_INPLACE_SLOW, DUK_TVAL_SET_TVAL_UPDREF, duk_hthread::heap, duk_ljstate::iserror, duk_heap::lj, duk_activation::parent, duk_hthread::resumer, duk_hthread::state, duk_ljstate::type, duk_hthread::valstack_bottom, duk_hthread::valstack_top, and duk_ljstate::value1.
| DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower | ( | duk_context * | ctx | ) |
Definition at line 44799 of file duktape.c.
References duk_push_current_thread().
| DUK_INTERNAL duk_ret_t duk_bi_typedarray_buffer_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_typedarray_bytelength_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_typedarray_byteoffset_getter | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_typedarray_set | ( | duk_context * | ctx | ) |
Definition at line 29383 of file duktape.c.
References duk_hbufobj::buf, duk__buffer_elemtype_copy_compatible, duk__require_bufobj_this(), DUK_ASSERT, DUK_ASSERT_TOP, DUK_DCERROR_RANGE_INVALID_ARGS, DUK_DCERROR_TYPE_INVALID_ARGS, DUK_DDD, DUK_DDDPRINT, duk_get_length(), duk_get_prop_index(), duk_get_top(), DUK_HBUFOBJ_ASSERT_VALID, DUK_HBUFOBJ_GET_SLICE_BASE, duk_hbufobj_promote_plain(), duk_hbufobj_push_validated_read(), DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL, DUK_HBUFOBJ_VALID_SLICE, duk_hbufobj_validated_write(), DUK_HOBJECT_IS_BUFOBJ, duk_memcpy_unsafe, duk_memmove_unsafe, duk_pop(), duk_push_fixed_buffer_nozero(), duk_push_this(), duk_put_prop_index(), duk_require_hobject(), duk_to_int(), duk_hbufobj::elem_type, duk_hthread::heap, duk_hbufobj::length, and duk_hbufobj::shift.
| DUK_INTERNAL duk_ret_t duk_bi_uint8array_allocplain | ( | duk_context * | ctx | ) |
| DUK_INTERNAL duk_ret_t duk_bi_uint8array_plainof | ( | duk_context * | ctx | ) |
Definition at line 28937 of file duktape.c.
References duk__hbufobj_fixed_from_argvalue().
| DUK_EXTERNAL const char * duk_buffer_to_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL void duk_bw_compact | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw_ctx | ||
| ) |
Definition at line 100230 of file duktape.c.
References DUK_ASSERT.
| DUK_INTERNAL void duk_bw_init | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw_ctx, | ||
| duk_hbuffer_dynamic * | h_buf | ||
| ) |
| DUK_INTERNAL void duk_bw_init_pushbuf | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw_ctx, | ||
| duk_size_t | buf_size | ||
| ) |
| DUK_INTERNAL 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 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 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 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 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 100268 of file duktape.c.
References duk_bufwriter_ctx::buf, duk__bw_update_ptrs(), DUK_ASSERT, duk_hbuffer_resize(), DUK_UNREF, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.
| DUK_INTERNAL void duk_bw_insert_raw_slice | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw, | ||
| duk_size_t | dst_off, | ||
| duk_size_t | src_off, | ||
| duk_size_t | len | ||
| ) |
Definition at line 100306 of file duktape.c.
References DUK_ASSERT, DUK_BW_GET_SIZE, duk_memcpy_unsafe, duk_memmove_unsafe, DUK_UNREF, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.
| DUK_INTERNAL void duk_bw_remove_raw_slice | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw, | ||
| duk_size_t | off, | ||
| duk_size_t | len | ||
| ) |
| DUK_INTERNAL duk_uint8_t * duk_bw_resize | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw_ctx, | ||
| duk_size_t | sz | ||
| ) |
Definition at line 100192 of file duktape.c.
References duk_bufwriter_ctx::buf, DUK_ASSERT, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR, DUK_HBUFFER_DYNAMIC_GET_SIZE, DUK_UNREF, duk_hthread::heap, duk_bufwriter_ctx::p, duk_bufwriter_ctx::p_base, and duk_bufwriter_ctx::p_limit.
| DUK_INTERNAL void duk_bw_write_ensure_slice | ( | duk_hthread * | thr, |
| duk_bufwriter_ctx * | bw, | ||
| duk_size_t | src_off, | ||
| duk_size_t | len | ||
| ) |
| DUK_INTERNAL 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 100242 of file duktape.c.
References DUK_ERROR_RANGE, DUK_STR_BUFFER_TOO_LONG, and DUK_WO_NORETURN.
| DUK_EXTERNAL void duk_call | ( | duk_hthread * | thr, |
| duk_idx_t | nargs | ||
| ) |
Definition at line 15320 of file duktape.c.
Referenced by duk_bi_string_prototype_replace(), and dukky_populate_object().
| DUK_INTERNAL void duk_call_construct_postprocess | ( | duk_hthread * | thr, |
| duk_small_uint_t | proxy_invariant | ||
| ) |
Definition at line 66568 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_EXTERNAL void duk_call_method | ( | duk_hthread * | thr, |
| duk_idx_t | nargs | ||
| ) |
Definition at line 15335 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_join_shared(), and duk_hobject_putprop().
| DUK_EXTERNAL void duk_call_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_idx_t | nargs | ||
| ) |
| DUK_INTERNAL DUK_NOINLINE DUK_COLD void duk_call_setup_propcall_error | ( | duk_hthread * | thr, |
| duk_tval * | tv_base, | ||
| duk_tval * | tv_key | ||
| ) |
| DUK_EXTERNAL void duk_cbor_decode | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | decode_flags | ||
| ) |
| DUK_EXTERNAL void duk_cbor_encode | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | encode_flags | ||
| ) |
Definition at line 32613 of file duktape.c.
References DUK_ERROR_UNSUPPORTED, and DUK_UNREF.
| DUK_EXTERNAL duk_codepoint_t duk_char_code_at | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t | char_offset | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_check_stack | ( | duk_hthread * | thr, |
| duk_idx_t | extra | ||
| ) |
Definition at line 19657 of file duktape.c.
Referenced by duk_hobject_realloc_props().
| DUK_EXTERNAL duk_bool_t duk_check_stack_top | ( | duk_hthread * | thr, |
| duk_idx_t | top | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_check_type | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | type | ||
| ) |
Definition at line 22591 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_EXTERNAL duk_bool_t duk_check_type_mask | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | mask | ||
| ) |
Definition at line 22647 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_get_tval_or_unused(), and duk_get_type_mask_tval().
Referenced by duk_get_buffer_default(), duk_opt_string(), and duk_require_buffer_data().
| DUK_INTERNAL void duk_clear_prototype | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18577 of file duktape.c.
References DUK_ERROR_TYPE, DUK_STR_NOT_CONFIGURABLE, and DUK_WO_NORETURN.
| DUK_EXTERNAL void duk_compact | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
| DUK_INTERNAL void duk_compact_m1 | ( | duk_hthread * | thr | ) |
Definition at line 18260 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_get_hobject().
Referenced by duk__load_func().
| DUK_EXTERNAL duk_int_t duk_compile_raw | ( | duk_hthread * | thr, |
| const char * | src_buffer, | ||
| duk_size_t | src_length, | ||
| duk_uint_t | flags | ||
| ) |
| DUK_EXTERNAL duk_double_t duk_components_to_time | ( | duk_hthread * | thr, |
| duk_time_components * | comp | ||
| ) |
| DUK_EXTERNAL void duk_concat | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 25701 of file duktape.c.
Referenced by duk_bi_regexp_prototype_flags(), and dukky_get_current_value_of_event_handler().
| DUK_INTERNAL void duk_concat_2 | ( | duk_hthread * | thr | ) |
Definition at line 25713 of file duktape.c.
References count(), duk__concat_and_join_helper(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL void duk_config_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| void * | ptr, | ||
| duk_size_t | len | ||
| ) |
| DUK_EXTERNAL void duk_copy | ( | duk_hthread * | thr, |
| duk_idx_t | from_idx, | ||
| duk_idx_t | to_idx | ||
| ) |
| DUK_INTERNAL void duk_copy_tvals_incref | ( | duk_hthread * | thr, |
| duk_tval * | tv_dst, | ||
| duk_tval * | tv_src, | ||
| duk_size_t | count | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_create_activation_environment_record | ( | duk_hthread * | thr, |
| duk_hobject * | func, | ||
| duk_size_t | bottom_byteoff | ||
| ) |
| DUK_EXTERNAL duk_hthread * 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 17094 of file duktape.c.
Referenced by js_newheap().
| DUK_INTERNAL DUK_INLINE void duk_dblunion_big_to_host | ( | duk_double_union * | u | ) |
| DUK_INTERNAL DUK_INLINE void duk_dblunion_host_to_big | ( | duk_double_union * | u | ) |
Definition at line 100864 of file duktape.c.
Referenced by duk_raw_write_cesu8().
| DUK_INTERNAL DUK_INLINE void duk_dblunion_host_to_little | ( | duk_double_union * | u | ) |
| DUK_INTERNAL DUK_INLINE void duk_dblunion_little_to_host | ( | duk_double_union * | u | ) |
| DUK_EXTERNAL void duk_debugger_attach | ( | duk_hthread * | thr, |
| 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_cooperate | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_debugger_detach | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL duk_bool_t duk_debugger_notify | ( | duk_hthread * | thr, |
| duk_idx_t | nvalues | ||
| ) |
Definition at line 17055 of file duktape.c.
References DUK_ASSERT_API_ENTRY, DUK_ERROR_TYPE, and DUK_WO_NORETURN.
| DUK_EXTERNAL void duk_debugger_pause | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_decode_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_decode_char_function | callback, | ||
| void * | udata | ||
| ) |
Definition at line 25762 of file duktape.c.
References count(), duk__concat_and_join_helper(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL void duk_def_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uint_t | flags | ||
| ) |
Definition at line 18169 of file duktape.c.
Referenced by duk_proxy_ownkeys_postprocess().
| DUK_INTERNAL void * duk_default_alloc_function | ( | void * | udata, |
| duk_size_t | size | ||
| ) |
| DUK_INTERNAL DUK_COLD void duk_default_fatal_handler | ( | void * | udata, |
| const char * | msg | ||
| ) |
Definition at line 12599 of file duktape.c.
References DUK_ERR_TYPE_ERROR.
| DUK_INTERNAL void duk_default_free_function | ( | void * | udata, |
| void * | ptr | ||
| ) |
| DUK_INTERNAL void * duk_default_realloc_function | ( | void * | udata, |
| void * | ptr, | ||
| duk_size_t | newsize | ||
| ) |
Definition at line 14328 of file duktape.c.
References DUK_ANSI_MALLOC, and DUK_UNREF.
| DUK_EXTERNAL duk_bool_t duk_del_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
Definition at line 17899 of file duktape.c.
Referenced by js_event_cleanup().
| DUK_EXTERNAL duk_bool_t duk_del_prop_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| void * | ptr | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_del_prop_index | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uarridx_t | arr_idx | ||
| ) |
Definition at line 17952 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_push_literal_raw(), and duk_require_normalize_index().
Referenced by duk_bi_array_prototype_splice(), dukky_destroythread(), and dukky_shuffle_array().
| DUK_EXTERNAL duk_bool_t duk_del_prop_literal_raw | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_del_prop_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_del_prop_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_del_prop_string | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key | ||
| ) |
Definition at line 17922 of file duktape.c.
Referenced by js_newthread().
| DUK_EXTERNAL void duk_destroy_heap | ( | duk_hthread * | thr | ) |
Definition at line 17145 of file duktape.c.
Referenced by dukky_destroyheap().
| DUK_INTERNAL DUK_INLINE duk_double_t duk_double_div | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
Definition at line 100798 of file duktape.c.
References duk_double_union::d, DUK_DBLUNION_HAS_SIGNBIT, duk_double_equals(), and duk_double_to_int32_t().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_bool_t duk_double_equals | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
Definition at line 100925 of file duktape.c.
Referenced by duk__js_samevalue_number(), duk_double_div(), and duk_is_whole_get_int32().
| DUK_INTERNAL duk_double_t duk_double_fmax | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
| DUK_INTERNAL duk_double_t duk_double_fmin | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_double_is_anyinf | ( | duk_double_t | x | ) |
Definition at line 100600 of file duktape.c.
References DUK_ASSERT, and DUK_ISNAN.
| DUK_INTERNAL duk_bool_t duk_double_is_finite | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_is_integer | ( | duk_double_t | x | ) |
Definition at line 100742 of file duktape.c.
References duk_double_signbit(), DUK_FABS, and DUK_FLOOR.
| DUK_INTERNAL duk_bool_t duk_double_is_nan | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_is_nan_or_inf | ( | duk_double_t | x | ) |
Definition at line 100638 of file duktape.c.
References duk_double_union::d, and DUK_DBLUNION_IS_ANYINF.
Referenced by duk_is_whole_get_int32().
| DUK_INTERNAL duk_bool_t duk_double_is_nan_or_zero | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_is_nan_zero_inf | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_is_neginf | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_is_posinf | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_is_safe_integer | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_bool_t duk_double_same_sign | ( | duk_double_t | x, |
| duk_double_t | y | ||
| ) |
Definition at line 100711 of file duktape.c.
Referenced by duk_js_equals_helper().
| DUK_INTERNAL duk_small_uint_t duk_double_signbit | ( | duk_double_t | x | ) |
Definition at line 100695 of file duktape.c.
Referenced by duk_double_is_integer().
| DUK_INTERNAL duk_float_t duk_double_to_float_t | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_int32_t duk_double_to_int32_t | ( | duk_double_t | x | ) |
Definition at line 100511 of file duktape.c.
Referenced by duk_double_div().
| DUK_INTERNAL duk_int_t duk_double_to_int_t | ( | duk_double_t | x | ) |
Definition at line 100492 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_INTERNAL duk_uint32_t duk_double_to_uint32_t | ( | duk_double_t | x | ) |
| DUK_INTERNAL duk_uint_t duk_double_to_uint_t | ( | duk_double_t | x | ) |
Definition at line 100503 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_INTERNAL duk_double_t duk_double_trunc_towards_zero | ( | duk_double_t | x | ) |
| DUK_EXTERNAL void duk_dump_function | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_dup | ( | duk_hthread * | thr, |
| duk_idx_t | from_idx | ||
| ) |
Definition at line 19777 of file duktape.c.
Referenced by duk__load_func(), duk_bi_array_prototype_splice(), duk_dup_m2(), duk_dup_m3(), duk_dup_m4(), duk_lexer_parse_js_input_element(), dukky_event_target_push_listeners(), dukky_generic_event_handler(), dukky_populate_object(), dukky_push_event(), dukky_push_node(), and dukky_push_node_stacked().
| DUK_INTERNAL void duk_dup_0 | ( | duk_hthread * | thr | ) |
Definition at line 19815 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_join_shared(), and duk_bi_string_prototype_replace().
| DUK_INTERNAL void duk_dup_1 | ( | duk_hthread * | thr | ) |
Definition at line 19819 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), and duk_bi_string_prototype_replace().
| DUK_INTERNAL void duk_dup_2 | ( | duk_hthread * | thr | ) |
Definition at line 19823 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), and duk_bi_string_prototype_replace().
| DUK_INTERNAL void duk_dup_m2 | ( | duk_hthread * | thr | ) |
Definition at line 19827 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_dup().
Referenced by duk__finalize_helper(), duk__load_func(), duk_bi_array_prototype_iter_shared(), duk_bi_regexp_prototype_flags(), and duk_hobject_get_enumerated_keys().
| DUK_INTERNAL void duk_dup_m3 | ( | duk_hthread * | thr | ) |
Definition at line 19831 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_dup().
Referenced by duk_bi_array_prototype_iter_shared().
| DUK_INTERNAL void duk_dup_m4 | ( | duk_hthread * | thr | ) |
Definition at line 19835 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_dup().
Referenced by duk_hobject_putprop().
| DUK_EXTERNAL void duk_dup_top | ( | duk_hthread * | thr | ) |
Definition at line 19792 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__parse_var_decl(), duk_bi_array_prototype_iter_shared(), duk_get_prop_desc(), and dukky_dump_error().
| DUK_EXTERNAL void duk_enum | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uint_t | enum_flags | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_equals | ( | duk_hthread * | thr, |
| duk_idx_t | idx1, | ||
| duk_idx_t | idx2 | ||
| ) |
| DUK_INTERNAL void duk_err_augment_error_create | ( | duk_hthread * | thr, |
| duk_hthread * | thr_callstack, | ||
| const char * | filename, | ||
| duk_int_t | line, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 49511 of file duktape.c.
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, and duk_hobject_prototype_chain_contains().
Referenced by duk_bi_error_prototype_to_string().
| DUK_INTERNAL void duk_err_augment_error_throw | ( | duk_hthread * | thr | ) |
Definition at line 49570 of file duktape.c.
Referenced by duk_bi_thread_resume(), duk_bi_thread_yield(), duk_err_create_and_throw(), and duk_throw_raw().
| 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 49879 of file duktape.c.
References duk_hthread::builtins, duk_heap::creating_error, DUK_ASSERT, DUK_ASSERT_LJSTATE_UNSET, DUK_BIDX_DOUBLE_ERROR, DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_err_augment_error_throw(), duk_err_create_and_throw(), duk_err_setup_ljstate1(), DUK_ERRCODE_FLAG_NOBLAME_FILELINE, duk_get_tval(), DUK_GET_TVAL_NEGIDX, duk_hthread_sync_and_null_currpc(), DUK_INTERNAL, DUK_LJ_TYPE_THROW, duk_push_error_object_raw(), duk_require_stack(), DUK_TVAL_SET_I32, DUK_TVAL_SET_OBJECT, duk_hthread::heap, and line().
Referenced by duk_err_create_and_throw().
| DUK_INTERNAL DUK_COLD void duk_err_error | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber, | ||
| const char * | message | ||
| ) |
| DUK_INTERNAL DUK_COLD void duk_err_error_alloc_failed | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber | ||
| ) |
| DUK_INTERNAL DUK_COLD void duk_err_error_internal | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber | ||
| ) |
Definition at line 12536 of file duktape.c.
References DUK_ERROR_RAW_FMT3.
| DUK_INTERNAL DUK_COLD void duk_err_handle_error | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_uint_t | line_and_code, | ||
| const char * | msg | ||
| ) |
| DUK_INTERNAL DUK_COLD 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_longjmp | ( | duk_hthread * | thr | ) |
Definition at line 49620 of file duktape.c.
Referenced by duk_bi_thread_resume().
| DUK_INTERNAL DUK_COLD void duk_err_range | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber, | ||
| const char * | message | ||
| ) |
| DUK_INTERNAL DUK_COLD void duk_err_range_index | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber, | ||
| duk_idx_t | idx | ||
| ) |
Definition at line 12548 of file duktape.c.
References DUK_ERR_ERROR, DUK_ERROR_RAW, and DUK_STR_INTERNAL_ERROR.
| DUK_INTERNAL DUK_COLD void duk_err_range_push_beyond | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber | ||
| ) |
Definition at line 12551 of file duktape.c.
References DUK_ERR_ERROR, DUK_ERROR_RAW, and DUK_STR_ALLOC_FAILED.
| DUK_INTERNAL DUK_COLD void duk_err_require_type_index | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber, | ||
| duk_idx_t | idx, | ||
| const char * | expect_name | ||
| ) |
Definition at line 12521 of file duktape.c.
References DUK_ERR_TYPE_ERROR, and DUK_ERROR_RAW_FMT3.
| DUK_INTERNAL void duk_err_setup_ljstate1 | ( | duk_hthread * | thr, |
| duk_small_uint_t | lj_type, | ||
| duk_tval * | tv_val | ||
| ) |
Definition at line 49840 of file duktape.c.
Referenced by duk_err_create_and_throw(), and duk_throw_raw().
| DUK_INTERNAL DUK_COLD void duk_err_type_invalid_args | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber | ||
| ) |
Definition at line 12554 of file duktape.c.
References DUK_ERR_ERROR, and DUK_ERROR_RAW.
| DUK_INTERNAL DUK_COLD void duk_err_type_invalid_state | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber | ||
| ) |
Definition at line 12557 of file duktape.c.
References DUK_ERR_RANGE_ERROR, and DUK_ERROR_RAW.
| DUK_INTERNAL DUK_COLD void duk_err_type_invalid_trap_result | ( | duk_hthread * | thr, |
| const char * | filename, | ||
| duk_int_t | linenumber | ||
| ) |
Definition at line 12560 of file duktape.c.
References DUK_ERR_RANGE_ERROR, and DUK_ERROR_RAW_FMT1.
| DUK_INTERNAL duk_hobject * duk_error_prototype_from_code | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code | ||
| ) |
| DUK_EXTERNAL void duk_error_raw | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | filename, | ||
| duk_int_t | line, | ||
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 25104 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_push_error_object_va_raw(), duk_throw, DUK_WO_NORETURN, and line().
| DUK_EXTERNAL duk_ret_t duk_error_stash | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | fmt, | ||
| ... | |||
| ) |
| DUK_INTERNAL void duk_error_throw_from_negative_rc | ( | duk_hthread * | thr, |
| duk_ret_t | rc | ||
| ) |
Definition at line 49998 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_EXTERNAL void duk_error_va_raw | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | filename, | ||
| duk_int_t | line, | ||
| const char * | fmt, | ||
| va_list | ap | ||
| ) |
| DUK_EXTERNAL duk_ret_t duk_eval_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
| DUK_EXTERNAL duk_int_t duk_eval_raw | ( | duk_hthread * | thr, |
| const char * | src_buffer, | ||
| duk_size_t | src_length, | ||
| duk_uint_t | flags | ||
| ) |
| DUK_EXTERNAL void duk_fatal_raw | ( | duk_hthread * | thr, |
| const char * | err_msg | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_bool_t duk_float_equals | ( | duk_float_t | x, |
| duk_float_t | y | ||
| ) |
| DUK_INTERNAL DUK_INLINE void duk_fltunion_big_to_host | ( | duk_float_union * | u | ) |
| DUK_INTERNAL DUK_INLINE void duk_fltunion_host_to_big | ( | duk_float_union * | u | ) |
| DUK_EXTERNAL void duk_free | ( | duk_hthread * | thr, |
| void * | ptr | ||
| ) |
Definition at line 17588 of file duktape.c.
References DUK_ASSERT_API_ENTRY, DUK_REALLOC_RAW, and duk_hthread::heap.
| DUK_INTERNAL void duk_free_hbuffer | ( | duk_heap * | heap, |
| duk_hbuffer * | h | ||
| ) |
| DUK_INTERNAL void duk_free_hobject | ( | duk_heap * | heap, |
| duk_hobject * | h | ||
| ) |
Definition at line 50276 of file duktape.c.
References duk_hthread::callstack_curr, duk_activation::cat, DUK_ASSERT, DUK_FREE, DUK_HOBJECT_GET_PROPS, DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_IS_NATFUNC, DUK_HOBJECT_IS_THREAD, DUK_UNREF, duk_activation::parent, duk_catcher::parent, and duk_hthread::valstack.
Referenced by duk_heap_process_finalize_list().
| DUK_INTERNAL void duk_free_hstring | ( | duk_heap * | heap, |
| duk_hstring * | h | ||
| ) |
Definition at line 50344 of file duktape.c.
References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, DUK_FREE, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR, DUK_HBUFFER_HAS_DYNAMIC, and DUK_HBUFFER_HAS_EXTERNAL.
| DUK_EXTERNAL void duk_free_raw | ( | duk_hthread * | thr, |
| void * | ptr | ||
| ) |
| DUK_EXTERNAL void duk_freeze | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
| DUK_EXTERNAL void duk_gc | ( | duk_hthread * | thr, |
| duk_uint_t | flags | ||
| ) |
Definition at line 17625 of file duktape.c.
Referenced by dukky_destroythread().
| DUK_EXTERNAL duk_ret_t duk_generic_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_boolean | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_boolean_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_bool_t | def_value | ||
| ) |
| DUK_INTERNAL duk_tval * duk_get_borrowed_this_tval | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void * duk_get_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size | ||
| ) |
| DUK_EXTERNAL void * duk_get_buffer_data | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size | ||
| ) |
| DUK_EXTERNAL void * duk_get_buffer_data_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| void * | def_ptr, | ||
| duk_size_t | def_size | ||
| ) |
Definition at line 20786 of file duktape.c.
References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_BUFFER, and DUK_WO_NORETURN.
| DUK_INTERNAL void * duk_get_buffer_data_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| void * | def_ptr, | ||
| duk_size_t | def_len, | ||
| duk_bool_t | throw_flag, | ||
| duk_bool_t * | out_isbuffer | ||
| ) |
Definition at line 20714 of file duktape.c.
References duk__get_buffer_helper(), and DUK_ASSERT_API_ENTRY.
Referenced by duk__prep_codec_arg().
| DUK_EXTERNAL void * duk_get_buffer_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| void * | def_ptr, | ||
| duk_size_t | def_len | ||
| ) |
Definition at line 20693 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_check_type_mask(), duk_require_buffer(), DUK_TYPE_MASK_NONE, and DUK_TYPE_MASK_UNDEFINED.
| DUK_EXTERNAL duk_c_function duk_get_c_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_c_function duk_get_c_function_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_c_function | def_value | ||
| ) |
| DUK_INTERNAL duk_small_uint_t duk_get_class_number | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_hthread * duk_get_context | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_hthread * duk_get_context_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_hthread * | def_value | ||
| ) |
| DUK_EXTERNAL duk_int_t duk_get_current_magic | ( | duk_hthread * | thr | ) |
Definition at line 15613 of file duktape.c.
References DUK_ACT_FLAG_STRICT, and duk_activation::flags.
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_join_shared(), duk_bi_boolean_prototype_tostring_shared(), duk_bi_buffer_readfield(), duk_bi_date_constructor(), duk_bi_object_constructor_is_sealed_frozen_shared(), duk_bi_string_prototype_indexof_shared(), and duk_bi_symbol_constructor_shared().
| DUK_EXTERNAL duk_errcode_t duk_get_error_code | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_get_finalizer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_global_heapptr | ( | duk_hthread * | thr, |
| void * | ptr | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_global_literal_raw | ( | duk_hthread * | thr, |
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_global_lstring | ( | duk_hthread * | thr, |
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_global_string | ( | duk_hthread * | thr, |
| const char * | key | ||
| ) |
Definition at line 18392 of file duktape.c.
Referenced by dukky_destroythread(), dukky_populate_object(), dukky_push_event(), dukky_push_generics(), dukky_push_node(), dukky_push_node_stacked(), js_closethread(), js_event_cleanup(), js_fire_event(), and js_newthread().
| DUK_INTERNAL duk_hbuffer * duk_get_hbuffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20895 of file duktape.c.
Referenced by duk_known_hnatfunc().
| DUK_INTERNAL duk_hcompfunc * duk_get_hcompfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20938 of file duktape.c.
Referenced by duk_set_length().
| DUK_EXTERNAL void * duk_get_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void * duk_get_heapptr_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| void * | def_value | ||
| ) |
| DUK_INTERNAL duk_hnatfunc * duk_get_hnatfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_get_hobject | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20877 of file duktape.c.
Referenced by duk__error_getter_helper(), duk_compact_m1(), duk_err_augment_error_create(), duk_get_type_tval(), duk_is_fixed_buffer(), and duk_known_hcompfunc().
| DUK_INTERNAL duk_hobject * duk_get_hobject_promote_mask | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | type_mask | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_get_hobject_with_class | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_small_uint_t | classnum | ||
| ) |
Definition at line 21218 of file duktape.c.
Referenced by duk_bi_string_prototype_replace().
| DUK_INTERNAL duk_hstring * duk_get_hstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20834 of file duktape.c.
Referenced by duk_known_hbuffer(), duk_proxy_ownkeys_postprocess(), and duk_push_class_string_tval().
| DUK_INTERNAL duk_hstring * duk_get_hstring_notsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20839 of file duktape.c.
Referenced by duk__error_getter_helper(), and duk_bi_global_object_eval().
| DUK_INTERNAL duk_hthread * duk_get_hthread | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20913 of file duktape.c.
Referenced by duk_opt_context().
| DUK_EXTERNAL duk_int_t duk_get_int | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20341 of file duktape.c.
Referenced by duk_bi_buffer_readfield(), duk_bi_global_object_eval(), dukky_generic_event_handler(), and dukky_populate_object().
| DUK_EXTERNAL duk_int_t duk_get_int_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | def_value | ||
| ) |
Definition at line 20353 of file duktape.c.
References duk__api_coerce_d2i(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL duk_size_t duk_get_length | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21251 of file duktape.c.
References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX, DUK_HSTRING_GET_DATA, DUK_HTHREAD_GET_STRING, DUK_STR_UNEXPECTED_TYPE, DUK_UNREF, and DUK_WO_NORETURN.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__load_func(), duk__parse_var_decl(), duk_bi_string_prototype_replace(), duk_bi_typedarray_set(), and duk_proxy_ownkeys_postprocess().
| DUK_EXTERNAL const char * duk_get_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len | ||
| ) |
| DUK_EXTERNAL const char * duk_get_lstring_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len, | ||
| const char * | def_ptr, | ||
| duk_size_t | def_len | ||
| ) |
| DUK_EXTERNAL duk_int_t duk_get_magic | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_get_memory_functions | ( | duk_hthread * | thr, |
| duk_memory_functions * | out_funcs | ||
| ) |
Definition at line 17610 of file duktape.c.
Referenced by dukky_reset_start_time().
| DUK_INTERNAL duk_bool_t duk_get_method_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
| DUK_EXTERNAL duk_double_t duk_get_now | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL duk_double_t duk_get_number | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20298 of file duktape.c.
Referenced by duk_js_tonumber().
| DUK_EXTERNAL duk_double_t duk_get_number_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_double_t | def_value | ||
| ) |
| DUK_EXTERNAL void * duk_get_pointer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void * duk_get_pointer_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| void * | def_value | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
Definition at line 17652 of file duktape.c.
References DUK_ASSERT_API_ENTRY.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk_hobject_get_enumerated_keys(), dukky_event_target_push_listeners(), dukky_get_current_value_of_event_handler(), dukky_populate_object(), dukky_push_event(), dukky_push_node(), dukky_push_node_stacked(), and js_fire_event().
| DUK_EXTERNAL void duk_get_prop_desc | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uint_t | flags | ||
| ) |
Definition at line 18161 of file duktape.c.
References DUK_ASSERT_API_ENTRY, DUK_BIDX_TYPE_ERROR_THROWER, duk_dup_top(), duk_push_hobject_bidx(), duk_push_hstring_stridx(), and duk_require_normalize_index().
| DUK_EXTERNAL duk_bool_t duk_get_prop_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| void * | ptr | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_prop_index | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uarridx_t | arr_idx | ||
| ) |
Definition at line 17705 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_push_literal_raw(), and duk_require_normalize_index().
Referenced by duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_join_shared(), duk_bi_array_prototype_splice(), duk_bi_string_prototype_replace(), duk_bi_typedarray_set(), duk_proxy_ownkeys_postprocess(), dukky_generic_event_handler(), and dukky_shuffle_array().
| DUK_EXTERNAL duk_bool_t duk_get_prop_literal_raw | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_prop_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_get_prop_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
Definition at line 17721 of file duktape.c.
Referenced by duk_bi_regexp_prototype_flags(), and duk_set_finalizer().
| DUK_INTERNAL duk_bool_t duk_get_prop_stridx_boolean | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx, | ||
| duk_bool_t * | out_has_prop | ||
| ) |
Definition at line 17734 of file duktape.c.
Referenced by duk_bi_string_prototype_replace().
| DUK_INTERNAL duk_bool_t duk_get_prop_stridx_short_raw | ( | duk_hthread * | thr, |
| duk_uint_t | packed_args | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_get_prop_string | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key | ||
| ) |
Definition at line 17675 of file duktape.c.
Referenced by duk__safe_to_stacktrace_raw(), dukky_event_target_push_listeners(), dukky_generic_event_handler(), dukky_get_current_value_of_event_handler(), dukky_populate_object(), dukky_push_generics(), dukky_register_event_listener_for(), js_fire_event(), and js_newthread().
| DUK_EXTERNAL void duk_get_prototype | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL const char * duk_get_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20443 of file duktape.c.
Referenced by duk__error_getter_helper(), and dukky_populate_object().
| DUK_EXTERNAL const char * duk_get_string_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| const char * | def_value | ||
| ) |
| DUK_INTERNAL const char * duk_get_string_notsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20520 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_EXTERNAL duk_idx_t duk_get_top | ( | duk_hthread * | thr | ) |
Definition at line 19072 of file duktape.c.
Referenced by duk__handle_call_raw(), duk__init_varmap_and_prologue_for_pass2(), duk__load_func(), duk__math_minmax(), duk_bi_array_prototype_splice(), duk_bi_global_object_eval(), duk_bi_pointer_constructor(), duk_bi_string_prototype_replace(), duk_bi_thread_resume(), duk_bi_thread_yield(), duk_bi_typedarray_set(), dukky_push_node_stacked(), js_closethread(), and js_exec().
| DUK_EXTERNAL duk_idx_t duk_get_top_index | ( | duk_hthread * | thr | ) |
Definition at line 19281 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_set_top_unsafe(), and duk_hthread::valstack_bottom.
Referenced by duk__error_getter_helper().
| DUK_INTERNAL duk_idx_t duk_get_top_index_unsafe | ( | duk_hthread * | thr | ) |
Definition at line 19300 of file duktape.c.
Referenced by duk_push_hstring().
| DUK_INTERNAL duk_idx_t duk_get_top_require_min | ( | duk_hthread * | thr, |
| duk_idx_t | min_top | ||
| ) |
Definition at line 19081 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.
| DUK_INTERNAL duk_tval * duk_get_tval | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18973 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__load_func(), duk_bi_array_prototype_join_shared(), duk_bi_boolean_prototype_tostring_shared(), duk_bi_global_object_eval(), duk_bi_thread_resume(), duk_bi_thread_yield(), duk_err_create_and_throw(), duk_hobject_define_property_helper(), duk_hobject_putprop(), duk_is_function(), duk_proxy_ownkeys_postprocess(), duk_require_tval(), and duk_throw_raw().
| DUK_INTERNAL duk_tval * duk_get_tval_or_unused | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 19008 of file duktape.c.
Referenced by duk__obj_flag_any_default_false(), duk_check_type_mask(), and duk_inspect_value().
| DUK_EXTERNAL duk_int_t duk_get_type | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22537 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_EXTERNAL duk_uint_t duk_get_type_mask | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_uint_t duk_get_type_mask_tval | ( | duk_tval * | tv | ) |
Definition at line 22597 of file duktape.c.
Referenced by duk_check_type_mask().
| DUK_INTERNAL duk_int_t duk_get_type_tval | ( | duk_tval * | tv | ) |
Definition at line 22498 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_get_hobject(), and DUK_HEAPHDR_CHECK_FLAG_BITS.
Referenced by duk_inspect_value().
| DUK_EXTERNAL duk_uint_t duk_get_uint | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20347 of file duktape.c.
Referenced by duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_uint_t duk_get_uint_default | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | def_value | ||
| ) |
Definition at line 20359 of file duktape.c.
References duk__api_coerce_d2ui(), and DUK_ASSERT_API_ENTRY.
| DUK_INTERNAL duk_int_t duk_handle_call_unprotected | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_small_uint_t | call_flags | ||
| ) |
| DUK_INTERNAL duk_int_t duk_handle_call_unprotected_nargs | ( | duk_hthread * | thr, |
| duk_idx_t | nargs, | ||
| duk_small_uint_t | call_flags | ||
| ) |
| DUK_INTERNAL duk_int_t duk_handle_safe_call | ( | duk_hthread * | thr, |
| duk_safe_call_function | func, | ||
| void * | udata, | ||
| duk_idx_t | num_stack_args, | ||
| duk_idx_t | num_stack_res | ||
| ) |
| DUK_INTERNAL duk_harray * duk_harray_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_has_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
Definition at line 17984 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), and dukky_register_event_listener_for().
| DUK_EXTERNAL duk_bool_t duk_has_prop_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| void * | ptr | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_has_prop_index | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uarridx_t | arr_idx | ||
| ) |
Definition at line 18035 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_push_literal_raw(), and duk_require_normalize_index().
| DUK_EXTERNAL duk_bool_t duk_has_prop_literal_raw | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_has_prop_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_has_prop_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
Definition at line 18051 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), and duk_xdef_prop().
| DUK_EXTERNAL duk_bool_t duk_has_prop_string | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key | ||
| ) |
| DUK_INTERNAL duk_hboundfunc * duk_hboundfunc_alloc | ( | duk_heap * | heap, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_hbuffer * duk_hbuffer_alloc | ( | duk_heap * | heap, |
| duk_size_t | size, | ||
| duk_small_uint_t | flags, | ||
| void ** | out_bufdata | ||
| ) |
| DUK_INTERNAL void * duk_hbuffer_get_dynalloc_ptr | ( | duk_heap * | heap, |
| void * | ud | ||
| ) |
Definition at line 50141 of file duktape.c.
Referenced by duk_hbuffer_resize().
| DUK_INTERNAL DUK_NOINLINE void duk_hbuffer_refzero | ( | duk_hthread * | thr, |
| duk_hbuffer * | h | ||
| ) |
| DUK_INTERNAL void duk_hbuffer_reset | ( | duk_hthread * | thr, |
| duk_hbuffer_dynamic * | buf | ||
| ) |
| DUK_INTERNAL void duk_hbuffer_resize | ( | duk_hthread * | thr, |
| duk_hbuffer_dynamic * | buf, | ||
| duk_size_t | new_size | ||
| ) |
Definition at line 50170 of file duktape.c.
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_LIKELY, duk_memzero, DUK_REALLOC_INDIRECT, DUK_WO_NORETURN, and duk_hthread::heap.
Referenced by duk__nud_array_literal(), duk_bw_insert_raw_bytes(), and duk_hbufobj_clamp_bytelength().
| DUK_INTERNAL duk_hbufobj * duk_hbufobj_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_uint_t duk_hbufobj_clamp_bytelength | ( | duk_hbufobj * | h_bufobj, |
| duk_uint_t | len | ||
| ) |
Definition at line 50239 of file duktape.c.
References DUK_ASSERT, DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, and duk_hbuffer_resize().
| DUK_INTERNAL void duk_hbufobj_promote_plain | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 28172 of file duktape.c.
Referenced by duk_bi_typedarray_set().
| DUK_INTERNAL void duk_hbufobj_push_uint8array_from_plain | ( | duk_hthread * | thr, |
| duk_hbuffer * | h_buf | ||
| ) |
| DUK_INTERNAL void duk_hbufobj_push_validated_read | ( | duk_hthread * | thr, |
| duk_hbufobj * | h_bufobj, | ||
| duk_uint8_t * | p, | ||
| duk_small_uint_t | elem_size | ||
| ) |
Definition at line 28219 of file duktape.c.
Referenced by duk__get_own_propdesc_raw(), and duk_bi_typedarray_set().
| DUK_INTERNAL void duk_hbufobj_validated_write | ( | duk_hthread * | thr, |
| duk_hbufobj * | h_bufobj, | ||
| duk_uint8_t * | p, | ||
| duk_small_uint_t | elem_size | ||
| ) |
Definition at line 28260 of file duktape.c.
Referenced by duk_bi_typedarray_set(), and duk_hobject_putprop().
| DUK_INTERNAL duk_hcompfunc * duk_hcompfunc_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_hdecenv * duk_hdecenv_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
Definition at line 56709 of file duktape.c.
References DUK_ERROR_ALLOC_FAILED, duk_hthread_alloc_unchecked(), DUK_WO_NORETURN, and duk_hthread::heap.
Referenced by duk__load_func(), and duk_bi_global_object_eval().
| DUK_INTERNAL duk_heap * duk_heap_alloc | ( | duk_alloc_function | alloc_func, |
| duk_realloc_function | realloc_func, | ||
| duk_free_function | free_func, | ||
| void * | heap_udata, | ||
| duk_fatal_function | fatal_func | ||
| ) |
| DUK_INTERNAL void duk_heap_free | ( | duk_heap * | heap | ) |
| DUK_INTERNAL void duk_heap_free_freelists | ( | duk_heap * | heap | ) |
| DUK_INTERNAL void duk_heap_free_heaphdr_raw | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
| DUK_INTERNAL duk_uint32_t duk_heap_hashstring | ( | duk_heap * | heap, |
| const duk_uint8_t * | str, | ||
| duk_size_t | len | ||
| ) |
| DUK_INTERNAL void duk_heap_insert_into_finalize_list | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
| DUK_INTERNAL void duk_heap_insert_into_heap_allocated | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
| DUK_INTERNAL void duk_heap_mark_and_sweep | ( | duk_heap * | heap, |
| duk_small_uint_t | flags | ||
| ) |
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void * duk_heap_mem_alloc | ( | duk_heap * | heap, |
| duk_size_t | size | ||
| ) |
Definition at line 53631 of file duktape.c.
References DUK_D, and DUK_DPRINT.
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void * duk_heap_mem_alloc_checked | ( | duk_hthread * | thr, |
| duk_size_t | size | ||
| ) |
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void * duk_heap_mem_alloc_checked_zeroed | ( | duk_hthread * | thr, |
| duk_size_t | size | ||
| ) |
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void * duk_heap_mem_alloc_zeroed | ( | duk_heap * | heap, |
| duk_size_t | size | ||
| ) |
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void duk_heap_mem_free | ( | duk_heap * | heap, |
| void * | ptr | ||
| ) |
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void * duk_heap_mem_realloc | ( | duk_heap * | heap, |
| void * | ptr, | ||
| duk_size_t | newsize | ||
| ) |
Definition at line 53785 of file duktape.c.
References DUK_D, and DUK_DPRINT.
| DUK_INTERNAL DUK_INLINE_PERF DUK_HOT void * duk_heap_mem_realloc_indirect | ( | duk_heap * | heap, |
| duk_mem_getptr | cb, | ||
| void * | ud, | ||
| duk_size_t | newsize | ||
| ) |
Definition at line 53909 of file duktape.c.
References DUK_D, and DUK_DPRINT.
| DUK_INTERNAL void duk_heap_process_finalize_list | ( | duk_heap * | heap | ) |
Definition at line 51611 of file duktape.c.
References count(), DUK_ASSERT, DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_free_hobject(), DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED, DUK_HEAP_REMOVE_FROM_FINALIZE_LIST, duk_heap_run_finalizer(), DUK_HEAPHDR_CLEAR_FINALIZABLE, DUK_HEAPHDR_CLEAR_FINALIZED, DUK_HEAPHDR_GET_REFCOUNT, DUK_HEAPHDR_GET_TYPE, DUK_HEAPHDR_HAS_FINALIZABLE, DUK_HEAPHDR_HAS_FINALIZED, DUK_HEAPHDR_HAS_REACHABLE, DUK_HEAPHDR_HAS_READONLY, DUK_HEAPHDR_HAS_TEMPROOT, DUK_HEAPHDR_PREDEC_REFCOUNT, duk_hobject_refcount_finalize_norz(), DUK_HTYPE_OBJECT, DUK_LIKELY, DUK_REFZERO_CHECK_SLOW, duk_heap::finalize_list, duk_heap::heap_thread, duk_heap::pf_prevent_count, duk_heap::pf_skip_finalizers, duk_heap::refzero_list, and duk_hthread::valstack.
Referenced by duk_refzero_check_slow().
| DUK_INTERNAL void duk_heap_remove_from_finalize_list | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
| DUK_INTERNAL void duk_heap_remove_from_heap_allocated | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
| DUK_INTERNAL void duk_heap_run_finalizer | ( | duk_heap * | heap, |
| duk_hobject * | obj | ||
| ) |
Definition at line 51857 of file duktape.c.
Referenced by duk_heap_process_finalize_list().
| DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte | ( | duk_hthread * | thr, |
| duk_hstring * | h, | ||
| duk_uint_fast32_t | char_offset | ||
| ) |
Definition at line 55102 of file duktape.c.
Referenced by duk_bi_string_prototype_replace().
| DUK_INTERNAL void duk_heap_strcache_string_remove | ( | duk_heap * | heap, |
| duk_hstring * | h | ||
| ) |
Definition at line 55029 of file duktape.c.
References DUK_HEAP_STRCACHE_SIZE, and duk_heap::strcache.
| DUK_INTERNAL void duk_heap_strtable_force_resize | ( | duk_heap * | heap | ) |
| DUK_INTERNAL void duk_heap_strtable_free | ( | duk_heap * | heap | ) |
| DUK_INTERNAL duk_hstring * duk_heap_strtable_intern | ( | duk_heap * | heap, |
| const duk_uint8_t * | str, | ||
| duk_uint32_t | blen | ||
| ) |
Definition at line 56052 of file duktape.c.
Referenced by duk__strtable_litcache_key().
| DUK_INTERNAL duk_hstring * duk_heap_strtable_intern_checked | ( | duk_hthread * | thr, |
| const duk_uint8_t * | str, | ||
| duk_uint32_t | len | ||
| ) |
Definition at line 56141 of file duktape.c.
References duk_lc_digits.
| DUK_INTERNAL duk_hstring * duk_heap_strtable_intern_literal_checked | ( | duk_hthread * | thr, |
| const duk_uint8_t * | str, | ||
| duk_uint32_t | blen | ||
| ) |
Definition at line 56170 of file duktape.c.
References DUK_ERROR_ALLOC_FAILED, and DUK_WO_NORETURN.
| DUK_INTERNAL duk_hstring * duk_heap_strtable_intern_u32 | ( | duk_heap * | heap, |
| duk_uint32_t | val | ||
| ) |
Definition at line 56114 of file duktape.c.
References DUK_STATS_INC.
Referenced by duk_hobject_realloc_props().
| DUK_INTERNAL duk_hstring * duk_heap_strtable_intern_u32_checked | ( | duk_hthread * | thr, |
| duk_uint32_t | val | ||
| ) |
| DUK_INTERNAL void duk_heap_strtable_unlink | ( | duk_heap * | heap, |
| duk_hstring * | h | ||
| ) |
| DUK_INTERNAL void duk_heap_strtable_unlink_prev | ( | duk_heap * | heap, |
| duk_hstring * | h, | ||
| duk_hstring * | prev | ||
| ) |
Definition at line 56289 of file duktape.c.
References DUK_ASSERT, duk_heaphdr_string::h_next, and duk_hstring::hdr.
| DUK_INTERNAL void duk_heap_switch_thread | ( | duk_heap * | heap, |
| duk_hthread * | new_thr | ||
| ) |
| DUK_INTERNAL void duk_heaphdr_refcount_finalize_norz | ( | duk_heap * | heap, |
| duk_heaphdr * | hdr | ||
| ) |
| DUK_INTERNAL DUK_NOINLINE void duk_heaphdr_refzero | ( | duk_hthread * | thr, |
| duk_heaphdr * | h | ||
| ) |
| DUK_INTERNAL DUK_NOINLINE void duk_heaphdr_refzero_norz | ( | duk_hthread * | thr, |
| duk_heaphdr * | h | ||
| ) |
| DUK_EXTERNAL void duk_hex_decode | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL const char * duk_hex_encode | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 16429 of file duktape.c.
References DUK_ERROR_UNSUPPORTED, DUK_UNREF, and DUK_WO_NORETURN.
| DUK_INTERNAL duk_hnatfunc * duk_hnatfunc_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_hobject_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_hobject_alloc_unchecked | ( | duk_heap * | heap, |
| duk_uint_t | hobject_flags | ||
| ) |
Definition at line 56544 of file duktape.c.
References duk__init_object_parts(), DUK_ALLOC_CHECKED_ZEROED, DUK_ASSERT, and duk_hthread::heap.
| DUK_INTERNAL void duk_hobject_compact_props | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_define_property_helper | ( | duk_hthread * | thr, |
| duk_uint_t | defprop_flags, | ||
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_idx_t | idx_value, | ||
| duk_hobject * | get, | ||
| duk_hobject * | set, | ||
| duk_bool_t | throw_flag | ||
| ) |
Definition at line 63200 of file duktape.c.
References duk_propdesc::a_idx, duk__abandon_array_part(), duk__get_own_propdesc_raw(), duk__handle_put_array_length_smaller(), duk__hobject_alloc_entry_checked(), duk__lookup_arguments_map(), DUK__NO_ARRAY_INDEX, duk__obtain_arridx_slot(), duk__to_new_array_length_checked(), DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, DUK_D, 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_DPRINT, duk_get_tval(), DUK_GET_TVAL_POSIDX, DUK_GETDESC_FLAG_PUSH_VALUE, DUK_HARRAY_ASSERT_VALID, DUK_HARRAY_LENGTH_NONWRITABLE, DUK_HARRAY_SET_LENGTH_NONWRITABLE, DUK_HARRAY_SET_LENGTH_WRITABLE, DUK_HEAPHDR_HAS_READONLY, DUK_HOBJECT_A_GET_VALUE_PTR, DUK_HOBJECT_DECREF_ALLOWNULL, DUK_HOBJECT_DECREF_NORZ_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_unsafe(), DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, DUK_PROPDESC_FLAGS_EC, DUK_PROPDESC_FLAGS_WEC, duk_push_u32, DUK_REFZERO_CHECK_SLOW, duk_replace(), duk_require_hstring(), duk_require_tval(), DUK_TVAL_INCREF, DUK_TVAL_IS_UNUSED, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_TVAL_UPDREF, DUK_TVAL_SET_UNDEFINED, DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ, DUK_UNREACHABLE, DUK_UNREF, duk_propdesc::e_idx, duk_propdesc::flags, duk_propdesc::get, duk_hthread::heap, duk_harray::length, and duk_propdesc::set.
| DUK_INTERNAL void duk_hobject_define_property_internal | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 62729 of file duktape.c.
Referenced by duk__declvar_helper().
| DUK_INTERNAL void duk_hobject_define_property_internal_arridx | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_uarridx_t | arr_idx, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 62862 of file duktape.c.
Referenced by duk_xdef_prop_stridx().
| DUK_INTERNAL duk_bool_t duk_hobject_delprop | ( | duk_hthread * | thr, |
| duk_tval * | tv_obj, | ||
| duk_tval * | tv_key, | ||
| duk_bool_t | throw_flag | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 62353 of file duktape.c.
References DUK_ERROR_TYPE, DUK_STR_SETTER_UNDEFINED, and DUK_WO_NORETURN.
Referenced by duk_hobject_define_property_helper(), and duk_js_delvar_activation().
| DUK_INTERNAL void duk_hobject_enumerator_create | ( | duk_hthread * | thr, |
| duk_small_uint_t | enum_flags | ||
| ) |
Definition at line 57071 of file duktape.c.
References duk_push_hstring(), duk_push_true(), and duk_put_prop().
| DUK_INTERNAL duk_bool_t duk_hobject_enumerator_next | ( | duk_hthread * | thr, |
| duk_bool_t | get_value | ||
| ) |
| DUK_INTERNAL duk_tval * duk_hobject_find_array_entry_tval_ptr | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_uarridx_t | i | ||
| ) |
Definition at line 59381 of file duktape.c.
References DUK_ASSERT, DUK_HOBJECT_E_GET_FLAGS, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR, DUK_HOBJECT_E_SLOT_IS_ACCESSOR, duk_hobject_find_entry(), and DUK_UNREF.
| DUK_INTERNAL duk_bool_t duk_hobject_find_entry | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_int_t * | e_idx, | ||
| duk_int_t * | h_idx | ||
| ) |
Definition at line 59255 of file duktape.c.
Referenced by duk__declvar_helper(), duk__get_own_propdesc_raw(), and duk_hobject_find_array_entry_tval_ptr().
| DUK_INTERNAL duk_tval * duk_hobject_find_entry_tval_ptr | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_hstring * | key | ||
| ) |
Definition at line 59335 of file duktape.c.
References DUK_DDD, and DUK_DDDPRINT.
| DUK_INTERNAL duk_tval * duk_hobject_find_entry_tval_ptr_and_attrs | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_hstring * | key, | ||
| duk_uint_t * | out_attrs | ||
| ) |
| DUK_INTERNAL duk_tval * duk_hobject_find_entry_tval_ptr_stridx | ( | duk_heap * | heap, |
| duk_hobject * | obj, | ||
| duk_small_uint_t | stridx | ||
| ) |
Definition at line 59352 of file duktape.c.
Referenced by duk__err_augment_user(), and duk_hobject_get_internal_value_string().
| DUK_INTERNAL duk_ret_t duk_hobject_get_enumerated_keys | ( | duk_hthread * | thr, |
| duk_small_uint_t | enum_flags | ||
| ) |
Definition at line 57539 of file duktape.c.
References duk_dup_m2(), duk_get_prop(), duk_push_hobject(), duk_remove(), and duk_remove_m2().
| DUK_INTERNAL duk_harray * duk_hobject_get_formals | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
Definition at line 59528 of file duktape.c.
References DUK_ASSERT, and DUK_HEAPHDR_IS_STRING.
| DUK_LOCAL duk_heaphdr * duk_hobject_get_internal_value_heaphdr | ( | duk_heap * | heap, |
| duk_hobject * | obj | ||
| ) |
| DUK_INTERNAL duk_hstring * duk_hobject_get_internal_value_string | ( | duk_heap * | heap, |
| duk_hobject * | obj | ||
| ) |
Definition at line 59505 of file duktape.c.
References duk_hobject_find_entry_tval_ptr_stridx(), and DUK_STRIDX_INT_VALUE.
Referenced by duk__get_own_propdesc_raw().
| DUK_INTERNAL duk_tval * duk_hobject_get_internal_value_tval_ptr | ( | duk_heap * | heap, |
| duk_hobject * | obj | ||
| ) |
| DUK_INTERNAL duk_size_t duk_hobject_get_length | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
| DUK_INTERNAL 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 60107 of file duktape.c.
Referenced by duk_proxy_ownkeys_postprocess().
| DUK_INTERNAL duk_hobject * duk_hobject_get_varmap | ( | duk_hthread * | thr, |
| duk_hobject * | obj | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_getprop | ( | duk_hthread * | thr, |
| duk_tval * | tv_obj, | ||
| duk_tval * | tv_key | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_has_finalizer_fast_raw | ( | duk_hobject * | obj | ) |
| DUK_INTERNAL duk_bool_t duk_hobject_hasprop | ( | duk_hthread * | thr, |
| duk_tval * | tv_obj, | ||
| duk_tval * | tv_key | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_hasprop_raw | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_hstring * | key | ||
| ) |
| DUK_INTERNAL void duk_hobject_object_get_own_property_descriptor | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
Definition at line 62984 of file duktape.c.
References DUK_D, and DUK_DPRINT.
| DUK_INTERNAL duk_bool_t duk_hobject_object_is_sealed_frozen_helper | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_bool_t | is_frozen | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_object_ownprop_helper | ( | duk_hthread * | thr, |
| duk_small_uint_t | required_desc_flags | ||
| ) |
Definition at line 64099 of file duktape.c.
References DUK_ERROR_TYPE, DUK_STR_NOT_EXTENSIBLE, and DUK_WO_NORETURN.
Referenced by duk_bi_object_getprototype_shared().
| DUK_INTERNAL void duk_hobject_object_seal_freeze_helper | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_bool_t | is_freeze | ||
| ) |
| DUK_INTERNAL void duk_hobject_pc2line_pack | ( | duk_hthread * | thr, |
| duk_compiler_instr * | instrs, | ||
| duk_uint_fast32_t | length | ||
| ) |
| DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query | ( | duk_hthread * | thr, |
| duk_idx_t | idx_func, | ||
| duk_uint_fast32_t | pc | ||
| ) |
Definition at line 57871 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_INTERNAL void duk_hobject_prepare_property_descriptor | ( | duk_hthread * | thr, |
| 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 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 57599 of file duktape.c.
Referenced by duk_err_augment_error_create().
| DUK_INTERNAL duk_bool_t duk_hobject_proxy_check | ( | duk_hobject * | obj, |
| duk_hobject ** | out_target, | ||
| duk_hobject ** | out_handler | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_hobject_putprop | ( | duk_hthread * | thr, |
| duk_tval * | tv_obj, | ||
| duk_tval * | tv_key, | ||
| duk_tval * | tv_val, | ||
| duk_bool_t | throw_flag | ||
| ) |
Definition at line 61478 of file duktape.c.
References duk_propdesc::a_idx, duk_hbufobj::buf, duk_hthread::builtins, duk__check_arguments_map_for_put(), duk__get_own_propdesc_raw(), duk__handle_put_array_length(), duk__hobject_alloc_entry_checked(), DUK__NO_ARRAY_INDEX, duk__obtain_arridx_slot(), duk__proxy_check_prop(), duk__push_tval_to_property_key(), duk__putprop_fastpath_bufobj_tval(), duk__putprop_shallow_fastpath_array_tval(), duk__tval_fastint_to_arr_idx(), duk__tval_number_to_arr_idx(), DUK__VALSTACK_SPACE, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, DUK_BIDX_BOOLEAN_PROTOTYPE, DUK_BIDX_NATIVE_FUNCTION_PROTOTYPE, DUK_BIDX_NUMBER_PROTOTYPE, DUK_BIDX_POINTER_PROTOTYPE, DUK_BIDX_STRING_PROTOTYPE, DUK_BIDX_SYMBOL_PROTOTYPE, DUK_BIDX_UINT8ARRAY_PROTOTYPE, duk_call_method(), DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, duk_dup_m4(), DUK_ERR_TYPE_ERROR, DUK_ERROR_FMT2, DUK_ERROR_RANGE, DUK_ERROR_TYPE, duk_get_tval(), DUK_GETDESC_FLAG_PUSH_VALUE, DUK_HARRAY_ASSERT_VALID, DUK_HARRAY_LENGTH_NONWRITABLE, DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_HBUFOBJ_ASSERT_VALID, DUK_HBUFOBJ_HAS_VIRTUAL_INDICES, DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL, duk_hbufobj_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_PROTOTYPE, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXOTIC_ARRAY, DUK_HOBJECT_HAS_EXTENSIBLE, DUK_HOBJECT_IS_ARRAY, DUK_HOBJECT_IS_BUFOBJ, DUK_HOBJECT_IS_PROXY, DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY, DUK_HSTRING_GET_CHARLEN, DUK_HSTRING_HAS_SYMBOL, DUK_HTHREAD_STRING_LENGTH, duk_js_samevalue, duk_pop_2_unsafe(), duk_pop_n_unsafe(), duk_pop_unsafe(), 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_STATS_INC, DUK_STR_INVALID_BASE, DUK_STR_NOT_CONFIGURABLE, DUK_STR_NOT_EXTENSIBLE, DUK_STR_NOT_WRITABLE, DUK_STR_PROTOTYPE_CHAIN_LIMIT, DUK_STR_PROXY_REJECTED, DUK_STRIDX_SET, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_FASTINT, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, duk_to_boolean_top_pop(), duk_to_number_m1(), duk_to_uint32(), DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_FASTINT_U32, DUK_TVAL_GET_OBJECT, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_INCREF, DUK_TVAL_IS_FASTINT, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_TVAL_SET_OBJECT, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_TVAL_UPDREF, DUK_UNLIKELY, DUK_UNREACHABLE, DUK_WO_NORETURN, duk_propdesc::e_idx, duk_propdesc::flags, duk_propdesc::get, duk_hthread::heap, duk_hbufobj::length, duk_harray::length, duk_hbufobj::offset, duk_propdesc::set, and duk_hbufobj::shift.
| DUK_INTERNAL void duk_hobject_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 58529 of file duktape.c.
References DUK__HASH_DELETED, DUK__HASH_UNUSED, DUK__VALSTACK_SPACE, DUK_ALLOC, DUK_ASSERT, DUK_ASSERT_VALSTACK_SPACE, duk_check_stack(), DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_ERROR_ALLOC_FAILED, DUK_ERROR_INTERNAL, DUK_FREE_CHECKED, duk_heap_strtable_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_memcpy_unsafe, duk_memset, DUK_MS_FLAG_NO_OBJECT_COMPACTION, duk_pop_n_nodecref_unsafe(), DUK_PROPDESC_FLAG_CONFIGURABLE, DUK_PROPDESC_FLAG_ENUMERABLE, DUK_PROPDESC_FLAG_WRITABLE, duk_push_hstring(), DUK_STATS_INC, DUK_TVAL_IS_UNUSED, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_UNUSED, DUK_UINT16_MAX, DUK_UNREF, DUK_WO_NORETURN, duk_hthread::heap, duk_heap::ms_base_flags, duk_heap::pf_prevent_count, and duk_propvalue::v.
Referenced by duk_push_harray_with_size_outptr().
| DUK_INTERNAL void duk_hobject_refcount_finalize_norz | ( | duk_heap * | heap, |
| duk_hobject * | h | ||
| ) |
Definition at line 54203 of file duktape.c.
References count(), DUK_ASSERT, and DUK_TVAL_DECREF_NORZ.
Referenced by duk__refcount_free_pending(), and duk_heap_process_finalize_list().
| DUK_INTERNAL DUK_NOINLINE void duk_hobject_refzero | ( | duk_hthread * | thr, |
| duk_hobject * | h | ||
| ) |
| DUK_INTERNAL DUK_NOINLINE void duk_hobject_refzero_norz | ( | duk_hthread * | thr, |
| duk_hobject * | h | ||
| ) |
Definition at line 54831 of file duktape.c.
References duk__heaphdr_refzero_helper().
| DUK_INTERNAL void duk_hobject_resize_entrypart | ( | duk_hthread * | thr, |
| duk_hobject * | obj, | ||
| duk_uint32_t | new_e_size | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_hobject_resolve_proxy_target | ( | duk_hobject * | obj | ) |
| DUK_INTERNAL void duk_hobject_set_prototype_updref | ( | duk_hthread * | thr, |
| duk_hobject * | h, | ||
| duk_hobject * | p | ||
| ) |
Definition at line 57634 of file duktape.c.
References DUK_ERROR_RANGE, DUK_HOBJECT_GET_PROTOTYPE, DUK_STR_PROTOTYPE_CHAIN_LIMIT, DUK_WO_NORETURN, and duk_hthread::heap.
| DUK_INTERNAL duk_hobjenv * duk_hobjenv_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_hproxy * duk_hproxy_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
| DUK_INTERNAL duk_ucodepoint_t duk_hstring_char_code_at_raw | ( | duk_hthread * | thr, |
| duk_hstring * | h, | ||
| duk_uint_t | pos, | ||
| duk_bool_t | surrogate_aware | ||
| ) |
Definition at line 64280 of file duktape.c.
References DUK_ASSERT.
| DUK_INTERNAL duk_bool_t duk_hstring_equals_ascii_cstring | ( | duk_hstring * | h, |
| const char * | cstr | ||
| ) |
| DUK_INTERNAL DUK_HOT duk_size_t duk_hstring_get_charlen | ( | duk_hstring * | h | ) |
| DUK_INTERNAL DUK_NOINLINE void duk_hstring_refzero | ( | duk_hthread * | thr, |
| duk_hstring * | h | ||
| ) |
| DUK_INTERNAL DUK_INLINE duk_activation * duk_hthread_activation_alloc | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL void duk_hthread_activation_free | ( | duk_hthread * | thr, |
| duk_activation * | act | ||
| ) |
Definition at line 65659 of file duktape.c.
References duk_heap::activation_free, duk__hthread_activation_alloc_slow(), DUK_ASSERT, DUK_LIKELY, duk_hthread::heap, and duk_activation::parent.
| DUK_INTERNAL void duk_hthread_activation_unwind_norz | ( | duk_hthread * | thr | ) |
Definition at line 65834 of file duktape.c.
Referenced by duk__handle_call_raw(), and duk_hthread_terminate().
| DUK_INTERNAL void duk_hthread_activation_unwind_reuse_norz | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_hthread * duk_hthread_alloc | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags | ||
| ) |
Definition at line 56688 of file duktape.c.
References duk_hthread::builtins, and DUK_NUM_BUILTINS.
| DUK_INTERNAL duk_hthread * duk_hthread_alloc_unchecked | ( | duk_heap * | heap, |
| duk_uint_t | hobject_flags | ||
| ) |
Definition at line 56645 of file duktape.c.
References duk_hbufobj::buf, duk_hbufobj::buf_prop, duk__hobject_alloc_init(), and DUK_HBUFOBJ_ASSERT_VALID.
Referenced by duk_hdecenv_alloc().
| DUK_INTERNAL DUK_INLINE duk_catcher * duk_hthread_catcher_alloc | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL void duk_hthread_catcher_free | ( | duk_hthread * | thr, |
| duk_catcher * | cat | ||
| ) |
Definition at line 65614 of file duktape.c.
References duk_heap::catcher_free, duk__hthread_catcher_alloc_slow(), DUK_ASSERT, DUK_LIKELY, duk_hthread::heap, and duk_catcher::parent.
| DUK_INTERNAL void duk_hthread_catcher_unwind_nolexenv_norz | ( | duk_hthread * | thr, |
| duk_activation * | act | ||
| ) |
| DUK_INTERNAL void duk_hthread_catcher_unwind_norz | ( | duk_hthread * | thr, |
| duk_activation * | act | ||
| ) |
| DUK_INTERNAL void duk_hthread_copy_builtin_objects | ( | duk_hthread * | thr_from, |
| duk_hthread * | thr_to | ||
| ) |
| DUK_INTERNAL void duk_hthread_create_builtin_objects | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_prev_pc | ( | duk_hthread * | thr, |
| duk_activation * | act | ||
| ) |
| DUK_INTERNAL duk_activation * duk_hthread_get_activation_for_level | ( | duk_hthread * | thr, |
| duk_int_t | level | ||
| ) |
Definition at line 65868 of file duktape.c.
Referenced by duk_bi_global_object_eval().
| DUK_INTERNAL void * duk_hthread_get_valstack_ptr | ( | duk_heap * | heap, |
| void * | ud | ||
| ) |
Definition at line 64520 of file duktape.c.
References DUK_TVAL_SET_UNDEFINED, and duk_hthread::valstack.
Referenced by duk__resize_valstack().
| DUK_INTERNAL duk_bool_t duk_hthread_init_stacks | ( | duk_heap * | heap, |
| duk_hthread * | thr | ||
| ) |
| DUK_INTERNAL void duk_hthread_sync_and_null_currpc | ( | duk_hthread * | thr | ) |
Definition at line 65508 of file duktape.c.
Referenced by duk__handle_call_raw(), duk_err_create_and_throw(), and duk_throw_raw().
| DUK_INTERNAL void duk_hthread_sync_currpc | ( | duk_hthread * | thr | ) |
Definition at line 65493 of file duktape.c.
References duk_activation::curr_pc, DUK_ASSERT, DUK_HCOMPFUNC_GET_CODE_BASE, DUK_HOBJECT_IS_COMPFUNC, DUK_UNREF, duk_activation::func, and duk_hthread::heap.
| DUK_INTERNAL void duk_hthread_terminate | ( | duk_hthread * | thr | ) |
Definition at line 65432 of file duktape.c.
References duk_hthread::callstack_curr, DUK_ASSERT, duk_hthread_activation_unwind_norz(), DUK_HTHREAD_STATE_TERMINATED, duk_set_top(), duk_hthread::state, duk_hthread::valstack, and duk_hthread::valstack_bottom.
| DUK_EXTERNAL void duk_insert | ( | duk_hthread * | thr, |
| duk_idx_t | to_idx | ||
| ) |
Definition at line 19840 of file duktape.c.
Referenced by duk__err_augment_user(), duk_bi_array_prototype_join_shared(), duk_bi_global_object_eval(), duk_bi_regexp_constructor(), duk_proxy_ownkeys_postprocess(), dukky_create_object(), dukky_event_target_push_listeners(), dukky_generic_event_handler(), dukky_get_current_value_of_event_handler(), dukky_inject_not_ctr(), dukky_populate_object(), dukky_push_node(), dukky_push_node_stacked(), and js_fire_event().
| DUK_INTERNAL void duk_insert_undefined | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL void duk_insert_undefined_n | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_idx_t | count | ||
| ) |
| DUK_EXTERNAL void duk_inspect_callstack_entry | ( | duk_hthread * | thr, |
| duk_int_t | level | ||
| ) |
| DUK_EXTERNAL void duk_inspect_value | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 17343 of file duktape.c.
References DUK__IDX_ASIZE, DUK__IDX_BCBYTES, DUK__IDX_CLASS, DUK__IDX_DBYTES, DUK__IDX_ENEXT, DUK__IDX_ESIZE, DUK__IDX_HBYTES, DUK__IDX_HSIZE, DUK__IDX_ITAG, DUK__IDX_PBYTES, DUK__IDX_REFC, DUK__IDX_TSTATE, DUK__IDX_TYPE, DUK__IDX_VARIANT, duk__inspect_multiple_uint(), DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_get_tval_or_unused(), duk_get_type_tval(), DUK_HBUFFER_GET_SIZE, DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_HCOMPFUNC_GET_DATA, DUK_HEAPHDR_GET_FLAGS, DUK_HEAPHDR_GET_REFCOUNT, DUK_HEAPHDR_GET_TYPE, DUK_HOBJECT_GET_ASIZE, DUK_HOBJECT_GET_CLASS_NUMBER, DUK_HOBJECT_GET_ENEXT, DUK_HOBJECT_GET_ESIZE, DUK_HOBJECT_GET_HSIZE, DUK_HOBJECT_IS_ARRAY, DUK_HOBJECT_IS_BUFOBJ, DUK_HOBJECT_IS_COMPFUNC, DUK_HOBJECT_IS_NATFUNC, DUK_HOBJECT_IS_THREAD, DUK_HOBJECT_P_ALLOC_SIZE, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_HAS_EXTDATA, DUK_HTYPE_BUFFER, DUK_HTYPE_OBJECT, DUK_HTYPE_STRING, duk_memset, duk_push_bare_object(), duk_push_pointer(), duk_push_uint(), duk_put_prop_literal, DUK_TVAL_GET_HEAPHDR, DUK_TVAL_GET_TAG, DUK_TVAL_IS_HEAP_ALLOCATED, and duk_hthread::heap.
| DUK_EXTERNAL duk_bool_t duk_instanceof | ( | duk_hthread * | thr, |
| duk_idx_t | idx1, | ||
| duk_idx_t | idx2 | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_array | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22786 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared().
| DUK_INTERNAL duk_bool_t duk_is_bare_object | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18595 of file duktape.c.
Referenced by duk__load_func().
| DUK_EXTERNAL duk_bool_t duk_is_boolean | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22670 of file duktape.c.
Referenced by duk_bi_boolean_prototype_tostring_shared(), and dukky_generic_event_handler().
| DUK_EXTERNAL duk_bool_t duk_is_bound_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_buffer_data | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22734 of file duktape.c.
References duk__tag_check(), DUK_ASSERT_API_ENTRY, and DUK_TAG_OBJECT.
| DUK_EXTERNAL duk_bool_t duk_is_c_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22851 of file duktape.c.
References DUK_ASSERT, DUK_HOBJECT_HAS_CONSTRUCTABLE, and DUK_TVAL_GET_OBJECT.
| DUK_INTERNAL duk_bool_t duk_is_callable_tval | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
Definition at line 22816 of file duktape.c.
References DUK_ASSERT, DUK_HOBJECT_HAS_CALLABLE, and DUK_TVAL_GET_OBJECT.
| DUK_EXTERNAL duk_bool_t duk_is_constructable | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22833 of file duktape.c.
References DUK_ASSERT, DUK_HOBJECT_HAS_CALLABLE, and DUK_TVAL_GET_OBJECT.
Referenced by duk__update_default_instance_proto().
| DUK_EXTERNAL duk_bool_t duk_is_constructor_call | ( | duk_hthread * | thr | ) |
Definition at line 15565 of file duktape.c.
References DUK_ERROR_TYPE_INVALID_ARGS, DUK_EXEC_ERROR, and DUK_WO_NORETURN.
Referenced by duk_bi_pointer_constructor().
| DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_ecmascript_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_external_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22878 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_get_hobject(), DUK_HOBJECT_CLASS_THREAD, and DUK_HOBJECT_GET_CLASS_NUMBER.
| DUK_EXTERNAL duk_bool_t duk_is_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22798 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_get_tval(), and duk_js_isarray().
Referenced by duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_bool_t duk_is_lightfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_nan | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_null | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22665 of file duktape.c.
References DUK_ERROR_TYPE, DUK_STR_UNEXPECTED_TYPE, and DUK_WO_NORETURN.
| DUK_EXTERNAL duk_bool_t duk_is_number | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22675 of file duktape.c.
Referenced by duk_bi_global_object_eval(), and duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_bool_t duk_is_object | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22723 of file duktape.c.
Referenced by duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_bool_t duk_is_pointer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22761 of file duktape.c.
Referenced by duk_bi_pointer_constructor().
| DUK_EXTERNAL duk_bool_t duk_is_strict_call | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL duk_bool_t duk_is_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22713 of file duktape.c.
Referenced by duk__safe_to_stacktrace_raw(), duk_bi_string_prototype_replace(), duk_js_tonumber(), and duk_push_class_string_tval().
| DUK_INTERNAL duk_bool_t duk_is_string_notsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22718 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_EXTERNAL duk_bool_t duk_is_symbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22771 of file duktape.c.
References duk__tag_check(), DUK_ASSERT_API_ENTRY, and DUK_TAG_POINTER.
| DUK_EXTERNAL duk_bool_t duk_is_thread | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_is_undefined | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22660 of file duktape.c.
Referenced by duk_bi_array_prototype_join_shared(), duk_bi_symbol_constructor_shared(), dukky_event_target_push_listeners(), dukky_get_current_value_of_event_handler(), dukky_populate_object(), dukky_push_event(), dukky_push_node(), dukky_push_node_stacked(), and js_fire_event().
| DUK_EXTERNAL duk_bool_t duk_is_valid_index | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 19050 of file duktape.c.
Referenced by duk__handle_call_raw(), and duk__prep_codec_arg().
| DUK_INTERNAL duk_bool_t duk_is_whole_get_int32 | ( | duk_double_t | x, |
| duk_int32_t * | ival | ||
| ) |
Definition at line 100783 of file duktape.c.
References duk_double_equals(), duk_double_is_nan_or_inf(), and duk_js_tointeger_number().
| DUK_INTERNAL duk_bool_t duk_is_whole_get_int32_nonegzero | ( | duk_double_t | x, |
| duk_int32_t * | ival | ||
| ) |
| DUK_EXTERNAL void duk_join | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 25752 of file duktape.c.
Referenced by duk_bi_array_prototype_join_shared().
| DUK_INTERNAL double duk_js_arith_mod | ( | double | x, |
| double | y | ||
| ) |
Definition at line 65938 of file duktape.c.
Referenced by duk__vm_arith_add().
| DUK_INTERNAL double duk_js_arith_pow | ( | double | x, |
| double | y | ||
| ) |
Definition at line 65991 of file duktape.c.
Referenced by duk_bi_math_object_onearg_shared().
| DUK_INTERNAL void duk_js_close_environment_record | ( | duk_hthread * | thr, |
| duk_hobject * | env | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_js_compare_helper | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_INTERNAL 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 77041 of file duktape.c.
Referenced by duk_bi_global_object_eval().
| DUK_INTERNAL 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 83169 of file duktape.c.
References DUK_HINT_NONE, duk_push_tval(), and duk_to_primitive().
Referenced by duk__compare_fastint().
| DUK_INTERNAL duk_bool_t duk_js_declvar_activation | ( | duk_hthread * | thr, |
| duk_activation * | act, | ||
| duk_hstring * | name, | ||
| duk_tval * | val, | ||
| duk_small_uint_t | prop_flags, | ||
| duk_bool_t | is_func_decl | ||
| ) |
Definition at line 85671 of file duktape.c.
References DUK_HDECENV_ASSERT_VALID.
| DUK_INTERNAL duk_bool_t duk_js_delvar_activation | ( | duk_hthread * | thr, |
| duk_activation * | act, | ||
| duk_hstring * | name | ||
| ) |
Definition at line 85384 of file duktape.c.
References duk__id_lookup_result::attrs, DUK_ASSERT, duk_hobject_delprop_raw(), DUK_PROPDESC_FLAG_CONFIGURABLE, duk__id_lookup_result::holder, and duk__id_lookup_result::value.
| DUK_INTERNAL duk_bool_t duk_js_equals_helper | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 82974 of file duktape.c.
References DUK_ASSERT, duk_double_same_sign(), DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, and DUK_UNLIKELY.
| DUK_INTERNAL void duk_js_execute_bytecode | ( | duk_hthread * | exec_thr | ) |
Definition at line 80087 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_INTERNAL duk_bool_t duk_js_getvar_activation | ( | duk_hthread * | thr, |
| duk_activation * | act, | ||
| duk_hstring * | name, | ||
| duk_bool_t | throw_flag | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_js_getvar_envrec | ( | duk_hthread * | thr, |
| duk_hobject * | env, | ||
| duk_hstring * | name, | ||
| duk_bool_t | throw_flag | ||
| ) |
Definition at line 85164 of file duktape.c.
References duk_push_tval(), duk_push_undefined(), and duk__id_lookup_result::value.
| DUK_INTERNAL duk_bool_t duk_js_in | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y | ||
| ) |
| DUK_INTERNAL void duk_js_init_activation_environment_records_delayed | ( | duk_hthread * | thr, |
| duk_activation * | act | ||
| ) |
Definition at line 84503 of file duktape.c.
Referenced by duk_bi_global_object_eval().
| DUK_INTERNAL duk_bool_t duk_js_instanceof | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_js_instanceof_ordinary | ( | duk_hthread * | thr, |
| duk_tval * | tv_x, | ||
| duk_tval * | tv_y | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_js_isarray | ( | duk_tval * | tv | ) |
Definition at line 83798 of file duktape.c.
Referenced by duk_bi_array_prototype_to_string(), and duk_is_function().
| DUK_INTERNAL duk_bool_t duk_js_isarray_hobject | ( | duk_hobject * | h | ) |
Definition at line 83790 of file duktape.c.
References DUK_STRIDX_LC_FUNCTION.
| DUK_INTERNAL void duk_js_push_closure | ( | duk_hthread * | thr, |
| duk_hcompfunc * | fun_temp, | ||
| duk_hobject * | outer_var_env, | ||
| duk_hobject * | outer_lex_env, | ||
| duk_bool_t | add_auto_proto | ||
| ) |
Definition at line 84040 of file duktape.c.
Referenced by duk_bi_global_object_eval().
| DUK_INTERNAL void duk_js_putvar_activation | ( | duk_hthread * | thr, |
| duk_activation * | act, | ||
| duk_hstring * | name, | ||
| duk_tval * | val, | ||
| duk_bool_t | strict | ||
| ) |
| DUK_INTERNAL void duk_js_putvar_envrec | ( | duk_hthread * | thr, |
| duk_hobject * | env, | ||
| duk_hstring * | name, | ||
| duk_tval * | val, | ||
| duk_bool_t | strict | ||
| ) |
Definition at line 85298 of file duktape.c.
Referenced by duk_hobject_define_property_helper().
| DUK_INTERNAL duk_small_int_t duk_js_string_compare | ( | duk_hstring * | h1, |
| duk_hstring * | h2 | ||
| ) |
Definition at line 83200 of file duktape.c.
References duk_memcmp_unsafe().
| DUK_INTERNAL duk_uarridx_t duk_js_to_arrayindex_string | ( | const duk_uint8_t * | str, |
| duk_uint32_t | blen | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_js_toboolean | ( | duk_tval * | tv | ) |
Definition at line 82518 of file duktape.c.
References DUK_ASSERT, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_HSTRING_GET_BYTELEN, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_FASTINT, 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_DOUBLE, DUK_TVAL_GET_FASTINT, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_DOUBLE, and DUK_TVAL_IS_UNUSED.
| DUK_INTERNAL duk_int32_t duk_js_toint32 | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_INTERNAL duk_double_t duk_js_tointeger | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_INTERNAL duk_double_t duk_js_tointeger_number | ( | duk_double_t | x | ) |
Definition at line 82723 of file duktape.c.
Referenced by duk_is_whole_get_int32().
| DUK_INTERNAL duk_double_t duk_js_tonumber | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
Definition at line 82646 of file duktape.c.
References DUK_ASSERT, duk_get_number(), duk_is_string(), duk_numconv_parse(), duk_pop_unsafe(), DUK_S2N_FLAG_ALLOW_AUTO_BIN_INT, DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT, DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT, DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO, DUK_S2N_FLAG_ALLOW_EMPTY_FRAC, DUK_S2N_FLAG_ALLOW_EXP, DUK_S2N_FLAG_ALLOW_FRAC, DUK_S2N_FLAG_ALLOW_INF, DUK_S2N_FLAG_ALLOW_LEADING_ZERO, DUK_S2N_FLAG_ALLOW_MINUS, DUK_S2N_FLAG_ALLOW_NAKED_FRAC, DUK_S2N_FLAG_ALLOW_PLUS, DUK_S2N_FLAG_TRIM_WHITE, DUK_TVAL_GET_DOUBLE, DUK_TVAL_IS_DOUBLE, DUK_TVAL_IS_NUMBER, DUK_TVAL_NEEDS_REFCOUNT_UPDATE, DUK_TVAL_SET_UNDEFINED, and duk_hthread::valstack_top.
| DUK_INTERNAL duk_uint16_t duk_js_touint16 | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_INTERNAL duk_uint32_t duk_js_touint32 | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_INTERNAL duk_small_uint_t duk_js_typeof_stridx | ( | duk_tval * | tv_x | ) |
| DUK_EXTERNAL void duk_json_decode | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL const char * duk_json_encode | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 16586 of file duktape.c.
References DUK_ERROR_UNSUPPORTED, DUK_UNREF, and DUK_WO_NORETURN.
| DUK_INTERNAL duk_hbuffer * duk_known_hbuffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21365 of file duktape.c.
References duk__known_heaphdr(), DUK_ASSERT, DUK_ASSERT_API_ENTRY, and duk_get_hstring().
Referenced by duk__load_func().
| DUK_INTERNAL duk_hcompfunc * duk_known_hcompfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21371 of file duktape.c.
References duk__known_heaphdr(), DUK_ASSERT, DUK_ASSERT_API_ENTRY, and duk_get_hobject().
| DUK_INTERNAL duk_hnatfunc * duk_known_hnatfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21377 of file duktape.c.
References duk__known_heaphdr(), DUK_ASSERT, DUK_ASSERT_API_ENTRY, and duk_get_hbuffer().
| DUK_INTERNAL duk_hobject * duk_known_hobject | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21359 of file duktape.c.
Referenced by duk_bi_global_object_eval(), and duk_bi_thread_constructor().
| DUK_INTERNAL duk_hstring * duk_known_hstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21353 of file duktape.c.
References duk_hthread::valstack_top.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk_bi_string_prototype_replace(), duk_lexer_parse_js_input_element(), duk_lexer_setpoint(), duk_proxy_ownkeys_postprocess(), and duk_push_class_string_tval().
| DUK_INTERNAL void duk_lexer_getpoint | ( | duk_lexer_ctx * | lex_ctx, |
| duk_lexer_point * | pt | ||
| ) |
| DUK_INTERNAL void duk_lexer_initctx | ( | duk_lexer_ctx * | lex_ctx | ) |
| DUK_INTERNAL 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 86732 of file duktape.c.
References duk_token::allow_auto_semi, DUK__ADVANCEBYTES, DUK__ADVANCECHARS, DUK__ADVTOK, DUK__APPENDBUFFER, DUK__INITBUFFER, duk__internbuffer(), DUK__ISDIGIT, DUK__ISHEXDIGIT, DUK__L0, DUK__L1, DUK__L2, DUK__L3, duk__lexer_parse_escape(), duk__lexer_parse_string_literal(), duk__lexer_skip_to_endofline(), DUK__LOOKUP, DUK_ASC_0, DUK_ASC_8, DUK_ASC_9, DUK_ASC_AMP, DUK_ASC_BACKSLASH, DUK_ASC_CARET, DUK_ASC_COLON, DUK_ASC_COMMA, DUK_ASC_DOUBLEQUOTE, DUK_ASC_EQUALS, DUK_ASC_EXCLAMATION, DUK_ASC_HASH, DUK_ASC_HT, DUK_ASC_LANGLE, DUK_ASC_LBRACKET, DUK_ASC_LC_B, DUK_ASC_LC_E, DUK_ASC_LC_O, DUK_ASC_LC_U, DUK_ASC_LC_X, 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_ASC_UC_E, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_COMPILE_SHEBANG, DUK_DOUBLE_NAN, duk_dup(), DUK_ERROR_RANGE, DUK_HEAP_NUM_STRINGS, DUK_HTHREAD_GET_STRING, DUK_ISNAN, duk_known_hstring(), DUK_LOWERCASE_CHAR_ASCII, duk_numconv_parse(), duk_replace(), DUK_S2N_FLAG_ALLOW_EMPTY_FRAC, DUK_S2N_FLAG_ALLOW_EXP, DUK_S2N_FLAG_ALLOW_FRAC, DUK_S2N_FLAG_ALLOW_LEADING_ZERO, DUK_S2N_FLAG_ALLOW_NAKED_FRAC, DUK_STR_TOKEN_LIMIT, DUK_STRIDX_END_RESERVED, DUK_STRIDX_START_RESERVED, DUK_STRIDX_START_STRICT_RESERVED, DUK_STRIDX_TO_TOK, duk_to_number_m1(), 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_EXP, DUK_TOK_EXP_EQ, DUK_TOK_GE, DUK_TOK_GT, DUK_TOK_IDENTIFIER, DUK_TOK_INCREMENT, DUK_TOK_INVALID, 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_WO_NORETURN, duk_lexer_ctx::flags, duk_lexer_codepoint::line, duk_token::lineterm, 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_INTERNAL void duk_lexer_parse_re_ranges | ( | duk_lexer_ctx * | lex_ctx, |
| duk_re_range_callback | gen_range, | ||
| void * | userdata | ||
| ) |
| DUK_INTERNAL void duk_lexer_parse_re_token | ( | duk_lexer_ctx * | lex_ctx, |
| duk_re_token * | out_token | ||
| ) |
| DUK_INTERNAL void duk_lexer_setpoint | ( | duk_lexer_ctx * | lex_ctx, |
| duk_lexer_point * | pt | ||
| ) |
Definition at line 86301 of file duktape.c.
References duk_lexer_ctx::bw, DUK_ASSERT, DUK_BW_PUSH_AS_STRING, duk_known_hstring(), duk_replace(), duk_lexer_ctx::slot1_idx, duk_lexer_ctx::slot2_idx, and duk_lexer_ctx::thr.
| DUK_EXTERNAL void duk_load_function | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_map_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_map_char_function | callback, | ||
| void * | udata | ||
| ) |
| DUK_INTERNAL DUK_INLINE duk_small_int_t duk_memcmp | ( | const void * | s1, |
| const void * | s2, | ||
| duk_size_t | len | ||
| ) |
Definition at line 101029 of file duktape.c.
Referenced by duk_bi_string_prototype_replace().
| DUK_INTERNAL DUK_INLINE duk_small_int_t duk_memcmp_unsafe | ( | const void * | s1, |
| const void * | s2, | ||
| duk_size_t | len | ||
| ) |
Definition at line 101018 of file duktape.c.
Referenced by duk_js_string_compare().
| DUK_INTERNAL void duk_native_stack_check | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_new | ( | duk_hthread * | thr, |
| duk_idx_t | nargs | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_next | ( | duk_hthread * | thr, |
| duk_idx_t | enum_index, | ||
| duk_bool_t | get_value | ||
| ) |
| DUK_NORETURN | ( | DUK_INTERNAL_DECL void | duk_default_fatal_handlervoid *udata, const char *msg | ) |
| 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 | ( | DUK_INTERNAL_DECL void | duk_err_errorduk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message | ) |
| DUK_NORETURN | ( | DUK_INTERNAL_DECL void | duk_err_error_internalduk_hthread *thr, const char *filename, duk_int_t linenumber | ) |
| 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 | ( | 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 | ( | DUK_INTERNAL_DECL void | duk_err_longjmpduk_hthread *thr | ) |
| DUK_NORETURN | ( | DUK_INTERNAL_DECL void | duk_err_range_indexduk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx | ) |
| DUK_NORETURN | ( | DUK_INTERNAL_DECL void | duk_err_require_type_indexduk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name | ) |
| DUK_NORETURN | ( | DUK_INTERNAL_DECL void | duk_error_throw_from_negative_rcduk_hthread *thr, duk_ret_t rc | ) |
| DUK_NORETURN | ( | DUK_LOCAL_DECL void | duk__throw_error_from_stashduk_hthread *thr, duk_errcode_t err_code, const char *fmt, va_list ap | ) |
| DUK_NORETURN | ( | DUK_LOCAL_DECL void | duk__uncaught_error_awareduk_hthread *thr | ) |
| DUK_EXTERNAL duk_idx_t duk_normalize_index | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18910 of file duktape.c.
Referenced by duk_put_prop_index().
| DUK_INTERNAL void duk_numconv_parse | ( | duk_hthread * | thr, |
| duk_small_int_t | radix, | ||
| duk_small_uint_t | flags | ||
| ) |
Definition at line 90484 of file duktape.c.
Referenced by duk_js_tonumber(), and duk_lexer_parse_js_input_element().
| DUK_INTERNAL void duk_numconv_stringify | ( | duk_hthread * | thr, |
| duk_small_int_t | radix, | ||
| duk_small_int_t | digits, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_opt_boolean | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_bool_t | def_value | ||
| ) |
| DUK_EXTERNAL void * duk_opt_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| void * | def_ptr, | ||
| duk_size_t | def_size | ||
| ) |
| DUK_EXTERNAL void * duk_opt_buffer_data | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| void * | def_ptr, | ||
| duk_size_t | def_size | ||
| ) |
| DUK_EXTERNAL duk_c_function duk_opt_c_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_c_function | def_value | ||
| ) |
| DUK_EXTERNAL duk_hthread * duk_opt_context | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_hthread * | def_value | ||
| ) |
Definition at line 21080 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_get_hthread().
| DUK_EXTERNAL void * duk_opt_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| void * | def_value | ||
| ) |
| DUK_EXTERNAL duk_int_t duk_opt_int | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | def_value | ||
| ) |
Definition at line 20377 of file duktape.c.
References duk__api_coerce_d2i(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL const char * duk_opt_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len, | ||
| const char * | def_ptr, | ||
| duk_size_t | def_len | ||
| ) |
| DUK_EXTERNAL duk_double_t duk_opt_number | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_double_t | def_value | ||
| ) |
| DUK_EXTERNAL void * duk_opt_pointer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| void * | def_value | ||
| ) |
| DUK_EXTERNAL const char * duk_opt_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| const char * | def_ptr | ||
| ) |
Definition at line 20472 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_check_type_mask(), DUK_TYPE_MASK_NONE, and DUK_TYPE_MASK_UNDEFINED.
| DUK_EXTERNAL duk_uint_t duk_opt_uint | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | def_value | ||
| ) |
| DUK_INTERNAL void duk_pack | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 24854 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_pop_n_nodecref_unsafe().
| DUK_EXTERNAL duk_int_t duk_pcall | ( | duk_hthread * | thr, |
| duk_idx_t | nargs | ||
| ) |
Definition at line 15390 of file duktape.c.
Referenced by dukky_pcall(), and js_exec().
| DUK_EXTERNAL duk_int_t duk_pcall_method | ( | duk_hthread * | thr, |
| duk_idx_t | nargs | ||
| ) |
Definition at line 15440 of file duktape.c.
Referenced by duk__err_augment_user(), dukky_generic_event_handler(), and js_fire_event().
| DUK_INTERNAL duk_int_t duk_pcall_method_flags | ( | duk_hthread * | thr, |
| duk_idx_t | nargs, | ||
| duk_small_uint_t | call_flags | ||
| ) |
| DUK_EXTERNAL duk_int_t duk_pcall_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_idx_t | nargs | ||
| ) |
| DUK_EXTERNAL duk_int_t duk_pnew | ( | duk_hthread * | thr, |
| duk_idx_t | nargs | ||
| ) |
| DUK_EXTERNAL void duk_pop | ( | duk_hthread * | thr | ) |
Definition at line 24715 of file duktape.c.
Referenced by duk__add_label(), duk__const_needs_refcount(), duk__do_compile(), duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), duk__load_func(), duk__safe_to_stacktrace_raw(), duk_bi_string_prototype_replace(), duk_bi_thread_resume(), duk_bi_typedarray_set(), duk_proxy_ownkeys_postprocess(), dukky_destroythread(), dukky_dump_error(), dukky_event_target_push_listeners(), dukky_generic_event_handler(), dukky_get_current_value_of_event_handler(), dukky_log_stack_frame(), dukky_populate_object(), dukky_push_event(), dukky_push_node(), dukky_push_node_stacked(), dukky_shuffle_array(), js_event_cleanup(), js_fire_event(), and js_newthread().
| DUK_EXTERNAL void duk_pop_2 | ( | duk_hthread * | thr | ) |
Definition at line 24804 of file duktape.c.
Referenced by duk__error_getter_helper(), dukky_event_target_push_listeners(), dukky_generic_event_handler(), dukky_get_current_value_of_event_handler(), dukky_populate_object(), dukky_push_node(), and dukky_register_event_listener_for().
| DUK_INTERNAL void duk_pop_2_nodecref_unsafe | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL void duk_pop_2_unsafe | ( | duk_hthread * | thr | ) |
Definition at line 24815 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), and duk_hobject_putprop().
| DUK_EXTERNAL void duk_pop_3 | ( | duk_hthread * | thr | ) |
Definition at line 24833 of file duktape.c.
Referenced by duk__error_getter_helper(), dukky_event_target_push_listeners(), and dukky_push_node_stacked().
| DUK_INTERNAL void duk_pop_3_nodecref_unsafe | ( | duk_hthread * | thr | ) |
Definition at line 24843 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_pop_n().
| DUK_INTERNAL void duk_pop_3_unsafe | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_pop_n | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 24627 of file duktape.c.
References count(), DUK_ASSERT, DUK_TVAL_SET_UNDEFINED, and duk_hthread::valstack_bottom.
Referenced by duk__concat_and_join_helper(), duk_pop_3_nodecref_unsafe(), dukky_generic_event_handler(), and js_fire_event().
| DUK_INTERNAL void duk_pop_n_nodecref_unsafe | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 24654 of file duktape.c.
Referenced by duk_hobject_realloc_props(), and duk_pack().
| DUK_INTERNAL void duk_pop_n_unsafe | ( | duk_hthread * | thr, |
| duk_idx_t | count | ||
| ) |
Definition at line 24646 of file duktape.c.
Referenced by duk_hobject_putprop().
| DUK_INTERNAL void duk_pop_nodecref_unsafe | ( | duk_hthread * | thr | ) |
Definition at line 24730 of file duktape.c.
Referenced by duk_bi_array_prototype_join_shared().
| DUK_INTERNAL void duk_pop_undefined | ( | duk_hthread * | thr | ) |
Definition at line 24752 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_join_shared(), and duk_bi_array_prototype_splice().
| DUK_INTERNAL void duk_pop_unsafe | ( | duk_hthread * | thr | ) |
Definition at line 24726 of file duktape.c.
Referenced by duk_hobject_define_property_helper(), duk_hobject_putprop(), and duk_js_tonumber().
| DUK_INTERNAL void duk_proxy_ownkeys_postprocess | ( | duk_hthread * | thr, |
| duk_hobject * | h_proxy_target, | ||
| duk_uint_t | flags | ||
| ) |
Definition at line 42272 of file duktape.c.
References DUK_ASSERT, DUK_CTX_ASSERT_VALID, DUK_DDD, DUK_DDDPRINT, duk_def_prop(), DUK_DEFPROP_HAVE_VALUE, DUK_DEFPROP_SET_WEC, DUK_ENUM_EXCLUDE_STRINGS, DUK_ENUM_INCLUDE_HIDDEN, DUK_ENUM_INCLUDE_NONENUMERABLE, DUK_ENUM_INCLUDE_SYMBOLS, DUK_ERROR_TYPE_INVALID_TRAP_RESULT, duk_get_hstring(), duk_get_length(), duk_get_prop_index(), duk_get_tval(), duk_hobject_get_own_propdesc(), DUK_HSTRING_HAS_HIDDEN, DUK_HSTRING_HAS_SYMBOL, duk_insert(), duk_known_hstring(), duk_pop(), DUK_PROPDESC_FLAG_ENUMERABLE, duk_push_array(), duk_push_uarridx, DUK_UNLIKELY, DUK_WO_NORETURN, and duk_propdesc::flags.
| DUK_EXTERNAL void duk_pull | ( | duk_hthread * | thr, |
| duk_idx_t | from_idx | ||
| ) |
| DUK_EXTERNAL duk_idx_t duk_push_array | ( | duk_hthread * | thr | ) |
Definition at line 23555 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_splice(), duk_proxy_ownkeys_postprocess(), dukky_event_target_push_listeners(), and dukky_generic_event_handler().
| DUK_EXTERNAL duk_idx_t duk_push_bare_array | ( | duk_hthread * | thr | ) |
Definition at line 23581 of file duktape.c.
Referenced by duk__load_func().
| DUK_EXTERNAL duk_idx_t duk_push_bare_object | ( | duk_hthread * | thr | ) |
Definition at line 24530 of file duktape.c.
Referenced by duk__load_func(), and duk_inspect_value().
| DUK_EXTERNAL void duk_push_boolean | ( | duk_hthread * | thr, |
| duk_bool_t | val | ||
| ) |
Definition at line 23004 of file duktape.c.
Referenced by duk_bi_array_prototype_to_string(), duk_bi_global_object_decode_uri(), duk_bi_global_object_is_finite(), dukky_register_event_listener_for(), js_exec(), and js_newheap().
| DUK_EXTERNAL void duk_push_buffer_object | ( | duk_hthread * | thr, |
| duk_idx_t | idx_buffer, | ||
| duk_size_t | byte_offset, | ||
| duk_size_t | byte_length, | ||
| duk_uint_t | flags | ||
| ) |
| DUK_EXTERNAL void * duk_push_buffer_raw | ( | duk_hthread * | thr, |
| duk_size_t | size, | ||
| duk_small_uint_t | flags | ||
| ) |
| DUK_INTERNAL duk_hbufobj * duk_push_bufobj_raw | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags_and_class, | ||
| duk_small_int_t | prototype_bidx | ||
| ) |
| DUK_EXTERNAL duk_idx_t duk_push_c_function | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_int_t | nargs | ||
| ) |
Definition at line 23806 of file duktape.c.
Referenced by dukky_inject_not_ctr().
| DUK_INTERNAL void duk_push_c_function_builtin | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_int_t | nargs | ||
| ) |
| DUK_INTERNAL void duk_push_c_function_builtin_noconstruct | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_int_t | nargs | ||
| ) |
| DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_idx_t | nargs, | ||
| duk_idx_t | length, | ||
| duk_int_t | magic | ||
| ) |
| DUK_INTERNAL void duk_push_class_string_tval | ( | duk_hthread * | thr, |
| duk_tval * | tv, | ||
| duk_bool_t | avoid_side_effects | ||
| ) |
Definition at line 21899 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_get_hstring(), duk_is_string(), duk_known_hstring(), and duk_safe_to_string.
Referenced by duk_bi_object_constructor().
| DUK_EXTERNAL void duk_push_context_dump | ( | duk_hthread * | thr | ) |
Definition at line 16824 of file duktape.c.
Referenced by dukky_push_context_dump().
| DUK_EXTERNAL void duk_push_current_function | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_push_current_thread | ( | duk_hthread * | thr | ) |
Definition at line 23347 of file duktape.c.
Referenced by duk_bi_type_error_thrower().
| DUK_EXTERNAL duk_idx_t duk_push_error_object_raw | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | filename, | ||
| duk_int_t | line, | ||
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 24164 of file duktape.c.
Referenced by duk_err_create_and_throw().
| DUK_EXTERNAL duk_idx_t duk_push_error_object_stash | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | fmt, | ||
| ... | |||
| ) |
| DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw | ( | duk_hthread * | thr, |
| duk_errcode_t | err_code, | ||
| const char * | filename, | ||
| duk_int_t | line, | ||
| const char * | fmt, | ||
| va_list | ap | ||
| ) |
Definition at line 24105 of file duktape.c.
References DUK_ASSERT_API_ENTRY, DUK_ERROR_UNSUPPORTED, DUK_UNREF, and DUK_WO_NORETURN.
Referenced by duk_error_raw().
| DUK_EXTERNAL void duk_push_false | ( | duk_hthread * | thr | ) |
Definition at line 23024 of file duktape.c.
Referenced by duk_bi_array_prototype_iter_shared().
| DUK_INTERNAL void * duk_push_fixed_buffer_nozero | ( | duk_hthread * | thr, |
| duk_size_t | len | ||
| ) |
Definition at line 24223 of file duktape.c.
Referenced by duk__arraybuffer_plain_slice(), duk__concat_and_join_helper(), duk__dump_hstring_raw(), duk__load_func(), and duk_bi_typedarray_set().
| DUK_INTERNAL void * duk_push_fixed_buffer_zero | ( | duk_hthread * | thr, |
| duk_size_t | len | ||
| ) |
| DUK_EXTERNAL void duk_push_global_object | ( | duk_hthread * | thr | ) |
Definition at line 23357 of file duktape.c.
Referenced by dukky_register_event_listener_for(), js_fire_event(), js_newheap(), and js_newthread().
| DUK_EXTERNAL void duk_push_global_stash | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_harray * duk_push_harray | ( | duk_hthread * | thr | ) |
Definition at line 23605 of file duktape.c.
Referenced by duk_push_harray_with_size_outptr().
| DUK_INTERNAL duk_harray * duk_push_harray_with_size | ( | duk_hthread * | thr, |
| duk_uint32_t | size | ||
| ) |
| DUK_INTERNAL duk_tval * duk_push_harray_with_size_outptr | ( | duk_hthread * | thr, |
| duk_uint32_t | size | ||
| ) |
Definition at line 23633 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_hobject_realloc_props(), duk_push_harray(), and duk_harray::length.
| DUK_INTERNAL duk_hboundfunc * duk_push_hboundfunc | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL void duk_push_hbuffer | ( | duk_hthread * | thr, |
| duk_hbuffer * | h | ||
| ) |
| DUK_INTERNAL duk_hcompfunc * duk_push_hcompfunc | ( | duk_hthread * | thr | ) |
Definition at line 23697 of file duktape.c.
Referenced by duk__load_func().
| DUK_EXTERNAL void duk_push_heap_stash | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL duk_idx_t duk_push_heapptr | ( | duk_hthread * | thr, |
| void * | ptr | ||
| ) |
| DUK_INTERNAL void duk_push_hobject | ( | duk_hthread * | thr, |
| duk_hobject * | h | ||
| ) |
Definition at line 24561 of file duktape.c.
References DUK_ASSERT_API_ENTRY, DUK_ASSERT_STRIDX_VALID, DUK_HTHREAD_GET_STRING, and duk_push_hstring().
Referenced by duk__load_func(), duk__pop_n_unsafe_raw(), duk__try_push_vsprintf(), duk_bi_global_object_eval(), duk_bi_object_constructor_get_own_property_descriptor(), duk_bi_thread_constructor(), duk_hobject_get_enumerated_keys(), and duk_hobject_putprop().
| DUK_INTERNAL void duk_push_hobject_bidx | ( | duk_hthread * | thr, |
| duk_small_int_t | builtin_idx | ||
| ) |
Definition at line 24581 of file duktape.c.
Referenced by duk_bi_global_object_eval(), and duk_get_prop_desc().
| DUK_INTERNAL void duk_push_hstring | ( | duk_hthread * | thr, |
| duk_hstring * | h | ||
| ) |
Definition at line 24540 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_get_top_index_unsafe(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_OBJECT, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_FASTREFS, and duk_push_object_helper().
Referenced by duk__get_own_propdesc_raw(), duk__parse_var_decl(), duk_hobject_enumerator_create(), duk_hobject_realloc_props(), and duk_push_hobject().
| DUK_INTERNAL void duk_push_hstring_empty | ( | duk_hthread * | thr | ) |
Definition at line 24556 of file duktape.c.
Referenced by duk__concat_and_join_helper(), duk_bi_array_prototype_join_shared(), and duk_bi_string_prototype_char_code_at().
| DUK_INTERNAL void duk_push_hstring_stridx | ( | duk_hthread * | thr, |
| duk_small_uint_t | stridx | ||
| ) |
Definition at line 24550 of file duktape.c.
Referenced by duk__error_getter_helper(), duk_bi_array_prototype_join_shared(), duk_bi_global_object_eval(), and duk_get_prop_desc().
| DUK_EXTERNAL void duk_push_int | ( | duk_hthread * | thr, |
| duk_int_t | val | ||
| ) |
Definition at line 23046 of file duktape.c.
References duk_double_union::d, DUK__CHECK_SPACE, DUK_ASSERT_API_ENTRY, DUK_DBLUNION_NORMALIZE_NAN_CHECK, DUK_TVAL_SET_NUMBER, and duk_hthread::valstack_top.
Referenced by duk__cbor_decode_skip_aival_int(), duk__error_getter_helper(), duk__init_varmap_and_prologue_for_pass2(), duk__parse_var_decl(), duk_bi_buffer_readfield(), duk_bi_string_prototype_match(), duk_bi_string_prototype_replace(), dukky_create_object(), dukky_push_node_stacked(), and js_newthread().
| DUK_INTERNAL void duk_push_lightfunc_name | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_INTERNAL void duk_push_lightfunc_name_raw | ( | duk_hthread * | thr, |
| duk_c_function | func, | ||
| duk_small_uint_t | lf_flags | ||
| ) |
Definition at line 25268 of file duktape.c.
Referenced by duk_push_lightfunc_tostring().
| DUK_INTERNAL void duk_push_lightfunc_tostring | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
Definition at line 25300 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_push_lightfunc_name_raw(), DUK_TVAL_GET_LIGHTFUNC, and DUK_TVAL_IS_LIGHTFUNC.
| DUK_EXTERNAL const char * duk_push_literal_raw | ( | duk_hthread * | thr, |
| const char * | str, | ||
| duk_size_t | len | ||
| ) |
Definition at line 23164 of file duktape.c.
Referenced by duk_del_prop_index(), duk_get_prop_index(), duk_has_prop_index(), and duk_put_prop_index().
| DUK_EXTERNAL const char * duk_push_lstring | ( | duk_hthread * | thr, |
| const char * | str, | ||
| duk_size_t | len | ||
| ) |
Definition at line 23117 of file duktape.c.
References duk_double_union::d, DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_API_ENTRY, DUK_DBLUNION_IS_NORMALIZED, DUK_DBLUNION_SET_NAN, DUK_TVAL_SET_NUMBER, and duk_hthread::valstack_top.
Referenced by duk__load_buffer_raw(), dukky_generic_event_handler(), dukky_get_current_value_of_event_handler(), dukky_push_handler_code_(), dukky_push_node_klass(), dukky_register_event_listener_for(), and js_fire_event().
| DUK_EXTERNAL void duk_push_nan | ( | duk_hthread * | thr | ) |
Definition at line 23105 of file duktape.c.
Referenced by duk__parse_string(), and duk_bi_date_constructor_now().
| DUK_EXTERNAL void duk_push_new_target | ( | duk_hthread * | thr | ) |
Definition at line 23294 of file duktape.c.
References duk_hthread::callstack_curr, duk_hthread::callstack_top, DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_hthread::valstack, and duk_hthread::valstack_bottom.
| DUK_EXTERNAL void duk_push_null | ( | duk_hthread * | thr | ) |
Definition at line 22995 of file duktape.c.
References DUK__CHECK_SPACE, DUK_ASSERT_API_ENTRY, and duk_hthread::valstack_top.
Referenced by duk__init_varmap_and_prologue_for_pass2(), and js_newthread().
| DUK_EXTERNAL void duk_push_number | ( | duk_hthread * | thr, |
| duk_double_t | val | ||
| ) |
Definition at line 23034 of file duktape.c.
Referenced by duk__cbor_decode_skip_aival_int(), duk_bi_buffer_readfield(), and duk_bi_date_prototype_to_json().
| DUK_EXTERNAL duk_idx_t duk_push_object | ( | duk_hthread * | thr | ) |
Definition at line 23545 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, DUK_HOBJECT_SET_PROTOTYPE_INIT_INCREF, and duk_push_object_helper().
Referenced by duk__load_func(), dukky_create_object(), dukky_event_target_push_listeners(), dukky_push_event(), dukky_push_node_stacked(), js_newheap(), and js_newthread().
| DUK_INTERNAL duk_hobject * duk_push_object_helper | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags_and_class, | ||
| duk_small_int_t | prototype_bidx | ||
| ) |
Definition at line 23501 of file duktape.c.
Referenced by duk_bi_pointer_constructor(), duk_push_hstring(), and duk_push_object().
| DUK_INTERNAL duk_hobject * duk_push_object_helper_proto | ( | duk_hthread * | thr, |
| duk_uint_t | hobject_flags_and_class, | ||
| duk_hobject * | proto | ||
| ) |
Definition at line 23534 of file duktape.c.
References duk_hthread::builtins, and DUK_HOBJECT_SET_PROTOTYPE_INIT_INCREF.
| DUK_EXTERNAL void duk_push_pointer | ( | duk_hthread * | thr, |
| void * | val | ||
| ) |
Definition at line 23198 of file duktape.c.
Referenced by duk_bi_pointer_constructor(), duk_inspect_value(), dukky_push_event(), dukky_push_node(), js_event_cleanup(), and js_newthread().
| DUK_EXTERNAL duk_idx_t duk_push_proxy | ( | duk_hthread * | thr, |
| duk_uint_t | proxy_flags | ||
| ) |
| DUK_EXTERNAL const char * duk_push_sprintf | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 23487 of file duktape.c.
Referenced by duk__error_getter_helper().
| DUK_EXTERNAL const char * duk_push_string | ( | duk_hthread * | thr, |
| const char * | str | ||
| ) |
Definition at line 23151 of file duktape.c.
Referenced by dukky_create_object(), dukky_get_current_value_of_event_handler(), dukky_log_stack_frame(), dukky_populate_object(), dukky_push_node_klass(), js_exec(), and js_newthread().
| DUK_INTERNAL void duk_push_string_funcptr | ( | duk_hthread * | thr, |
| duk_uint8_t * | ptr, | ||
| duk_size_t | sz | ||
| ) |
| DUK_INTERNAL const char * duk_push_string_readable | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL const char * duk_push_string_tval_readable | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
Definition at line 25500 of file duktape.c.
Referenced by duk_hobject_putprop().
| DUK_INTERNAL const char * duk_push_string_tval_readable_error | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_INTERNAL void duk_push_symbol_descriptive_string | ( | duk_hthread * | thr, |
| duk_hstring * | h | ||
| ) |
| DUK_EXTERNAL void duk_push_this | ( | duk_hthread * | thr | ) |
Definition at line 23253 of file duktape.c.
Referenced by duk__error_getter_helper(), duk_bi_boolean_prototype_tostring_shared(), duk_bi_regexp_constructor(), duk_bi_regexp_prototype_flags(), and duk_bi_typedarray_set().
| DUK_INTERNAL void duk_push_this_check_object_coercible | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_hobject * duk_push_this_coercible_to_object | ( | duk_hthread * | thr | ) |
Definition at line 23265 of file duktape.c.
References duk__push_this_helper(), and DUK_ASSERT_API_ENTRY.
| DUK_INTERNAL duk_hstring * duk_push_this_coercible_to_string | ( | duk_hthread * | thr | ) |
Definition at line 23276 of file duktape.c.
References duk__push_this_helper(), and DUK_ASSERT_API_ENTRY.
Referenced by duk_bi_string_prototype_indexof_shared(), and duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_idx_t duk_push_thread_raw | ( | duk_hthread * | thr, |
| duk_uint_t | flags | ||
| ) |
| DUK_EXTERNAL void duk_push_thread_stash | ( | duk_hthread * | thr, |
| duk_hthread * | target_thr | ||
| ) |
| DUK_EXTERNAL void duk_push_true | ( | duk_hthread * | thr | ) |
Definition at line 23015 of file duktape.c.
References DUK__CHECK_SPACE, DUK_ASSERT_API_ENTRY, and duk_hthread::valstack_top.
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_object_prototype_defineaccessor(), and duk_hobject_enumerator_create().
| DUK_INTERNAL void duk_push_tval | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
Definition at line 22971 of file duktape.c.
Referenced by duk__declvar_helper(), duk__err_augment_user(), duk__get_own_propdesc_raw(), duk__load_func(), duk_bi_global_object_eval(), duk_bi_thread_resume(), duk_hobject_putprop(), duk_js_data_compare(), and duk_js_getvar_envrec().
| DUK_EXTERNAL void duk_push_uint | ( | duk_hthread * | thr, |
| duk_uint_t | val | ||
| ) |
Definition at line 23075 of file duktape.c.
Referenced by duk__error_getter_helper(), duk__get_own_propdesc_raw(), duk__push_this_helper(), duk_bi_buffer_readfield(), duk_bi_string_prototype_replace(), and duk_inspect_value().
| DUK_INTERNAL duk_hstring * duk_push_uint_to_hstring | ( | duk_hthread * | thr, |
| duk_uint_t | i | ||
| ) |
Definition at line 23207 of file duktape.c.
References DUK__CHECK_SPACE, DUK_ASSERT_API_ENTRY, DUK_TVAL_SET_POINTER, and duk_hthread::valstack_top.
| DUK_EXTERNAL void duk_push_undefined | ( | duk_hthread * | thr | ) |
Definition at line 22983 of file duktape.c.
References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_API_ENTRY, DUK_TVAL_INCREF, DUK_TVAL_SET_TVAL, and duk_hthread::valstack_top.
Referenced by duk__err_augment_user(), duk__get_own_propdesc_raw(), duk_bi_array_prototype_iter_shared(), duk_js_getvar_envrec(), and dukky_event_target_push_listeners().
| DUK_EXTERNAL const char * duk_push_vsprintf | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| va_list | ap | ||
| ) |
| DUK_EXTERNAL void duk_put_function_list | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const duk_function_list_entry * | funcs | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_global_heapptr | ( | duk_hthread * | thr, |
| void * | ptr | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_global_literal_raw | ( | duk_hthread * | thr, |
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_global_lstring | ( | duk_hthread * | thr, |
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_global_string | ( | duk_hthread * | thr, |
| const char * | key | ||
| ) |
Definition at line 18451 of file duktape.c.
Referenced by js_newheap(), and js_newthread().
| DUK_EXTERNAL void duk_put_number_list | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const duk_number_list_entry * | numbers | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
Definition at line 17831 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk__load_func(), duk_hobject_enumerator_create(), dukky_event_target_push_listeners(), dukky_push_event(), dukky_push_node_stacked(), dukky_register_event_listener_for(), and js_newthread().
| DUK_EXTERNAL duk_bool_t duk_put_prop_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| void * | ptr | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_prop_index | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uarridx_t | arr_idx | ||
| ) |
Definition at line 17870 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_normalize_index(), and duk_push_literal_raw().
Referenced by duk__load_func(), duk__parse_var_decl(), duk_bi_array_prototype_splice(), duk_bi_typedarray_set(), dukky_generic_event_handler(), dukky_shuffle_array(), and js_newthread().
| DUK_EXTERNAL duk_bool_t duk_put_prop_literal_raw | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_prop_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key, | ||
| duk_size_t | key_len | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_put_prop_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_put_prop_stridx_short_raw | ( | duk_hthread * | thr, |
| duk_uint_t | packed_args | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_put_prop_string | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| const char * | key | ||
| ) |
Definition at line 17836 of file duktape.c.
Referenced by dukky_create_object(), dukky_event_target_push_listeners(), dukky_inject_not_ctr(), dukky_push_node_stacked(), js_newheap(), and js_newthread().
| DUK_EXTERNAL duk_double_t duk_random | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL duk_ret_t duk_range_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 25168 of file duktape.c.
References DUK__ERROR_STASH_SHARED, and DUK_ASSERT_API_ENTRY.
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_read_double_be | ( | const duk_uint8_t * | p | ) |
Definition at line 13920 of file duktape.c.
Referenced by duk_raw_write_u32_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_float_t duk_raw_read_float_be | ( | const duk_uint8_t * | p | ) |
Definition at line 13913 of file duktape.c.
Referenced by duk_raw_write_u16_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_read_u16_be | ( | const duk_uint8_t * | p | ) |
Definition at line 13899 of file duktape.c.
Referenced by duk_raw_readinc_float_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_read_u32_be | ( | const duk_uint8_t * | p | ) |
Definition at line 13906 of file duktape.c.
Referenced by duk_raw_readinc_double_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_readinc_double_be | ( | const duk_uint8_t ** | p | ) |
Definition at line 13945 of file duktape.c.
References duk_raw_read_u32_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_float_t duk_raw_readinc_float_be | ( | const duk_uint8_t ** | p | ) |
Definition at line 13939 of file duktape.c.
References duk_raw_read_u16_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_readinc_u16_be | ( | const duk_uint8_t ** | p | ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_readinc_u32_be | ( | const duk_uint8_t ** | p | ) |
| DUK_INTERNAL duk_small_int_t duk_raw_write_cesu8 | ( | duk_uint8_t * | p, |
| duk_ucodepoint_t | val | ||
| ) |
Definition at line 13982 of file duktape.c.
References duk_double_union::d, duk_dblunion_host_to_big(), duk_memcpy, and duk_double_union::uc.
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_double_be | ( | duk_uint8_t * | p, |
| duk_double_t | val | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_float_be | ( | duk_uint8_t * | p, |
| duk_float_t | val | ||
| ) |
Definition at line 13963 of file duktape.c.
References duk__u16_union::b, duk_memcpy, and duk__u16_union::x.
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u16_be | ( | duk_uint8_t * | p, |
| duk_uint16_t | val | ||
| ) |
Definition at line 13951 of file duktape.c.
References duk_raw_read_float_be().
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u32_be | ( | duk_uint8_t * | p, |
| duk_uint32_t | val | ||
| ) |
Definition at line 13957 of file duktape.c.
References duk_raw_read_double_be().
| DUK_INTERNAL duk_small_int_t duk_raw_write_xutf8 | ( | duk_uint8_t * | p, |
| duk_ucodepoint_t | val | ||
| ) |
| DUK_INTERNAL void duk_raw_writeinc_cesu8 | ( | duk_uint8_t ** | p, |
| duk_ucodepoint_t | val | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_writeinc_double_be | ( | duk_uint8_t ** | p, |
| duk_double_t | val | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_writeinc_float_be | ( | duk_uint8_t ** | p, |
| duk_float_t | val | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_writeinc_u16_be | ( | duk_uint8_t ** | p, |
| duk_uint16_t | val | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_writeinc_u32_be | ( | duk_uint8_t ** | p, |
| duk_uint32_t | val | ||
| ) |
| DUK_INTERNAL void duk_raw_writeinc_xutf8 | ( | duk_uint8_t ** | p, |
| duk_ucodepoint_t | val | ||
| ) |
| DUK_EXTERNAL void * duk_realloc | ( | duk_hthread * | thr, |
| void * | ptr, | ||
| duk_size_t | size | ||
| ) |
Definition at line 17594 of file duktape.c.
References DUK_ALLOC, DUK_ASSERT_API_ENTRY, and duk_hthread::heap.
| DUK_EXTERNAL void * duk_realloc_raw | ( | duk_hthread * | thr, |
| void * | ptr, | ||
| duk_size_t | size | ||
| ) |
Definition at line 17576 of file duktape.c.
References DUK_ALLOC_RAW, DUK_ASSERT_API_ENTRY, and duk_hthread::heap.
| DUK_EXTERNAL duk_ret_t duk_reference_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 25172 of file duktape.c.
References DUK__ERROR_STASH_SHARED, DUK_ASSERT_API_ENTRY, and DUK_ERR_ERROR.
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_refzero_check_fast | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL void duk_refzero_check_slow | ( | duk_hthread * | thr | ) |
Definition at line 54607 of file duktape.c.
References DUK_ASSERT, duk_heap_process_finalize_list(), DUK_UNLIKELY, duk_heap::finalize_list, duk_hthread::heap, and duk_heap::refzero_list.
| DUK_INTERNAL void duk_regexp_compile | ( | duk_hthread * | thr | ) |
Definition at line 91641 of file duktape.c.
References DUK_ASC_BACKSLASH, and DUK_BW_ENSURE_RAW.
| DUK_INTERNAL void duk_regexp_create_instance | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL void duk_regexp_match | ( | duk_hthread * | thr | ) |
Definition at line 92843 of file duktape.c.
Referenced by duk_bi_regexp_prototype_test(), and duk_bi_string_prototype_replace().
| DUK_INTERNAL void duk_regexp_match_force_global | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_remove | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 19974 of file duktape.c.
Referenced by duk_hobject_get_enumerated_keys(), duk_remove_n(), dukky_populate_object(), and dukky_push_generics().
| DUK_INTERNAL void duk_remove_m2 | ( | duk_hthread * | thr | ) |
Definition at line 20019 of file duktape.c.
Referenced by duk_hobject_get_enumerated_keys().
| DUK_INTERNAL void duk_remove_n | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_idx_t | count | ||
| ) |
Definition at line 20025 of file duktape.c.
References DUK_ASSERT_API_ENTRY, and duk_remove().
| DUK_INTERNAL void duk_remove_n_unsafe | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_idx_t | count | ||
| ) |
Definition at line 20070 of file duktape.c.
References DUK_TVAL_SET_UNDEFINED.
| DUK_INTERNAL void duk_remove_unsafe | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL int duk_repl_fpclassify | ( | double | x | ) |
Definition at line 11438 of file duktape.c.
References duk_double_union::d, DUK_FP_NORMAL, DUK_FP_SUBNORMAL, DUK_FP_ZERO, duk_double_union::ui, and duk_double_union::us.
| DUK_INTERNAL int duk_repl_isfinite | ( | double | x | ) |
| DUK_INTERNAL int duk_repl_isinf | ( | double | x | ) |
| DUK_INTERNAL int duk_repl_isnan | ( | double | x | ) |
Definition at line 11489 of file duktape.c.
References DUK_FP_INFINITE, DUK_FP_NAN, and DUK_FPCLASSIFY.
| DUK_INTERNAL int duk_repl_signbit | ( | double | x | ) |
| DUK_EXTERNAL void duk_replace | ( | duk_hthread * | thr, |
| duk_idx_t | to_idx | ||
| ) |
Definition at line 19937 of file duktape.c.
Referenced by duk__concat_and_join_helper(), duk__error_getter_helper(), duk__safe_to_stacktrace_raw(), duk_hobject_define_property_helper(), duk_lexer_parse_js_input_element(), duk_lexer_setpoint(), and dukky_push_event().
| DUK_EXTERNAL duk_bool_t duk_require_boolean | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20243 of file duktape.c.
References duk__get_boolean_raw(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL void * duk_require_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size | ||
| ) |
Definition at line 20703 of file duktape.c.
Referenced by duk_get_buffer_default().
| DUK_EXTERNAL void * duk_require_buffer_data | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size | ||
| ) |
Definition at line 20807 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_check_type_mask(), duk_require_buffer_data(), DUK_TYPE_MASK_NONE, and DUK_TYPE_MASK_UNDEFINED.
Referenced by duk_require_buffer_data().
| DUK_EXTERNAL duk_c_function duk_require_c_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_require_constructable | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_require_constructor_call | ( | duk_hthread * | thr | ) |
Definition at line 15577 of file duktape.c.
References duk_hthread::callstack_curr, DUK_ACT_FLAG_CONSTRUCT, DUK_ASSERT_API_ENTRY, and duk_activation::flags.
| DUK_EXTERNAL duk_hthread * duk_require_context | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21074 of file duktape.c.
Referenced by js_newthread().
| DUK_EXTERNAL void duk_require_function | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_hbuffer * duk_require_hbuffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20900 of file duktape.c.
References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_OBJECT, and DUK_WO_NORETURN.
| DUK_INTERNAL duk_hcompfunc * duk_require_hcompfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20950 of file duktape.c.
References duk__get_tagged_heaphdr_raw(), DUK_ASSERT_API_ENTRY, DUK_HOBJECT_IS_COMPFUNC, DUK_TAG_OBJECT, and DUK_UNLIKELY.
| DUK_EXTERNAL void * duk_require_heapptr | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_hnatfunc * duk_require_hnatfunc | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20975 of file duktape.c.
References duk__get_tagged_heaphdr_raw(), DUK_ASSERT_API_ENTRY, DUK_HOBJECT_IS_NATFUNC, DUK_TAG_OBJECT, and DUK_UNLIKELY.
| DUK_INTERNAL duk_hobject * duk_require_hobject | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20882 of file duktape.c.
References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_STRING, and DUK_WO_NORETURN.
Referenced by duk_bi_reflect_object_delete_property(), duk_bi_thread_resume(), duk_bi_typedarray_set(), and duk_xdef_prop_stridx().
| DUK_INTERNAL duk_hobject * duk_require_hobject_accept_mask | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | type_mask | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_require_hobject_promote_mask | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_uint_t | type_mask | ||
| ) |
Definition at line 21205 of file duktape.c.
References duk__get_hobject_promote_mask_raw(), DUK_ASSERT_API_ENTRY, and DUK_TYPE_MASK_PROMOTE.
| DUK_INTERNAL duk_hobject * duk_require_hobject_with_class | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_small_uint_t | classnum | ||
| ) |
Definition at line 21232 of file duktape.c.
Referenced by duk_bi_regexp_constructor().
| DUK_INTERNAL duk_hstring * duk_require_hstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20851 of file duktape.c.
References duk__get_tagged_heaphdr_raw(), DUK_ASSERT_API_ENTRY, DUK_HSTRING_HAS_SYMBOL, DUK_TAG_STRING, and DUK_UNLIKELY.
Referenced by duk__concat_and_join_helper(), and duk_hobject_define_property_helper().
| DUK_INTERNAL duk_hstring * duk_require_hstring_notsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_hthread * duk_require_hthread | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20925 of file duktape.c.
References duk__get_tagged_heaphdr_raw(), DUK_ASSERT_API_ENTRY, DUK_HOBJECT_IS_THREAD, DUK_TAG_OBJECT, and DUK_UNLIKELY.
Referenced by duk_bi_thread_resume().
| DUK_EXTERNAL duk_int_t duk_require_int | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20365 of file duktape.c.
References duk__api_coerce_d2i(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL const char * duk_require_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len | ||
| ) |
| DUK_INTERNAL const char * duk_require_lstring_notsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len | ||
| ) |
| DUK_EXTERNAL duk_idx_t duk_require_normalize_index | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18945 of file duktape.c.
Referenced by duk_del_prop_index(), duk_get_prop_desc(), duk_get_prop_index(), and duk_has_prop_index().
| DUK_EXTERNAL void duk_require_null | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_double_t duk_require_number | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_require_object | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void * duk_require_pointer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_require_stack | ( | duk_hthread * | thr, |
| duk_idx_t | extra | ||
| ) |
Definition at line 19680 of file duktape.c.
Referenced by duk__error_getter_helper(), duk__handle_call_raw(), duk__load_func(), duk__parse_func_body(), duk_bi_array_prototype_join_shared(), duk_bi_string_prototype_replace(), and duk_err_create_and_throw().
| DUK_EXTERNAL void duk_require_stack_top | ( | duk_hthread * | thr, |
| duk_idx_t | top | ||
| ) |
| DUK_EXTERNAL const char * duk_require_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL const char * duk_require_string_notsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_idx_t duk_require_top_index | ( | duk_hthread * | thr | ) |
Definition at line 19309 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.
| DUK_INTERNAL duk_tval * duk_require_tval | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 19020 of file duktape.c.
References duk__const_tval_unused, DUK_ASSERT_API_ENTRY, duk_get_tval(), and DUK_LOSE_CONST.
Referenced by duk__to_primitive_helper(), duk_hobject_define_property_helper(), and duk_hobject_putprop().
| DUK_EXTERNAL duk_uint_t duk_require_uint | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 20371 of file duktape.c.
References duk__api_coerce_d2ui(), and DUK_ASSERT_API_ENTRY.
| DUK_EXTERNAL void duk_require_undefined | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_require_valid_index | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_tval * duk_reserve_gap | ( | duk_hthread * | thr, |
| duk_idx_t | idx_base, | ||
| duk_idx_t | count | ||
| ) |
| DUK_EXTERNAL void * duk_resize_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t | new_size | ||
| ) |
Definition at line 14348 of file duktape.c.
References DUK_ANSI_FREE, DUK_DDD, DUK_DDDPRINT, and DUK_UNREF.
| DUK_INTERNAL void duk_resolve_nonbound_function | ( | duk_hthread * | thr | ) |
Definition at line 15680 of file duktape.c.
Referenced by duk_bi_thread_resume().
| DUK_EXTERNAL void duk_resume | ( | duk_hthread * | thr, |
| const duk_thread_state * | state | ||
| ) |
| DUK_EXTERNAL duk_int_t duk_safe_call | ( | duk_hthread * | thr, |
| duk_safe_call_function | func, | ||
| void * | udata, | ||
| duk_idx_t | nargs, | ||
| duk_idx_t | nrets | ||
| ) |
Definition at line 15481 of file duktape.c.
References DUK_ERROR_TYPE_INVALID_ARGS, DUK_EXEC_ERROR, and DUK_WO_NORETURN.
Referenced by dukky_create_object(), dukky_log_stack_frame(), and dukky_push_node_stacked().
| DUK_EXTERNAL const char * duk_safe_to_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len | ||
| ) |
| DUK_EXTERNAL const char * duk_safe_to_stacktrace | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21844 of file duktape.c.
Referenced by dukky_dump_error().
| DUK_EXTERNAL duk_bool_t duk_samevalue | ( | duk_hthread * | thr, |
| duk_idx_t | idx1, | ||
| duk_idx_t | idx2 | ||
| ) |
| DUK_EXTERNAL void duk_seal | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
| DUK_INTERNAL void duk_seal_freeze_raw | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_bool_t | is_freeze | ||
| ) |
Definition at line 18284 of file duktape.c.
Referenced by duk_bi_object_constructor_is_sealed_frozen_shared().
| DUK_EXTERNAL void duk_set_finalizer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18628 of file duktape.c.
References DUK_ASSERT_API_ENTRY, duk_get_prop_stridx(), and DUK_STRIDX_INT_FINALIZER.
| DUK_EXTERNAL void duk_set_global_object | ( | duk_hthread * | thr | ) |
Definition at line 17230 of file duktape.c.
Referenced by js_newthread().
| DUK_EXTERNAL void duk_set_length | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t | len | ||
| ) |
Definition at line 21383 of file duktape.c.
References duk__known_heaphdr(), DUK_ASSERT, DUK_ASSERT_API_ENTRY, and duk_get_hcompfunc().
Referenced by duk__nud_array_literal().
| DUK_EXTERNAL void duk_set_magic | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | magic | ||
| ) |
| DUK_EXTERNAL void duk_set_prototype | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 18553 of file duktape.c.
Referenced by dukky_populate_object().
| DUK_EXTERNAL void duk_set_top | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 19098 of file duktape.c.
References DUK_ERROR_TYPE_INVALID_ARGS, and DUK_WO_NORETURN.
Referenced by duk__load_func(), duk_bi_array_prototype_join_shared(), duk_bi_array_prototype_splice(), duk_bi_pointer_constructor(), duk_hthread_terminate(), dukky_push_node_stacked(), js_closethread(), and js_exec().
| DUK_INTERNAL void duk_set_top_and_wipe | ( | duk_hthread * | thr, |
| duk_idx_t | top, | ||
| duk_idx_t | idx_wipe_start | ||
| ) |
Definition at line 19269 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_INTERNAL void duk_set_top_unsafe | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 19201 of file duktape.c.
Referenced by duk__handle_call_raw(), and duk_get_top_index().
| DUK_EXTERNAL void * duk_steal_buffer | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size | ||
| ) |
Definition at line 14367 of file duktape.c.
References DUK_ERROR_TYPE, DUK_STR_WRONG_BUFFER_TYPE, and DUK_WO_NORETURN.
| DUK_EXTERNAL duk_bool_t duk_strict_equals | ( | duk_hthread * | thr, |
| duk_idx_t | idx1, | ||
| duk_idx_t | idx2 | ||
| ) |
| DUK_EXTERNAL void duk_substring | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t | start_offset, | ||
| duk_size_t | end_offset | ||
| ) |
Definition at line 25825 of file duktape.c.
Referenced by duk__get_own_propdesc_raw().
| DUK_EXTERNAL void duk_suspend | ( | duk_hthread * | thr, |
| duk_thread_state * | state | ||
| ) |
| DUK_EXTERNAL void duk_swap | ( | duk_hthread * | thr, |
| duk_idx_t | idx1, | ||
| duk_idx_t | idx2 | ||
| ) |
| DUK_EXTERNAL void duk_swap_top | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_ret_t duk_syntax_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 25176 of file duktape.c.
References DUK__ERROR_STASH_SHARED, DUK_ASSERT_API_ENTRY, and DUK_ERR_EVAL_ERROR.
| DUK_INTERNAL duk_ret_t duk_textdecoder_decode_utf8_nodejs | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_throw_raw | ( | duk_hthread * | thr | ) |
Definition at line 25022 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, DUK_DDD, DUK_DDDPRINT, duk_err_augment_error_throw(), duk_err_setup_ljstate1(), DUK_ERROR_TYPE_INVALID_ARGS, duk_get_tval(), DUK_GET_TVAL_NEGIDX, duk_hthread_sync_and_null_currpc(), DUK_LJ_TYPE_THROW, DUK_UNLIKELY, DUK_WO_NORETURN, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.
| DUK_INTERNAL duk_double_t duk_time_get_ecmascript_time | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_double_t duk_time_get_ecmascript_time_nofrac | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_double_t duk_time_get_monotonic_time | ( | duk_hthread * | thr | ) |
| DUK_EXTERNAL void duk_time_to_components | ( | duk_hthread * | thr, |
| duk_double_t | timeval, | ||
| duk_time_components * | comp | ||
| ) |
| DUK_EXTERNAL duk_bool_t duk_to_boolean | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21531 of file duktape.c.
References duk__to_primitive_helper().
Referenced by duk_bi_array_prototype_iter_shared(), duk_bi_buffer_readfield(), and dukky_generic_event_handler().
| DUK_INTERNAL duk_bool_t duk_to_boolean_top_pop | ( | duk_hthread * | thr | ) |
Definition at line 21550 of file duktape.c.
Referenced by duk_bi_thread_resume(), duk_bi_thread_yield(), and duk_hobject_putprop().
| DUK_EXTERNAL void * duk_to_buffer_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_size, | ||
| duk_uint_t | mode | ||
| ) |
| DUK_INTERNAL duk_hobject * duk_to_hobject | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_hstring * duk_to_hstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22157 of file duktape.c.
Referenced by duk__concat_and_join_helper(), and duk_bi_string_prototype_replace().
| DUK_INTERNAL duk_hstring * duk_to_hstring_acceptsymbol | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_hstring * duk_to_hstring_m1 | ( | duk_hthread * | thr | ) |
Definition at line 22168 of file duktape.c.
References DUK_ASSERT_API_ENTRY.
Referenced by duk__push_this_helper(), and duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_int_t duk_to_int | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21660 of file duktape.c.
Referenced by duk__init_varmap_and_prologue_for_pass2(), duk_bi_buffer_readfield(), duk_bi_typedarray_set(), and dukky_generic_event_handler().
| DUK_EXTERNAL duk_int32_t duk_to_int32 | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL duk_int_t duk_to_int_check_range | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | minval, | ||
| duk_int_t | maxval | ||
| ) |
| DUK_INTERNAL duk_int_t duk_to_int_clamped | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | minval, | ||
| duk_int_t | maxval | ||
| ) |
Definition at line 22046 of file duktape.c.
Referenced by duk_bi_array_prototype_splice().
| DUK_INTERNAL duk_int_t duk_to_int_clamped_raw | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | minval, | ||
| duk_int_t | maxval, | ||
| duk_bool_t * | out_clamped | ||
| ) |
| DUK_EXTERNAL const char * duk_to_lstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_size_t * | out_len | ||
| ) |
Definition at line 21765 of file duktape.c.
Referenced by duk__prep_codec_arg(), and duk_bi_symbol_constructor_shared().
| DUK_EXTERNAL void duk_to_null | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_double_t duk_to_number | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21566 of file duktape.c.
Referenced by duk__math_minmax(), duk_bi_global_object_decode_uri(), and duk_bi_global_object_is_finite().
| DUK_INTERNAL duk_double_t duk_to_number_m1 | ( | duk_hthread * | thr | ) |
Definition at line 21586 of file duktape.c.
Referenced by duk__error_getter_helper(), duk_hobject_putprop(), and duk_lexer_parse_js_input_element().
| DUK_INTERNAL duk_double_t duk_to_number_m2 | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_double_t duk_to_number_tval | ( | duk_hthread * | thr, |
| duk_tval * | tv | ||
| ) |
| DUK_EXTERNAL void duk_to_object | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22345 of file duktape.c.
Referenced by duk_bi_array_prototype_join_shared(), and duk_bi_object_constructor_is_extensible().
| DUK_EXTERNAL void * duk_to_pointer | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22263 of file duktape.c.
Referenced by duk_bi_pointer_constructor().
| DUK_EXTERNAL void duk_to_primitive | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | hint | ||
| ) |
Definition at line 21520 of file duktape.c.
Referenced by duk_js_data_compare().
| DUK_INTERNAL void duk_to_primitive_ordinary | ( | duk_hthread * | thr, |
| duk_idx_t | idx, | ||
| duk_int_t | hint | ||
| ) |
| DUK_INTERNAL duk_hstring * duk_to_property_key_hstring | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL const char * duk_to_stacktrace | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL const char * duk_to_string | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 22059 of file duktape.c.
Referenced by duk_bi_array_prototype_join_shared(), and duk_bi_string_prototype_replace().
| DUK_EXTERNAL duk_uint_t duk_to_uint | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_uint16_t duk_to_uint16 | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL duk_uint32_t duk_to_uint32 | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21694 of file duktape.c.
Referenced by duk_hobject_putprop().
| DUK_INTERNAL duk_uint8_t duk_to_uint8clamped | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_EXTERNAL void duk_to_undefined | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 21418 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_EXTERNAL void duk_trim | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked_fastint | ( | duk_tval * | tv | ) |
| DUK_INTERNAL DUK_ALWAYS_INLINE void duk_tval_set_number_chkfast_fast | ( | duk_tval * | tv, |
| duk_double_t | x | ||
| ) |
| DUK_INTERNAL DUK_NOINLINE void duk_tval_set_number_chkfast_slow | ( | duk_tval * | tv, |
| duk_double_t | x | ||
| ) |
Definition at line 93669 of file duktape.c.
References DUK_I64_CONSTANT, and DUK_TVAL_SET_FASTINT.
| DUK_EXTERNAL duk_ret_t duk_type_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 25180 of file duktape.c.
References DUK__ERROR_STASH_SHARED, DUK_ASSERT_API_ENTRY, and DUK_ERR_RANGE_ERROR.
| DUK_INTERNAL void duk_unicode_case_convert_string | ( | duk_hthread * | thr, |
| duk_bool_t | uppercase | ||
| ) |
Definition at line 13719 of file duktape.c.
Referenced by duk_bi_string_prototype_indexof_shared().
| DUK_INTERNAL 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 12823 of file duktape.c.
Referenced by duk__push_hstring_readable_unicode().
| DUK_INTERNAL 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 12920 of file duktape.c.
Referenced by duk__match_regexp(), duk__transform_callback_encode_uri(), and duk__utf8_backtrack().
| DUK_INTERNAL duk_small_int_t duk_unicode_encode_cesu8 | ( | duk_ucodepoint_t | cp, |
| duk_uint8_t * | out | ||
| ) |
| DUK_INTERNAL duk_small_int_t duk_unicode_encode_xutf8 | ( | duk_ucodepoint_t | cp, |
| duk_uint8_t * | out | ||
| ) |
Definition at line 12729 of file duktape.c.
Referenced by duk__push_hstring_readable_unicode().
| DUK_INTERNAL duk_small_int_t duk_unicode_get_xutf8_length | ( | duk_ucodepoint_t | cp | ) |
| DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_part | ( | duk_codepoint_t | cp | ) |
Definition at line 13368 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_start | ( | duk_codepoint_t | cp | ) |
Definition at line 13295 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_INTERNAL duk_small_int_t duk_unicode_is_letter | ( | duk_codepoint_t | cp | ) |
Definition at line 13455 of file duktape.c.
Referenced by duk__case_transform_helper().
| DUK_INTERNAL duk_small_int_t duk_unicode_is_line_terminator | ( | duk_codepoint_t | cp | ) |
Definition at line 13276 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_INTERNAL duk_bool_t duk_unicode_is_utf8_compatible | ( | const duk_uint8_t * | buf, |
| duk_size_t | len | ||
| ) |
| DUK_INTERNAL duk_small_int_t duk_unicode_is_whitespace | ( | duk_codepoint_t | cp | ) |
Definition at line 13198 of file duktape.c.
Referenced by duk_lexer_parse_js_input_element().
| DUK_INTERNAL duk_codepoint_t duk_unicode_re_canonicalize_char | ( | duk_hthread * | thr, |
| duk_codepoint_t | cp | ||
| ) |
Definition at line 13783 of file duktape.c.
Referenced by duk__match_regexp().
| DUK_INTERNAL duk_small_int_t duk_unicode_re_is_wordchar | ( | duk_codepoint_t | cp | ) |
| DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length | ( | const duk_uint8_t * | data, |
| duk_size_t | blen | ||
| ) |
| DUK_INTERNAL duk_idx_t duk_unpack_array_like | ( | duk_hthread * | thr, |
| duk_idx_t | idx | ||
| ) |
Definition at line 24909 of file duktape.c.
References DUK_TVAL_SET_UNDEFINED.
| DUK_EXTERNAL duk_ret_t duk_uri_error_stash | ( | duk_hthread * | thr, |
| const char * | fmt, | ||
| ... | |||
| ) |
Definition at line 25184 of file duktape.c.
References DUK__ERROR_STASH_SHARED, DUK_ASSERT_API_ENTRY, and DUK_ERR_REFERENCE_ERROR.
| DUK_INTERNAL duk_double_t duk_util_get_random_double | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL duk_double_t duk_util_tinyrandom_get_double | ( | duk_hthread * | thr | ) |
Definition at line 101070 of file duktape.c.
References DUK_ASSERT, and DUK_MEMCMP.
| DUK_INTERNAL void duk_util_tinyrandom_prepare_seed | ( | duk_hthread * | thr | ) |
| DUK_INTERNAL DUK_INLINE duk_bool_t duk_valstack_grow_check_nothrow | ( | duk_hthread * | thr, |
| duk_size_t | min_bytes | ||
| ) |
| DUK_INTERNAL DUK_INLINE void duk_valstack_grow_check_throw | ( | duk_hthread * | thr, |
| duk_size_t | min_bytes | ||
| ) |
Definition at line 19556 of file duktape.c.
Referenced by duk__handle_call_raw().
| DUK_INTERNAL void duk_valstack_shrink_check_nothrow | ( | duk_hthread * | thr, |
| duk_bool_t | snug | ||
| ) |
| DUK_EXTERNAL void duk_xcopymove_raw | ( | duk_hthread * | to_thr, |
| duk_hthread * | from_thr, | ||
| duk_idx_t | count, | ||
| duk_bool_t | is_copy | ||
| ) |
| DUK_INTERNAL void duk_xdef_prop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | desc_flags | ||
| ) |
Definition at line 18072 of file duktape.c.
References duk_has_prop_stridx().
Referenced by duk__load_func().
| DUK_INTERNAL void duk_xdef_prop_index | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_uarridx_t | arr_idx, | ||
| duk_small_uint_t | desc_flags | ||
| ) |
| DUK_INTERNAL void duk_xdef_prop_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx, | ||
| duk_small_uint_t | desc_flags | ||
| ) |
Definition at line 18101 of file duktape.c.
References DUK_ASSERT, DUK_ASSERT_API_ENTRY, duk_hobject_define_property_internal_arridx(), and duk_require_hobject().
| DUK_INTERNAL void duk_xdef_prop_stridx_short_raw | ( | duk_hthread * | thr, |
| duk_uint_t | packed_args | ||
| ) |
| DUK_INTERNAL void duk_xdef_prop_stridx_thrower | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_xget_owndataprop | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_xget_owndataprop_stridx | ( | duk_hthread * | thr, |
| duk_idx_t | obj_idx, | ||
| duk_small_uint_t | stridx | ||
| ) |
| DUK_INTERNAL duk_bool_t duk_xget_owndataprop_stridx_short_raw | ( | duk_hthread * | thr, |
| duk_uint_t | packed_args | ||
| ) |
| DUK_LOCAL const duk_int8_t duk__base64_decode_nequal_step[5] |
| DUK_LOCAL const duk_int8_t duk__base64_dectab_fast[256] |
| DUK_LOCAL const duk_uint8_t duk__base64_enctab_fast[64] |
Definition at line 15774 of file duktape.c.
Referenced by duk__base64_encode_fast_1().
| DUK_LOCAL const duk_uint8_t duk__bitpacked_lookup[16] |
|
static |
|
static |
Definition at line 27861 of file duktape.c.
Referenced by duk_bi_typedarray_set().
|
static |
|
static |
|
static |
| DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[] |
| DUK_LOCAL const duk_tval_unused duk__const_tval_unused = DUK_TVAL_UNUSED_INITIALIZER() |
Definition at line 19006 of file duktape.c.
Referenced by duk_require_tval().
|
static |
Definition at line 34036 of file duktape.c.
Referenced by duk_bi_date_constructor().
| DUK_LOCAL duk_uint8_t duk__days_in_month[12] |
| DUK_LOCAL const duk_uint8_t duk__decode_uri_component_reserved_table[16] |
| DUK_LOCAL const duk_uint8_t duk__decode_uri_reserved_table[16] |
Definition at line 36686 of file duktape.c.
Referenced by duk_bi_global_object_encode_uri().
| DUK_LOCAL const duk_uint8_t duk__encode_uricomponent_unescaped_table[16] |
Definition at line 36674 of file duktape.c.
Referenced by duk_bi_global_object_unescape().
| DUK_LOCAL const duk_uint8_t duk__encode_uriunescaped_table[16] |
Definition at line 36662 of file duktape.c.
Referenced by duk_bi_global_object_escape().
| DUK_LOCAL const duk_uint8_t duk__escape_unescaped_table[16] |
| DUK_LOCAL const duk_uint8_t duk__json_decnumber_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_quotestr_lookup[256] |
| DUK_LOCAL const duk_small_uint_t duk__object_keys_enum_flags[4] |
| DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[] |
| DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[] |
| DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[] |
| DUK_LOCAL const duk_uint16_t* const duk__re_range_lookup1[3] |
| DUK_LOCAL const duk_uint8_t duk__re_range_lookup2[3] |
| DUK_LOCAL const duk_uint8_t duk__str2num_digits_for_radix[] |
| DUK_LOCAL const duk__exp_limits duk__str2num_exp_limits[] |
| DUK_LOCAL const char* const duk__symbol_type_strings[4] = { "hidden", "global", "local", "wellknown" } |
| DUK_LOCAL const char* const duk__toprim_hint_strings[3] = { "default", "string", "number" } |
| DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[] |
| DUK_LOCAL const duk_uint_t duk__type_from_tag[] |
| DUK_LOCAL const duk_uint_t duk__type_mask_from_tag[] |
| DUK_EXTERNAL const char* duk_api_global_filename = NULL |
| DUK_EXTERNAL duk_int_t duk_api_global_line = 0 |
| DUK_INTERNAL const duk_c_function duk_bi_native_functions[185] |
| DUK_INTERNAL duk_uint8_t duk_class_number_to_stridx[32] |
| DUK_INTERNAL const duk_int8_t duk_hex_dectab[256] |
Definition at line 14044 of file duktape.c.
Referenced by duk__lexer_parse_escape().
| 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_int8_t duk_is_idchar_tab[128] |
| DUK_INTERNAL const duk_uint8_t duk_lc_digits[36] |
Definition at line 14027 of file duktape.c.
Referenced by duk__json_enc_buffer_data(), duk__json_enc_key_autoquote(), duk__push_hstring_readable_unicode(), and duk_heap_strtable_intern_checked().
| DUK_INTERNAL const duk_uint8_t duk_strings_data[972] |
| DUK_INTERNAL const duk_uint8_t duk_uc_nybbles[16] |
| const duk_uint8_t duk_unicode_caseconv_lc |
Definition at line 94039 of file duktape.c.
Referenced by duk__case_transform_helper().
| const duk_uint8_t duk_unicode_caseconv_uc |
Definition at line 93973 of file duktape.c.
Referenced by duk__case_transform_helper().
| const duk_uint8_t duk_unicode_idp_m_ids_noa |
| const duk_uint8_t duk_unicode_ids_m_let_noa |
| const duk_uint8_t duk_unicode_re_canon_bitmap |
Definition at line 99915 of file duktape.c.
Referenced by duk__regexp_generate_ranges().
| DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_digit[2] |
Definition at line 13834 of file duktape.c.
Referenced by duk__parse_disjunction().
| 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_uint16_t duk_unicode_re_ranges_white[22] |
Definition at line 13838 of file duktape.c.
Referenced by duk__parse_disjunction().
| DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_wordchar[8] |
Definition at line 13845 of file duktape.c.
Referenced by duk__parse_disjunction().
| DUK_INTERNAL const duk_uint8_t duk_unicode_xutf8_markers[7] = { 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe } |
1.9.4