Function run_start

compiler/src/main/exports.rs:173–225

(len: usize)

#[unsafe(no_mangle)]
pub unsafe extern "C" fn run_start(len: usize) -> u32 {
    // Discard any previous paused run; a fresh `run_start` is a hard reset of execution state.
    with_runtime(|rt| { rt.paused_run = None; });

    let src = match read_src(len) {
        Ok(s) => s,
        Err(e) => {
            let msg = s!("input rejected: invalid utf-8 at byte ", int e.valid_up_to());
            let n = unsafe { write_out(&msg) };
            return STATUS_ERROR | ((n as u32) & STATUS_PAYLOAD_MASK);
        }
    };

    let (tokens, lex_errs) = lex(&src);
    let resolver = Box::new(WasmHostResolver { dir: String::new() });
    let mut p = Parser::with_resolver(&src, tokens.into_iter(), resolver);
    for e in lex_errs {
        p.errors.push(Diagnostic { start: e.start, end: e.end, msg: e.msg.into() });
    }
    let (mut chunk, errs) = p.parse();

    if !errs.is_empty() {
        let mut buf = String::new();
        for (i, e) in errs.iter().enumerate() {
            if i > 0 { buf.push('\n'); }
            buf.push_str(&e.render(&src, None));
        }
        let n = unsafe { write_out(&buf) };
        return STATUS_ERROR | ((n as u32) & STATUS_PAYLOAD_MASK);
    }

    crate::modules::vm::optimizer::constant_fold(&mut chunk);

    // Leak chunk so its lifetime survives across `run_resume`; reclaimed on page reload.
    let chunk_static: &'static SSAChunk = Box::leak(Box::new(chunk));
    let mut vm = VM::with_limits(chunk_static, Limits::sandbox());
    vm.print_hook = Some(stream_print);
    vm.set_time_hook(now_ns_host);
    vm.strict_input = true;

    let inp_text = with_runtime(|rt| {
        if rt.inp_len == 0 { return String::new(); }
        let bytes = &rt.inp[..rt.inp_len];
        let inp = core::str::from_utf8(bytes).unwrap_or("").to_string();
        rt.inp_len = 0;
        inp
    });
    if !inp_text.is_empty() {
        vm.input_buffer = inp_text.split('\n').map(alloc::string::String::from).collect();
    }

    step_vm(vm, &src, None)
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn run_resume() -> u32 {