Function compile_user_callable

core/src/compiler/top.rs:1117–1190

Compiles a single user-defined callable.

(
    ctx: &mut Context,
    symtable: &mut GlobalSymtable,
    callable: CallableSpan,
)

/// Compiles a single user-defined callable.
fn compile_user_callable(
    ctx: &mut Context,
    symtable: &mut GlobalSymtable,
    callable: CallableSpan,
) -> Result<()> {
    if ctx.current_callable.is_some() {
        return Err(Error::CannotNestUserCallables(callable.name_pos));
    }

    let skip_pc = ctx.codegen.emit(bytecode::make_nop(), callable.name_pos);

    let start_pc = ctx.codegen.next_pc();

    let key_pos = callable.name_pos;
    let key = SymbolKey::from(callable.name.name);
    ctx.current_callable = Some(if callable.name.ref_type.is_some() {
        CallableKind::Function
    } else {
        CallableKind::Sub
    });
    debug_assert!(ctx.callable_exit_jumps.is_empty());

    let mut symtable = symtable.enter_scope();

    // The call protocol expects the return value to be in the first local variable
    // so allocate it early, and then all arguments follow in order from left to right.
    if let Some(vtype) = callable.name.ref_type {
        let ret_reg = symtable
            .put_local(key.clone(), SymbolPrototype::Scalar(vtype))
            .map_err(|e| Error::from_syms(e, key_pos))?;

        // Set the default value of the function result.  We could instead try to do this
        // at runtime by clearning the return register... but the problem is that we need
        // to handle non-primitive types like strings and the runtime doesn't know the type
        // of the result to properly allocate it.
        let value = match vtype {
            ExprType::Boolean | ExprType::Integer => 0,
            ExprType::Double => ctx.codegen.get_constant(ConstantDatum::Double(0.0), key_pos)?,
            ExprType::Text => {
                ctx.codegen.get_constant(ConstantDatum::Text(String::new()), key_pos)?
            }
        };
        ctx.codegen.emit(bytecode::make_load_integer(ret_reg, value), key_pos);
    }
    for param in callable.params {
        let key = SymbolKey::from(param.name);
        symtable
            .put_local(
                key.clone(),
                SymbolPrototype::Scalar(param.ref_type.unwrap_or(ExprType::Integer)),
            )
            .map_err(|e| Error::from_syms(e, key_pos))?;
    }

    for stmt in callable.body {
        compile_stmt(ctx, &mut symtable, stmt)?;
    }