amend tests; now support for alternative evaluation

Author: DavidLee18

src/compiler/mod.rs

@@ -115,7 +115,7 @@ pub(crate) fn eval(state: TiState) -> Result<Vec<TiState>, EvalError> {
     res.push(temp.clone());
     step(&mut temp)?;
     do_admin(&mut temp);
-    while !ti_final(&temp) {
+    while !ti_final(&temp)? {
         res.push(temp.clone());
         step(&mut temp)?;
         do_admin(&mut temp);
@@ -126,9 +126,9 @@ pub(crate) fn eval(state: TiState) -> Result<Vec<TiState>, EvalError> {
 
 fn step(state: &mut TiState) -> Result<(), EvalError> {
     let (stack, dump, heap, _, _) = state;
-    println!("Stack: {:?}", stack);
-    println!("Dump: {:?}", dump);
-    println!("{:?}", heap);
+    // println!("Stack: {:?}", stack);
+    // println!("Dump: {:?}", dump);
+    // println!("{:?}", heap);
 
     let last_stack = *stack.last().ok_or(EvalError::EmptyStack)?;
 
@@ -201,14 +201,14 @@ fn prim_step(state: &mut TiState, prim: Primitive) -> Result<(), EvalError> {
                 let Node::Num(n) = arg1 else {
                     stack.pop().ok_or(EvalError::EmptyStack)?;
                     dump.push(stack.clone());
-                    *stack = args;
+                    *stack = vec![args[0]];
                     return Ok(());
                 };
                 let arg2 = heap.lookup(args[1]).map_err(EvalError::Heap)?;
                 let Node::Num(m) = arg2 else {
                     stack.pop().ok_or(EvalError::EmptyStack)?;
                     dump.push(stack.clone());
-                    *stack = args;
+                    *stack = vec![args[1]];
                     return Ok(());
                 };
                 stack.pop().ok_or(EvalError::EmptyStack)?;
@@ -261,16 +261,19 @@ fn sc_step(
     Ok(())
 }
 
-fn ti_final(state: &TiState) -> bool {
+fn ti_final(state: &TiState) -> Result<bool, EvalError> {
     let (stack, dump, heap, _, _) = state;
-    dump.is_empty()
-        && match stack.len() {
-        1 => heap
-            .lookup(stack[0])
-            .map(Node::is_data_node)
-            .unwrap_or(false),
-        0 => panic!("Empty stack!"),
-        _ => false,
+    if !dump.is_empty() {
+        Ok(false)
+    } else {
+        match stack.len() {
+            1 => heap
+                .lookup(stack[0])
+                .map(Node::is_data_node)
+                .map_err(EvalError::Heap),
+            0 => Err(EvalError::EmptyStack),
+            _ => Ok(false),
+        }
     }
 }
 

src/core/mod.rs

@@ -118,7 +118,7 @@ impl Heap<Node> {
         expr: CoreExpr,
         env: &mut ASSOC<Name, Addr>,
     ) -> Result<Addr, HeapError> {
-        println!("env: {:?}", env);
+        // println!("env: {:?}", env);
         match expr {
             CoreExpr::Var(v) => env
                 .iter()
@@ -150,7 +150,7 @@ impl Heap<Node> {
         root_addr: Addr,
         env: &mut ASSOC<Name, Addr>,
     ) -> Result<(), HeapError> {
-        println!("env: {:?}", env);
+        // println!("env: {:?}", env);
         match body {
             CoreExpr::Var(a) => {
                 let a_addr = env

src/lang/mod.rs

@@ -53,7 +53,7 @@ pub const PRELUDE_DEFS: &'static str = "I x = x; K x y = x; K1 x y = y; S f g x
 
 type Token = (u32, String);
 
-fn clex(input: String) -> Vec<Token> {
+pub(crate) fn clex(input: String) -> Vec<Token> {
     let mut tokens: Vec<Token> = Vec::new();
     let mut chars = input.chars();
     let mut c = chars.next();
@@ -125,7 +125,7 @@ fn clex(input: String) -> Vec<Token> {
 
 const TWO_CHAR_OPS: [&'static str; 5] = ["==", "~=", ">=", "<=", "->"];
 
-fn syntax(tokens: Vec<Token>) -> Result<Vec<CoreProgram>, SyntaxError> {
+pub(crate) fn syntax(tokens: Vec<Token>) -> Result<Vec<CoreProgram>, SyntaxError> {
     let ress = parser::program()(tokens)
         .into_iter()
         .filter(|(_, v)| v.is_empty())

src/main.rs

@@ -1,4 +1,5 @@
 use crate::compiler::{Node, ResultError, TiStats};
+use crate::lang::SyntaxError;
 use std::path::PathBuf;
 
 pub mod compiler;
@@ -23,9 +24,8 @@ fn run_file(p: PathBuf) -> Result<Vec<Result<(Vec<Node>, TiStats), ResultError>>
         .collect::<Vec<_>>())
 }
 
-fn run(s: String) -> Result<Vec<Result<(Vec<Node>, TiStats), ResultError>>, ResultError> {
-    let state = lang::parse_raw(s)
-        .map_err(ResultError::Syntax)?
+fn run(s: String) -> Result<Vec<Result<(Vec<Node>, TiStats), ResultError>>, SyntaxError> {
+    let state = lang::parse_raw(s)?
         .into_iter()
         .map(|p| compiler::compile(p).map_err(ResultError::Compile))
         .collect::<Vec<_>>();
@@ -40,10 +40,6 @@ fn run(s: String) -> Result<Vec<Result<(Vec<Node>, TiStats), ResultError>>, Resu
 }
 
 fn main() {
-    let program = String::from(
-        r#"
-    main = 4*5+(2-5)
-    "#,
-    );
+    let program = String::from(r#"main = 4*5+(2-5)"#);
     println!("{:?}", run(program));
 }