mark core as nostd

* implement custom hashmap to back symtable
* pass in print and read callbacks to keep stdlib pure
* use core / alloc versions of Box, Rc, Vec, etc
* replace pow func with libm

Signed-off-by: Ava Affine <ava@sunnypup.io>

core/src/stl/append.rs

@@ -18,7 +18,10 @@
 use crate::segment::{Ctr, Seg, Type};
 use crate::sym::{SymTable, Symbol, Args, ValueType};
 use crate::error::{Traceback, start_trace};
-use std::rc::Rc;
+use alloc::rc::Rc;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+
 
 const CONS_DOCSTRING: &str = "traverses any number of arguments collecting them into a list.
 If the first argument is a list, all other arguments are added sequentially to the end of the list contained in the first argument.";

core/src/stl/boolean.rs

@@ -18,7 +18,9 @@
 use crate::segment::{Ctr, Seg, Type};
 use crate::error::{Traceback, start_trace};
 use crate::sym::{SymTable, ValueType, Args, Symbol};
-use std::rc::Rc;
+use alloc::rc::Rc;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
 
 const AND_DOCSTRING: &str =
     "traverses a list of N arguments, all of which are expected to be boolean.

core/src/stl/control.rs

@@ -19,8 +19,9 @@ use crate::eval::eval;
 use crate::error::{Traceback, start_trace};
 use crate::segment::{Ctr, Seg, Type};
 use crate::sym::{SymTable, Symbol, ValueType, Args};
-use std::rc::Rc;
-use std::process;
+use alloc::rc::Rc;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
 
 const IF_DOCSTRING: &str =
     "accepts three bodies, a condition, an unevaluated consequence, and an alternative consequence.
@@ -397,33 +398,7 @@ fn assert_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
     }
 }
 
