duk_hthread_builtins.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Macros
#define	DUK__CLASS_BITS   5
#define	DUK__BIDX_BITS   7
#define	DUK__STRIDX_BITS   9 /* XXX: try to optimize to 8 (would now be possible, <200 used) */
#define	DUK__NATIDX_BITS   8
#define	DUK__NUM_NORMAL_PROPS_BITS   6
#define	DUK__NUM_FUNC_PROPS_BITS   6
#define	DUK__PROP_FLAGS_BITS   3
#define	DUK__STRING_LENGTH_BITS   8
#define	DUK__STRING_CHAR_BITS   7
#define	DUK__LENGTH_PROP_BITS   3
#define	DUK__NARGS_BITS   3
#define	DUK__PROP_TYPE_BITS   3
#define	DUK__MAGIC_BITS   16
#define	DUK__NARGS_VARARGS_MARKER   0x07
#define	DUK__NO_CLASS_MARKER   0x00 /* 0 = DUK_HOBJECT_CLASS_UNUSED */
#define	DUK__NO_BIDX_MARKER   0x7f
#define	DUK__NO_STRIDX_MARKER   0xff
#define	DUK__PROP_TYPE_DOUBLE   0
#define	DUK__PROP_TYPE_STRING   1
#define	DUK__PROP_TYPE_STRIDX   2
#define	DUK__PROP_TYPE_BUILTIN   3
#define	DUK__PROP_TYPE_UNDEFINED   4
#define	DUK__PROP_TYPE_BOOLEAN_TRUE   5
#define	DUK__PROP_TYPE_BOOLEAN_FALSE   6
#define	DUK__PROP_TYPE_ACCESSOR   7

Functions
DUK_LOCAL void	duk__push_stridx (duk_context *ctx, duk_bitdecoder_ctx *bd)
DUK_LOCAL void	duk__push_string (duk_context *ctx, duk_bitdecoder_ctx *bd)
DUK_LOCAL void	duk__push_stridx_or_string (duk_context *ctx, duk_bitdecoder_ctx *bd)
DUK_LOCAL void	duk__push_double (duk_context *ctx, duk_bitdecoder_ctx *bd)
DUK_INTERNAL void	duk_hthread_create_builtin_objects (duk_hthread *thr)
DUK_INTERNAL void	duk_hthread_copy_builtin_objects (duk_hthread *thr_from, duk_hthread *thr_to)

Macro Definition Documentation

DUK__BIDX_BITS

#define DUK__BIDX_BITS   7

Definition at line 14 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__CLASS_BITS

#define DUK__CLASS_BITS   5

Definition at line 13 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__LENGTH_PROP_BITS

#define DUK__LENGTH_PROP_BITS   3

Definition at line 22 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__MAGIC_BITS

#define DUK__MAGIC_BITS   16

Definition at line 25 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__NARGS_BITS

#define DUK__NARGS_BITS   3

Definition at line 23 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__NARGS_VARARGS_MARKER

#define DUK__NARGS_VARARGS_MARKER   0x07

Definition at line 27 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__NATIDX_BITS

#define DUK__NATIDX_BITS   8

Definition at line 16 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__NO_BIDX_MARKER

#define DUK__NO_BIDX_MARKER   0x7f

Definition at line 29 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__NO_CLASS_MARKER

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

Definition at line 28 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

DUK__NO_STRIDX_MARKER

#define DUK__NO_STRIDX_MARKER   0xff

Definition at line 30 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

DUK__NUM_FUNC_PROPS_BITS

#define DUK__NUM_FUNC_PROPS_BITS   6

Definition at line 18 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__NUM_NORMAL_PROPS_BITS

#define DUK__NUM_NORMAL_PROPS_BITS   6

Definition at line 17 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_FLAGS_BITS

#define DUK__PROP_FLAGS_BITS   3

Definition at line 19 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_ACCESSOR

#define DUK__PROP_TYPE_ACCESSOR   7

Definition at line 39 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_BITS

#define DUK__PROP_TYPE_BITS   3

Definition at line 24 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_BOOLEAN_FALSE

#define DUK__PROP_TYPE_BOOLEAN_FALSE   6

Definition at line 38 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_BOOLEAN_TRUE

#define DUK__PROP_TYPE_BOOLEAN_TRUE   5

Definition at line 37 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_BUILTIN

#define DUK__PROP_TYPE_BUILTIN   3

Definition at line 35 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_DOUBLE

#define DUK__PROP_TYPE_DOUBLE   0

Definition at line 32 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_STRIDX

#define DUK__PROP_TYPE_STRIDX   2

