duktape-1.5.2/src-separate/duk_bi_object.c

Go to the documentation of this file.

/*
 *  Object built-ins
 */
 
#include "duk_internal.h"
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor(duk_context *ctx) {
    if (!duk_is_constructor_call(ctx) &&
        !duk_is_null_or_undefined(ctx, 0)) {
        duk_to_object(ctx, 0);
        return 1;
    }
 
    if (duk_is_object(ctx, 0)) {
        return 1;
    }
 
    /* Pointer and buffer primitive values are treated like other
     * primitives values which have a fully fledged object counterpart:
     * promote to an object value.  Lightfuncs are coerced with
     * ToObject() even they could also be returned as is.
     */
    if (duk_check_type_mask(ctx, 0, DUK_TYPE_MASK_STRING |
                                    DUK_TYPE_MASK_BOOLEAN |
                                    DUK_TYPE_MASK_NUMBER |
                                    DUK_TYPE_MASK_POINTER |
                                    DUK_TYPE_MASK_BUFFER |
                                    DUK_TYPE_MASK_LIGHTFUNC)) {
        duk_to_object(ctx, 0);
        return 1;
    }
 
    duk_push_object_helper(ctx,
                           DUK_HOBJECT_FLAG_EXTENSIBLE |
                           DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                           DUK_BIDX_OBJECT_PROTOTYPE);
    return 1;
}
 
/* Shared helper to implement Object.getPrototypeOf and the ES6
 * Object.prototype.__proto__ getter.
 *
 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
 */
DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_hobject *proto;
 
    DUK_UNREF(thr);
 
    /* magic: 0=getter call, 1=Object.getPrototypeOf */
    if (duk_get_current_magic(ctx) == 0) {
        duk_push_this_coercible_to_object(ctx);
        duk_insert(ctx, 0);
    }
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    /* h is NULL for lightfunc */
 
    /* XXX: should the API call handle this directly, i.e. attempt
     * to duk_push_hobject(ctx, null) would push a null instead?
     * (On the other hand 'undefined' would be just as logical, but
     * not wanted here.)
     */
 
    if (h == NULL) {
        duk_push_hobject_bidx(ctx, DUK_BIDX_FUNCTION_PROTOTYPE);
    } else {
        proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
        if (proto) {
            duk_push_hobject(ctx, proto);
        } else {
            duk_push_null(ctx);
        }
    }
    return 1;
}
 
/* Shared helper to implement ES6 Object.setPrototypeOf and
 * Object.prototype.__proto__ setter.
 *
 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
 * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.setprototypeof
 */
DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_obj;
    duk_hobject *h_new_proto;
    duk_hobject *h_curr;
    duk_ret_t ret_success = 1;  /* retval for success path */
 
    /* Preliminaries for __proto__ and setPrototypeOf (E6 19.1.2.18 steps 1-4);
     * magic: 0=setter call, 1=Object.setPrototypeOf
     */
    if (duk_get_current_magic(ctx) == 0) {
        duk_push_this_check_object_coercible(ctx);
        duk_insert(ctx, 0);
        if (!duk_check_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT)) {
            return 0;
        }
 
        /* __proto__ setter returns 'undefined' on success unlike the
         * setPrototypeOf() call which returns the target object.
         */
        ret_success = 0;
    } else {
        duk_require_object_coercible(ctx, 0);
        duk_require_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT);
    }
 
    h_new_proto = duk_get_hobject(ctx, 1);
    /* h_new_proto may be NULL */
    if (duk_is_lightfunc(ctx, 0)) {
        if (h_new_proto == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]) {
            goto skip;
        }
        goto fail_nonextensible;
    }
    h_obj = duk_get_hobject(ctx, 0);
    if (!h_obj) {
        goto skip;
    }
    DUK_ASSERT(h_obj != NULL);
 
    /* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */
    /* TODO: implement Proxy object support here */
 
    if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) {
        goto skip;
    }
    if (!DUK_HOBJECT_HAS_EXTENSIBLE(h_obj)) {
        goto fail_nonextensible;
    }
    for (h_curr = h_new_proto; h_curr != NULL; h_curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_curr)) {
        /* Loop prevention */
        if (h_curr == h_obj) {
            goto fail_loop;
        }
    }
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h_obj, h_new_proto);
    /* fall thru */
 
 skip:
    duk_set_top(ctx, 1);
    return ret_success;
 
 fail_nonextensible:
 fail_loop:
    return DUK_RET_TYPE_ERROR;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx) {
    /* XXX: no need for indirect call */
    return duk_hobject_object_get_own_property_descriptor(ctx);
}
 
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 ] */
 
        duk_replace(ctx, 0);
 
        /* [ obj Properties ] */
 
        /* Just call the "original" Object.defineProperties() to
         * finish up.
         */
 
        return duk_bi_object_constructor_define_properties(ctx);
    }
 
    /* [ O Properties obj ] */
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_property(duk_context *ctx) {
    duk_hobject *obj;
    duk_hstring *key;
    duk_hobject *get;
    duk_hobject *set;
    duk_idx_t idx_value;
    duk_uint_t defprop_flags;
 
    DUK_ASSERT(ctx != NULL);
 
    DUK_DDD(DUK_DDDPRINT("Object.defineProperty(): ctx=%p obj=%!T key=%!T desc=%!T",
                         (void *) ctx,
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (duk_tval *) duk_get_tval(ctx, 2)));
 
    /* [ obj key desc ] */
 
    /* Lightfuncs are currently supported by coercing to a temporary
     * Function object; changes will be allowed (the coerced value is
     * extensible) but will be lost.
     */
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    (void) duk_to_string(ctx, 1);
    key = duk_require_hstring(ctx, 1);
    (void) duk_require_hobject(ctx, 2);
 
    DUK_ASSERT(obj != NULL);
    DUK_ASSERT(key != NULL);
    DUK_ASSERT(duk_get_hobject(ctx, 2) != NULL);
 
    /*
     *  Validate and convert argument property descriptor (an Ecmascript
     *  object) into a set of defprop_flags and possibly property value,
     *  getter, and/or setter values on the value stack.
     *
     *  Lightfunc set/get values are coerced to full Functions.
     */
 
    duk_hobject_prepare_property_descriptor(ctx,
                                            2 /*idx_desc*/,
                                            &defprop_flags,
                                            &idx_value,
                                            &get,
                                            &set);
 
    /*
     *  Use Object.defineProperty() helper for the actual operation.
     */
 
    duk_hobject_define_property_helper(ctx,
                                       defprop_flags,
                                       obj,
                                       key,
                                       idx_value,
                                       get,
                                       set);
 
    /* Ignore the normalize/validate helper outputs on the value stack,
     * they're popped automatically.
     */
 
    /*
     *  Return target object.
     */
 
    duk_push_hobject(ctx, obj);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_properties(duk_context *ctx) {
    duk_small_uint_t pass;
    duk_uint_t defprop_flags;
    duk_hobject *obj;
    duk_idx_t idx_value;
    duk_hobject *get;
    duk_hobject *set;
 
    /* Lightfunc handling by ToObject() coercion. */
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);  /* target */
    DUK_ASSERT(obj != NULL);
 
    duk_to_object(ctx, 1);        /* properties object */
 
    DUK_DDD(DUK_DDDPRINT("target=%!iT, properties=%!iT",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1)));
 
    /*
     *  Two pass approach to processing the property descriptors.
     *  On first pass validate and normalize all descriptors before
     *  any changes are made to the target object.  On second pass
     *  make the actual modifications to the target object.
     *
     *  Right now we'll just use the same normalize/validate helper
     *  on both passes, ignoring its outputs on the first pass.
     */
 
    for (pass = 0; pass < 2; pass++) {
        duk_set_top(ctx, 2);  /* -> [ hobject props ] */
        duk_enum(ctx, 1, DUK_ENUM_OWN_PROPERTIES_ONLY /*enum_flags*/);
 
        for (;;) {
            duk_hstring *key;
 
            /* [ hobject props enum(props) ] */
 
            duk_set_top(ctx, 3);
 
            if (!duk_next(ctx, 2, 1 /*get_value*/)) {
                break;
            }
 
            DUK_DDD(DUK_DDDPRINT("-> key=%!iT, desc=%!iT",
                                 (duk_tval *) duk_get_tval(ctx, -2),
                                 (duk_tval *) duk_get_tval(ctx, -1)));
 
            /* [ hobject props enum(props) key desc ] */
 
            duk_hobject_prepare_property_descriptor(ctx,
                                                    4 /*idx_desc*/,
                                                    &defprop_flags,
                                                    &idx_value,
                                                    &get,
                                                    &set);
 
            /* [ hobject props enum(props) key desc value? getter? setter? ] */
 
            if (pass == 0) {
                continue;
            }
 
            key = duk_get_hstring(ctx, 3);
            DUK_ASSERT(key != NULL);
 
            duk_hobject_define_property_helper(ctx,
                                               defprop_flags,
                                               obj,
                                               key,
                                               idx_value,
                                               get,
                                               set);
        }
    }
 
    /*
     *  Return target object
     */
 
    duk_dup(ctx, 0);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_seal_freeze_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_bool_t is_freeze;
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    if (!h) {
        /* Lightfunc, always success. */
        return 1;
    }
 
    is_freeze = (duk_bool_t) duk_get_current_magic(ctx);
    duk_hobject_object_seal_freeze_helper(thr, h, is_freeze);
 
    /* Sealed and frozen objects cannot gain any more properties,
     * so this is a good time to compact them.
     */
    duk_hobject_compact_props(thr, h);
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    if (!h) {
        /* Lightfunc, always success. */
        return 1;
    }
    DUK_ASSERT(h != NULL);
 
    DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
 
    /* A non-extensible object cannot gain any more properties,
     * so this is a good time to compact.
     */
    duk_hobject_compact_props(thr, h);
 
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx) {
    duk_hobject *h;
    duk_bool_t is_frozen;
    duk_bool_t rc;
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    if (!h) {
        duk_push_true(ctx);  /* frozen and sealed */
    } else {
        is_frozen = duk_get_current_magic(ctx);
        rc = duk_hobject_object_is_sealed_frozen_helper((duk_hthread *) ctx, h, is_frozen /*is_frozen*/);
        duk_push_boolean(ctx, rc);
    }
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx) {
    duk_hobject *h;
 
    h = duk_require_hobject_or_lfunc(ctx, 0);
    if (!h) {
        duk_push_false(ctx);
    } else {
        duk_push_boolean(ctx, DUK_HOBJECT_HAS_EXTENSIBLE(h));
    }
    return 1;
}
 
