rudus/src/main.rs

use chumsky::{input::Stream, prelude::*};
use imbl::HashMap;
use std::env;

const DEBUG_COMPILE: bool = true;
const DEBUG_RUN: bool = true;

mod base;

mod spans;
use crate::spans::Spanned;

mod lexer;
use crate::lexer::lexer;

mod parser;
use crate::parser::{parser, Ast};

mod validator;

mod compiler;
use crate::compiler::Compiler;

mod value;
use value::Value;

mod vm;
use vm::Vm;

const PRELUDE: &str = include_str!("../assets/prelude.ld");

pub fn prelude() -> HashMap<&'static str, Value> {
    let tokens = lexer().parse(PRELUDE).into_output_errors().0.unwrap();
    let (parsed, parse_errors) = parser()
        .parse(Stream::from_iter(tokens).map((0..PRELUDE.len()).into(), |(t, s)| (t, s)))
        .into_output_errors();

    if !parse_errors.is_empty() {
        println!("ERROR PARSING PRELUDE:");
        println!("{:?}", parse_errors);
        panic!();
    }

    let parsed: &'static Spanned<Ast> = Box::leak(Box::new(parsed.unwrap()));
    let mut compiler = Compiler::new(parsed, "prelude", PRELUDE, None, HashMap::new());
    let base = base::make_base();
    compiler.emit_constant(base);
    compiler.bind("base");
    compiler.compile();

    let chunk = compiler.chunk;
    let mut vm = Vm::new(chunk);
    let prelude = vm.run().clone().unwrap();
    match prelude {
        Value::Dict(hashmap) => *hashmap,
        _ => unreachable!(),
    }
}

pub fn run(src: &'static str) {
    let (tokens, lex_errs) = lexer().parse(src).into_output_errors();
    if !lex_errs.is_empty() {
        println!("{:?}", lex_errs);
        return;
    }

    let tokens = tokens.unwrap();

    let (parse_result, parse_errors) = parser()
        .parse(Stream::from_iter(tokens).map((0..src.len()).into(), |(t, s)| (t, s)))
        .into_output_errors();
    if !parse_errors.is_empty() {
        println!("{:?}", parse_errors);
        return;
    }

    // ::sigh:: The AST should be 'static
    // This simplifies lifetimes, and
    // in any event, the AST should live forever
    let parsed: &'static Spanned<Ast> = Box::leak(Box::new(parse_result.unwrap()));

    // let prelude = prelude();
    let prelude = imbl::HashMap::new();

    let mut compiler = Compiler::new(parsed, "test", src, None, prelude);
    // let base = base::make_base();
    // compiler.emit_constant(base);
    // compiler.bind("base");

    compiler.compile();
    if DEBUG_COMPILE {
        println!("=== source code ===");
        println!("{src}");
        compiler.disassemble();
        println!("\n\n")
    }

    if DEBUG_RUN {
        println!("=== vm run: test ===");
    }

    let vm_chunk = compiler.chunk;

    let mut vm = Vm::new(vm_chunk);
    let result = vm.run();
    let output = match result {
        Ok(val) => val.show(),
        Err(panic) => format!("Ludus panicked! {panic}"),
    };
    vm.print_stack();
    println!("{output}");
}

pub fn main() {
    env::set_var("RUST_BACKTRACE", "1");
    let src = "
fn one {
    (x as :number) -> {
        fn two () -> :number
        two
    }
    (x as :bool) -> {
        fn two () -> :bool
        two
    }
}

one (true) ()
";
    run(src);
}