From f0ce1743e702696749dc28f83d3e99a6ca104391 Mon Sep 17 00:00:00 2001
From: Andrew Morris <voltrevo@gmail.com>
Date: Wed, 24 May 2023 15:53:47 +1000
Subject: [PATCH] Integrate step limit into run() instead of separate method

---
 valuescript_program_embed/src/main.rs |  1 +
 valuescript_vm/src/virtual_machine.rs | 57 ++++++++++-----------------
 valuescript_wasm/src/lib.rs           |  2 +-
 vstc/src/run_command.rs               |  8 +++-
 vstc/src/test_inputs.rs               |  2 +-
 5 files changed, 31 insertions(+), 39 deletions(-)

diff --git a/valuescript_program_embed/src/main.rs b/valuescript_program_embed/src/main.rs
index 07972f7..ac21753 100644
--- a/valuescript_program_embed/src/main.rs
+++ b/valuescript_program_embed/src/main.rs
@@ -47,6 +47,7 @@ pub fn main() {
       0x0e, 0x07, 0x0e, 0x03, 0x06, 0x01, 0x09, 0x0e, 0x04, 0x0e, 0x05, 0x0e, 0x06, 0x00, 0x00,
       0x00, 0x0b, 0x05, 0x02, 0x04, 0x0e, 0x02, 0x0e, 0x03, 0x00, 0x00,
     ]),
+    None,
     &[],
   );
 
diff --git a/valuescript_vm/src/virtual_machine.rs b/valuescript_vm/src/virtual_machine.rs
index 78cb080..22caced 100644
--- a/valuescript_vm/src/virtual_machine.rs
+++ b/valuescript_vm/src/virtual_machine.rs
@@ -15,37 +15,11 @@ pub struct VirtualMachine {
 }
 
 impl VirtualMachine {
-  pub fn run(&mut self, bytecode: &Rc<Vec<u8>>, params: &[String]) -> Result<Val, Val> {
-    let mut bd = BytecodeDecoder {
-      data: bytecode.clone(),
-      pos: 0,
-    };
-
-    let main_fn = bd.decode_val(&Vec::new());
-
-    let mut frame = match main_fn.load_function() {
-      LoadFunctionResult::StackFrame(f) => f,
-      _ => panic!("bytecode does start with function"),
-    };
-
-    for p in params {
-      frame.write_param(Val::String(Rc::new(p.clone())));
-    }
-
-    self.push(frame);
-
-    while self.stack.len() > 0 {
-      self.step()?;
-    }
-
-    return Ok(self.frame.get_call_result().return_);
-  }
-
-  pub fn run_with_limit(
+  pub fn run(
     &mut self,
     bytecode: &Rc<Vec<u8>>,
+    step_limit: Option<usize>,
     params: &[Val],
-    step_limit: usize,
   ) -> Result<Val, Val> {
     let mut bd = BytecodeDecoder {
       data: bytecode.clone(),
@@ -65,18 +39,29 @@ impl VirtualMachine {
 
     self.push(frame);
 
-    let mut step_count = 0;
+    match step_limit {
+      Some(step_limit) => {
+        let mut step_count = 0;
 
-    while step_count < step_limit {
-      self.step()?;
-      step_count += 1;
+        while step_count < step_limit {
+          self.step()?;
+          step_count += 1;
 
-      if self.stack.len() == 0 {
-        return Ok(self.frame.get_call_result().return_);
+          if self.stack.len() == 0 {
+            return Ok(self.frame.get_call_result().return_);
+          }
+        }
+
+        error!("step limit reached")
+      }
+      None => {
+        while self.stack.len() > 0 {
+          self.step()?;
+        }
+
+        Ok(self.frame.get_call_result().return_)
       }
     }
-
-    error!("step limit reached")
   }
 
   pub fn new() -> VirtualMachine {
diff --git a/valuescript_wasm/src/lib.rs b/valuescript_wasm/src/lib.rs
index 1ba6fc3..3a70786 100644
--- a/valuescript_wasm/src/lib.rs
+++ b/valuescript_wasm/src/lib.rs
@@ -95,7 +95,7 @@ fn run_to_result(entry_point: &str, read_file: &js_sys::Function, args: &str) ->
     }
   };
 
-  let vm_result = vm.run_with_limit(&bytecode, &val_args, 1000000);
+  let vm_result = vm.run(&bytecode, Some(1000000), &val_args);
 
   RunResult {
     diagnostics: HashMap::default(),
diff --git a/vstc/src/run_command.rs b/vstc/src/run_command.rs
index 88230b4..7ffa2fe 100644
--- a/vstc/src/run_command.rs
+++ b/vstc/src/run_command.rs
@@ -2,6 +2,7 @@ use std::rc::Rc;
 use std::{ffi::OsStr, path::Path, process::exit};
 
 use valuescript_compiler::{assemble, compile, parse_module};
+use valuescript_vm::vs_value::Val;
 use valuescript_vm::VirtualMachine;
 
 use crate::resolve_entry_path::resolve_entry_path;
@@ -38,7 +39,12 @@ pub fn run_command(args: &Vec<String>) {
 
   let mut vm = VirtualMachine::new();
 
-  match vm.run(&bytecode, &args[argpos..]) {
+  let val_args: Vec<Val> = args[argpos..]
+    .iter()
+    .map(|a| Val::String(Rc::new(a.into())))
+    .collect();
+
+  match vm.run(&bytecode, None, &val_args) {
     Ok(result) => {
       println!("{}", result);
     }
diff --git a/vstc/src/test_inputs.rs b/vstc/src/test_inputs.rs
index a615646..72e283f 100644
--- a/vstc/src/test_inputs.rs
+++ b/vstc/src/test_inputs.rs
@@ -83,7 +83,7 @@ mod tests {
 
           let mut vm = VirtualMachine::new();
 
-          let result = vm.run(&bytecode, &[]);
+          let result = vm.run(&bytecode, Some(2_000_000), &[]);
 
           let result_str = match result {
             Ok(val) => val.codify(),