Working ish runtime

src/parser/ast.rs

@@ -1,43 +1,43 @@
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Program {
     pub functions: Vec<Function>,
     pub statements: Vec<Statement>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Function {
     pub name: String,
     pub params: Vec<String>,
     pub body: Vec<Statement>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Statement {
     Instruction(Instruction),
     PointerAssign { left: Reg, right: Reg },
     FunctionCall(FunctionCall),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Instruction {
     pub opcode: String,
     pub operands: Vec<Operand>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FunctionCall {
     pub name: String,
     pub args: Vec<Operand>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Operand {
     Reg(Reg),
     Number(i64),
     Pointer(Box<Operand>),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Reg {
     Global(String),
     Local(String),

src/runtime.rs

@@ -0,0 +1,71 @@
+use std::{collections::HashMap, path::Path};
+
+use crate::parser::{self, ast::Statement};
+
+#[derive(Debug, Clone)]
+pub struct Registry {}
+
+pub struct Function {
+    pub registry: Registry,
+    pub body: Vec<Statement>,
+    pub params: Vec<String>,
+}
+
+pub struct Runtime {
+    pub registry: Registry,
+    pub functions: HashMap<String, Function>,
+}
+
+impl Registry {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Runtime {
+    pub fn new() -> Self {
+        Self {
+            registry: Registry::new(),
+            functions: HashMap::new(),
+        }
+    }
+}
+
+impl Runtime {
+    pub fn execute_script(&mut self, path: &Path) {
+        let src = std::fs::read_to_string(path).unwrap();
+
+        let ast = parser::parse_program(&src).unwrap();
+
+        for func in ast.functions {
+            self.functions.insert(
+                func.name,
+                Function {
+                    registry: Registry::new(),
+                    body: func.body,
+                    params: func.params,
+                },
+            );
+        }
+    }
+
+    pub fn execute(&mut self, statements: Vec<Statement>, reg: Registry) {
+        for statement in statements {
+            match statement {
+                Statement::Instruction(inst) => {
+                    println!("{inst:#?}");
+                }
+                _ => {}
+            }
+        }
+    }
+
+    pub fn call_function(&mut self, fn_name: &str, params: Vec<u8>) {
+        let f = self
+            .functions
+            .get(fn_name)
+            .expect("Function does not exist");
+
+        self.execute(f.body.clone(), f.registry.clone());
+    }
+}