README.md

@@ -29,7 +29,6 @@
 - [x] Hash tables
 - [x] Fizzbuzz
 - [ ] Closures
-- [ ] Error handling
 - [ ] Garbage collection
 - [ ] Long strings
 - [ ] Using arrays internally for tables

src/instruction.rs

@@ -1,4 +1,4 @@
-#[derive (Clone, Copy, Debug, PartialEq)]
+#[derive (Debug, PartialEq)]
 pub enum Instruction {
 	Add (u8, u8, u8),
 	AddI (u8, u8, i8),

src/loader.rs

@@ -221,6 +221,8 @@ pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
 {
 	// Ignore things I haven't implemented yet
 	
+	use crate::value::Value;
+	
 	parse_string (rdr)?; // function name
 	parse_int (rdr).unwrap ();    // start line in source code
 	parse_int (rdr).unwrap ();    // last line in source code

src/main.rs

@@ -8,7 +8,7 @@ mod value;
 #[cfg (test)]
 mod tests;
 
-fn main () -> Result <(), state::StepError> {
+fn main () {
 	use state::State;
 	
 	let mut list_bytecode = false;
@@ -64,10 +64,11 @@ fn main () -> Result <(), state::StepError> {
 		vm.debug_print = true;
 	}
 	
+	let max_iters = 2000;
 	let mut in_break = false;
 	let mut last_input = String::new ();
 	
-	loop {
+	for _ in 0..max_iters {
 		if in_break || breakpoints.iter ().any (|bp| vm.at_breakpoint (bp)) {
 			in_break = true;
 			dbg! (&vm.stack);
@@ -85,17 +86,17 @@ fn main () -> Result <(), state::StepError> {
 			
 			match input.as_str ().trim_end () {
 				"c" => in_break = false,
-				"q" => return Ok (()),
+				"q" => return,
 				"registers" => {
 					dbg! (&vm.registers);
 					continue;
 				}
 				"s" => {
-					match vm.step ()? {
+					match vm.step () {
 						None => (),
 						Some (state::StepOutput::ChunkReturned (x)) => {
 							dbg! (x);
-							return Ok (());
+							return;
 						},
 					}
 					continue;
@@ -104,11 +105,11 @@ fn main () -> Result <(), state::StepError> {
 			}
 		}
 		
-		match vm.step ()? {
+		match vm.step () {
 			None => (),
 			Some (state::StepOutput::ChunkReturned (x)) => {
 				dbg! (x);
-				return Ok (());
+				return;
 			},
 		}
 	}

src/state.rs

@@ -59,21 +59,8 @@ pub struct State <'a> {
 	upvalues: &'a [Value],
 }
 
-fn lw_io_write (l: &mut State, num_args: usize) -> usize {
+fn lw_print (l: &mut State) -> i32 {
-	for i in 0..u8::try_from (num_args).unwrap () {
+	for i in 0..u8::try_from (l.get_top ()).unwrap () {
-		match l.reg (i) {
-			Value::Float (x) => print! ("{}", x),
-			Value::Integer (x) => print! ("{}", x),
-			Value::String (x) => print! ("{}", x),
-			_ => panic! ("Can't io.write this value"),
-		}
-	}
-	// TODO: PUC Lua actually returns the file handle here.
-	0
-}
-
-fn lw_print (l: &mut State, num_args: usize) -> usize {
-	for i in 0..u8::try_from (num_args).unwrap () {
 		let input = l.reg (i);
 		
 		if i == 0 {
@@ -88,66 +75,14 @@ fn lw_print (l: &mut State, num_args: usize) -> usize {
 	1
 }
 
-fn lw_sqrt (l: &mut State, num_args: usize) -> usize {
-	assert! (num_args >= 1, "math.sqrt needs 1 argument");
-	let input = l.reg (0).as_float ().unwrap ();
-	let output = input.sqrt ();
-	*l.reg_mut (0) = Value::from (output);
-	1
-}
-
-fn lw_string_format (l: &mut State, num_args: usize) -> usize {
-	assert! (num_args >= 1, "string.format needs at least 1 argument");
-	assert_eq! (l.get_top (), 2, "string.format not fully implemented");
-	let f_string = l.reg (0).as_str ().unwrap ();
-	assert_eq! (f_string, "%0.9f");
-	let num = l.reg (1).as_float ().unwrap ();
-	
-	let output = format! ("{:0.9}", num);
-	
-	*l.reg_mut (0) = Value::from (output);
-	1
-}
-
-fn lw_tonumber (l: &mut State, num_args: usize) -> usize {
-	assert_eq! (num_args, 1, "tonumber only implemented for 1 argument");
-	let output = match l.reg (0) {
-		Value::Float (x) => Value::Float (*x),
-		Value::Integer (x) => Value::Integer (*x),
-		Value::String (x) => {
-			if let Ok (x) = str::parse::<i64> (x) {
-				Value::from (x)
-			}
-			else if let Ok (x) = str::parse::<f64> (x) {
-				Value::from (x)
-			}
-			else {
-				Value::Nil
-			}
-		},
-		_ => Value::Nil,
-	};
-	*l.reg_mut (0) = output;
-	1
-}
-
 pub enum StepOutput {
 	ChunkReturned (Vec <Value>),
 }
 
-#[derive (Debug)]
-pub struct StepError {
-	frame: StackFrame,
-	inst:  Instruction,
-	msg: &'static str,
-}
-
 impl <'a> State <'a> {
 	pub fn new (chunk: &'a Chunk, upvalues: &'a [Value]) -> Self {
 		Self {
-			// TODO: Stack is actually supposed to grow to a limit of
+			registers: vec! [Value::Nil; 16],
-			// idk 10,000. I thought it was fixed at 256.
-			registers: vec! [Value::Nil; 256],
 			top: 0,
 			stack: vec! [
 				StackFrame {
@@ -173,25 +108,9 @@ impl <'a> State <'a> {
 		let arg = args.map (|s| Value::from (s)).enumerate ();
 		let arg = Value::from_iter (arg.map (|(i, v)| (Value::from (i), v)));
 		
-		let io = [
-			("write", Value::RsFunc (lw_io_write)),
-		].into_iter ().map (|(k, v)| (k.to_string (), v));
-		
-		let math = [
-			("sqrt", Value::RsFunc (lw_sqrt)),
-		].into_iter ().map (|(k, v)| (k.to_string (), v));
-		
-		let string = [
-			("format", Value::RsFunc (lw_string_format)),
-		].into_iter ().map (|(k, v)| (k.to_string (), v));
-		
 		let env = [
 			("arg", arg),
-			("io", Value::from_iter (io.into_iter ())),
-			("math", Value::from_iter (math.into_iter ())),
 			("print", Value::RsFunc (lw_print)),
-			("string", Value::from_iter (string.into_iter ())),
-			("tonumber", Value::RsFunc (lw_tonumber)),
 		].into_iter ().map (|(k, v)| (k.to_string (), v));
 		
 		vec! [
@@ -221,17 +140,7 @@ impl <'a> State <'a> {
 		self.top - self.stack.last ().unwrap ().register_offset
 	}
 	
-	fn make_step_error (&self, msg: &'static str, inst: &Instruction) -> StepError
+	pub fn step (&mut self) -> Option <StepOutput> {
-	{
-		StepError {
-			frame: self.stack.last ().unwrap ().clone (),
-			inst: inst.clone (),
-			msg,
-		}
-	}
-	
-	pub fn step (&mut self) -> Result <Option <StepOutput>, StepError> 
-	{
 		let chunk = self.chunk;
 		self.step_count += 1;
 		
@@ -252,10 +161,6 @@ impl <'a> State <'a> {
 		// let r = &mut self.registers [frame.register_offset..];
 		let k = &block.constants;
 		
-		let make_step_error = |msg| {
-			self.make_step_error (msg, instruction)
-		};
-		
 		match instruction {
 			Instruction::Add (a, b, c) => {
 				let v_b = self.reg (*b);
@@ -287,7 +192,7 @@ impl <'a> State <'a> {
 				
 				*self.reg_mut (*a) = x;
 			},
-			Instruction::Call (a, b, c) => {
+			Instruction::Call (a, b, _c) => {
 				let b = usize::from (*b);
 				
 				// Take arguments from registers [a + 1, a + b)
@@ -325,7 +230,7 @@ impl <'a> State <'a> {
 						}
 						
 						// Skip the PC increment at the bottom of the loop
-						return Ok (None);
+						return None;
 					},
 					Value::RsFunc (x) => {
 						let current_frame = self.stack.last ().unwrap ();
@@ -337,30 +242,21 @@ impl <'a> State <'a> {
 						});
 						
 						// No clue what the '1' is doing here
-						let b = if b == 0 {
+						self.top = new_offset + b - 1;
-							self.top - *a as usize
-						}
-						else {
-							b
-						};
 						
 						// Call
-						let num_results = x (self, b - 1);
+						let num_results = x (self);
 						
 						let popped_frame = self.stack.pop ().unwrap ();
 						let offset = popped_frame.register_offset - 1;
 						
 						for i in (offset)..(offset + usize::try_from (num_results).unwrap ()) {
-							self.registers [i] = self.registers [i + 1].take ();
+							self.registers [i] = self.registers [i + 1 + usize::from (*a)].take ();
-						}
-						
-						// Set up top for the next call
-						if *c == 0 {
-							self.top = popped_frame.register_offset - 1 + num_results;
 						}
 					},
 					_ => {
-						Err (make_step_error ("Cannot call value"))?;
+						let stack = &self.stack;
+						panic! ("Cannot call value {a:?}. backtrace: {stack:?}");
 					},
 				}
 			},
@@ -397,9 +293,7 @@ impl <'a> State <'a> {
 				}
 				else {
 					let v_b = v_b.as_float ().unwrap_or_else (|| panic! ("{v_b}"));
-					
+					let v_c = v_c.as_float ().unwrap_or_else (|| panic! ("{v_c}"));
-					let v_c = v_c.as_float ().ok_or_else (|| make_step_error ("C must be a number"))?;
-					
 					Value::from (v_b / v_c)
 				};
 				
@@ -447,9 +341,9 @@ impl <'a> State <'a> {
 			},
 			Instruction::GetField (a, b, c) => {
 				let t = match self.reg (*b) {
-					Value::Nil => Err (make_step_error ("R[B] must not be nil"))?,
+					Value::Nil => panic! ("R[B] must not be nil {}:{}", frame.block_idx, frame.program_counter),
 					Value::Table (t) => t,
-					_ => Err (make_step_error ("R[B] must be a table"))?,
+					_ => panic! ("R[B] must be a table"),
 				};
 				
 				let key = match &k [usize::from (*c)] {
@@ -534,17 +428,11 @@ impl <'a> State <'a> {
 			Instruction::Jmp (s_j) => next_pc += s_j,
 			Instruction::Len (a, b) => {
 				let len = match self.reg (*b) {
-					Value::BogusClosure (_) => Err (make_step_error ("attempt to get length of a function value"))?,
+					Value::String (s) => s.len (),
-					Value::Boolean (_) => Err (make_step_error ("attempt to get length of a boolean value"))?,
+					_ => unimplemented!(),
-					Value::Float (_) => Err (make_step_error ("attempt to get length of a number value"))?,
-					Value::Integer (_) => Err (make_step_error ("attempt to get length of a number value"))?,
-					Value::Nil => Err (make_step_error ("attempt to get length of a nil value"))?,
-					Value::RsFunc (_) => Err (make_step_error ("attempt to get length of a function value"))?,
-					Value::String (s) => s.len ().into (),
-					Value::Table (t) => t.borrow ().length ().into (),
 				};
 				
-				*self.reg_mut (*a) = len;
+				*self.reg_mut (*a) = len.into ();
 			}
 			Instruction::LoadF (a, sbx) => {
 				*self.reg_mut (*a) = Value::Float (*sbx as f64);
@@ -682,18 +570,15 @@ impl <'a> State <'a> {
 					for i in (offset)..(offset - 1 + b) {
 						self.registers [i] = self.registers [i + 1 + a].take ();
 					}
-					
-					self.top = popped_frame.register_offset - 1 + b - 1;
 				}
 				else {
 					// Return from the entire program
-					return Ok (Some (StepOutput::ChunkReturned (self.registers [a..(a + b - 1)].to_vec())));
+					return Some (StepOutput::ChunkReturned (self.registers [a..(a + b - 1)].to_vec()));
 				}
 			},
 			Instruction::Return0 => {
-				let popped_frame = self.stack.pop ().unwrap ();
+				self.stack.pop ();
 				next_pc = self.stack.last ().unwrap ().program_counter;
-				self.top = popped_frame.register_offset - 1 + 0;
 			},
 			Instruction::Return1 (a) => {
 				let a = usize::try_from (*a).unwrap ();
@@ -717,8 +602,6 @@ impl <'a> State <'a> {
 				// Shift output register down
 				let offset = popped_frame.register_offset;
 				self.registers [offset - 1] = self.registers [offset + a].take ();
-				
-				self.top = popped_frame.register_offset - 1 + 1;
 			},
 			Instruction::SetField (a, b, c, k_flag) => {
 				let value = if *k_flag {
@@ -814,10 +697,10 @@ impl <'a> State <'a> {
 				frame.block_idx = closure.idx;
 				
 				// Skip the PC increment
-				return Ok (None);
+				return None;
 			},
-			Instruction::Test (a, k) => {
+			Instruction::Test (a, _k) => {
-				if self.reg (*a).is_truthy() != *k {
+				if self.reg (*a).is_truthy() {
 					next_pc += 1;
 				}
 			},
@@ -844,11 +727,11 @@ impl <'a> State <'a> {
 			frame.program_counter = next_pc;
 		}
 		
-		Ok (None)
+		None
 	}
 	
 	pub fn execute_chunk (&mut self, breakpoints: &[Breakpoint]) 
-	-> Result <Vec <Value>, StepError> {
+	-> Vec <Value> {
 		let max_iters = 2000;
 		
 		for _ in 0..max_iters {
@@ -856,9 +739,9 @@ impl <'a> State <'a> {
 				dbg! (&self);
 			}
 			
-			match self.step ()? {
+			match self.step () {
 				None => (),
-				Some (StepOutput::ChunkReturned (x)) => return Ok (x),
+				Some (StepOutput::ChunkReturned (x)) => return x,
 			}
 		}
 		

src/tests.rs

@@ -25,7 +25,7 @@ fn calculate_hash<T: Hash>(t: &T) -> u64 {
 fn run_chunk (args: &[&str], chunk: &Chunk) -> Vec <Value> {
 	let upvalues = State::upvalues_from_args (args.into_iter ().map (|s| s.to_string ()));
 	let mut vm = State::new (chunk, &upvalues);
-	vm.execute_chunk (&[]).unwrap ()
+	vm.execute_chunk (&[])
 }
 
 /// Takes arguments and Lua bytecode, loads it, runs it,
@@ -120,7 +120,7 @@ fn bools () {
 		
 		let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
 		let mut vm = State::new (&chunk, &upvalues);
-		let actual = vm.execute_chunk (&[]).unwrap ();
+		let actual = vm.execute_chunk (&[]);
 		assert_eq! (actual, expected);
 	}
 }
@@ -176,7 +176,7 @@ fn floats () {
 		let expected: Vec <Value> = expected;
 		let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
 		let mut vm = State::new (&chunk, &upvalues);
-		let actual = vm.execute_chunk (&[]).unwrap ();
+		let actual = vm.execute_chunk (&[]);
 		
 		assert_eq! (actual, expected);
 	}
@@ -198,7 +198,7 @@ fn fma () {
 		let expected: Vec <Value> = expected;
 		let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
 		let mut vm = State::new (&chunk, &upvalues);
-		let actual = vm.execute_chunk (&[]).unwrap ();
+		let actual = vm.execute_chunk (&[]);
 		
 		assert_eq! (actual, expected);
 	}
@@ -368,50 +368,14 @@ fn value_size () {
 	// with 64-bit floats
 	// 
 	// It would be nice if LunarWaveVM is the same or better.
-	// I'm also just checking a bunch of my assumptions about how
+	// There are some exploratory things in this test, too
-	// Rust organizes and sizes different types
 	
 	use std::mem::size_of;
 	
-	{
-		// Make sure that Rx / Box are both pointers that hide the size
-		// of big types
-		
 	assert! (size_of::<Box <()>> () <= 8);
 	assert! (size_of::<std::rc::Rc <()>> () <= 8);
-	}
-	
-	{
-		// Make sure LWVM's Values are 16 bytes or smaller.
-		// Because types are usually aligned to their size, f64s
-		// are supposed to be aligned to 8 bytes. So even an `Option <f64>`
-		// uses 8 bytes to say "Some" or "None".
-		// I could _maybe_ fudge this somehow but it's fine to start with.
 	
 	let sz = size_of::<crate::value::Value> ();
 	let expected = 16;
 	assert! (sz <= expected, "{sz} > {expected}");
-	}
-	
-	{
-		// All these are 8 bytes for the same reason Value is 16 bytes.
-		// Luckily Rust doesn't seem to stack the 4-byte overhead
-		// of Result and Option.
-		
-		let sz = size_of::<(i32, i32)> ();
-		let expected = 8;
-		assert! (sz == expected, "{sz} != {expected}");
-		
-		let sz = size_of::<Option <i32>> ();
-		let expected = 8;
-		assert! (sz == expected, "{sz} != {expected}");
-		
-		let sz = size_of::<Result <i32, i32>> ();
-		let expected = 8;
-		assert! (sz == expected, "{sz} != {expected}");
-		
-		let sz = size_of::<Result <Option <i32>, i32>> ();
-		let expected = 8;
-		assert! (sz == expected, "{sz} != {expected}");
-	}
 }

src/value.rs

@@ -26,7 +26,7 @@ pub enum Value {
 	Float (f64),
 	
 	Integer (i64),
-	RsFunc (fn (&mut crate::state::State, usize) -> usize),
+	RsFunc (fn (&mut crate::state::State) -> i32),
 	String (Rc <String>),
 	Table (Rc <RefCell <Table>>),
 	
@@ -207,13 +207,6 @@ impl Value {
 		}
 	}
 	
-	pub fn as_str (&self) -> Option <&str> {
-		match self {
-			Self::String (x) => Some (x.as_str ()),
-			_ => None,
-		}
-	}
-	
 	pub fn as_table (&self) -> Option <&Rc <RefCell <Table>>> {
 		match self {
 			Self::Table (t) => Some (t),
@@ -272,15 +265,6 @@ impl Table {
 	) {
 		self.insert_inner (a.into (), b.into ())
 	}
-	
-	pub fn length (&self) -> i64 {
-		for i in 1..i64::MAX {
-			if self.get (i) == Value::Nil {
-				return i - 1;
-			}
-		}
-		0
-	}
 }
 
 impl FromIterator <(Value, Value)> for Table {

test_vectors/n_body_new_stuff.lua

@@ -1,7 +0,0 @@
-print ()
-print ("asdf")
-print (math.sqrt (16))
-print (math.sqrt (16.0))
-
-local N = tonumber (arg and arg [1]) or 1000
-print (N)