Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / src / engine / iterator_helper_next.lucb

#==============================================================================================
#
#   iterator_helper_next - The Iterator Helper objects: finalizer, marker and next/return
#
#   DESCRIPTION:
#       Port of quickjs.c "Iterator Helper" (lines 44437-44717): the lazy iterators that
#       Iterator.prototype.drop/filter/flatMap/map/take return. `next` (gen_magic_next)
#       and `return` (gen_magic_return) share js_iterator_helper_next. A failure marked
#       `fail` in QuickJS closes the underlying iterator; `fail_no_close` does not.
#
#==============================================================================================

# mark: Finalizer and marker ====================================================================

## Finalizer of the Iterator Helper class.
func js_iterator_helper_finalizer(rt: Runtime*, val: Value):
    let p = val.u.obj
    if let raw = p.u.opaque:
        let it = (IteratorHelperData*)raw
        js_free_value_rt(rt, it.obj)
        js_free_value_rt(rt, it.func_)
        js_free_value_rt(rt, it.next)
        js_free_value_rt(rt, it.inner)
        js_free_rt(rt, it)

## Marker of the Iterator Helper class.
func js_iterator_helper_mark(rt: Runtime*, val: Value, mark_func: MarkFunc):
    let p = val.u.obj
    if let raw = p.u.opaque:
        let it = (IteratorHelperData*)raw
        js_mark_value(rt, it.obj, mark_func)
        js_mark_value(rt, it.func_, mark_func)
        js_mark_value(rt, it.next, mark_func)
        js_mark_value(rt, it.inner, mark_func)

# mark: next and return =========================================================================

## `next` (magic gen_magic_next) and `return` (gen_magic_return) of an Iterator Helper.
func js_iterator_helper_next(ctx: Context*, this_val: Value, argc: i32, argv: Value*, pdone: i32*, magic: i32) -> Value!:
    *pdone = 0

    let it = (IteratorHelperData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.iterator_helper))
    if it.executing:
        try js_throw_type_error(ctx, "cannot invoke a running iterator")
    if it.done:
        *pdone = 1
        return js_undefined()

    it.executing = true

    var done = false
    let ret = iterator_helper_step(ctx, it, &done, magic) catch failure:
        iterator_helper_finish(it, done, pdone, magic)
        error(failure.code, failure.message)
    iterator_helper_finish(it, done, pdone, magic)
    return ret

# The `done` label of js_iterator_helper_next, run on success and on failure.
func iterator_helper_finish(it: IteratorHelperData*, done: bool, pdone: i32*, magic: i32):
    *pdone = (i32)done
    it.done = done if magic == gen_magic_next else true
    it.executing = false

# The next method of the underlying iterator for this step: `next`, or its `return`
# method when the helper is being returned. A failure closes the iterator.
func iterator_helper_method(ctx: Context*, it: IteratorHelperData*, magic: i32) -> Value!:
    if magic == gen_magic_next:
        return js_dup_value(ctx, it.next)
    let method = js_get_property(ctx, it.obj, atom_return) catch:
        try js_iterator_close_fail(ctx, it.obj)
    return method

# The inner_fail label of flatMap: close and drop the inner iterator, then close the
# outer one, preserving the pending exception.
func iterator_helper_inner_fail(ctx: Context*, it: IteratorHelperData*) -> never!:
    js_iterator_close_ignore(ctx, it.inner, false)
    js_free_value(ctx, it.inner)
    it.inner = js_undefined()
    try js_iterator_close_fail(ctx, it.obj)

