Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / src / engine / array_iteration.lucb

#==============================================================================================
#
#   array_iteration - Array.prototype methods that visit the elements in order
#
#   DESCRIPTION:
#       Port of quickjs.c lines 42112-42626: every/some/forEach/map/filter (shared with
#       the typed arrays through `special_ta`), reduce/reduceRight, fill, includes,
#       indexOf, lastIndexOf and the find family.
#
#==============================================================================================

# mark: every, some, forEach, map, filter =======================================================

# The magic of js_array_every: which method it is. The typed arrays add `special_ta`.
let special_every: i32 = 0
let special_some: i32 = 1
let special_for_each: i32 = 2
let special_map: i32 = 3
let special_filter: i32 = 4
let special_ta: i32 = 8

## Array.prototype.every, some, forEach, map and filter, and their typed array versions
## (`special` is one of the special_* values, with `special_ta` for a typed array).
func js_array_every(ctx: Context*, this_val: Value, argc: i32, argv: Value*, special: i32) -> Value!:
    var args: Value[3] = ---
    var ret = js_undefined()
    var val = js_undefined()
    errdefer js_free_value_at(ctx, &ret)
    errdefer js_free_value_at(ctx, &val)
    var obj: Value = ---
    if (special & special_ta) != 0:
        obj = js_dup_value(ctx, this_val)
    else:
        obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var len: i64 = 0
    if (special & special_ta) != 0:
        len = (i64)(try js_typed_array_get_length_unsafe(ctx, obj))
    else:
        try js_get_length64(ctx, &len, obj)
    let func_ = argv[0]
    var this_arg = js_undefined()
    if argc > 1:
        this_arg = argv[1]

    try check_function(ctx, func_)

    if special == special_every or special == (special_every | special_ta):
        ret = js_true()
    elif special == special_some or special == (special_some | special_ta):
        ret = js_false()
    elif special == special_map:
        ret = try js_array_species_create(ctx, obj, len)
    elif special == special_filter:
        ret = try js_array_species_create(ctx, obj, 0)
    elif special == (special_map | special_ta):
        args[0] = obj
        args[1] = js_new_int32((i32)len)
        ret = try js_typed_array__species_create(ctx, js_undefined(), 2, &args[0])
    elif special == (special_filter | special_ta):
        ret = try js_new_array(ctx)
    var n: i64 = 0

    var k: i64 = 0
    while k < len:
        var present = false
        if (special & special_ta) != 0:
            val = try js_get_property_int64(ctx, obj, k)
            present = true
        else:
            present = try js_try_get_property_int64(ctx, obj, k, &val)
        if present:
            let index_val = js_new_int64(k)
            args[0] = val
            args[1] = index_val
            args[2] = obj
            let res = js_call(ctx, func_, this_arg, 3, &args[0]) catch failure:
                js_free_value(ctx, index_val)
                error(failure.code, failure.message)
            js_free_value(ctx, index_val)
            if special == special_every or special == (special_every | special_ta):
                if not try js_to_bool_free(ctx, res):
                    ret = js_false()
                    break
            elif special == special_some or special == (special_some | special_ta):
                if try js_to_bool_free(ctx, res):
                    ret = js_true()
                    break
            elif special == special_map:
                try js_define_property_value_int64(ctx, ret, k, res, prop_c_w_e | prop_throw)
            elif special == (special_map | special_ta):
                try js_set_property_value(ctx, ret, js_new_int32((i32)k), res, prop_throw)
            elif special == special_filter or special == (special_filter | special_ta):
                if try js_to_bool_free(ctx, res):
                    let idx = n
                    n += 1
                    try js_define_property_value_int64(ctx, ret, idx, js_dup_value(ctx, val), prop_c_w_e | prop_throw)
            else:
                js_free_value(ctx, res)
            js_free_value(ctx, val)
            val = js_undefined()
        k += 1
    # done
    if special == (special_filter | special_ta):
        args[0] = obj
        args[1] = js_new_int32((i32)n)
        let arr = try js_typed_array__species_create(ctx, js_undefined(), 2, &args[0])
        args[0] = ret
        let res = js_invoke(ctx, arr, atom_set, 1, &args[0]) catch failure:
            js_free_value(ctx, arr)
            error(failure.code, failure.message)
        js_free_value(ctx, res)
        js_free_value(ctx, ret)
        ret = arr
    js_free_value(ctx, val)
    return ret

# mark: reduce, reduceRight =====================================================================

# The magic of js_array_reduce; the typed arrays add `special_ta`.
let special_reduce: i32 = 0
let special_reduce_right: i32 = 1

## Array.prototype.reduce and reduceRight, and their typed array versions.
func js_array_reduce(ctx: Context*, this_val: Value, argc: i32, argv: Value*, special: i32) -> Value!:
    var args: Value[4] = ---
    var acc = js_undefined()
    var val = js_undefined()
    errdefer js_free_value_at(ctx, &acc)
    errdefer js_free_value_at(ctx, &val)
    var obj: Value = ---
    if (special & special_ta) != 0:
        obj = js_dup_value(ctx, this_val)
    else:
        obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var len: i64 = 0
    if (special & special_ta) != 0:
        len = (i64)(try js_typed_array_get_length_unsafe(ctx, obj))
    else:
        try js_get_length64(ctx, &len, obj)
    let func_ = argv[0]

    try check_function(ctx, func_)

    var k: i64 = 0
    if argc > 1:
        acc = js_dup_value(ctx, argv[1])
    else:
        while true:
            if k >= len:
                try js_throw_type_error(ctx, "empty array")
            let k0 = len - k - 1 if (special & special_reduce_right) != 0 else k
            k += 1
            if (special & special_ta) != 0:
                acc = try js_get_property_int64(ctx, obj, k0)
                break
            elif try js_try_get_property_int64(ctx, obj, k0, &acc):
                break
    while k < len:
        let k1 = len - k - 1 if (special & special_reduce_right) != 0 else k
        var present = false
        if (special & special_ta) != 0:
            val = try js_get_property_int64(ctx, obj, k1)
            present = true
        else:
            present = try js_try_get_property_int64(ctx, obj, k1, &val)
        if present:
            let index_val = js_new_int64(k1)
            args[0] = acc
            args[1] = val
            args[2] = index_val
            args[3] = obj
            let acc1 = js_call(ctx, func_, js_undefined(), 4, &args[0]) catch failure:
                js_free_value(ctx, index_val)
                js_free_value(ctx, val)
                val = js_undefined()
                error(failure.code, failure.message)
            js_free_value(ctx, index_val)
            js_free_value(ctx, val)
            val = js_undefined()
            js_free_value(ctx, acc)
            acc = acc1
        k += 1
    return acc

# mark: fill, includes, indexOf, lastIndexOf ====================================================

## Array.prototype.fill(value, start, end).
func js_array_fill(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let obj = try js_to_object(ctx, this_val)
    errdefer js_free_value(ctx, obj)
    var len: i64 = 0
    try js_get_length64(ctx, &len, obj)

    var start: i64 = 0
    if argc > 1 and not js_is_undefined(argv[1]):
        try js_to_int64_clamp(ctx, &start, argv[1], 0, len, len)

    var end: i64 = len
    if argc > 2 and not js_is_undefined(argv[2]):
        try js_to_int64_clamp(ctx, &end, argv[2], 0, len, len)

    # XXX: should special case fast arrays
    while start < end:
        try js_set_property_int64(ctx, obj, start, js_dup_value(ctx, argv[0]))
        start += 1
    return obj

## Array.prototype.includes(value, fromIndex), comparing with SameValueZero.
func js_array_includes(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var len: i64 = 0
    try js_get_length64(ctx, &len, obj)

    var res = false
    if len > 0:
        var n: i64 = 0
        if argc > 1:
            try js_to_int64_clamp(ctx, &n, argv[1], 0, len, len)
        var arrp_opt: Value*? = none
        var count: u32 = 0
        if js_get_fast_array(ctx, obj, &arrp_opt, &count):
            # none only for an empty array, whose elements are never read
            let arrp = arrp_opt else argv
            while n < (i64)count:
                if js_strict_eq2(ctx, argv[0], arrp[(usize)n], StrictEqMode.same_value_zero):
                    res = true
                    break
                n += 1
        # done: the fast path found it
        if not res:
            while n < len:
                let val = try js_get_property_int64(ctx, obj, n)
                if js_strict_eq2(ctx, argv[0], val, StrictEqMode.same_value_zero):
                    js_free_value(ctx, val)
                    res = true
                    break
                js_free_value(ctx, val)
                n += 1
    return js_new_bool(res)

## Array.prototype.indexOf(value, fromIndex), comparing with ===.
func js_array_index_of(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var len: i64 = 0
    try js_get_length64(ctx, &len, obj)

    var res: i64 = -1
    if len > 0:
        var n: i64 = 0
        if argc > 1:
            try js_to_int64_clamp(ctx, &n, argv[1], 0, len, len)
        var arrp_opt: Value*? = none
        var count: u32 = 0
        if js_get_fast_array(ctx, obj, &arrp_opt, &count):
            # none only for an empty array, whose elements are never read
            let arrp = arrp_opt else argv
            while n < (i64)count:
                if js_strict_eq2(ctx, argv[0], arrp[(usize)n], StrictEqMode.strict):
                    res = n
                    break
                n += 1
        # done: the fast path found it
        if res < 0:
            while n < len:
                var val = js_undefined()
                let present = try js_try_get_property_int64(ctx, obj, n, &val)
                if present:
                    if js_strict_eq2(ctx, argv[0], val, StrictEqMode.strict):
                        js_free_value(ctx, val)
                        res = n
                        break
                    js_free_value(ctx, val)
                n += 1
    return js_new_int64(res)

## Array.prototype.lastIndexOf(value, fromIndex), comparing with ===.
func js_array_last_index_of(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var len: i64 = 0
    try js_get_length64(ctx, &len, obj)

    var res: i64 = -1
    if len > 0:
        var n = len - 1
        if argc > 1:
            try js_to_int64_clamp(ctx, &n, argv[1], -1, len - 1, len)
        # XXX: should special case fast arrays
        while n >= 0:
            var val = js_undefined()
            let present = try js_try_get_property_int64(ctx, obj, n, &val)
            if present:
                if js_strict_eq2(ctx, argv[0], val, StrictEqMode.strict):
                    js_free_value(ctx, val)
                    res = n
                    break
                js_free_value(ctx, val)
            n -= 1
    return js_new_int64(res)

# mark: find ====================================================================================

# The magic of js_array_find.
let array_find: i32 = 0
let array_find_index: i32 = 1
let array_find_last: i32 = 2
let array_find_last_index: i32 = 3

## Array.prototype.find, findIndex, findLast and findLastIndex (`mode` is one of the
## array_find* values).
func js_array_find(ctx: Context*, this_val: Value, argc: i32, argv: Value*, mode: i32) -> Value!:
    var args: Value[3] = ---
    let obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var len: i64 = 0
    try js_get_length64(ctx, &len, obj)

    let func_ = argv[0]
    try check_function(ctx, func_)

    var this_arg = js_undefined()
    if argc > 1:
        this_arg = argv[1]

    var k: i64 = 0
    var dir: i64 = 1
    var end = len
    if mode == array_find_last or mode == array_find_last_index:
        k = len - 1
        dir = -1
        end = -1

    # TODO(bnoordhuis) add fast path for fast arrays
    while k != end:
        let index_val = js_new_int64(k)
        errdefer js_free_value(ctx, index_val)
        # index_val is a number: js_get_property_value taking it leaves it valid
        let val = try js_get_property_value(ctx, obj, index_val)
        errdefer js_free_value(ctx, val)
        args[0] = val
        args[1] = index_val
        args[2] = this_val
        let res = try js_call(ctx, func_, this_arg, 3, &args[0])
        if try js_to_bool_free(ctx, res):
            if mode == array_find_index or mode == array_find_last_index:
                js_free_value(ctx, val)
                return index_val
            js_free_value(ctx, index_val)
            return val
        js_free_value(ctx, val)
        js_free_value(ctx, index_val)
        k += dir
    if mode == array_find_index or mode == array_find_last_index:
        return js_new_int32(-1)
    return js_undefined()