From 0ee58ee676945f9a652690f490936080ab5a0623 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sat, 30 Jan 2021 09:57:50 +0100 Subject: fix closures in closure bug --- src/compiler.rs | 5 ++++- src/vm.rs | 4 ++-- 2 files changed, 6 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 347abe6..92bf3fc 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -472,6 +472,9 @@ impl Compiler { let mut return_type = Type::Void; let mut function_block = Block::new(&name, &self.current_file, self.line()); + let block_id = self.blocks.len(); + self.blocks.push(Rc::new(RefCell::new(Block::new(&name, &self.current_file, self.line())))); + let _ret = push_frame!(self, function_block, { loop { match self.peek() { @@ -538,8 +541,8 @@ impl Compiler { let func = Op::Constant(Value::Function(Vec::new(), Rc::clone(&function_block))); + self.blocks[block_id] = function_block; block.add(func, self.line()); - self.blocks.push(function_block); } fn variable_expression(&mut self, block: &mut Block) { diff --git a/src/vm.rs b/src/vm.rs index 849aaa1..e2b9e57 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -470,9 +470,9 @@ impl VM { self.stack.push(Value::Function(Vec::new(), block.clone())); let mut types = Vec::new(); - for (slot, is_up, _) in block.borrow().ups.iter() { + for (slot, is_up, ty) in block.borrow().ups.iter() { if *is_up { - types.push(Type::Void); + types.push(ty.clone()); } else { types.push(self.stack[*slot].as_type()); } -- cgit v1.2.1 From d2fd074370d829d3d1dfbc6279f1fcbde769eeb3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sat, 30 Jan 2021 23:17:49 +0100 Subject: Add in the yield keyword --- src/compiler.rs | 8 +++++++- src/lib.rs | 21 ++++++++++++++++++++- src/tokenizer.rs | 3 +++ src/vm.rs | 21 +++++++++++++++++---- 4 files changed, 47 insertions(+), 6 deletions(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 92bf3fc..b7fdce1 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -473,7 +473,8 @@ impl Compiler { let mut function_block = Block::new(&name, &self.current_file, self.line()); let block_id = self.blocks.len(); - self.blocks.push(Rc::new(RefCell::new(Block::new(&name, &self.current_file, self.line())))); + let new_block = Block::new(&name, &self.current_file, self.line()); + self.blocks.push(Rc::new(RefCell::new(new_block))); let _ret = push_frame!(self, function_block, { loop { @@ -888,6 +889,11 @@ impl Compiler { } } + (Token::Yield, ..) => { + self.eat(); + block.add(Op::Yield, self.line()); + } + (Token::Identifier(name), Token::ColonEqual, ..) => { self.eat(); self.eat(); diff --git a/src/lib.rs b/src/lib.rs index bdd4ae4..42f24bd 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -21,6 +21,22 @@ pub fn run_file(path: &Path, print: bool, functions: Vec<(String, RustFunction)> run(tokenizer::file_to_tokens(path), path, print, functions) } +pub fn compile_file(path: &Path, + print: bool, + functions: Vec<(String, RustFunction)> + ) -> Result> { + let tokens = tokenizer::file_to_tokens(path); + match compiler::compile("main", path, tokens, &functions) { + Ok(prog) => { + let mut vm = vm::VM::new().print_blocks(print).print_ops(print); + vm.typecheck(&prog)?; + vm.init(&prog); + Ok(vm) + } + Err(errors) => Err(errors), + } +} + pub fn run_string(s: &str, print: bool, functions: Vec<(String, RustFunction)>) -> Result<(), Vec> { run(tokenizer::string_to_tokens(s), Path::new("builtin"), print, functions) } @@ -30,7 +46,8 @@ pub fn run(tokens: TokenStream, path: &Path, print: bool, functions: Vec<(String Ok(prog) => { let mut vm = vm::VM::new().print_blocks(print).print_ops(print); vm.typecheck(&prog)?; - if let Err(e) = vm.run(&prog) { + vm.init(&prog); + if let Err(e) = vm.run() { Err(vec![e]) } else { Ok(()) @@ -450,7 +467,9 @@ pub enum Op { Call(usize), Print, + Return, + Yield, } #[derive(Debug)] diff --git a/src/tokenizer.rs b/src/tokenizer.rs index 7bd0849..28172a3 100644 --- a/src/tokenizer.rs +++ b/src/tokenizer.rs @@ -35,6 +35,9 @@ pub enum Token { #[token("print")] Print, + #[token("yield")] + Yield, + #[token("ret")] Ret, diff --git a/src/vm.rs b/src/vm.rs index e2b9e57..60f723b 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -42,7 +42,9 @@ pub struct VM { } -enum OpResult { +#[derive(Eq, PartialEq)] +pub enum OpResult { + Yield, Continue, Done, } @@ -139,6 +141,11 @@ impl VM { self.stack.pop().unwrap(); } + Op::Yield => { + self.frame_mut().ip += 1; + return Ok(OpResult::Yield); + } + Op::PopUpvalue => { let value = self.stack.pop().unwrap(); let slot = self.stack.len(); @@ -427,7 +434,7 @@ impl VM { self.frame().block.borrow().ops[self.frame().ip]); } - pub fn run(&mut self, prog: &Prog) -> Result<(), Error>{ + pub fn init(&mut self, prog: &Prog) { let block = Rc::clone(&prog.blocks[0]); self.blobs = prog.blobs.clone(); self.extern_functions = prog.functions.clone(); @@ -441,6 +448,9 @@ impl VM { block, ip: 0 }); + } + + pub fn run(&mut self) -> Result { if self.print_blocks { println!("\n [[{}]]\n", "RUNNING".red()); @@ -452,8 +462,9 @@ impl VM { self.print_stack() } - if matches!(self.eval_op(self.op())?, OpResult::Done) { - return Ok(()); + let op = self.eval_op(self.op())?; + if matches!(op, OpResult::Done | OpResult::Yield) { + return Ok(op); } } } @@ -464,6 +475,8 @@ impl VM { Op::Jmp(_line) => {} + Op::Yield => {} + Op::Constant(ref value) => { match value.clone() { Value::Function(_, block) => { -- cgit v1.2.1 From e3b2b1af21b2bdf2adfff62f652cb3cf8ab74e36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sun, 31 Jan 2021 21:13:25 +0100 Subject: pop_twice -> poppop() --- src/vm.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'src') diff --git a/src/vm.rs b/src/vm.rs index 60f723b..0470efb 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -92,7 +92,7 @@ impl VM { self.stack.pop().unwrap() } - fn pop_twice(&mut self) -> (Value, Value) { + fn poppop(&mut self) -> (Value, Value) { let (a, b) = (self.stack.remove(self.stack.len() - 1), self.stack.remove(self.stack.len() - 1)); (b, a) // this matches the order they were on the stack @@ -207,7 +207,7 @@ impl VM { } Op::Add => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a + b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a + b)), (Value::String(a), Value::String(b)) => { @@ -218,7 +218,7 @@ impl VM { } Op::Sub => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a - b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a - b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), @@ -226,7 +226,7 @@ impl VM { } Op::Mul => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a * b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a * b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), @@ -234,7 +234,7 @@ impl VM { } Op::Div => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a / b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a / b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), @@ -242,7 +242,7 @@ impl VM { } Op::Equal => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Bool(a == b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a == b)), (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a == b)), @@ -252,7 +252,7 @@ impl VM { } Op::Less => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Bool(a < b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a < b)), (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a < b)), @@ -262,7 +262,7 @@ impl VM { } Op::Greater => { - match self.pop_twice() { + match self.poppop() { (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Bool(a > b)), (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a > b)), (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a > b)), @@ -272,14 +272,14 @@ impl VM { } Op::And => { - match self.pop_twice() { + match self.poppop() { (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a && b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Or => { - match self.pop_twice() { + match self.poppop() { (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a || b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } -- cgit v1.2.1 From 16a80551298c91e516b813ec205761e7fed2328b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sun, 31 Jan 2021 21:18:22 +0100 Subject: use the pop method don't interact with the stack --- src/vm.rs | 62 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 31 insertions(+), 31 deletions(-) (limited to 'src') diff --git a/src/vm.rs b/src/vm.rs index 0470efb..7fe9c23 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -138,7 +138,7 @@ impl VM { } Op::Pop => { - self.stack.pop().unwrap(); + self.pop(); } Op::Yield => { @@ -147,7 +147,7 @@ impl VM { } Op::PopUpvalue => { - let value = self.stack.pop().unwrap(); + let value = self.pop(); let slot = self.stack.len(); self.drop_upvalue(slot, value); } @@ -178,28 +178,28 @@ impl VM { } Op::Get(field) => { - let inst = self.stack.pop(); - if let Some(Value::BlobInstance(ty, values)) = inst { + let inst = self.pop(); + if let Value::BlobInstance(ty, values) = inst { let slot = self.blobs[ty].name_to_field.get(&field).unwrap().0; self.stack.push(values.borrow()[slot].clone()); } else { - error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst.unwrap()])); + error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst])); } } Op::Set(field) => { - let value = self.stack.pop().unwrap(); - let inst = self.stack.pop(); - if let Some(Value::BlobInstance(ty, values)) = inst { + let value = self.pop(); + let inst = self.pop(); + if let Value::BlobInstance(ty, values) = inst { let slot = self.blobs[ty].name_to_field.get(&field).unwrap().0; values.borrow_mut()[slot] = value; } else { - error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst.unwrap()])); + error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst])); } } Op::Neg => { - match self.stack.pop().unwrap() { + match self.pop() { Value::Float(a) => self.stack.push(Value::Float(-a)), Value::Int(a) => self.stack.push(Value::Int(-a)), a => error!(self, ErrorKind::RuntimeTypeError(op, vec![a])), @@ -286,7 +286,7 @@ impl VM { } Op::Not => { - match self.stack.pop().unwrap() { + match self.pop() { Value::Bool(a) => self.stack.push(Value::Bool(!a)), a => error!(self, ErrorKind::RuntimeTypeError(op, vec![a])), } @@ -298,14 +298,14 @@ impl VM { } Op::JmpFalse(line) => { - if matches!(self.stack.pop(), Some(Value::Bool(false))) { + if matches!(self.pop(), Value::Bool(false)) { self.frame_mut().ip = line; return Ok(OpResult::Continue); } } Op::Assert => { - if matches!(self.stack.pop(), Some(Value::Bool(false))) { + if matches!(self.pop(), Value::Bool(false)) { error!(self, ErrorKind::Assert); } self.stack.push(Value::Bool(true)); @@ -324,7 +324,7 @@ impl VM { Op::AssignUpvalue(slot) => { let offset = self.frame().stack_offset; - let value = self.stack.pop().unwrap(); + let value = self.pop(); let slot = match &self.stack[offset] { Value::Function(ups, _) => Rc::clone(&ups[slot]), _ => unreachable!(), @@ -339,7 +339,7 @@ impl VM { Op::AssignLocal(slot) => { let slot = self.frame().stack_offset + slot; - self.stack[slot] = self.stack.pop().unwrap(); + self.stack[slot] = self.pop(); } Op::Define(_) => {} @@ -355,7 +355,7 @@ impl VM { values.push(Value::Nil); } - self.stack.pop(); + self.pop(); self.stack.push(Value::BlobInstance(blob_id, Rc::new(RefCell::new(values)))); } Value::Function(_, block) => { @@ -394,7 +394,7 @@ impl VM { } Op::Print => { - println!("PRINT: {:?}", self.stack.pop().unwrap()); + println!("PRINT: {:?}", self.pop()); } Op::Return => { @@ -402,7 +402,7 @@ impl VM { if self.frames.is_empty() { return Ok(OpResult::Done); } else { - self.stack[last.stack_offset] = self.stack.pop().unwrap(); + self.stack[last.stack_offset] = self.pop(); for slot in last.stack_offset+1..self.stack.len() { if self.upvalues.contains_key(&slot) { let value = self.stack[slot].clone(); @@ -515,31 +515,31 @@ impl VM { } Op::Get(field) => { - let inst = self.stack.pop(); - if let Some(Value::BlobInstance(ty, _)) = inst { + let inst = self.pop(); + if let Value::BlobInstance(ty, _) = inst { let value = self.blobs[ty].name_to_field.get(&field).unwrap().1.as_value(); self.stack.push(value); } else { self.stack.push(Value::Nil); - error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst.unwrap()])); + error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst])); } } Op::Set(field) => { - let value = self.stack.pop().unwrap(); - let inst = self.stack.pop(); - if let Some(Value::BlobInstance(ty, _)) = inst { + let value = self.pop(); + let inst = self.pop(); + if let Value::BlobInstance(ty, _) = inst { let ty = &self.blobs[ty].name_to_field.get(&field).unwrap().1; if ty != &Type::from(&value) { - error!(self, ErrorKind::RuntimeTypeError(Op::Set(field.clone()), vec![inst.unwrap()])); + error!(self, ErrorKind::RuntimeTypeError(Op::Set(field.clone()), vec![inst])); } } else { - error!(self, ErrorKind::RuntimeTypeError(Op::Set(field.clone()), vec![inst.unwrap()])); + error!(self, ErrorKind::RuntimeTypeError(Op::Set(field.clone()), vec![inst])); } } Op::PopUpvalue => { - self.stack.pop().unwrap(); + self.pop(); } Op::ReadUpvalue(slot) => { @@ -549,7 +549,7 @@ impl VM { Op::AssignUpvalue(slot) => { let var = self.frame().block.borrow().ups[slot].2.clone(); - let up = self.stack.pop().unwrap().as_type(); + let up = self.pop().as_type(); if var != up { error!(self, ErrorKind::TypeError(op, vec![var, up]), "Incorrect type for upvalue.".to_string()); @@ -557,7 +557,7 @@ impl VM { } Op::Return => { - let a = self.stack.pop().unwrap(); + let a = self.pop(); let inner = self.frame().block.borrow(); let ret = inner.ret(); if a.as_type() != *ret { @@ -603,7 +603,7 @@ impl VM { values[*slot] = ty.as_value(); } - self.stack.pop(); + self.pop(); self.stack.push(Value::BlobInstance(blob_id, Rc::new(RefCell::new(values)))); } Value::Function(_, block) => { @@ -702,7 +702,7 @@ impl VM { } if !self.stack.is_empty() { - let ident = self.stack.pop().unwrap().identity(); + let ident = self.pop().identity(); self.stack.push(ident); } } -- cgit v1.2.1 From 906e4946a54e8ae70dab3a5ab9d2ca5a3c34d0f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sun, 31 Jan 2021 21:29:52 +0100 Subject: add noisy error on invalid stack --- src/vm.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/vm.rs b/src/vm.rs index 7fe9c23..562bed9 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -89,7 +89,10 @@ impl VM { } fn pop(&mut self) -> Value { - self.stack.pop().unwrap() + match self.stack.pop() { + Some(x) => x, + None => self.crash_and_burn(), + } } fn poppop(&mut self) -> (Value, Value) { @@ -117,6 +120,17 @@ impl VM { self.frame().block.borrow().ops[ip].clone() } + fn crash_and_burn(&self) -> ! { + println!("\n\n !!!POPING EMPTY STACK - DUMPING EVERYTHING!!!\n"); + self.print_stack(); + println!("\n"); + self.frame().block.borrow().debug_print(); + println!(" ip: {}, line: {}\n", + self.frame().ip.blue(), + self.frame().block.borrow().line(self.frame().ip).blue()); + unreachable!(); + } + fn error(&self, kind: ErrorKind, message: Option) -> Error { let frame = self.frames.last().unwrap(); Error { -- cgit v1.2.1 From 200f6bfe2e4bddbbcc1a7545d780b7c1d640ba42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sun, 31 Jan 2021 21:33:04 +0100 Subject: self.stack.push -> self.push --- src/vm.rs | 94 +++++++++++++++++++++++++++++++++------------------------------ 1 file changed, 49 insertions(+), 45 deletions(-) (limited to 'src') diff --git a/src/vm.rs b/src/vm.rs index 562bed9..b7fa318 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -88,6 +88,10 @@ impl VM { Rc::new(RefCell::new(UpValue::new(slot)))) } + fn push(&mut self, value: Value) { + self.stack.push(value); + } + fn pop(&mut self) -> Value { match self.stack.pop() { Some(x) => x, @@ -188,14 +192,14 @@ impl VM { }, _ => value.clone(), }; - self.stack.push(value); + self.push(value); } Op::Get(field) => { let inst = self.pop(); if let Value::BlobInstance(ty, values) = inst { let slot = self.blobs[ty].name_to_field.get(&field).unwrap().0; - self.stack.push(values.borrow()[slot].clone()); + self.push(values.borrow()[slot].clone()); } else { error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst])); } @@ -214,18 +218,18 @@ impl VM { Op::Neg => { match self.pop() { - Value::Float(a) => self.stack.push(Value::Float(-a)), - Value::Int(a) => self.stack.push(Value::Int(-a)), + Value::Float(a) => self.push(Value::Float(-a)), + Value::Int(a) => self.push(Value::Int(-a)), a => error!(self, ErrorKind::RuntimeTypeError(op, vec![a])), } } Op::Add => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a + b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a + b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Float(a + b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Int(a + b)), (Value::String(a), Value::String(b)) => { - self.stack.push(Value::String(Rc::from(format!("{}{}", a, b)))) + self.push(Value::String(Rc::from(format!("{}{}", a, b)))) } (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } @@ -233,75 +237,75 @@ impl VM { Op::Sub => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a - b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a - b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Float(a - b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Int(a - b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Mul => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a * b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a * b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Float(a * b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Int(a * b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Div => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a / b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a / b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Float(a / b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Int(a / b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Equal => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Bool(a == b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a == b)), - (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a == b)), - (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a == b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Bool(a == b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Bool(a == b)), + (Value::String(a), Value::String(b)) => self.push(Value::Bool(a == b)), + (Value::Bool(a), Value::Bool(b)) => self.push(Value::Bool(a == b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Less => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Bool(a < b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a < b)), - (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a < b)), - (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a < b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Bool(a < b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Bool(a < b)), + (Value::String(a), Value::String(b)) => self.push(Value::Bool(a < b)), + (Value::Bool(a), Value::Bool(b)) => self.push(Value::Bool(a < b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Greater => { match self.poppop() { - (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Bool(a > b)), - (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a > b)), - (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a > b)), - (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a > b)), + (Value::Float(a), Value::Float(b)) => self.push(Value::Bool(a > b)), + (Value::Int(a), Value::Int(b)) => self.push(Value::Bool(a > b)), + (Value::String(a), Value::String(b)) => self.push(Value::Bool(a > b)), + (Value::Bool(a), Value::Bool(b)) => self.push(Value::Bool(a > b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::And => { match self.poppop() { - (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a && b)), + (Value::Bool(a), Value::Bool(b)) => self.push(Value::Bool(a && b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Or => { match self.poppop() { - (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a || b)), + (Value::Bool(a), Value::Bool(b)) => self.push(Value::Bool(a || b)), (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])), } } Op::Not => { match self.pop() { - Value::Bool(a) => self.stack.push(Value::Bool(!a)), + Value::Bool(a) => self.push(Value::Bool(!a)), a => error!(self, ErrorKind::RuntimeTypeError(op, vec![a])), } } @@ -322,7 +326,7 @@ impl VM { if matches!(self.pop(), Value::Bool(false)) { error!(self, ErrorKind::Assert); } - self.stack.push(Value::Bool(true)); + self.push(Value::Bool(true)); } Op::ReadUpvalue(slot) => { @@ -333,7 +337,7 @@ impl VM { } _ => unreachable!(), }; - self.stack.push(value); + self.push(value); } Op::AssignUpvalue(slot) => { @@ -348,7 +352,7 @@ impl VM { Op::ReadLocal(slot) => { let slot = self.frame().stack_offset + slot; - self.stack.push(self.stack[slot].clone()); + self.push(self.stack[slot].clone()); } Op::AssignLocal(slot) => { @@ -370,7 +374,7 @@ impl VM { } self.pop(); - self.stack.push(Value::BlobInstance(blob_id, Rc::new(RefCell::new(values)))); + self.push(Value::BlobInstance(blob_id, Rc::new(RefCell::new(values)))); } Value::Function(_, block) => { let inner = block.borrow(); @@ -399,7 +403,7 @@ impl VM { Err(ek) => error!(self, ek, "Wrong arguments to external function".to_string()), }; self.stack.truncate(new_base); - self.stack.push(res); + self.push(res); } _ => { unreachable!() @@ -455,7 +459,7 @@ impl VM { self.stack.clear(); self.frames.clear(); - self.stack.push(Value::Function(Vec::new(), Rc::clone(&block))); + self.push(Value::Function(Vec::new(), Rc::clone(&block))); self.frames.push(Frame { stack_offset: 0, @@ -494,7 +498,7 @@ impl VM { Op::Constant(ref value) => { match value.clone() { Value::Function(_, block) => { - self.stack.push(Value::Function(Vec::new(), block.clone())); + self.push(Value::Function(Vec::new(), block.clone())); let mut types = Vec::new(); for (slot, is_up, ty) in block.borrow().ups.iter() { @@ -523,7 +527,7 @@ impl VM { }; }, _ => { - self.stack.push(value.clone()); + self.push(value.clone()); } } } @@ -532,9 +536,9 @@ impl VM { let inst = self.pop(); if let Value::BlobInstance(ty, _) = inst { let value = self.blobs[ty].name_to_field.get(&field).unwrap().1.as_value(); - self.stack.push(value); + self.push(value); } else { - self.stack.push(Value::Nil); + self.push(Value::Nil); error!(self, ErrorKind::RuntimeTypeError(Op::Get(field.clone()), vec![inst])); } } @@ -558,7 +562,7 @@ impl VM { Op::ReadUpvalue(slot) => { let value = self.frame().block.borrow().ups[slot].2.as_value(); - self.stack.push(value); + self.push(value); } Op::AssignUpvalue(slot) => { @@ -618,7 +622,7 @@ impl VM { } self.pop(); - self.stack.push(Value::BlobInstance(blob_id, Rc::new(RefCell::new(values)))); + self.push(Value::BlobInstance(blob_id, Rc::new(RefCell::new(values)))); } Value::Function(_, block) => { let inner = block.borrow(); @@ -649,12 +653,12 @@ impl VM { Ok(value) => value, Err(ek) => { self.stack.truncate(new_base); - self.stack.push(Value::Nil); + self.push(Value::Nil); error!(self, ek, "Wrong arguments to external function".to_string()) } }; self.stack.truncate(new_base); - self.stack.push(res); + self.push(res); } _ => { error!(self, @@ -683,9 +687,9 @@ impl VM { self.stack.clear(); self.frames.clear(); - self.stack.push(Value::Function(Vec::new(), Rc::clone(&block))); + self.push(Value::Function(Vec::new(), Rc::clone(&block))); for arg in block.borrow().args() { - self.stack.push(arg.as_value()); + self.push(arg.as_value()); } self.frames.push(Frame { @@ -717,7 +721,7 @@ impl VM { if !self.stack.is_empty() { let ident = self.pop().identity(); - self.stack.push(ident); + self.push(ident); } } errors -- cgit v1.2.1 From d089b4a0f86b16adf23b99b8205ca7af1d586dc0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Mon, 1 Feb 2021 10:21:09 +0100 Subject: Update src/vm.rs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Gustav Sörnäs --- src/vm.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/vm.rs b/src/vm.rs index b7fa318..fd8eb73 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -125,7 +125,7 @@ impl VM { } fn crash_and_burn(&self) -> ! { - println!("\n\n !!!POPING EMPTY STACK - DUMPING EVERYTHING!!!\n"); + println!("\n\n !!!POPPING EMPTY STACK - DUMPING EVERYTHING!!!\n"); self.print_stack(); println!("\n"); self.frame().block.borrow().debug_print(); -- cgit v1.2.1 From afc4a3fe1618239017e15cabc664dd70abc1d75b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Sun, 31 Jan 2021 22:28:48 +0100 Subject: add assignment ops --- src/compiler.rs | 82 ++++++++++++++++++++++++++++++++++++++++++++++----------- src/lib.rs | 21 +++++++++++++++ src/vm.rs | 16 +++++++---- 3 files changed, 98 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index b7fdce1..69bf6eb 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -621,9 +621,38 @@ impl Compiler { } } - fn assign(&mut self, name: &str, block: &mut Block) { + fn assign(&mut self, block: &mut Block) { + let name = match self.eat() { + Token::Identifier(name) => name, + _ => { + error!(self, format!("Expected identifier in assignment")); + return; + } + }; + + let op = match self.eat() { + Token::Equal => None, + + Token::PlusEqual => Some(Op::Add), + Token::MinusEqual => Some(Op::Sub), + Token::StarEqual => Some(Op::Mul), + Token::SlashEqual => Some(Op::Div), + + _ => { + error!(self, format!("Expected '=' in assignment")); + return; + } + }; + if let Some(var) = self.find_variable(&name) { - self.expression(block); + if let Some(op) = op { + block.add(Op::Copy, self.line()); + self.expression(block); + block.add(op, self.line()); + } else { + self.expression(block); + } + if var.upvalue { block.add(Op::AssignUpvalue(var.slot), self.line()); } else { @@ -832,14 +861,31 @@ impl Compiler { return Err(()); }; - if self.peek() == Token::Equal { - self.eat(); - self.expression(block); - block.add(Op::Set(field), self.line()); - return Ok(()); - } else { - block.add(Op::Get(field), self.line()); - } + let op = match self.peek() { + Token::Equal => { + self.eat(); + self.expression(block); + block.add(Op::Set(field), self.line()); + return Ok(()); + } + + Token::PlusEqual => Op::Add, + Token::MinusEqual => Op::Sub, + Token::StarEqual => Op::Mul, + Token::SlashEqual => Op::Div, + + _ => { + block.add(Op::Get(field), self.line()); + continue; + } + }; + block.add(Op::Copy, self.line()); + block.add(Op::Get(field.clone()), self.line()); + self.eat(); + self.expression(block); + block.add(op, self.line()); + block.add(Op::Set(field), self.line()); + return Ok(()); } Token::LeftParen => { self.call(block); @@ -867,6 +913,16 @@ impl Compiler { block.add(Op::Print, self.line()); } + (Token::Identifier(_), Token::Equal, ..) | + (Token::Identifier(_), Token::PlusEqual, ..) | + (Token::Identifier(_), Token::MinusEqual, ..) | + (Token::Identifier(_), Token::SlashEqual, ..) | + (Token::Identifier(_), Token::StarEqual, ..) + + => { + self.assign(block); + } + (Token::Identifier(_), Token::Dot, ..) => { let block_length = block.ops.len(); let token_length = self.curr; @@ -900,12 +956,6 @@ impl Compiler { self.definition_statement(&name, Type::UnknownType, block); } - (Token::Identifier(name), Token::Equal, ..) => { - self.eat(); - self.eat(); - self.assign(&name, block); - } - (Token::Blob, Token::Identifier(_), ..) => { self.blob_statement(block); } diff --git a/src/lib.rs b/src/lib.rs index 42f24bd..453d6ce 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -325,6 +325,26 @@ a() <=> 4 test_file!(scoping, "tests/scoping.tdy"); test_file!(for_, "tests/for.tdy"); + + test_multiple!( + op_assign, + add: "a := 1\na += 1\na <=> 2", + sub: "a := 2\na -= 1\na <=> 1", + mul: "a := 2\na *= 2\na <=> 4", + div: "a := 2\na /= 2\na <=> 1", + cluster: " +blob A { a: int } +a := A() +a.a = 0 +a.a += 1 +a.a <=> 1 +a.a *= 2 +a.a <=> 2 +a.a /= 2 +a.a <=> 1 +a.a -= 1 +a.a <=> 0" + ); } #[derive(Clone)] @@ -431,6 +451,7 @@ pub enum Op { Pop, PopUpvalue, + Copy, Constant(Value), Get(String), diff --git a/src/vm.rs b/src/vm.rs index fd8eb73..6ff7b65 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -159,17 +159,23 @@ impl VM { self.pop(); } - Op::Yield => { - self.frame_mut().ip += 1; - return Ok(OpResult::Yield); - } - Op::PopUpvalue => { let value = self.pop(); let slot = self.stack.len(); self.drop_upvalue(slot, value); } + Op::Copy => { + let v = self.pop(); + self.push(v.clone()); + self.push(v); + } + + Op::Yield => { + self.frame_mut().ip += 1; + return Ok(OpResult::Yield); + } + Op::Constant(value) => { let offset = self.frame().stack_offset; let value = match value { -- cgit v1.2.1