--- /dev/null
+/*
+ * Function built-ins
+ */
+
+#include "duk_internal.h"
+
+DUK_INTERNAL duk_ret_t duk_bi_function_constructor(duk_context *ctx) {
+ duk_hthread *thr = (duk_hthread *) ctx;
+ duk_hstring *h_sourcecode;
+ duk_idx_t nargs;
+ duk_idx_t i;
+ duk_small_uint_t comp_flags;
+ duk_hcompiledfunction *func;
+ duk_hobject *outer_lex_env;
+ duk_hobject *outer_var_env;
+
+ /* normal and constructor calls have identical semantics */
+
+ nargs = duk_get_top(ctx);
+ for (i = 0; i < nargs; i++) {
+ duk_to_string(ctx, i);
+ }
+
+ if (nargs == 0) {
+ duk_push_string(ctx, "");
+ duk_push_string(ctx, "");
+ } else if (nargs == 1) {
+ /* XXX: cover this with the generic >1 case? */
+ duk_push_string(ctx, "");
+ } else {
+ duk_insert(ctx, 0); /* [ arg1 ... argN-1 body] -> [body arg1 ... argN-1] */
+ duk_push_string(ctx, ",");
+ duk_insert(ctx, 1);
+ duk_join(ctx, nargs - 1);
+ }
+
+ /* [ body formals ], formals is comma separated list that needs to be parsed */
+
+ DUK_ASSERT_TOP(ctx, 2);
+
+ /* XXX: this placeholder is not always correct, but use for now.
+ * It will fail in corner cases; see test-dev-func-cons-args.js.
+ */
+ duk_push_string(ctx, "function(");
+ duk_dup(ctx, 1);
+ duk_push_string(ctx, "){");
+ duk_dup(ctx, 0);
+ duk_push_string(ctx, "}");
+ duk_concat(ctx, 5);
+
+ /* [ body formals source ] */
+
+ DUK_ASSERT_TOP(ctx, 3);
+
+ /* strictness is not inherited, intentional */
+ comp_flags = DUK_JS_COMPILE_FLAG_FUNCEXPR;
+
+ duk_push_hstring_stridx(ctx, DUK_STRIDX_COMPILE); /* XXX: copy from caller? */ /* XXX: ignored now */
+ h_sourcecode = duk_require_hstring(ctx, -2);
+ duk_js_compile(thr,
+ (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode),
+ (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode),
+ comp_flags);
+ func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
+ DUK_ASSERT(func != NULL);
+ DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) func));
+
+ /* [ body formals source template ] */
+
+ /* only outer_lex_env matters, as functions always get a new
+ * variable declaration environment.
+ */
+
+ outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
+ outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
+
+ duk_js_push_closure(thr, func, outer_var_env, outer_lex_env, 1 /*add_auto_proto*/);
+
+ /* [ body formals source template closure ] */
+
+ return 1;
+}
+
+DUK_INTERNAL duk_ret_t duk_bi_function_prototype(duk_context *ctx) {
+ /* ignore arguments, return undefined (E5 Section 15.3.4) */
+ DUK_UNREF(ctx);
+ return 0;
+}
+
+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx) {
+ duk_tval *tv;
+
+ /*
+ * E5 Section 15.3.4.2 places few requirements on the output of
+ * this function:
+ *
+ * - The result is an implementation dependent representation
+ * of the function; in particular
+ *
+ * - The result must follow the syntax of a FunctionDeclaration.
+ * In particular, the function must have a name (even in the
+ * case of an anonymous function or a function with an empty
+ * name).
+ *
+ * - Note in particular that the output does NOT need to compile
+ * into anything useful.
+ */
+
+
+ /* XXX: faster internal way to get this */
+ duk_push_this(ctx);
+ tv = duk_get_tval(ctx, -1);
+ DUK_ASSERT(tv != NULL);
+
+ if (DUK_TVAL_IS_OBJECT(tv)) {
+ duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv);
+ const char *func_name;
+
+ /* Function name: missing/undefined is mapped to empty string,
+ * otherwise coerce to string.
+ */
+ /* XXX: currently no handling for non-allowed identifier characters,
+ * e.g. a '{' in the function name.
+ */
+ duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
+ if (duk_is_undefined(ctx, -1)) {
+ func_name = "";
+ } else {
+ func_name = duk_to_string(ctx, -1);
+ DUK_ASSERT(func_name != NULL);
+ }
+
+ /* Indicate function type in the function body using a dummy
+ * directive.
+ */
+ if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj)) {
+ duk_push_sprintf(ctx, "function %s() {\"ecmascript\"}", (const char *) func_name);
+ } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) {
+ duk_push_sprintf(ctx, "function %s() {\"native\"}", (const char *) func_name);
+ } else if (DUK_HOBJECT_HAS_BOUND(obj)) {
+ duk_push_sprintf(ctx, "function %s() {\"bound\"}", (const char *) func_name);
+ } else {
+ goto type_error;
+ }
+ } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
+ duk_push_lightfunc_tostring(ctx, tv);
+ } else {
+ goto type_error;
+ }
+
+ return 1;
+
+ type_error:
+ return DUK_RET_TYPE_ERROR;
+}
+
+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx) {
+ duk_idx_t len;
+ duk_idx_t i;
+
+ DUK_ASSERT_TOP(ctx, 2); /* not a vararg function */
+
+ duk_push_this(ctx);
+ if (!duk_is_callable(ctx, -1)) {
+ DUK_DDD(DUK_DDDPRINT("func is not callable"));
+ goto type_error;
+ }
+ duk_insert(ctx, 0);
+ DUK_ASSERT_TOP(ctx, 3);
+
+ DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argArray=%!iT",
+ (duk_tval *) duk_get_tval(ctx, 0),
+ (duk_tval *) duk_get_tval(ctx, 1),
+ (duk_tval *) duk_get_tval(ctx, 2)));
+
+ /* [ func thisArg argArray ] */
+
+ if (duk_is_null_or_undefined(ctx, 2)) {
+ DUK_DDD(DUK_DDDPRINT("argArray is null/undefined, no args"));
+ len = 0;
+ } else if (!duk_is_object(ctx, 2)) {
+ goto type_error;
+ } else {
+ DUK_DDD(DUK_DDDPRINT("argArray is an object"));
+
+ /* XXX: make this an internal helper */
+ duk_get_prop_stridx(ctx, 2, DUK_STRIDX_LENGTH);
+ len = (duk_idx_t) duk_to_uint32(ctx, -1); /* ToUint32() coercion required */
+ duk_pop(ctx);
+
+ duk_require_stack(ctx, len);
+
+ DUK_DDD(DUK_DDDPRINT("argArray length is %ld", (long) len));
+ for (i = 0; i < len; i++) {
+ duk_get_prop_index(ctx, 2, i);
+ }
+ }
+ duk_remove(ctx, 2);
+ DUK_ASSERT_TOP(ctx, 2 + len);
+
+ /* [ func thisArg arg1 ... argN ] */
+
+ DUK_DDD(DUK_DDDPRINT("apply, func=%!iT, thisArg=%!iT, len=%ld",
+ (duk_tval *) duk_get_tval(ctx, 0),
+ (duk_tval *) duk_get_tval(ctx, 1),
+ (long) len));
+ duk_call_method(ctx, len);
+ return 1;
+
+ type_error:
+ return DUK_RET_TYPE_ERROR;
+}
+
+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx) {
+ duk_idx_t nargs;
+
+ /* Step 1 is not necessary because duk_call_method() will take
+ * care of it.
+ */
+
+ /* vararg function, thisArg needs special handling */
+ nargs = duk_get_top(ctx); /* = 1 + arg count */
+ if (nargs == 0) {
+ duk_push_undefined(ctx);
+ nargs++;
+ }
+ DUK_ASSERT(nargs >= 1);
+
+ /* [ thisArg arg1 ... argN ] */
+
+ duk_push_this(ctx); /* 'func' in the algorithm */
+ duk_insert(ctx, 0);
+
+ /* [ func thisArg arg1 ... argN ] */
+
+ DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argcount=%ld, top=%ld",
+ (duk_tval *) duk_get_tval(ctx, 0),
+ (duk_tval *) duk_get_tval(ctx, 1),
+ (long) (nargs - 1),
+ (long) duk_get_top(ctx)));
+ duk_call_method(ctx, nargs - 1);
+ return 1;
+}
+
+/* XXX: the implementation now assumes "chained" bound functions,
+ * whereas "collapsed" bound functions (where there is ever only
+ * one bound function which directly points to a non-bound, final
+ * function) would require a "collapsing" implementation which
+ * merges argument lists etc here.
+ */
+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_bind(duk_context *ctx) {
+ duk_hobject *h_bound;
+ duk_hobject *h_target;
+ duk_idx_t nargs;
+ duk_idx_t i;
+
+ /* vararg function, careful arg handling (e.g. thisArg may not be present) */
+ nargs = duk_get_top(ctx); /* = 1 + arg count */
+ if (nargs == 0) {
+ duk_push_undefined(ctx);
+ nargs++;
+ }
+ DUK_ASSERT(nargs >= 1);
+
+ duk_push_this(ctx);
+ if (!duk_is_callable(ctx, -1)) {
+ DUK_DDD(DUK_DDDPRINT("func is not callable"));
+ goto type_error;
+ }
+
+ /* [ thisArg arg1 ... argN func ] (thisArg+args == nargs total) */
+ DUK_ASSERT_TOP(ctx, nargs + 1);
+
+ /* create bound function object */
+ duk_push_object_helper(ctx,
+ DUK_HOBJECT_FLAG_EXTENSIBLE |
+ DUK_HOBJECT_FLAG_BOUND |
+ DUK_HOBJECT_FLAG_CONSTRUCTABLE |
+ DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION),
+ DUK_BIDX_FUNCTION_PROTOTYPE);
+ h_bound = duk_get_hobject(ctx, -1);
+ DUK_ASSERT(h_bound != NULL);
+
+ /* [ thisArg arg1 ... argN func boundFunc ] */
+ duk_dup(ctx, -2); /* func */
+ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
+
+ duk_dup(ctx, 0); /* thisArg */
+ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);
+
+ duk_push_array(ctx);
+
+ /* [ thisArg arg1 ... argN func boundFunc argArray ] */
+
+ for (i = 0; i < nargs - 1; i++) {
+ duk_dup(ctx, 1 + i);
+ duk_put_prop_index(ctx, -2, i);
+ }
+ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_ARGS, DUK_PROPDESC_FLAGS_NONE);
+
+ /* [ thisArg arg1 ... argN func boundFunc ] */
+
+ /* bound function 'length' property is interesting */
+ h_target = duk_get_hobject(ctx, -2);
+ if (h_target == NULL || /* lightfunc */
+ DUK_HOBJECT_GET_CLASS_NUMBER(h_target) == DUK_HOBJECT_CLASS_FUNCTION) {
+ /* For lightfuncs, simply read the virtual property. */
+ duk_int_t tmp;
+ duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH);
+ tmp = duk_to_int(ctx, -1) - (nargs - 1); /* step 15.a */
+ duk_pop(ctx);
+ duk_push_int(ctx, (tmp < 0 ? 0 : tmp));
+ } else {
+ duk_push_int(ctx, 0);
+ }
+ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); /* attrs in E5 Section 15.3.5.1 */
+
+ /* caller and arguments must use the same thrower, [[ThrowTypeError]] */
+ duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
+ duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE);
+
+ /* these non-standard properties are copied for convenience */
+ /* XXX: 'copy properties' API call? */
+ duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
+ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_WC);
+ duk_get_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME);
+ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC);
+
+ /* The 'strict' flag is copied to get the special [[Get]] of E5.1
+ * Section 15.3.5.4 to apply when a 'caller' value is a strict bound
+ * function. Not sure if this is correct, because the specification
+ * is a bit ambiguous on this point but it would make sense.
+ */
+ if (h_target == NULL) {
+ /* Lightfuncs are always strict. */
+ DUK_HOBJECT_SET_STRICT(h_bound);
+ } else if (DUK_HOBJECT_HAS_STRICT(h_target)) {
+ DUK_HOBJECT_SET_STRICT(h_bound);
+ }
+ DUK_DDD(DUK_DDDPRINT("created bound function: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
+
+ return 1;
+
+ type_error:
+ return DUK_RET_TYPE_ERROR;
+}
projects / ceph.git / blobdiff