Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / src / engine / parser_expr.lucb

#==============================================================================================
#
#   parser_expr - Unary, binary, logical and conditional expressions
#
#   DESCRIPTION:
#       Port of quickjs.c lines 27500-27998: 'delete', the unary operators and
#       increments, the binary operators by precedence level, '&&' '||' '??', and the
#       conditional operator. The assignments follow in parser_assign.lucb.
#
#       A parser function that answers -1 on a syntax error in QuickJS is fallible here
#       (`-> !`); the SyntaxError is pending in the context, as in C.
#
#==============================================================================================

# mark: delete ==================================================================================

func js_parse_delete(s: ParseState*) -> !:
    let fd = s.fd()
    try next_token(s)
    try js_parse_unary(s, pf_pow_forbidden)
    let opcode = get_prev_opcode(fd)
    var ret_true = false
    if opcode == (u8)Op.get_field or opcode == (u8)TempOp.get_field_opt_chain:
        var opt_chain_label: i32 = -1
        if opcode == (u8)TempOp.get_field_opt_chain:
            opt_chain_label = (i32)cutils.get_u32(bytecode_at(fd, fd.last_opcode_pos + 1 + 4 + 1))
        let name = cutils.get_u32(bytecode_at(fd, fd.last_opcode_pos + 1))
        fd.byte_code.size = (usize)fd.last_opcode_pos
        let val = js_atom_to_value(s.ctx, name) catch failure:
            js_free_atom(s.ctx, name)
            error(failure.code, failure.message)
        emit_push_const(s, val, true) catch failure:
            js_free_value(s.ctx, val)
            js_free_atom(s.ctx, name)
            error(failure.code, failure.message)
        js_free_value(s.ctx, val)
        js_free_atom(s.ctx, name)
        emit_op(s, (u8)Op.delete)
        if opt_chain_label >= 0:
            let next_label = emit_goto(s, (i32)Op.goto_, -1)
            _ = emit_label(s, opt_chain_label)
            # if the optional chain is not taken, return 'true'
            emit_op(s, (u8)Op.drop)
            emit_op(s, (u8)Op.push_true)
            _ = emit_label(s, next_label)
        fd.last_opcode_pos = -1
    elif opcode == (u8)Op.get_array_el:
        fd.byte_code.size = (usize)fd.last_opcode_pos
        fd.last_opcode_pos = -1
        emit_op(s, (u8)Op.delete)
    elif opcode == (u8)TempOp.get_array_el_opt_chain:
        let opt_chain_label = (i32)cutils.get_u32(bytecode_at(fd, fd.last_opcode_pos + 1 + 1))
        fd.byte_code.size = (usize)fd.last_opcode_pos
        emit_op(s, (u8)Op.delete)
        let next_label = emit_goto(s, (i32)Op.goto_, -1)
        _ = emit_label(s, opt_chain_label)
        # if the optional chain is not taken, return 'true'
        emit_op(s, (u8)Op.drop)
        emit_op(s, (u8)Op.push_true)
        _ = emit_label(s, next_label)
        fd.last_opcode_pos = -1
    elif opcode == (u8)TempOp.scope_get_var:
        # 'delete this': this is not a reference
        let name = cutils.get_u32(bytecode_at(fd, fd.last_opcode_pos + 1))
        if name == atom_this or name == atom_new_target:
            ret_true = true
        elif ((i32)fd.js_mode & js_mode_strict) != 0:
            try js_parse_error(s, "cannot delete a direct reference in strict mode")
        else:
            set_last_opcode(fd, (u8)TempOp.scope_delete_var)
    elif opcode == (u8)TempOp.scope_get_private_field:
        try js_parse_error(s, "cannot delete a private class field")
    elif opcode == (u8)Op.get_super_value:
        fd.byte_code.size = (usize)fd.last_opcode_pos
        fd.last_opcode_pos = -1
        emit_op(s, (u8)Op.throw_error)
        emit_atom(s, no_atom)
        emit_u8(s, (u8)throw_error_delete_super)
    else:
        ret_true = true
    if ret_true:
        emit_op(s, (u8)Op.drop)
        emit_op(s, (u8)Op.push_true)

# mark: Unary operators =========================================================================

