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 <mail@tazj.in>
This commit is contained in:
Vincent Ambo
tazjin
parent
4a86a06466
commit
78355d3c0b
2 changed files with 156 additions and 95 deletions
|
|
@ -7,6 +7,8 @@ pub enum ErrorKind {
|
|||
ExpectedSemicolon,
|
||||
ExpectedVariableName,
|
||||
TypeError(String),
|
||||
UndefinedVariable(String),
|
||||
InternalError(String),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
|
|
|
|||
|
|
@ -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<Error>) {
|
|||
|
||||
// Tree-walk interpreter
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct Environment {
|
||||
values: HashMap<String, Literal>,
|
||||
}
|
||||
|
||||
impl Environment {
|
||||
fn define(&mut self, name: &str, value: Literal) {
|
||||
self.values.insert(name.into(), value);
|
||||
}
|
||||
|
||||
fn get(&self, name: &parser::Variable) -> Result<Literal, Error> {
|
||||
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<Literal, Error> {
|
||||
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<Literal, Error> {
|
||||
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<Literal, Error> {
|
||||
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<Literal, Error> {
|
||||
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<Literal, Error> {
|
||||
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<Literal, Error> {
|
||||
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(())
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue