duk_bi_array.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Macros
#define	DUK__ARRAY_MID_JOIN_LIMIT   4096
#define	DUK__ITER_EVERY   0
#define	DUK__ITER_SOME   1
#define	DUK__ITER_FOREACH   2
#define	DUK__ITER_MAP   3
#define	DUK__ITER_FILTER   4

Functions
DUK_LOCAL duk_uint32_t	duk__push_this_obj_len_u32 (duk_context *ctx)
DUK_LOCAL duk_uint32_t	duk__push_this_obj_len_u32_limited (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_constructor (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_constructor_is_array (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_to_string (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_concat (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_join_shared (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_pop (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_push (duk_context *ctx)
DUK_LOCAL duk_small_int_t	duk__array_sort_compare (duk_context *ctx, duk_int_t idx1, duk_int_t idx2)
DUK_LOCAL void	duk__array_sort_swap (duk_context *ctx, duk_int_t l, duk_int_t r)
DUK_LOCAL void	duk__array_qsort (duk_context *ctx, duk_int_t lo, duk_int_t hi)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_sort (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_splice (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_reverse (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_slice (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_shift (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_unshift (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_indexof_shared (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_iter_shared (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_array_prototype_reduce_shared (duk_context *ctx)

Macro Definition Documentation

DUK__ARRAY_MID_JOIN_LIMIT

#define DUK__ARRAY_MID_JOIN_LIMIT   4096

Definition at line 49 of file duktape-1.5.2/src-separate/duk_bi_array.c.

Referenced by duk_bi_array_prototype_join_shared().

DUK__ITER_EVERY

#define DUK__ITER_EVERY   0

Definition at line 1207 of file duktape-1.5.2/src-separate/duk_bi_array.c.

Referenced by duk_bi_array_prototype_iter_shared().

DUK__ITER_FILTER

#define DUK__ITER_FILTER   4

Definition at line 1211 of file duktape-1.5.2/src-separate/duk_bi_array.c.

Referenced by duk_bi_array_prototype_iter_shared().

DUK__ITER_FOREACH

#define DUK__ITER_FOREACH   2

Definition at line 1209 of file duktape-1.5.2/src-separate/duk_bi_array.c.

Referenced by duk_bi_array_prototype_iter_shared().

DUK__ITER_MAP

#define DUK__ITER_MAP   3

Definition at line 1210 of file duktape-1.5.2/src-separate/duk_bi_array.c.

Referenced by duk_bi_array_prototype_iter_shared().

DUK__ITER_SOME

#define DUK__ITER_SOME   1

Definition at line 1208 of file duktape-1.5.2/src-separate/duk_bi_array.c.

Referenced by duk_bi_array_prototype_iter_shared().

Function Documentation

duk__array_qsort()

DUK_LOCAL void duk__array_qsort	(	duk_context *	ctx,
		duk_int_t	lo,
		duk_int_t	hi )

Definition at line 602 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_int_t p, l, r;
 
    /* The lo/hi indices may be crossed and hi < 0 is possible at entry. */
 
    DUK_DDD(DUK_DDDPRINT("duk__array_qsort: lo=%ld, hi=%ld, obj=%!T",
                         (long) lo, (long) hi, (duk_tval *) duk_get_tval(ctx, 1)));
 
    DUK_ASSERT_TOP(ctx, 3);
 
    /* In some cases it may be that lo > hi, or hi < 0; these
     * degenerate cases happen e.g. for empty arrays, and in
     * recursion leaves.
     */
 
    /* trivial cases */
    if (hi - lo < 1) {
        DUK_DDD(DUK_DDDPRINT("degenerate case, return immediately"));
        return;
    }
    DUK_ASSERT(hi > lo);
    DUK_ASSERT(hi - lo + 1 >= 2);
 
    /* randomized pivot selection */
    p = lo + (duk_util_tinyrandom_get_bits(thr, 30) % (hi - lo + 1));  /* rnd in [lo,hi] */
    DUK_ASSERT(p >= lo && p <= hi);
    DUK_DDD(DUK_DDDPRINT("lo=%ld, hi=%ld, chose pivot p=%ld",
                         (long) lo, (long) hi, (long) p));
 
    /* move pivot out of the way */
    duk__array_sort_swap(ctx, p, lo);
    p = lo;
    DUK_DDD(DUK_DDDPRINT("pivot moved out of the way: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
 
    l = lo + 1;
    r = hi;
    for (;;) {
        /* find elements to swap */
        for (;;) {
            DUK_DDD(DUK_DDDPRINT("left scan: l=%ld, r=%ld, p=%ld",
                                 (long) l, (long) r, (long) p));
            if (l >= hi) {
                break;
            }
            if (duk__array_sort_compare(ctx, l, p) >= 0) {  /* !(l < p) */
                break;
            }
            l++;
        }
        for (;;) {
            DUK_DDD(DUK_DDDPRINT("right scan: l=%ld, r=%ld, p=%ld",
                                 (long) l, (long) r, (long) p));
            if (r <= lo) {
                break;
            }
            if (duk__array_sort_compare(ctx, p, r) >= 0) {  /* !(p < r) */
                break;
            }
            r--;
        }
        if (l >= r) {
            goto done;
        }
        DUK_ASSERT(l < r);
 
        DUK_DDD(DUK_DDDPRINT("swap %ld and %ld", (long) l, (long) r));
 
        duk__array_sort_swap(ctx, l, r);
 
        DUK_DDD(DUK_DDDPRINT("after swap: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
        l++;
        r--;
    }
 done:
    /* Note that 'l' and 'r' may cross, i.e. r < l */
    DUK_ASSERT(l >= lo && l <= hi);
    DUK_ASSERT(r >= lo && r <= hi);
 
    /* XXX: there's no explicit recursion bound here now.  For the average
     * qsort recursion depth O(log n) that's not really necessary: e.g. for
     * 2**32 recursion depth would be about 32 which is OK.  However, qsort
     * worst case recursion depth is O(n) which may be a problem.
     */
 
    /* move pivot to its final place */
    DUK_DDD(DUK_DDDPRINT("before final pivot swap: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
    duk__array_sort_swap(ctx, lo, r);
 
#if defined(DUK_USE_DDDPRINT)
    duk__debuglog_qsort_state(ctx, lo, hi, r);
#endif
 
    DUK_DDD(DUK_DDDPRINT("recurse: pivot=%ld, obj=%!T", (long) r, (duk_tval *) duk_get_tval(ctx, 1)));
    duk__array_qsort(ctx, lo, r - 1);
    duk__array_qsort(ctx, r + 1, hi);
}

References duk__array_qsort(), duk__array_sort_compare(), duk__array_sort_swap(), DUK_ASSERT, DUK_ASSERT_TOP, DUK_DDD, DUK_DDDPRINT, duk_get_tval(), and duk_util_tinyrandom_get_bits().

Referenced by duk__array_qsort(), and duk_bi_array_prototype_sort().

duk__array_sort_compare()

DUK_LOCAL duk_small_int_t duk__array_sort_compare	(	duk_context *	ctx,
		duk_int_t	idx1,
		duk_int_t	idx2 )

Definition at line 424 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                                                    {
    duk_bool_t have1, have2;
    duk_bool_t undef1, undef2;
    duk_small_int_t ret;
    duk_idx_t idx_obj = 1;  /* fixed offsets in valstack */
    duk_idx_t idx_fn = 0;
    duk_hstring *h1, *h2;
 
    /* Fast exit if indices are identical.  This is valid for a non-existent property,
     * for an undefined value, and almost always for ToString() coerced comparison of
     * arbitrary values (corner cases where this is not the case include e.g. a an
     * object with varying ToString() coercion).
     *
     * The specification does not prohibit "caching" of values read from the array, so
     * assuming equality for comparing an index with itself falls into the category of
     * "caching".
     *
     * Also, compareFn may be inconsistent, so skipping a call to compareFn here may
     * have an effect on the final result.  The specification does not require any
     * specific behavior for inconsistent compare functions, so again, this fast path
     * is OK.
     */
 
    if (idx1 == idx2) {
        DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld -> indices identical, quick exit",
                             (long) idx1, (long) idx2));
        return 0;
    }
 
    have1 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx1);
    have2 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx2);
 
    DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld, have1=%ld, have2=%ld, val1=%!T, val2=%!T",
                         (long) idx1, (long) idx2, (long) have1, (long) have2,
                         (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
 
    if (have1) {
        if (have2) {
            ;
        } else {
            ret = -1;
            goto pop_ret;
        }
    } else {
        if (have2) {
            ret = 1;
            goto pop_ret;
        } else {
            ret = 0;
            goto pop_ret;
        }
    }
 
    undef1 = duk_is_undefined(ctx, -2);
    undef2 = duk_is_undefined(ctx, -1);
    if (undef1) {
        if (undef2) {
            ret = 0;
            goto pop_ret;
        } else {
            ret = 1;
            goto pop_ret;
        }
    } else {
        if (undef2) {
            ret = -1;
            goto pop_ret;
        } else {
            ;
        }
    }
 
    if (!duk_is_undefined(ctx, idx_fn)) {
        duk_double_t d;
 
        /* no need to check callable; duk_call() will do that */
        duk_dup(ctx, idx_fn);    /* -> [ ... x y fn ] */
        duk_insert(ctx, -3);     /* -> [ ... fn x y ] */
        duk_call(ctx, 2);        /* -> [ ... res ] */
 
        /* The specification is a bit vague what to do if the return
         * value is not a number.  Other implementations seem to
         * tolerate non-numbers but e.g. V8 won't apparently do a
         * ToNumber().
         */
 
        /* XXX: best behavior for real world compatibility? */
 
        d = duk_to_number(ctx, -1);
        if (d < 0.0) {
            ret = -1;
        } else if (d > 0.0) {
            ret = 1;
        } else {
            ret = 0;
        }
 
        duk_pop(ctx);
        DUK_DDD(DUK_DDDPRINT("-> result %ld (from comparefn, after coercion)", (long) ret));
        return ret;
    }
 
    /* string compare is the default (a bit oddly) */
 
    h1 = duk_to_hstring(ctx, -2);
    h2 = duk_to_hstring(ctx, -1);
    DUK_ASSERT(h1 != NULL);
    DUK_ASSERT(h2 != NULL);
 
    ret = duk_js_string_compare(h1, h2);  /* retval is directly usable */
    goto pop_ret;
 
 pop_ret:
    duk_pop_2(ctx);
    DUK_DDD(DUK_DDDPRINT("-> result %ld", (long) ret));
    return ret;
}

References DUK_ASSERT, duk_call(), DUK_DDD, DUK_DDDPRINT, duk_dup(), duk_get_prop_index(), duk_get_tval(), duk_insert(), duk_is_undefined(), duk_js_string_compare(), duk_pop(), duk_pop_2(), duk_to_hstring(), duk_to_number(), and NULL.

Referenced by duk__array_qsort().

duk__array_sort_swap()

DUK_LOCAL void duk__array_sort_swap	(	duk_context *	ctx,
		duk_int_t	l,
		duk_int_t	r )

Definition at line 542 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                                {
    duk_bool_t have_l, have_r;
    duk_idx_t idx_obj = 1;  /* fixed offset in valstack */
 
    if (l == r) {
        return;
    }
 
    /* swap elements; deal with non-existent elements correctly */
    have_l = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
    have_r = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) r);
 
    if (have_r) {
        /* right exists, [[Put]] regardless whether or not left exists */
        duk_put_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
    } else {
        duk_del_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
        duk_pop(ctx);
    }
 
    if (have_l) {
        duk_put_prop_index(ctx, idx_obj, (duk_uarridx_t) r);
    } else {
        duk_del_prop_index(ctx, idx_obj, (duk_uarridx_t) r);
        duk_pop(ctx);
    }
}

References duk_del_prop_index(), duk_get_prop_index(), duk_pop(), and duk_put_prop_index().

Referenced by duk__array_qsort().

duk__push_this_obj_len_u32()

DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32

(

duk_context *

ctx

)

Definition at line 54 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                    {
    duk_uint32_t len;
 
    (void) duk_push_this_coercible_to_object(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);
    len = duk_to_uint32(ctx, -1);
 
    /* -> [ ... ToObject(this) ToUint32(length) ] */
    return len;
}

References duk_get_prop_stridx(), duk_push_this_coercible_to_object(), DUK_STRIDX_LENGTH, and duk_to_uint32().

Referenced by duk__push_this_obj_len_u32_limited(), duk_bi_array_prototype_iter_shared(), duk_bi_array_prototype_join_shared(), duk_bi_array_prototype_pop(), duk_bi_array_prototype_push(), duk_bi_array_prototype_reduce_shared(), duk_bi_array_prototype_reverse(), duk_bi_array_prototype_shift(), and duk_bi_array_prototype_unshift().

duk__push_this_obj_len_u32_limited()

DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32_limited

(

duk_context *

ctx

)

Definition at line 65 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                            {
    /* Range limited to [0, 0x7fffffff] range, i.e. range that can be
     * represented with duk_int32_t.  Use this when the method doesn't
     * handle the full 32-bit unsigned range correctly.
     */
    duk_uint32_t ret = duk__push_this_obj_len_u32(ctx);
    if (DUK_UNLIKELY(ret >= 0x80000000UL)) {
        DUK_ERROR_RANGE((duk_hthread *) ctx, DUK_STR_ARRAY_LENGTH_OVER_2G);
    }
    return ret;
}

References duk__push_this_obj_len_u32(), DUK_ERROR_RANGE, DUK_STR_ARRAY_LENGTH_OVER_2G, and DUK_UNLIKELY.

Referenced by duk_bi_array_prototype_indexof_shared(), duk_bi_array_prototype_slice(), duk_bi_array_prototype_sort(), and duk_bi_array_prototype_splice().

duk_bi_array_constructor()

DUK_INTERNAL duk_ret_t duk_bi_array_constructor

(

duk_context *

ctx

)

Definition at line 81 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                  {
    duk_idx_t nargs;
    duk_double_t d;
    duk_uint32_t len;
    duk_idx_t i;
 
    nargs = duk_get_top(ctx);
    duk_push_array(ctx);
 
    if (nargs == 1 && duk_is_number(ctx, 0)) {
        /* XXX: expensive check (also shared elsewhere - so add a shared internal API call?) */
        d = duk_get_number(ctx, 0);
        len = duk_to_uint32(ctx, 0);
        if (((duk_double_t) len) != d) {
            return DUK_RET_RANGE_ERROR;
        }
 
        /* XXX: if 'len' is low, may want to ensure array part is kept:
         * the caller is likely to want a dense array.
         */
        duk_push_u32(ctx, len);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);  /* [ ToUint32(len) array ToUint32(len) ] -> [ ToUint32(len) array ] */
        return 1;
    }
 
    /* XXX: optimize by creating array into correct size directly, and
     * operating on the array part directly; values can be memcpy()'d from
     * value stack directly as long as refcounts are increased.
     */
    for (i = 0; i < nargs; i++) {
        duk_dup(ctx, i);
        duk_xdef_prop_index_wec(ctx, -2, (duk_uarridx_t) i);
    }
 
    duk_push_u32(ctx, (duk_uint32_t) nargs);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
    return 1;
}

References duk_dup(), duk_get_number(), duk_get_top(), duk_is_number(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_u32, DUK_RET_RANGE_ERROR, DUK_STRIDX_LENGTH, duk_to_uint32(), duk_xdef_prop_index_wec, and duk_xdef_prop_stridx().

duk_bi_array_constructor_is_array()

DUK_INTERNAL duk_ret_t duk_bi_array_constructor_is_array

(

duk_context *

ctx

)

Definition at line 124 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                           {
    duk_hobject *h;
 
    h = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_ARRAY);
    duk_push_boolean(ctx, (h != NULL));
    return 1;
}

References duk_get_hobject_with_class(), DUK_HOBJECT_CLASS_ARRAY, duk_push_boolean(), and NULL.

duk_bi_array_prototype_concat()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_concat

(

duk_context *

ctx

)

Definition at line 175 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                       {
    duk_idx_t i, n;
    duk_uarridx_t idx, idx_last;
    duk_uarridx_t j, len;
    duk_hobject *h;
 
    /* XXX: the insert here is a bit expensive if there are a lot of items.
     * It could also be special cased in the outermost for loop quite easily
     * (as the element is dup()'d anyway).
     */
 
    (void) duk_push_this_coercible_to_object(ctx);
    duk_insert(ctx, 0);
    n = duk_get_top(ctx);
    duk_push_array(ctx);  /* -> [ ToObject(this) item1 ... itemN arr ] */
 
    /* NOTE: The Array special behaviors are NOT invoked by duk_xdef_prop_index()
     * (which differs from the official algorithm).  If no error is thrown, this
     * doesn't matter as the length is updated at the end.  However, if an error
     * is thrown, the length will be unset.  That shouldn't matter because the
     * caller won't get a reference to the intermediate value.
     */
 
    idx = 0;
    idx_last = 0;
    for (i = 0; i < n; i++) {
        DUK_ASSERT_TOP(ctx, n + 1);
 
        /* [ ToObject(this) item1 ... itemN arr ] */
 
        duk_dup(ctx, i);
        h = duk_get_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_ARRAY);
        if (!h) {
            duk_xdef_prop_index_wec(ctx, -2, idx++);
            idx_last = idx;
            continue;
        }
 
        /* [ ToObject(this) item1 ... itemN arr item(i) ] */
 
        /* XXX: an array can have length higher than 32 bits; this is not handled
         * correctly now.
         */
        len = (duk_uarridx_t) duk_get_length(ctx, -1);
        for (j = 0; j < len; j++) {
            if (duk_get_prop_index(ctx, -1, j)) {
                /* [ ToObject(this) item1 ... itemN arr item(i) item(i)[j] ] */
                duk_xdef_prop_index_wec(ctx, -3, idx++);
                idx_last = idx;
            } else {
                idx++;
                duk_pop(ctx);
#if defined(DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER)
                /* According to E5.1 Section 15.4.4.4 nonexistent trailing
                 * elements do not affect 'length' of the result.  Test262
                 * and other engines disagree, so update idx_last here too.
                 */
                idx_last = idx;
#else
                /* Strict standard behavior, ignore trailing elements for
                 * result 'length'.
                 */
#endif
            }
        }
        duk_pop(ctx);
    }
 
    /* The E5.1 Section 15.4.4.4 algorithm doesn't set the length explicitly
     * in the end, but because we're operating with an internal value which
     * is known to be an array, this should be equivalent.
     */
    duk_push_uarridx(ctx, idx_last);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
 
    DUK_ASSERT_TOP(ctx, n + 1);
    return 1;
}

References DUK_ASSERT_TOP, duk_dup(), duk_get_hobject_with_class(), duk_get_length(), duk_get_prop_index(), duk_get_top(), DUK_HOBJECT_CLASS_ARRAY, duk_insert(), duk_pop(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_this_coercible_to_object(), duk_push_uarridx, DUK_STRIDX_LENGTH, duk_xdef_prop_index_wec, and duk_xdef_prop_stridx().

duk_bi_array_prototype_indexof_shared()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_indexof_shared

(

duk_context *

ctx

)

Definition at line 1117 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                               {
    duk_idx_t nargs;
    duk_int_t i, len;
    duk_int_t from_index;
    duk_small_int_t idx_step = duk_get_current_magic(ctx);  /* idx_step is +1 for indexOf, -1 for lastIndexOf */
 
    /* lastIndexOf() needs to be a vararg function because we must distinguish
     * between an undefined fromIndex and a "not given" fromIndex; indexOf() is
     * made vararg for symmetry although it doesn't strictly need to be.
     */
 
    nargs = duk_get_top(ctx);
    duk_set_top(ctx, 2);
 
    /* XXX: must be able to represent -len */
    len = (duk_int_t) duk__push_this_obj_len_u32_limited(ctx);
    if (len == 0) {
        goto not_found;
    }
 
    /* Index clamping is a bit tricky, we must ensure that we'll only iterate
     * through elements that exist and that the specific requirements from E5.1
     * Sections 15.4.4.14 and 15.4.4.15 are fulfilled; especially:
     *
     *   - indexOf: clamp to [-len,len], negative handling -> [0,len],
     *     if clamped result is len, for-loop bails out immediately
     *
     *   - lastIndexOf: clamp to [-len-1, len-1], negative handling -> [-1, len-1],
     *     if clamped result is -1, for-loop bails out immediately
     *
     * If fromIndex is not given, ToInteger(undefined) = 0, which is correct
     * for indexOf() but incorrect for lastIndexOf().  Hence special handling,
     * and why lastIndexOf() needs to be a vararg function.
     */
 
    if (nargs >= 2) {
        /* indexOf: clamp fromIndex to [-len, len]
         * (if fromIndex == len, for-loop terminates directly)
         *
         * lastIndexOf: clamp fromIndex to [-len - 1, len - 1]
         * (if clamped to -len-1 -> fromIndex becomes -1, terminates for-loop directly)
         */
        from_index = duk_to_int_clamped(ctx,
                                        1,
                                        (idx_step > 0 ? -len : -len - 1),
                                        (idx_step > 0 ? len : len - 1));
        if (from_index < 0) {
            /* for lastIndexOf, result may be -1 (mark immediate termination) */
            from_index = len + from_index;
        }
    } else {
        /* for indexOf, ToInteger(undefined) would be 0, i.e. correct, but
         * handle both indexOf and lastIndexOf specially here.
         */
        if (idx_step > 0) {
            from_index = 0;
        } else {
            from_index = len - 1;
        }
    }
 
    /* stack[0] = searchElement
     * stack[1] = fromIndex
     * stack[2] = object
     * stack[3] = length (not needed, but not popped above)
     */
 
    for (i = from_index; i >= 0 && i < len; i += idx_step) {
        DUK_ASSERT_TOP(ctx, 4);
 
        if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
            DUK_ASSERT_TOP(ctx, 5);
            if (duk_strict_equals(ctx, 0, 4)) {
                duk_push_int(ctx, i);
                return 1;
            }
        }
 
        duk_pop(ctx);
    }
 
 not_found:
    duk_push_int(ctx, -1);
    return 1;
}

References duk__push_this_obj_len_u32_limited(), DUK_ASSERT_TOP, duk_get_current_magic(), duk_get_prop_index(), duk_get_top(), duk_pop(), duk_push_int(), duk_set_top(), duk_strict_equals(), and duk_to_int_clamped().

duk_bi_array_prototype_iter_shared()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared

(

duk_context *

ctx

)

Definition at line 1218 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                            {
    duk_uint32_t len;
    duk_uint32_t i;
    duk_uarridx_t k;
    duk_bool_t bval;
    duk_small_int_t iter_type = duk_get_current_magic(ctx);
    duk_uint32_t res_length = 0;
 
    /* each call this helper serves has nargs==2 */
    DUK_ASSERT_TOP(ctx, 2);
 
    len = duk__push_this_obj_len_u32(ctx);
    duk_require_callable(ctx, 0);
    /* if thisArg not supplied, behave as if undefined was supplied */
 
    if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) {
        duk_push_array(ctx);
    } else {
        duk_push_undefined(ctx);
    }
 
    /* stack[0] = callback
     * stack[1] = thisArg
     * stack[2] = object
     * stack[3] = ToUint32(length)  (unused, but avoid unnecessary pop)
     * stack[4] = result array (or undefined)
     */
 
    k = 0;  /* result index for filter() */
    for (i = 0; i < len; i++) {
        DUK_ASSERT_TOP(ctx, 5);
 
        if (!duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
#if defined(DUK_USE_NONSTD_ARRAY_MAP_TRAILER)
            /* Real world behavior for map(): trailing non-existent
             * elements don't invoke the user callback, but are still
             * counted towards result 'length'.
             */
            if (iter_type == DUK__ITER_MAP) {
                res_length = i + 1;
            }
#else
            /* Standard behavior for map(): trailing non-existent
             * elements don't invoke the user callback and are not
             * counted towards result 'length'.
             */
#endif
            duk_pop(ctx);
            continue;
        }
 
        /* The original value needs to be preserved for filter(), hence
         * this funny order.  We can't re-get the value because of side
         * effects.
         */
 
        duk_dup(ctx, 0);
        duk_dup(ctx, 1);
        duk_dup(ctx, -3);
        duk_push_u32(ctx, i);
        duk_dup(ctx, 2);  /* [ ... val callback thisArg val i obj ] */
        duk_call_method(ctx, 3); /* -> [ ... val retval ] */
 
        switch (iter_type) {
        case DUK__ITER_EVERY:
            bval = duk_to_boolean(ctx, -1);
            if (!bval) {
                /* stack top contains 'false' */
                return 1;
            }
            break;
        case DUK__ITER_SOME:
            bval = duk_to_boolean(ctx, -1);
            if (bval) {
                /* stack top contains 'true' */
                return 1;
            }
            break;
        case DUK__ITER_FOREACH:
            /* nop */
            break;
        case DUK__ITER_MAP:
            duk_dup(ctx, -1);
            duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) i);  /* retval to result[i] */
            res_length = i + 1;
            break;
        case DUK__ITER_FILTER:
            bval = duk_to_boolean(ctx, -1);
            if (bval) {
                duk_dup(ctx, -2);  /* orig value */
                duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) k);
                k++;
                res_length = k;
            }
            break;
        default:
            DUK_UNREACHABLE();
            break;
        }
        duk_pop_2(ctx);
 
        DUK_ASSERT_TOP(ctx, 5);
    }
 
    switch (iter_type) {
    case DUK__ITER_EVERY:
        duk_push_true(ctx);
        break;
    case DUK__ITER_SOME:
        duk_push_false(ctx);
        break;
    case DUK__ITER_FOREACH:
        duk_push_undefined(ctx);
        break;
    case DUK__ITER_MAP:
    case DUK__ITER_FILTER:
        DUK_ASSERT_TOP(ctx, 5);
        DUK_ASSERT(duk_is_array(ctx, -1));  /* topmost element is the result array already */
        duk_push_u32(ctx, res_length);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
        break;
    default:
        DUK_UNREACHABLE();
        break;
    }
 
    return 1;
}

References DUK__ITER_EVERY, DUK__ITER_FILTER, DUK__ITER_FOREACH, DUK__ITER_MAP, DUK__ITER_SOME, duk__push_this_obj_len_u32(), DUK_ASSERT, DUK_ASSERT_TOP, duk_call_method(), duk_dup(), duk_get_current_magic(), duk_get_prop_index(), duk_is_array(), duk_pop(), duk_pop_2(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_false(), duk_push_true(), duk_push_u32, duk_push_undefined(), duk_require_callable, DUK_STRIDX_LENGTH, duk_to_boolean(), DUK_UNREACHABLE, duk_xdef_prop_index_wec, and duk_xdef_prop_stridx().

duk_bi_array_prototype_join_shared()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_join_shared

(

duk_context *

ctx

)

Definition at line 267 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                            {
    duk_uint32_t len, count;
    duk_uint32_t idx;
    duk_small_int_t to_locale_string = duk_get_current_magic(ctx);
    duk_idx_t valstack_required;
 
    /* For join(), nargs is 1.  For toLocaleString(), nargs is 0 and
     * setting the top essentially pushes an undefined to the stack,
     * thus defaulting to a comma separator.
     */
    duk_set_top(ctx, 1);
    if (duk_is_undefined(ctx, 0)) {
        duk_pop(ctx);
        duk_push_hstring_stridx(ctx, DUK_STRIDX_COMMA);
    } else {
        duk_to_string(ctx, 0);
    }
 
    len = duk__push_this_obj_len_u32(ctx);
 
    /* [ sep ToObject(this) len ] */
 
    DUK_DDD(DUK_DDDPRINT("sep=%!T, this=%!T, len=%lu",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (unsigned long) len));
 
    /* The extra (+4) is tight. */
    valstack_required = (len >= DUK__ARRAY_MID_JOIN_LIMIT ?
                         DUK__ARRAY_MID_JOIN_LIMIT : len) + 4;
    duk_require_stack(ctx, valstack_required);
 
    duk_dup(ctx, 0);
 
    /* [ sep ToObject(this) len sep ] */
 
    count = 0;
    idx = 0;
    for (;;) {
        if (count >= DUK__ARRAY_MID_JOIN_LIMIT ||   /* intermediate join to avoid valstack overflow */
            idx >= len) { /* end of loop (careful with len==0) */
            /* [ sep ToObject(this) len sep str0 ... str(count-1) ] */
            DUK_DDD(DUK_DDDPRINT("mid/final join, count=%ld, idx=%ld, len=%ld",
                                 (long) count, (long) idx, (long) len));
            duk_join(ctx, (duk_idx_t) count);  /* -> [ sep ToObject(this) len str ] */
            duk_dup(ctx, 0);                   /* -> [ sep ToObject(this) len str sep ] */
            duk_insert(ctx, -2);               /* -> [ sep ToObject(this) len sep str ] */
            count = 1;
        }
        if (idx >= len) {
            /* if true, the stack already contains the final result */
            break;
        }
 
        duk_get_prop_index(ctx, 1, (duk_uarridx_t) idx);
        if (duk_is_null_or_undefined(ctx, -1)) {
            duk_pop(ctx);
            duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
        } else {
            if (to_locale_string) {
                duk_to_object(ctx, -1);
                duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_LOCALE_STRING);
                duk_insert(ctx, -2);  /* -> [ ... toLocaleString ToObject(val) ] */
                duk_call_method(ctx, 0);
                duk_to_string(ctx, -1);
            } else {
                duk_to_string(ctx, -1);
            }
        }
 
        count++;
        idx++;
    }
 
    /* [ sep ToObject(this) len sep result ] */
 
    return 1;
}

References DUK__ARRAY_MID_JOIN_LIMIT, duk__push_this_obj_len_u32(), duk_call_method(), DUK_DDD, DUK_DDDPRINT, duk_dup(), duk_get_current_magic(), duk_get_prop_index(), duk_get_prop_stridx(), duk_get_tval(), duk_insert(), duk_is_null_or_undefined(), duk_is_undefined(), duk_join(), duk_pop(), duk_push_hstring_stridx(), duk_require_stack(), duk_set_top(), DUK_STRIDX_COMMA, DUK_STRIDX_EMPTY_STRING, DUK_STRIDX_TO_LOCALE_STRING, duk_to_object(), and duk_to_string().

duk_bi_array_prototype_pop()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_pop

(

duk_context *

ctx

)

Definition at line 350 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                    {
    duk_uint32_t len;
    duk_uint32_t idx;
 
    DUK_ASSERT_TOP(ctx, 0);
    len = duk__push_this_obj_len_u32(ctx);
    if (len == 0) {
        duk_push_int(ctx, 0);
        duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
        return 0;
    }
    idx = len - 1;
 
    duk_get_prop_index(ctx, 0, (duk_uarridx_t) idx);
    duk_del_prop_index(ctx, 0, (duk_uarridx_t) idx);
    duk_push_u32(ctx, idx);
    duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
    return 1;
}

References duk__push_this_obj_len_u32(), DUK_ASSERT_TOP, duk_del_prop_index(), duk_get_prop_index(), duk_push_int(), duk_push_u32, duk_put_prop_stridx(), and DUK_STRIDX_LENGTH.

duk_bi_array_prototype_push()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_push

(

duk_context *

ctx

)

Definition at line 370 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                     {
    /* Note: 'this' is not necessarily an Array object.  The push()
     * algorithm is supposed to work for other kinds of objects too,
     * so the algorithm has e.g. an explicit update for the 'length'
     * property which is normally "magical" in arrays.
     */
 
    duk_uint32_t len;
    duk_idx_t i, n;
 
    n = duk_get_top(ctx);
    len = duk__push_this_obj_len_u32(ctx);
 
    /* [ arg1 ... argN obj length ] */
 
    /* Technically Array.prototype.push() can create an Array with length
     * longer than 2^32-1, i.e. outside the 32-bit range.  The final length
     * is *not* wrapped to 32 bits in the specification.
     *
     * This implementation tracks length with a uint32 because it's much
     * more practical.
     *
     * See: test-bi-array-push-maxlen.js.
     */
 
    if (len + (duk_uint32_t) n < len) {
        DUK_D(DUK_DPRINT("Array.prototype.push() would go beyond 32-bit length, throw"));
        return DUK_RET_RANGE_ERROR;
    }
 
    for (i = 0; i < n; i++) {
        duk_dup(ctx, i);
        duk_put_prop_index(ctx, -3, len + i);
    }
    len += n;
 
    duk_push_u32(ctx, len);
    duk_dup_top(ctx);
    duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH);
 
    /* [ arg1 ... argN obj length new_length ] */
    return 1;
}

References duk__push_this_obj_len_u32(), DUK_D, DUK_DPRINT, duk_dup(), duk_dup_top(), duk_get_top(), duk_push_u32, duk_put_prop_index(), duk_put_prop_stridx(), DUK_RET_RANGE_ERROR, and DUK_STRIDX_LENGTH.

duk_bi_array_prototype_reduce_shared()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reduce_shared

(

duk_context *

ctx

)

Definition at line 1351 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                              {
    duk_idx_t nargs;
    duk_bool_t have_acc;
    duk_uint32_t i, len;
    duk_small_int_t idx_step = duk_get_current_magic(ctx);  /* idx_step is +1 for reduce, -1 for reduceRight */
 
    /* We're a varargs function because we need to detect whether
     * initialValue was given or not.
     */
    nargs = duk_get_top(ctx);
    DUK_DDD(DUK_DDDPRINT("nargs=%ld", (long) nargs));
 
    duk_set_top(ctx, 2);
    len = duk__push_this_obj_len_u32(ctx);
    if (!duk_is_callable(ctx, 0)) {
        goto type_error;
    }
 
    /* stack[0] = callback fn
     * stack[1] = initialValue
     * stack[2] = object (coerced this)
     * stack[3] = length (not needed, but not popped above)
     * stack[4] = accumulator
     */
 
    have_acc = 0;
    if (nargs >= 2) {
        duk_dup(ctx, 1);
        have_acc = 1;
    }
    DUK_DDD(DUK_DDDPRINT("have_acc=%ld, acc=%!T",
                         (long) have_acc, (duk_tval *) duk_get_tval(ctx, 3)));
 
    /* For len == 0, i is initialized to len - 1 which underflows.
     * The condition (i < len) will then exit the for-loop on the
     * first round which is correct.  Similarly, loop termination
     * happens by i underflowing.
     */
 
    for (i = (idx_step >= 0 ? 0 : len - 1);
         i < len;  /* i >= 0 would always be true */
         i += idx_step) {
        DUK_DDD(DUK_DDDPRINT("i=%ld, len=%ld, have_acc=%ld, top=%ld, acc=%!T",
                             (long) i, (long) len, (long) have_acc,
                             (long) duk_get_top(ctx),
                             (duk_tval *) duk_get_tval(ctx, 4)));
 
        DUK_ASSERT((have_acc && duk_get_top(ctx) == 5) ||
                   (!have_acc && duk_get_top(ctx) == 4));
 
        if (!duk_has_prop_index(ctx, 2, (duk_uarridx_t) i)) {
            continue;
        }
 
        if (!have_acc) {
            DUK_ASSERT_TOP(ctx, 4);
            duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
            have_acc = 1;
            DUK_ASSERT_TOP(ctx, 5);
        } else {
            DUK_ASSERT_TOP(ctx, 5);
            duk_dup(ctx, 0);
            duk_dup(ctx, 4);
            duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
            duk_push_u32(ctx, i);
            duk_dup(ctx, 2);
            DUK_DDD(DUK_DDDPRINT("calling reduce function: func=%!T, prev=%!T, curr=%!T, idx=%!T, obj=%!T",
                                 (duk_tval *) duk_get_tval(ctx, -5), (duk_tval *) duk_get_tval(ctx, -4),
                                 (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
                                 (duk_tval *) duk_get_tval(ctx, -1)));
            duk_call(ctx, 4);
            DUK_DDD(DUK_DDDPRINT("-> result: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
            duk_replace(ctx, 4);
            DUK_ASSERT_TOP(ctx, 5);
        }
    }
 
    if (!have_acc) {
        goto type_error;
    }
 
    DUK_ASSERT_TOP(ctx, 5);
    return 1;
 
 type_error:
    return DUK_RET_TYPE_ERROR;
}

References duk__push_this_obj_len_u32(), DUK_ASSERT, DUK_ASSERT_TOP, duk_call(), DUK_DDD, DUK_DDDPRINT, duk_dup(), duk_get_current_magic(), duk_get_prop_index(), duk_get_top(), duk_get_tval(), duk_has_prop_index(), duk_is_callable, duk_push_u32, duk_replace(), DUK_RET_TYPE_ERROR, and duk_set_top().

duk_bi_array_prototype_reverse()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reverse

(

duk_context *

ctx

)

Definition at line 900 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                        {
    duk_uint32_t len;
    duk_uint32_t middle;
    duk_uint32_t lower, upper;
    duk_bool_t have_lower, have_upper;
 
    len = duk__push_this_obj_len_u32(ctx);
    middle = len / 2;
 
    /* If len <= 1, middle will be 0 and for-loop bails out
     * immediately (0 < 0 -> false).
     */
 
    for (lower = 0; lower < middle; lower++) {
        DUK_ASSERT(len >= 2);
        DUK_ASSERT_TOP(ctx, 2);
 
        DUK_ASSERT(len >= lower + 1);
        upper = len - lower - 1;
 
        have_lower = duk_get_prop_index(ctx, -2, (duk_uarridx_t) lower);
        have_upper = duk_get_prop_index(ctx, -3, (duk_uarridx_t) upper);
 
        /* [ ToObject(this) ToUint32(length) lowerValue upperValue ] */
 
        if (have_upper) {
            duk_put_prop_index(ctx, -4, (duk_uarridx_t) lower);
        } else {
            duk_del_prop_index(ctx, -4, (duk_uarridx_t) lower);
            duk_pop(ctx);
        }
 
        if (have_lower) {
            duk_put_prop_index(ctx, -3, (duk_uarridx_t) upper);
        } else {
            duk_del_prop_index(ctx, -3, (duk_uarridx_t) upper);
            duk_pop(ctx);
        }
 
        DUK_ASSERT_TOP(ctx, 2);
    }
 
    DUK_ASSERT_TOP(ctx, 2);
    duk_pop(ctx);  /* -> [ ToObject(this) ] */
    return 1;
}

References duk__push_this_obj_len_u32(), DUK_ASSERT, DUK_ASSERT_TOP, duk_del_prop_index(), duk_get_prop_index(), duk_pop(), and duk_put_prop_index().

duk_bi_array_prototype_shift()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_shift

(

duk_context *

ctx

)

Definition at line 1013 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                      {
    duk_uint32_t len;
    duk_uint32_t i;
 
    len = duk__push_this_obj_len_u32(ctx);
    if (len == 0) {
        duk_push_int(ctx, 0);
        duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
        return 0;
    }
 
    duk_get_prop_index(ctx, 0, 0);
 
    /* stack[0] = object (this)
     * stack[1] = ToUint32(length)
     * stack[2] = elem at index 0 (retval)
     */
 
    for (i = 1; i < len; i++) {
        DUK_ASSERT_TOP(ctx, 3);
        if (duk_get_prop_index(ctx, 0, (duk_uarridx_t) i)) {
            /* fromPresent = true */
            duk_put_prop_index(ctx, 0, (duk_uarridx_t) (i - 1));
        } else {
            /* fromPresent = false */
            duk_del_prop_index(ctx, 0, (duk_uarridx_t) (i - 1));
            duk_pop(ctx);
        }
    }
    duk_del_prop_index(ctx, 0, (duk_uarridx_t) (len - 1));
 
    duk_push_u32(ctx, (duk_uint32_t) (len - 1));
    duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
 
    DUK_ASSERT_TOP(ctx, 3);
    return 1;
}

References duk__push_this_obj_len_u32(), DUK_ASSERT_TOP, duk_del_prop_index(), duk_get_prop_index(), duk_pop(), duk_push_int(), duk_push_u32, duk_put_prop_index(), duk_put_prop_stridx(), and DUK_STRIDX_LENGTH.

duk_bi_array_prototype_slice()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_slice

(

duk_context *

ctx

)

Definition at line 951 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                      {
    duk_uint32_t len;
    duk_int_t start, end;
    duk_int_t i;
    duk_uarridx_t idx;
    duk_uint32_t res_length = 0;
 
    /* XXX: len >= 0x80000000 won't work below because we need to be
     * able to represent -len.
     */
    len = duk__push_this_obj_len_u32_limited(ctx);
    duk_push_array(ctx);
 
    /* stack[0] = start
     * stack[1] = end
     * stack[2] = ToObject(this)
     * stack[3] = ToUint32(length)
     * stack[4] = result array
     */
 
    start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
    if (start < 0) {
        start = len + start;
    }
    /* XXX: could duk_is_undefined() provide defaulting undefined to 'len'
     * (the upper limit)?
     */
    if (duk_is_undefined(ctx, 1)) {
        end = len;
    } else {
        end = duk_to_int_clamped(ctx, 1, -((duk_int_t) len), (duk_int_t) len);
        if (end < 0) {
            end = len + end;
        }
    }
    DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len);
    DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len);
 
    idx = 0;
    for (i = start; i < end; i++) {
        DUK_ASSERT_TOP(ctx, 5);
        if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
            duk_xdef_prop_index_wec(ctx, 4, idx);
            res_length = idx + 1;
        } else {
            duk_pop(ctx);
        }
        idx++;
        DUK_ASSERT_TOP(ctx, 5);
    }
 
    duk_push_u32(ctx, res_length);
    duk_xdef_prop_stridx(ctx, 4, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
 
    DUK_ASSERT_TOP(ctx, 5);
    return 1;
}

References duk__push_this_obj_len_u32_limited(), DUK_ASSERT, DUK_ASSERT_TOP, duk_get_prop_index(), duk_is_undefined(), duk_pop(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_u32, DUK_STRIDX_LENGTH, duk_to_int_clamped(), duk_xdef_prop_index_wec, and duk_xdef_prop_stridx().

duk_bi_array_prototype_sort()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_sort

(

duk_context *

ctx

)

Definition at line 700 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                     {
    duk_uint32_t len;
 
    /* XXX: len >= 0x80000000 won't work below because a signed type
     * is needed by qsort.
     */
    len = duk__push_this_obj_len_u32_limited(ctx);
 
    /* stack[0] = compareFn
     * stack[1] = ToObject(this)
     * stack[2] = ToUint32(length)
     */
 
    if (len > 0) {
        /* avoid degenerate cases, so that (len - 1) won't underflow */
        duk__array_qsort(ctx, (duk_int_t) 0, (duk_int_t) (len - 1));
    }
 
    DUK_ASSERT_TOP(ctx, 3);
    duk_pop(ctx);
    return 1;  /* return ToObject(this) */
}

References duk__array_qsort(), duk__push_this_obj_len_u32_limited(), DUK_ASSERT_TOP, and duk_pop().

duk_bi_array_prototype_splice()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_splice

(

duk_context *

ctx

)

Definition at line 736 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                       {
    duk_idx_t nargs;
    duk_uint32_t len;
    duk_bool_t have_delcount;
    duk_int_t item_count;
    duk_int_t act_start;
    duk_int_t del_count;
    duk_int_t i, n;
 
    DUK_UNREF(have_delcount);
 
    nargs = duk_get_top(ctx);
    if (nargs < 2) {
        duk_set_top(ctx, 2);
        nargs = 2;
        have_delcount = 0;
    } else {
        have_delcount = 1;
    }
 
    /* XXX: len >= 0x80000000 won't work below because we need to be
     * able to represent -len.
     */
    len = duk__push_this_obj_len_u32_limited(ctx);
 
    act_start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
    if (act_start < 0) {
        act_start = len + act_start;
    }
    DUK_ASSERT(act_start >= 0 && act_start <= (duk_int_t) len);
 
#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
    if (have_delcount) {
#endif
        del_count = duk_to_int_clamped(ctx, 1, 0, len - act_start);
#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
    } else {
        /* E5.1 standard behavior when deleteCount is not given would be
         * to treat it just like if 'undefined' was given, which coerces
         * ultimately to 0.  Real world behavior is to splice to the end
         * of array, see test-bi-array-proto-splice-no-delcount.js.
         */
        del_count = len - act_start;
    }
#endif
 
    DUK_ASSERT(nargs >= 2);
    item_count = (duk_int_t) (nargs - 2);
 
    DUK_ASSERT(del_count >= 0 && del_count <= (duk_int_t) len - act_start);
    DUK_ASSERT(del_count + act_start <= (duk_int_t) len);
 
    /* For now, restrict result array into 32-bit length range. */
    if (((duk_double_t) len) - ((duk_double_t) del_count) + ((duk_double_t) item_count) > (duk_double_t) DUK_UINT32_MAX) {
        DUK_D(DUK_DPRINT("Array.prototype.splice() would go beyond 32-bit length, throw"));
        return DUK_RET_RANGE_ERROR;
    }
 
    duk_push_array(ctx);
 
    /* stack[0] = start
     * stack[1] = deleteCount
     * stack[2...nargs-1] = items
     * stack[nargs] = ToObject(this)               -3
     * stack[nargs+1] = ToUint32(length)           -2
     * stack[nargs+2] = result array               -1
     */
 
    DUK_ASSERT_TOP(ctx, nargs + 3);
 
    /* Step 9: copy elements-to-be-deleted into the result array */
 
    for (i = 0; i < del_count; i++) {
        if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (act_start + i))) {
            duk_xdef_prop_index_wec(ctx, -2, i);  /* throw flag irrelevant (false in std alg) */
        } else {
            duk_pop(ctx);
        }
    }
    duk_push_u32(ctx, (duk_uint32_t) del_count);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
 
    /* Steps 12 and 13: reorganize elements to make room for itemCount elements */
 
    if (item_count < del_count) {
        /*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 1
         * -> [ A B F G H ]          (conceptual intermediate step)
         * -> [ A B . F G H ]        (placeholder marked)
         *    [ A B C F G H ]        (actual result at this point, C will be replaced)
         */
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
 
        n = len - del_count;
        for (i = act_start; i < n; i++) {
            if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
                duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
            } else {
                duk_pop(ctx);
                duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
            }
        }
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
 
        /* loop iterator init and limit changed from standard algorithm */
        n = len - del_count + item_count;
        for (i = len - 1; i >= n; i--) {
            duk_del_prop_index(ctx, -3, (duk_uarridx_t) i);
        }
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
    } else if (item_count > del_count) {
        /*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 4
         * -> [ A B F G H ]          (conceptual intermediate step)
         * -> [ A B . . . . F G H ]  (placeholder marked)
         *    [ A B C D E F F G H ]  (actual result at this point)
         */
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
 
        /* loop iterator init and limit changed from standard algorithm */
        for (i = len - del_count - 1; i >= act_start; i--) {
            if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
                duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
            } else {
                duk_pop(ctx);
                duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
            }
        }
 
        DUK_ASSERT_TOP(ctx, nargs + 3);
    } else {
        /*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 3
         * -> [ A B F G H ]          (conceptual intermediate step)
         * -> [ A B . . . F G H ]    (placeholder marked)
         *    [ A B C D E F G H ]    (actual result at this point)
         */
    }
    DUK_ASSERT_TOP(ctx, nargs + 3);
 
    /* Step 15: insert itemCount elements into the hole made above */
 
    for (i = 0; i < item_count; i++) {
        duk_dup(ctx, i + 2);  /* args start at index 2 */
        duk_put_prop_index(ctx, -4, (duk_uarridx_t) (act_start + i));
    }
 
    /* Step 16: update length; note that the final length may be above 32 bit range
     * (but we checked above that this isn't the case here)
     */
 
    duk_push_u32(ctx, len - del_count + item_count);
    duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH);
 
    /* result array is already at the top of stack */
    DUK_ASSERT_TOP(ctx, nargs + 3);
    return 1;
}

References duk__push_this_obj_len_u32_limited(), DUK_ASSERT, DUK_ASSERT_TOP, DUK_D, duk_del_prop_index(), DUK_DPRINT, duk_dup(), duk_get_prop_index(), duk_get_top(), duk_pop(), DUK_PROPDESC_FLAGS_W, duk_push_array(), duk_push_u32, duk_put_prop_index(), duk_put_prop_stridx(), DUK_RET_RANGE_ERROR, duk_set_top(), DUK_STRIDX_LENGTH, duk_to_int_clamped(), DUK_UINT32_MAX, DUK_UNREF, duk_xdef_prop_index_wec, and duk_xdef_prop_stridx().

duk_bi_array_prototype_to_string()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_to_string

(

duk_context *

ctx

)

Definition at line 136 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                          {
    (void) duk_push_this_coercible_to_object(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_JOIN);
 
    /* [ ... this func ] */
    if (!duk_is_callable(ctx, -1)) {
        /* Fall back to the initial (original) Object.toString().  We don't
         * currently have pointers to the built-in functions, only the top
         * level global objects (like "Array") so this is now done in a bit
         * of a hacky manner.  It would be cleaner to push the (original)
         * function and use duk_call_method().
         */
 
        /* XXX: 'this' will be ToObject() coerced twice, which is incorrect
         * but should have no visible side effects.
         */
        DUK_DDD(DUK_DDDPRINT("this.join is not callable, fall back to (original) Object.toString"));
        duk_set_top(ctx, 0);
        return duk_bi_object_prototype_to_string(ctx);  /* has access to 'this' binding */
    }
 
    /* [ ... this func ] */
 
    duk_insert(ctx, -2);
 
    /* [ ... func this ] */
 
    DUK_DDD(DUK_DDDPRINT("calling: func=%!iT, this=%!iT",
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
    duk_call_method(ctx, 0);
 
    return 1;
}

References duk_bi_object_prototype_to_string(), duk_call_method(), DUK_DDD, DUK_DDDPRINT, duk_get_prop_stridx(), duk_get_tval(), duk_insert(), duk_is_callable, duk_push_this_coercible_to_object(), duk_set_top(), and DUK_STRIDX_JOIN.

duk_bi_array_prototype_unshift()

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_unshift

(

duk_context *

ctx

)

Definition at line 1055 of file duktape-1.5.2/src-separate/duk_bi_array.c.

                                                                        {
    duk_idx_t nargs;
    duk_uint32_t len;
    duk_uint32_t i;
 
    nargs = duk_get_top(ctx);
    len = duk__push_this_obj_len_u32(ctx);
 
    /* stack[0...nargs-1] = unshift args (vararg)
     * stack[nargs] = ToObject(this)
     * stack[nargs+1] = ToUint32(length)
     */
 
    DUK_ASSERT_TOP(ctx, nargs + 2);
 
    /* Note: unshift() may operate on indices above unsigned 32-bit range
     * and the final length may be >= 2**32.  However, we restrict the
     * final result to 32-bit range for practicality.
     */
 
    if (len + (duk_uint32_t) nargs < len) {
        DUK_D(DUK_DPRINT("Array.prototype.unshift() would go beyond 32-bit length, throw"));
        return DUK_RET_RANGE_ERROR;
    }
 
    i = len;
    while (i > 0) {
        DUK_ASSERT_TOP(ctx, nargs + 2);
        i--;
        /* k+argCount-1; note that may be above 32-bit range */
 
        if (duk_get_prop_index(ctx, -2, (duk_uarridx_t) i)) {
            /* fromPresent = true */
            /* [ ... ToObject(this) ToUint32(length) val ] */
            duk_put_prop_index(ctx, -3, (duk_uarridx_t) (i + nargs));  /* -> [ ... ToObject(this) ToUint32(length) ] */
        } else {
            /* fromPresent = false */
            /* [ ... ToObject(this) ToUint32(length) val ] */
            duk_pop(ctx);
            duk_del_prop_index(ctx, -2, (duk_uarridx_t) (i + nargs));  /* -> [ ... ToObject(this) ToUint32(length) ] */
        }
        DUK_ASSERT_TOP(ctx, nargs + 2);
    }
 
    for (i = 0; i < (duk_uint32_t) nargs; i++) {
        DUK_ASSERT_TOP(ctx, nargs + 2);
        duk_dup(ctx, i);  /* -> [ ... ToObject(this) ToUint32(length) arg[i] ] */
        duk_put_prop_index(ctx, -3, (duk_uarridx_t) i);
        DUK_ASSERT_TOP(ctx, nargs + 2);
    }
 
    DUK_ASSERT_TOP(ctx, nargs + 2);
    duk_push_u32(ctx, len + nargs);
    duk_dup_top(ctx);  /* -> [ ... ToObject(this) ToUint32(length) final_len final_len ] */
    duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH);
    return 1;
}

References duk__push_this_obj_len_u32(), DUK_ASSERT_TOP, DUK_D, duk_del_prop_index(), DUK_DPRINT, duk_dup(), duk_dup_top(), duk_get_prop_index(), duk_get_top(), duk_pop(), duk_push_u32, duk_put_prop_index(), duk_put_prop_stridx(), DUK_RET_RANGE_ERROR, and DUK_STRIDX_LENGTH.