DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_hthread *thr) {
duk_hobject *proto;
DUK_ASSERT_TOP(thr, 2);
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
duk_hbufobj_promote_plain(thr, 0);
#endif
proto = duk_require_hobject_accept_mask(thr, 0, DUK_TYPE_MASK_NULL);
DUK_ASSERT(proto != NULL || duk_is_null(thr, 0));
(void) duk_push_object_helper_proto(thr,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_FLAG_FASTREFS |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
proto);
if (!duk_is_undefined(thr, 1)) {
/* [ O Properties obj ] */
duk_replace(thr, 0);
/* [ obj Properties ] */
/* Just call the "original" Object.defineProperties() to
* finish up.
*/
return duk_bi_object_constructor_define_properties(thr);
}
/* [ O Properties obj ] */
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) {
duk_hobject *h_target;
duk_hobject *h_handler;
if (!duk_is_constructor_call(ctx)) {
return DUK_RET_TYPE_ERROR;
}
/* Reject a proxy object as the target because it would need
* special handler in property lookups. (ES6 has no such restriction)
*/
h_target = duk_require_hobject_or_lfunc_coerce(ctx, 0);
DUK_ASSERT(h_target != NULL);
if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_target)) {
return DUK_RET_TYPE_ERROR;
}
/* Reject a proxy object as the handler because it would cause
* potentially unbounded recursion. (ES6 has no such restriction)
*/
h_handler = duk_require_hobject_or_lfunc_coerce(ctx, 1);
DUK_ASSERT(h_handler != NULL);
if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_handler)) {
return DUK_RET_TYPE_ERROR;
}
/* XXX: the returned value is exotic in ES6, but we use a
* simple object here with no prototype. Without a prototype,
* [[DefaultValue]] coercion fails which is abit confusing.
* No callable check/handling in the current Proxy subset.
*/
(void) duk_push_object_helper_proto(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
NULL);
DUK_ASSERT_TOP(ctx, 3);
/* Make _Target and _Handler non-configurable and non-writable.
* They can still be forcibly changed by C code (both user and
* Duktape internal), but not by Ecmascript code.
*/
/* Proxy target */
duk_dup(ctx, 0);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
/* Proxy handler */
duk_dup(ctx, 1);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_HANDLER, DUK_PROPDESC_FLAGS_NONE);
return 1; /* replacement handler */
}
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx) {
duk_tval *tv;
duk_hobject *proto = NULL;
DUK_ASSERT_TOP(ctx, 2);
tv = duk_get_tval(ctx, 0);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_NULL(tv)) {
;
} else if (DUK_TVAL_IS_OBJECT(tv)) {
proto = DUK_TVAL_GET_OBJECT(tv);
DUK_ASSERT(proto != NULL);
} else {
return DUK_RET_TYPE_ERROR;
}
(void) duk_push_object_helper_proto(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
proto);
if (!duk_is_undefined(ctx, 1)) {
/* [ O Properties obj ] */
/* Use original function. No need to get it explicitly,
* just call the helper.
*/
duk_replace(ctx, 0);
/* [ obj Properties ] */
return duk_hobject_object_define_properties(ctx);
}
/* [ O Properties obj ] */
return 1;
}
static duk_uint8_t *duk__load_func(duk_context *ctx, duk_uint8_t *p, duk_uint8_t *p_end) {
duk_hthread *thr;
duk_hcompiledfunction *h_fun;
duk_hbuffer *h_data;
duk_size_t data_size;
duk_uint32_t count_instr, count_const, count_funcs;
duk_uint32_t n;
duk_uint32_t tmp32;
duk_small_uint_t const_type;
duk_uint8_t *fun_data;
duk_uint8_t *q;
duk_idx_t idx_base;
duk_tval *tv;
duk_uarridx_t arr_idx;
/* XXX: There's some overlap with duk_js_closure() here, but
* seems difficult to share code. Ensure that the final function
* looks the same as created by duk_js_closure().
*/
DUK_ASSERT(ctx != NULL);
thr = (duk_hthread *) ctx;
DUK_DD(DUK_DDPRINT("loading function, p=%p, p_end=%p", (void *) p, (void *) p_end));
DUK__ASSERT_LEFT(3 * 4);
count_instr = DUK_RAW_READ_U32_BE(p);
count_const = DUK_RAW_READ_U32_BE(p);
count_funcs = DUK_RAW_READ_U32_BE(p);
data_size = sizeof(duk_tval) * count_const +
sizeof(duk_hobject *) * count_funcs +
sizeof(duk_instr_t) * count_instr;
DUK_DD(DUK_DDPRINT("instr=%ld, const=%ld, funcs=%ld, data_size=%ld",
(long) count_instr, (long) count_const,
(long) count_const, (long) data_size));
/* Value stack is used to ensure reachability of constants and
* inner functions being loaded. Require enough space to handle
* large functions correctly.
*/
duk_require_stack(ctx, 2 + count_const + count_funcs);
idx_base = duk_get_top(ctx);
/* Push function object, init flags etc. This must match
* duk_js_push_closure() quite carefully.
*/
duk_push_compiledfunction(ctx);
h_fun = duk_get_hcompiledfunction(ctx, -1);
DUK_ASSERT(h_fun != NULL);
DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) h_fun));
DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, h_fun) == NULL);
DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, h_fun) == NULL);
DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, h_fun) == NULL);
h_fun->nregs = DUK_RAW_READ_U16_BE(p);
h_fun->nargs = DUK_RAW_READ_U16_BE(p);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
h_fun->start_line = DUK_RAW_READ_U32_BE(p);
h_fun->end_line = DUK_RAW_READ_U32_BE(p);
#else
p += 8; /* skip line info */
#endif
/* duk_hcompiledfunction flags; quite version specific */
tmp32 = DUK_RAW_READ_U32_BE(p);
DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32);
/* standard prototype */
DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &h_fun->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
/* assert just a few critical flags */
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h_fun) == DUK_HTYPE_OBJECT);
DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&h_fun->obj));
DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&h_fun->obj));
DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&h_fun->obj));
DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&h_fun->obj));
DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&h_fun->obj));
DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&h_fun->obj));
DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&h_fun->obj));
/* Create function 'data' buffer but don't attach it yet. */
fun_data = (duk_uint8_t *) duk_push_fixed_buffer(ctx, data_size);
DUK_ASSERT(fun_data != NULL);
/* Load bytecode instructions. */
DUK_ASSERT(sizeof(duk_instr_t) == 4);
DUK__ASSERT_LEFT(count_instr * sizeof(duk_instr_t));
#if defined(DUK_USE_INTEGER_BE)
q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
DUK_MEMCPY((void *) q,
(const void *) p,
sizeof(duk_instr_t) * count_instr);
p += sizeof(duk_instr_t) * count_instr;
#else
q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
for (n = count_instr; n > 0; n--) {
*((duk_instr_t *) (void *) q) = DUK_RAW_READ_U32_BE(p);
q += sizeof(duk_instr_t);
}
#endif
/* Load constants onto value stack but don't yet copy to buffer. */
for (n = count_const; n > 0; n--) {
DUK__ASSERT_LEFT(1);
const_type = DUK_RAW_READ_U8(p);
switch (const_type) {
case DUK__SER_STRING: {
p = duk__load_string_raw(ctx, p);
break;
}
case DUK__SER_NUMBER: {
/* Important to do a fastint check so that constants are
* properly read back as fastints.
*/
duk_tval tv_tmp;
duk_double_t val;
DUK__ASSERT_LEFT(8);
val = DUK_RAW_READ_DOUBLE_BE(p);
DUK_TVAL_SET_NUMBER_CHKFAST(&tv_tmp, val);
duk_push_tval(ctx, &tv_tmp);
break;
}
default: {
goto format_error;
}
}
}
/* Load inner functions to value stack, but don't yet copy to buffer. */
for (n = count_funcs; n > 0; n--) {
p = duk__load_func(ctx, p, p_end);
if (p == NULL) {
goto format_error;
}
}
/* With constants and inner functions on value stack, we can now
* atomically finish the function 'data' buffer, bump refcounts,
* etc.
*
* Here we take advantage of the value stack being just a duk_tval
* array: we can just memcpy() the constants as long as we incref
* them afterwards.
*/
h_data = (duk_hbuffer *) duk_get_hbuffer(ctx, idx_base + 1);
DUK_ASSERT(h_data != NULL);
DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC(h_data));
DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_fun, h_data);
DUK_HBUFFER_INCREF(thr, h_data);
tv = duk_get_tval(ctx, idx_base + 2); /* may be NULL if no constants or inner funcs */
DUK_ASSERT((count_const == 0 && count_funcs == 0) || tv != NULL);
q = fun_data;
if (count_const > 0) {
/* Explicit zero size check to avoid NULL 'tv'. */
DUK_MEMCPY((void *) q, (const void *) tv, sizeof(duk_tval) * count_const);
for (n = count_const; n > 0; n--) {
DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q); /* no side effects */
q += sizeof(duk_tval);
}
tv += count_const;
}
DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_fun, (duk_hobject **) (void *) q);
for (n = count_funcs; n > 0; n--) {
duk_hobject *h_obj;
DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
h_obj = DUK_TVAL_GET_OBJECT(tv);
DUK_ASSERT(h_obj != NULL);
tv++;
DUK_HOBJECT_INCREF(thr, h_obj);
*((duk_hobject **) (void *) q) = h_obj;
q += sizeof(duk_hobject *);
}
DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_fun, (duk_instr_t *) (void *) q);
/* The function object is now reachable and refcounts are fine,
* so we can pop off all the temporaries.
*/
DUK_DDD(DUK_DDDPRINT("function is reachable, reset top; func: %!iT", duk_get_tval(ctx, idx_base)));
duk_set_top(ctx, idx_base + 1);
/* Setup function properties. */
tmp32 = DUK_RAW_READ_U32_BE(p);
duk_push_u32(ctx, tmp32);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
p = duk__load_string_raw(ctx, p);
if (DUK_HOBJECT_HAS_NAMEBINDING((duk_hobject *) h_fun)) {
/* Original function instance/template had NAMEBINDING.
* Must create a lexical environment on loading to allow
* recursive functions like 'function foo() { foo(); }'.
*/
duk_hobject *proto;
proto = thr->builtins[DUK_BIDX_GLOBAL_ENV];
(void) duk_push_object_helper_proto(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
proto);
duk_dup(ctx, -2); /* -> [ func funcname env funcname ] */
duk_dup(ctx, idx_base); /* -> [ func funcname env funcname func ] */
duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ func funcname env ] */
duk_xdef_prop_stridx(ctx, idx_base, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
/* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
* will be ignored anyway
*/
}
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
p = duk__load_string_raw(ctx, p);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC);
duk_push_object(ctx);
duk_dup(ctx, -2);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC); /* func.prototype.constructor = func */
duk_compact(ctx, -1);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W);
p = duk__load_buffer_raw(ctx, p);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_WC);
duk_push_object(ctx); /* _Varmap */
for (;;) {
/* XXX: awkward */
p = duk__load_string_raw(ctx, p);
if (duk_get_length(ctx, -1) == 0) {
duk_pop(ctx);
break;
}
tmp32 = DUK_RAW_READ_U32_BE(p);
duk_push_u32(ctx, tmp32);
duk_put_prop(ctx, -3);
}
duk_compact(ctx, -1);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE);
duk_push_array(ctx); /* _Formals */
for (arr_idx = 0; ; arr_idx++) {
/* XXX: awkward */
p = duk__load_string_raw(ctx, p);
if (duk_get_length(ctx, -1) == 0) {
duk_pop(ctx);
break;
}
duk_put_prop_index(ctx, -2, arr_idx);
}
duk_compact(ctx, -1);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE);
/* Return with final function pushed on stack top. */
DUK_DD(DUK_DDPRINT("final loaded function: %!iT", duk_get_tval(ctx, -1)));
DUK_ASSERT_TOP(ctx, idx_base + 1);
return p;
format_error:
return NULL;
}