Added Function Tables

- Ftable struct
- CallFunction procedure
- Refactors to Cell, Ctr (consequently to lex too)
- More recursive routines in Cell

src/func.rs

@@ -0,0 +1,137 @@
+/* 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 std::boxed::Box;
+use std::collections::HashMap;
+use crate::cell::{Ctr, Cell, Type};
+use crate::vars::{VTable};
+use crate::eval::eval;
+
+// Standardized function signature for stdlib functions
+pub type Operation = fn(Box<Cell>, Box<VTable>, Box<FTable>) -> Box<Cell>;
+pub type FTable = HashMap<String, Function>;
+
+/* Function Args
+ * If Lazy, is an integer denoting number of args
+ * If Strict, is a list of Ctrs (with no wrapped values) denoting arg type.
+ */
+pub enum Args {
+    // signed: -1 denotes infinite args
+    Lazy(i128),
+    Strict(Vec<Type>)
+}
+
+// function which does not need args checked
+pub struct Function {
+    pub function: Operation,
+    pub name: String,
+    pub times_called: u128,
+    pub args: Args,
+
+    // dont fail on undefined symbol (passed to eval)
+    pub loose_syms: bool,
+
+    // dont evaluate args at all. leave that to the function
+    pub eval_lazy: bool
+}
+
+/* call_function
+ * routine is called by eval when a function call is detected
+ * full list of cells considered to be a function call is passed in
+ * (that means that args contains the function symbol in 0 index)
+ */
+pub fn call_function(
+    args: Box<Cell>,
+    func: Function,
+    vars: Box<VTable>,
+    funcs: Box<FTable>
+) -> Result<Box<Cell>, String> {
+    let mut n_args = args;
+    if !func.eval_lazy {
+        match eval(args, vars, funcs, func.loose_syms) {
+            Ok(box_cell) => n_args = box_cell,
+            Err(s) => return Err(
+                format!(
+                    "error evaluating args to {}: {}",
+                    func.name,
+                    s
+                )
+            )
+        }
+    }
+
+    let mut passes = false;
+    match func.args {
+        Args::Lazy(num) => {
+            if num < 0 {
+                passes = true
+            }
+
+            if !(num == (args.len() - 1)) {
+                return Err(format!("expected {} args in call to {}", num, func.name))
+            }
+        },
+
+        Args::Strict(arg_types) => {
+            let idx: usize = 0;
+            passes = args.circuit(|c: Ctr| {
+                if idx >= arg_types.len() {
+                    return false;
+                }
+
+                if let c = Ctr::None {
+                    return false;
+                }
+
+                let ret = arg_types[idx] == c.to_type();
+                if ret {
+                    idx += 1;
+                }
+                return ret;
+            });
+
+            if passes && idx < (arg_types.len() - 1) {
+                Err(format!(
+                    "{} too little arguments in call to {}",
+                    arg_types.len() - (idx + 1),
+                    func.name
+                ));
+            }
+
+            if !passes {
+                if idx < (arg_types.len() - 1) {
+                    Err(format!(
+                        "argument {} in call to {} is of wrong type (expected {})",
+                        idx + 1,
+                        func.name,
+                        arg_types[idx].to_str()
+                    ));
+                }
+
+                if idx == (arg_types.len() - 1) {
+                    Err(format!(
+                        "too many arguments in call to {}",
+                        func.name
+                    ));
+                }
+            }
+        }
+    }
+
+    func.times_called += 1;
+    return Ok((func.function)(args, vars, funcs));
+}