Add var value

- this is actually a constant, so the function parameter case is a bit
  contrived

Author: porcelijn

src/ast.rs

@@ -5,20 +5,25 @@ use crate::token::Tokenizer;
 use std::iter::Peekable;
 
 pub struct Bindings {
-    vars: Vec<String>,
+    vars: Vec<(String, i32)>,
 }
 
 impl Bindings {
     pub fn new() -> Self {
         Self { vars: Vec::new(), }
     }
 
-    pub fn add_var(&mut self, var: &str) {
-        self.vars.push(var.into());
+    pub fn add_var(&mut self, var: &str, value: i32) {
+        self.vars.push((var.into(), value));
     }
 
     fn get_index(&self, var: &str) -> Option<usize> {
-        self.vars.iter().position(|v| v == var)
+        self.vars.iter().position(|(v,_)| v == var)
+    }
+
+    fn get_value(&self, var: &str) -> Option<i32> {
+        let tuple = self.vars.iter().find(|(v,_)| v == var)?;
+        Some(tuple.1)
     }
 }
 
@@ -180,7 +185,7 @@ impl ToWasm for Factor {
             },
             Self::Param(p) => {
                 let mut out = vec![0x20]; // local.get
-                if let Some(index) = bindings.get_index(&p) {
+                if let Some(index) = bindings.get_index(p) {
                     write_leb128(index as i128, &mut out);
                 } else {
                     panic!("Unknown binding for local '{p}'");
@@ -255,24 +260,24 @@ fn test_parse() {
     assert_eq!(compile("variable"), "local.get $variable");
 }
 
-pub fn add_fluff(expr_wat: &str) -> String {
-    let mut wat = r#"
+pub fn generate_wat(expr_wat: &str, bindings: &Bindings) -> String {
+    let mut wat = format!(r#"
         (module
             (import "host" "log" (func $host_log (param i32)))
             (func (export "calc") (result i32)
                 i32.const 123 ;; <-- Closure `param`
                 call $host_log
 
-                i32.const 7 ;; <-- WASM function param `$x`
-                i32.const 9 ;; <-- WASM function param `$yy`
+                i32.const {} ;; <-- WASM function param `$x`
+                i32.const {} ;; <-- WASM function param `$yy`
                 call $eval_expr
                 return)
-    "#.to_string();
+    "#, bindings.get_value("x").unwrap(), bindings.get_value("yy").unwrap());
 
     wat.push_str("(func $eval_expr (param $x i32) (param $yy i32) (result i32)");
     wat.push_str(expr_wat);
     wat.push_str(" return)");
-    wat.push_str(")");
+    wat.push(')');
     wat
 }
 
@@ -365,8 +370,8 @@ pub fn generate_wasm(expr: &impl ToWasm, bindings: &Bindings) -> Vec<u8> {
             0x00, // localdeclcount(0)
             0x41, 0xfb, 0x00, // i32.const 123
             0x10, 0x00, // call function index=0 (host_log)
-            0x41, 0x07, // i32.const 7
-            0x41, 0x09, // i32.const 9
+            0x41, bindings.get_value("x").unwrap() as u8, // i32.const 7
+            0x41, bindings.get_value("yy").unwrap() as u8, // i32.const 9
             0x10, 0x02, // call function index=2 (eval_expr)
             0x0f, // return
             0x0b, // end

src/main.rs

@@ -1,7 +1,7 @@
 mod ast;
 mod token;
 
-use crate::ast::{Expr, add_fluff, Bindings, generate_wasm};
+use crate::ast::{Expr, Bindings, generate_wat, generate_wasm};
 use crate::token::Tokenizer;
 
 use wasmtime::{Caller, Engine, Func, Instance, Module, Result, Store};
@@ -10,9 +10,12 @@ use wasmtime::{Caller, Engine, Func, Instance, Module, Result, Store};
 fn test_eval() {
     fn evaluate(s: &str) -> i32 {
         let expr = Expr::parse(&mut Tokenizer::from_str(s).peekable());
+        let mut bindings = Bindings::new();
+        bindings.add_var("x", 7);
+        bindings.add_var("yy", 9);
         eprintln!("{}", expr.to_wat());
         // eval_wat(&expr).expect("Failed to evaluate")
-        eval_wasm(&expr).expect("Failed to evaluate")
+        eval_wasm(&expr, &bindings).expect("Failed to evaluate")
     }
     assert_eq!(evaluate("1+2+3+4+5+6+7+8+9"), 45);
     assert_eq!(evaluate("1*2*3*4*5*6*7*8*9"), 362880);
@@ -25,9 +28,8 @@ fn test_eval() {
     assert_eq!(evaluate("100/3"), 33);
 }
 
-fn eval_wat(expr: &Expr) -> Result<i32> {
-    let wat = add_fluff(&expr.to_wat()); // wrap raw WAT in Module
-
+fn eval_wat(expr: &Expr, bindings: &Bindings) -> Result<i32> {
+    let wat = generate_wat(&expr.to_wat(), bindings); // wrap raw WAT in Module
     let engine = Engine::default();
     let module = Module::new(&engine, wat)?;
 
@@ -46,11 +48,8 @@ fn eval_wat(expr: &Expr) -> Result<i32> {
     calc.call(&mut store, ())
 }
 
-fn eval_wasm(expr: &Expr) -> Result<i32>{
-    let mut bindings = Bindings::new();
-    bindings.add_var("x");
-    bindings.add_var("yy");
-    let wasm = generate_wasm(expr, &bindings);
+fn eval_wasm(expr: &Expr, bindings: &Bindings) -> Result<i32> {
+    let wasm = generate_wasm(expr, bindings);
     let engine = Engine::default();
     let module = Module::new(&engine, wasm)?;
 
@@ -71,16 +70,19 @@ fn eval_wasm(expr: &Expr) -> Result<i32>{
 
 fn main() -> Result<()> {
     let args = std::env::args();
+    let mut bindings = Bindings::new();
+    bindings.add_var("x", 7);
+    bindings.add_var("yy", 42);
     for arg in args.skip(1) {
         println!();
         println!("Expression:\t{arg}");
         let tokens: Vec<_> = Tokenizer::from_str(&arg).collect();
         println!("Tokenized:\t{tokens:?}");
         let expr = Expr::parse(&mut tokens.into_iter().peekable());
         println!("WASM Text:\t{}", expr.to_wat().replace('\n', "\n\t\t"));
-        let result = eval_wat(&expr)?;
+        let result = eval_wat(&expr, &bindings)?;
         println!("Text result:\t{result}");
-        let result = eval_wasm(&expr)?;
+        let result = eval_wasm(&expr, &bindings)?;
         println!("Binary result:\t{result}");
     }
 

src/token.rs

@@ -31,7 +31,7 @@ impl<'a> Iterator for Tokenizer<'a> {
                 '0'..='9' => {
                     let mut v = c.to_digit(10).unwrap() as i32;
                     while let Some(&c) = self.chars.peek() {
-                        if !('0'..='9').contains(&c) { break; }
+                        if !c.is_ascii_digit() { break; }
                         self.chars.next();
                         v = v * 10 + c.to_digit(10).unwrap() as i32;
                     }
@@ -40,7 +40,7 @@ impl<'a> Iterator for Tokenizer<'a> {
                 'a'..='z' => {
                     let mut v = c.to_string();
                     while let Some(&c) = self.chars.peek() {
-                        if !('a'..='z').contains(&c) { break; }
+                        if !c.is_ascii_lowercase() { break; }
                         self.chars.next();
                         v += &c.to_string();
                     }