schala/src/eval.rs

194 lines
5.2 KiB
Rust
Raw Normal View History

2016-01-20 03:52:11 -08:00
use std::collections::HashMap;
use parser::{AST, ASTNode, Expression, Function};
2016-01-18 02:24:14 -08:00
2016-01-20 03:52:11 -08:00
struct Varmap {
map: HashMap<String, Expression>
}
impl Varmap {
fn new() -> Varmap {
2016-01-21 01:16:01 -08:00
let mut map = HashMap::new();
Varmap { map: map }
2016-01-20 03:52:11 -08:00
}
fn add_binding(&mut self, var: String, value: Expression) {
self.map.insert(var, value);
}
fn lookup_binding(&mut self, var: String) -> Option<&Expression> {
self.map.get(&var)
}
}
struct Funcmap {
map: HashMap<String, Function>,
}
impl Funcmap {
fn new() -> Funcmap {
let map = HashMap::new();
Funcmap { map: map }
}
fn add_function(&mut self, name: String, function: Function) {
self.map.insert(name, function);
}
fn lookup_function(&mut self, name: String) -> Option<&Function> {
self.map.get(&name)
}
}
2016-01-18 02:24:14 -08:00
pub struct Evaluator {
varmap: Varmap,
funcmap: Funcmap,
2016-01-18 02:24:14 -08:00
}
impl Evaluator {
pub fn new() -> Evaluator {
Evaluator { varmap: Varmap::new(), funcmap: Funcmap::new() }
2016-01-18 02:24:14 -08:00
}
pub fn run(&mut self, ast: AST) -> Vec<String> {
ast.into_iter().map(|astnode| {
self.reduce(astnode)
2016-01-18 02:24:14 -08:00
}).collect()
}
}
2016-01-19 01:30:48 -08:00
trait Evaluable {
fn is_reducible(&self) -> bool;
}
impl Evaluable for ASTNode {
fn is_reducible(&self) -> bool {
use parser::ASTNode::*;
match self {
&ExprNode(ref expr) => expr.is_reducible(),
&FuncNode(ref function) => true,
}
}
}
impl Evaluable for Expression {
fn is_reducible(&self) -> bool {
use parser::Expression::*;
match *self {
Null => false,
StringLiteral(_) => false,
Number(_) => false,
_ => true,
}
}
}
2016-01-18 02:24:14 -08:00
impl Evaluator {
fn reduce(&mut self, mut node: ASTNode) -> String {
2016-01-18 02:24:14 -08:00
loop {
node = self.step(node);
if !node.is_reducible() {
2016-01-18 02:24:14 -08:00
break
}
}
format!("{}", node)
2016-01-18 02:24:14 -08:00
}
fn step(&mut self, node: ASTNode) -> ASTNode {
self.reduce_astnode(node)
}
fn reduce_astnode(&mut self, node: ASTNode) -> ASTNode {
use parser::ASTNode::*;
match node {
ExprNode(expr) => {
if expr.is_reducible() {
ExprNode(self.reduce_expr(expr))
} else {
ExprNode(expr)
}
},
FuncNode(func) => {
let fn_name = func.prototype.name.clone();
self.funcmap.add_function(fn_name, func);
ExprNode(Expression::Null)
},
}
}
fn reduce_expr(&mut self, expression: Expression) -> Expression {
use parser::Expression::*;
match expression {
e@StringLiteral(_) => e,
e@Number(_) => e,
2016-01-21 01:16:01 -08:00
Variable(var) => {
2016-01-22 02:59:33 -08:00
match self.varmap.lookup_binding(var) {
None => Null,
Some(expr) => expr.clone()
}
2016-01-21 01:16:01 -08:00
},
2016-01-21 17:42:45 -08:00
BinExp(op, box left, box right) => {
2016-01-22 02:15:02 -08:00
if right.is_reducible() {
let new = self.reduce_expr(right);
return BinExp(op, Box::new(left), Box::new(new));
}
//special case for variable assignment
if op == "=" {
match left {
Variable(var) => {
self.varmap.add_binding(var, right);
return Null;
},
_ => ()
}
}
2016-01-21 17:42:45 -08:00
if left.is_reducible() {
let new = self.reduce_expr(left);
BinExp(op, Box::new(new), Box::new(right))
} else {
2016-01-22 02:15:02 -08:00
self.reduce_binop(op, left, right) //can assume both arguments are maximally reduced
2016-01-21 17:42:45 -08:00
}
},
_ => unimplemented!(),
}
2016-01-21 17:42:45 -08:00
}
2016-01-21 17:42:45 -08:00
fn reduce_binop(&mut self, op: String, left: Expression, right: Expression) -> Expression {
use parser::Expression::*;
match &op[..] {
"+" => match (left, right) {
(Number(l), Number(r)) => Number(l + r),
2016-01-22 04:55:01 -08:00
(StringLiteral(s1), StringLiteral(s2)) => StringLiteral(format!("{}{}", s1, s2)),
_ => Null,
2016-01-21 17:42:45 -08:00
},
"-" => match (left, right) {
(Number(l), Number(r)) => Number(l - r),
_ => Null,
2016-01-21 17:42:45 -08:00
},
2016-01-22 02:38:06 -08:00
"*" => match (left, right) {
(Number(l), Number(r)) => Number(l * r),
_ => Null,
},
"/" => match (left, right) {
(Number(l), Number(r)) if r != 0.0 => Number(l / r),
_ => Null,
},
"%" => match (left, right) {
(Number(l), Number(r)) => Number(l % r),
_ => Null,
},
2016-01-21 17:42:45 -08:00
"=" => match (left, right) {
2016-01-22 02:15:02 -08:00
(Variable(var), right) => {
self.varmap.add_binding(var, right);
Null
},
_ => Null,
2016-01-21 17:42:45 -08:00
},
_ => unimplemented!(),
}
2016-01-18 02:24:14 -08:00
}
}