schala/src/eval.rs

258 lines
7.3 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-12-21 19:22:08 -08:00
#[derive(Debug)]
enum SideEffect {
Print(String),
Bundle(Vec<SideEffect>),
}
2016-01-20 03:52:11 -08:00
struct Varmap {
map: HashMap<String, Expression>
}
impl Varmap {
fn new() -> Varmap {
2016-01-24 16:10:18 -08:00
Varmap { map: HashMap::new()}
2016-01-20 03:52:11 -08:00
}
}
struct Funcmap {
map: HashMap<String, Function>,
}
impl Funcmap {
fn new() -> Funcmap {
let map = HashMap::new();
Funcmap { map: map }
}
}
2016-01-18 02:24:14 -08:00
pub struct Evaluator {
varmap: Varmap,
funcmap: Funcmap,
2016-01-23 20:49:16 -08:00
frames: Vec<Varmap>,
2016-01-18 02:24:14 -08:00
}
impl Evaluator {
pub fn new() -> Evaluator {
2016-01-23 20:49:16 -08:00
Evaluator { varmap: Varmap::new(),
funcmap: Funcmap::new(),
frames: Vec::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()
}
fn add_binding(&mut self, var: String, value: Expression) {
2016-01-24 15:48:56 -08:00
match self.frames.last_mut() {
Some(frame) => frame.map.insert(var, value),
None => self.varmap.map.insert(var, value),
};
}
2016-01-23 20:49:16 -08:00
fn lookup_binding(&mut self, var: String) -> Option<Expression> {
for frame in self.frames.iter().rev() {
match frame.map.get(&var) {
None => (),
Some(expr) => return Some(expr.clone()),
}
}
2016-01-23 20:49:16 -08:00
self.varmap.map.get(&var).map(|expr| expr.clone())
}
fn add_function(&mut self, name: String, function: Function) {
self.funcmap.map.insert(name, function);
}
fn lookup_function(&self, name: String) -> Option<Function> {
self.funcmap.map.get(&name).map(|x| x.clone())
}
2016-01-18 02:24:14 -08:00
}
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(),
2016-01-24 16:10:18 -08:00
&FuncNode(_) => 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 {
2016-12-21 19:22:08 -08:00
let (new_node, side_effect) = self.reduce_astnode(node);
if let Some(s) = side_effect {
self.perform_side_effect(s);
}
new_node
}
2016-12-21 19:22:08 -08:00
fn perform_side_effect(&mut self, side_effect: SideEffect) {
println!("lol doin' a side effect {:?}", side_effect);
}
fn reduce_astnode(&mut self, node: ASTNode) -> (ASTNode, Option<SideEffect>) {
use parser::ASTNode::*;
match node {
ExprNode(expr) => {
if expr.is_reducible() {
2016-12-21 19:22:08 -08:00
let (new_expr, side_effect) = self.reduce_expr(expr);
(ExprNode(new_expr), side_effect)
} else {
2016-12-21 19:22:08 -08:00
(ExprNode(expr), None)
}
},
FuncNode(func) => {
let fn_name = func.prototype.name.clone();
self.add_function(fn_name, func);
2016-12-21 19:22:08 -08:00
(ExprNode(Expression::Null), None)
},
}
}
2016-12-21 19:22:08 -08:00
fn reduce_expr(&mut self, expression: Expression) -> (Expression, Option<SideEffect>) {
use parser::Expression::*;
match expression {
2016-12-21 19:22:08 -08:00
Null => (Null, None),
e@StringLiteral(_) => (e, None),
e@Number(_) => (e, None),
2016-01-21 01:16:01 -08:00
Variable(var) => {
match self.lookup_binding(var) {
2016-12-21 19:22:08 -08:00
None => (Null, None),
Some(expr) => (expr, None),
2016-01-22 02:59:33 -08:00
}
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);
2016-12-21 19:22:08 -08:00
return (BinExp(op, Box::new(left), Box::new(new.0)), new.1);
2016-01-22 02:15:02 -08:00
}
//special case for variable assignment
if op == "=" {
match left {
Variable(var) => {
self.add_binding(var, right);
2016-12-21 19:22:08 -08:00
return (Null, None);
2016-01-22 02:15:02 -08:00
},
_ => ()
}
}
2016-01-21 17:42:45 -08:00
if left.is_reducible() {
let new = self.reduce_expr(left);
2016-12-21 19:22:08 -08:00
(BinExp(op, Box::new(new.0), Box::new(right)), new.1)
2016-01-21 17:42:45 -08:00
} else {
2016-12-21 19:22:08 -08:00
(self.reduce_binop(op, left, right), None) //can assume both arguments are maximally reduced
2016-01-21 17:42:45 -08:00
}
},
2016-01-26 02:57:09 -08:00
Call(name, args) => self.reduce_call(name, args),
Conditional(_,_,_) => 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.add_binding(var, right);
2016-01-22 02:15:02 -08:00
Null
},
_ => Null,
2016-01-21 17:42:45 -08:00
},
_ => Null,
2016-01-21 17:42:45 -08:00
}
2016-01-18 02:24:14 -08:00
}
2016-12-21 19:22:08 -08:00
fn reduce_call(&mut self, name: String, arguments: Vec<Expression>) -> (Expression, Option<SideEffect>) {
use parser::Expression::*;
let function = match self.lookup_function(name) {
Some(func) => func,
2016-12-21 19:22:08 -08:00
None => return (Null, None)
};
if function.prototype.parameters.len() != arguments.len() {
2016-12-21 19:22:08 -08:00
return (Null, None)
}
let mut frame: Varmap = Varmap::new();
for (binding, expr) in function.prototype.parameters.iter().zip(arguments.iter()) {
frame.map.insert(binding.clone(), expr.clone());
}
self.frames.push(frame);
2016-01-24 12:10:34 -08:00
let mut retval = Null;
2016-12-21 19:22:08 -08:00
let mut side_effects = Vec::new();
for expr in function.body.iter() {
2016-01-24 15:48:56 -08:00
retval = expr.clone();
while retval.is_reducible() {
2016-12-21 19:22:08 -08:00
let r = self.reduce_expr(retval);
retval = r.0;
if let Some(s) = r.1 {
side_effects.push(s);
}
2016-01-24 15:48:56 -08:00
}
}
self.frames.pop();
2016-12-21 19:22:08 -08:00
(retval, Some(SideEffect::Bundle(side_effects)))
}
2016-01-18 02:24:14 -08:00
}