duk_hthread.h File Reference

Go to the source code of this file.

Data Structures
struct	duk_activation
struct	duk_catcher
struct	duk_hthread

Macros
#define	DUK_VALSTACK_GROW_STEP   128 /* roughly 1 kiB */
#define	DUK_VALSTACK_SHRINK_THRESHOLD   256 /* roughly 2 kiB */
#define	DUK_VALSTACK_SHRINK_SPARE   64 /* roughly 0.5 kiB */
#define	DUK_VALSTACK_INITIAL_SIZE   128 /* roughly 1.0 kiB -> but rounds up to DUK_VALSTACK_GROW_STEP in practice */
#define	DUK_VALSTACK_INTERNAL_EXTRA
#define	DUK_VALSTACK_API_ENTRY_MINIMUM   DUK_API_ENTRY_STACK
#define	DUK_VALSTACK_DEFAULT_MAX   1000000L
#define	DUK_CALLSTACK_GROW_STEP   8 /* roughly 256 bytes */
#define	DUK_CALLSTACK_SHRINK_THRESHOLD   16 /* roughly 512 bytes */
#define	DUK_CALLSTACK_SHRINK_SPARE   8 /* roughly 256 bytes */
#define	DUK_CALLSTACK_INITIAL_SIZE   8
#define	DUK_CALLSTACK_DEFAULT_MAX   10000L
#define	DUK_CATCHSTACK_GROW_STEP   4 /* roughly 64 bytes */
#define	DUK_CATCHSTACK_SHRINK_THRESHOLD   8 /* roughly 128 bytes */
#define	DUK_CATCHSTACK_SHRINK_SPARE   4 /* roughly 64 bytes */
#define	DUK_CATCHSTACK_INITIAL_SIZE   4
#define	DUK_CATCHSTACK_DEFAULT_MAX   10000L
#define	DUK_ACT_FLAG_STRICT   (1 << 0) /* function executes in strict mode */
#define	DUK_ACT_FLAG_TAILCALLED   (1 << 1) /* activation has tail called one or more times */
#define	DUK_ACT_FLAG_CONSTRUCT   (1 << 2) /* function executes as a constructor (called via "new") */
#define	DUK_ACT_FLAG_PREVENT_YIELD   (1 << 3) /* activation prevents yield (native call or "new") */
#define	DUK_ACT_FLAG_DIRECT_EVAL   (1 << 4) /* activation is a direct eval call */
#define	DUK_ACT_FLAG_BREAKPOINT_ACTIVE   (1 << 5) /* activation has active breakpoint(s) */
#define	DUK_ACT_GET_FUNC(act)   ((act)->func)
#define	DUK_TB_FLAG_NOBLAME_FILELINE   (1 << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */
#define	DUK_CAT_TYPE_MASK   0x0000000fUL
#define	DUK_CAT_TYPE_BITS   4
#define	DUK_CAT_LABEL_MASK   0xffffff00UL
#define	DUK_CAT_LABEL_BITS   24
#define	DUK_CAT_LABEL_SHIFT   8
#define	DUK_CAT_FLAG_CATCH_ENABLED   (1 << 4) /* catch part will catch */
#define	DUK_CAT_FLAG_FINALLY_ENABLED   (1 << 5) /* finally part will catch */
#define	DUK_CAT_FLAG_CATCH_BINDING_ENABLED   (1 << 6) /* request to create catch binding */
#define	DUK_CAT_FLAG_LEXENV_ACTIVE   (1 << 7) /* catch or with binding is currently active */
#define	DUK_CAT_TYPE_UNKNOWN   0
#define	DUK_CAT_TYPE_TCF   1
#define	DUK_CAT_TYPE_LABEL   2
#define	DUK_CAT_GET_TYPE(c)   ((c)->flags & DUK_CAT_TYPE_MASK)
#define	DUK_CAT_GET_LABEL(c)   (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT)
#define	DUK_CAT_HAS_CATCH_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED)
#define	DUK_CAT_HAS_FINALLY_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED)
#define	DUK_CAT_HAS_CATCH_BINDING_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED)
#define	DUK_CAT_HAS_LEXENV_ACTIVE(c)   ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)
#define	DUK_CAT_SET_CATCH_ENABLED(c)
#define	DUK_CAT_SET_FINALLY_ENABLED(c)
#define	DUK_CAT_SET_CATCH_BINDING_ENABLED(c)
#define	DUK_CAT_SET_LEXENV_ACTIVE(c)
#define	DUK_CAT_CLEAR_CATCH_ENABLED(c)
#define	DUK_CAT_CLEAR_FINALLY_ENABLED(c)
#define	DUK_CAT_CLEAR_CATCH_BINDING_ENABLED(c)
#define	DUK_CAT_CLEAR_LEXENV_ACTIVE(c)
#define	DUK_HTHREAD_GET_STRING(thr, idx)    ((thr)->strs[(idx)])
#define	DUK_HTHREAD_GET_CURRENT_ACTIVATION(thr)   (&(thr)->callstack[(thr)->callstack_top - 1])
#define	DUK_HTHREAD_STATE_INACTIVE   1 /* thread not currently running */
#define	DUK_HTHREAD_STATE_RUNNING   2 /* thread currently running (only one at a time) */
#define	DUK_HTHREAD_STATE_RESUMED   3 /* thread resumed another thread (active but not running) */
#define	DUK_HTHREAD_STATE_YIELDED   4 /* thread has yielded */
#define	DUK_HTHREAD_STATE_TERMINATED   5 /* thread has terminated */
#define	DUK_ASSERT_CTX_VSSIZE(ctx)
#define	DUK_ASSERT_CTX_VALID(ctx)

