150 lines
3.7 KiB
Rust
150 lines
3.7 KiB
Rust
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;
|
|
use crate::validator::Validator;
|
|
|
|
mod errors;
|
|
use crate::errors::report_invalidation;
|
|
|
|
mod compiler;
|
|
use crate::compiler::Compiler;
|
|
|
|
mod value;
|
|
use value::Value;
|
|
|
|
mod vm;
|
|
use vm::Vm;
|
|
|
|
const PRELUDE: &str = include_str!("../assets/test_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 = parsed.unwrap();
|
|
let (ast, span) = &parsed;
|
|
|
|
let base = base::make_base();
|
|
let mut base_env = imbl::HashMap::new();
|
|
base_env.insert("base", base.clone());
|
|
|
|
let mut validator = Validator::new(ast, span, "prelude", PRELUDE, base_env);
|
|
|
|
validator.validate();
|
|
|
|
if !validator.errors.is_empty() {
|
|
println!("VALIDATION ERRORS IN PRLUDE:");
|
|
report_invalidation(validator.errors);
|
|
panic!();
|
|
}
|
|
|
|
let parsed: &'static Spanned<Ast> = Box::leak(Box::new(parsed));
|
|
let mut compiler = Compiler::new(parsed, "prelude", PRELUDE, None, HashMap::new());
|
|
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 validator = Validator::new(&parsed.0, &parsed.1, "user input", src, prelude.clone());
|
|
validator.validate();
|
|
|
|
if !validator.errors.is_empty() {
|
|
println!("Ludus found some validation errors:");
|
|
report_invalidation(validator.errors);
|
|
return;
|
|
}
|
|
|
|
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 = r#"
|
|
map(inc, [1, 2, 3])
|
|
"#;
|
|
run(src);
|
|
}
|