From 78355d3c0b91e5b952be6244f23c14a2d596d05f Mon Sep 17 00:00:00 2001 From: Vincent Ambo Date: Thu, 31 Dec 2020 00:59:15 +0300 Subject: [PATCH] feat(tazjin/rlox): Add global variable support in interpreter Change-Id: I4134cf78dc3934a517ad0c848ae1d3729abaf882 Reviewed-on: https://cl.tvl.fyi/c/depot/+/2297 Tested-by: BuildkiteCI Reviewed-by: tazjin --- users/tazjin/rlox/src/errors.rs | 2 + users/tazjin/rlox/src/interpreter.rs | 249 +++++++++++++++++---------- 2 files changed, 156 insertions(+), 95 deletions(-) diff --git a/users/tazjin/rlox/src/errors.rs b/users/tazjin/rlox/src/errors.rs index 03a243124..2c29aa4c2 100644 --- a/users/tazjin/rlox/src/errors.rs +++ b/users/tazjin/rlox/src/errors.rs @@ -7,6 +7,8 @@ pub enum ErrorKind { ExpectedSemicolon, ExpectedVariableName, TypeError(String), + UndefinedVariable(String), + InternalError(String), } #[derive(Debug)] diff --git a/users/tazjin/rlox/src/interpreter.rs b/users/tazjin/rlox/src/interpreter.rs index 99df23d72..5b03883b6 100644 --- a/users/tazjin/rlox/src/interpreter.rs +++ b/users/tazjin/rlox/src/interpreter.rs @@ -1,6 +1,7 @@ use crate::errors::{report, Error, ErrorKind}; use crate::parser::{self, Declaration, Expr, Literal, Program, Statement}; use crate::scanner::{self, TokenKind}; +use std::collections::HashMap; // Run some Lox code and print it to stdout pub fn run(code: &str) { @@ -9,8 +10,9 @@ pub fn run(code: &str) { match scanner::scan(&chars) { Ok(tokens) => match parser::parse(tokens) { Ok(program) => { + let mut interpreter = Interpreter::default(); println!("Program:\n{:?}", program); - if let Err(err) = run_program(&program) { + if let Err(err) = interpreter.interpret(&program) { println!("Error in program: {:?}", err); } } @@ -28,6 +30,157 @@ fn report_errors(errors: Vec) { // Tree-walk interpreter +#[derive(Debug, Default)] +struct Environment { + values: HashMap, +} + +impl Environment { + fn define(&mut self, name: &str, value: Literal) { + self.values.insert(name.into(), value); + } + + fn get(&self, name: &parser::Variable) -> Result { + if let TokenKind::Identifier(ident) = &name.0.kind { + return self + .values + .get(ident) + .map(Clone::clone) + .ok_or_else(|| Error { + line: name.0.line, + kind: ErrorKind::UndefinedVariable(ident.into()), + }); + } + + Err(Error { + line: name.0.line, + kind: ErrorKind::InternalError("unexpected identifier kind".into()), + }) + } +} + +#[derive(Debug, Default)] +struct Interpreter { + globals: Environment, +} + +impl Interpreter { + fn interpret_stmt<'a>(&self, stmt: &Statement<'a>) -> Result<(), Error> { + match stmt { + Statement::Expr(expr) => { + self.eval(expr)?; + } + Statement::Print(expr) => { + let result = self.eval(expr)?; + println!("{:?}", result) + } + } + + Ok(()) + } + + fn interpret_var<'a>(&mut self, var: &parser::Var<'a>) -> Result<(), Error> { + if let TokenKind::Identifier(ident) = &var.name.kind { + let init = var.initialiser.as_ref().ok_or_else(|| Error { + line: var.name.line, + kind: ErrorKind::InternalError("missing variable initialiser".into()), + })?; + + self.globals.define(ident, self.eval(init)?); + return Ok(()); + } + + Err(Error { + line: var.name.line, + kind: ErrorKind::InternalError("unexpected identifier kind".into()), + }) + } + + pub fn interpret<'a>(&mut self, program: &Program<'a>) -> Result<(), Error> { + for decl in program { + match decl { + Declaration::Stmt(stmt) => self.interpret_stmt(stmt)?, + Declaration::Var(var) => self.interpret_var(var)?, + } + } + + Ok(()) + } + + fn eval<'a>(&self, expr: &Expr<'a>) -> Result { + match expr { + Expr::Literal(lit) => Ok(lit.clone()), + Expr::Grouping(grouping) => self.eval(&*grouping.0), + Expr::Unary(unary) => self.eval_unary(unary), + Expr::Binary(binary) => self.eval_binary(binary), + Expr::Variable(var) => self.globals.get(var), + } + } + + fn eval_unary<'a>(&self, expr: &parser::Unary<'a>) -> Result { + let right = self.eval(&*expr.right)?; + + match (&expr.operator.kind, right) { + (TokenKind::Minus, Literal::Number(num)) => Ok(Literal::Number(-num)), + (TokenKind::Bang, right) => Ok(Literal::Boolean(!eval_truthy(&right))), + + (op, right) => Err(Error { + line: expr.operator.line, + kind: ErrorKind::TypeError(format!( + "Operator '{:?}' can not be called with argument '{:?}'", + op, right + )), + }), + } + } + + fn eval_binary<'a>(&self, expr: &parser::Binary<'a>) -> Result { + let left = self.eval(&*expr.left)?; + let right = self.eval(&*expr.right)?; + + let result = match (&expr.operator.kind, left, right) { + // Numeric + (TokenKind::Minus, Literal::Number(l), Literal::Number(r)) => Literal::Number(l - r), + (TokenKind::Slash, Literal::Number(l), Literal::Number(r)) => Literal::Number(l / r), + (TokenKind::Star, Literal::Number(l), Literal::Number(r)) => Literal::Number(l * r), + (TokenKind::Plus, Literal::Number(l), Literal::Number(r)) => Literal::Number(l + r), + + // Strings + (TokenKind::Plus, Literal::String(l), Literal::String(r)) => { + Literal::String(format!("{}{}", l, r)) + } + + // Comparators (on numbers only?) + (TokenKind::Greater, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l > r), + (TokenKind::GreaterEqual, Literal::Number(l), Literal::Number(r)) => { + Literal::Boolean(l >= r) + } + (TokenKind::Less, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l < r), + (TokenKind::LessEqual, Literal::Number(l), Literal::Number(r)) => { + Literal::Boolean(l <= r) + } + + // Equality + (TokenKind::Equal, l, r) => Literal::Boolean(l == r), + (TokenKind::BangEqual, l, r) => Literal::Boolean(l != r), + + (op, left, right) => { + return Err(Error { + line: expr.operator.line, + kind: ErrorKind::TypeError(format!( + "Operator '{:?}' can not be called with arguments '({:?}, {:?})'", + op, left, right + )), + }) + } + }; + + Ok(result) + } +} + +// Interpreter functions not dependent on interpreter-state. + fn eval_truthy(lit: &Literal) -> bool { match lit { Literal::Nil => false, @@ -35,97 +188,3 @@ fn eval_truthy(lit: &Literal) -> bool { _ => true, } } - -fn eval_unary<'a>(expr: &parser::Unary<'a>) -> Result { - let right = eval(&*expr.right)?; - - match (&expr.operator.kind, right) { - (TokenKind::Minus, Literal::Number(num)) => Ok(Literal::Number(-num)), - (TokenKind::Bang, right) => Ok(Literal::Boolean(!eval_truthy(&right))), - - (op, right) => Err(Error { - line: expr.operator.line, - kind: ErrorKind::TypeError(format!( - "Operator '{:?}' can not be called with argument '{:?}'", - op, right - )), - }), - } -} - -fn eval_binary<'a>(expr: &parser::Binary<'a>) -> Result { - let left = eval(&*expr.left)?; - let right = eval(&*expr.right)?; - - let result = match (&expr.operator.kind, left, right) { - // Numeric - (TokenKind::Minus, Literal::Number(l), Literal::Number(r)) => Literal::Number(l - r), - (TokenKind::Slash, Literal::Number(l), Literal::Number(r)) => Literal::Number(l / r), - (TokenKind::Star, Literal::Number(l), Literal::Number(r)) => Literal::Number(l * r), - (TokenKind::Plus, Literal::Number(l), Literal::Number(r)) => Literal::Number(l + r), - - // Strings - (TokenKind::Plus, Literal::String(l), Literal::String(r)) => { - Literal::String(format!("{}{}", l, r)) - } - - // Comparators (on numbers only?) - (TokenKind::Greater, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l > r), - (TokenKind::GreaterEqual, Literal::Number(l), Literal::Number(r)) => { - Literal::Boolean(l >= r) - } - (TokenKind::Less, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l < r), - (TokenKind::LessEqual, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l <= r), - - // Equality - (TokenKind::Equal, l, r) => Literal::Boolean(l == r), - (TokenKind::BangEqual, l, r) => Literal::Boolean(l != r), - - (op, left, right) => { - return Err(Error { - line: expr.operator.line, - kind: ErrorKind::TypeError(format!( - "Operator '{:?}' can not be called with arguments '({:?}, {:?})'", - op, left, right - )), - }) - } - }; - - Ok(result) -} - -fn eval<'a>(expr: &Expr<'a>) -> Result { - match expr { - Expr::Literal(lit) => Ok(lit.clone()), - Expr::Grouping(grouping) => eval(&*grouping.0), - Expr::Unary(unary) => eval_unary(unary), - Expr::Binary(binary) => eval_binary(binary), - Expr::Variable(_) => unimplemented!(), - } -} - -fn run_stmt<'a>(stmt: &Statement<'a>) -> Result<(), Error> { - match stmt { - Statement::Expr(expr) => { - eval(expr)?; - } - Statement::Print(expr) => { - let result = eval(expr)?; - println!("{:?}", result) - } - } - - Ok(()) -} - -fn run_program<'a>(program: &Program<'a>) -> Result<(), Error> { - for decl in program { - match decl { - Declaration::Stmt(stmt) => run_stmt(stmt)?, - Declaration::Var(_var) => unimplemented!(), - } - } - - Ok(()) -}