Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / src / engine / array_splice.lucb

#==============================================================================================
#
#   array_splice - Array.prototype splice, toSpliced, copyWithin, flat and flatMap
#
#   DESCRIPTION:
#       Port of quickjs.c lines 43000-43347: splice (in place on fast arrays with a
#       writable length), toSpliced, copyWithin, FlattenIntoArray and flat/flatMap.
#
#==============================================================================================

# mark: splice, toSpliced =======================================================================

## Array.prototype.splice(start, deleteCount, ...items).
func js_array_splice(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    var arr = js_undefined()
    errdefer js_free_value_at(ctx, &arr)
    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 start: i64 = 0
    try js_to_int64_clamp(ctx, &start, argv[0], 0, len, len)

    var item_count: u32 = 0
    var del_count: i64 = 0
    if argc == 0:
        item_count = 0
        del_count = 0
    elif argc == 1:
        item_count = 0
        del_count = len - start
    else:
        item_count = (u32)(argc - 2)
        try js_to_int64_clamp(ctx, &del_count, argv[1], 0, len - start, 0)
    if len + (i64)item_count - del_count > max_safe_integer:
        try js_throw_type_error(ctx, "Array loo long")
    let final = start + del_count
    # warning: 'len' may be different from the actual array length
    # because it may have been modified
    let new_len = len + (i64)item_count - del_count

    let ctor = try js_array_species_get_ctor(ctx, obj)

    let p = obj.u.obj
    if (js_is_undefined(ctor) and p.class_id == ClassId.array and p.fast_array and final <= (i64)p.u.array.count and ((i32)get_shape_prop(p.shape).flags & prop_writable) != 0 and can_extend_fast_array(p)):
        # writable array length
        let count32 = p.u.array.count
        var arrp = p.u.array.u.values

        # fast case
        arr = try js_create_array(ctx, (i32)del_count, arrp + (usize)start)

        if (i64)item_count != del_count:
            # resize
            let new_count32 = (u32)((i64)count32 + (i64)item_count - del_count)
            if del_count > (i64)item_count:
                for i: i64 in 0..<(del_count - (i64)item_count):
                    js_free_value(ctx, arrp[(usize)(start + (i64)item_count + i)])
                _ = cutils.memmove(arrp + (usize)(start + (i64)item_count), arrp + (usize)final,
                                   (usize)((i64)count32 - final) * memory.size_of(Value))
            else:
                if new_count32 > p.u.array.u1.size:
                    try expand_fast_array(ctx, p, new_count32)
                    arrp = p.u.array.u.values
                _ = cutils.memmove(arrp + (usize)(start + (i64)item_count), arrp + (usize)final,
                                   (usize)((i64)count32 - final) * memory.size_of(Value))
                for i: i64 in 0..<((i64)item_count - del_count):
                    arrp[(usize)(start + del_count + i)] = js_undefined()
            p.u.array.count = new_count32
        for i: u32 in 0..<item_count:
            set_value(ctx, arrp + (usize)(start + (i64)i), js_dup_value(ctx, argv[(usize)i + 2]))
    else:
        arr = js_array_create_from_ctor(ctx, ctor, del_count) catch failure:
            js_free_value(ctx, ctor)
            error(failure.code, failure.message)
        js_free_value(ctx, ctor)

        var n: i64 = 0
        var k = start
        while k < final:
            var val = js_undefined()
            let k_present = try js_try_get_property_int64(ctx, obj, k, &val)
            if k_present:
                try js_create_data_property_uint32(ctx, arr, n, val, prop_throw)
            k += 1
            n += 1
        try js_set_property(ctx, arr, atom_length, js_new_int64(n))

        if (i64)item_count != del_count:
            let dir: i32 = 1 if (i64)item_count <= del_count else -1
            try js_copy_sub_array(ctx, obj, start + (i64)item_count, start + del_count,
                                  len - (start + del_count), dir)

            k = len
            while k > new_len:
                k -= 1
                try js_delete_property_int64(ctx, obj, k, prop_throw)
        for i: u32 in 0..<item_count:
            try js_set_property_int64(ctx, obj, start + (i64)i, js_dup_value(ctx, argv[(usize)i + 2]))
    try js_set_property(ctx, obj, atom_length, js_new_int64(new_len))
    return arr

## Array.prototype.toSpliced(start, skipCount, ...items): a dense copy with the splice
## applied.
func js_array_to_spliced(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 start: i64 = 0
    if argc > 0:
        try js_to_int64_clamp(ctx, &start, argv[0], 0, len, len)

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

    var add: i64 = 0
    if argc > 2:
        add = (i64)(argc - 2)

    let newlen = len + add - del
    if newlen > max_safe_integer:
        try js_throw_type_error(ctx, "invalid array length")

    let arr = try js_allocate_fast_array(ctx, newlen)
    errdefer js_free_value(ctx, arr)

    if newlen <= 0:
        return arr

    let p = arr.u.obj
    var pval = p.u.array.u.values
    let last = pval + (usize)newlen

    var i: i64 = 0
    var j: i64 = 0
    var arrp_opt: Value*? = none
    var count32: u32 = 0
    if js_get_fast_array(ctx, obj, &arrp_opt, &count32) and (i64)count32 == len:
        # none only for an empty array, whose elements are never read
        let arrp = arrp_opt else argv
        while i < start:
            *pval = js_dup_value(ctx, arrp[(usize)i])
            i += 1
            pval += 1
        while j < add:
            *pval = js_dup_value(ctx, argv[(usize)(2 + j)])
            j += 1
            pval += 1
        i += del
        while i < len:
            *pval = js_dup_value(ctx, arrp[(usize)i])
            i += 1
            pval += 1
    else:
        while i < start:
            try js_try_get_property_int64(ctx, obj, i, pval)
            i += 1
            pval += 1
        while j < add:
            *pval = js_dup_value(ctx, argv[(usize)(2 + j)])
            j += 1
            pval += 1
        i += del
        while i < len:
            try js_try_get_property_int64(ctx, obj, i, pval)
            i += 1
            pval += 1

    assert(pval == last)
    return arr

# mark: copyWithin ==============================================================================

## Array.prototype.copyWithin(target, start, end).
func js_array_copy_within(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 to: i64 = 0
    try js_to_int64_clamp(ctx, &to, argv[0], 0, len, len)

    var from_: i64 = 0
    try js_to_int64_clamp(ctx, &from_, argv[1], 0, len, len)

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

    let count = cutils.min_int64(final - from_, len - to)

    let dir: i32 = -1 if (from_ < to and to < from_ + count) else 1
    try js_copy_sub_array(ctx, obj, to, from_, count, dir)
    return obj

# mark: flat, flatMap ===========================================================================

## FlattenIntoArray: define the elements of `source` (mapped by `mapper_function` when it
## is not undefined) into `target` from `target_index`, flattening arrays `depth` levels
## deep. Answers the next target index.
func js_flatten_into_array(ctx: Context*, target: Value, source: Value, source_len: i64,
                           target_index: i64, depth: i32, mapper_function: Value,
                           this_arg: Value) -> i64!:
    if js_check_stack_overflow(ctx.rt, 0):
        try js_throw_stack_overflow(ctx)

    var index = target_index
    for source_index: i64 in 0..<source_len:
        var element = js_undefined()
        let present = try js_try_get_property_int64(ctx, source, source_index, &element)
        if not present:
            continue
        if not js_is_undefined(mapper_function):
            var args: Value[3] = [element, js_new_int64(source_index), source]
            let mapped = js_call(ctx, mapper_function, this_arg, 3, &args[0]) catch failure:
                js_free_value(ctx, args[0])
                js_free_value(ctx, args[1])
                error(failure.code, failure.message)
            js_free_value(ctx, args[0])
            js_free_value(ctx, args[1])
            element = mapped
        if depth > 0:
            errdefer js_free_value(ctx, element)
            let is_array = try js_is_array(ctx, element)
            if is_array:
                var element_len: i64 = 0
                try js_get_length64(ctx, &element_len, element)
                index = try js_flatten_into_array(ctx, target, element, element_len, index,
                                                  depth - 1, js_undefined(), js_undefined())
                js_free_value(ctx, element)
                continue
        if index >= max_safe_integer:
            js_free_value(ctx, element)
            try js_throw_type_error(ctx, "Array too long")
        try js_define_property_value_int64(ctx, target, index, element, prop_c_w_e | prop_throw)
        index += 1
    return index

## Array.prototype.flat(depth), and flatMap(mapper, thisArg) when `map` is 1.
func js_array_flatten(ctx: Context*, this_val: Value, argc: i32, argv: Value*, map: i32) -> Value!:
    let obj = try js_to_object(ctx, this_val)
    defer js_free_value(ctx, obj)
    var source_len: i64 = 0
    try js_get_length64(ctx, &source_len, obj)

    var depth_num: i32 = 1
    var mapper_function = js_undefined()
    var this_arg = js_undefined()
    if map != 0:
        mapper_function = argv[0]
        if argc > 1:
            this_arg = argv[1]
        try check_function(ctx, mapper_function)
    else:
        if argc > 0 and not js_is_undefined(argv[0]):
            try js_to_int32_sat(ctx, &depth_num, argv[0])
    let arr = try js_array_species_create(ctx, obj, 0)
    errdefer js_free_value(ctx, arr)
    try js_flatten_into_array(ctx, arr, obj, source_len, 0, depth_num, mapper_function, this_arg)
    return arr