mirascript-core 0.1.105

Compiler and bytecode definitions for the MiraScript language
Documentation
use std::borrow::Cow;

use crate::SourceRange;

use super::{
    Emitter,
    constant::Constant as C,
    opcode::{
        OpCode::{self, *},
        OpParam, OpParamTrait, Register,
    },
};

impl<'s, 'c> Emitter<'s, 'c> {
    pub fn add_const_string(&mut self, value: impl Into<Cow<'s, str>>) -> OpParam {
        self.chunk.add_constant(C::String(value.into()))
    }
    pub fn add_const_number(&mut self, value: f64) -> OpParam {
        self.chunk.add_constant(C::Number(value))
    }
    pub fn add_const_ordinal(&mut self, value: i32) -> OpParam {
        self.chunk.add_constant(C::Ordinal(value))
    }
    pub fn add_const_bool(&mut self, value: bool) -> OpParam {
        self.chunk
            .add_constant(if value { C::True } else { C::False })
    }

    pub fn op(&mut self, mapping: SourceRange, op: OpCode) {
        self.chunk.add_code(op);
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_1(&mut self, mapping: SourceRange, op: OpCode, arg1: impl OpParamTrait) {
        if !arg1.is_wide() {
            self.chunk.add_code(op);
            self.chunk.add_param(arg1);
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(arg1);
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_2(
        &mut self,
        mapping: SourceRange,
        op: OpCode,
        arg1: impl OpParamTrait,
        arg2: impl OpParamTrait,
    ) {
        if !arg1.is_wide() && !arg2.is_wide() {
            self.chunk.add_code(op);
            self.chunk.add_param(arg1);
            self.chunk.add_param(arg2);
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(arg1);
            self.chunk.add_param_wide(arg2);
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_3(
        &mut self,
        mapping: SourceRange,
        op: OpCode,
        arg1: impl OpParamTrait,
        arg2: impl OpParamTrait,
        arg3: impl OpParamTrait,
    ) {
        if !arg1.is_wide() && !arg2.is_wide() && !arg3.is_wide() {
            self.chunk.add_code(op);
            self.chunk.add_param(arg1);
            self.chunk.add_param(arg2);
            self.chunk.add_param(arg3);
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(arg1);
            self.chunk.add_param_wide(arg2);
            self.chunk.add_param_wide(arg3);
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_4(
        &mut self,
        mapping: SourceRange,
        op: OpCode,
        arg1: impl OpParamTrait,
        arg2: impl OpParamTrait,
        arg3: impl OpParamTrait,
        arg4: impl OpParamTrait,
    ) {
        if !arg1.is_wide() && !arg2.is_wide() && !arg3.is_wide() && !arg4.is_wide() {
            self.chunk.add_code(op);
            self.chunk.add_param(arg1);
            self.chunk.add_param(arg2);
            self.chunk.add_param(arg3);
            self.chunk.add_param(arg4);
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(arg1);
            self.chunk.add_param_wide(arg2);
            self.chunk.add_param_wide(arg3);
            self.chunk.add_param_wide(arg4);
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    fn op_const(&mut self, mapping: SourceRange, reg: Register, const_id: OpParam) {
        self.op_2(mapping, Constant, reg, const_id);
    }
    pub fn op_global(
        &mut self,
        mapping: SourceRange,
        reg: Register,
        name: impl Into<Cow<'s, str>>,
    ) {
        let const_id = self.add_const_string(name);
        self.op_2(mapping, GetGlobal, reg, const_id);
    }
    pub fn op_global_dyn(&mut self, mapping: SourceRange, reg: Register, name: Register) {
        self.op_2(mapping, GetGlobalDyn, reg, name);
    }
    pub fn op_nil(&mut self, mapping: SourceRange, reg: Register) {
        self.op_unary(mapping, reg, Assign, Register::EMPTY);
    }
    pub fn op_number(&mut self, mapping: SourceRange, reg: Register, value: f64) {
        let const_id = self.add_const_number(value);
        self.op_const(mapping, reg, const_id);
    }
    pub fn op_bool(&mut self, mapping: SourceRange, reg: Register, value: bool) {
        let const_id = self.add_const_bool(value);
        self.op_const(mapping, reg, const_id);
    }
    pub fn op_string(
        &mut self,
        mapping: SourceRange,
        reg: Register,
        value: impl Into<Cow<'s, str>>,
    ) {
        let const_id = self.add_const_string(value);
        self.op_const(mapping, reg, const_id);
    }
    pub fn op_uninit(&mut self, mapping: SourceRange, reg: Register) {
        self.op_1(mapping, OpCode::Uninit, reg);
    }
    pub fn op_format(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        val: Register,
        fmt: impl Into<Cow<'s, str>>,
    ) {
        let fmt = self.add_const_string(fmt);
        self.op_3(mapping, OpCode::Format, ret, val, fmt);
    }
    pub fn op_unary(&mut self, mapping: SourceRange, ret: Register, op: OpCode, reg: Register) {
        self.op_2(mapping, op, ret, reg);
    }
    pub fn op_binary(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        op: OpCode,
        left: Register,
        right: Register,
    ) {
        self.op_3(mapping, op, ret, left, right);
    }
    pub fn op_variadic(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        op: OpCode,
        var_args: Vec<impl OpParamTrait>,
    ) {
        let n: OpParam = var_args.len().into();
        if !n.is_wide() && !ret.is_wide() && !var_args.iter().any(|r| r.is_wide()) {
            self.chunk.add_code(op);
            self.chunk.add_param(ret);
            self.chunk.add_param(n);
            for r in var_args {
                self.chunk.add_param(r);
            }
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(ret);
            self.chunk.add_param_wide(n);
            for r in var_args {
                self.chunk.add_param_wide(r);
            }
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_variadic_1(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        op: OpCode,
        arg1: impl OpParamTrait,
        var_args: Vec<impl OpParamTrait>,
    ) {
        let n: OpParam = var_args.len().into();
        if !n.is_wide()
            && !ret.is_wide()
            && !arg1.is_wide()
            && !var_args.iter().any(|r| r.is_wide())
        {
            self.chunk.add_code(op);
            self.chunk.add_param(ret);
            self.chunk.add_param(arg1);
            self.chunk.add_param(n);
            for r in var_args {
                self.chunk.add_param(r);
            }
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(ret);
            self.chunk.add_param_wide(arg1);
            self.chunk.add_param_wide(n);
            for r in var_args {
                self.chunk.add_param_wide(r);
            }
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_variadic_variadic_1(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        op: OpCode,
        arg1: impl OpParamTrait,
        var_args1: Vec<impl OpParamTrait>,
        var_args2: Vec<impl OpParamTrait>,
    ) {
        let n1: OpParam = var_args1.len().into();
        let n2: OpParam = var_args2.len().into();
        if !n1.is_wide()
            && !n2.is_wide()
            && !ret.is_wide()
            && !arg1.is_wide()
            && !var_args1.iter().any(|r| r.is_wide())
            && !var_args2.iter().any(|r| r.is_wide())
        {
            self.chunk.add_code(op);
            self.chunk.add_param(ret);
            self.chunk.add_param(arg1);
            self.chunk.add_param(n1);
            for r in var_args1 {
                self.chunk.add_param(r);
            }
            self.chunk.add_param(n2);
            for r in var_args2 {
                self.chunk.add_param(r);
            }
        } else {
            self.chunk.add_code_wide(op);
            self.chunk.add_param_wide(ret);
            self.chunk.add_param_wide(arg1);
            self.chunk.add_param_wide(n1);
            for r in var_args1 {
                self.chunk.add_param_wide(r);
            }
            self.chunk.add_param_wide(n2);
            for r in var_args2 {
                self.chunk.add_param_wide(r);
            }
        }
        self.diagnostics
            .push(crate::DiagnosticCode::SourceMap, mapping);
    }
    pub fn op_non_nil(&mut self, mapping: SourceRange, reg: Register) {
        self.op_1(mapping, AssertNonNil, reg);
    }

    pub fn op_if(&mut self, mapping: SourceRange, if_code: OpCode, cond: Register) {
        self.op_1(mapping, if_code, cond);
    }
    pub fn op_else(&mut self, mapping: SourceRange) {
        self.op(mapping, Else);
    }
    pub fn op_if_end(&mut self, mapping: SourceRange) {
        self.op(mapping, IfEnd);
    }

    pub fn op_return(&mut self, mapping: SourceRange, ret: Register) {
        self.op_1(mapping, Return, ret);
    }

    pub fn op_call(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        func: impl Into<Cow<'s, str>>,
        args: Vec<Register>,
        spreads: Vec<OpParam>,
    ) {
        let f = self.add_const_string(func);
        self.op_variadic_variadic_1(mapping, ret, Call, f, args, spreads)
    }

    pub fn op_call_dyn(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        func: Register,
        args: Vec<Register>,
        spreads: Vec<OpParam>,
    ) {
        self.op_variadic_variadic_1(mapping, ret, CallDyn, func, args, spreads)
    }

    pub fn op_get_upvalue(
        &mut self,
        mapping: SourceRange,
        reg: Register,
        level: usize,
        up_reg: Register,
    ) {
        let level: OpParam = level.into();
        self.op_3(mapping, GetUpvalue, reg, level, up_reg);
    }

    pub fn op_set_upvalue(
        &mut self,
        mapping: SourceRange,
        reg: Register,
        level: usize,
        up_reg: Register,
    ) {
        let level: OpParam = level.into();
        self.op_3(mapping, SetUpvalue, reg, level, up_reg);
    }

    pub fn op_get(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        obj: Register,
        name: impl Into<Cow<'s, str>>,
    ) {
        let const_id = self.add_const_string(name);
        self.op_3(mapping, Get, ret, obj, const_id);
    }

    pub fn op_get_index(&mut self, mapping: SourceRange, ret: Register, obj: Register, index: i32) {
        self.op_3(mapping, GetIndex, ret, obj, OpParam::new(index));
    }

    pub fn op_get_dyn(
        &mut self,
        mapping: SourceRange,
        ret: Register,
        obj: Register,
        index: Register,
    ) {
        self.op_3(mapping, GetDyn, ret, obj, index);
    }
}