## allowed parse_flags: PF_POW_ALLOWED, PF_POW_FORBIDDEN
func js_parse_unary(s: ParseState*, parse_flags0: i32) -> !:
    var parse_flags = parse_flags0
    match s.token.val:
        .plus, .minus, .bang, .tilde, .void_:
            let op_token_ptr = s.token.ptr
            let op = s.token.val
            try next_token(s)
            try js_parse_unary(s, pf_pow_forbidden)
            match op:
                .minus:
                    emit_source_pos(s, op_token_ptr)
                    emit_op(s, (u8)Op.neg)
                .plus:
                    emit_source_pos(s, op_token_ptr)
                    emit_op(s, (u8)Op.plus)
                .bang:
                    emit_op(s, (u8)Op.lnot)
                .tilde:
                    emit_source_pos(s, op_token_ptr)
                    emit_op(s, (u8)Op.not_)
                .void_:
                    emit_op(s, (u8)Op.drop)
                    emit_op(s, (u8)Op.undefined)
                _:
                    trap("js_parse_unary: unexpected operator")
            parse_flags = 0
        .dec, .inc:
            let op = s.token.val
            let op_token_ptr = s.token.ptr
            try next_token(s)
            try js_parse_unary(s, 0)
            var opcode: i32 = 0
            var scope: i32 = 0
            var name = no_atom
            var label: i32 = 0
            var depth_unused: i32 = 0
            try get_lvalue(s, &opcode, &scope, &name, &label, &depth_unused, true, op)
            emit_source_pos(s, op_token_ptr)
            emit_op(s, (u8)((i32)Op.dec + (i32)op - (i32)TokenType.dec))
            put_lvalue(s, opcode, scope, name, label, PutLValueKind.keep_top, false)
        .typeof:
            try next_token(s)
            try js_parse_unary(s, pf_pow_forbidden)
            # reference access should not return an exception, so we patch the get_var
            let fd = s.fd()
            if get_prev_opcode(fd) == (u8)TempOp.scope_get_var:
                set_last_opcode(fd, (u8)TempOp.scope_get_var_undef)
            emit_op(s, (u8)Op.typeof)
            parse_flags = 0
        .delete:
            try js_parse_delete(s)
            parse_flags = 0
        .await:
            if (s.fd().func_kind & js_func_async) == 0:
                try js_parse_error(s, "unexpected 'await' keyword")
            if not s.fd().in_function_body:
                try js_parse_error(s, "await in default expression")
            try next_token(s)
            try js_parse_unary(s, pf_pow_forbidden)
            s.fd().has_await = true
            emit_op(s, (u8)Op.await)
            parse_flags = 0
        _:
            try js_parse_postfix_expr(s, pf_postfix_call)
            if not s.got_lf and (s.token.val == TokenType.dec or s.token.val == TokenType.inc):
                let op = s.token.val
                let op_token_ptr = s.token.ptr
                var opcode: i32 = 0
                var scope: i32 = 0
                var name = no_atom
                var label: i32 = 0
                var depth_unused: i32 = 0
                try get_lvalue(s, &opcode, &scope, &name, &label, &depth_unused, true, op)
                emit_source_pos(s, op_token_ptr)
                emit_op(s, (u8)((i32)Op.post_dec + (i32)op - (i32)TokenType.dec))
                put_lvalue(s, opcode, scope, name, label, PutLValueKind.keep_second, false)
                try next_token(s)
    if (parse_flags & (pf_pow_allowed | pf_pow_forbidden)) != 0:
        if s.token.val == TokenType.pow:
            # Strict ES7 exponentiation syntax rules: To solve conficting semantics between
            # different implementations regarding the precedence of prefix operators and
            # the postifx exponential, ES7 specifies that -2**2 is a syntax error.
            if (parse_flags & pf_pow_forbidden) != 0:
                try js_throw_syntax_error(s.ctx, "unparenthesized unary expression can't appear on the left-hand side of '**'")
            let op_token_ptr = s.token.ptr
            try next_token(s)
            try js_parse_unary(s, pf_pow_allowed)
            emit_source_pos(s, op_token_ptr)
            emit_op(s, (u8)Op.pow)

# mark: Binary operators ========================================================================

# The opcode of the binary operator `op` at precedence `level` (1: multiplicative to 8:
# '|'), or none if `op` is not one of that level ('in' only with PF_IN_ACCEPTED).
func binary_opcode(level: i32, op: TokenType, parse_flags: i32) -> Op?:
    match level:
        1:
            match op:
                .star: return Op.mul
                .slash: return Op.div
                .percent: return Op.mod
                _: return none
        2:
            match op:
                .plus: return Op.add
                .minus: return Op.sub
                _: return none
        3:
            match op:
                .shl: return Op.shl
                .sar: return Op.sar
                .shr: return Op.shr
                _: return none
        4:
            match op:
                .less: return Op.lt
                .greater: return Op.gt
                .lte: return Op.lte
                .gte: return Op.gte
                .instanceof: return Op.instanceof
                .in_:
                    if (parse_flags & pf_in_accepted) != 0:
                        return Op.in_
                    return none
                _: return none
        5:
            match op:
                .eq: return Op.eq
                .neq: return Op.neq
                .strict_eq: return Op.strict_eq
                .strict_neq: return Op.strict_neq
                _: return none
        6:
            if op == TokenType.ampersand:
                return Op.and_
            return none
        7:
            if op == TokenType.caret:
                return Op.xor
            return none
        8:
            if op == TokenType.pipe:
                return Op.or_
            return none
        _:
            trap("js_parse_expr_binary: invalid level")