-const EXIT_DOCSTRING: &str = "Takes on input: an integer used as an exit code.
-Entire REPL process quits with exit code.";
-fn exit_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
-    if let Ctr::Integer(i) = *ast.car {
-        if i > 2 ^ 32 {
-            panic!("argument to exit too large!")
-        } else {
-            process::exit(i as i32);
-        }
-    } else {
-        panic!("impossible argument to exit")
-    }
-}
-
 pub fn add_control_lib(syms: &mut SymTable) {
-    syms.insert(
-        "exit".to_string(),
-        Symbol {
-            name: String::from("exit"),
-            args: Args::Strict(vec![Type::Integer]),
-            conditional_branches: false,
-            docs: EXIT_DOCSTRING.to_string(),
-            value: ValueType::Internal(Rc::new(exit_callback)),
-            ..Default::default()
-        },
-    );
-
     syms.insert(
         "assert".to_string(),
         Symbol {

core/src/stl/decl.rs

@@ -19,7 +19,9 @@ use crate::eval::eval;
 use crate::error::{Traceback, start_trace};
 use crate::segment::{Ctr, Seg, Type};
 use crate::sym::{SymTable, Symbol, UserFn, ValueType, Args};
-use std::rc::Rc;
+use alloc::rc::Rc;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
 
 const QUOTE_DOCSTRING: &str = "takes a single unevaluated tree and returns it as it is: unevaluated.";
 fn quote_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
@@ -84,7 +86,7 @@ fn eval_callback(ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback> {
 }
 
 const HELP_DOCSTRING: &str = "prints help text for a given symbol. Expects only one argument.";
-fn help_callback(ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback> {
+fn help_callback(ast: &Seg, syms: &mut SymTable, print: fn(&String)) -> Result<Ctr, Traceback> {
     if ast.len() != 1 {
         return Err(start_trace(("help", "expected one input").into()));
     }
@@ -96,7 +98,7 @@ fn help_callback(ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback> {
             } else {
                 args_str = sym.args.to_string();
             }
-            println!(
+            print(&format!(
                 "NAME: {0}\n
 ARGS: {1}\n
 DOCUMENTATION:\n
@@ -104,7 +106,7 @@ DOCUMENTATION:\n
 CURRENT VALUE AND/OR BODY:
 {3}",
                 sym.name, args_str, sym.docs, sym.value
-            );
+            ));
         } else {
             return Err(start_trace(("help", format!("{symbol} is undefined")).into()));
         }
@@ -129,7 +131,7 @@ fn isset_callback(ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback> {
 
 const ENV_DOCSTRING: &str = "takes no arguments
 prints out all available symbols and their associated values";
-fn env_callback(_ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback> {
+fn env_callback(_ast: &Seg, syms: &mut SymTable, print: fn(&String)) -> Result<Ctr, Traceback> {
     let mut functions = vec![];
     let mut variables = vec![];
     for (name, val) in syms.iter() {
@@ -146,13 +148,13 @@ fn env_callback(_ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback> {
         }
     }
 
-    println!("VARIABLES:");
+    print(&String::from("VARIABLES:"));
     for var in variables {
-        println!("{}", var)
+        print(&var)
     }
-    println!("\nFUNCTIONS:");
+    print(&String::from("\nFUNCTIONS:"));
     for func in functions {
-        println!("{}", func);
+        print(&func);
     }
     Ok(Ctr::None)
 }
@@ -414,7 +416,8 @@ pub fn store_callback(ast: &Seg, syms: &mut SymTable) -> Result<Ctr, Traceback>
     }
 }
 
-pub fn add_decl_lib_static(syms: &mut SymTable) {
+pub fn add_decl_lib_static(syms: &mut SymTable, print: fn(&String)) {
+    let help_print = print.clone();
     syms.insert(
         "help".to_string(),
         Symbol {
@@ -422,7 +425,11 @@ pub fn add_decl_lib_static(syms: &mut SymTable) {
             args: Args::Strict(vec![Type::Symbol]),
             conditional_branches: true,
             docs: HELP_DOCSTRING.to_string(),
-            value: ValueType::Internal(Rc::new(help_callback)),
+            value: ValueType::Internal(Rc::new(
+                move |ast: &Seg, syms: &mut SymTable| -> Result<Ctr, Traceback> {
+                    help_callback(ast, syms, help_print)
+                }
+            )),
             ..Default::default()
         },
     );
@@ -511,6 +518,7 @@ pub fn add_decl_lib_static(syms: &mut SymTable) {
         }
     );
 
+    let env_print = print.clone();
     syms.insert(
         "env".to_string(),
         Symbol {
@@ -518,7 +526,11 @@ pub fn add_decl_lib_static(syms: &mut SymTable) {
             args: Args::None,
             conditional_branches: false,
             docs: ENV_DOCSTRING.to_string(),
-            value: ValueType::Internal(Rc::new(env_callback)),
+            value: ValueType::Internal(Rc::new(
+                move |ast: &Seg, syms: &mut SymTable| -> Result<Ctr, Traceback> {
+                    env_callback(ast, syms, env_print)
+                }
+            )),
             ..Default::default()
         },
     );

core/src/stl/math.rs

@@ -18,7 +18,12 @@
 use crate::segment::{Ctr, Seg};
 use crate::sym::{SymTable, ValueType, Symbol, Args};
 use crate::error::{Traceback, start_trace};
-use std::rc::Rc;
+
+use libm::pow;
+
+use alloc::rc::Rc;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
 
 fn isnumeric(arg: &Ctr) -> bool {
     matches!(arg, Ctr::Integer(_) | Ctr::Float(_))
@@ -189,12 +194,7 @@ fn floatcast_callback(ast: &Seg, _: &mut SymTable) -> Result<Ctr, Traceback> {
 
 const EXP_DOCSTRING: &str = "Takes two args, both expected to be numeric.
 Returns the first arg to the power of the second arg.
-Does not handle overflow or underflow.
-
-PANIC CASES:
-- arg1 is a float and arg2 is greater than an int32
-- an integer exceeding the size of a float64 is raised to a float power
-- an integer is rased to the power of another integer exceeding the max size of an unsigned 32bit integer";
+Does not handle overflow or underflow.";
 fn exp_callback(ast: &Seg, _: &mut SymTable) -> Result<Ctr, Traceback> {
     let first = *ast.car.clone();
     if !isnumeric(&first) {
@@ -218,15 +218,15 @@ fn exp_callback(ast: &Seg, _: &mut SymTable) -> Result<Ctr, Traceback> {
 
     match first {
         Ctr::Float(lf) => match second {
-            Ctr::Float(rf) => Ok(Ctr::Float(f64::powf(lf, rf))),
-            Ctr::Integer(ri) => Ok(Ctr::Float(f64::powi(lf, ri as i32))),
+            Ctr::Float(rf) => Ok(Ctr::Float(pow(lf, rf))),
+            Ctr::Integer(ri) => Ok(Ctr::Float(pow(lf as f64, ri as f64))),
             _ => Err(start_trace(
                 ("exp", "not implemented for these input types")
                     .into())),
         },
         Ctr::Integer(li) => match second {
-            Ctr::Float(rf) => Ok(Ctr::Float(f64::powf(li as f64, rf))),
-            Ctr::Integer(ri) => Ok(Ctr::Integer(li.pow(ri as u32))),
+            Ctr::Float(rf) => Ok(Ctr::Float(pow(li as f64, rf))),
+            Ctr::Integer(ri) => Ok(Ctr::Float(pow(li as f64, ri as f64))),
             _ => Err(start_trace(
                 ("exp", "not implemented for these input types")
                     .into())),

core/src/stl/strings.rs

@@ -18,18 +18,19 @@
 use crate::segment::{Ctr, Seg, Type};
 use crate::sym::{SymTable, Symbol, ValueType, Args};
 use crate::error::{Traceback, start_trace};
-use std::io::Write;
-use std::io;
-use std::rc::Rc;
+use alloc::rc::Rc;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+
 
 const ECHO_DOCSTRING: &str =
     "traverses any number of arguments. Prints their evaluated values on a new line for each.";
-fn echo_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
+fn echo_callback(ast: &Seg, _syms: &mut SymTable, print_callback: fn(&String)) -> Result<Ctr, Traceback> {
     ast.circuit(&mut |arg: &Ctr| match arg {
-        Ctr::String(s) => print!("{}", s) == (),
-        _ => print!("{}", arg) == (),
+        Ctr::String(s) => print_callback(s) == (),
+        _ => print_callback(&arg.to_string()) == (),
     });
-    println!();
+    print_callback(&String::from("\n"));
     Ok(Ctr::None)
 }
 
@@ -239,13 +240,15 @@ fn split_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
 const INPUT_DOCSTRING: &str = "Takes one argument (string) and prints it.
 Then prompts for user input.
 User input is returned as a string";
-fn input_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
+fn input_callback(
+    ast: &Seg,
+    _syms: &mut SymTable,
+    print_callback: fn(&String),
+    read_callback: fn() -> String,
+) -> Result<Ctr, Traceback> {
     if let Ctr::String(ref s) = *ast.car {
-        print!("{}", s);
-        let _= io::stdout().flush();
-        let mut input = String::new();
-        io::stdin().read_line(&mut input).expect("couldnt read user input");
-        Ok(Ctr::String(input.trim().to_string()))
+        print_callback(s);
+        Ok(Ctr::String(read_callback()))
     } else {
         Err(start_trace(
             ("input", "expected a string input to prompt user with")
@@ -253,7 +256,8 @@ fn input_callback(ast: &Seg, _syms: &mut SymTable) -> Result<Ctr, Traceback> {
     }
 }
 
-pub fn add_string_lib(syms: &mut SymTable) {
+pub fn add_string_lib(syms: &mut SymTable, print: fn(&String), read: fn() -> String) {
+    let echo_print = print.clone();
     syms.insert(
         "echo".to_string(),
         Symbol {
@@ -261,7 +265,11 @@ pub fn add_string_lib(syms: &mut SymTable) {
             args: Args::Infinite,
             conditional_branches: false,
             docs: ECHO_DOCSTRING.to_string(),
-            value: ValueType::Internal(Rc::new(echo_callback)),
+            value: ValueType::Internal(Rc::new(
+                move |ast: &Seg, syms: &mut SymTable| -> Result<Ctr, Traceback> {
+                    echo_callback(ast, syms, echo_print)
+                }
+            )),
             ..Default::default()
         },
     );
@@ -344,6 +352,8 @@ pub fn add_string_lib(syms: &mut SymTable) {
         },
     );
 
+    let input_print = print.clone();
+    let input_read = read.clone();
     syms.insert(
         "input".to_string(),
         Symbol {
@@ -351,7 +361,11 @@ pub fn add_string_lib(syms: &mut SymTable) {
             args: Args::Strict(vec![Type::String]),
             conditional_branches: false,
             docs: INPUT_DOCSTRING.to_string(),
-            value: ValueType::Internal(Rc::new(input_callback)),
+            value: ValueType::Internal(Rc::new(
+                move |ast: &Seg, syms: &mut SymTable| -> Result<Ctr, Traceback> {
+                    input_callback(ast, syms, input_print, input_read)
+                }
+            )),
             ..Default::default()
         }
     );