Functions
DUK_INTERNAL_DECL void	duk_hthread_copy_builtin_objects (duk_hthread *thr_from, duk_hthread *thr_to)
DUK_INTERNAL_DECL void	duk_hthread_create_builtin_objects (duk_hthread *thr)
DUK_INTERNAL_DECL duk_bool_t	duk_hthread_init_stacks (duk_heap *heap, duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_terminate (duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_callstack_grow (duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_callstack_shrink_check (duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_callstack_unwind (duk_hthread *thr, duk_size_t new_top)
DUK_INTERNAL_DECL void	duk_hthread_catchstack_grow (duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_catchstack_shrink_check (duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_catchstack_unwind (duk_hthread *thr, duk_size_t new_top)
DUK_INTERNAL_DECL duk_activation *	duk_hthread_get_current_activation (duk_hthread *thr)
DUK_INTERNAL_DECL void *	duk_hthread_get_valstack_ptr (duk_heap *heap, void *ud)
DUK_INTERNAL_DECL void *	duk_hthread_get_callstack_ptr (duk_heap *heap, void *ud)
DUK_INTERNAL_DECL void *	duk_hthread_get_catchstack_ptr (duk_heap *heap, void *ud)
DUK_INTERNAL_DECL duk_uint_fast32_t	duk_hthread_get_act_prev_pc (duk_hthread *thr, duk_activation *act)
DUK_INTERNAL_DECL void	duk_hthread_sync_currpc (duk_hthread *thr)
DUK_INTERNAL_DECL void	duk_hthread_sync_and_null_currpc (duk_hthread *thr)

Macro Definition Documentation

DUK_ACT_FLAG_BREAKPOINT_ACTIVE

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

Definition at line 53 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ACT_FLAG_CONSTRUCT

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

Definition at line 50 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ACT_FLAG_DIRECT_EVAL

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

Definition at line 52 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ACT_FLAG_PREVENT_YIELD

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

Definition at line 51 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ACT_FLAG_STRICT

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

Definition at line 48 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ACT_FLAG_TAILCALLED

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

Definition at line 49 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ACT_GET_FUNC

#define DUK_ACT_GET_FUNC

(

act

)

((act)->func)

Definition at line 55 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_ASSERT_CTX_VALID

#define DUK_ASSERT_CTX_VALID

(

ctx

)

Value:

        do { \
        DUK_ASSERT((ctx) != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \
        DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused2 == 0); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack != NULL); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack_bottom); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack_top); \
        DUK_ASSERT_CTX_VSSIZE((ctx)); \
    } while (0)

Definition at line 167 of file duktape-1.5.2/src-separate/duk_hthread.h.

    DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \
        ((duk_hthread *) (ctx))->valstack_size)
#endif
#define DUK_ASSERT_CTX_VALID(ctx) do { \
        DUK_ASSERT((ctx) != NULL); \
        DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \
        DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \
        DUK_ASSERT(((duk_hthread *) (ctx))->unused2 == 0); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack != NULL); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack); \
        DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack_bottom); \

DUK_ASSERT_CTX_VSSIZE

#define DUK_ASSERT_CTX_VSSIZE

(

ctx

)

Value:

    DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \
        ((duk_hthread *) (ctx))->valstack_size)

Definition at line 163 of file duktape-1.5.2/src-separate/duk_hthread.h.

#if defined(DUK_USE_PREFER_SIZE)
#define DUK_ASSERT_CTX_VSSIZE(ctx)  /*nop*/
#else

DUK_CALLSTACK_DEFAULT_MAX

#define DUK_CALLSTACK_DEFAULT_MAX   10000L

Definition at line 36 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CALLSTACK_GROW_STEP

#define DUK_CALLSTACK_GROW_STEP   8 /* roughly 256 bytes */

Definition at line 32 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CALLSTACK_INITIAL_SIZE

#define DUK_CALLSTACK_INITIAL_SIZE   8

Definition at line 35 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CALLSTACK_SHRINK_SPARE

#define DUK_CALLSTACK_SHRINK_SPARE   8 /* roughly 256 bytes */

Definition at line 34 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CALLSTACK_SHRINK_THRESHOLD

#define DUK_CALLSTACK_SHRINK_THRESHOLD   16 /* roughly 512 bytes */

Definition at line 33 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_CLEAR_CATCH_BINDING_ENABLED

#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED

(

c

)

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
    } while (0)

Definition at line 110 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_CLEAR_FINALLY_ENABLED(c)  do { \
        (c)->flags &= ~DUK_CAT_FLAG_FINALLY_ENABLED; \
    } while (0)

DUK_CAT_CLEAR_CATCH_ENABLED

#define DUK_CAT_CLEAR_CATCH_ENABLED

(

c

)

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)

Definition at line 104 of file duktape-1.5.2/src-separate/duk_hthread.h.

        (c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \
    } while (0)
 

DUK_CAT_CLEAR_FINALLY_ENABLED

#define DUK_CAT_CLEAR_FINALLY_ENABLED

(

c

)

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_FINALLY_ENABLED; \
    } while (0)

