🚧 wip: add string interning, but a few things broke
_
parent
08bbb53900
commit
eb32a53d18
|
|
@ -22,6 +22,8 @@ fn lunar_wave (args: Vec <String>) -> Result <Vec <lwvm::Value>, lwvm::StepError
|
|||
let mut arg_iter = args.iter ();
|
||||
let _exe_name = arg_iter.next ().unwrap ();
|
||||
|
||||
let mut si = lwvm::Interner::default ();
|
||||
|
||||
while let Some (arg) = arg_iter.next () {
|
||||
match arg.as_str () {
|
||||
"--break" => {
|
||||
|
|
@ -40,7 +42,7 @@ fn lunar_wave (args: Vec <String>) -> Result <Vec <lwvm::Value>, lwvm::StepError
|
|||
let mut buf = vec! [];
|
||||
std::io::stdin ().read_to_end (&mut buf).unwrap ();
|
||||
let bc = lwvm::ensure_bytecode (buf).unwrap ();
|
||||
chunk = Some (lwvm::parse_chunk (&bc).unwrap ());
|
||||
chunk = Some (lwvm::parse_chunk (&bc, &mut si).unwrap ());
|
||||
|
||||
lua_args = vec! ["-".to_string ()];
|
||||
},
|
||||
|
|
@ -51,7 +53,7 @@ fn lunar_wave (args: Vec <String>) -> Result <Vec <lwvm::Value>, lwvm::StepError
|
|||
}
|
||||
else if chunk.is_none () {
|
||||
let bc = lwvm::compile_bytecode_from_file (x);
|
||||
chunk = Some (lwvm::parse_chunk (&bc).unwrap ());
|
||||
chunk = Some (lwvm::parse_chunk (&bc, &mut si).unwrap ());
|
||||
|
||||
lua_args = vec! [x.to_string ()];
|
||||
}
|
||||
|
|
@ -68,10 +70,12 @@ fn lunar_wave (args: Vec <String>) -> Result <Vec <lwvm::Value>, lwvm::StepError
|
|||
chunk,
|
||||
list_bytecode,
|
||||
lua_args,
|
||||
si,
|
||||
}),
|
||||
None => repl (ReplParams {
|
||||
list_bytecode,
|
||||
lua_args,
|
||||
si,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
|
@ -81,11 +85,13 @@ struct DebuggerParams {
|
|||
chunk: lwvm::Chunk,
|
||||
list_bytecode: bool,
|
||||
lua_args: Vec <String>,
|
||||
si: lwvm::Interner,
|
||||
}
|
||||
|
||||
struct ReplParams {
|
||||
list_bytecode: bool,
|
||||
lua_args: Vec <String>,
|
||||
si: lwvm::Interner,
|
||||
}
|
||||
|
||||
/// The interpreter mode, which has optional debugging abilities
|
||||
|
|
@ -97,9 +103,7 @@ fn debugger (params: DebuggerParams) -> Result <Vec <lwvm::Value>, lwvm::StepErr
|
|||
dbg! (¶ms.chunk);
|
||||
}
|
||||
|
||||
let upvalues = lwvm::State::upvalues_from_args (params.lua_args.into_iter ());
|
||||
|
||||
let mut vm = lwvm::State::new (params.chunk, upvalues);
|
||||
let mut vm = lwvm::State::new_with_args (params.chunk, params.si, params.lua_args.into_iter ());
|
||||
if std::env::var("LWVM_DEBUG").is_ok() {
|
||||
vm.debug_print = true;
|
||||
}
|
||||
|
|
@ -160,9 +164,7 @@ fn debugger (params: DebuggerParams) -> Result <Vec <lwvm::Value>, lwvm::StepErr
|
|||
|
||||
fn repl (params: ReplParams) -> Result <Vec <lwvm::Value>, lwvm::StepError>
|
||||
{
|
||||
let upvalues = lwvm::State::upvalues_from_args (params.lua_args.into_iter ());
|
||||
|
||||
let mut vm = lwvm::State::new (lwvm::Chunk::default (), upvalues);
|
||||
let mut vm = lwvm::State::new_with_args (lwvm::Chunk::default (), params.si, params.lua_args.into_iter ());
|
||||
|
||||
println! ("Lunar Wave 0.1.0-modified Copyright (C) 2023 ReactorScram (implements Lua 5.4 Copyright (C) 1994-2022 Lua.org, PUC-Rio");
|
||||
|
||||
|
|
@ -188,7 +190,7 @@ fn repl (params: ReplParams) -> Result <Vec <lwvm::Value>, lwvm::StepError>
|
|||
continue;
|
||||
},
|
||||
};
|
||||
let chunk = lwvm::parse_chunk (&bytecode).unwrap ();
|
||||
let chunk = lwvm::parse_chunk (&bytecode, &mut vm.si).unwrap ();
|
||||
|
||||
if params.list_bytecode {
|
||||
dbg! (&chunk);
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ pub use state::Chunk as Chunk;
|
|||
pub use state::State as State;
|
||||
pub use state::StepError as StepError;
|
||||
pub use state::StepOutput as StepOutput;
|
||||
pub use string_interner::Interner as Interner;
|
||||
pub use value::Value as Value;
|
||||
|
||||
#[cfg (test)]
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ use crate::{
|
|||
state::{
|
||||
Block,
|
||||
Chunk,
|
||||
}
|
||||
},
|
||||
string_interner::Interner,
|
||||
};
|
||||
|
||||
pub fn compile_bytecode_from_file (path: &str) -> Vec <u8> {
|
||||
|
|
@ -242,7 +243,7 @@ fn parse_i64 <R: Read> (rdr: &mut R) -> Option <i64> {
|
|||
// code, but I don't like recursion in general, and I don't know
|
||||
// why PUC wrote it that way.
|
||||
|
||||
pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
|
||||
pub fn parse_block <R: Read> (rdr: &mut R, si: &mut Interner, blocks: &mut Vec <Block>)
|
||||
-> Option <()>
|
||||
{
|
||||
// Ignore things I haven't implemented yet
|
||||
|
|
@ -273,12 +274,12 @@ pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
|
|||
|
||||
let val = match const_type {
|
||||
3 => parse_i64 (rdr).unwrap ().into (),
|
||||
4 => parse_string (rdr).unwrap ().into (),
|
||||
4 => si.to_value (parse_string (rdr).unwrap ().as_str ()),
|
||||
|
||||
// For LUA_TNUMBER, PUC Lua uses a macro that adds 16 to signify a float
|
||||
19 => parse_float (rdr).unwrap ().into (),
|
||||
// 0x10 + 4 = long string
|
||||
20 => parse_string (rdr).unwrap ().into (),
|
||||
20 => si.to_value (parse_string (rdr).unwrap ().as_str ()),
|
||||
x => panic! ("Constant {} has type {}", i, x),
|
||||
};
|
||||
|
||||
|
|
@ -312,7 +313,7 @@ pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
|
|||
// Subfunctions. PUC calls them protos.
|
||||
let protos_count = parse_int (rdr).unwrap ();
|
||||
for _ in 0..protos_count {
|
||||
parse_block (rdr, blocks).unwrap ();
|
||||
parse_block (rdr, si, blocks).unwrap ();
|
||||
}
|
||||
|
||||
// Skip over debug stuff
|
||||
|
|
@ -348,12 +349,12 @@ pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
|
|||
Some (())
|
||||
}
|
||||
|
||||
pub fn parse_chunk (buf: &[u8]) -> Option <Chunk> {
|
||||
pub fn parse_chunk (buf: &[u8], si: &mut Interner) -> Option <Chunk> {
|
||||
let mut rdr = std::io::Cursor::new (buf);
|
||||
parse_chunk_from_reader (&mut rdr)
|
||||
parse_chunk_from_reader (&mut rdr, si)
|
||||
}
|
||||
|
||||
pub fn parse_chunk_from_reader <R: Read> (rdr: &mut R) -> Option <Chunk> {
|
||||
pub fn parse_chunk_from_reader <R: Read> (rdr: &mut R, si: &mut Interner) -> Option <Chunk> {
|
||||
// Discard 32 bytes from the start of the file.
|
||||
// This is magic number, version number, etc.
|
||||
|
||||
|
|
@ -364,7 +365,7 @@ pub fn parse_chunk_from_reader <R: Read> (rdr: &mut R) -> Option <Chunk> {
|
|||
|
||||
let mut blocks = vec![];
|
||||
|
||||
parse_block (rdr, &mut blocks).unwrap ();
|
||||
parse_block (rdr, si, &mut blocks).unwrap ();
|
||||
|
||||
Some (Chunk {
|
||||
blocks,
|
||||
|
|
@ -373,6 +374,8 @@ pub fn parse_chunk_from_reader <R: Read> (rdr: &mut R) -> Option <Chunk> {
|
|||
|
||||
#[cfg (test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn load_size () {
|
||||
let f = |input: &[u8]| {
|
||||
|
|
@ -441,6 +444,8 @@ mod tests {
|
|||
fn parse_nested_functions () {
|
||||
use std::io::Read;
|
||||
|
||||
let mut si = Interner::default ();
|
||||
|
||||
let bytecode = include_bytes! ("../test_vectors/functions.luac");
|
||||
|
||||
{
|
||||
|
|
@ -451,7 +456,7 @@ mod tests {
|
|||
|
||||
let mut blocks = vec! [];
|
||||
|
||||
super::parse_block (&mut rdr, &mut blocks).unwrap ();
|
||||
super::parse_block (&mut rdr, &mut si, &mut blocks).unwrap ();
|
||||
|
||||
assert_eq! (blocks [0].instructions.len (), 15);
|
||||
assert_eq! (blocks [1].instructions.len (), 6);
|
||||
|
|
@ -461,7 +466,7 @@ mod tests {
|
|||
}
|
||||
|
||||
if false {
|
||||
let file = crate::loader::parse_chunk (bytecode).unwrap ();
|
||||
let file = crate::loader::parse_chunk (bytecode, &mut si).unwrap ();
|
||||
|
||||
assert_eq! (file.blocks.len (), 5);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
use crate::{
|
||||
instruction::Instruction,
|
||||
string_interner::Interner,
|
||||
value::{
|
||||
BogusClosure,
|
||||
Value,
|
||||
|
|
@ -55,6 +56,7 @@ pub struct State {
|
|||
step_count: u32,
|
||||
chunk: Chunk,
|
||||
upvalues: Vec <Value>,
|
||||
pub si: Interner,
|
||||
}
|
||||
|
||||
fn lw_io_write (l: &mut State, num_args: usize) -> usize {
|
||||
|
|
@ -62,7 +64,7 @@ fn lw_io_write (l: &mut State, num_args: usize) -> usize {
|
|||
match l.reg (i) {
|
||||
Value::Float (x) => print! ("{}", x),
|
||||
Value::Integer (x) => print! ("{}", x),
|
||||
Value::String (x) => print! ("{}", x),
|
||||
Value::String (x) => print! ("{}", l.si.get (*x)),
|
||||
_ => panic! ("Can't io.write this value"),
|
||||
}
|
||||
}
|
||||
|
|
@ -97,12 +99,12 @@ 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");
|
||||
assert_eq! (Value::String (f_string), l.to_string ("%0.9f"));
|
||||
let num = l.reg (1).as_float ().unwrap ();
|
||||
|
||||
let output = format! ("{:0.9}", num);
|
||||
|
||||
*l.reg_mut (0) = Value::from (output);
|
||||
*l.reg_mut (0) = l.to_string (&output);
|
||||
1
|
||||
}
|
||||
|
||||
|
|
@ -117,14 +119,14 @@ fn lw_table_concat (l: &mut State, num_args: usize) -> usize {
|
|||
|
||||
for i in 0..t.length () {
|
||||
if i > 0 {
|
||||
s.push_str (joiner);
|
||||
s.push_str (l.si.get (joiner));
|
||||
}
|
||||
let x = t.get_int (i + 1);
|
||||
s.push_str (&format! ("{}", x));
|
||||
}
|
||||
s
|
||||
};
|
||||
*l.reg_mut (0) = Value::from (s);
|
||||
*l.reg_mut (0) = l.to_string (&s);
|
||||
1
|
||||
}
|
||||
|
||||
|
|
@ -137,15 +139,15 @@ fn lw_table_pack (l: &mut State, num_args: usize) -> usize {
|
|||
1
|
||||
}
|
||||
|
||||
fn tonumber (value: &Value) -> Value {
|
||||
fn tonumber (l: &State, value: &Value) -> Value {
|
||||
match value {
|
||||
Value::Float (x) => Value::Float (*x),
|
||||
Value::Integer (x) => Value::Integer (*x),
|
||||
Value::String (x) => {
|
||||
if let Ok (x) = str::parse::<i64> (x) {
|
||||
if let Ok (x) = str::parse::<i64> (l.si.get (*x)) {
|
||||
Value::from (x)
|
||||
}
|
||||
else if let Ok (x) = str::parse::<f64> (x) {
|
||||
else if let Ok (x) = str::parse::<f64> (l.si.get (*x)) {
|
||||
Value::from (x)
|
||||
}
|
||||
else {
|
||||
|
|
@ -158,7 +160,7 @@ fn tonumber (value: &Value) -> Value {
|
|||
|
||||
fn lw_tonumber (l: &mut State, num_args: usize) -> usize {
|
||||
assert_eq! (num_args, 1, "tonumber only implemented for 1 argument");
|
||||
let output = tonumber (l.reg (0));
|
||||
let output = tonumber (&l, l.reg (0));
|
||||
*l.reg_mut (0) = output;
|
||||
1
|
||||
}
|
||||
|
|
@ -191,6 +193,26 @@ impl State {
|
|||
step_count: 0,
|
||||
chunk,
|
||||
upvalues,
|
||||
si: Default::default (),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_with_args <I: Iterator <Item = String>> (chunk: Chunk, mut si: Interner, args: I) -> Self {
|
||||
let upvalues = Self::upvalues_from_args (&mut si, args);
|
||||
|
||||
Self {
|
||||
// TODO: Stack is actually supposed to grow to a limit of
|
||||
// idk 10,000. I thought it was fixed at 256.
|
||||
registers: vec! [Value::Nil; 256],
|
||||
top: 0,
|
||||
stack: vec! [
|
||||
StackFrame::default (),
|
||||
],
|
||||
debug_print: false,
|
||||
step_count: 0,
|
||||
chunk,
|
||||
upvalues,
|
||||
si,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -199,27 +221,27 @@ impl State {
|
|||
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>
|
||||
fn upvalues_from_args <I: Iterator <Item = String>> (si: &mut Interner, args: I) -> Vec <Value>
|
||||
{
|
||||
let arg = args.map (|s| Value::from (s)).enumerate ();
|
||||
let arg = Value::from_iter (arg.map (|(i, v)| (Value::from (i), v)));
|
||||
let arg = args.map (|s| si.intern (&s)).enumerate ();
|
||||
let arg = Value::from_iter (arg.map (|(i, v)| (Value::from (i), Value::String (v))));
|
||||
|
||||
let io = [
|
||||
let io: Vec <_> = [
|
||||
("write", Value::RsFunc (lw_io_write)),
|
||||
].into_iter ().map (|(k, v)| (k.to_string (), v));
|
||||
].into_iter ().map (|(k, v)| (si.intern (k), v)).collect ();
|
||||
|
||||
let math = [
|
||||
let math: Vec <_> = [
|
||||
("sqrt", Value::RsFunc (lw_sqrt)),
|
||||
].into_iter ().map (|(k, v)| (k.to_string (), v));
|
||||
].into_iter ().map (|(k, v)| (si.intern (k), v)).collect ();
|
||||
|
||||
let string = [
|
||||
let string: Vec <_> = [
|
||||
("format", Value::RsFunc (lw_string_format)),
|
||||
].into_iter ().map (|(k, v)| (k.to_string (), v));
|
||||
].into_iter ().map (|(k, v)| (si.intern (k), v)).collect ();
|
||||
|
||||
let table = [
|
||||
let table: Vec <_> = [
|
||||
("concat", Value::RsFunc (lw_table_concat)),
|
||||
("pack", Value::RsFunc (lw_table_pack)),
|
||||
].into_iter ().map (|(k, v)| (k.to_string (), v));
|
||||
].into_iter ().map (|(k, v)| (si.intern (k), v)).collect ();
|
||||
|
||||
let env = [
|
||||
("arg", arg),
|
||||
|
|
@ -229,7 +251,7 @@ impl State {
|
|||
("string", Value::from_iter (string.into_iter ())),
|
||||
("table", Value::from_iter (table.into_iter ())),
|
||||
("tonumber", Value::RsFunc (lw_tonumber)),
|
||||
].into_iter ().map (|(k, v)| (k.to_string (), v));
|
||||
].into_iter ().map (|(k, v)| (si.intern (k), v));
|
||||
|
||||
vec! [
|
||||
Value::from_iter (env.into_iter ()),
|
||||
|
|
@ -486,11 +508,11 @@ impl State {
|
|||
};
|
||||
|
||||
let key = match &k [usize::from (c)] {
|
||||
Value::String (s) => s,
|
||||
Value::String (s) => *s,
|
||||
_ => panic! ("K[C] must be a string"),
|
||||
};
|
||||
|
||||
let val = t.borrow ().get_str (key.as_str ()).clone ();
|
||||
let val = t.borrow ().get_str (key).clone ();
|
||||
|
||||
*self.reg_mut (a) = val;
|
||||
},
|
||||
|
|
@ -530,11 +552,11 @@ impl State {
|
|||
let table = value.as_table ().expect ("GetTabUp only works on tables").borrow ();
|
||||
|
||||
let key = match k.get (c).unwrap () {
|
||||
Value::String (s) => String::from (s.as_ref()),
|
||||
Value::String (s) => *s,
|
||||
_ => panic! ("GetTabUp only supports string keys"),
|
||||
};
|
||||
|
||||
*self.reg_mut (a) = table.get (key);
|
||||
*self.reg_mut (a) = table.get_str (key).clone ();
|
||||
},
|
||||
Instruction::GetI (a, b, c) => {
|
||||
let key = i64::try_from (c).unwrap ();
|
||||
|
|
@ -573,7 +595,7 @@ impl State {
|
|||
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::String (s) => self.si.get (*s).len ().into (),
|
||||
Value::Table (t) => t.borrow ().length ().into (),
|
||||
};
|
||||
|
||||
|
|
@ -765,14 +787,14 @@ impl State {
|
|||
let b = usize::try_from (b).unwrap ();
|
||||
|
||||
let key = match k.get (b).unwrap () {
|
||||
Value::String (s) => s.as_ref (),
|
||||
Value::String (s) => *s,
|
||||
_ => panic! ("SetField only supports string keys"),
|
||||
};
|
||||
|
||||
let mut dst = self.reg (a).as_table ()
|
||||
.expect ("SetField only works on tables").borrow_mut ();
|
||||
|
||||
dst.insert_str (key.as_str (), value);
|
||||
dst.insert_str (key, value);
|
||||
},
|
||||
Instruction::SetI (a, b, c, k_flag) => {
|
||||
let value = if k_flag {
|
||||
|
|
@ -946,7 +968,7 @@ impl State {
|
|||
pub fn eval (&mut self, src: &str) -> Result <Vec <Value>, crate::Error>
|
||||
{
|
||||
let bytecode = crate::compile_bytecode (src.as_bytes ().to_vec ())?;
|
||||
let chunk = crate::parse_chunk (&bytecode).unwrap ();
|
||||
let chunk = crate::parse_chunk (&bytecode, &mut self.si).unwrap ();
|
||||
|
||||
self.set_chunk (chunk);
|
||||
Ok (self.execute ()?)
|
||||
|
|
@ -971,4 +993,8 @@ impl State {
|
|||
self.stack = vec! [Default::default ()];
|
||||
self.chunk = chunk;
|
||||
}
|
||||
|
||||
pub fn to_string (&mut self, s: &str) -> Value {
|
||||
Value::String (self.si.intern (s))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,25 +1,40 @@
|
|||
use std::collections::BTreeMap;
|
||||
|
||||
use crate::value::Value;
|
||||
|
||||
#[derive (Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
pub struct InternedString (i64);
|
||||
|
||||
#[derive (Default)]
|
||||
#[derive (Debug, Default)]
|
||||
pub struct Interner {
|
||||
table: std::collections::BTreeMap <String, i64>,
|
||||
table_fwd: BTreeMap <String, i64>,
|
||||
table_rev: BTreeMap <i64, String>,
|
||||
counter: i64,
|
||||
}
|
||||
|
||||
impl Interner {
|
||||
pub fn get (&self, s: InternedString) -> &str {
|
||||
self.table_rev.get (&s.0).unwrap ()
|
||||
}
|
||||
|
||||
pub fn intern (&mut self, s: &str) -> InternedString {
|
||||
match self.table.get (s) {
|
||||
match self.table_fwd.get (s) {
|
||||
Some (x) => InternedString (*x),
|
||||
None => {
|
||||
self.counter += 1;
|
||||
if self.counter == i64::MAX {
|
||||
panic! ("Out of IDs");
|
||||
}
|
||||
self.table.insert (s.to_string (), self.counter);
|
||||
self.table_fwd.insert (s.to_string (), self.counter);
|
||||
self.table_rev.insert (self.counter, s.to_string ());
|
||||
InternedString (self.counter)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_value (&mut self, s: &str) -> Value {
|
||||
Value::from (self.intern (s))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg (test)]
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ use crate::{
|
|||
Chunk,
|
||||
State,
|
||||
},
|
||||
string_interner::Interner,
|
||||
value::Value,
|
||||
};
|
||||
|
||||
|
|
@ -23,16 +24,15 @@ fn calculate_hash<T: Hash>(t: &T) -> u64 {
|
|||
/// and returns the output
|
||||
|
||||
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);
|
||||
let mut vm = State::new_with_args (chunk, args.iter ());
|
||||
vm.execute ().unwrap ()
|
||||
}
|
||||
|
||||
/// Takes arguments and Lua bytecode, loads it, runs it,
|
||||
/// and return the output
|
||||
|
||||
fn run_bytecode (args: &[&str], bc: &[u8]) -> Vec <Value> {
|
||||
let chunk = loader::parse_chunk (&bc).unwrap ();
|
||||
fn run_bytecode (args: &[&str], bc: &[u8], si: &mut Interner) -> Vec <Value> {
|
||||
let chunk = loader::parse_chunk (&bc, si).unwrap ();
|
||||
run_chunk (args, chunk)
|
||||
}
|
||||
|
||||
|
|
@ -41,9 +41,9 @@ fn run_bytecode (args: &[&str], bc: &[u8]) -> Vec <Value> {
|
|||
/// runs it,
|
||||
/// and returns the output
|
||||
|
||||
fn run_source (args: &[&str], s: &str) -> Vec <Value> {
|
||||
fn run_source (args: &[&str], s: &str, si: &mut Interner) -> Vec <Value> {
|
||||
let bc = loader::compile_bytecode (s.as_bytes ().to_vec ()).unwrap ();
|
||||
run_bytecode (args, &bc)
|
||||
run_bytecode (args, &bc, si)
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -62,6 +62,8 @@ fn bools () {
|
|||
return x
|
||||
*/
|
||||
|
||||
let mut si = Interner::default ();
|
||||
|
||||
let chunk = Chunk {
|
||||
blocks: vec! [
|
||||
Block {
|
||||
|
|
@ -90,8 +92,8 @@ fn bools () {
|
|||
Inst::Return (2, 1, 1, false),
|
||||
],
|
||||
constants: vec! [
|
||||
"arg".into (),
|
||||
"print".into (),
|
||||
si.to_value ("arg"),
|
||||
si.to_value ("print"),
|
||||
],
|
||||
upvalues: vec! [],
|
||||
},
|
||||
|
|
@ -129,7 +131,7 @@ fn bools () {
|
|||
fn closure () {
|
||||
let source = include_bytes! ("../test_vectors/closure.lua");
|
||||
let bytecode = &crate::loader::compile_bytecode (source.to_vec ()).unwrap ();
|
||||
let chunk = crate::loader::parse_chunk (bytecode).unwrap ();
|
||||
let chunk = crate::loader::parse_chunk (bytecode, &mut Interner::default ()).unwrap ();
|
||||
|
||||
assert_eq! (run_chunk (&["_exe_name"], chunk), vec! [Value::from (23i64)]);
|
||||
}
|
||||
|
|
@ -146,6 +148,8 @@ fn floats () {
|
|||
return x
|
||||
*/
|
||||
|
||||
let mut si = Interner::default ();
|
||||
|
||||
let block = Block {
|
||||
instructions: vec! [
|
||||
Inst::VarArgPrep (0),
|
||||
|
|
@ -161,7 +165,7 @@ fn floats () {
|
|||
],
|
||||
constants: vec! [
|
||||
0.5.into (),
|
||||
"print".into (),
|
||||
si.to_value ("print"),
|
||||
],
|
||||
upvalues: vec! [],
|
||||
};
|
||||
|
|
@ -186,7 +190,7 @@ fn floats () {
|
|||
fn fma () {
|
||||
let source = include_bytes! ("../test_vectors/fma.lua");
|
||||
let bytecode = &crate::loader::compile_bytecode (source.to_vec ()).unwrap ();
|
||||
let chunk = crate::loader::parse_chunk (bytecode).unwrap ();
|
||||
let chunk = crate::loader::parse_chunk (bytecode, &mut Interner::default ()).unwrap ();
|
||||
assert_eq! (chunk.blocks.len (), 5);
|
||||
|
||||
assert_eq! (chunk.blocks [3].upvalues.len (), 2);
|
||||
|
|
@ -241,6 +245,8 @@ fn heap () {
|
|||
};
|
||||
use crate::value::Table;
|
||||
|
||||
let mut si = Interner::default ();
|
||||
|
||||
{
|
||||
let mut allocations = HashMap::new ();
|
||||
let mut ctr = 0;
|
||||
|
|
@ -255,7 +261,7 @@ fn heap () {
|
|||
|
||||
allocations.get_mut (&a).unwrap ().insert (1, c);
|
||||
|
||||
allocations.get_mut (&c).unwrap ().insert (2, "eee");
|
||||
allocations.get_mut (&c).unwrap ().insert (2, si.to_value ("eee"));
|
||||
}
|
||||
|
||||
if true {
|
||||
|
|
@ -292,10 +298,12 @@ fn heap () {
|
|||
|
||||
#[test]
|
||||
fn is_93 () {
|
||||
assert_eq! (Value::from ("93"), Value::from ("93"));
|
||||
assert_ne! (Value::from ("94"), Value::from ("93"));
|
||||
assert_ne! (calculate_hash (&Value::from ("94")), calculate_hash (&Value::from ("93")));
|
||||
assert_ne! (Value::Nil, Value::from ("93"));
|
||||
let mut si = Interner::default ();
|
||||
|
||||
assert_eq! (si.to_value ("93"), si.to_value ("93"));
|
||||
assert_ne! (si.to_value ("94"), si.to_value ("93"));
|
||||
assert_ne! (calculate_hash (&si.to_value ("94")), calculate_hash (&si.to_value ("93")));
|
||||
assert_ne! (Value::Nil, si.to_value ("93"));
|
||||
|
||||
let src = br#"
|
||||
if arg [1] == "93" then
|
||||
|
|
@ -308,7 +316,7 @@ fn is_93 () {
|
|||
"#;
|
||||
|
||||
let bc = loader::compile_bytecode (src.to_vec ()).unwrap ();
|
||||
let chunk = loader::parse_chunk (&bc).unwrap ();
|
||||
let chunk = loader::parse_chunk (&bc, &mut Interner::default ()).unwrap ();
|
||||
|
||||
assert_eq! (chunk.blocks [0].instructions [3], Inst::EqK (0, 1, false));
|
||||
|
||||
|
|
@ -369,7 +377,7 @@ fn tables_1 () {
|
|||
print (t ["t"][1])
|
||||
"#;
|
||||
|
||||
run_source (&[], src);
|
||||
run_source (&[], src, &mut Interner::default ());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -384,7 +392,7 @@ fn tables_2 () {
|
|||
print (a [2])
|
||||
"#;
|
||||
|
||||
run_source (&[], src);
|
||||
run_source (&[], src, &mut Interner::default ());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -396,7 +404,7 @@ fn tailcall () {
|
|||
"#;
|
||||
|
||||
let bc = loader::compile_bytecode (src.to_vec ()).unwrap ();
|
||||
let chunk = loader::parse_chunk (&bc).unwrap ();
|
||||
let chunk = loader::parse_chunk (&bc, &mut Interner::default ()).unwrap ();
|
||||
|
||||
assert_eq! (chunk.blocks [0].instructions [3], Instruction::TailCall (0, 2, 1, false));
|
||||
|
||||
|
|
|
|||
|
|
@ -4,11 +4,16 @@ use std::{
|
|||
Eq,
|
||||
PartialEq,
|
||||
},
|
||||
collections::HashMap,
|
||||
collections::{BTreeMap, HashMap},
|
||||
fmt,
|
||||
rc::Rc,
|
||||
};
|
||||
|
||||
use crate::string_interner::{
|
||||
Interner,
|
||||
InternedString,
|
||||
};
|
||||
|
||||
#[derive (Debug, Eq, PartialEq)]
|
||||
pub struct BogusClosure {
|
||||
// I'm pretty sure this should be absolute?
|
||||
|
|
@ -27,7 +32,7 @@ pub enum Value {
|
|||
|
||||
Integer (i64),
|
||||
RsFunc (fn (&mut crate::state::State, usize) -> usize),
|
||||
String (Rc <String>),
|
||||
String (InternedString),
|
||||
Table (Rc <RefCell <Table>>),
|
||||
|
||||
// These are all bogus, I haven't figured out how to implement
|
||||
|
|
@ -47,7 +52,7 @@ impl fmt::Debug for Value {
|
|||
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::String (s) => write! (f, "unimplemented Debug",),
|
||||
Value::Table (t) => write! (f, "{:?}", t.borrow ()),
|
||||
|
||||
Value::BogusClosure (x) => write! (f, "{:?}", x.borrow ()),
|
||||
|
|
@ -70,7 +75,7 @@ impl fmt::Display for Value {
|
|||
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::String (s) => write! (f, "unimplemented Display"),
|
||||
Value::Table (t) => write! (f, "table: {:?}", std::rc::Rc::as_ptr (t)),
|
||||
|
||||
Value::BogusClosure (x) => write! (f, "BogusClosure: {:?}", std::rc::Rc::as_ptr (x)),
|
||||
|
|
@ -90,18 +95,6 @@ impl From <bool> for Value {
|
|||
}
|
||||
}
|
||||
|
||||
impl From <String> 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 <i32> for Value {
|
||||
fn from (x: i32) -> Self {
|
||||
Self::Integer (i64::from (x))
|
||||
|
|
@ -126,6 +119,12 @@ impl From <usize> for Value {
|
|||
}
|
||||
}
|
||||
|
||||
impl From <InternedString> for Value {
|
||||
fn from (x: InternedString) -> Self {
|
||||
Self::String (x)
|
||||
}
|
||||
}
|
||||
|
||||
impl From <Table> for Value {
|
||||
fn from (x: Table) -> Self {
|
||||
Self::Table (Rc::new (RefCell::new (x)))
|
||||
|
|
@ -139,9 +138,9 @@ impl FromIterator <(Value, Value)> for Value {
|
|||
}
|
||||
}
|
||||
|
||||
impl FromIterator <(String, Value)> for Value {
|
||||
fn from_iter <I: IntoIterator <Item=(String, Value)>> (i: I) -> Self {
|
||||
Self::from_iter (i.into_iter ().map (|(s, v)| (Value::from (s), v)))
|
||||
impl FromIterator <(InternedString, Value)> for Value {
|
||||
fn from_iter <I: IntoIterator <Item=(InternedString, Value)>> (i: I) -> Self {
|
||||
Self::from_iter (i.into_iter ().map (|(s, v)| (Value::String (s), v)))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -209,9 +208,9 @@ impl Value {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn as_str (&self) -> Option <&str> {
|
||||
pub fn as_str (&self) -> Option <InternedString> {
|
||||
match self {
|
||||
Self::String (x) => Some (x.as_str ()),
|
||||
Self::String (x) => Some (*x),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -223,6 +222,10 @@ impl Value {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn from_str (si: &mut Interner, s: &str) -> Value {
|
||||
Value::String (si.intern (s))
|
||||
}
|
||||
|
||||
pub fn is_truthy (&self) -> bool {
|
||||
// And this is something Lua does better than JS and Python.
|
||||
|
||||
|
|
@ -244,11 +247,12 @@ impl Value {
|
|||
pub struct Table {
|
||||
array: Vec <Value>,
|
||||
hash: HashMap <Value, Value>,
|
||||
map: BTreeMap <InternedString, Value>,
|
||||
}
|
||||
|
||||
impl fmt::Debug for Table {
|
||||
fn fmt (&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write! (f, "Table {:#?}", self.hash)?;
|
||||
write! (f, "Table {:#?}", self.map)?;
|
||||
|
||||
Ok (())
|
||||
}
|
||||
|
|
@ -256,14 +260,11 @@ impl fmt::Debug for Table {
|
|||
|
||||
impl Table {
|
||||
fn get_inner (&self, key: &Value) -> Value {
|
||||
// self.hash.get (key).cloned ().unwrap_or_default ()
|
||||
for (hay, value) in &self.hash {
|
||||
if key == hay {
|
||||
return value.clone ();
|
||||
}
|
||||
match key {
|
||||
Value::Nil => Value::Nil,
|
||||
Value::String (x) => self.map.get (x).cloned ().unwrap_or_default (),
|
||||
x => self.hash.get (x).cloned ().unwrap_or_default (),
|
||||
}
|
||||
|
||||
Value::Nil
|
||||
}
|
||||
|
||||
pub fn get <A: Into <Value>> (&self, key: A) -> Value {
|
||||
|
|
@ -274,25 +275,11 @@ impl Table {
|
|||
self.get_inner (&(key.into ()))
|
||||
}
|
||||
|
||||
pub fn get_str (&self, key: &str) -> &Value {
|
||||
for (hay, value) in &self.hash {
|
||||
if Some (key) == hay.as_str () {
|
||||
return value;
|
||||
}
|
||||
pub fn get_str (&self, key: InternedString) -> &Value {
|
||||
match self.map.get (&key) {
|
||||
None => &NIL,
|
||||
Some (x) => x,
|
||||
}
|
||||
|
||||
&NIL
|
||||
}
|
||||
|
||||
fn insert_inner (&mut self, a: Value, b: Value) {
|
||||
for (hay, value) in &mut self.hash {
|
||||
if &a == hay {
|
||||
*value = b;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
self.hash.insert (a, b);
|
||||
}
|
||||
|
||||
/// Insert value at arbitrary key
|
||||
|
|
@ -302,25 +289,26 @@ impl Table {
|
|||
a: A,
|
||||
b: B,
|
||||
) {
|
||||
self.insert_inner (a.into (), b.into ())
|
||||
match a.into () {
|
||||
Value::Nil => (),
|
||||
Value::String (x) => {
|
||||
self.map.insert (x, b.into ());
|
||||
},
|
||||
x => {
|
||||
self.hash.insert (x, b.into ());
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Insert value at integer key
|
||||
|
||||
pub fn insert_int <A: Into <Value>> (&mut self, k: i64, v: A)
|
||||
{
|
||||
self.insert_inner (k.into (), v.into ())
|
||||
self.insert (Value::from (k), v.into ())
|
||||
}
|
||||
|
||||
pub fn insert_str (&mut self, key: &str, v: Value) {
|
||||
for (hay, value) in &mut self.hash {
|
||||
if Some (key) == hay.as_str () {
|
||||
*value = v;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
self.hash.insert (key.into (), v);
|
||||
pub fn insert_str (&mut self, key: InternedString, v: Value) {
|
||||
self.map.insert (key, v);
|
||||
}
|
||||
|
||||
pub fn length (&self) -> i64 {
|
||||
|
|
@ -336,21 +324,18 @@ impl Table {
|
|||
impl FromIterator <(Value, Value)> for Table {
|
||||
fn from_iter<I: IntoIterator<Item = (Value, Value)>> (i: I) -> Self
|
||||
{
|
||||
let hash = i.into_iter ().collect ();
|
||||
Self {
|
||||
array: Default::default (),
|
||||
hash,
|
||||
let mut that = Self::default ();
|
||||
for (k, v) in i.into_iter () {
|
||||
that.insert (k, v);
|
||||
}
|
||||
that
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg (test)]
|
||||
mod tests {
|
||||
use std::collections::HashMap;
|
||||
use super::{
|
||||
Table,
|
||||
Value,
|
||||
};
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn smoke () {
|
||||
|
|
@ -364,23 +349,24 @@ mod tests {
|
|||
#[test]
|
||||
fn tables () {
|
||||
let nil = Value::Nil;
|
||||
let mut si = Interner::default ();
|
||||
|
||||
assert_ne! (Value::from (18.0), Value::from (19.0));
|
||||
|
||||
let mut t = HashMap::new ();
|
||||
t.insert (Value::from ("x"), Value::from (19.0));
|
||||
assert_eq! (t.get (&Value::from ("x")), Some (&Value::from (19.0)));
|
||||
t.insert (Value::from_str (&mut si, "x"), Value::from (19.0));
|
||||
assert_eq! (t.get (&Value::from_str (&mut si, "x")), Some (&Value::from (19.0)));
|
||||
|
||||
let mut t = Table::default ();
|
||||
|
||||
assert_eq! (t.get ("a"), nil);
|
||||
assert_eq! (t.get ("b"), nil);
|
||||
assert_eq! (t.get (Value::from_str (&mut si, "a")), nil);
|
||||
assert_eq! (t.get (Value::from_str (&mut si, "b")), nil);
|
||||
|
||||
t.insert ("a", 1993);
|
||||
t.insert ("b", 2007);
|
||||
t.insert (si.to_value ("a"), 1993);
|
||||
t.insert (si.to_value ("b"), 2007);
|
||||
|
||||
assert_eq! (t.get ("a"), 1993);
|
||||
assert_eq! (t.get ("b"), 2007);
|
||||
assert_eq! (t.get (Value::from_str (&mut si, "a")), 1993);
|
||||
assert_eq! (t.get (Value::from_str (&mut si, "b")), 2007);
|
||||
|
||||
t.insert (19, 93);
|
||||
assert_eq! (t.get (19), 93);
|
||||
|
|
|
|||
Loading…
Reference in New Issue