ralix 0.2.0

A simple, type-safe, tree walking interpreter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::{
    Environment, EvalResult, Evaluator, Lexer, Parser, RuntimeContext, SymbolTable, object::Module,
};
use std::{
    collections::HashMap,
    fs, io,
    path::{Path, PathBuf},
};

#[derive(Debug)]
pub enum ModuleState {
    Loading,
    Loaded(Module),
}

pub type ModuleCache = HashMap<PathBuf, ModuleState>;

impl Evaluator<'_> {
    pub fn evaluate_module(&mut self, module_path: PathBuf) -> io::Result<Module> {
        let module_source = fs::read_to_string(&module_path)?;
        let working_directory = module_path.parent().unwrap_or(Path::new("."));

        self.ctx
            .module_cache
            .insert(module_path.clone(), ModuleState::Loading);

        let mut st = SymbolTable::default();
        let program = match Parser::new(Lexer::new(&module_source), &mut st, working_directory)
            .parse_program()
        {
            Ok(p) => p,
            Err(parse_error) => {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    parse_error.to_string(),
                ));
            }
        };

        // skiping type checking during runtime

        let mut environment = Environment::default();
        let ctx = RuntimeContext {
            module_cache: self.ctx.module_cache,
            heap: self.ctx.heap,
            environment: &mut environment,
            self_module: Module::default(),
        };
        let mut evaluator = Evaluator::new(ctx);
        if let EvalResult::Err(runtime_error) = evaluator.evaluate_program(program) {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                runtime_error.to_string(),
            ));
        }

        Ok(evaluator.ctx.self_module)
    }
}