Definition at line 107 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_CLEAR_CATCH_ENABLED(c)    do { \
        (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)

DUK_CAT_CLEAR_LEXENV_ACTIVE

#define DUK_CAT_CLEAR_LEXENV_ACTIVE

(

c

)

Value:

        do { \
        (c)->flags &= ~DUK_CAT_FLAG_LEXENV_ACTIVE; \
    } while (0)

Definition at line 113 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED(c)    do { \
        (c)->flags &= ~DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
    } while (0)

DUK_CAT_FLAG_CATCH_BINDING_ENABLED

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

Definition at line 76 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_FLAG_CATCH_ENABLED

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

Definition at line 74 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_FLAG_FINALLY_ENABLED

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

Definition at line 75 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_FLAG_LEXENV_ACTIVE

#define DUK_CAT_FLAG_LEXENV_ACTIVE   (1 << 7) /* catch or with binding is currently active */

Definition at line 77 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_GET_LABEL

#define DUK_CAT_GET_LABEL

(

c

)

(((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT)

Definition at line 84 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_GET_TYPE

#define DUK_CAT_GET_TYPE

(

c

)

((c)->flags & DUK_CAT_TYPE_MASK)

Definition at line 83 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_HAS_CATCH_BINDING_ENABLED

#define DUK_CAT_HAS_CATCH_BINDING_ENABLED

(

c

)

((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED)

Definition at line 88 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_HAS_CATCH_ENABLED

#define DUK_CAT_HAS_CATCH_ENABLED

(

c

)

((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED)

Definition at line 86 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_HAS_FINALLY_ENABLED

#define DUK_CAT_HAS_FINALLY_ENABLED

(

c

)

((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED)

Definition at line 87 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_HAS_LEXENV_ACTIVE

#define DUK_CAT_HAS_LEXENV_ACTIVE

(

c

)

((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)

Definition at line 89 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_LABEL_BITS

#define DUK_CAT_LABEL_BITS   24

Definition at line 71 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_LABEL_MASK

#define DUK_CAT_LABEL_MASK   0xffffff00UL

Definition at line 70 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_LABEL_SHIFT

#define DUK_CAT_LABEL_SHIFT   8

Definition at line 72 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_SET_CATCH_BINDING_ENABLED

#define DUK_CAT_SET_CATCH_BINDING_ENABLED

(

c

)

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
    } while (0)

Definition at line 97 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_SET_FINALLY_ENABLED(c)  do { \
        (c)->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; \
    } while (0)

DUK_CAT_SET_CATCH_ENABLED

#define DUK_CAT_SET_CATCH_ENABLED

(

c

)

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)

Definition at line 91 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_HAS_CATCH_BINDING_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED)
#define DUK_CAT_HAS_LEXENV_ACTIVE(c)           ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)
 

DUK_CAT_SET_FINALLY_ENABLED

#define DUK_CAT_SET_FINALLY_ENABLED

(

c

)

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; \
    } while (0)

Definition at line 94 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_SET_CATCH_ENABLED(c)    do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \
    } while (0)

DUK_CAT_SET_LEXENV_ACTIVE

#define DUK_CAT_SET_LEXENV_ACTIVE

(

c

)

Value:

        do { \
        (c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \
    } while (0)

Definition at line 100 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c)    do { \
        (c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
    } while (0)

DUK_CAT_TYPE_BITS

#define DUK_CAT_TYPE_BITS   4

Definition at line 69 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_TYPE_LABEL

#define DUK_CAT_TYPE_LABEL   2

Definition at line 81 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_TYPE_MASK

#define DUK_CAT_TYPE_MASK   0x0000000fUL

Definition at line 68 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_TYPE_TCF

#define DUK_CAT_TYPE_TCF   1

Definition at line 80 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CAT_TYPE_UNKNOWN

#define DUK_CAT_TYPE_UNKNOWN   0

Definition at line 79 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CATCHSTACK_DEFAULT_MAX

#define DUK_CATCHSTACK_DEFAULT_MAX   10000L

Definition at line 42 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CATCHSTACK_GROW_STEP

#define DUK_CATCHSTACK_GROW_STEP   4 /* roughly 64 bytes */

Definition at line 38 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CATCHSTACK_INITIAL_SIZE

#define DUK_CATCHSTACK_INITIAL_SIZE   4

Definition at line 41 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CATCHSTACK_SHRINK_SPARE

#define DUK_CATCHSTACK_SHRINK_SPARE   4 /* roughly 64 bytes */

Definition at line 40 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_CATCHSTACK_SHRINK_THRESHOLD

#define DUK_CATCHSTACK_SHRINK_THRESHOLD   8 /* roughly 128 bytes */

Definition at line 39 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_HTHREAD_GET_CURRENT_ACTIVATION

#define DUK_HTHREAD_GET_CURRENT_ACTIVATION

(

thr

)

(&(thr)->callstack[(thr)->callstack_top - 1])

Definition at line 134 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_HTHREAD_GET_STRING

#define DUK_HTHREAD_GET_STRING	(		thr,
			idx )    ((thr)->strs[(idx)])

Definition at line 129 of file duktape-1.5.2/src-separate/duk_hthread.h.

#define DUK_HTHREAD_GET_STRING(thr,idx) \
    ((duk_hstring *) DUK_USE_HEAPPTR_DEC16((thr)->heap->heap_udata, (thr)->strs16[(idx)]))

DUK_HTHREAD_STATE_INACTIVE

#define DUK_HTHREAD_STATE_INACTIVE   1 /* thread not currently running */

Definition at line 137 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_HTHREAD_STATE_RESUMED

#define DUK_HTHREAD_STATE_RESUMED   3 /* thread resumed another thread (active but not running) */

Definition at line 139 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_HTHREAD_STATE_RUNNING

#define DUK_HTHREAD_STATE_RUNNING   2 /* thread currently running (only one at a time) */

Definition at line 138 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_HTHREAD_STATE_TERMINATED

#define DUK_HTHREAD_STATE_TERMINATED   5 /* thread has terminated */

Definition at line 141 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_HTHREAD_STATE_YIELDED

#define DUK_HTHREAD_STATE_YIELDED   4 /* thread has yielded */

Definition at line 140 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_TB_FLAG_NOBLAME_FILELINE

#define DUK_TB_FLAG_NOBLAME_FILELINE   (1 << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */

Definition at line 61 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_API_ENTRY_MINIMUM

#define DUK_VALSTACK_API_ENTRY_MINIMUM   DUK_API_ENTRY_STACK

Definition at line 20 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_DEFAULT_MAX

#define DUK_VALSTACK_DEFAULT_MAX   1000000L

Definition at line 30 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_GROW_STEP

#define DUK_VALSTACK_GROW_STEP   128 /* roughly 1 kiB */

Definition at line 15 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_INITIAL_SIZE

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

Definition at line 18 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_INTERNAL_EXTRA

#define DUK_VALSTACK_INTERNAL_EXTRA

Value:

                                                 64      /* internal extra elements assumed on function entry,
                                                 * always added to user-defined 'extra' for e.g. the
                                                 * duk_check_stack() call.
                                                 */

Definition at line 19 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_SHRINK_SPARE

#define DUK_VALSTACK_SHRINK_SPARE   64 /* roughly 0.5 kiB */

Definition at line 17 of file duktape-1.5.2/src-separate/duk_hthread.h.

DUK_VALSTACK_SHRINK_THRESHOLD

#define DUK_VALSTACK_SHRINK_THRESHOLD   256 /* roughly 2 kiB */

Definition at line 16 of file duktape-1.5.2/src-separate/duk_hthread.h.

Function Documentation

duk_hthread_callstack_grow()

DUK_INTERNAL_DECL void duk_hthread_callstack_grow

(

duk_hthread *

thr

)

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

        : This should be probably reworked so that there is a shared
 *  unwind primitive which handles all stacks as requested, and knows
 *  the proper order for unwinding.)
 *
 *  Valstack entries above 'top' are always kept initialized to
 *  "undefined unused".  Callstack and catchstack entries above 'top'
 *  are not zeroed and are left as garbage.
 *
 *  Value stack handling is mostly a part of the API implementation.
 */
 
/* include removed: duk_internal.h */
 
/* check that there is space for at least one new entry */
DUK_INTERNAL void duk_hthread_callstack_grow(duk_hthread *thr) {
    duk_activation *new_ptr;
    duk_size_t old_size;
    duk_size_t new_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);   /* avoid warning (unsigned) */
    DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
 
    if (thr->callstack_top < thr->callstack_size) {
        return;
    }
 
    old_size = thr->callstack_size;
    new_size = old_size + DUK_CALLSTACK_GROW_STEP;
 
    /* this is a bit approximate (errors out before max is reached); this is OK */
    if (new_size >= thr->callstack_max) {
        DUK_ERROR_RANGE(thr, DUK_STR_CALLSTACK_LIMIT);
    }
 
    DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size));

duk_hthread_callstack_shrink_check()

DUK_INTERNAL_DECL void duk_hthread_callstack_shrink_check

(

duk_hthread *

thr

)

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

                  {
        /* No need for a NULL/zero-size check because new_size > 0) */
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    thr->callstack = new_ptr;
    thr->callstack_size = new_size;
 
    /* note: any entries above the callstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_callstack_shrink_check(duk_hthread *thr) {
    duk_size_t new_size;
    duk_activation *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
 
    if (thr->callstack_size - thr->callstack_top < DUK_CALLSTACK_SHRINK_THRESHOLD) {
        return;
    }
 
    new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE;
    DUK_ASSERT(new_size >= thr->callstack_top);
 
    DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.

duk_hthread_callstack_unwind()

DUK_INTERNAL_DECL void duk_hthread_callstack_unwind	(	duk_hthread *	thr,
		duk_size_t	new_top )

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

           {
        thr->callstack = p;
        thr->callstack_size = new_size;
    } else {
        /* Because new_size != 0, if condition doesn't need to be
         * (p != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("callstack shrink failed, ignoring"));
    }
 
    /* note: any entries above the callstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top) {
    duk_size_t idx;
 
    DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld",
                         (void *) thr,
                         (thr != NULL ? (long) thr->callstack_top : (long) -1),
                         (long) new_top));
 
    DUK_ASSERT(thr);
    DUK_ASSERT(thr->heap);
    DUK_ASSERT_DISABLE(new_top >= 0);  /* unsigned */
    DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top);  /* cannot grow */
 
    /*
     *  The loop below must avoid issues with potential callstack
     *  reallocations.  A resize (and other side effects) may happen
     *  e.g. due to finalizer/errhandler calls caused by a refzero or
     *  mark-and-sweep.  Arbitrary finalizers may run, because when
     *  an environment record is refzero'd, it may refer to arbitrary
     *  values which also become refzero'd.
     *
     *  So, the pointer 'p' is re-looked-up below whenever a side effect
     *  might have changed it.
     */
 
    idx = thr->callstack_top;
    while (idx > new_top) {
        duk_activation *act;
        duk_hobject *func;
#ifdef DUK_USE_REFERENCE_COUNTING
        duk_hobject *tmp;
#endif
#ifdef DUK_USE_DEBUGGER_SUPPORT
        duk_heap *heap;
#endif
 
        idx--;
        DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
        DUK_ASSERT((duk_size_t) idx < thr->callstack_size);  /* true, despite side effect resizes */
 
        act = thr->callstack + idx;
        /* With lightfuncs, act 'func' may be NULL */
 
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
        /*
         *  Restore 'caller' property for non-strict callee functions.
         */
 
        func = DUK_ACT_GET_FUNC(act);
        if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) {
            duk_tval *tv_caller;
            duk_tval tv_tmp;
            duk_hobject *h_tmp;
 
            tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr));
 
            /* The act->prev_caller should only be set if the entry for 'caller'
             * exists (as it is only set in that case, and the property is not
             * configurable), but handle all the cases anyway.
             */
 
            if (tv_caller) {
                DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller);
                if (act->prev_caller) {
                    /* Just transfer the refcount from act->prev_caller to tv_caller,
                     * so no need for a refcount update.  This is the expected case.
                     */
                    DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller);
                    act->prev_caller = NULL;
                } else {
                    DUK_TVAL_SET_NULL(tv_caller);   /* no incref needed */
                    DUK_ASSERT(act->prev_caller == NULL);
                }
                DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
            } else {
                h_tmp = act->prev_caller;
                if (h_tmp) {
                    act->prev_caller = NULL;
                    DUK_HOBJECT_DECREF(thr, h_tmp);  /* side effects */
                }
            }
            act = thr->callstack + idx;  /* avoid side effects */
            DUK_ASSERT(act->prev_caller == NULL);
        }
#endif
 
        /*
         *  Unwind debugger state.  If we unwind while stepping
         *  (either step over or step into), pause execution.
         */
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
        heap = thr->heap;
        if (heap->dbg_step_thread == thr &&
            heap->dbg_step_csindex == idx) {
            /* Pause for all step types: step into, step over, step out.
             * This is the only place explicitly handling a step out.
             */
            DUK_HEAP_SET_PAUSED(heap);
            DUK_ASSERT(heap->dbg_step_thread == NULL);
        }
#endif
 
        /*
         *  Close environment record(s) if they exist.
         *
         *  Only variable environments are closed.  If lex_env != var_env, it
         *  cannot currently contain any register bound declarations.
         *
         *  Only environments created for a NEWENV function are closed.  If an
         *  environment is created for e.g. an eval call, it must not be closed.
         */
 
        func = DUK_ACT_GET_FUNC(act);
        if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) {
            DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation"));
            goto skip_env_close;
        }
        /* func is NULL for lightfunc */
 
        DUK_ASSERT(act->lex_env == act->var_env);
        if (act->var_env != NULL) {
            DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O",
                                 (void *) act->var_env, (duk_heaphdr *) act->var_env));
            duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom);
            act = thr->callstack + idx;  /* avoid side effect issues */
        }
 
#if 0
        if (act->lex_env != NULL) {
            if (act->lex_env == act->var_env) {
                /* common case, already closed, so skip */
                DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env "
                                   "already closed -> skip closing lex_env"));
                ;
            } else {
                DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O",
                                   (void *) act->lex_env, (duk_heaphdr *) act->lex_env));
                duk_js_close_environment_record(thr, act->lex_env, DUK_ACT_GET_FUNC(act), act->idx_bottom);
                act = thr->callstack + idx;  /* avoid side effect issues */
            }
        }
#endif
 
        DUK_ASSERT((act->lex_env == NULL) ||
                   ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
 
        DUK_ASSERT((act->var_env == NULL) ||
                   ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
                    (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
 
     skip_env_close:
 
        /*
         *  Update preventcount
         */
 
        if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
            DUK_ASSERT(thr->callstack_preventcount >= 1);
            thr->callstack_preventcount--;
        }
 
        /*
         *  Reference count updates
         *
         *  Note: careful manipulation of refcounts.  The top is
         *  not updated yet, so all the activations are reachable
         *  for mark-and-sweep (which may be triggered by decref).
         *  However, the pointers are NULL so this is not an issue.
         */
 
#ifdef DUK_USE_REFERENCE_COUNTING
        tmp = act->var_env;
#endif
        act->var_env = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
        act = thr->callstack + idx;  /* avoid side effect issues */
#endif
 
#ifdef DUK_USE_REFERENCE_COUNTING
        tmp = act->lex_env;
#endif
        act->lex_env = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
        act = thr->callstack + idx;  /* avoid side effect issues */
#endif
 
        /* Note: this may cause a corner case situation where a finalizer
         * may see a currently reachable activation whose 'func' is NULL.
         */
#ifdef DUK_USE_REFERENCE_COUNTING
        tmp = DUK_ACT_GET_FUNC(act);
#endif
        act->func = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
        DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
        act = thr->callstack + idx;  /* avoid side effect issues */
        DUK_UNREF(act);
#endif
    }
 
    thr->callstack_top = new_top;

duk_hthread_catchstack_grow()

DUK_INTERNAL_DECL void duk_hthread_catchstack_grow

(

duk_hthread *

thr

)

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

                                {
        duk_activation *act = thr->callstack + thr->callstack_top - 1;
        act->idx_retval = 0;
    }
#endif
 
    /* Note: any entries above the callstack top are garbage and not zeroed.
     * Also topmost activation idx_retval is garbage (not zeroed), and must
     * be ignored.
     */
}
 
DUK_INTERNAL void duk_hthread_catchstack_grow(duk_hthread *thr) {
    duk_catcher *new_ptr;
    duk_size_t old_size;
    duk_size_t new_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->catchstack_top);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
 
    if (thr->catchstack_top < thr->catchstack_size) {
        return;
    }
 
    old_size = thr->catchstack_size;
    new_size = old_size + DUK_CATCHSTACK_GROW_STEP;
 
    /* this is a bit approximate (errors out before max is reached); this is OK */
    if (new_size >= thr->catchstack_max) {
        DUK_ERROR_RANGE(thr, DUK_STR_CATCHSTACK_LIMIT);
    }
 
    DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size));

duk_hthread_catchstack_shrink_check()

DUK_INTERNAL_DECL void duk_hthread_catchstack_shrink_check

(

duk_hthread *

thr

)

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

                  {
        /* No need for a NULL/zero-size check because new_size > 0) */
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    thr->catchstack = new_ptr;
    thr->catchstack_size = new_size;
 
    /* note: any entries above the catchstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_catchstack_shrink_check(duk_hthread *thr) {
    duk_size_t new_size;
    duk_catcher *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->catchstack_top >= 0);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
 
    if (thr->catchstack_size - thr->catchstack_top < DUK_CATCHSTACK_SHRINK_THRESHOLD) {
        return;
    }
 
    new_size = thr->catchstack_top + DUK_CATCHSTACK_SHRINK_SPARE;
    DUK_ASSERT(new_size >= thr->catchstack_top);
 
    DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.

duk_hthread_catchstack_unwind()

DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind	(	duk_hthread *	thr,
		duk_size_t	new_top )

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

           {
        thr->catchstack = p;
        thr->catchstack_size = new_size;
    } else {
        /* Because new_size != 0, if condition doesn't need to be
         * (p != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring"));
    }
 
    /* note: any entries above the catchstack top are garbage and not zeroed */
}
 
DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top) {
    duk_size_t idx;
 
    DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld",
                         (void *) thr,
                         (thr != NULL ? (long) thr->catchstack_top : (long) -1),
                         (long) new_top));
 
    DUK_ASSERT(thr);
    DUK_ASSERT(thr->heap);
    DUK_ASSERT_DISABLE(new_top >= 0);  /* unsigned */
    DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top);  /* cannot grow */
 
    /*
     *  Since there are no references in the catcher structure,
     *  unwinding is quite simple.  The only thing we need to
     *  look out for is popping a possible lexical environment
     *  established for an active catch clause.
     */
 
    idx = thr->catchstack_top;
    while (idx > new_top) {
        duk_catcher *p;
        duk_activation *act;
        duk_hobject *env;
 
        idx--;
        DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
        DUK_ASSERT((duk_size_t) idx < thr->catchstack_size);
 
        p = thr->catchstack + idx;
 
        if (DUK_CAT_HAS_LEXENV_ACTIVE(p)) {
            DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active",
                                 (long) idx, (long) p->callstack_index, (long) thr->callstack_top));
 
            /* XXX: Here we have a nasty dependency: the need to manipulate
             * the callstack means that catchstack must always be unwound by
             * the caller before unwinding the callstack.  This should be fixed
             * later.
             */
 
            /* Note that multiple catchstack entries may refer to the same
             * callstack entry.
             */
            act = thr->callstack + p->callstack_index;
            DUK_ASSERT(act >= thr->callstack);
            DUK_ASSERT(act < thr->callstack + thr->callstack_top);
 
            DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO",
                                 (long) idx, (long) p->callstack_index,

duk_hthread_copy_builtin_objects()

DUK_INTERNAL_DECL void duk_hthread_copy_builtin_objects	(	duk_hthread *	thr_from,
		duk_hthread *	thr_to )

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

                                               {
        DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO",
                           (long) i, (duk_heaphdr *) duk_require_hobject(ctx, i)));
    }
#endif
 
    /*
     *  Pop built-ins from stack: they are now INCREF'd and

duk_hthread_create_builtin_objects()

DUK_INTERNAL_DECL void duk_hthread_create_builtin_objects

(

duk_hthread *

thr

)

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

                                                                          {
    duk_double_union du;
    duk_small_uint_t i;
 
    for (i = 0; i < 8; i++) {
        /* Encoding endianness must match target memory layout,
         * build scripts and genbuiltins.py must ensure this.
         */
        du.uc[i] = (duk_uint8_t) duk_bd_decode(bd, 8);
    }
 
    duk_push_number(ctx, du.d);  /* push operation normalizes NaNs */
}
 
DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) {
    duk_context *ctx = (duk_context *) thr;
    duk_bitdecoder_ctx bd_ctx;
    duk_bitdecoder_ctx *bd = &bd_ctx;  /* convenience */
    duk_hobject *h;
    duk_small_uint_t i, j;
 
    DUK_D(DUK_DPRINT("INITBUILTINS BEGIN: DUK_NUM_BUILTINS=%d, DUK_NUM_BUILTINS_ALL=%d", (int) DUK_NUM_BUILTINS, (int) DUK_NUM_ALL_BUILTINS));
 
    DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
    bd->data = (const duk_uint8_t *) duk_builtins_data;
    bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
 
    /*
     *  First create all built-in bare objects on the empty valstack.
     *
     *  Built-ins in the index range [0,DUK_NUM_BUILTINS-1] have value
     *  stack indices matching their eventual thr->builtins[] index.
     *
     *  Built-ins in the index range [DUK_NUM_BUILTINS,DUK_NUM_ALL_BUILTINS]
     *  will exist on the value stack during init but won't be placed
     *  into thr->builtins[].  These are objects referenced in some way
     *  from thr->builtins[] roots but which don't need to be indexed by
     *  Duktape through thr->builtins[] (e.g. user custom objects).
     */
 
    duk_require_stack(ctx, DUK_NUM_ALL_BUILTINS);
 
    DUK_DD(DUK_DDPRINT("create empty built-ins"));
    DUK_ASSERT_TOP(ctx, 0);
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        duk_small_uint_t class_num;
        duk_small_int_t len = -1;  /* must be signed */
 
        class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS);
        len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
 
        if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
            duk_small_uint_t natidx;
            duk_int_t c_nargs;  /* must hold DUK_VARARGS */
            duk_c_function c_func;
            duk_int16_t magic;
 
            DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len));
            DUK_ASSERT(len >= 0);
 
            natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
            c_func = duk_bi_native_functions[natidx];
 
            c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
            if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
                c_nargs = DUK_VARARGS;
            }
 
            /* XXX: set magic directly here? (it could share the c_nargs arg) */
            duk_push_c_function_noexotic(ctx, c_func, c_nargs);
 
            h = duk_require_hobject(ctx, -1);
            DUK_ASSERT(h != NULL);
 
            /* Currently all built-in native functions are strict.
             * duk_push_c_function() now sets strict flag, so
             * assert for it.
             */
            DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h));
 
            /* XXX: function properties */
 
            /* Built-in 'name' is not writable by default.  Function '.name'
             * is writable to allow user code to set a '.name' on a native
             * function.
             */
            duk__push_stridx_or_string(ctx, bd);
            duk_xdef_prop_stridx(ctx,
                                 -2,
                                 DUK_STRIDX_NAME,
                                 (i == DUK_BIDX_FUNCTION_PROTOTYPE) ?
                                     DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE);
 
            /* Almost all global level Function objects are constructable
             * but not all: Function.prototype is a non-constructable,
             * callable Function.
             */
            if (duk_bd_decode_flag(bd)) {
                DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h));
            } else {
                DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h);
            }
 
            /* Cast converts magic to 16-bit signed value */
            magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
            ((duk_hnativefunction *) h)->magic = magic;
        } else {
            /* XXX: ARRAY_PART for Array prototype? */
 
            duk_push_object_helper(ctx,
                                   DUK_HOBJECT_FLAG_EXTENSIBLE,
                                   -1);  /* no prototype or class yet */
 
            h = duk_require_hobject(ctx, -1);
            DUK_ASSERT(h != NULL);
        }
 
        DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
 
        if (i < DUK_NUM_BUILTINS) {
            thr->builtins[i] = h;
            DUK_HOBJECT_INCREF(thr, &h->hdr);
        }
 
        if (len >= 0) {
            /*
             *  For top-level objects, 'length' property has the following
             *  default attributes: non-writable, non-enumerable, non-configurable
             *  (E5 Section 15).
             *
             *  However, 'length' property for Array.prototype has attributes
             *  expected of an Array instance which are different: writable,
             *  non-enumerable, non-configurable (E5 Section 15.4.5.2).
             *
             *  This is currently determined implicitly based on class; there are
             *  no attribute flags in the init data.
             */
 
            duk_push_int(ctx, len);
            duk_xdef_prop_stridx(ctx,
                                 -2,
                                 DUK_STRIDX_LENGTH,
                                 (class_num == DUK_HOBJECT_CLASS_ARRAY ?  /* only Array.prototype matches */
                                  DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE));
        }
 
        /* enable exotic behaviors last */
 
        if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
            DUK_HOBJECT_SET_EXOTIC_ARRAY(h);
        }
        if (class_num == DUK_HOBJECT_CLASS_STRING) {
            DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h);
        }
 
        /* some assertions */
 
        DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h));
        /* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h));
        /* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h));       /* currently, even for Array.prototype */
        /* DUK_HOBJECT_FLAG_STRICT varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) ||  /* all native functions have NEWENV */
                   DUK_HOBJECT_HAS_NEWENV(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h));
        DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h));
        /* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */
        /* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */
        DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h));
 
        DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len));
    }
 
    /*
     *  Then decode the builtins init data (see genbuiltins.py) to
     *  init objects
     */
 
    DUK_DD(DUK_DDPRINT("initialize built-in object properties"));
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        duk_small_uint_t t;
        duk_small_uint_t num;
 
        DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i));
        h = duk_require_hobject(ctx, i);
        DUK_ASSERT(h != NULL);
 
        t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
        if (t != DUK__NO_BIDX_MARKER) {
            DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t));
            DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, duk_require_hobject(ctx, t));
        }
 
        t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
        if (t != DUK__NO_BIDX_MARKER) {
            /* 'prototype' property for all built-in objects (which have it) has attributes:
             *  [[Writable]] = false,
             *  [[Enumerable]] = false,
             *  [[Configurable]] = false
             */
            DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t));
            duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE);
        }
 
        t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
        if (t != DUK__NO_BIDX_MARKER) {
            /* 'constructor' property for all built-in objects (which have it) has attributes:
             *  [[Writable]] = true,
             *  [[Enumerable]] = false,
             *  [[Configurable]] = true
             */
            DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t));
            duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC);
        }
 
        /* normal valued properties */
        num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS);
        DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num));
        for (j = 0; j < num; j++) {
            duk_small_uint_t prop_flags;
 
            duk__push_stridx_or_string(ctx, bd);
 
            /*
             *  Property attribute defaults are defined in E5 Section 15 (first
             *  few pages); there is a default for all properties and a special
             *  default for 'length' properties.  Variation from the defaults is
             *  signaled using a single flag bit in the bitstream.
             */
 
            if (duk_bd_decode_flag(bd)) {
                prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS);
            } else {
                prop_flags = DUK_PROPDESC_FLAGS_WC;
            }
 
            t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS);
 
            DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, key %!T, flags 0x%02lx, type %ld",
                                 (long) i, (long) j, duk_get_tval(ctx, -1), (unsigned long) prop_flags, (long) t));
 
            switch (t) {
            case DUK__PROP_TYPE_DOUBLE: {
                duk__push_double(ctx, bd);
                break;
            }
            case DUK__PROP_TYPE_STRING: {
                duk__push_string(ctx, bd);
                break;
            }
            case DUK__PROP_TYPE_STRIDX: {
                duk__push_stridx(ctx, bd);
                break;
            }
            case DUK__PROP_TYPE_BUILTIN: {
                duk_small_uint_t bidx;
 
                bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
                DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER);
                duk_dup(ctx, (duk_idx_t) bidx);
                break;
            }
            case DUK__PROP_TYPE_UNDEFINED: {
                duk_push_undefined(ctx);
                break;
            }
            case DUK__PROP_TYPE_BOOLEAN_TRUE: {
                duk_push_true(ctx);
                break;
            }
            case DUK__PROP_TYPE_BOOLEAN_FALSE: {
                duk_push_false(ctx);
                break;
            }
            case DUK__PROP_TYPE_ACCESSOR: {
                duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
                duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
                duk_c_function c_func_getter;
                duk_c_function c_func_setter;
 
                /* XXX: this is a bit awkward because there is no exposed helper
                 * in the API style, only this internal helper.
                 */
                DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, key=%!T, getteridx=%ld, setteridx=%ld, flags=0x%04lx",
                                     (long) i, duk_get_tval(ctx, -1), (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags));
 
                c_func_getter = duk_bi_native_functions[natidx_getter];
                c_func_setter = duk_bi_native_functions[natidx_setter];
                duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0);  /* always 0 args */
                duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1);  /* always 1 arg */
 
                /* XXX: magic for getter/setter? use duk_def_prop()? */
 
                DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_WRITABLE) == 0);  /* genbuiltins.py ensures */
 
                prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR;  /* accessor flag not encoded explicitly */
                duk_hobject_define_accessor_internal(thr,
                                                     duk_require_hobject(ctx, i),
                                                     duk_get_hstring(ctx, -3),
                                                     duk_require_hobject(ctx, -2),
                                                     duk_require_hobject(ctx, -1),
                                                     prop_flags);
                duk_pop_3(ctx);  /* key, getter and setter, now reachable through object */
                goto skip_value;
            }
            default: {
                /* exhaustive */
                DUK_UNREACHABLE();
            }
            }
 
            DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
            duk_xdef_prop(ctx, i, prop_flags);
 
         skip_value:
            continue;  /* avoid empty label at the end of a compound statement */
        }
 
        /* native function properties */
        num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS);
        DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num));
        for (j = 0; j < num; j++) {
            duk_hstring *h_key;
            duk_small_uint_t natidx;
            duk_int_t c_nargs;  /* must hold DUK_VARARGS */
            duk_small_uint_t c_length;
            duk_int16_t magic;
            duk_c_function c_func;
            duk_hnativefunction *h_func;
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
            duk_small_int_t lightfunc_eligible;
#endif
 
            duk__push_stridx_or_string(ctx, bd);
            h_key = duk_get_hstring(ctx, -1);
            DUK_ASSERT(h_key != NULL);
            DUK_UNREF(h_key);
            natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
 
            c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS);
            c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
            if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
                c_nargs = DUK_VARARGS;
            }
 
            c_func = duk_bi_native_functions[natidx];
 
            DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, key %!O, natidx %ld, length %ld, nargs %ld",
                                 (long) i, (long) j, (duk_heaphdr *) h_key, (long) natidx, (long) c_length,
                                 (c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs)));
 
            /* Cast converts magic to 16-bit signed value */
            magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
 
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
            lightfunc_eligible =
                ((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) &&
                (c_length <= DUK_LFUNC_LENGTH_MAX) &&
                (magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX);
 
            if (h_key == DUK_HTHREAD_STRING_EVAL(thr) ||
                h_key == DUK_HTHREAD_STRING_YIELD(thr) ||
                h_key == DUK_HTHREAD_STRING_RESUME(thr) ||
                h_key == DUK_HTHREAD_STRING_REQUIRE(thr)) {
                /* These functions have trouble working as lightfuncs.
                 * Some of them have specific asserts and some may have
                     * additional properties (e.g. 'require.id' may be written).
                 */
                DUK_D(DUK_DPRINT("reject as lightfunc: key=%!O, i=%d, j=%d", (duk_heaphdr *) h_key, (int) i, (int) j));
                lightfunc_eligible = 0;
            }
 
            if (lightfunc_eligible) {
                duk_tval tv_lfunc;
                duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs);
                duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs);
                DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags);
                duk_push_tval(ctx, &tv_lfunc);
                DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1)));
                goto lightfunc_skip;
            }
 
            DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic));