## allowed parse_flags: PF_IN_ACCEPTED
func js_parse_expr_binary(s: ParseState*, level: i32, parse_flags: i32) -> !:
    if level == 0:
        try js_parse_unary(s, pf_pow_allowed)
        return
    elif (s.token.val == TokenType.private_name and (parse_flags & pf_in_accepted) != 0 and level == 4 and peek_token(s, false) == TokenType.in_):
        let atom = js_dup_atom(s.ctx, s.token.u.ident.atom)
        errdefer js_free_atom(s.ctx, atom)
        try next_token(s)
        if s.token.val != TokenType.in_:
            # QuickJS fails here without throwing (peek_token saw 'in')
            error(exception, "")
        try next_token(s)
        try js_parse_expr_binary(s, level - 1, parse_flags)
        emit_op(s, (u8)TempOp.scope_in_private_field)
        emit_atom(s, atom)
        emit_u16(s, (u16)s.fd().scope_level)
        js_free_atom(s.ctx, atom)
        return
    else:
        try js_parse_expr_binary(s, level - 1, parse_flags)
    while true:
        let op = s.token.val
        let op_token_ptr = s.token.ptr
        let opcode = binary_opcode(level, op, parse_flags) else return
        try next_token(s)
        try js_parse_expr_binary(s, level - 1, parse_flags)
        emit_source_pos(s, op_token_ptr)
        emit_op(s, (u8)opcode)

# mark: Logical and conditional operators =======================================================

## allowed parse_flags: PF_IN_ACCEPTED
func js_parse_logical_and_or(s: ParseState*, op: TokenType, parse_flags: i32) -> !:
    if op == TokenType.land:
        try js_parse_expr_binary(s, 8, parse_flags)
    else:
        try js_parse_logical_and_or(s, TokenType.land, parse_flags)
    if s.token.val == op:
        let label1 = new_label(s)

        while true:
            try next_token(s)
            emit_op(s, (u8)Op.dup)
            let jump = (i32)Op.if_false if op == TokenType.land else (i32)Op.if_true
            _ = emit_goto(s, jump, label1)
            emit_op(s, (u8)Op.drop)

            if op == TokenType.land:
                try js_parse_expr_binary(s, 8, parse_flags)
            else:
                try js_parse_logical_and_or(s, TokenType.land, parse_flags)
            if s.token.val != op:
                if s.token.val == TokenType.double_question_mark:
                    try js_parse_error(s, "cannot mix ?? with && or ||")
                break

        _ = emit_label(s, label1)

func js_parse_coalesce_expr(s: ParseState*, parse_flags: i32) -> !:
    try js_parse_logical_and_or(s, TokenType.lor, parse_flags)
    if s.token.val == TokenType.double_question_mark:
        let label1 = new_label(s)
        while true:
            try next_token(s)

            emit_op(s, (u8)Op.dup)
            emit_op(s, (u8)Op.is_undefined_or_null)
            _ = emit_goto(s, (i32)Op.if_false, label1)
            emit_op(s, (u8)Op.drop)

            try js_parse_expr_binary(s, 8, parse_flags)
            if s.token.val != TokenType.double_question_mark:
                break
        _ = emit_label(s, label1)

## allowed parse_flags: PF_IN_ACCEPTED
func js_parse_cond_expr(s: ParseState*, parse_flags: i32) -> !:
    try js_parse_coalesce_expr(s, parse_flags)
    if s.token.val == TokenType.question:
        try next_token(s)
        let label1 = emit_goto(s, (i32)Op.if_false, -1)

        try js_parse_assign_expr(s)
        try js_parse_expect(s, TokenType.colon)

        let label2 = emit_goto(s, (i32)Op.goto_, -1)

        _ = emit_label(s, label1)

        try js_parse_assign_expr2(s, parse_flags & pf_in_accepted)

        _ = emit_label(s, label2)