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 upvalue_count = parse_int (rdr).unwrap () as usize;
let mut upvalues = Vec::with_capacity (upvalue_count);
for _ in 0..upvalue_count { for _ in 0..upvalue_count {
let in_stack = parse_byte (rdr).unwrap () == 1; // Just ignore these
let idx = parse_byte (rdr).unwrap ();
let kind = parse_byte (rdr).unwrap ();
let upvalue = crate::state::Upvalue { for _ in 0..3 {
in_stack, parse_byte (rdr).unwrap ();
idx, }
kind,
};
upvalues.push (upvalue);
} }
blocks.push (Block { blocks.push (Block {
constants, constants,
instructions, instructions,
upvalues, upvalue_count,
}); });
// Recursion // Recursion

74
src/main.rs
View File

@ -14,24 +14,12 @@ fn main () {
let mut list_bytecode = false; let mut list_bytecode = false;
let mut pipe_bytecode = false; let mut pipe_bytecode = false;
let mut script = None; let mut script = None;
let mut breakpoints = vec![];
let mut args = std::env::args (); let mut args = std::env::args ();
let exe_name = args.next ().unwrap (); let exe_name = args.next ().unwrap ();
while let Some (arg) = args.next () { while let Some (arg) = args.next () {
match arg.as_str () { 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, "--list-bytecode" => list_bytecode = true,
"--pipe-bytecode" => pipe_bytecode = true, "--pipe-bytecode" => pipe_bytecode = true,
"--script" => script = Some (args.next ().unwrap ()), "--script" => script = Some (args.next ().unwrap ()),
@ -57,63 +45,17 @@ fn main () {
dbg! (&chunk); dbg! (&chunk);
} }
let upvalues = State::upvalues_from_args ([exe_name].into_iter ().chain (args)); let mut vm = State::default ();
if std::env::var("LUA_DEBUG").is_ok() {
let mut vm = State::new (&chunk, &upvalues);
if std::env::var("LWVM_DEBUG").is_ok() {
vm.debug_print = true; vm.debug_print = true;
} }
let max_iters = 2000; let upvalues = State::upvalues_from_args ([exe_name].into_iter ().chain (args));
let mut in_break = false;
let mut last_input = String::new ();
for _ in 0..max_iters { vm.breakpoints.push (state::Breakpoint {
if in_break || breakpoints.iter ().any (|bp| vm.at_breakpoint (bp)) { block_idx: 3,
in_break = true; program_counter: 0,
dbg! (&vm.stack); });
let mut input = Default::default (); vm.execute_chunk (&chunk, &upvalues);
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");
} }

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)] #[derive (Debug)]
pub struct Block { pub struct Block {
pub instructions: Vec <Instruction>, pub instructions: Vec <Instruction>,
pub constants: Vec <Value>, pub constants: Vec <Value>,
pub upvalues: Vec <Upvalue>, pub upvalue_count: usize,
} }
#[derive (Debug)] #[derive (Debug)]
@ -28,7 +21,7 @@ pub struct Chunk {
} }
#[derive (Clone, Debug)] #[derive (Clone, Debug)]
pub struct StackFrame { struct StackFrame {
// i32 makes it a little easier to implement jumps // i32 makes it a little easier to implement jumps
// Starts at 0 right after OP_CALL // Starts at 0 right after OP_CALL
@ -47,16 +40,34 @@ pub struct Breakpoint {
} }
#[derive (Debug)] #[derive (Debug)]
pub struct State <'a> { pub struct State {
pub registers: Vec <Value>, registers: Vec <Value>,
// Currently only used for native function calls // Currently only used for native function calls
top: usize, top: usize,
pub stack: Vec <StackFrame>, stack: Vec <StackFrame>,
pub debug_print: bool, pub debug_print: bool,
pub breakpoints: Vec <Breakpoint>,
step_count: u32, 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 { fn lw_print (l: &mut State) -> i32 {
@ -75,34 +86,7 @@ fn lw_print (l: &mut State) -> i32 {
1 1
} }
pub enum StepOutput { impl State {
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
}
pub fn upvalues_from_args <I: Iterator <Item = String>> (args: I) -> Vec <Value> pub fn upvalues_from_args <I: Iterator <Item = String>> (args: I) -> Vec <Value>
{ {
let arg = args.map (|s| Value::from (s)).enumerate (); 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 self.top - self.stack.last ().unwrap ().register_offset
} }
pub fn step (&mut self) -> Option <StepOutput> { pub fn execute_chunk (&mut self, chunk: &Chunk, upvalues: &[Value])
let chunk = self.chunk; -> Vec <Value> {
let max_iters = 2000;
for _ in 0..max_iters {
self.step_count += 1; self.step_count += 1;
let frame = self.stack.last_mut ().unwrap ().clone (); let frame = self.stack.last_mut ().unwrap ().clone ();
let block = chunk.blocks.get (frame.block_idx).unwrap (); 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 mut next_pc = frame.program_counter;
let pc = usize::try_from (frame.program_counter).expect ("program_counter is not a valid usize"); 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_b = self.reg (*b);
let v_c = self.reg (*c); 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) Value::from (v_b + v_c)
} }
else { else {
let v_b = v_b.as_float ().unwrap_or_else (|| panic! ("{v_b}")); Value::from (v_b.as_float ().unwrap () + v_c.as_float ().unwrap ())
let v_c = v_c.as_float ().unwrap_or_else (|| panic! ("{v_c}"));
Value::from (v_b + v_c)
}; };
*self.reg_mut (*a) = x; *self.reg_mut (*a) = sum;
}, },
Instruction::Call (a, b, _c) => { Instruction::Call (a, b, _c) => {
let b = usize::from (*b); let b = usize::from (*b);
@ -196,7 +188,7 @@ impl <'a> State <'a> {
match v_a { match v_a {
Value::BogusClosure (rc) => { Value::BogusClosure (rc) => {
let idx = rc.borrow ().idx; let idx = rc.idx;
let block_idx = frame.block_idx; let block_idx = frame.block_idx;
let target_block = idx; let target_block = idx;
@ -216,7 +208,7 @@ impl <'a> State <'a> {
} }
// Skip the PC increment at the bottom of the loop // Skip the PC increment at the bottom of the loop
return None; continue;
}, },
Value::RsFunc (x) => { Value::RsFunc (x) => {
let current_frame = self.stack.last ().unwrap (); let current_frame = self.stack.last ().unwrap ();
@ -249,25 +241,10 @@ impl <'a> State <'a> {
Instruction::Closure (a, b) => { Instruction::Closure (a, b) => {
let b = usize::try_from (*b).unwrap (); let b = usize::try_from (*b).unwrap ();
let idx = frame.block_idx + b + 1; *self.reg_mut (*a) = Value::BogusClosure (BogusClosure {
let block = &chunk.blocks [idx]; idx: b + frame.block_idx + 1,
upvalues: vec! [],
let mut new_upvalues = Vec::with_capacity (block.upvalues.len ()); }.into ());
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,
});
}, },
Instruction::EqI (a, sb, k_flag) => { Instruction::EqI (a, sb, k_flag) => {
if (self.reg (*a).as_int ().unwrap () == *sb as i64) != *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 b = usize::try_from (*b).unwrap ();
let c = usize::try_from (*c).unwrap (); let c = usize::try_from (*c).unwrap ();
// If we're inside a closure, use its upvalues let table = upvalues.get (b).unwrap ().as_table ().expect ("GetTabUp only works on tables").borrow ();
// 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 key = match k.get (c).unwrap () { let key = match k.get (c).unwrap () {
Value::String (s) => String::from (s.as_ref()), Value::String (s) => String::from (s.as_ref()),
@ -378,21 +338,14 @@ impl <'a> State <'a> {
}, },
Instruction::GetUpVal (a, b) => { Instruction::GetUpVal (a, b) => {
let this_func = self.stack.last ().unwrap ().register_offset - 1; let this_func = self.stack.last ().unwrap ().register_offset - 1;
let closure = match &self.registers [this_func] { let upvalues = match &self.registers [this_func] {
Value::BogusClosure (rc) => rc.clone (), Value::BogusClosure (rc) => &rc.upvalues,
_ => panic! ("Can't do GetUpVal outside a closure"), _ => panic! ("Can't do GetUpVal outside a closure"),
}; };
let b = usize::try_from (*b).unwrap (); let b = usize::try_from (*b).unwrap ();
let upvalue = match closure.borrow ().upvalues.get (b) { *self.reg_mut (*a) = upvalues [b].clone ();
Some (x) => x.clone (),
None => {
dbg! (chunk, &self);
panic! ("Missing upvalue");
}
};
*self.reg_mut (*a) = upvalue;
}, },
Instruction::Jmp (s_j) => next_pc += s_j, Instruction::Jmp (s_j) => next_pc += s_j,
Instruction::Len (a, b) => { Instruction::Len (a, b) => {
@ -444,27 +397,9 @@ impl <'a> State <'a> {
*self.reg_mut (*a) = (b % c).into (); *self.reg_mut (*a) = (b % c).into ();
}, },
Instruction::Move (a, b) => { 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 (); *self.reg_mut (*a) = self.reg (*b).clone ();
}, },
Instruction::Mul (a, b, c) => { Instruction::Mul (_a, _b, _c) => unimplemented!(),
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::NewTable (a) => { Instruction::NewTable (a) => {
*self.reg_mut (*a) = Value::Table (Default::default ()); *self.reg_mut (*a) = Value::Table (Default::default ());
}, },
@ -477,25 +412,24 @@ impl <'a> State <'a> {
let popped_frame = self.stack.pop ().unwrap (); let popped_frame = self.stack.pop ().unwrap ();
// Build closure if needed. No point building if we're // Build closure if needed
// popping the last frame and exiting the program. if *k {
if *k && ! self.stack.is_empty () {
let closure_idx = match &self.registers [popped_frame.register_offset + a] { let closure_idx = match &self.registers [popped_frame.register_offset + a] {
Value::BogusClosure (rc) => rc.borrow ().idx, Value::BogusClosure (rc) => rc.idx,
_ => panic! ("Impossible"), _ => 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 start_reg = a + popped_frame.register_offset - upvalue_count;
let upvalues = self.registers [start_reg..start_reg+upvalue_count].iter ().cloned ().collect (); 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, idx: closure_idx,
upvalues, upvalues,
}); }.into ());
} }
if self.debug_print { if self.debug_print {
@ -523,13 +457,10 @@ impl <'a> State <'a> {
} }
else { else {
// Return from the entire program // 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 => { Instruction::Return0 => unimplemented! (),
self.stack.pop ();
next_pc = self.stack.last ().unwrap ().program_counter;
},
Instruction::Return1 (a) => { Instruction::Return1 (a) => {
let a = usize::try_from (*a).unwrap (); let a = usize::try_from (*a).unwrap ();
let popped_frame = self.stack.pop ().unwrap (); let popped_frame = self.stack.pop ().unwrap ();
@ -603,36 +534,7 @@ impl <'a> State <'a> {
} }
}, },
Instruction::SetTabUp (_a, _b, _c) => unimplemented! (), Instruction::SetTabUp (_a, _b, _c) => unimplemented! (),
Instruction::TailCall (a, b, _c, k) => { Instruction::TailCall (_a, _b, _c, _k) => unimplemented! (),
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::Test (a, _k) => { Instruction::Test (a, _k) => {
if self.reg (*a).is_truthy() { if self.reg (*a).is_truthy() {
next_pc += 1; next_pc += 1;
@ -646,26 +548,8 @@ impl <'a> State <'a> {
let frame = self.stack.last_mut ().unwrap (); let frame = self.stack.last_mut ().unwrap ();
frame.program_counter = next_pc; 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"); 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 /// and returns the output
fn run_chunk (args: &[&str], chunk: &Chunk) -> Vec <Value> { 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 upvalues = State::upvalues_from_args (args.into_iter ().map (|s| s.to_string ()));
let mut vm = State::new (chunk, &upvalues); vm.execute_chunk (chunk, &upvalues)
vm.execute_chunk (&[])
} }
/// Takes arguments and Lua bytecode, loads it, runs it, /// Takes arguments and Lua bytecode, loads it, runs it,
@ -93,7 +93,7 @@ fn bools () {
"arg".into (), "arg".into (),
"print".into (), "print".into (),
], ],
upvalues: vec! [], upvalue_count: 1,
}, },
Block { Block {
instructions: vec! [ instructions: vec! [
@ -107,7 +107,7 @@ fn bools () {
Inst::Return0, Inst::Return0,
], ],
constants: vec! [], constants: vec! [],
upvalues: vec! [], upvalue_count: 0,
}, },
], ],
}; };
@ -118,9 +118,10 @@ fn bools () {
] { ] {
let expected: Vec <Value> = expected; 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 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); assert_eq! (actual, expected);
} }
} }
@ -163,7 +164,7 @@ fn floats () {
0.5.into (), 0.5.into (),
"print".into (), "print".into (),
], ],
upvalues: vec! [], upvalue_count: 1,
}; };
let chunk = Chunk { let chunk = Chunk {
blocks: vec! [block], blocks: vec! [block],
@ -174,9 +175,9 @@ fn floats () {
(vec! ["_exe_name", " "], vec! [3.5.into ()]), (vec! ["_exe_name", " "], vec! [3.5.into ()]),
] { ] {
let expected: Vec <Value> = expected; 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 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 (&chunk, &upvalues);
let actual = vm.execute_chunk (&[]);
assert_eq! (actual, expected); assert_eq! (actual, expected);
} }
@ -184,21 +185,19 @@ fn floats () {
#[test] #[test]
fn fma () { fn fma () {
let source = include_bytes! ("../test_vectors/fma.lua"); let bytecode = include_bytes! ("../test_vectors/fma.luac");
let bytecode = &crate::loader::compile_bytecode_from_stdin (source.to_vec ()); let mut rdr = std::io::Cursor::new (bytecode);
let chunk = crate::loader::parse_chunk_from_bytes (bytecode).unwrap (); let file = crate::loader::parse_chunk (&mut rdr).unwrap ();
assert_eq! (chunk.blocks.len (), 5); assert_eq! (file.blocks.len (), 4);
assert_eq! (chunk.blocks [3].upvalues.len (), 2);
for (arg, expected) in [ for (arg, expected) in [
(vec! ["_exe_name"], vec! [122.into ()]), (vec! ["_exe_name"], vec! [122.into ()]),
(vec! ["_exe_name"], vec! [122.into ()]), (vec! ["_exe_name"], vec! [122.into ()]),
] { ] {
let expected: Vec <Value> = expected; 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 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 (&file, &upvalues);
let actual = vm.execute_chunk (&[]);
assert_eq! (actual, expected); assert_eq! (actual, expected);
} }

47
src/value.rs
View File

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

13
test_vectors/fma.lua
View File

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