statements in rust
This commit is contained in:
parent
15b331f447
commit
a629ddca05
6 changed files with 434 additions and 194 deletions
|
|
@ -1,110 +1,233 @@
|
|||
use thiserror::Error;
|
||||
use tracing::error;
|
||||
|
||||
use crate::{
|
||||
environment::{Environment, EnvironmentError},
|
||||
expression::Expression,
|
||||
statement::Statement,
|
||||
token::{Literal, Token, TokenType},
|
||||
value::Value,
|
||||
};
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum InterpreterError {
|
||||
#[error("line {0}: MINUS unary expression expects a number on the right")]
|
||||
#[error("[line {0}] MINUS unary expression expects a number on the right")]
|
||||
UnaryExpressionNotANumber(usize),
|
||||
#[error("line {0}: unknown unary operator: {1}")]
|
||||
#[error("[line {0}] unknown unary operator: {1}")]
|
||||
UnaryOperatorUnknown(usize, String),
|
||||
#[error("line {0}: unknown binary operator: {1}")]
|
||||
#[error("[line {0}] unknown binary operator: {1}")]
|
||||
BinaryOperatorUnknown(usize, String),
|
||||
#[error("[line {0}] left or right is not a number.")]
|
||||
BinaryExpressionNeedsNumber(usize),
|
||||
#[error("[line {0}] left or right is neither a number nor string.")]
|
||||
BinaryExpressionNeedsNumberOrString(usize),
|
||||
#[error("{0}")]
|
||||
UndefinedVariable(EnvironmentError),
|
||||
}
|
||||
|
||||
/// Try to evaluate an expression and return its result.
|
||||
pub fn evaluate(expression: Expression) -> Result<Value, InterpreterError> {
|
||||
match expression {
|
||||
Expression::Literal { value } => literal(value),
|
||||
Expression::Grouping { expression } => grouping(*expression),
|
||||
Expression::Unary {
|
||||
operator: op,
|
||||
right,
|
||||
} => unary(op, *right),
|
||||
Expression::Binary {
|
||||
left,
|
||||
operator,
|
||||
right,
|
||||
} => binary(*left, operator, *right),
|
||||
/// Interpreter for the Lox language.
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Interpreter {
|
||||
environment: Environment,
|
||||
}
|
||||
|
||||
impl Interpreter {
|
||||
/// Try to evaluate an expression and return its result.
|
||||
pub fn run(&mut self, statements: Vec<Statement>) -> Result<(), InterpreterError> {
|
||||
for stmt in statements {
|
||||
match self.execute(stmt) {
|
||||
Ok(_) => {}
|
||||
Err(e) => error!("{e}"),
|
||||
};
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert the literal value into a Value.
|
||||
fn literal(literal: Literal) -> Result<Value, InterpreterError> {
|
||||
Ok(literal.into())
|
||||
}
|
||||
///Execute a statement.
|
||||
fn execute(&mut self, statement: Statement) -> Result<(), InterpreterError> {
|
||||
match statement {
|
||||
Statement::Block(statements) => {
|
||||
let sub_env = Environment::with_enclosing(self.environment.clone());
|
||||
self.block(statements, sub_env)?
|
||||
}
|
||||
Statement::Print(expression) => self.print_statement(expression)?,
|
||||
Statement::Expression(expression) => {
|
||||
self.evaluate(expression)?;
|
||||
}
|
||||
Statement::Var { name, initializer } => self.var_statement(name, *initializer)?,
|
||||
};
|
||||
|
||||
/// Evaluate the inner expression.
|
||||
fn grouping(inner: Expression) -> Result<Value, InterpreterError> {
|
||||
evaluate(inner)
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Evaluate the expression on the right and use its result when evaluating the unary operator.
|
||||
fn unary(op: Token, right: Expression) -> Result<Value, InterpreterError> {
|
||||
let right = evaluate(right)?;
|
||||
/// Execute all statements within a block, using a new environment (with the old one as the
|
||||
/// enclosing one).
|
||||
fn block(
|
||||
&mut self,
|
||||
statements: Vec<Statement>,
|
||||
environment: Environment,
|
||||
) -> Result<(), InterpreterError> {
|
||||
let prev_env = &self.environment.clone();
|
||||
self.environment = environment;
|
||||
|
||||
match op.token_type {
|
||||
TokenType::Minus => {
|
||||
if let Value::Number(val) = right {
|
||||
Ok(Value::Number(-val))
|
||||
} else {
|
||||
Err(InterpreterError::UnaryExpressionNotANumber(op.line))
|
||||
for stmt in statements {
|
||||
if let Err(e) = self.execute(stmt) {
|
||||
error!("{e}");
|
||||
}
|
||||
}
|
||||
TokenType::Bang => Ok(Value::Boolean(!right.is_truthy())),
|
||||
_ => Err(InterpreterError::UnaryOperatorUnknown(op.line, op.lexeme)),
|
||||
|
||||
self.environment = prev_env.clone();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculate number operations.
|
||||
fn number_op(left: f64, op: TokenType, right: f64) -> f64 {
|
||||
match op {
|
||||
TokenType::Minus => left - right,
|
||||
TokenType::Plus => left + right,
|
||||
TokenType::Slash => left / right,
|
||||
TokenType::Star => left * right,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculate boolean operations.
|
||||
fn boolean_op(left: f64, op: TokenType, right: f64) -> bool {
|
||||
match op {
|
||||
TokenType::Greater => left > right,
|
||||
TokenType::GreaterEqual => left >= right,
|
||||
TokenType::Less => left < right,
|
||||
TokenType::LessEqual => left <= right,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Evaluate the left and right expressions (in that order) and then combine them with the
|
||||
/// specified operator.
|
||||
fn binary(left: Expression, op: Token, right: Expression) -> Result<Value, InterpreterError> {
|
||||
let left = evaluate(left)?;
|
||||
let right = evaluate(right)?;
|
||||
|
||||
match op.token_type {
|
||||
TokenType::Minus | TokenType::Slash | TokenType::Star | TokenType::Plus => {
|
||||
if let (Value::Number(left), Value::Number(right)) = (left, right) {
|
||||
Ok(Value::Number(number_op(left, op.token_type, right)))
|
||||
} else {
|
||||
todo!()
|
||||
}
|
||||
/// Evaluate an expression and return its value.
|
||||
fn evaluate(&mut self, expression: Expression) -> Result<Value, InterpreterError> {
|
||||
match expression {
|
||||
Expression::Literal { value } => self.literal(value),
|
||||
Expression::Grouping { expression } => self.grouping(*expression),
|
||||
Expression::Unary {
|
||||
operator: op,
|
||||
right,
|
||||
} => self.unary(op, *right),
|
||||
Expression::Binary {
|
||||
left,
|
||||
operator,
|
||||
right,
|
||||
} => self.binary(*left, operator, *right),
|
||||
Expression::Variable { name } => self.var_expression(&name),
|
||||
Expression::Assign { name, value } => self.assign(&name, *value),
|
||||
}
|
||||
TokenType::Greater | TokenType::GreaterEqual | TokenType::Less | TokenType::LessEqual => {
|
||||
if let (Value::Number(left), Value::Number(right)) = (left, right) {
|
||||
Ok(Value::Boolean(boolean_op(left, op.token_type, right)))
|
||||
} else {
|
||||
todo!()
|
||||
}
|
||||
|
||||
/// Evaluate an expression and print its value to stdout.
|
||||
fn print_statement(&mut self, expression: Expression) -> Result<(), InterpreterError> {
|
||||
let value = self.evaluate(expression)?;
|
||||
println!("{value}");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Initialize a variable with an initializer expression or nil.
|
||||
fn var_statement(
|
||||
&mut self,
|
||||
name: Token,
|
||||
initializer: Option<Expression>,
|
||||
) -> Result<(), InterpreterError> {
|
||||
let value = if let Some(initializer) = initializer {
|
||||
self.evaluate(initializer)
|
||||
} else {
|
||||
Ok(Value::Nil)
|
||||
}?;
|
||||
|
||||
self.environment.define(name.lexeme, value);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Assign the value of an expression to a variable.
|
||||
fn assign(&mut self, name: &Token, value: Expression) -> Result<Value, InterpreterError> {
|
||||
let value = self.evaluate(value)?;
|
||||
|
||||
self.environment
|
||||
.assign(name, value.clone())
|
||||
.map_err(InterpreterError::UndefinedVariable)?;
|
||||
Ok(value)
|
||||
}
|
||||
|
||||
/// Convert the literal value into a Value.
|
||||
fn literal(&self, literal: Literal) -> Result<Value, InterpreterError> {
|
||||
Ok(literal.into())
|
||||
}
|
||||
|
||||
/// Evaluate the inner expression.
|
||||
fn grouping(&mut self, inner: Expression) -> Result<Value, InterpreterError> {
|
||||
self.evaluate(inner)
|
||||
}
|
||||
|
||||
/// Evaluate the expression on the right and use its result when evaluating the unary operator.
|
||||
fn unary(&mut self, op: Token, right: Expression) -> Result<Value, InterpreterError> {
|
||||
let right = self.evaluate(right)?;
|
||||
|
||||
match op.token_type {
|
||||
TokenType::Minus => {
|
||||
if let Value::Number(val) = right {
|
||||
Ok(Value::Number(-val))
|
||||
} else {
|
||||
Err(InterpreterError::UnaryExpressionNotANumber(op.line))
|
||||
}
|
||||
}
|
||||
TokenType::Bang => Ok(Value::Boolean(!right.is_truthy())),
|
||||
_ => Err(InterpreterError::UnaryOperatorUnknown(op.line, op.lexeme)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the value of a variable.
|
||||
fn var_expression(&mut self, name: &Token) -> Result<Value, InterpreterError> {
|
||||
self.environment
|
||||
.get(name)
|
||||
.map_err(InterpreterError::UndefinedVariable)
|
||||
}
|
||||
|
||||
/// Calculate number operations.
|
||||
fn number_op(&self, left: f64, op: TokenType, right: f64) -> f64 {
|
||||
match op {
|
||||
TokenType::Minus => left - right,
|
||||
TokenType::Plus => left + right,
|
||||
TokenType::Slash => left / right,
|
||||
TokenType::Star => left * right,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculate boolean operations.
|
||||
fn boolean_op(&self, left: f64, op: TokenType, right: f64) -> bool {
|
||||
match op {
|
||||
TokenType::Greater => left > right,
|
||||
TokenType::GreaterEqual => left >= right,
|
||||
TokenType::Less => left < right,
|
||||
TokenType::LessEqual => left <= right,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Evaluate the left and right expressions (in that order) and then combine them with the
|
||||
/// specified operator.
|
||||
fn binary(
|
||||
&mut self,
|
||||
left: Expression,
|
||||
op: Token,
|
||||
right: Expression,
|
||||
) -> Result<Value, InterpreterError> {
|
||||
let left = self.evaluate(left)?;
|
||||
let right = self.evaluate(right)?;
|
||||
|
||||
match op.token_type {
|
||||
TokenType::Minus | TokenType::Slash | TokenType::Star | TokenType::Plus => {
|
||||
if let (Value::Number(left), Value::Number(right)) = (left.clone(), right.clone()) {
|
||||
Ok(Value::Number(self.number_op(left, op.token_type, right)))
|
||||
} else if let (Value::String(left), Value::String(right)) = (left, right) {
|
||||
Ok(Value::String(format!("{}{}", left.clone(), right.clone())))
|
||||
} else {
|
||||
Err(InterpreterError::BinaryExpressionNeedsNumberOrString(
|
||||
op.line,
|
||||
))
|
||||
}
|
||||
}
|
||||
TokenType::Greater
|
||||
| TokenType::GreaterEqual
|
||||
| TokenType::Less
|
||||
| TokenType::LessEqual => {
|
||||
if let (Value::Number(left), Value::Number(right)) = (left, right) {
|
||||
Ok(Value::Boolean(self.boolean_op(left, op.token_type, right)))
|
||||
} else {
|
||||
Err(InterpreterError::BinaryExpressionNeedsNumber(op.line))
|
||||
}
|
||||
}
|
||||
TokenType::BangEqual => Ok(Value::Boolean(left != right)),
|
||||
TokenType::EqualEqual => Ok(Value::Boolean(left == right)),
|
||||
_ => Err(InterpreterError::BinaryOperatorUnknown(op.line, op.lexeme)),
|
||||
}
|
||||
TokenType::BangEqual => Ok(Value::Boolean(left != right)),
|
||||
TokenType::EqualEqual => Ok(Value::Boolean(left == right)),
|
||||
_ => Err(InterpreterError::BinaryOperatorUnknown(op.line, op.lexeme)),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue