interpreter.rs

// Interpreter
use crate::ast::{Expr, Op, SpanExpr};

pub fn eval_expr(e: &SpanExpr) -> i32 {
    match e.clone().1 {
        Expr::Num(i) => i,
        Expr::BinOp(op, l, r) => {
            let lv = eval_expr(&l);
            let rv = eval_expr(&r);
            match op {
                Op::Add => lv + rv,
                Op::Sub => lv - rv,
                Op::Mul => lv * rv,
                Op::Div => lv / rv,
                Op::Pow => lv.pow(rv as u32),
                _ => unimplemented!(),
            }
        }
        Expr::UnaryOp(op, e) => {
            let e = eval_expr(&e);
            match op {
                Op::Add => e,
                Op::Sub => -e,
                _ => unimplemented!(),
            }
        }
        _ => unimplemented!(),
    }
}

// use crate::ast::{Binop, Cmd, Constant, Expr, Item, Prog, TypeDecl};
// use crate::check::{check_prog, Fenv, Tenv};
// use crate::parse::parse_prog;

//use std::collections::HashMap;

// pub type Addr = u32;

// #[derive(Debug, PartialEq, Clone)]
// pub enum Data {
//     Value(Constant),
//     Pointer(Addr),
// }

// pub type Venv = HashMap<String, Addr>;
// pub type Menv = HashMap<Addr, Data>;

// #[derive(Debug, PartialEq, Clone)]
// pub struct Mem {
//     pub Addr: u32,
//     pub Menv: Menv,
// }

// impl Mem {
//     fn new() -> Mem {
//         Mem {
//             Addr: 0,
//             Menv: Menv::new(),
//         }
//     }

//     fn alloc(&mut self) -> Addr {
//         // allocate a new address
//         self.Addr += 1;
//         self.Addr
//     }
// }

// pub fn get_bool(d: Data) -> bool {
//     if let Data::Value(Constant::Boolean(b)) = d {