Definition at line 34 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_STRING

#define DUK__PROP_TYPE_STRING   1

Definition at line 33 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__PROP_TYPE_UNDEFINED

#define DUK__PROP_TYPE_UNDEFINED   4

Definition at line 36 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk_hthread_create_builtin_objects().

DUK__STRIDX_BITS

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

Definition at line 15 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk__push_stridx().

DUK__STRING_CHAR_BITS

#define DUK__STRING_CHAR_BITS   7

Definition at line 21 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk__push_string().

DUK__STRING_LENGTH_BITS

#define DUK__STRING_LENGTH_BITS   8

Definition at line 20 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

Referenced by duk__push_string().

Function Documentation

duk__push_double()

DUK_LOCAL void duk__push_double	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 196 of file duktape-1.5.2/src-separate/duk_hthread_builtins.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 */
}

References duk_double_union::d, duk_bd_decode(), duk_push_number(), and duk_double_union::uc.

Referenced by duk_hthread_create_builtin_objects().

duk__push_stridx()

DUK_LOCAL void duk__push_stridx	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 169 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

                                                                          {
    duk_small_uint_t n;
 
    n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
    DUK_ASSERT_DISABLE(n >= 0);  /* unsigned */
    DUK_ASSERT(n < DUK_HEAP_NUM_STRINGS);
    duk_push_hstring_stridx(ctx, n);
}

References DUK__STRIDX_BITS, DUK_ASSERT, DUK_ASSERT_DISABLE, duk_bd_decode(), DUK_HEAP_NUM_STRINGS, and duk_push_hstring_stridx().

Referenced by duk__push_stridx_or_string(), and duk_hthread_create_builtin_objects().

duk__push_stridx_or_string()

DUK_LOCAL void duk__push_stridx_or_string	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 189 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

                                                                                    {
    if (duk_bd_decode_flag(bd)) {
        duk__push_string(ctx, bd);
    } else {
        duk__push_stridx(ctx, bd);
    }
}

References duk__push_stridx(), duk__push_string(), and duk_bd_decode_flag().

Referenced by duk_hthread_create_builtin_objects().

duk__push_string()

DUK_LOCAL void duk__push_string	(	duk_context *	ctx,
		duk_bitdecoder_ctx *	bd )

Definition at line 177 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

                                                                          {
    duk_small_uint_t n;
    duk_small_uint_t i;
    duk_uint8_t *p;
 
    n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRING_LENGTH_BITS);
    p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, n);
    for (i = 0; i < n; i++) {
        *p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
    }
    duk_to_string(ctx, -1);
}

References DUK__STRING_CHAR_BITS, DUK__STRING_LENGTH_BITS, duk_bd_decode(), duk_push_fixed_buffer, and duk_to_string().

Referenced by duk__push_stridx_or_string(), and duk_hthread_create_builtin_objects().

duk_hthread_copy_builtin_objects()

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

Definition at line 829 of file duktape-1.5.2/src-separate/duk_hthread_builtins.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 */
    }
}

References duk_hthread::builtins, DUK_HOBJECT_INCREF_ALLOWNULL, and DUK_NUM_BUILTINS.

duk_hthread_create_builtin_objects()

DUK_INTERNAL void duk_hthread_create_builtin_objects

(

duk_hthread *

thr

)

Definition at line 210 of file duktape-1.5.2/src-separate/duk_hthread_builtins.c.

                                                                       {
    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"));
 
#ifdef DUK_USE_DDPRINT
    for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) {
        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
     *  reachable from the builtins[] array or indirectly
     *  through builtins[].
     */
 
    duk_set_top(ctx, 0);
    DUK_ASSERT_TOP(ctx, 0);
}

