reactor
/
lunar_wave
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: reactor:57486f7a65b2aae06ee7f38dfe05e8ff253f3ca4
Branches Tags
reactor:main
..
compare: reactor:b639d02027358b130efa952ae76d05e5ac7f54a8
Branches Tags
reactor:main

No commits in common. "57486f7a65b2aae06ee7f38dfe05e8ff253f3ca4" and "b639d02027358b130efa952ae76d05e5ac7f54a8" have entirely different histories.
57486f7a65 ... b639d02027

7 changed files with 483 additions and 712 deletions
Show Stats Expand all files Collapse all files

18
src/loader.rs
View File

@ -251,25 +251,19 @@ pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
}
let upvalue_count = parse_int (rdr).unwrap () as usize;
let mut upvalues = Vec::with_capacity (upvalue_count);
for _ in 0..upvalue_count {
let in_stack = parse_byte (rdr).unwrap () == 1;
let idx = parse_byte (rdr).unwrap ();
let kind = parse_byte (rdr).unwrap ();
// Just ignore these
let upvalue = crate::state::Upvalue {
in_stack,
idx,
kind,
};
upvalues.push (upvalue);
for _ in 0..3 {
parse_byte (rdr).unwrap ();
}
}
blocks.push (Block {
constants,
instructions,
upvalues,
upvalue_count,
});
// Recursion

74
src/main.rs
View File