# The body of js_iterator_helper_next for each kind; `*pdone` is QuickJS's `*pdone`.
func iterator_helper_step(ctx: Context*, it: IteratorHelperData*, pdone: bool*, magic: i32) -> Value!:
    var args: Value[2] = ---
    var no_args = js_undefined()
    match it.kind:
        .drop:
            let method = try iterator_helper_method(ctx, it, magic)
            defer js_free_value(ctx, method)
            while it.count > 0:
                it.count -= 1
                let item = try js_iterator_next(ctx, it.obj, method, 0, &no_args, pdone)
                js_free_value(ctx, item)
                if magic == gen_magic_return:
                    *pdone = true
                if *pdone:
                    return js_undefined()

            return try js_iterator_next(ctx, it.obj, method, 0, &no_args, pdone)
        .filter:
            let method = try iterator_helper_method(ctx, it, magic)
            defer js_free_value(ctx, method)
            while true:
                # filter_again
                let item = try js_iterator_next(ctx, it.obj, method, 0, &no_args, pdone)
                if *pdone or magic == gen_magic_return:
                    return item
                let index_val = js_new_int64(it.count)
                it.count += 1
                args[0] = item
                args[1] = index_val
                let selected = js_call(ctx, it.func_, js_undefined(), 2, &args[0]) catch:
                    js_free_value(ctx, index_val)
                    js_free_value(ctx, item)
                    try js_iterator_close_fail(ctx, it.obj)
                js_free_value(ctx, index_val)
                let keep = js_to_bool_free(ctx, selected) catch failure:
                    js_free_value(ctx, item)
                    error(failure.code, failure.message)
                if keep:
                    return item
                js_free_value(ctx, item)
        .flat_map:
            while true:
                # flat_map_again
                if js_is_undefined(it.inner):
                    let method = try iterator_helper_method(ctx, it, magic)
                    let item = js_iterator_next(ctx, it.obj, method, 0, &no_args, pdone) catch failure:
                        js_free_value(ctx, method)
                        error(failure.code, failure.message)
                    js_free_value(ctx, method)
                    if *pdone or magic == gen_magic_return:
                        return item
                    let index_val = js_new_int64(it.count)
                    it.count += 1
                    args[0] = item
                    args[1] = index_val
                    let mapped = js_call(ctx, it.func_, js_undefined(), 2, &args[0]) catch:
                        js_free_value(ctx, item)
                        js_free_value(ctx, index_val)
                        try js_iterator_close_fail(ctx, it.obj)
                    js_free_value(ctx, item)
                    js_free_value(ctx, index_val)
                    if not js_is_object(mapped):
                        js_free_value(ctx, mapped)
                        js_throw_type_error(ctx, "not an object") catch:
                            try js_iterator_close_fail(ctx, it.obj)
                    let iter_method = js_get_property(ctx, mapped, atom_Symbol_iterator) catch:
                        js_free_value(ctx, mapped)
                        try js_iterator_close_fail(ctx, it.obj)
                    var iter: Value = ---
                    if js_is_null(iter_method) or js_is_undefined(iter_method):
                        js_free_value(ctx, iter_method)
                        iter = mapped
                    else:
                        iter = js_get_iterator2(ctx, mapped, iter_method) catch:
                            js_free_value(ctx, iter_method)
                            js_free_value(ctx, mapped)
                            try js_iterator_close_fail(ctx, it.obj)
                        js_free_value(ctx, iter_method)
                        js_free_value(ctx, mapped)

                    it.inner = iter

                var inner_method: Value = ---
                if magic == gen_magic_next:
                    inner_method = js_get_property(ctx, it.inner, atom_next) catch:
                        try iterator_helper_inner_fail(ctx, it)
                else:
                    inner_method = js_get_property(ctx, it.inner, atom_return) catch:
                        try iterator_helper_inner_fail(ctx, it)
                if not (magic == gen_magic_return and (js_is_undefined(inner_method) or js_is_null(inner_method))):
                    let item = js_iterator_next(ctx, it.inner, inner_method, 0, &no_args, pdone) catch:
                        js_free_value(ctx, inner_method)
                        try iterator_helper_inner_fail(ctx, it)
                    js_free_value(ctx, inner_method)
                    if not *pdone:
                        return item
                # inner_end
                *pdone = false  # The outer iterator must continue.
                js_iterator_close_ignore(ctx, it.inner, false)
                js_free_value(ctx, it.inner)
                it.inner = js_undefined()
        .map:
            let method = try iterator_helper_method(ctx, it, magic)
            let item = js_iterator_next(ctx, it.obj, method, 0, &no_args, pdone) catch failure:
                js_free_value(ctx, method)
                error(failure.code, failure.message)
            js_free_value(ctx, method)
            if *pdone or magic == gen_magic_return:
                return item
            let index_val = js_new_int64(it.count)
            it.count += 1
            args[0] = item
            args[1] = index_val
            let ret = js_call(ctx, it.func_, js_undefined(), 2, &args[0]) catch:
                js_free_value(ctx, index_val)
                js_free_value(ctx, item)
                try js_iterator_close_fail(ctx, it.obj)
            js_free_value(ctx, index_val)
            js_free_value(ctx, item)
            return ret
        .take:
            if it.count > 0:
                let method = try iterator_helper_method(ctx, it, magic)
                it.count -= 1
                let item = js_iterator_next(ctx, it.obj, method, 0, &no_args, pdone) catch failure:
                    js_free_value(ctx, method)
                    error(failure.code, failure.message)
                js_free_value(ctx, method)
                return item

            *pdone = true
            try js_iterator_close_checked(ctx, it.obj, false)
            return js_undefined()
        _:
            trap("abort: not an Iterator Helper kind")