Split project into separate files

1 files changed, 274 insertions, 0 deletions

diff --git a/src/runtime.rs b/src/runtime.rs
new file mode 100644
index 0000000..3a16567
--- /dev/null
+++ b/src/runtime.rs
@@ -0,0 +1,274 @@
+use super::ast;
+use std::collections::HashMap;
+use std::fmt;
+use std::rc::Rc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+#[derive(Debug, Clone)]
+pub enum BuiltinFunction {
+    IntegerIncrement,
+    IntegerDecrement,
+    IntegerAdd,
+    IntegerAdd1(i64),
+    IntegerMultiply,
+    IntegerMultiply1(i64),
+    IntegerEq,
+    IntegerEq1(i64),
+}
+
+#[derive(Debug, Clone)]
+pub enum Value {
+    Integer(i64),
+    String(String),
+    Var(usize),
+    Function(usize, Rc<Value>),
+    BuiltinFunction(BuiltinFunction),
+}
+
+impl fmt::Display for Value {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Value::Integer(value) => write!(f, "{} :: Integer", value),
+            Value::String(value) => write!(f, "{} :: String", value),
+            Value::Var(v) => write!(f, "{} :: Unbound variable", v),
+            Value::Function(_, _) => {
+                write!(f, "Function :: Function")
+            }
+            Value::BuiltinFunction(_) => write!(f, "Built-in function :: Function"),
+        }
+    }
+}
+
+static VAR_ID_INC: AtomicUsize = AtomicUsize::new(0);
+const B_INTEGER_INCREMENT: &str = "int.increment";
+const B_INTEGER_DECREMENT: &str = "int.decrement";
+const B_INTEGER_ADD: &str = "int.add";
+const B_INTEGER_MULTIPLY: &str = "int.multiply";
+const B_INTEGER_EQ: &str = "int.eq?";
+
+fn advance_v() -> usize {
+    let v = VAR_ID_INC.load(Ordering::Relaxed);
+    VAR_ID_INC.store(v + 1, Ordering::Relaxed);
+    v
+}
+
+fn make_boolean_true_function() -> Value {
+    let x = advance_v();
+    let y = advance_v();
+    Value::Function(x, Rc::new(Value::Function(y, Rc::new(Value::Var(x)))))
+}
+
+fn make_boolean_false_function() -> Value {
+    let x = advance_v();
+    let y = advance_v();
+    Value::Function(x, Rc::new(Value::Function(y, Rc::new(Value::Var(y)))))
+}
+
+fn try_builtin_symbol_to_value(symbol: &ast::Symbol) -> Option<Value> {
+    match symbol.as_str() {
+        "true" => Some(make_boolean_true_function()),
+        "false" => Some(make_boolean_false_function()),
+        "id" => {
+            let v = advance_v();
+            Some(Value::Function(v, Rc::new(Value::Var(v))))
+        }
+        B_INTEGER_INCREMENT => Some(Value::BuiltinFunction(BuiltinFunction::IntegerIncrement)),
+        B_INTEGER_DECREMENT => Some(Value::BuiltinFunction(BuiltinFunction::IntegerDecrement)),
+        B_INTEGER_ADD => Some(Value::BuiltinFunction(BuiltinFunction::IntegerAdd)),
+        B_INTEGER_MULTIPLY => Some(Value::BuiltinFunction(BuiltinFunction::IntegerMultiply)),
+        B_INTEGER_EQ => Some(Value::BuiltinFunction(BuiltinFunction::IntegerEq)),
+        _ => None,
+    }
+}
+
+fn try_apply_function(func_rc: Rc<Value>, arg_rc: Rc<Value>, bound_v: Option<usize>) -> Rc<Value> {
+    let func = &*func_rc;
+    let arg = &*arg_rc;
+    match func {
+        Value::Function(func_v, body_rc) => {
+            let v1 = bound_v.unwrap_or(*func_v);
+            let body = &**body_rc;
+            match body {
+                Value::Var(v2) => {
+                    if v1 == *v2 {
+                        arg_rc
+                    } else {
+                        Rc::clone(body_rc)
+                    }
+                }
+                Value::Function(body_v, _) => {
+                    let new_body = try_apply_function(Rc::clone(body_rc), arg_rc, Some(v1));
+                    Rc::new(Value::Function(*body_v, new_body))
+                }
+                _ => Rc::clone(body_rc),
+            }
+        }
+        Value::BuiltinFunction(builtin) => match builtin {
+            BuiltinFunction::IntegerIncrement => match arg {
+                Value::Integer(value) => Rc::new(Value::Integer(value + 1)),
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_INCREMENT
+                ),
+            },
+            BuiltinFunction::IntegerDecrement => match arg {
+                Value::Integer(value) => Rc::new(Value::Integer(value - 1)),
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_DECREMENT
+                ),
+            },
+            BuiltinFunction::IntegerAdd => match arg {
+                Value::Integer(value) => {
+                    Rc::new(Value::BuiltinFunction(BuiltinFunction::IntegerAdd1(*value)))
+                }
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_ADD
+                ),
+            },
+            BuiltinFunction::IntegerAdd1(other) => match arg {
+                Value::Integer(value) => Rc::new(Value::Integer(other + value)),
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_ADD
+                ),
+            },
+            BuiltinFunction::IntegerMultiply => match arg {
+                Value::Integer(value) => Rc::new(Value::BuiltinFunction(
+                    BuiltinFunction::IntegerMultiply1(*value),
+                )),
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_MULTIPLY
+                ),
+            },
+            BuiltinFunction::IntegerMultiply1(other) => match arg {
+                Value::Integer(value) => Rc::new(Value::Integer(other * value)),
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_MULTIPLY
+                ),
+            },
+            BuiltinFunction::IntegerEq => match arg {
+                Value::Integer(value) => {
+                    Rc::new(Value::BuiltinFunction(BuiltinFunction::IntegerEq1(*value)))
+                }
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_EQ
+                ),
+            },
+            BuiltinFunction::IntegerEq1(other) => match arg {
+                Value::Integer(value) => Rc::new(if other == value {
+                    make_boolean_true_function()
+                } else {
+                    make_boolean_false_function()
+                }),
+                _ => panic!(
+                    "[runtime] tried to apply non-integer value to {}",
+                    B_INTEGER_EQ
+                ),
+            },
+        },
+        _ => func_rc,
+    }
+}
+
+fn evaluate_expr_inner_unary(
+    symbol_table: &HashMap<String, Rc<Value>>,
+    inner: &ast::ExpressionInner,
+) -> Rc<Value> {
+    match inner {
+        ast::ExpressionInner::IntegerLiteral(value) => Rc::new(Value::Integer(*value)),
+        ast::ExpressionInner::StringLiteral(value) => Rc::new(Value::String(value.clone())),
+        ast::ExpressionInner::Symbol(value) => {
+            let builtin_value = try_builtin_symbol_to_value(value);
+            if builtin_value.is_some() {
+                return Rc::new(builtin_value.unwrap());
+            }
+
+            let table_lookup_value = symbol_table.get(value);
+            if table_lookup_value.is_some() {
+                let lookup_rc = table_lookup_value.unwrap();
+                return Rc::clone(lookup_rc);
+            }
+
+            panic!("[runtime] symbol not defined: {:#?}", value);
+        }
+        ast::ExpressionInner::Expression(value_rc) => {
+            let sub_expr = &**value_rc;
+            evaluate_expr(symbol_table, sub_expr)
+        }
+    }
+}
+
+fn evaluate_expr_inner_binary(
+    symbol_table: &HashMap<String, Rc<Value>>,
+    lhs: &ast::ExpressionInner,
+    rhs: &ast::ExpressionInner,
+) -> Rc<Value> {
+    match lhs {
+        ast::ExpressionInner::Expression(value_rc) => {
+            let sub_expr = &**value_rc;
+
+            let evaled_lhs = evaluate_expr(symbol_table, sub_expr);
+            let evaled_rhs = evaluate_expr_inner_unary(symbol_table, rhs);
+            try_apply_function(evaled_lhs, evaled_rhs, None)
+        }
+        ast::ExpressionInner::Symbol(value) => {
+            let lhs_value_rc: Rc<Value>;
+
+            if let Some(builtin) = try_builtin_symbol_to_value(value) {
+                lhs_value_rc = Rc::new(builtin);
+            } else if let Some(lookup) = symbol_table.get(value) {
+                lhs_value_rc = Rc::clone(lookup);
+            } else {
+                panic!("[runtime] symbol not defined: {:#?}", value);
+            }
+
+            let evaled_rhs = evaluate_expr_inner_unary(symbol_table, rhs);
+            try_apply_function(lhs_value_rc, evaled_rhs, None)
+        }
+        other => unreachable!(
+            "[runtime] this should not be on the left side of a binary expression: {:#?}",
+            other
+        ),
+    }
+}
+
+fn evaluate_expr(
+    symbol_table: &HashMap<String, Rc<Value>>,
+    expression: &ast::Expression,
+) -> Rc<Value> {
+    match expression {
+        ast::Expression::Unary(inner) => evaluate_expr_inner_unary(symbol_table, inner),
+        ast::Expression::Binary(inner1, inner2) => {
+            evaluate_expr_inner_binary(symbol_table, inner1, inner2)
+        }
+    }
+}
+
+pub fn evaluate(program: &ast::Program) {
+    let mut symbol_table: HashMap<String, Rc<Value>> = HashMap::new();
+
+    for statement in program {
+        match statement {
+            ast::Statement::Definition { symbol, expression } => {
+                println!("[runtime] defining symbol: {:#?}", symbol);
+                let value = evaluate_expr(&symbol_table, expression);
+                symbol_table.insert(symbol.clone(), value);
+            }
+            ast::Statement::Expression(expression) => {
+                println!("[runtime] evaluating free-standing expression");
+                let value = evaluate_expr(&symbol_table, expression);
+                println!("Result: {}", value);
+            }
+        }
+    }
+
+    println!(
+        "[runtime] evaluation done, symbol_table state dump: {:#?}",
+        symbol_table
+    );
+}