@ -14,24 +14,12 @@ fn main () {
let mut list_bytecode = false;
let mut pipe_bytecode = false;
let mut script = None;
let mut breakpoints = vec![];
let mut args = std::env::args ();
let exe_name = args.next ().unwrap ();
while let Some (arg) = args.next () {
match arg.as_str () {
"--break" => {
let s = args.next ().unwrap ();
let (block_idx, program_counter) = s.split_once (":").unwrap ();
let block_idx = str::parse (block_idx).unwrap ();
let program_counter = str::parse (program_counter).unwrap ();
breakpoints.push (state::Breakpoint {
block_idx,
program_counter,
});
},
"--list-bytecode" => list_bytecode = true,
"--pipe-bytecode" => pipe_bytecode = true,
"--script" => script = Some (args.next ().unwrap ()),
@ -57,63 +45,17 @@ fn main () {
dbg! (&chunk);
}
let upvalues = State::upvalues_from_args ([exe_name].into_iter ().chain (args));
let mut vm = State::new (&chunk, &upvalues);
if std::env::var("LWVM_DEBUG").is_ok() {
let mut vm = State::default ();
if std::env::var("LUA_DEBUG").is_ok() {
vm.debug_print = true;
}
let max_iters = 2000;
let mut in_break = false;
let mut last_input = String::new ();
let upvalues = State::upvalues_from_args ([exe_name].into_iter ().chain (args));
for _ in 0..max_iters {
if in_break || breakpoints.iter ().any (|bp| vm.at_breakpoint (bp)) {
in_break = true;
dbg! (&vm.stack);
vm.breakpoints.push (state::Breakpoint {
block_idx: 3,
program_counter: 0,
});
let mut input = Default::default ();
std::io::stdin ().read_line (&mut input).unwrap ();
let input = if input == "" {
&last_input
}
else {
last_input = input;
&last_input
};
match input.as_str ().trim_end () {
"c" => in_break = false,
"q" => return,
"registers" => {
dbg! (&vm.registers);
continue;
}
"s" => {
match vm.step () {
None => (),
Some (state::StepOutput::ChunkReturned (x)) => {
dbg! (x);
return;
},
}
continue;
},
x => { dbg! (x); },
}
}
match vm.step () {
None => (),
Some (state::StepOutput::ChunkReturned (x)) => {
dbg! (x);
return;
},
}
}
dbg! (vm);
panic! ("Hit max iterations before block returned");
vm.execute_chunk (&chunk, &upvalues);
}

238
src/state.rs
View File

@ -8,18 +8,11 @@ use crate::{
},
};
#[derive (Debug)]
pub struct Upvalue {
pub in_stack: bool,
pub idx: u8,
pub kind: u8,
}
#[derive (Debug)]
pub struct Block {
pub instructions: Vec <Instruction>,
pub constants: Vec <Value>,
pub upvalues: Vec <Upvalue>,
pub upvalue_count: usize,
}
#[derive (Debug)]
@ -28,7 +21,7 @@ pub struct Chunk {
}
#[derive (Clone, Debug)]
pub struct StackFrame {
struct StackFrame {
// i32 makes it a little easier to implement jumps
// Starts at 0 right after OP_CALL
@ -47,16 +40,34 @@ pub struct Breakpoint {
}
#[derive (Debug)]
pub struct State <'a> {
pub registers: Vec <Value>,
pub struct State {
registers: Vec <Value>,
// Currently only used for native function calls
top: usize,
pub stack: Vec <StackFrame>,
stack: Vec <StackFrame>,
pub debug_print: bool,
pub breakpoints: Vec <Breakpoint>,
step_count: u32,
chunk: &'a Chunk,
upvalues: &'a [Value],
}
impl Default for State {
fn default () -> Self {
Self {
registers: vec! [Value::Nil; 16],
top: 0,
stack: vec! [
StackFrame {
program_counter: 0,
block_idx: 0,
register_offset: 0,
},
],
debug_print: false,
breakpoints: Default::default(),
step_count: 0,
}
}
}
fn lw_print (l: &mut State) -> i32 {
@ -75,34 +86,7 @@ fn lw_print (l: &mut State) -> i32 {
1
}
pub enum StepOutput {
ChunkReturned (Vec <Value>),
}
impl <'a> State <'a> {
pub fn new (chunk: &'a Chunk, upvalues: &'a [Value]) -> Self {
Self {
registers: vec! [Value::Nil; 16],
top: 0,
stack: vec! [
StackFrame {
program_counter: 0,
block_idx: 0,
register_offset: 0,
},
],
debug_print: false,
step_count: 0,
chunk,
upvalues,
}
}
pub fn at_breakpoint (&self, bp: &Breakpoint) -> bool {
let frame = self.stack.last ().unwrap ();
frame.block_idx == bp.block_idx && frame.program_counter == bp.program_counter
}
impl State {
pub fn upvalues_from_args <I: Iterator <Item = String>> (args: I) -> Vec <Value>
{
let arg = args.map (|s| Value::from (s)).enumerate ();
@ -140,13 +124,23 @@ impl <'a> State <'a> {
self.top - self.stack.last ().unwrap ().register_offset
}
pub fn step (&mut self) -> Option <StepOutput> {
let chunk = self.chunk;
pub fn execute_chunk (&mut self, chunk: &Chunk, upvalues: &[Value])
-> Vec <Value> {
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");
@ -166,17 +160,15 @@ impl <'a> State <'a> {
let v_b = self.reg (*b);
let v_c = self.reg (*c);
let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ())
let sum = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ())
{
Value::from (v_b + v_c)
}
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}"));
Value::from (v_b + v_c)
Value::from (v_b.as_float ().unwrap () + v_c.as_float ().unwrap ())
};
*self.reg_mut (*a) = x;
*self.reg_mut (*a) = sum;
},
Instruction::Call (a, b, _c) => {
let b = usize::from (*b);
@ -196,7 +188,7 @@ impl <'a> State <'a> {
match v_a {
Value::BogusClosure (rc) => {
let idx = rc.borrow ().idx;
let idx = rc.idx;
let block_idx = frame.block_idx;
let target_block = idx;
@ -216,7 +208,7 @@ impl <'a> State <'a> {
}
// Skip the PC increment at the bottom of the loop
return None;
continue;
},
Value::RsFunc (x) => {
let current_frame = self.stack.last ().unwrap ();
@ -249,25 +241,10 @@ impl <'a> State <'a> {
Instruction::Closure (a, b) => {
let b = usize::try_from (*b).unwrap ();
let idx = frame.block_idx + b + 1;
let block = &chunk.blocks [idx];
let mut new_upvalues = Vec::with_capacity (block.upvalues.len ());
for uv in &block.upvalues {
let val = if uv.in_stack {
self.reg (uv.idx).clone ()
}
else {
// TODO: This isn't really correct
self.upvalues [usize::from (uv.idx)].clone ()
};
new_upvalues.push (val);
}
*self.reg_mut (*a) = Value::from (BogusClosure {
idx,
upvalues: new_upvalues,
});
*self.reg_mut (*a) = Value::BogusClosure (BogusClosure {
idx: b + frame.block_idx + 1,
upvalues: vec! [],
}.into ());
},
Instruction::EqI (a, sb, k_flag) => {
if (self.reg (*a).as_int ().unwrap () == *sb as i64) != *k_flag
@ -340,24 +317,7 @@ impl <'a> State <'a> {
let b = usize::try_from (*b).unwrap ();
let c = usize::try_from (*c).unwrap ();
// If we're inside a closure, use its upvalues
// instead of the chunk's upvalues
let frame = self.stack.last ().unwrap ();
let value = if frame.register_offset == 0 {
self.upvalues.get (b).unwrap ().clone ()
}
else if let Some (cell) = self.registers [frame.register_offset - 1].as_closure ()
{
let closure = cell.borrow ();
let value = closure.upvalues.get (b).unwrap ();
value.clone ()
}
else {
self.upvalues.get (b).unwrap ().clone ()
};
let table = value.as_table ().expect ("GetTabUp only works on tables").borrow ();
let table = upvalues.get (b).unwrap ().as_table ().expect ("GetTabUp only works on tables").borrow ();
let key = match k.get (c).unwrap () {
Value::String (s) => String::from (s.as_ref()),
@ -378,21 +338,14 @@ impl <'a> State <'a> {
},
Instruction::GetUpVal (a, b) => {
let this_func = self.stack.last ().unwrap ().register_offset - 1;
let closure = match &self.registers [this_func] {
Value::BogusClosure (rc) => rc.clone (),
let upvalues = match &self.registers [this_func] {
Value::BogusClosure (rc) => &rc.upvalues,
_ => panic! ("Can't do GetUpVal outside a closure"),
};
let b = usize::try_from (*b).unwrap ();
let upvalue = match closure.borrow ().upvalues.get (b) {
Some (x) => x.clone (),
None => {
dbg! (chunk, &self);
panic! ("Missing upvalue");
}
};
*self.reg_mut (*a) = upvalue;
*self.reg_mut (*a) = upvalues [b].clone ();
},
Instruction::Jmp (s_j) => next_pc += s_j,
Instruction::Len (a, b) => {
@ -444,27 +397,9 @@ impl <'a> State <'a> {
*self.reg_mut (*a) = (b % c).into ();
},
Instruction::Move (a, b) => {
// If the value in b is deleted instead of duplicated,
// a bunch of tests fail
*self.reg_mut (*a) = self.reg (*b).clone ();
},
Instruction::Mul (a, b, c) => {
let v_b = self.reg (*b);
let v_c = self.reg (*c);
let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ())
{
Value::from (v_b * v_c)
}
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}"));
Value::from (v_b * v_c)
};
*self.reg_mut (*a) = x;
},
Instruction::Mul (_a, _b, _c) => unimplemented!(),
Instruction::NewTable (a) => {
*self.reg_mut (*a) = Value::Table (Default::default ());
},
@ -477,25 +412,24 @@ impl <'a> State <'a> {
let popped_frame = self.stack.pop ().unwrap ();
// Build closure if needed. No point building if we're
// popping the last frame and exiting the program.
// Build closure if needed
if *k {
if *k && ! self.stack.is_empty () {
let closure_idx = match &self.registers [popped_frame.register_offset + a] {
Value::BogusClosure (rc) => rc.borrow ().idx,
Value::BogusClosure (rc) => rc.idx,
_ => panic! ("Impossible"),
};
let upvalue_count = chunk.blocks [closure_idx].upvalues.len ();
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::from (BogusClosure {
self.registers [a + popped_frame.register_offset] = Value::BogusClosure (BogusClosure {
idx: closure_idx,
upvalues,
});
}.into ());
}
if self.debug_print {
@ -523,13 +457,10 @@ impl <'a> State <'a> {
}
else {
// Return from the entire program
return Some (StepOutput::ChunkReturned (self.registers [a..(a + b - 1)].to_vec()));
return self.registers [a..(a + b - 1)].to_vec();
}
},
Instruction::Return0 => {
self.stack.pop ();
next_pc = self.stack.last ().unwrap ().program_counter;
},
Instruction::Return0 => unimplemented! (),
Instruction::Return1 (a) => {
let a = usize::try_from (*a).unwrap ();
let popped_frame = self.stack.pop ().unwrap ();
@ -603,36 +534,7 @@ impl <'a> State <'a> {
}
},
Instruction::SetTabUp (_a, _b, _c) => unimplemented! (),
Instruction::TailCall (a, b, _c, k) => {
assert! (!k, "closing over values in tail calls not implemented");
// Shift closure and inputs into place
let a = usize::from (*a);
let b = usize::from (*b);
let offset = frame.register_offset - 1;
for i in (offset)..(offset + b) {
self.registers [i] = self.registers [i + a + 1].take ();
}
let value = &self.registers [offset];
let closure = if let Some (x) = value.as_closure () {
x
}
else {
dbg! (self);
panic! ("OP_TAILCALL only implemented for closures");
};
let closure = closure.borrow ();
// Jump into the other function
let frame = self.stack.last_mut ().unwrap ();
frame.program_counter = 0;
frame.block_idx = closure.idx;
// Skip the PC increment
return None;
},
Instruction::TailCall (_a, _b, _c, _k) => unimplemented! (),
Instruction::Test (a, _k) => {
if self.reg (*a).is_truthy() {
next_pc += 1;
@ -646,26 +548,8 @@ impl <'a> State <'a> {
let frame = self.stack.last_mut ().unwrap ();
frame.program_counter = next_pc;
}
None
}
pub fn execute_chunk (&mut self, breakpoints: &[Breakpoint])
-> Vec <Value> {
let max_iters = 2000;
for _ in 0..max_iters {
if breakpoints.iter ().any (|bp| self.at_breakpoint (bp)) {
dbg! (&self);
}
match self.step () {
None => (),
Some (StepOutput::ChunkReturned (x)) => return x,
}
}
dbg! (self);
panic! ("Hit max iterations before block returned");
}
}

33
src/tests.rs
View File

@ -23,9 +23,9 @@ fn calculate_hash<T: Hash>(t: &T) -> u64 {
/// and returns the output
fn run_chunk (args: &[&str], chunk: &Chunk) -> Vec <Value> {
let mut vm = State::default ();
let upvalues = State::upvalues_from_args (args.into_iter ().map (|s| s.to_string ()));
let mut vm = State::new (chunk, &upvalues);
vm.execute_chunk (&[])
vm.execute_chunk (chunk, &upvalues)
}
/// Takes arguments and Lua bytecode, loads it, runs it,
@ -93,7 +93,7 @@ fn bools () {
"arg".into (),
"print".into (),
],
upvalues: vec! [],
upvalue_count: 1,
},
Block {
instructions: vec! [
@ -107,7 +107,7 @@ fn bools () {
Inst::Return0,
],
constants: vec! [],
upvalues: vec! [],
upvalue_count: 0,
},
],
};
@ -118,9 +118,10 @@ fn bools () {
] {
let expected: Vec <Value> = expected;
let mut vm = State::default ();
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 (&[]);
let actual = vm.execute_chunk (&chunk, &upvalues);
assert_eq! (actual, expected);
}
}
@ -163,7 +164,7 @@ fn floats () {
0.5.into (),
"print".into (),
],
upvalues: vec! [],
upvalue_count: 1,
};
let chunk = Chunk {
blocks: vec! [block],
@ -174,9 +175,9 @@ fn floats () {
(vec! ["_exe_name", " "], vec! [3.5.into ()]),
] {
let expected: Vec <Value> = expected;
let mut vm = State::default ();
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 (&[]);
let actual = vm.execute_chunk (&chunk, &upvalues);
assert_eq! (actual, expected);
}
@ -184,21 +185,19 @@ fn floats () {
#[test]
fn fma () {
let source = include_bytes! ("../test_vectors/fma.lua");
let bytecode = &crate::loader::compile_bytecode_from_stdin (source.to_vec ());
let chunk = crate::loader::parse_chunk_from_bytes (bytecode).unwrap ();
assert_eq! (chunk.blocks.len (), 5);
assert_eq! (chunk.blocks [3].upvalues.len (), 2);
let bytecode = include_bytes! ("../test_vectors/fma.luac");
let mut rdr = std::io::Cursor::new (bytecode);
let file = crate::loader::parse_chunk (&mut rdr).unwrap ();
assert_eq! (file.blocks.len (), 4);
for (arg, expected) in [
(vec! ["_exe_name"], vec! [122.into ()]),
(vec! ["_exe_name"], vec! [122.into ()]),
] {
let expected: Vec <Value> = expected;
let mut vm = State::default ();
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 (&[]);
let actual = vm.execute_chunk (&file, &upvalues);
assert_eq! (actual, expected);
}

47
src/value.rs
View File

@ -11,12 +11,11 @@ use std::{
#[derive (Debug, Eq, PartialEq)]
pub struct BogusClosure {
// I'm pretty sure this should be absolute?
pub idx: usize,
pub upvalues: Vec <Value>,
}
#[derive (Clone, PartialEq)]
#[derive (Clone, Debug, PartialEq)]
pub enum Value {
Nil,
Boolean (bool),
@ -33,24 +32,7 @@ pub enum Value {
// These are all bogus, I haven't figured out how to implement
// closures yet
BogusClosure (Rc <RefCell <BogusClosure>>),
}
impl fmt::Debug for Value {
fn fmt (&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Value::Nil => write! (f, "nil"),
Value::Boolean (false) => write! (f, "false"),
Value::Boolean (true) => write! (f, "true"),
Value::Float (x) => write! (f, "{:?}", x),
Value::Integer (x) => write! (f, "{}", x),
Value::RsFunc (x) => write! (f, "function: {:?}", x),
Value::String (s) => write! (f, "\"{}\"", s),
Value::Table (t) => write! (f, "{:?}", t.borrow ()),
Value::BogusClosure (x) => write! (f, "{:?}", x.borrow ()),
}
}
BogusClosure (Rc <BogusClosure>),
}
impl Default for Value {
@ -71,17 +53,11 @@ impl fmt::Display for Value {
Value::String (s) => write! (f, "{}", s),
Value::Table (t) => write! (f, "table: {:?}", std::rc::Rc::as_ptr (t)),
Value::BogusClosure (x) => write! (f, "BogusClosure: {:?}", std::rc::Rc::as_ptr (x)),
Value::BogusClosure (_) => write! (f, "BogusClosure"),
}
}
}
impl From <BogusClosure> for Value {
fn from (x: BogusClosure) -> Self {
Self::BogusClosure (Rc::new (RefCell::new (x)))
}
}
impl From <bool> for Value {
fn from (x: bool) -> Self {
Self::Boolean (x)
@ -180,13 +156,6 @@ impl PartialEq <i64> for Value {
}
impl Value {
pub fn as_closure (&self) -> Option <&Rc <RefCell <BogusClosure>>> {
match self {
Self::BogusClosure (x) => Some (x),
_ => None,
}
}
/// Coerces ints to float
pub fn as_float (&self) -> Option <f64> {
@ -231,20 +200,12 @@ impl Value {
}
}
#[derive (Default, Eq, PartialEq)]
#[derive (Debug, Default, Eq, PartialEq)]
pub struct Table {
array: Vec <Value>,
hash: HashMap <Value, Value>,
}
impl fmt::Debug for Table {
fn fmt (&self, f: &mut fmt::Formatter) -> fmt::Result {
write! (f, "Table {:#?}", self.hash)?;
Ok (())
}
}
impl Table {
fn get_inner (&self, key: &Value) -> Value {
self.hash.get (key).cloned ().unwrap_or_default ()

8
test_vectors/closure.lua
View File

@ -1,11 +1,11 @@
local function make_closure (t)
local function make_closure (x)
print (x)
return function (y)
return t.x + y
return x + y
end
end
local f = make_closure ({ x = 11 })
local t = {}
local f = make_closure (11)
local x = f (12)
print (x)
return x

9
test_vectors/fma.lua
View File

@ -1,7 +1,5 @@
-- This one fails :( I haven't implemented closures properly yet.
local ii = "bogus"
local function add (aa, bb)
return aa + bb
end
@ -14,13 +12,6 @@ local function fma (ee, ff, gg)
return add (mul (ee, ff), gg)
end
local function run ()
local hh = fma (10, 11, 12)
print (hh)
return hh
end
local hh = run ()
print (ii)
return hh