schala/src/schala_lang/eval.rs

197 lines
6.2 KiB
Rust
Raw Normal View History

2018-02-23 19:06:37 -08:00
use schala_lang::parsing::{AST, Statement, Declaration, Expression, Variant, ExpressionType};
use schala_lang::builtin::{BinOp, PrefixOp};
2017-10-13 03:05:18 -07:00
use std::collections::HashMap;
use std::rc::Rc;
2017-09-30 23:30:02 -07:00
pub struct State {
2017-10-13 03:05:18 -07:00
values: HashMap<Rc<String>, ValueEntry>,
}
enum ValueEntry {
Binding {
val: FullyEvaluatedExpr,
},
Function {
body: Vec<Statement>,
}
2017-09-30 23:30:02 -07:00
}
2017-10-01 19:09:55 -07:00
type EvalResult<T> = Result<T, String>;
2017-10-13 03:05:18 -07:00
#[derive(Debug, PartialEq, Clone)]
2017-10-01 19:09:55 -07:00
enum FullyEvaluatedExpr {
UnsignedInt(u64),
SignedInt(i64),
Float(f64),
Str(String),
Bool(bool),
2017-10-23 01:54:02 -07:00
FuncLit(Rc<String>),
2017-10-13 03:05:18 -07:00
Custom {
string_rep: Rc<String>,
2017-10-23 00:22:25 -07:00
},
Tuple(Vec<FullyEvaluatedExpr>),
2017-10-01 19:09:55 -07:00
}
impl State {
pub fn new() -> State {
State { values: HashMap::new() }
2017-09-30 23:30:02 -07:00
}
2017-10-01 19:29:05 -07:00
pub fn evaluate(&mut self, ast: AST) -> Vec<String> {
let mut acc = vec![];
2017-10-01 12:55:28 -07:00
for statement in ast.0 {
2017-10-01 19:09:55 -07:00
match self.eval_statement(statement) {
Ok(output) => {
if let Some(s) = output {
2017-10-01 19:29:05 -07:00
acc.push(s);
2017-10-01 19:09:55 -07:00
}
},
Err(error) => {
2017-10-13 03:05:18 -07:00
acc.push(format!("Eval error: {}", error));
2017-10-01 19:09:55 -07:00
return acc;
},
2017-10-01 12:55:28 -07:00
}
}
2017-10-01 19:29:05 -07:00
acc
2017-10-01 12:55:28 -07:00
}
}
impl State {
2017-10-01 19:09:55 -07:00
fn eval_statement(&mut self, statement: Statement) -> EvalResult<Option<String>> {
use self::FullyEvaluatedExpr::*;
2017-10-01 12:55:28 -07:00
match statement {
2017-10-01 19:09:55 -07:00
Statement::ExpressionStatement(expr) => {
self.eval_expr(expr).map( |eval| {
match eval {
UnsignedInt(n) => Some(format!("{}", n)),
SignedInt(n) => Some(format!("{}", n)),
Float(f) => Some(format!("{}", f)),
Str(s) => Some(format!("\"{}\"", s)),
Bool(b) => Some(format!("{}", b)),
2017-10-13 03:05:18 -07:00
Custom { string_rep } => Some(format!("{}", string_rep)),
2017-10-23 00:22:25 -07:00
Tuple(_items) => Some(format!("(tuple to be defined later)")),
2017-10-23 01:54:02 -07:00
FuncLit(name) => Some(format!("<function {}>", name)),
2017-10-01 19:09:55 -07:00
}
})
},
Statement::Declaration(decl) => {
2017-10-01 19:31:43 -07:00
self.eval_decl(decl).map(|_| None)
2017-10-01 19:09:55 -07:00
}
2017-10-01 12:55:28 -07:00
}
}
2017-10-13 03:05:18 -07:00
fn eval_decl(&mut self, decl: Declaration) -> EvalResult<()> {
use self::Declaration::*;
use self::Variant::*;
match decl {
FuncDecl(signature, statements) => {
let name = signature.name;
self.values.insert(name, ValueEntry::Function { body: statements.clone() });
},
TypeDecl(_name, body) => {
for variant in body.0.iter() {
match variant {
&UnitStruct(ref name) => self.values.insert(name.clone(),
ValueEntry::Binding { val: FullyEvaluatedExpr::Custom { string_rep: name.clone() } }),
2017-10-23 01:54:02 -07:00
&TupleStruct(ref _name, ref _args) => unimplemented!(),
&Record(ref _name, ref _fields) => unimplemented!(),
2017-10-13 03:05:18 -07:00
};
}
},
_ => return Err(format!("Declaration evaluation not yet implemented"))
}
Ok(())
2017-09-30 23:30:02 -07:00
}
2017-10-01 00:48:08 -07:00
2017-10-01 19:09:55 -07:00
fn eval_expr(&mut self, expr: Expression) -> EvalResult<FullyEvaluatedExpr> {
2017-10-01 12:55:28 -07:00
use self::ExpressionType::*;
2017-10-01 19:09:55 -07:00
use self::FullyEvaluatedExpr::*;
2017-10-01 12:55:28 -07:00
let expr_type = expr.0;
2017-10-01 19:09:55 -07:00
match expr_type {
IntLiteral(n) => Ok(UnsignedInt(n)),
FloatLiteral(f) => Ok(Float(f)),
StringLiteral(s) => Ok(Str(s.to_string())),
BoolLiteral(b) => Ok(Bool(b)),
2017-10-02 20:11:27 -07:00
PrefixExp(op, expr) => self.eval_prefix_exp(op, expr),
BinExp(op, lhs, rhs) => self.eval_binexp(op, lhs, rhs),
2017-10-14 13:54:17 -07:00
Value(name, _) => self.eval_value(name),
2017-10-23 00:22:25 -07:00
TupleLiteral(expressions) => {
let mut evals = Vec::new();
for expr in expressions {
match self.eval_expr(expr) {
Ok(fully_evaluated) => evals.push(fully_evaluated),
error => return error,
}
}
Ok(Tuple(evals))
}
2017-10-23 01:54:02 -07:00
Call { f, arguments } => self.eval_application(*f, arguments),
2017-10-23 00:22:25 -07:00
x => Err(format!("Unimplemented thing {:?}", x)),
2017-10-01 19:09:55 -07:00
}
2017-10-01 12:55:28 -07:00
}
2017-10-02 20:11:27 -07:00
2017-10-23 01:54:02 -07:00
fn eval_application(&mut self, f: Expression, _arguments: Vec<Expression>) -> EvalResult<FullyEvaluatedExpr> {
use self::ExpressionType::*;
match f {
Expression(Value(identifier, _), _) => {
match self.values.get(&identifier) {
Some(&ValueEntry::Function { ref body }) => {
let new_state = State::new();
let sub_ast = AST(body.clone());
2017-10-23 01:54:02 -07:00
println!("LOL ALL FUNCTIONS EVALUATE TO 2!");
Ok(FullyEvaluatedExpr::UnsignedInt(2))
},
_ => Err(format!("Function {} not found", identifier)),
}
},
x => Err(format!("Trying to apply {:?} which is not a function", x)),
}
}
2017-10-13 03:05:18 -07:00
fn eval_value(&mut self, name: Rc<String>) -> EvalResult<FullyEvaluatedExpr> {
use self::ValueEntry::*;
match self.values.get(&name) {
None => return Err(format!("Value {} not found", *name)),
Some(lookup) => {
match lookup {
&Binding { ref val } => Ok(val.clone()),
2017-10-23 01:54:02 -07:00
&Function { .. } => Ok(FullyEvaluatedExpr::FuncLit(name.clone()))
2017-10-13 03:05:18 -07:00
}
}
}
}
2018-02-23 19:06:37 -08:00
fn eval_binexp(&mut self, op: BinOp, lhs: Box<Expression>, rhs: Box<Expression>) -> EvalResult<FullyEvaluatedExpr> {
2017-10-02 20:11:27 -07:00
use self::FullyEvaluatedExpr::*;
let evaled_lhs = self.eval_expr(*lhs)?;
let evaled_rhs = self.eval_expr(*rhs)?;
2018-02-23 19:06:37 -08:00
let sigil: &str = op.sigil.as_ref().as_str();
Ok(match (sigil, evaled_lhs, evaled_rhs) {
2017-10-02 20:11:27 -07:00
("+", UnsignedInt(l), UnsignedInt(r)) => UnsignedInt(l + r),
("++", Str(s1), Str(s2)) => Str(format!("{}{}", s1, s2)),
2017-10-02 20:11:27 -07:00
("-", UnsignedInt(l), UnsignedInt(r)) => UnsignedInt(l - r),
("*", UnsignedInt(l), UnsignedInt(r)) => UnsignedInt(l * r),
("/", UnsignedInt(l), UnsignedInt(r)) => UnsignedInt(l / r),
("%", UnsignedInt(l), UnsignedInt(r)) => UnsignedInt(l % r),
_ => return Err(format!("Runtime error: not yet implemented")),
})
}
2018-02-23 19:06:37 -08:00
fn eval_prefix_exp(&mut self, op: PrefixOp, expr: Box<Expression>) -> EvalResult<FullyEvaluatedExpr> {
2017-10-02 20:11:27 -07:00
use self::FullyEvaluatedExpr::*;
let evaled_expr = self.eval_expr(*expr)?;
2018-02-23 19:06:37 -08:00
let sigil: &str = op.sigil.as_ref().as_str();
Ok(match (sigil, evaled_expr) {
2017-10-02 20:11:27 -07:00
("!", Bool(true)) => Bool(false),
("!", Bool(false)) => Bool(true),
("-", UnsignedInt(n)) => SignedInt(-1*(n as i64)),
("-", SignedInt(n)) => SignedInt(-1*(n as i64)),
_ => return Err(format!("Runtime error: not yet implemented")),
})
}
2017-10-01 12:55:28 -07:00
}