Function compile_pending_ops

core/src/compiler/exprs.rs:452–569

Processes `pending` binary ops from innermost to outermost, using `reg` as the accumulator. This avoids the deep recursion that would arise if we compiled binary op chains by recursing on the lhs.

(
    codegen: &mut Codegen,
    symtable: &mut TempSymtable<'_, '_>,
    reg: Register,
    mut etype: ExprType,
    mut pending: Vec<PendingOp>,
)

/// This avoids the deep recursion that would arise if we compiled binary op chains
/// by recursing on the lhs.
fn compile_pending_ops(
    codegen: &mut Codegen,
    symtable: &mut TempSymtable<'_, '_>,
    reg: Register,
    mut etype: ExprType,
    mut pending: Vec<PendingOp>,
) -> Result<ExprType> {
    while let Some(op) = pending.pop() {
        match op {
            PendingOp::Unary(op) => {
                let result_type = match etype {
                    ExprType::Boolean if op.make_boolean.is_some() => ExprType::Boolean,
                    ExprType::Double if op.make_double.is_some() => ExprType::Double,
                    ExprType::Integer => ExprType::Integer,
                    _ => match op.kind {
                        PendingUnaryKind::Negate => return Err(Error::NotANumber(op.pos, etype)),
                        PendingUnaryKind::Not => {
                            return Err(Error::TypeMismatch(op.pos, etype, ExprType::Integer));
                        }
                    },
                };
                match result_type {
                    ExprType::Boolean => {
                        let mut scope = symtable.temp_scope();
                        let temp = scope.alloc().map_err(|e| Error::from_syms(e, op.pos))?;
                        codegen.emit_value(temp, ConstantDatum::Integer(1), op.pos)?;
                        codegen.emit(op.make_boolean.unwrap()(reg, reg, temp), op.pos);
                    }
                    ExprType::Double => {
                        codegen.emit(op.make_double.unwrap()(reg), op.pos);
                    }
                    ExprType::Integer => {
                        codegen.emit((op.make_integer)(reg), op.pos);
                    }
                    ExprType::Text => unreachable!(),
                }
                etype = result_type;
            }
            PendingOp::Binary(op) => {
                let rpos = op.rhs.start_pos();
                let mut scope = symtable.temp_scope();
                let rtemp = scope.alloc().map_err(|e| Error::from_syms(e, rpos))?;
                let rtype = compile_expr(codegen, symtable, rtemp, op.rhs)?;

                let result_type = match (etype, rtype) {
                    (ExprType::Boolean, ExprType::Boolean) if op.make_boolean.is_some() => {
                        ExprType::Boolean
                    }
                    (ExprType::Text, ExprType::Text) if op.make_text.is_some() => ExprType::Text,
                    (_, _) if op.make_double.is_some() => {
                        match resolve_numeric_binary_type(
                            codegen, reg, etype, rtemp, rtype, rpos, op.pos,
                        ) {
                            Some(v) => v,
                            None => {
                                return Err(Error::BinaryOpType(op.pos, op.op_name, etype, rtype));
                            }
                        }