Feat: Optimize VM with template memoization, scope chain, version table, and error handling.

Author: dylan-sutton-chavez

.github/workflows/wasm.yml

@@ -30,6 +30,9 @@ jobs:
       - name: Unused Code
         run: cargo shear && cargo clippy --lib --target wasm32-unknown-unknown --features wasm
 
+      - name: Test
+        run: cargo test --features wasm-tests
+
       - name: Install WASM Tools
         run: cargo install twiggy
 

compiler/Cargo.toml

@@ -43,4 +43,5 @@ panic = "abort"
 strip = true
 
 [features]
-wasm = ["lol_alloc"]
+wasm = ["lol_alloc"]
+wasm-tests = []

compiler/src/lib.rs

@@ -1,20 +1,21 @@
 #![cfg_attr(target_arch = "wasm32", no_std)] // Enables no_std only for WASM builds.
-
+ 
 extern crate alloc; // Enables heap allocation without the standard library.
-
+ 
 /* 
 Webassembly architecture entry point.
 */
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(target_arch = "wasm32", test))]
 pub mod wasm;
 
 /*
 Internal modules accessed through all the package.
 */
-
+ 
 pub mod modules {
     pub mod lexer;
     pub mod parser;
     pub mod vm;
-}
+}
+ 

compiler/src/main.rs

@@ -1,20 +1,20 @@
-use compiler_lib::modules::{lexer::lexer, parser::Parser, vm::VM};
+use compiler_lib::modules::{lexer::lexer, parser::Parser, vm::{VM, Limits}};
 use std::{env, fs, process::exit};
 use log::{debug, info, error};
 
-fn parse_args() -> (String, usize, bool) {
+fn parse_args() -> (String, usize, bool, bool) {
     let args: Vec<_> = env::args().skip(1).collect();
-    if args.is_empty() || args.contains(&"-h".into()) { 
-        println!("usage: edge [-d] [-dd] [-q] <file>"); exit(0) 
+    if args.is_empty() || args.contains(&"-h".into()) {
+        println!("usage: edge [-d] [-dd] [-q] [--sandbox] <file>"); exit(0)
     }
     let p = args.iter().find(|&a| !a.starts_with('-')).cloned().unwrap_or_else(|| {
         eprintln!("abort: execution failed because no input target was specified"); exit(1)
     });
     let v = args.iter().filter(|&a| a == "-d").count() + (args.iter().filter(|&a| a == "-dd").count() * 2);
-    (p, if v > 0 { v + 2 } else { 0 }, args.contains(&"-q".into()))
+    (p, if v > 0 { v + 2 } else { 0 }, args.contains(&"-q".into()), args.contains(&"--sandbox".into()))
 }
 
-fn run(path: &str, v: usize, q: bool) -> Result<(), Box<dyn std::error::Error>> {
+fn run(path: &str, v: usize, q: bool, sandbox: bool) -> Result<(), Box<dyn std::error::Error>> {
     stderrlog::new().module(module_path!()).verbosity(v).quiet(q).init().ok();
 
     let src = fs::read_to_string(path).map_err(|e| format!("io: cannot access '{}' because {}", path, e))?;
@@ -29,9 +29,10 @@ fn run(path: &str, v: usize, q: bool) -> Result<(), Box<dyn std::error::Error>>
 
     info!("emit: snapshot created [ops={} consts={}]", chunk.instructions.len(), chunk.constants.len());
 
-    let mut vm = VM::new(&chunk);
+    let limits = if sandbox { Limits::sandbox() } else { Limits::none() };
+    let mut vm = VM::with_limits(&chunk, limits);
     vm.run().map_err(|e| format!("trap: cpu-stop triggered by '{}' (illegal operation in main thread)", e))?;
-    
+
     vm.output.iter().for_each(|l| println!("{l}"));
 
     let (sp, tot) = vm.cache_stats();
@@ -40,9 +41,9 @@ fn run(path: &str, v: usize, q: bool) -> Result<(), Box<dyn std::error::Error>>
 }
 
 fn main() {
-    let (p, v, q) = parse_args();
-    if let Err(e) = run(&p, v, q) { 
-        error!("process terminated: {}", e); 
-        exit(1) 
+    let (p, v, q, sandbox) = parse_args();
+    if let Err(e) = run(&p, v, q, sandbox) {
+        error!("process terminated: {}", e);
+        exit(1)
     }
 }