References duk_hthread::builtins, duk_bitdecoder_ctx::data, DUK__BIDX_BITS, DUK__CLASS_BITS, DUK__LENGTH_PROP_BITS, DUK__MAGIC_BITS, DUK__NARGS_BITS, DUK__NARGS_VARARGS_MARKER, DUK__NATIDX_BITS, DUK__NO_BIDX_MARKER, DUK__NUM_FUNC_PROPS_BITS, DUK__NUM_NORMAL_PROPS_BITS, DUK__PROP_FLAGS_BITS, DUK__PROP_TYPE_ACCESSOR, DUK__PROP_TYPE_BITS, DUK__PROP_TYPE_BOOLEAN_FALSE, DUK__PROP_TYPE_BOOLEAN_TRUE, DUK__PROP_TYPE_BUILTIN, DUK__PROP_TYPE_DOUBLE, DUK__PROP_TYPE_STRIDX, DUK__PROP_TYPE_STRING, DUK__PROP_TYPE_UNDEFINED, duk__push_double(), duk__push_stridx(), duk__push_stridx_or_string(), duk__push_string(), DUK_ASSERT, DUK_ASSERT_TOP, duk_bd_decode(), duk_bd_decode_flag(), duk_bd_decode_flagged(), duk_bi_native_functions, DUK_BIDX_DATE_PROTOTYPE, DUK_BIDX_DOUBLE_ERROR, DUK_BIDX_DUKTAPE, DUK_BIDX_FUNCTION_PROTOTYPE, DUK_BIDX_OBJECT_CONSTRUCTOR, DUK_BIDX_OBJECT_PROTOTYPE, DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DELPROP_FLAG_THROW, DUK_DPRINT, duk_dup(), duk_eval_string, duk_eval_string_noresult, duk_get_hstring(), duk_get_prop_stridx(), duk_get_tval(), DUK_HOBJECT_CLASS_ARRAY, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_CLASS_STRING, DUK_HOBJECT_CLEAR_CONSTRUCTABLE, DUK_HOBJECT_CLEAR_EXTENSIBLE, duk_hobject_compact_props(), duk_hobject_define_accessor_internal(), duk_hobject_delprop_raw(), DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_HAS_ARRAY_PART, DUK_HOBJECT_HAS_BOUND, DUK_HOBJECT_HAS_COMPILEDFUNCTION, DUK_HOBJECT_HAS_CONSTRUCTABLE, DUK_HOBJECT_HAS_CREATEARGS, DUK_HOBJECT_HAS_ENVRECCLOSED, DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS, DUK_HOBJECT_HAS_EXTENSIBLE, DUK_HOBJECT_HAS_NAMEBINDING, DUK_HOBJECT_HAS_NATIVEFUNCTION, DUK_HOBJECT_HAS_NEWENV, DUK_HOBJECT_HAS_STRICT, DUK_HOBJECT_HAS_THREAD, DUK_HOBJECT_INCREF, DUK_HOBJECT_SET_CLASS_NUMBER, DUK_HOBJECT_SET_EXOTIC_ARRAY, DUK_HOBJECT_SET_EXOTIC_STRINGOBJ, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_HOBJECT_SET_STRICT, DUK_HTHREAD_STRING___PROTO__, DUK_HTHREAD_STRING_EVAL, DUK_HTHREAD_STRING_REQUIRE, DUK_HTHREAD_STRING_RESUME, DUK_HTHREAD_STRING_SET_PROTOTYPE_OF, DUK_HTHREAD_STRING_YIELD, duk_initjs_data, DUK_LFUNC_FLAGS_PACK, DUK_LFUNC_LENGTH_MAX, DUK_LFUNC_MAGIC_MAX, DUK_LFUNC_MAGIC_MIN, DUK_LFUNC_NARGS_MAX, DUK_LFUNC_NARGS_MIN, DUK_LFUNC_NARGS_VARARGS, DUK_MEMZERO, DUK_NUM_ALL_BUILTINS, DUK_NUM_BUILTINS, duk_pop(), duk_pop_3(), DUK_PROPDESC_FLAG_ACCESSOR, DUK_PROPDESC_FLAG_WRITABLE, DUK_PROPDESC_FLAGS_NONE, DUK_PROPDESC_FLAGS_W, DUK_PROPDESC_FLAGS_WC, duk_push_c_function_noconstruct_noexotic(), duk_push_c_function_noexotic(), duk_push_false(), duk_push_int(), duk_push_object_helper(), duk_push_string(), duk_push_true(), duk_push_tval(), duk_push_undefined(), duk_require_hnativefunction(), duk_require_hobject(), duk_require_stack(), duk_set_top(), DUK_STRIDX_CONSTRUCTOR, DUK_STRIDX_ENV, DUK_STRIDX_LENGTH, DUK_STRIDX_NAME, DUK_STRIDX_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_STRIDX_TO_UTC_STRING, DUK_TVAL_SET_LIGHTFUNC, DUK_UNREACHABLE, DUK_UNREF, DUK_USE_ALIGN_BY, DUK_USE_ARCH_STRING, DUK_USE_COMPILER_STRING, DUK_USE_HOBJECT_LAYOUT_2, DUK_USE_OS_STRING, DUK_USE_STRTAB_PROBE, DUK_VARARGS, duk_xdef_prop(), duk_xdef_prop_stridx(), duk_xdef_prop_stridx_builtin(), error(), duk_hobject::hdr, duk_bitdecoder_ctx::length, duk_hnativefunction::magic, and NULL.