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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::{fmt::Display, rc::Rc};

use crate::{Program, Value};

mod context;
mod error;
mod expressions;
mod module_cache;
mod statements;

pub use context::*;
pub use error::*;
pub use module_cache::*;

#[macro_export]
macro_rules! try_eval_result {
    ( $eval_result: expr ) => {{
        let value = $eval_result;
        match value {
            EvalResult::NoValue | EvalResult::Err(_) => return value,
            EvalResult::Return(_) => return value,
            EvalResult::Value(v) => v,
        }
    }};
}

impl From<Value> for EvalResult<Value> {
    fn from(val: Value) -> Self {
        EvalResult::Value(val)
    }
}

impl From<Option<Value>> for EvalResult<Value> {
    fn from(value: Option<Value>) -> Self {
        match value {
            Some(val) => Self::Value(val),
            None => Self::NoValue,
        }
    }
}

impl Value {
    pub fn copy_bits(&self) -> Option<Value> {
        match self {
            Value::Int(v) => Value::from(*v),
            Value::Char(v) => Value::from(*v),
            Value::Float(v) => Value::from(*v),
            Value::Boolean(v) => Value::from(*v),
            Value::Type(v) => Value::Type(v.clone()),
            Value::String(v) => Value::String(
                Rc::clone(v), /* Only copies the pointer that points the orijinal string value */
            ),
            Value::Pointer(addr) => Value::Pointer(*addr),
            Value::Null => Value::NULL,
            Value::Function(func) => Value::Function(func.clone()),
            _ => return None,
        }
        .into()
    }
}

pub struct Evaluator<'ctx> {
    ctx: RuntimeContext<'ctx>,
}

impl<'ctx> Evaluator<'ctx> {
    pub const fn new(ctx: RuntimeContext<'ctx>) -> Self {
        Evaluator { ctx }
    }
}

impl Evaluator<'_> {
    pub fn evaluate_program(&mut self, program: Program) -> EvalResult<Value> {
        let mut result = EvalResult::NoValue;

        for s in program.statements {
            result = self.evaluate_statement(s);

            match &result {
                EvalResult::Value(_) => {}
                EvalResult::NoValue => {}
                EvalResult::Return(obj) => match obj.clone() {
                    Some(o) => return EvalResult::Value(o),
                    None => return EvalResult::NoValue,
                },
                EvalResult::Err(err) => self.err(err),
            }
        }

        result
    }

    pub fn err<M: Display>(&self, msg: M) {
        eprintln!("\x1b[91mRuntime Error!\x1b[0m: {msg}");
    }
}