From 39dd5e81f2b59853d84e3bea95c2298aebc4e1c4 Mon Sep 17 00:00:00 2001
From: Daniel M <daniel.q.mueller@stud.h-da.de>
Date: Sun, 2 Jan 2022 21:58:10 +0100
Subject: [PATCH] Start implementing interpreter

- Implemented tree-walk-interpreter for expressions only
- Binops Add, Mul
- Value Types I64
---
 src/interpreter.rs | 42 ++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs         |  1 +
 src/main.rs        | 22 +++++++++++-----------
 src/parser.rs      |  4 ++--
 4 files changed, 56 insertions(+), 13 deletions(-)
 create mode 100644 src/interpreter.rs

diff --git a/src/interpreter.rs b/src/interpreter.rs
new file mode 100644
index 0000000..19c49c0
--- /dev/null
+++ b/src/interpreter.rs
@@ -0,0 +1,42 @@
+use crate::parser::{Ast, BinOpType};
+
+#[derive(Debug)]
+pub enum Value {
+    I64(i64),
+}
+
+pub struct Interpreter {
+    // Runtime storage, for example variables ...
+}
+
+impl Interpreter {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn run(&mut self, prog: Ast) {
+        let result = self.resolve_expr(prog);
+
+        println!("Result = {:?}", result);
+    }
+
+    fn resolve_expr(&mut self, expr: Ast) -> Value {
+        match expr {
+            Ast::I64(val) => Value::I64(val),
+            Ast::BinOp(bo, lhs, rhs) => self.resolve_binop(bo, *lhs, *rhs),
+        }
+    }
+
+    fn resolve_binop(&mut self, bo: BinOpType, lhs: Ast, rhs: Ast) -> Value {
+        let lhs = self.resolve_expr(lhs);
+        let rhs = self.resolve_expr(rhs);
+
+        match (lhs, rhs) {
+            (Value::I64(lhs), Value::I64(rhs)) => match bo {
+                BinOpType::Add => Value::I64(lhs + rhs),
+                BinOpType::Mul => Value::I64(lhs * rhs),
+            },
+            // _ => panic!("Value types are not compatible"),
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 6054fb1..74c1228 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,2 +1,3 @@
 pub mod lexer;
 pub mod parser;
+pub mod interpreter;
diff --git a/src/main.rs b/src/main.rs
index 0f936c3..d7500eb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,23 +1,23 @@
-use nek_lang::{lexer::lex, parser::parse};
+use nek_lang::{lexer::lex, parser::parse, interpreter::Interpreter};
 
 
 fn main() {
 
-    let code = "33 +5*2";
-    // Should produce ast: Add {
-    //     lhs: I64(33),
-    //     rhs: Mul: {
-    //         lhs: I64(5),
-    //         rhs: I64(2)
-    //     }
-    // }
+    let mut code = String::new();
 
-    let tokens = lex(code);
+    std::io::stdin().read_line(&mut code).unwrap();
+    let code = code.trim();
+
+    let tokens = lex(&code);
 
     println!("Tokens: {:?}\n", tokens);
 
     let ast = parse(tokens);
 
-    println!("Ast: {:#?}", ast);
+    println!("Ast: {:#?}\n", ast);
+
+    let mut interpreter = Interpreter::new();
+
+    interpreter.run(ast);
 
 }
diff --git a/src/parser.rs b/src/parser.rs
index bbe8756..1f4573e 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -3,7 +3,7 @@ use std::iter::Peekable;
 use crate::lexer::Token;
 
 /// Types for binary operators
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum BinOpType {
     /// Addition
     Add,
@@ -12,7 +12,7 @@ pub enum BinOpType {
     Mul,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum Ast {
     /// Integer literal (64-bit)
     I64(i64),