From 1d3d9d32e34c72c84ff72af4583f83d7105bdb98 Mon Sep 17 00:00:00 2001 From: Vincent Ambo Date: Sat, 27 Feb 2021 16:38:46 +0200 Subject: feat(tazjin/rlox): Set up precedence parsing scaffolding Defines a new precedence levels enum which can be used to restrict the parser precedence in any given location. As an example, unary expressions and grouping are implemented, as these have a different precedence from e.g. expression() Change-Id: I91f299fc77530f76c3aba717f638985428104ee5 Reviewed-on: https://cl.tvl.fyi/c/depot/+/2558 Reviewed-by: tazjin Tested-by: BuildkiteCI --- users/tazjin/rlox/src/bytecode/compiler.rs | 101 ---------------- users/tazjin/rlox/src/bytecode/compiler/mod.rs | 156 +++++++++++++++++++++++++ 2 files changed, 156 insertions(+), 101 deletions(-) delete mode 100644 users/tazjin/rlox/src/bytecode/compiler.rs create mode 100644 users/tazjin/rlox/src/bytecode/compiler/mod.rs (limited to 'users/tazjin') diff --git a/users/tazjin/rlox/src/bytecode/compiler.rs b/users/tazjin/rlox/src/bytecode/compiler.rs deleted file mode 100644 index ab5a970ffd12..000000000000 --- a/users/tazjin/rlox/src/bytecode/compiler.rs +++ /dev/null @@ -1,101 +0,0 @@ -use super::chunk::Chunk; -use super::errors::{Error, ErrorKind, LoxResult}; -use super::opcode::OpCode; -use crate::scanner; - -struct Compiler> { - tokens: T, - chunk: Chunk, - panic: bool, - errors: Vec, - - // TODO(tazjin): Restructure so that these don't need to be Option? - current: Option, - previous: Option, -} - -impl> Compiler { - fn compile(&mut self) -> LoxResult<()> { - self.advance(); - self.expression(); - self.consume( - &scanner::TokenKind::Eof, - ErrorKind::ExpectedToken("Expected end of expression"), - )?; - - self.end_compiler() - } - - fn advance(&mut self) { - self.previous = self.current.take(); - self.current = self.tokens.next(); - } - - fn expression(&mut self) { - unimplemented!() - } - - fn consume( - &mut self, - expected: &scanner::TokenKind, - err: ErrorKind, - ) -> LoxResult<()> { - unimplemented!() - } - - fn current_chunk(&mut self) -> &mut Chunk { - &mut self.chunk - } - - fn end_compiler(&mut self) -> LoxResult<()> { - self.emit_op(OpCode::OpReturn); - Ok(()) - } - - fn emit_op(&mut self, op: OpCode) { - let line = self.previous().line; - self.current_chunk().add_op(op, line); - } - - fn previous(&self) -> &scanner::Token { - self.previous - .as_ref() - .expect("invalid internal compiler state: missing previous token") - } - - fn error_at(&mut self, token: &scanner::Token, kind: ErrorKind) { - if self.panic { - return; - } - - self.panic = true; - self.errors.push(Error { - kind, - line: token.line, - }) - } -} - -pub fn compile(code: &str) -> Result> { - let chars = code.chars().collect::>(); - let tokens = scanner::scan(&chars).map_err(|errors| { - errors.into_iter().map(Into::into).collect::>() - })?; - - let mut compiler = Compiler { - tokens: tokens.into_iter().peekable(), - chunk: Default::default(), - panic: false, - errors: vec![], - current: None, - previous: None, - }; - - compiler.compile()?; - - if compiler.errors.is_empty() { - Ok(unimplemented!()) - } else { - Err(compiler.errors) - } -} diff --git a/users/tazjin/rlox/src/bytecode/compiler/mod.rs b/users/tazjin/rlox/src/bytecode/compiler/mod.rs new file mode 100644 index 000000000000..813cf2e26df0 --- /dev/null +++ b/users/tazjin/rlox/src/bytecode/compiler/mod.rs @@ -0,0 +1,156 @@ +use super::chunk::Chunk; +use super::errors::{Error, ErrorKind, LoxResult}; +use super::opcode::OpCode; +use super::value::Value; +use crate::scanner::{self, Token, TokenKind}; + +#[cfg(test)] +mod tests; + +struct Compiler> { + tokens: T, + chunk: Chunk, + panic: bool, + errors: Vec, + + // TODO(tazjin): Restructure so that these don't need to be Option? + current: Option, + previous: Option, +} + +#[derive(Debug, PartialEq, PartialOrd)] +enum Precedence { + None, + Assignment, // = + Or, // or + And, // and + Equality, // == != + Comparison, // < > <= >= + Term, // + - + Factor, // * / + Unary, // ! - + Call, // . () + Primary, +} + +impl> Compiler { + fn compile(&mut self) -> LoxResult<()> { + self.advance(); + self.expression()?; + self.consume( + &TokenKind::Eof, + ErrorKind::ExpectedToken("Expected end of expression"), + )?; + + self.end_compiler() + } + + fn advance(&mut self) { + self.previous = self.current.take(); + self.current = self.tokens.next(); + } + + fn expression(&mut self) -> LoxResult<()> { + self.parse_precedence(Precedence::Assignment) + } + + // TODO(tazjin): Assumption is that we have access to the previous + // token wherever this ends up invoked. True? + fn number(&mut self, num: f64) { + self.emit_constant(num); + } + + fn grouping(&mut self, num: f64) -> LoxResult<()> { + self.expression()?; + self.consume( + &TokenKind::RightParen, + ErrorKind::ExpectedToken("Expected ')' after expression"), + ) + } + + fn unary(&mut self, kind: &TokenKind) -> LoxResult<()> { + // Compile the operand + self.parse_precedence(Precedence::Unary)?; + + // Emit operator instruction + match kind { + TokenKind::Minus => self.emit_op(OpCode::OpNegate), + _ => unreachable!("only called for unary operator tokens"), + } + + Ok(()) + } + + fn parse_precedence(&mut self, precedence: Precedence) -> LoxResult<()> { + unimplemented!("what goes here?") + } + + fn consume( + &mut self, + expected: &TokenKind, + err: ErrorKind, + ) -> LoxResult<()> { + unimplemented!() + } + + fn current_chunk(&mut self) -> &mut Chunk { + &mut self.chunk + } + + fn end_compiler(&mut self) -> LoxResult<()> { + self.emit_op(OpCode::OpReturn); + Ok(()) + } + + fn emit_op(&mut self, op: OpCode) { + let line = self.previous().line; + self.current_chunk().add_op(op, line); + } + + fn emit_constant(&mut self, val: Value) { + let idx = self.chunk.add_constant(val); + self.emit_op(OpCode::OpConstant(idx)); + } + + fn previous(&self) -> &Token { + self.previous + .as_ref() + .expect("invalid internal compiler state: missing previous token") + } + + fn error_at(&mut self, token: &Token, kind: ErrorKind) { + if self.panic { + return; + } + + self.panic = true; + self.errors.push(Error { + kind, + line: token.line, + }) + } +} + +pub fn compile(code: &str) -> Result> { + let chars = code.chars().collect::>(); + let tokens = scanner::scan(&chars).map_err(|errors| { + errors.into_iter().map(Into::into).collect::>() + })?; + + let mut compiler = Compiler { + tokens: tokens.into_iter().peekable(), + chunk: Default::default(), + panic: false, + errors: vec![], + current: None, + previous: None, + }; + + compiler.compile()?; + + if compiler.errors.is_empty() { + Ok(unimplemented!()) + } else { + Err(compiler.errors) + } +} -- cgit 1.4.1