From 353300db3c2904b0230349cae07693f4b7917766 Mon Sep 17 00:00:00 2001
From: Rohith-Raju <rohithraju488@gmail.com>
Date: Wed, 15 May 2024 14:56:27 +0530
Subject: [PATCH] update(function): fix recursion and repl state

---
 include/Interpreter.h    | 12 +++++++---
 include/Parser.h         |  3 ++-
 include/Return.h         |  6 +++++
 include/Statement.h      | 10 ++++++++-
 include/env/Env.h        |  2 +-
 main.cpp                 | 47 ++++++++++++++++++++++++++++++++++++----
 src/Function.cpp         |  4 ++--
 src/Interpreter.cpp      | 29 ++++++++++++++++++-------
 src/Parser.cpp           | 12 ++++++++++
 src/Statement.cpp        |  3 +++
 src/env/Env.cpp          | 20 ++++++++---------
 test/TestInterpreter.cpp | 36 +++++++++++++++++++++++++-----
 test/lib                 |  2 +-
 13 files changed, 148 insertions(+), 38 deletions(-)
 create mode 100644 include/Return.h

diff --git a/include/Interpreter.h b/include/Interpreter.h
index ffc7817..346468f 100644
--- a/include/Interpreter.h
+++ b/include/Interpreter.h
@@ -14,7 +14,7 @@
 
 class Interpreter {
 private:
-  static Environment *environment;
+  Environment *environment;
 
   void excecute(Statement *stmnt);
 
@@ -31,13 +31,17 @@ class Interpreter {
   bool checkCompatibility(Token *op, Object left, Object right);
 
 public:
-  static Environment *globals;
+  Environment *globals;
 
   Interpreter();
 
   bool isBreakUsed = false;
 
-  void excecuteBlock(std::vector<Statement *> stmnts, Environment *env);
+  bool isReturnUsed = false;
+
+  Object returnObj;
+
+  Object excecuteBlock(std::vector<Statement *> stmnts, Environment *env);
 
   void interpret(std::vector<Statement *> &statements);
 
@@ -55,6 +59,8 @@ class Interpreter {
 
   void visitFuncStmnt(Function *stmnt);
 
+  void visitReturnStmnt(Return *stmnt);
+
   Object visitAssignment(Assignment *expr);
 
   Object visitLogicalExp(Logical *expr);
diff --git a/include/Parser.h b/include/Parser.h
index e1f594a..11e7b4c 100644
--- a/include/Parser.h
+++ b/include/Parser.h
@@ -45,13 +45,14 @@ class Parser {
   Statement *breakStatement();
   Statement *expressionStatement();
   Statement *function(std::string str);
+  Statement *returnStatement();
   std::vector<Statement *> blockStatement();
 
   // Variable stuff
   Statement *declaration();
   Statement *varDeclaration();
 
-  // helper functions
+  // Helper functions
   Expr *equality();
   bool check(TokenType type);
   Token advance();
diff --git a/include/Return.h b/include/Return.h
new file mode 100644
index 0000000..c027a45
--- /dev/null
+++ b/include/Return.h
@@ -0,0 +1,6 @@
+#include "utls/Object.h"
+
+struct ReturnValue {
+  Object value;
+  ReturnValue(Object value) : value(value){};
+};
diff --git a/include/Statement.h b/include/Statement.h
index 3ec9332..aae81ef 100644
--- a/include/Statement.h
+++ b/include/Statement.h
@@ -17,7 +17,8 @@ enum Statement_type {
   StmntIf_type,
   StmntWhile_type,
   StmntBreak_type,
-  StmntFunc_type
+  StmntFunc_type,
+  StmntReturn_type
 };
 
 class Statement {
@@ -88,4 +89,11 @@ class Function : public Statement {
            std::vector<Statement *> body);
 };
 
+class Return : public Statement {
+public:
+  Token *keyword;
+  Expr *value;
+  Return(Token *keyword, Expr *value);
+};
+
 #endif
diff --git a/include/env/Env.h b/include/env/Env.h
index d8a6b83..94bb0b0 100644
--- a/include/env/Env.h
+++ b/include/env/Env.h
@@ -16,7 +16,7 @@ class Environment {
 
 public:
   Environment();
-  ~Environment();
+  //~Environment();
   Environment(Environment *enclosing);
   void define(Token *tkn, Object value);
   void define(std::string name, Object value);
diff --git a/main.cpp b/main.cpp
index affeef8..7cbb047 100644
--- a/main.cpp
+++ b/main.cpp
@@ -2,12 +2,42 @@
 #include "Interpreter.h"
 #include "Scanner.h"
 #include <Parser.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
 #include <iostream>
 #include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
 #include <vector>
 
+namespace fs = std::filesystem;
+
 void runCode(std::string source);
 
+std::string readFile(fs::path path) {
+  if (path.extension() != ".crux") {
+    std::cerr << "Filename " << path.filename()
+              << " should end with the extension \".crux\" \n";
+    exit(64);
+  }
+
+  std::ostringstream data;
+  std::fstream file(path, std::ios_base::in);
+  if (!file.is_open()) {
+    std::cerr << "File could't be found or opened \n";
+    exit(64);
+  }
+  data << file.rdbuf();
+  return data.str();
+}
+
+void runFile(std::string path) {
+  fs::path fPath(path);
+  runCode(readFile(fPath));
+}
+
 void runPromt() {
   for (;;) {
     std::cout << "> ";
@@ -25,16 +55,25 @@ void runPromt() {
   }
 }
 
+Interpreter interpreter{};
+
 void runCode(std::string source) {
   Scanner scanner(source);
   std::vector<Token> tokens = scanner.scanTokens();
   Parser parser(tokens);
   std::vector<Statement *> expression = parser.parse();
-  std::unique_ptr<Interpreter> interpreter = std::make_unique<Interpreter>();
-  interpreter->interpret(expression);
+  interpreter.interpret(expression);
 }
 
-int main() {
-  runPromt();
+int main(int argc, char *argv[]) {
+  if (argc > 2) {
+    std::cout << "usage: crux <script>\n";
+    std::cout << "using repl: ./crux\n";
+    exit(64);
+  } else if (argc == 2) {
+    runFile(argv[1]);
+  } else {
+    runPromt();
+  }
   return 0;
 }
diff --git a/src/Function.cpp b/src/Function.cpp
index 8de56eb..6d5e403 100644
--- a/src/Function.cpp
+++ b/src/Function.cpp
@@ -17,8 +17,8 @@ Object CruxFunction::call(Interpreter *interpreter, std::vector<Object> args) {
   for (int i = 0; i < declaration->params.size(); i++) {
     env->define(declaration->params[i], args[i]);
   }
-  interpreter->excecuteBlock(declaration->body, env);
-  return Object();
+  Object value = interpreter->excecuteBlock(declaration->body, env);
+  return value;
 }
 
 std::string CruxFunction::str() {
diff --git a/src/Interpreter.cpp b/src/Interpreter.cpp
index 280fa07..fa414a7 100644
--- a/src/Interpreter.cpp
+++ b/src/Interpreter.cpp
@@ -16,9 +16,6 @@
 #include <string>
 #include <vector>
 
-Environment *Interpreter::environment;
-Environment *Interpreter::globals;
-
 Interpreter::Interpreter() {
   if (!environment) {
     globals = new Environment();
@@ -51,8 +48,12 @@ void Interpreter::excecute(Statement *stmnt) {
   case StmntFunc_type:
     visitFuncStmnt((Function *)stmnt);
     break;
+  case StmntReturn_type:
+    visitReturnStmnt((Return *)stmnt);
+    break;
   case StmntBreak_type:
     isBreakUsed = true;
+    break;
   }
 }
 
@@ -102,7 +103,7 @@ void Interpreter::checkNumberOperand(Token *op, Object right) {
 }
 
 bool Interpreter::checkIfSameTypes(Object left, Object right) {
-  if (left.type == num_type && right.type == num_type)
+  if (left.type == right.type)
     return true;
   else
     return false;
@@ -168,22 +169,33 @@ void Interpreter::visitFuncStmnt(Function *stmnt) {
   environment->define(stmnt->name, declaration);
 }
 
+void Interpreter::visitReturnStmnt(Return *stmnt) {
+  returnObj = evaluate(stmnt->value);
+  isReturnUsed = true;
+}
+
 void Interpreter::visitBlockStmnt(Block *stmnt) {
   Environment *locals = new Environment(environment);
   excecuteBlock(stmnt->stmnt, locals);
-  delete locals;
 }
 
-void Interpreter::excecuteBlock(std::vector<Statement *> stmnts,
-                                Environment *env) {
+Object Interpreter::excecuteBlock(std::vector<Statement *> stmnts,
+                                  Environment *env) {
   Environment *previous = environment;
   environment = env;
   for (Statement *stmnt : stmnts) {
     excecute(stmnt);
-    if (crux::hadRuntimeError)
+    if (isBreakUsed || isReturnUsed || crux::hadRuntimeError)
       break;
   }
   environment = previous;
+
+  if (isReturnUsed) {
+    isReturnUsed = false;
+    return this->returnObj;
+  }
+
+  return Object();
 }
 
 Object Interpreter::visitVariableExp(Variable *expr) {
@@ -203,6 +215,7 @@ Object Interpreter::visitLogicalExp(Logical *expr) {
 
 Object Interpreter::visitAssignment(Assignment *expr) {
   Object value = evaluate(expr->value);
+
   environment->assign(expr->name, value);
   return value;
 }
diff --git a/src/Parser.cpp b/src/Parser.cpp
index d1bf464..711511e 100644
--- a/src/Parser.cpp
+++ b/src/Parser.cpp
@@ -57,6 +57,8 @@ Statement *Parser::statement() {
     return forStatement();
   if (match(BREAK))
     return breakStatement();
+  if (match(RETURN))
+    return returnStatement();
   if (match(LEFT_BRACE))
     return new Block(blockStatement());
   return expressionStatement();
@@ -322,6 +324,16 @@ Statement *Parser::function(std::string kind) {
   return new Function(name, params, body);
 }
 
+Statement *Parser::returnStatement() {
+  Token *name = new Token(previous());
+  Expr *value = nullptr;
+  if (!check(SEMICOLON)) {
+    value = expression();
+  }
+  consume(SEMICOLON, "expected ; at the end of the statement");
+  return new Return(name, value);
+}
+
 Expr *Parser::primary() {
   if (match(FALSE))
     return new Literal(new Object(false));
diff --git a/src/Statement.cpp b/src/Statement.cpp
index 4f51e00..f6ae5e5 100644
--- a/src/Statement.cpp
+++ b/src/Statement.cpp
@@ -50,3 +50,6 @@ Break::Break(bool isBrkPre)
 Function::Function(Token *name, std::vector<Token *> params,
                    std::vector<Statement *> body)
     : Statement(StmntFunc_type), name(name), params(params), body(body) {}
+
+Return::Return(Token *keyword, Expr *value)
+    : Statement(StmntReturn_type), keyword(keyword), value(value) {}
diff --git a/src/env/Env.cpp b/src/env/Env.cpp
index 67dc977..1771f3c 100644
--- a/src/env/Env.cpp
+++ b/src/env/Env.cpp
@@ -9,20 +9,18 @@
 
 Environment::Environment() : enclosing(nullptr) {}
 
-Environment::~Environment() {
-  if (enclosing != nullptr) {
-    deepClean(enclosing);
-  }
-  values.clear();
-  enclosing = nullptr;
-}
+// Environment::~Environment() {
+//   if (enclosing != nullptr) {
+//     deepClean(enclosing);
+//   }
+//   enclosing = nullptr;
+// }
 
 void Environment::deepClean(Environment *enclosing) {
   if (enclosing != nullptr)
     deepClean(enclosing);
 
   enclosing->values.clear();
-  delete enclosing;
   enclosing = nullptr;
   return;
 }
@@ -34,7 +32,7 @@ void Environment::define(Token *tkn, Object value) {
 }
 
 void Environment::define(std::string name, Object value) {
-  values.emplace(name, value);
+  values.insert({name, value});
 }
 
 void Environment::assign(Token *name, Object value) {
@@ -55,8 +53,8 @@ Object Environment::get(Token *name) {
   if (values.find(name->lexeme) != values.end()) {
     Object obj = values[name->lexeme];
     if (obj.type == nullptr_type)
-      throw RuntimeError(*name, "Uninitalized variable " + name->lexeme +
-                                    " can't be computed");
+      throw RuntimeError(*name, "Uninitalized variable :" + name->lexeme +
+                                    " nil values can't be computed");
     return obj;
   }
 
diff --git a/test/TestInterpreter.cpp b/test/TestInterpreter.cpp
index b92c6f7..e913b96 100644
--- a/test/TestInterpreter.cpp
+++ b/test/TestInterpreter.cpp
@@ -5,6 +5,7 @@
 #include "Scanner.h"
 #include "gtest/gtest.h"
 #include <Statement.h>
+#include <ios>
 #include <string>
 #include <vector>
 
@@ -56,8 +57,10 @@ TEST(InterpreterTest, TestVarStatement) {
   std::vector<Statement *> statement = parser.parse();
 
   testing::internal::CaptureStdout();
-  Interpreter{}.interpret(statement);
+  Interpreter *interpreter = new Interpreter();
+  interpreter->interpret(statement);
   std::string result = testing::internal::GetCapturedStdout();
+  delete interpreter;
 }
 
 TEST(InterpreterTest, TestIfStatement) {
@@ -67,7 +70,8 @@ TEST(InterpreterTest, TestIfStatement) {
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
   testing::internal::CaptureStdout();
-  Interpreter{}.interpret(statements);
+  Interpreter *interpreter = new Interpreter();
+  interpreter->interpret(statements);
   std::string result = testing::internal::GetCapturedStdout();
   ASSERT_EQ(result, "equal\n");
 }
@@ -80,10 +84,11 @@ TEST(InterpreterTest, TestIfElseStatement) {
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
   testing::internal::CaptureStdout();
-  Interpreter interpreter = Interpreter();
-  interpreter.interpret(statements);
+  Interpreter *interpreter = new Interpreter();
+  interpreter->interpret(statements);
   std::string result = testing::internal::GetCapturedStdout();
   ASSERT_EQ(result, "Not equal\n");
+  delete interpreter;
 }
 
 TEST(InterpreterTest, TestWhileLoop) {
@@ -93,9 +98,11 @@ TEST(InterpreterTest, TestWhileLoop) {
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
   testing::internal::CaptureStdout();
-  Interpreter{}.interpret(statements);
+  Interpreter *interpreter = new Interpreter();
+  interpreter->interpret(statements);
   std::string result = testing::internal::GetCapturedStdout();
   ASSERT_EQ(result, "5.000000\n4.000000\n3.000000\n2.000000\n1.000000\n");
+  delete interpreter;
 }
 
 TEST(InterpreterTest, TestForLoop) {
@@ -105,7 +112,24 @@ TEST(InterpreterTest, TestForLoop) {
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
   testing::internal::CaptureStdout();
-  Interpreter{}.interpret(statements);
+  Interpreter *interpreter = new Interpreter();
+  interpreter->interpret(statements);
   std::string result = testing::internal::GetCapturedStdout();
   ASSERT_EQ(result, "0.000000\n1.000000\n2.000000\n3.000000\n4.000000\n");
+  delete interpreter;
+}
+
+TEST(InterpreterTest, TestSimpleFunction) {
+  std::string test = "fun printWords(a,b){print a +\" \"+ b;} "
+                     "printWords(\"Hello\", \"World\");";
+  Scanner scan(test);
+  std::vector<Token> tokens = scan.scanTokens();
+  Parser p(tokens);
+  std::vector<Statement *> statements = p.parse();
+  testing::internal::CaptureStdout();
+  Interpreter *interpreter = new Interpreter();
+  interpreter->interpret(statements);
+  std::string result = testing::internal::GetCapturedStdout();
+  ASSERT_EQ(result, "Hello World\n");
+  delete interpreter;
 }
diff --git a/test/lib b/test/lib
index d83fee1..33af80a 160000
--- a/test/lib
+++ b/test/lib
@@ -1 +1 @@
-Subproject commit d83fee138a9ae6cb7c03688a2d08d4043a39815d
+Subproject commit 33af80a883ddc33d9c0fac0a5b4578301efb18de