/* Shared helper for Object.getOwnPropertyNames() and Object.keys().
 * Magic: 0=getOwnPropertyNames, 1=Object.keys.
 */
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
#if defined(DUK_USE_ES6_PROXY)
    duk_hobject *h_proxy_target;
    duk_hobject *h_proxy_handler;
    duk_hobject *h_trap_result;
    duk_uarridx_t i, len, idx;
#endif
    duk_small_uint_t enum_flags;
 
    DUK_ASSERT_TOP(ctx, 1);
    DUK_UNREF(thr);
 
    obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    DUK_ASSERT(obj != NULL);
    DUK_UNREF(obj);
 
#if defined(DUK_USE_ES6_PROXY)
    if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
                                            obj,
                                            &h_proxy_target,
                                            &h_proxy_handler))) {
        goto skip_proxy;
    }
 
    duk_push_hobject(ctx, h_proxy_handler);
    if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_OWN_KEYS)) {
        /* Careful with reachability here: don't pop 'obj' before pushing
         * proxy target.
         */
        DUK_DDD(DUK_DDDPRINT("no ownKeys trap, get keys of target instead"));
        duk_pop_2(ctx);
        duk_push_hobject(ctx, h_proxy_target);
        duk_replace(ctx, 0);
        DUK_ASSERT_TOP(ctx, 1);
        goto skip_proxy;
    }
 
    /* [ obj handler trap ] */
    duk_insert(ctx, -2);
    duk_push_hobject(ctx, h_proxy_target);  /* -> [ obj trap handler target ] */
    duk_call_method(ctx, 1 /*nargs*/);      /* -> [ obj trap_result ] */
    h_trap_result = duk_require_hobject(ctx, -1);
    DUK_UNREF(h_trap_result);
 
    len = (duk_uarridx_t) duk_get_length(ctx, -1);
    idx = 0;
    duk_push_array(ctx);
    for (i = 0; i < len; i++) {
        /* [ obj trap_result res_arr ] */
        if (duk_get_prop_index(ctx, -2, i) && duk_is_string(ctx, -1)) {
            /* XXX: for Object.keys() we should check enumerability of key */
            /* [ obj trap_result res_arr propname ] */
            duk_put_prop_index(ctx, -2, idx);
            idx++;
        } else {
            duk_pop(ctx);
        }
    }
 
    /* XXX: missing trap result validation for non-configurable target keys
     * (must be present), for non-extensible target all target keys must be
     * present and no extra keys can be present.
     * http://www.ecma-international.org/ecma-262/6.0/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
     */
 
    /* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result)
     * should be filtered so that only enumerable keys remain.  Enumerability
     * should be checked with [[GetOwnProperty]] on the original object
     * (i.e., the proxy in this case).  If the proxy has a getOwnPropertyDescriptor
     * trap, it should be triggered for every property.  If the proxy doesn't have
     * the trap, enumerability should be checked against the target object instead.
     * We don't do any of this now, so Object.keys() and Object.getOwnPropertyNames()
     * return the same result now for proxy traps.  We still do clean up the trap
     * result, so that Object.keys() and Object.getOwnPropertyNames() will return a
     * clean array of strings without gaps.
     */
    return 1;
 
 skip_proxy:
