Function run

compiler/src/main/exports.rs:303–362

(len: usize)

#[unsafe(no_mangle)]
pub unsafe extern "C" fn run(len: usize) -> usize {
    let src = match read_src(len) {
        Ok(s) => s,
        Err(e) => return unsafe {
            write_out(&s!("input rejected: invalid utf-8 at byte ", int e.valid_up_to()))
        },
    };

    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();

    let out: String = if !errs.is_empty() {
        let mut s = String::new();
        for (i, e) in errs.iter().enumerate() {
            if i > 0 { s.push('\n'); }
            s.push_str(&e.render(&src, None));
        }
        s
    } else {
        crate::modules::vm::optimizer::constant_fold(&mut chunk);
        let mut vm = VM::with_limits(&chunk, Limits::sandbox());
        vm.print_hook = Some(stream_print);
        vm.set_time_hook(now_ns_host);
        vm.strict_input = true;
        // Drain any host-supplied input bytes; `UTF-8` invalid bytes degrade to an empty input rather than UB.
        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();
        }

        // Publish VM for re-entrant host_edge_op via RAII guard so a panic or early return cannot leave a stale pointer in the runtime.
        let _guard = VmGuard::new(&mut vm);
        let result = vm.run();

        match result {
            Ok(_) => String::new(),
            // Legacy `run` cannot suspend; embedders that need `sleep(n>0)` / `frame()` / `receive()` must drive `run_start` + `run_resume`.
            Err(VmErr::HostYield(_)) => String::from(
                "RuntimeError: scheduler suspended; this build's legacy `run` entry has no resume, drive `run_start` / `run_resume` instead.",
            ),
            Err(e) => e.render_traceback(
                &src, vm.error_pos(), None,
                vm.call_stack_frames(), vm.function_names_ref(),
            ),
        }
    };