big progress on rewrite

Signed-off-by: Ava Hahn <ava@aidanis.online>

the_rewrite/src/eval.rs

@@ -0,0 +1,139 @@
+/* relish: versatile lisp shell
+ * Copyright (C) 2021 Aidan Hahn
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+use crate::func::FTable;
+use crate::segment::{Seg, Ctr};
+use crate::vars::VTable;
+
+/* iterates over a syntax tree
+ * returns a NEW LIST of values
+ * representing the simplest possible form of the input
+ */
+pub fn eval<'a>(
+    ast: &'a Seg<'a>,
+    vars: &'a mut VTable<'a>,
+    funcs: &'a mut FTable<'a>,
+    sym_loose: bool,
+) -> Result<Box<Ctr<'a>>, String> {
+    let mut ret = Box::new(Ctr::Seg(Seg::new()));
+    let mut iter: &mut Seg;
+    if let Ctr::Seg(ref mut s) = *ret {
+        iter = s;
+    } else {
+        return Err("Critfail: no fuckin clue whats up here".to_string())
+    }
+
+    let mut car = &ast.car;
+
+    // doing an initial variable check here allows us
+    // to find functions passed in as variables
+    if let Ctr::Symbol(tok) = **car {
+        if let Some(val) = vars.get(tok.clone()) {
+            car = &(val.clone());
+        }
+    }
+
+    // another check to detect if we may have a function call
+    if let Ctr::Symbol(ref tok) = **car {
+        match *ast.cdr {
+            Ctr::Seg(ref ast) => {
+                if let Some(func) = funcs.get(tok.clone()) {
+                    return func.func_call(ast, vars, funcs);
+                } else if !sym_loose {
+                    return Err(format!("Couldnt find definition of {}.", tok));
+                }
+            }
+            Ctr::None => {
+                if let Some(func) = funcs.get(tok.clone()) {
+                    return func.func_call(&Seg::new(), vars, funcs);
+                } else if !sym_loose {
+                    return Err(format!("Couldnt find definition of {}.", tok.clone()));
+                }
+            }
+            _ => return Err(format!("Arguments to function not a list!")),
+        }
+    }
+
+    let mut none = false;
+    while !none {
+        match **car {
+            // if LIST: call eval inner on it with first_item=true
+            Ctr::Seg(ref inner) => {
+                match eval(inner, vars, funcs, sym_loose) {
+                    Ok(res) => (*iter).car = res,
+                    Err(e) => return Err(format!("Evaluation error: {}", e)),
+                }
+            }
+
+            // if SYMBOL: unwrap naively
+            Ctr::Symbol(ref tok) => {
+                if let Some(val) = vars.get(tok.clone()) {
+                    iter.car = val.clone();
+                } else if sym_loose {
+                    iter.car = car.clone()
+                } else {
+                    return Err(format!("Undefined variable: {}", tok.clone()));
+                }
+            }
+
+            // if OTHER: clone and set
+            _ => {
+                iter.car = car.clone();
+            }
+        }
+
+        match *ast.cdr {
+            // if SYMBOL: unwrap naively, then end
+            Ctr::Symbol(ref tok) => {
+                if let Some(val) = vars.get(tok.clone()) {
+                    iter.cdr = val.clone();
+                } else if sym_loose {
+                    iter.cdr = ast.cdr.clone()
+                } else {
+                    return Err(format!("Undefined variable: {}", tok.clone()));
+                }
+
+                none = true;
+            }
+
+            // if LIST:
+            //    - iter.cdr = new_ast(None, None)
+            //    - iter = iter.cdr
+            //    - car = cdr.car
+            //    - cdr = cdr.cdr
+            //    - LOOP
+            Ctr::Seg(next) => {
+                iter.cdr = Box::new(Ctr::Seg(Seg::new()));
+                ast = &next;
+            }
+
+            // if OTHER: clone and set, and then end
+            _ => {
+                iter.cdr = ast.cdr.clone();
+                none = true;
+            }
+        }
+
+        if let Ctr::None = **car {
+            if let Ctr::None = *ast.cdr {
+                none = true;
+            }
+        }
+    }
+
+    return Ok(ret);
+}