#endif  /* DUK_USE_LIGHTFUNC_BUILTINS */
 
            /* [ (builtin objects) name ] */
 
            duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs);
            h_func = duk_require_hnativefunction(ctx, -1);
            DUK_UNREF(h_func);
 
            /* Currently all built-in native functions are strict.
             * This doesn't matter for many functions, but e.g.
             * String.prototype.charAt (and other string functions)
             * rely on being strict so that their 'this' binding is
             * not automatically coerced.
             */
            DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func);
 
            /* No built-in functions are constructable except the top
             * level ones (Number, etc).
             */
            DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func));
 
            /* XXX: any way to avoid decoding magic bit; there are quite
             * many function properties and relatively few with magic values.
             */
            h_func->magic = magic;
 
            /* [ (builtin objects) name func ] */
 
            duk_push_int(ctx, c_length);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
 
            duk_dup(ctx, -2);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
 
            /* XXX: other properties of function instances; 'arguments', 'caller'. */
 
            DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T",
                               (long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1)));
 
            /* [ (builtin objects) name func ] */
 
            /*
             *  The default property attributes are correct for all
             *  function valued properties of built-in objects now.
             */
 
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
         lightfunc_skip:
#endif
 
            duk_xdef_prop(ctx, i, DUK_PROPDESC_FLAGS_WC);
 
            /* [ (builtin objects) ] */
        }
    }
 
    /*
     *  Special post-tweaks, for cases not covered by the init data format.
     *
     *  - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
     *    toGMTString is required to have the same Function object as
     *    toUTCString in E5 Section B.2.6.  Note that while Smjs respects
     *    this, V8 does not (the Function objects are distinct).
     *
     *  - Make DoubleError non-extensible.
     *
     *  - Add info about most important effective compile options to Duktape.
     *
     *  - Possibly remove some properties (values or methods) which are not
     *    desirable with current feature options but are not currently
     *    conditional in init data.
     */
 
    duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING);
    duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC);
 
    h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR);
    DUK_ASSERT(h != NULL);
    DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
 
#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY)
    DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features"));
    (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW);
#endif
 
#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF)
    DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features"));
    (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW);
#endif
 
    /* XXX: relocate */
    duk_push_string(ctx,
            /* Endianness indicator */
#if defined(DUK_USE_INTEGER_LE)
                    "l"
#elif defined(DUK_USE_INTEGER_BE)
                    "b"
#elif defined(DUK_USE_INTEGER_ME)  /* integer mixed endian not really used now */
                    "m"
#else
                    "?"
#endif
#if defined(DUK_USE_DOUBLE_LE)
                    "l"
#elif defined(DUK_USE_DOUBLE_BE)
                    "b"
#elif defined(DUK_USE_DOUBLE_ME)
                    "m"
#else
                    "?"
#endif
                    " "
            /* Packed or unpacked tval */
#if defined(DUK_USE_PACKED_TVAL)
                    "p"
#else
                    "u"
#endif
#if defined(DUK_USE_FASTINT)
            "f"
#endif
            " "
            /* Low memory options */
#if defined(DUK_USE_STRTAB_CHAIN)
            "c"  /* chain */
#elif defined(DUK_USE_STRTAB_PROBE)
            "p"  /* probe */
#else
            "?"
#endif
#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16)
            "n"
#endif
#if defined(DUK_USE_HEAPPTR16)
            "h"
#endif
#if defined(DUK_USE_DATAPTR16)
            "d"
#endif
#if defined(DUK_USE_FUNCPTR16)
            "f"
#endif
#if defined(DUK_USE_REFCOUNT16)
            "R"
#endif
#if defined(DUK_USE_STRHASH16)
            "H"
#endif
#if defined(DUK_USE_STRLEN16)
            "S"
#endif
#if defined(DUK_USE_BUFLEN16)
            "B"
#endif
#if defined(DUK_USE_OBJSIZES16)
            "O"
#endif
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
            "L"
#endif
#if defined(DUK_USE_ROM_STRINGS) || defined(DUK_USE_ROM_OBJECTS)
            /* XXX: This won't be shown in practice now
             * because this code is not run when builtins
             * are in ROM.
             */
            "Z"
#endif
                    " "
            /* Object property allocation layout */
#if defined(DUK_USE_HOBJECT_LAYOUT_1)
            "p1"
#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
            "p2"
#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
            "p3"
#else
            "p?"
#endif
            " "
            /* Alignment guarantee */
#if (DUK_USE_ALIGN_BY == 4)
            "a4"
#elif (DUK_USE_ALIGN_BY == 8)
            "a8"
#elif (DUK_USE_ALIGN_BY == 1)
            "a1"
#else
#error invalid DUK_USE_ALIGN_BY
#endif
            " "
            /* Architecture, OS, and compiler strings */
                    DUK_USE_ARCH_STRING
            " "
                    DUK_USE_OS_STRING
            " "
                    DUK_USE_COMPILER_STRING);
    duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC);
 
    /*
     *  InitJS code - Ecmascript code evaluated from a built-in source
     *  which provides e.g. backward compatibility.  User can also provide
     *  JS code to be evaluated at startup.
     */
 
