Function compile_for

core/src/compiler/top.rs:606–676

Compiles a `FOR` loop and emits bytecode into `ctx`.

(ctx: &mut Context, symtable: &mut LocalSymtable<'_>, span: ForSpan)

/// Compiles a `FOR` loop and emits bytecode into `ctx`.
fn compile_for(ctx: &mut Context, symtable: &mut LocalSymtable<'_>, span: ForSpan) -> Result<()> {
    if span.iter_double && span.iter.ref_type.is_none() {
        match symtable.get_local_or_global(&span.iter) {
            Ok(..) => {
                // Keep existing iterators as-is.  This mirrors core behavior where implicit
                // widening to DOUBLE only happens when the iterator does not exist yet.
            }

            Err(syms::Error::UndefinedSymbol(..)) => {
                let key = SymbolKey::from(&span.iter.name);
                if symtable.get_callable(&key).is_some() {
                    return Err(Error::from_syms(
                        syms::Error::AlreadyDefined(span.iter.clone()),
                        span.iter_pos,
                    ));
                }
                symtable
                    .put_local(key, SymbolPrototype::Scalar(ExprType::Double))
                    .map_err(|e| Error::from_syms(e, span.iter_pos))?;
            }

            Err(e) => return Err(Error::from_syms(e, span.iter_pos)),
        }
    }

    compile_assignment(
        &mut ctx.codegen,
        symtable,
        AssignmentSpan { vref: span.iter.clone(), vref_pos: span.iter_pos, expr: span.start },
    )?;

    let start_pc = ctx.codegen.next_pc();
    let (jump_end_pc, cond_reg, cond_pos) = {
        let cond_pos = span.end.start_pos();
        let mut frozen = symtable.frozen();
        let mut scope = frozen.temp_scope();
        let reg = scope.alloc().map_err(|e| Error::from_syms(e, cond_pos))?;
        compile_expr_as_type(&mut ctx.codegen, &mut frozen, reg, span.end, ExprType::Boolean)?;
        (ctx.codegen.emit(bytecode::make_nop(), cond_pos), reg, cond_pos)
    };
    ctx.codegen.mark_statement_start(start_pc);

    ctx.for_exit_stack.push(vec![]);

    for stmt in span.body {
        compile_stmt(ctx, symtable, stmt)?;
    }

    compile_assignment(
        &mut ctx.codegen,
        symtable,
        AssignmentSpan { vref: span.iter, vref_pos: span.iter_pos, expr: span.next },
    )?;

    let start_target =
        u16::try_from(start_pc).map_err(|_| Error::TargetTooFar(cond_pos, start_pc))?;
    ctx.codegen.emit(bytecode::make_jump(start_target), cond_pos);