Function compile_stmt

core/src/compiler/top.rs:760–1079

Compiles a single `stmt` into the `ctx`.

(
    ctx: &mut Context,
    symtable: &mut LocalSymtable<'_>,
    stmt: Statement,
)

/// Compiles a single `stmt` into the `ctx`.
fn compile_stmt(
    ctx: &mut Context,
    symtable: &mut LocalSymtable<'_>,
    stmt: Statement,
) -> Result<()> {
    let start_pc = ctx.codegen.next_pc();
    let mut mark_start = true;
    match stmt {
        Statement::ArrayAssignment(span) => {
            let key_pos = span.vref_pos;

            let (arr_reg, info) = match symtable.get_local_or_global(&span.vref) {
                Ok((reg, SymbolPrototype::Array(info))) => (reg, info),

                Ok((_, SymbolPrototype::Scalar(_))) | Err(syms::Error::UndefinedSymbol(..)) => {
                    return Err(Error::NotAnArray(key_pos, span.vref));
                }

                Err(e) => return Err(Error::from_syms(e, key_pos)),
            };

            if span.subscripts.len() != info.ndims {
                return Err(Error::WrongNumberOfSubscripts(
                    key_pos,
                    info.ndims,
                    span.subscripts.len(),
                ));
            }

            let mut symtable = symtable.frozen();
            let mut outer_scope = symtable.temp_scope();

            let val_reg = outer_scope.alloc().map_err(|e| Error::from_syms(e, key_pos))?;
            compile_expr_as_type(
                &mut ctx.codegen,
                &mut symtable,
                val_reg,
                span.expr,
                info.subtype,
            )?;

            let first_sub_reg = compile_integer_exprs(
                &mut ctx.codegen,
                &mut symtable,
                &mut outer_scope,
                key_pos,
                span.subscripts.into_iter(),
            )?;
            ctx.codegen.emit(bytecode::make_store_array(arr_reg, val_reg, first_sub_reg), key_pos);
        }

        Statement::Assignment(span) => {
            compile_assignment(&mut ctx.codegen, symtable, span)?;
        }

        Statement::Call(span) => {
            let key = SymbolKey::from(&span.vref.name);
            let key_pos = span.vref_pos;