mirror of
https://github.com/MorizzG/rlox.git
synced 2025-12-06 04:12:42 +00:00
renamed interpret to interpreter
This commit is contained in:
parent
f9804c0c29
commit
b8741ea3cc
4 changed files with 3 additions and 3 deletions
377
interpreter/src/interpreter.rs
Normal file
377
interpreter/src/interpreter.rs
Normal file
|
|
@ -0,0 +1,377 @@
|
|||
use std::rc::Rc;
|
||||
|
||||
use rlox2_frontend::parser::{BinaryOp, Expr, Literal, LogicalOp, Stmt, UnaryOp};
|
||||
use rustc_hash::FxHashMap;
|
||||
|
||||
use crate::error::RuntimeError;
|
||||
use crate::function::LoxExternFunction;
|
||||
use crate::{LoxClass, LoxReference};
|
||||
|
||||
use super::environment::Environment;
|
||||
use super::{LoxFunction, Runtime, Value};
|
||||
|
||||
pub type EvalResult<T> = Result<T, RuntimeError>;
|
||||
|
||||
/*====================================================================================================================*/
|
||||
|
||||
pub fn execute(statement: Stmt, runtime: &mut Runtime) -> Result<(), RuntimeError> {
|
||||
let mut env = Environment::new(runtime);
|
||||
|
||||
statement.eval(&mut env)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/*====================================================================================================================*/
|
||||
|
||||
trait Eval {
|
||||
fn eval(&self, env: &mut Environment) -> EvalResult<Value>;
|
||||
}
|
||||
|
||||
impl Eval for Literal {
|
||||
fn eval(&self, _env: &mut Environment) -> EvalResult<Value> {
|
||||
match self {
|
||||
Literal::String(s) => Ok(Value::String(s.clone())),
|
||||
Literal::Number(num) => Ok(Value::Number(*num)),
|
||||
Literal::Bool(b) => Ok(Value::Bool(*b)),
|
||||
Literal::Nil => Ok(Value::Nil),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Eval for Expr {
|
||||
fn eval(&self, env: &mut Environment) -> EvalResult<Value> {
|
||||
match self {
|
||||
Expr::Literal { literal } => literal.eval(env),
|
||||
Expr::Unary { op, expr } => {
|
||||
let arg = expr.eval(env)?;
|
||||
|
||||
match (*op, arg) {
|
||||
(UnaryOp::Negate, Value::Number(num)) => Ok(Value::Number(-num)),
|
||||
(UnaryOp::Not, Value::Bool(b)) => Ok(Value::Bool(!b)),
|
||||
(UnaryOp::Not, primitive) => Ok(Value::Bool(!primitive.is_truthy())),
|
||||
(op, arg) => Err(RuntimeError::UnaryOpInvalidArgument { op, arg }),
|
||||
}
|
||||
}
|
||||
Expr::Binary { left, op, right } => {
|
||||
use Value::{Bool, Number, String};
|
||||
|
||||
let op = *op;
|
||||
|
||||
let left = left.eval(env)?;
|
||||
let right = right.eval(env)?;
|
||||
|
||||
if op == BinaryOp::Equal {
|
||||
return Ok(Bool(left == right));
|
||||
}
|
||||
|
||||
if op == BinaryOp::NotEqual {
|
||||
return Ok(Bool(left != right));
|
||||
}
|
||||
|
||||
match (left, right) {
|
||||
(Number(left), Number(right)) => match op {
|
||||
BinaryOp::Add => Ok(Number(left + right)),
|
||||
BinaryOp::Subtract => Ok(Number(left - right)),
|
||||
BinaryOp::Multiply => Ok(Number(left * right)),
|
||||
BinaryOp::Divide => Ok(Number(left / right)),
|
||||
BinaryOp::Less => Ok(Bool(left < right)),
|
||||
BinaryOp::LessEqual => Ok(Bool(left <= right)),
|
||||
BinaryOp::Greater => Ok(Bool(left > right)),
|
||||
BinaryOp::GreaterEqual => Ok(Bool(left >= right)),
|
||||
_ => unreachable!(),
|
||||
},
|
||||
(String(left), String(right)) => match op {
|
||||
BinaryOp::Add => {
|
||||
let s: Box<str> =
|
||||
itertools::chain(left.as_ref().chars(), right.chars()).collect();
|
||||
|
||||
Ok(Value::string(s))
|
||||
}
|
||||
BinaryOp::Less => Ok(Bool(left < right)),
|
||||
BinaryOp::LessEqual => Ok(Bool(left <= right)),
|
||||
BinaryOp::Greater => Ok(Bool(left > right)),
|
||||
BinaryOp::GreaterEqual => Ok(Bool(left >= right)),
|
||||
BinaryOp::Equal | BinaryOp::NotEqual => unreachable!(),
|
||||
_ => Err(RuntimeError::BinaryOpInvalidArguments {
|
||||
left: String(left),
|
||||
op,
|
||||
right: String(right),
|
||||
}),
|
||||
},
|
||||
(left, right) => {
|
||||
Err(RuntimeError::BinaryOpInvalidArguments { left, op, right })
|
||||
}
|
||||
}
|
||||
}
|
||||
Expr::Logical { left, op, right } => {
|
||||
let left = left.eval(env)?;
|
||||
|
||||
// shortcircuit
|
||||
if *op == LogicalOp::Or && left.is_truthy()
|
||||
|| *op == LogicalOp::And && !left.is_truthy()
|
||||
{
|
||||
return Ok(left);
|
||||
}
|
||||
|
||||
let right = right.eval(env)?;
|
||||
Ok(right)
|
||||
}
|
||||
Expr::Grouping { expr } => expr.eval(env),
|
||||
Expr::Variable { name } => panic!("Unresolved variable {name}"),
|
||||
Expr::LocalVariable { name, level } => env.get_local(name, *level),
|
||||
Expr::GlobalVariable { name } => env.get_global(name),
|
||||
Expr::Assignment { target, value } => {
|
||||
let value = value.eval(env)?;
|
||||
|
||||
match target.as_ref() {
|
||||
Expr::LocalVariable { name, level } => {
|
||||
env.assign(name, value.clone(), *level)?
|
||||
}
|
||||
Expr::GlobalVariable { name } => env.assign_global(name, value.clone())?,
|
||||
_ => panic!("Invalid assigment target {target}"),
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
Expr::Call { callee, args } => {
|
||||
let callee = callee.eval(env)?;
|
||||
/* let args = args
|
||||
.iter()
|
||||
.map(|arg| arg.eval(env))
|
||||
.collect::<EvalResult<Vec<Value>>>()?; */
|
||||
|
||||
for arg in args {
|
||||
let arg = arg.eval(env)?;
|
||||
env.push_arg(arg);
|
||||
}
|
||||
|
||||
match callee {
|
||||
Value::Function(fun) => call_fun(fun, env),
|
||||
Value::ExternFunction(ext_fun) => call_extfun(ext_fun, env),
|
||||
Value::Class(class) => call_class(class, env),
|
||||
_ => Err(RuntimeError::NotCallable { callee }),
|
||||
}
|
||||
}
|
||||
Expr::Get { target, name } => {
|
||||
let target = target.eval(env)?;
|
||||
|
||||
if let Value::Object(object) = target {
|
||||
object.get(name).ok_or_else(|| {
|
||||
let class = object.class();
|
||||
let name = name.to_owned();
|
||||
RuntimeError::UndefinedAttribute { class, name }
|
||||
})
|
||||
} else {
|
||||
Err(RuntimeError::InvalidGetTarget)
|
||||
}
|
||||
}
|
||||
Expr::Set {
|
||||
target,
|
||||
name,
|
||||
value,
|
||||
} => {
|
||||
let target = target.eval(env)?;
|
||||
|
||||
if let Value::Object(mut object) = target {
|
||||
let value = value.eval(env)?;
|
||||
object.set(name.clone(), value);
|
||||
Ok(Value::Nil)
|
||||
} else {
|
||||
Err(RuntimeError::InvalidSetTarget)
|
||||
}
|
||||
}
|
||||
Expr::Function {
|
||||
name,
|
||||
param_names,
|
||||
closure_vars,
|
||||
body,
|
||||
} => Ok(Value::function(LoxFunction::new(
|
||||
name.clone(),
|
||||
env.collect_closure(closure_vars),
|
||||
param_names.clone(),
|
||||
body.as_ref().clone(),
|
||||
))),
|
||||
Expr::Class {
|
||||
superclass,
|
||||
name,
|
||||
methods: method_exprs,
|
||||
} => {
|
||||
let superclass = match superclass.as_ref().map(|expr| expr.eval(env)) {
|
||||
Some(Ok(Value::Class(superclass))) => Some(superclass),
|
||||
Some(Ok(value)) => return Err(RuntimeError::InvalidSuperclass { value }),
|
||||
Some(Err(err)) => return Err(err),
|
||||
None => None,
|
||||
};
|
||||
|
||||
let mut methods: FxHashMap<String, Value> = FxHashMap::default();
|
||||
|
||||
// this is the scope "this" will get injected in
|
||||
env.enter_scope()?;
|
||||
|
||||
for method_expr in method_exprs.iter() {
|
||||
let method = method_expr.eval(env)?;
|
||||
if let Value::Function(ref fun) = method {
|
||||
let name = fun.name().to_owned();
|
||||
methods.insert(name, method);
|
||||
}
|
||||
}
|
||||
|
||||
env.exit_scope();
|
||||
|
||||
Ok(Value::class(LoxClass::new(
|
||||
name.clone(),
|
||||
methods,
|
||||
superclass,
|
||||
)))
|
||||
}
|
||||
Expr::This => panic!("Unresolved this"),
|
||||
Expr::Super {
|
||||
super_var,
|
||||
this_var,
|
||||
method,
|
||||
} => match (super_var.eval(env)?, this_var.eval(env)?) {
|
||||
(Value::Class(superclass), Value::Object(this)) => {
|
||||
if let Some(method) = superclass.get_method(method, this) {
|
||||
Ok(method)
|
||||
} else {
|
||||
Err(RuntimeError::InvalidGetTarget)
|
||||
}
|
||||
}
|
||||
(super_val, this_val) => {
|
||||
panic!("super evaluated to {super_val} and this evaluated to {this_val}")
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Eval for Stmt {
|
||||
fn eval(&self, env: &mut Environment) -> EvalResult<Value> {
|
||||
match self {
|
||||
Stmt::Print { expr } => {
|
||||
use std::io::Write;
|
||||
|
||||
let val = expr.eval(env)?;
|
||||
writeln!(env.runtime(), "{val}").unwrap();
|
||||
}
|
||||
Stmt::IfStmt {
|
||||
condition,
|
||||
then_branch,
|
||||
else_branch,
|
||||
} => {
|
||||
let condition = condition.eval(env)?;
|
||||
if condition.is_truthy() {
|
||||
then_branch.eval(env)?;
|
||||
} else if let Some(else_branch) = else_branch {
|
||||
else_branch.eval(env)?;
|
||||
}
|
||||
}
|
||||
Stmt::While { condition, body } => {
|
||||
while condition.eval(env)?.is_truthy() {
|
||||
match body.eval(env) {
|
||||
Ok(_) => {}
|
||||
Err(RuntimeError::Break) => break,
|
||||
Err(err) => return Err(err),
|
||||
}
|
||||
}
|
||||
}
|
||||
Stmt::VarDecl { name, initializer } => {
|
||||
let initializer = initializer.eval(env)?;
|
||||
env.define(name.clone(), initializer);
|
||||
}
|
||||
Stmt::Block { statements } => {
|
||||
env.enter_scope()?;
|
||||
for statement in statements {
|
||||
if let Err(err) = statement.eval(env) {
|
||||
env.exit_scope();
|
||||
return Err(err);
|
||||
}
|
||||
}
|
||||
env.exit_scope();
|
||||
}
|
||||
Stmt::ExprStmt { expr } => {
|
||||
// expr.eval(env)?;
|
||||
// Ok(Value::Nil)
|
||||
expr.eval(env)?;
|
||||
}
|
||||
Stmt::Break => return Err(RuntimeError::Break),
|
||||
Stmt::Return { expr } => {
|
||||
let value = expr.eval(env)?;
|
||||
return Err(RuntimeError::Return { value });
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Value::Nil)
|
||||
}
|
||||
}
|
||||
|
||||
/*====================================================================================================================*/
|
||||
|
||||
pub fn call_fun(fun: Rc<LoxFunction>, env: &mut Environment) -> EvalResult<Value> {
|
||||
let args = env.collect_args();
|
||||
|
||||
if args.len() != fun.arity() {
|
||||
return Err(RuntimeError::WrongArity {
|
||||
name: fun.name().to_owned(),
|
||||
arity: fun.arity(),
|
||||
given: args.len(),
|
||||
});
|
||||
}
|
||||
|
||||
env.enter_scope()?;
|
||||
|
||||
env.define(fun.name(), Value::Function(fun.clone()));
|
||||
|
||||
env.insert_closure(fun.closure().clone());
|
||||
|
||||
for (name, value) in std::iter::zip(fun.param_names(), args) {
|
||||
env.define(name.clone(), value);
|
||||
}
|
||||
|
||||
let ret_val = match fun.body().eval(env) {
|
||||
Ok(_) => Ok(Value::Nil),
|
||||
Err(RuntimeError::Return { value }) => Ok(value),
|
||||
Err(err) => Err(err),
|
||||
};
|
||||
|
||||
env.exit_scope();
|
||||
|
||||
ret_val
|
||||
}
|
||||
|
||||
pub fn call_extfun(ext_fun: Rc<LoxExternFunction>, env: &mut Environment) -> EvalResult<Value> {
|
||||
let args = env.collect_args();
|
||||
|
||||
if args.len() != ext_fun.arity() {
|
||||
return Err(RuntimeError::WrongArity {
|
||||
name: ext_fun.name().to_owned(),
|
||||
arity: ext_fun.arity(),
|
||||
given: args.len(),
|
||||
});
|
||||
}
|
||||
|
||||
(ext_fun.closure())(args, env)
|
||||
}
|
||||
|
||||
// has to take class as an argument instead of as self to leave it behind its Rc
|
||||
pub fn call_class(class: Rc<LoxClass>, env: &mut Environment) -> EvalResult<Value> {
|
||||
// let args = env.collect_args();
|
||||
|
||||
if env.num_args() != class.arity() {
|
||||
return Err(RuntimeError::WrongArity {
|
||||
name: class.name().to_owned(),
|
||||
arity: class.arity(),
|
||||
given: env.num_args(),
|
||||
});
|
||||
}
|
||||
|
||||
let object = LoxReference::new(class);
|
||||
|
||||
// object.init(args, env)?;
|
||||
|
||||
if let Some(Value::Function(method)) = object.get("init") {
|
||||
call_fun(method, env)?;
|
||||
}
|
||||
|
||||
Ok(Value::Object(object))
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue