Function prepare_globals

core/src/compiler/top.rs:1247–1320

Prepares global variables injected from outside of the compiled program. Pre-defined scalar globals are initialized to their default values (0 for numeric types, empty string for text). Pre-defined array globals are allocated with all elements set to their default values. The compiled program may read or write any of these globals. After execution, use `Vm::get_global*` methods to query the va

(
    ctx: &mut Context,
    symtable: &mut GlobalSymtable,
    global_defs: &[GlobalDef],
)

/// After execution, use `Vm::get_global*` methods to query the values of these globals (and
/// any globals declared via `DIM SHARED` in the program itself).
pub(super) fn prepare_globals(
    ctx: &mut Context,
    symtable: &mut GlobalSymtable,
    global_defs: &[GlobalDef],
) -> Result<()> {
    let preamble_pos = LineCol { line: 0, col: 0 };

    // Register all global defs in the symbol table and collect array globals for the preamble.
    let mut max_ndims: u8 = 0;
    let mut array_globals: Vec<(Register, &GlobalDef)> = vec![];
    for def in global_defs {
        let key = SymbolKey::from(&def.name);
        match &def.kind {
            GlobalDefKind::Array { subtype, dimensions } => {
                let ndims =
                    u8::try_from(dimensions.len()).expect("Array must have at most 255 dimensions");
                let info = syms::ArrayInfo { subtype: *subtype, ndims: usize::from(ndims) };
                let reg = symtable
                    .put_global(key, SymbolPrototype::Array(info))
                    .map_err(|e| Error::from_syms(e, preamble_pos))?;
                max_ndims = max(max_ndims, ndims);
                array_globals.push((reg, def));
            }

            GlobalDefKind::Scalar { etype, initial_value } => {
                let reg = symtable
                    .put_global(key, SymbolPrototype::Scalar(*etype))
                    .map_err(|e| Error::from_syms(e, preamble_pos))?;
                match initial_value {
                    Some(datum) => {
                        if datum.etype() != *etype {
                            return Err(Error::TypeMismatch(preamble_pos, datum.etype(), *etype));
                        }
                        ctx.codegen.emit_value(reg, datum.clone(), preamble_pos)?;
                    }
                    None => ctx.codegen.emit_default(reg, *etype, preamble_pos),
                }
            }
        }
    }

    // Emit the array initialization preamble, but only if any arrays were defined.
    //
    // We use a short-lived `ENTER/LEAVE` scope to borrow local registers for the dimension
    // temporaries without permanently consuming global register slots.
    if array_globals.is_empty() {
        // `compile` starts by popping an EOF, so make sure there is one.
        ctx.codegen.emit(bytecode::make_eof(), preamble_pos);
        return Ok(());
    }
    for (reg, def) in array_globals {
        let GlobalDefKind::Array { subtype, dimensions } = &def.kind else {
            unreachable!("array_globals only contains array defs per the loop above")
        };

        let ndims = u8::try_from(dimensions.len()).unwrap();
        for (i, &dim) in dimensions.iter().enumerate() {
            let dim_u16 =