#endif  /* DUK_USE_ES6_PROXY */
 
    DUK_ASSERT_TOP(ctx, 1);
 
    if (duk_get_current_magic(ctx)) {
        /* Object.keys */
        enum_flags = DUK_ENUM_OWN_PROPERTIES_ONLY |
                     DUK_ENUM_NO_PROXY_BEHAVIOR;
    } else {
        /* Object.getOwnPropertyNames */
        enum_flags = DUK_ENUM_INCLUDE_NONENUMERABLE |
                     DUK_ENUM_OWN_PROPERTIES_ONLY |
                     DUK_ENUM_NO_PROXY_BEHAVIOR;
    }
 
    return duk_hobject_get_enumerated_keys(ctx, enum_flags);
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx) {
    duk_push_this(ctx);
    duk_to_object_class_string_top(ctx);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx) {
    DUK_ASSERT_TOP(ctx, 0);
    (void) duk_push_this_coercible_to_object(ctx);
    duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_STRING);
    if (!duk_is_callable(ctx, 1)) {
        return DUK_RET_TYPE_ERROR;
    }
    duk_dup(ctx, 0);  /* -> [ O toString O ] */
    duk_call_method(ctx, 0);  /* XXX: call method tail call? */
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx) {
    (void) duk_push_this_coercible_to_object(ctx);
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_v;
    duk_hobject *h_obj;
 
    DUK_ASSERT_TOP(ctx, 1);
 
    h_v = duk_get_hobject(ctx, 0);
    if (!h_v) {
        duk_push_false(ctx);  /* XXX: tail call: return duk_push_false(ctx) */
        return 1;
    }
 
    h_obj = duk_push_this_coercible_to_object(ctx);
    DUK_ASSERT(h_obj != NULL);
 
    /* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare.
     * Prototype loops should cause an error to be thrown.
     */
    duk_push_boolean(ctx, duk_hobject_prototype_chain_contains(thr, DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_v), h_obj, 0 /*ignore_loop*/));
    return 1;
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_has_own_property(duk_context *ctx) {
    return duk_hobject_object_ownprop_helper(ctx, 0 /*required_desc_flags*/);
}
 
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_property_is_enumerable(duk_context *ctx) {
    return duk_hobject_object_ownprop_helper(ctx, DUK_PROPDESC_FLAG_ENUMERABLE /*required_desc_flags*/);
}