flesh/src/eval.rs

/* 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::rc::Rc;
use std::cell::RefCell;
use crate::segment::{Ast, Ctr};
use crate::func::{FTable, func_call};
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(
    ast: Ast,
    vars: Rc<RefCell<VTable>>,
    funcs: Rc<RefCell<FTable>>,
    sym_loose: bool
) -> Result<Ast, String> {
    eval_inner(ast, vars, funcs, sym_loose, true)
}

fn eval_inner(
    ast: Ast,
    vars: Rc<RefCell<VTable>>,
    funcs: Rc<RefCell<FTable>>,
    sym_loose: bool,
    first_item: bool
) -> Result<Ast, String> {
    /* LOGIC:
     * 1. make new ast
     * 2. call process_ctr on ast.car
     * 3. set new.car to result
     * 4. else call process_ctr on cdr
     *    (set first_item to false)
     *    (and set new.cdr to result)
     * 5. return new ast
     */
    let ret: Ast;
    let mret = ret.clone().borrow_mut();
    let ast_inner = ast.clone().borrow_mut();

    match process_ctr(
        ast_inner.car,
        vars.clone(),
        funcs.clone(),
        sym_loose,
        first_item,
        mret.cdr
    ) {
        Ok(ctr) => {
            mret.car = ctr
        },
        Err(err) => {
            return Err(err)
        }
    }

    match process_ctr(
        ast_inner.cdr,
        vars.clone(),
        funcs.clone(),
        sym_loose,
        false,
        RefCell::new(Rc::clone(Ctr::None))
    ) {
        Ok(ctr) => {
            mret.cdr = ctr
        },
        Err(err) => {
            return Err(err)
        }
    }
}

fn process_ctr(
    ctr: Ctr,
    vars: Rc<RefCell<VTable>>,
    funcs: Rc<RefCell<FTable>>,
    sym_loose: bool,
    first_item: bool,
    rest: Ast
) -> Result<Ctr, String> {
    /* LOGIC:
     *   1. if symbol, unwrap (DEEP COPY)
     *   2. if first_item and symbol, call function?
     *      (else: return var copy)
     *   3. if list return result of eval()
     *   4. finally, return a clone (shallow copy) of datum
     */

    match ctr {
        Ctr::Symbol(token) => {
            let mut tok = token;
            if let Some(s) = vars.borrow().get(token) {

                // is function, or variable alias?
                if first_item {
                    if let Ctr::Symbol(t) = s {
                        if let Some(f) = funcs.borrow().get(t) {
                            tok = t;
                        }
                    }

                // is a basic value.
                } else {
                    return Ok((*s).clone())
                }

            // else call function
            } else if !first_item && !sym_loose {
                return Err("variable not found")
            }

            if first_item {
                if let Some(f) = funcs.borrow().get(tok) {
                    match func_call(f, rest, vars.clone(), funcs.clone()) {
                        Ok(a) => Ok(Ctr::Seg(a.borrow().clone())),
                        Err(s) => Err(s)
                    }
                }
            }
        },
        Ctr::Seg(tree) => {
            match eval(tree, vars, funcs, sym_loose) {
                Ok(ast) => {
                    Ok(ast.borrow())
                },
                Err(e) => {
                    Err(e)
                }
            }
        },
        _ => Ok(ctr.clone())
    }
}