Function compile_select

core/src/compiler/top.rs:392–492

Compiles a `SELECT` statement and emits bytecode into `ctx`.

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

/// Compiles a `SELECT` statement and emits bytecode into `ctx`.
fn compile_select(
    ctx: &mut Context,
    symtable: &mut LocalSymtable<'_>,
    span: SelectSpan,
) -> Result<()> {
    let end_pos = span.end_pos;
    let ncases = span.cases.len();
    let select_cases = span.cases;
    let select_expr = span.expr;
    let select_expr_pos = select_expr.start_pos();

    /// Captures the data needed to materialize a `CASE` body after dispatch generation.
    struct PendingCase {
        body: Vec<Statement>,
        body_jump_pcs: Vec<(usize, LineCol)>,
        has_next_case: bool,
    }

    let mut pending_cases = Vec::with_capacity(ncases);
    let mut pending_next_case_jump: Option<(usize, LineCol)> = None;

    symtable.with_reserved_temp(
        |e| Error::from_syms(e, select_expr_pos),
        |test_reg, frozen| {
            let test_type = compile_expr(&mut ctx.codegen, frozen, test_reg, select_expr)?;

            for (i, case) in select_cases.into_iter().enumerate() {
                let has_next_case = i < ncases - 1;
                let mut body_jump_pcs = vec![];
                let case_dispatch_addr = ctx.codegen.next_pc();
                if let Some((jump_pc, pos)) = pending_next_case_jump.take() {
                    let target = u16::try_from(case_dispatch_addr)
                        .map_err(|_| Error::TargetTooFar(pos, case_dispatch_addr))?;
                    ctx.codegen.patch(jump_pc, bytecode::make_jump(target));
                }

                if case.guards.is_empty() {
                    let jump_body_pc = ctx.codegen.emit(bytecode::make_nop(), end_pos);
                    body_jump_pcs.push((jump_body_pc, end_pos));
                } else {
                    for guard in case.guards {
                        let (cond_reg, pos) =
                            compile_case_guard(ctx, frozen, test_reg, test_type, guard)?;
                        let jump_next_guard_pc = ctx.codegen.emit(bytecode::make_nop(), pos);
                        let jump_body_pc = ctx.codegen.emit(bytecode::make_nop(), pos);
                        body_jump_pcs.push((jump_body_pc, pos));

                        let next_addr = ctx.codegen.next_pc();
                        let target = u16::try_from(next_addr)
                            .map_err(|_| Error::TargetTooFar(pos, next_addr))?;
                        ctx.codegen.patch(
                            jump_next_guard_pc,
                            bytecode::make_jump_if_false(cond_reg, target),
                        );
                    }

                    let jump_next_case_pc = ctx.codegen.emit(bytecode::make_nop(), end_pos);
                    pending_next_case_jump = Some((jump_next_case_pc, end_pos));