From c574e4f707b1a2e638407bb60bf51355371874d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Tue, 9 Feb 2021 00:01:29 +0100 Subject: refactor function parsing --- src/compiler.rs | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 7f0d32d..1d41c32 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -600,6 +600,9 @@ impl Compiler { } } } + if self.panic { + break; + } } add_op(self, block, Op::Call(arity)); @@ -718,18 +721,17 @@ impl Compiler { break; } } - Token::LeftParen => { - self.call(block); + _ => { + if !parse_branch!(self, block, self.call(block)) { + break + } } - _ => { break } } } } else if let Some(blob) = self.find_blob(&name) { let string = self.add_constant(Value::Blob(blob)); add_op(self, block, Op::Constant(string)); - if self.peek() == Token::LeftParen { - self.call(block); - } + parse_branch!(self, block, self.call(block)); } else if let Some(slot) = self.find_extern_function(&name) { let string = self.add_constant(Value::ExternFunction(slot)); add_op(self, block, Op::Constant(string)); @@ -1059,15 +1061,14 @@ impl Compiler { add_op(self, block, Op::Set(field)); return; } - Token::LeftParen => { - self.call(block); - } Token::Newline => { return; } _ => { - error!(self, "Unexpected token when parsing blob-field."); - return; + if !parse_branch!(self, block, self.call(block)) { + error!(self, "Unexpected token when parsing blob-field."); + return; + } } } } -- cgit v1.2.1 From aeab306921dfe9af4b444a77bd46d1700e43dd88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Tue, 9 Feb 2021 00:30:30 +0100 Subject: fancy call syntax --- src/compiler.rs | 75 +++++++++++++++++++++++++++++++++++++++++++-------------- src/lib.rs | 8 ++++++ 2 files changed, 65 insertions(+), 18 deletions(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 1d41c32..58e5f23 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -579,29 +579,68 @@ impl Compiler { } fn call(&mut self, block: &mut Block) { - expect!(self, Token::LeftParen, "Expected '(' at start of function call."); - let mut arity = 0; - loop { - match self.peek() { - Token::EOF => { - error!(self, "Unexpected EOF in function call."); - break; - } - Token::RightParen => { - self.eat(); - break; + match self.peek() { + Token::LeftParen => { + self.eat(); + loop { + match self.peek() { + Token::EOF => { + error!(self, "Unexpected EOF in function call."); + break; + } + Token::RightParen => { + self.eat(); + break; + } + _ => { + self.expression(block); + arity += 1; + if !matches!(self.peek(), Token::RightParen) { + expect!(self, Token::Comma, "Expected ',' after argument."); + } + } + } + if self.panic { + break; + } } - _ => { - self.expression(block); - arity += 1; - if !matches!(self.peek(), Token::RightParen) { - expect!(self, Token::Comma, "Expected ',' after argument."); + }, + + Token::Not => { + // I suspect this will be wierd with the boolean NOT + // operator... + self.eat(); + loop { + match self.peek() { + Token::EOF => { + error!(self, "Unexpected EOF in function call."); + break; + } + Token::Newline => { + break; + } + _ => { + if !parse_branch!(self, block, self.expression(block)) { + break; + } + arity += 1; + if matches!(self.peek(), Token::Comma) { + self.eat(); + } + } } + if self.panic { + break; + } + } + if !self.panic { + println!("LINE {} -- ", self.line()); } } - if self.panic { - break; + + _ => { + error!(self, "Not a valid function call, expected a '!' or a '('."); } } diff --git a/src/lib.rs b/src/lib.rs index ae45c45..96ed6fd 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1045,6 +1045,14 @@ a.a -= 1 a.a <=> 0" ); + test_multiple!( + fancy_call, + not: "f := fn {}\n f!\n", + one_arg: "f := fn a:int { a <=> 1 }\n f! 1\n", + two_arg: "f := fn a:int, b:int { b <=> 3 }\n f! 1, 1 + 2\n", + three_arg: "f := fn a:int, b:int, c:int { c <=> 13 }\n f! 1, 1 + 2, 1 + 4 * 3\n", + ); + test_multiple!( newline_regression, simple: "a := 1 // blargh \na += 1 // blargh \n a <=> 2 // HARGH", -- cgit v1.2.1 From 8283faff92557387ab057bbc6f4f0c33e96dbcbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Tue, 9 Feb 2021 17:58:59 +0100 Subject: Not -> Bang --- src/compiler.rs | 6 ++---- src/tokenizer.rs | 2 +- 2 files changed, 3 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 58e5f23..34af10b 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -389,7 +389,7 @@ impl Compiler { Token::Bool(_) => self.value(block), Token::String(_) => self.value(block), - Token::Not => self.unary(block), + Token::Bang => self.unary(block), _ => { return false; }, } @@ -607,9 +607,7 @@ impl Compiler { } }, - Token::Not => { - // I suspect this will be wierd with the boolean NOT - // operator... + Token::Bang => { self.eat(); loop { match self.peek() { diff --git a/src/tokenizer.rs b/src/tokenizer.rs index 9574af1..cf7a14c 100644 --- a/src/tokenizer.rs +++ b/src/tokenizer.rs @@ -112,7 +112,7 @@ pub enum Token { #[token("||")] Or, #[token("!")] - Not, + Bang, #[token(",")] Comma, -- cgit v1.2.1 From d3daee70dc8f84a94f06d5f2e25fd11695be716c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Tue, 9 Feb 2021 18:00:11 +0100 Subject: better "invalid function call" error --- src/compiler.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 34af10b..db79d65 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -638,7 +638,7 @@ impl Compiler { } _ => { - error!(self, "Not a valid function call, expected a '!' or a '('."); + error!(self, "Invalid function call. Expected '!' or '('."); } } -- cgit v1.2.1 From 1f79e974677b48d9cd9d69941de8c2fea3e583c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Tue, 9 Feb 2021 18:39:10 +0100 Subject: not -> bang fixup --- src/compiler.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index db79d65..35fedf3 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -489,7 +489,7 @@ impl Compiler { fn unary(&mut self, block: &mut Block) { let op = match self.eat() { Token::Minus => Op::Neg, - Token::Not => Op::Not, + Token::Bang => Op::Not, _ => { error!(self, "Invalid unary operator"); Op::Neg }, }; self.parse_precedence(block, Prec::Factor); -- cgit v1.2.1 From cd1e464c11fb84ef8319e52019c23c0a91d5e3a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 10 Feb 2021 22:12:31 +0100 Subject: fix the assignment --- src/compiler.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 7f0d32d..a7fc30b 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -799,7 +799,11 @@ impl Compiler { if let Some(var) = self.find_variable(&name) { if let Some(op) = op { - add_op(self, block, Op::Copy); + if var.upvalue { + add_op(self, block, Op::ReadUpvalue(var.slot)); + } else { + add_op(self, block, Op::ReadLocal(var.slot)); + } self.expression(block); add_op(self, block, op); } else { -- cgit v1.2.1 From 9596dadf3ad99aefec2547f4f8294d772811d8be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 10 Feb 2021 22:12:41 +0100 Subject: add regression tests --- src/lib.rs | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) (limited to 'src') diff --git a/src/lib.rs b/src/lib.rs index ae45c45..d8d9505 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1050,4 +1050,33 @@ a.a <=> 0" simple: "a := 1 // blargh \na += 1 // blargh \n a <=> 2 // HARGH", expressions: "1 + 1 // blargh \n 2 // blargh \n // HARGH \n", ); + + test_multiple!( + assignment_op_regression, + simple_add: " +a := 0 +b := 99999 +a += 1 +a <=> 1 +", + + simple_sub: " +a := 0 +b := 99999 +a -= 1 +a <=> -1 +", + + strange: " +a := 0 +{ + b := 99999 + { + a := 99999 + } + a -= 1 +} +a <=> -1 +", + ); } -- cgit v1.2.1 From 75398cbe82ef32c1eb1996808717e4e5d564f94b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 10 Feb 2021 22:35:48 +0100 Subject: add a simple stacktrace --- src/vm.rs | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/vm.rs b/src/vm.rs index e5c7b2e..d238087 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -63,9 +63,10 @@ pub struct VM { pub print_blocks: bool, pub print_ops: bool, + runtime: bool, - extern_functions: Vec, + extern_functions: Vec, } #[derive(Eq, PartialEq)] @@ -92,6 +93,7 @@ impl VM { print_blocks: false, print_ops: false, + runtime: false, extern_functions: Vec::new() } @@ -158,10 +160,25 @@ impl VM { self.frame().block.borrow().ops[ip] } + fn print_stacktrace(&self) { + if !self.runtime { return; } + + println!("\n<{}>", "STACK".red()); + for (i, frame) in self.frames.iter().enumerate() { + println!(" {:>3}. {}:{:<4} in {:10}", + i, + frame.block.borrow().file.display(), + frame.block.borrow().line(self.frame().ip), + frame.block.borrow().name.blue()); + } + println!("") + } + /// Stop the program, violently fn crash_and_burn(&self) -> ! { self.print_stack(); println!("\n"); + self.print_stacktrace(); self.frame().block.borrow().debug_print(); println!(" ip: {}, line: {}\n", self.frame().ip.blue(), @@ -171,6 +188,7 @@ impl VM { fn error(&self, kind: ErrorKind, message: Option) -> Error { let frame = self.frames.last().unwrap(); + self.print_stacktrace(); Error { kind, file: frame.block.borrow().file.clone(), @@ -458,6 +476,7 @@ impl VM { self.extern_functions = prog.functions.clone(); self.stack.clear(); self.frames.clear(); + self.runtime = true; self.push(Value::Function(Vec::new(), Rc::clone(&block))); @@ -738,6 +757,7 @@ impl VM { self.blobs = prog.blobs.clone(); self.constants = prog.constants.clone(); self.strings = prog.strings.clone(); + self.runtime = false; self.extern_functions = prog.functions.clone(); for block in prog.blocks.iter() { -- cgit v1.2.1 From 651865f41eea7a64093724ad664646eb76100ab1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 10 Feb 2021 23:01:35 +0100 Subject: add constants --- src/compiler.rs | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) (limited to 'src') diff --git a/src/compiler.rs b/src/compiler.rs index 7f0d32d..d18d9c6 100644 --- a/src/compiler.rs +++ b/src/compiler.rs @@ -126,6 +126,7 @@ struct Variable { active: bool, upvalue: bool, captured: bool, + mutable: bool, } struct Frame { @@ -759,6 +760,32 @@ impl Compiler { scope, active: false, upvalue: false, + mutable: true, + }); + Ok(slot) + } + + fn define_constant(&mut self, name: &str, typ: Type, _block: &mut Block) -> Result { + if let Some(var) = self.find_variable(&name) { + if var.scope == self.frame().scope { + error!(self, format!("Multiple definitions of {} in this block.", name)); + return Err(()); + } + } + + let slot = self.stack().len(); + let scope = self.frame().scope; + self.stack_mut().push(Variable { + name: String::from(name), + captured: false, + outer_upvalue: false, + outer_slot: 0, + slot, + typ, + scope, + active: false, + upvalue: false, + mutable: false, }); Ok(slot) } @@ -774,6 +801,15 @@ impl Compiler { } } + fn constant_statement(&mut self, name: &str, typ: Type, block: &mut Block) { + let slot = self.define_constant(name, typ.clone(), block); + self.expression(block); + + if let Ok(slot) = slot { + self.stack_mut()[slot].active = true; + } + } + fn assign(&mut self, block: &mut Block) { let name = match self.eat() { Token::Identifier(name) => name, @@ -798,6 +834,10 @@ impl Compiler { }; if let Some(var) = self.find_variable(&name) { + if !var.mutable { + // TODO(ed): Maybe a better error than "SyntaxError". + error!(self, format!("Cannot assign to constant '{}'", var.name)); + } if let Some(op) = op { add_op(self, block, Op::Copy); self.expression(block); @@ -1123,6 +1163,12 @@ impl Compiler { self.definition_statement(&name, Type::Unknown, block); } + (Token::Identifier(name), Token::ColonColon, ..) => { + self.eat(); + self.eat(); + self.constant_statement(&name, Type::Unknown, block); + } + (Token::Blob, Token::Identifier(_), ..) => { self.blob_statement(block); } @@ -1177,6 +1223,7 @@ impl Compiler { active: false, captured: false, upvalue: false, + mutable: true, }); let mut block = Block::new(name, file, 0); -- cgit v1.2.1 From 9bd53d666c32d93b6a81a05c15025fd41bd056ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 10 Feb 2021 23:05:45 +0100 Subject: add tests for constants --- src/lib.rs | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/lib.rs b/src/lib.rs index ae45c45..cd84776 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -805,6 +805,16 @@ mod tests { assert_errs!(run_string("\n", true, Vec::new()), [ErrorKind::Unreachable]); } + #[test] + fn assign_to_constant() { + assert_errs!(run_string("a :: 2\na = 2", true, Vec::new()), [ErrorKind::SyntaxError(_, _)]); + } + + #[test] + fn assign_to_constant_upvalue() { + assert_errs!(run_string("a :: 2\nq :: fn { a = 2 }\n", true, Vec::new()), [ErrorKind::SyntaxError(_, _)]); + } + macro_rules! test_multiple { ($mod:ident, $( $fn:ident : $prog:literal ),+ $( , )? ) => { mod $mod { @@ -848,7 +858,7 @@ mod tests { test_multiple!( if_, compare_constants_equality: "if 1 == 2 { - + }", compare_constants_unequality: "if 1 != 1 { @@ -1050,4 +1060,16 @@ a.a <=> 0" simple: "a := 1 // blargh \na += 1 // blargh \n a <=> 2 // HARGH", expressions: "1 + 1 // blargh \n 2 // blargh \n // HARGH \n", ); + + test_multiple!( + read_constants, + simple: " +a :: 1 +a <=> 1 +b := 2 +{ + a <=> 1 +} +", + ); } -- cgit v1.2.1 From 089d018fdc5a76508aba27292ba379d5691cbc3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Thu, 11 Feb 2021 18:15:47 +0100 Subject: fix feedback from codereview --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/lib.rs b/src/lib.rs index cd84776..3f753f1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -858,7 +858,7 @@ mod tests { test_multiple!( if_, compare_constants_equality: "if 1 == 2 { - + }", compare_constants_unequality: "if 1 != 1 { -- cgit v1.2.1