use std::{ collections::BTreeMap, rc::Rc, }; #[derive (Debug, PartialEq)] pub enum Instruction { Add (u8, u8, u8), Call (u8, u8, u8), Closure (u8, i32), // Equals Constant? EqK (u8, u8, u8), // Get Immediate? GetI (u8, u8, u8), // Get Table, Upvalue GetTabUp (u8, u8, u8), GetUpVal (u8, u8), // Jump Jmp (i32), // Load F (Float?) LoadF (u8, i32), LoadFalse (u8), // Load Integer? LoadI (u8, i32), // Load Constant LoadK (u8, i32), LoadNil (u8), LoadTrue (u8), // MetaMethod, Binary MmBin (u8, u8, u8), Move (u8, u8), Mul (u8, u8, u8), Not (u8, u8), // (A, B, _C, k) Return B - 1 registers starting with A Return (u8, u8, u8, bool), Return0, // Return just one register Return1 (u8), SetTabUp (u8, u8, u8), TailCall (u8, u8, u8, bool), Test (u8, bool), VarArgPrep (i32), } #[derive (Clone, Debug, PartialEq)] pub struct BogusClosure { idx: usize, upvalues: Vec , } #[derive (Clone, Debug, PartialEq)] pub enum Value { Nil, Boolean (bool), Float (f64), String (Rc ), // These are all bogus, I haven't figured out how to implement // tables and function pointers yet BogusArg (Rc >), BogusClosure (Rc ), BogusEnv (Rc >), BogusPrint, } impl Default for Value { fn default () -> Self { Self::Nil } } impl From for Value { fn from (x: String) -> Self { Self::String (x.into ()) } } impl From <&str> for Value { fn from (x: &str) -> Self { Self::from (String::from (x)) } } impl From for Value { fn from (x: i32) -> Self { Self::Float (f64::try_from (x).unwrap ()) } } impl From for Value { fn from (x: f64) -> Self { Self::Float (x) } } impl Value { fn as_float (&self) -> Option { match self { Self::Float (x) => Some (*x), _ => None, } } fn is_truthy (&self) -> bool { // And this is something Lua does better than JS and Python. match self { Value::Nil => false, Value::Boolean (false) => false, _ => true, } } fn take (&mut self) -> Self { let mut x = Value::Nil; std::mem::swap (self, &mut x); x } } pub struct Block { pub instructions: Vec , pub constants: Vec , pub upvalue_count: usize, } pub struct Chunk { pub blocks: Vec , } #[derive (Clone, Debug)] struct StackFrame { // i32 makes it a little easier to implement jumps // Starts at 0 right after OP_CALL program_counter: i32, // Starts from 0 for main and 1 for the first closure block_idx: usize, register_offset: usize, } #[derive (Debug)] pub struct Breakpoint { pub block_idx: usize, pub program_counter: i32, } #[derive (Debug)] pub struct State { registers: Vec , stack: Vec , pub debug_print: bool, pub breakpoints: Vec , step_count: u32, } impl Default for State { fn default () -> Self { Self { registers: vec! [Value::Nil; 16], stack: vec! [ StackFrame { program_counter: 0, block_idx: 0, register_offset: 0, }, ], debug_print: false, breakpoints: Default::default(), step_count: 0, } } } impl State { pub fn upvalues_from_args > (args: I) -> Vec { let arg: Vec <_> = args.map (|s| s.to_string ()).collect (); let env = BTreeMap::from_iter ([ ("arg", Value::BogusArg (arg.into ())), ("print", Value::BogusPrint), ].map (|(k, v)| (k.to_string (), v))); vec! [ Value::BogusEnv (env.into ()), ] } fn register_window (&self) -> &[Value] { let frame = self.stack.last ().unwrap (); &self.registers [frame.register_offset..] } fn register_window_mut (&mut self) -> &mut [Value] { let frame = self.stack.last_mut ().unwrap (); &mut self.registers [frame.register_offset..] } pub fn execute_chunk (&mut self, chunk: &Chunk, upvalues: &[Value]) -> Vec { let max_iters = 2000; for _ in 0..max_iters { self.step_count += 1; let frame = self.stack.last_mut ().unwrap ().clone (); let block = chunk.blocks.get (frame.block_idx).unwrap (); for bp in &self.breakpoints { if frame.block_idx == bp.block_idx && frame.program_counter == bp.program_counter { dbg! (&self); } } let mut next_pc = frame.program_counter; let pc = usize::try_from (frame.program_counter).expect ("program_counter is not a valid usize"); let instruction = match block.instructions.get (pc) { Some (x) => x, None => { dbg! (&self.stack); panic! ("program_counter went out of bounds"); } }; // let r = &mut self.registers [frame.register_offset..]; let k = &block.constants; match instruction { Instruction::Add (a, b, c) => { let r = self.register_window_mut (); let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let c = usize::try_from (*c).unwrap (); let v_b = r [b].as_float ().unwrap (); let v_c = r [c].as_float ().unwrap (); r [a] = (v_b + v_c).into (); }, Instruction::Call (a, _b, c) => { // Take arguments from registers [a + 1, a + b) // Call the function in register [a] // Return values in registers [a, a + c - 1) // // That is, call a with b - 1 arguments and expect c returns // // e.g. CALL 0 2 1 mean "Call 0 with 1 argument, return 1 value", like for printing a constant // TODO: Only implement printing values for now let a = usize::try_from (*a).unwrap (); let r = self.register_window_mut (); let v_a = r.get (a).unwrap (); match v_a { Value::BogusClosure (rc) => { let idx = rc.idx; let block_idx = frame.block_idx; let target_block = idx; let current_frame = self.stack.last ().unwrap (); self.stack.push (StackFrame { program_counter: 0, block_idx: target_block, register_offset: current_frame.register_offset + a + 1, }); if self.debug_print { println! ("Inst {block_idx}:{pc} calls {target_block}:0"); let stack_depth = self.stack.len (); println! ("stack_depth: {stack_depth}"); } // Skip the PC increment at the bottom of the loop continue; }, Value::BogusPrint => { // In real Lua, print is a function inside // the runtime. Here it's bogus. // assert_eq! (*b, 2); assert_eq! (*c, 1); let value = r.get (a + 1).unwrap (); match value { Value::Nil => println! ("nil"), Value::Boolean (false) => println! ("false"), Value::Boolean (true) => println! ("true"), Value::Float (x) => println! ("{}", x), Value::String (s) => println! ("{}", s), _ => unimplemented! (), }; r [a] = r [a + 1].take (); }, _ => { let stack = &self.stack; panic! ("Cannot call value {a:?}. backtrace: {stack:?}"); }, } }, Instruction::Closure (a, b) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); if self.debug_print { println! ("OP_CLOSURE {a} {b}"); } let r = self.register_window_mut (); r [a] = Value::BogusClosure (BogusClosure { idx: b + frame.block_idx + 1, upvalues: vec! [], }.into ()); }, Instruction::EqK (a, b, c_k) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let r = self.register_window (); let equal = r [a] == k [b]; match (equal, c_k) { (true, 0) => next_pc += 1, (false, 1) => next_pc += 1, _ => (), } }, Instruction::GetTabUp (a, b, c) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let c = usize::try_from (*c).unwrap (); let env = match upvalues.get (b).unwrap () { Value::BogusEnv (x) => x, _ => panic! ("Only allowed upvalue is BogusEnv"), }; let key = match k.get (c).unwrap () { Value::String (s) => s.as_ref (), _ => panic! ("GetTabUp only supports string keys"), }; let value = env.get (key).unwrap (); self.register_window_mut() [a] = value.clone (); }, Instruction::GetI (a, b, c) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let c = usize::try_from (*c).unwrap (); let r = self.register_window_mut (); let table = r.get (b).unwrap (); let value = match table { Value::BogusArg (arg) => arg.get (c).map (|x| x.as_str().into ()).unwrap_or_default(), _ => unimplemented!(), }; r [a] = value; }, Instruction::GetUpVal (a, b) => { let this_func = self.stack.last ().unwrap ().register_offset - 1; let upvalues = match &self.registers [this_func] { Value::BogusClosure (rc) => &rc.upvalues, _ => panic! ("Can't do GetUpVal outside a closure"), }; let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); self.register_window_mut ()[a] = upvalues [b].clone (); }, Instruction::Jmp (s_j) => next_pc += s_j, Instruction::LoadF (a, sbx) => { let a = usize::try_from (*a).unwrap (); self.register_window_mut ()[a] = Value::Float (*sbx as f64); } Instruction::LoadFalse (a) => { let a = usize::try_from (*a).unwrap (); self.register_window_mut ()[a] = Value::Boolean (false); }, Instruction::LoadI (a, sbx) => { let a = usize::try_from (*a).unwrap (); self.register_window_mut ()[a] = (*sbx).into (); }, Instruction::LoadK (a, bx) => { let a = usize::try_from (*a).unwrap (); let bx = usize::try_from (*bx).unwrap (); self.register_window_mut ()[a] = k [bx].clone (); }, Instruction::LoadNil (a) => { let a = usize::try_from (*a).unwrap (); self.register_window_mut ()[a] = Value::Nil; }, Instruction::LoadTrue (a) => { let a = usize::try_from (*a).unwrap (); self.register_window_mut ()[a] = Value::Boolean (true); }, Instruction::MmBin (a, b, _c) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let r = self.register_window(); let a = &r [a]; let b = &r [b]; if a.as_float().is_some() && b.as_float().is_some () { // No need for metamethods } else { panic! ("Not sure how to implememtn OP_MMBIN for these 2 values {a:?}, {b:?}"); } }, Instruction::Move (a, b) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let r = self.register_window_mut(); r [a] = r [b].clone (); }, Instruction::Not (a, b) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let r = self.register_window_mut(); r [a] = Value::Boolean (! r [b].is_truthy()); } Instruction::Return (a, b, c, k) => { let a = usize::try_from (*a).unwrap (); let b = usize::try_from (*b).unwrap (); let _c = usize::try_from (*c).unwrap (); let popped_frame = self.stack.pop ().unwrap (); // Build closure if needed if *k { let closure_idx = match &self.registers [popped_frame.register_offset + a] { Value::BogusClosure (rc) => rc.idx, _ => panic! ("Impossible"), }; let upvalue_count = chunk.blocks [closure_idx].upvalue_count; let start_reg = a + popped_frame.register_offset - upvalue_count; let upvalues = self.registers [start_reg..start_reg+upvalue_count].iter ().cloned ().collect (); self.registers [a + popped_frame.register_offset] = Value::BogusClosure (BogusClosure { idx: closure_idx, upvalues, }.into ()); } if self.debug_print { let old_block = popped_frame.block_idx; let old_pc = popped_frame.program_counter; println! ("Inst {old_block}:{old_pc} returns"); let stack_depth = self.stack.len (); println! ("stack_depth: {stack_depth}"); } if let Some (new_frame) = self.stack.last() { next_pc = new_frame.program_counter; // Shift our output registers down so the caller // can grab them // idk exactly why Lua does this // Register that our function was in before we // called it. let offset = popped_frame.register_offset - 1; for i in (offset)..(offset - 1 + b) { self.registers [i] = self.registers [i + 1 + a].take (); } } else { // Return from the entire program return self.registers [a..(a + b - 1)].to_vec(); } }, Instruction::Return1 (a) => { let a = usize::try_from (*a).unwrap (); let popped_frame = self.stack.pop ().unwrap (); self.registers [popped_frame.register_offset - 1] = self.register_window ()[a].clone (); let frame = self.stack.last ().unwrap (); let new_block = frame.block_idx; next_pc = frame.program_counter; if self.debug_print { let old_block = popped_frame.block_idx; let old_pc = popped_frame.program_counter; println! ("Inst {old_block}:{old_pc} returns to inst {new_block}:{next_pc}"); let stack_depth = self.stack.len (); println! ("stack_depth: {stack_depth}"); } // Shift output register down let offset = popped_frame.register_offset; self.registers [offset - 1] = self.registers [offset + a].take (); }, Instruction::Test (a, _k) => { let a = usize::try_from (*a).unwrap (); let a = self.register_window ().get (a).unwrap (); if self.debug_print { println! ("Test {a:?}"); } if a.is_truthy() { next_pc += 1; } }, Instruction::VarArgPrep (_) => (), x => panic! ("Unimplemented instruction {x:?}"), } next_pc += 1; { let frame = self.stack.last_mut ().unwrap (); frame.program_counter = next_pc; } } panic! ("Hit max iterations before block returned"); } }