#ifdef DUK_USE_BUILTIN_INITJS
    /* XXX: compression */
    DUK_DD(DUK_DDPRINT("running built-in initjs"));
    duk_eval_string(ctx, (const char *) duk_initjs_data);  /* initjs data is NUL terminated */
    duk_pop(ctx);
#endif  /* DUK_USE_BUILTIN_INITJS */
 
#ifdef DUK_USE_USER_INITJS
    /* XXX: compression (as an option) */
    DUK_DD(DUK_DDPRINT("running user initjs"));
    duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS);
#endif  /* DUK_USE_USER_INITJS */
 
    /*
     *  Since built-ins are not often extended, compact them.
     */
 
    DUK_DD(DUK_DDPRINT("compact built-ins"));
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        duk_hobject_compact_props(thr, duk_require_hobject(ctx, i));
    }
 
    DUK_D(DUK_DPRINT("INITBUILTINS END"));

duk_hthread_get_act_prev_pc()

DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_prev_pc	(	duk_hthread *	thr,
		duk_activation *	act )

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

                                                                                                  {
    duk_instr_t *bcode;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(act != NULL);
    DUK_UNREF(thr);
 
    /* XXX: store 'bcode' pointer to activation for faster lookup? */
    if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) {
        bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func));
        return (duk_uint_fast32_t) (act->curr_pc - bcode);
    }
    return 0;
}
#endif  /* DUK_USE_DEBUGGER_SUPPORT */
 
DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act) {

duk_hthread_get_callstack_ptr()

DUK_INTERNAL_DECL void * duk_hthread_get_callstack_ptr	(	duk_heap *	heap,
		void *	ud )

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

duk_hthread_get_catchstack_ptr()

DUK_INTERNAL_DECL void * duk_hthread_get_catchstack_ptr	(	duk_heap *	heap,
		void *	ud )

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

duk_hthread_get_current_activation()

DUK_INTERNAL_DECL duk_activation * duk_hthread_get_current_activation

(

duk_hthread *

thr

)

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

duk_hthread_get_valstack_ptr()

DUK_INTERNAL_DECL void * duk_hthread_get_valstack_ptr	(	duk_heap *	heap,
		void *	ud )

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

     :
 

duk_hthread_init_stacks()

DUK_INTERNAL_DECL duk_bool_t duk_hthread_init_stacks	(	duk_heap *	heap,
		duk_hthread *	thr )

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

           {
        return duk_unicode_unvalidated_utf8_length(DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
    }
}
#endif  /* !DUK_USE_HSTRING_CLEN */
/*
 *  duk_hthread allocation and freeing.
 */
 
/* include removed: duk_internal.h */
 
/*
 *  Allocate initial stacks for a thread.  Note that 'thr' must be reachable
 *  as a garbage collection may be triggered by the allocation attempts.
 *  Returns zero (without leaking memory) if init fails.
 */
 
DUK_INTERNAL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr) {
    duk_size_t alloc_size;
    duk_size_t i;
 
    DUK_ASSERT(heap != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->valstack == NULL);
    DUK_ASSERT(thr->valstack_end == NULL);
    DUK_ASSERT(thr->valstack_bottom == NULL);
    DUK_ASSERT(thr->valstack_top == NULL);
    DUK_ASSERT(thr->callstack == NULL);
    DUK_ASSERT(thr->catchstack == NULL);
 
    /* valstack */
    alloc_size = sizeof(duk_tval) * DUK_VALSTACK_INITIAL_SIZE;
    thr->valstack = (duk_tval *) DUK_ALLOC(heap, alloc_size);
    if (!thr->valstack) {
        goto fail;
    }
    DUK_MEMZERO(thr->valstack, alloc_size);
    thr->valstack_end = thr->valstack + DUK_VALSTACK_INITIAL_SIZE;
#if !defined(DUK_USE_PREFER_SIZE)
    thr->valstack_size = DUK_VALSTACK_INITIAL_SIZE;
#endif
    thr->valstack_bottom = thr->valstack;
    thr->valstack_top = thr->valstack;
 
    for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) {
        DUK_TVAL_SET_UNDEFINED(&thr->valstack[i]);
    }
 
    /* callstack */
    alloc_size = sizeof(duk_activation) * DUK_CALLSTACK_INITIAL_SIZE;
    thr->callstack = (duk_activation *) DUK_ALLOC(heap, alloc_size);
    if (!thr->callstack) {
        goto fail;
    }
    DUK_MEMZERO(thr->callstack, alloc_size);
    thr->callstack_size = DUK_CALLSTACK_INITIAL_SIZE;
    DUK_ASSERT(thr->callstack_top == 0);
 
    /* catchstack */
    alloc_size = sizeof(duk_catcher) * DUK_CATCHSTACK_INITIAL_SIZE;
    thr->catchstack = (duk_catcher *) DUK_ALLOC(heap, alloc_size);
    if (!thr->catchstack) {
        goto fail;

duk_hthread_sync_and_null_currpc()

DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc

(

duk_hthread *

thr

)

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

                                                            {
    duk_activation *act;
 
    DUK_ASSERT(thr != NULL);
 
    if (thr->ptr_curr_pc != NULL) {
        /* ptr_curr_pc != NULL only when bytecode executor is active. */
        DUK_ASSERT(thr->callstack_top > 0);
        act = thr->callstack + thr->callstack_top - 1;

duk_hthread_sync_currpc()

DUK_INTERNAL_DECL void duk_hthread_sync_currpc

(

duk_hthread *

thr

)

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

                                                                 {
        bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func));
        ret = (duk_uint_fast32_t) (act->curr_pc - bcode);
        if (ret > 0) {
            ret--;
        }
        return ret;

duk_hthread_terminate()

DUK_INTERNAL_DECL void duk_hthread_terminate

(

duk_hthread *

thr

)

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

                                                                                               {
    duk_small_uint_t i;
 
    for (i = 0; i < DUK_NUM_BUILTINS; i++) {
        thr_to->builtins[i] = thr_from->builtins[i];
        DUK_HOBJECT_INCREF_ALLOWNULL(thr_to, thr_to->builtins[i]);  /* side effect free */
    }
}
/*
 *  Thread support.
 */
 
/* include removed: duk_internal.h */
 
DUK_INTERNAL void duk_hthread_terminate(duk_hthread *thr) {
    DUK_ASSERT(thr != NULL);
 
    /* Order of unwinding is important */
 
    duk_hthread_catchstack_unwind(thr, 0);
 
    duk_hthread_callstack_unwind(thr, 0);  /* side effects, possibly errors */
 
    thr->valstack_bottom = thr->valstack;
    duk_set_top((duk_context *) thr, 0);  /* unwinds valstack, updating refcounts */