Merge branch 'statements'

.github/workflows/workflow.yaml

@@ -14,12 +14,12 @@ jobs:
       - name: Configure Project
         uses: threeal/cmake-action@v1.3.0
         with: 
-          c-compiler: gcc
-          cxx-compiler: g++
+          c-compiler: clang 
+          cxx-compiler: clang++
           cxx-flags: "--std=c++17"
 
       - name: Build Project
         run: cmake --build build
 
       - name: Run-Tests
-        run: ./build/test/run_crux_test
+        run: ./build/test/run_crux_test

include/CruxCallable.h

@@ -0,0 +1,19 @@
+//
+// Cruxcallable.h contains function definations that is overridden
+// by CruxFunction and Crux Class
+//
+//
+#pragma once
+
+#include "utls/Object.h"
+#include <string>
+#include <vector>
+
+class Interpreter;
+
+class CruxCallable {
+public:
+  virtual int arity() = 0;
+  virtual Object call(Interpreter *interpreter, std::vector<Object>) = 0;
+  virtual std::string str() = 0;
+};

include/Expr.h

@@ -1,11 +1,10 @@
 //
-// Created by Rohith on 1/25/24.
-//
 
 #ifndef CRUX_EXPR_H
 #define CRUX_EXPR_H
 
 #include "Token.h"
+#include <vector>
 
 enum ExprType {
   ExprType_Binary,
@@ -15,7 +14,8 @@ enum ExprType {
   ExprType_Ternary,
   ExprType_Variable,
   ExprType_Assignment,
-  ExprType_Logical
+  ExprType_Logical,
+  ExprType_Call
 };
 
 class Expr {
@@ -38,6 +38,17 @@ class Binary : public Expr {
   ~Binary();
 };
 
+class Call : public Expr {
+public:
+  Expr *callee;
+  Token *paren;
+  std::vector<Expr *> arguments;
+
+  Call(Expr *callee, Token *paren, std::vector<Expr *> arguments);
+
+  ~Call();
+};
+
 class Grouping : public Expr {
 public:
   Expr *expression;

include/Function.h

@@ -0,0 +1,16 @@
+#ifndef FUNCTION_H
+#define FUNCTION_H
+
+#include "CruxCallable.h"
+#include "Statement.h"
+
+class CruxFunction : public CruxCallable {
+public:
+  Function *declaration;
+  CruxFunction(Function *declaration);
+  virtual int arity() override;
+  virtual Object call(Interpreter *interpreter, std::vector<Object>) override;
+  virtual std::string str() override;
+};
+
+#endif // FUNCTION_H

include/Interpreter.h

@@ -14,12 +14,8 @@
 
 class Interpreter {
 private:
-  Environment *environment = new Environment();
-
   void excecute(Statement *stmnt);
 
-  void excecuteBlock(std::vector<Statement *> stmnts, Environment *env);
-
   Object evaluate(Expr *expr);
 
   bool isTruthy(Object right);
@@ -33,8 +29,22 @@ class Interpreter {
   bool checkCompatibility(Token *op, Object left, Object right);
 
 public:
+  Environment *globals = new Environment();
+
+private:
+  Environment *environment = globals;
+
+public:
+  Interpreter();
+
   bool isBreakUsed = false;
 
+  bool isReturnUsed = false;
+
+  Object returnObj;
+
+  Object excecuteBlock(std::vector<Statement *> stmnts, Environment *env);
+
   void interpret(std::vector<Statement *> &statements);
 
   void visitPrintStmnt(Print *stmnt);
@@ -49,6 +59,10 @@ class Interpreter {
 
   void visitWhileStmnt(While *stmnt);
 
+  void visitFuncStmnt(Function *stmnt);
+
+  void visitReturnStmnt(Return *stmnt);
+
   Object visitAssignment(Assignment *expr);
 
   Object visitLogicalExp(Logical *expr);
@@ -57,15 +71,15 @@ class Interpreter {
 
   Object visitGroupExp(Grouping *expr);
 
+  Object visitCall(Call *stmnt);
+
   Object visitUnaryExp(Unary *expr);
 
   Object visitBinaryExp(Binary *expr);
 
   Object visitTernaryExp(Ternary *expr);
 
   Object visitVariableExp(Variable *expr);
-
-  ~Interpreter();
 };
 
 #endif // CRUX_INTERPRETER_H

include/NativeFunction.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "CruxCallable.h"
+#include <chrono>
+#include <string>
+#include <vector>
+class Interpreter;
+
+class ClockFunction : public CruxCallable {
+  virtual int arity() override { return 0; }
+
+  virtual Object call(Interpreter *interpreter, std::vector<Object>) override {
+    auto millisec_since_epoch =
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch())
+            .count();
+
+    Object value((double)millisec_since_epoch / 1000.0);
+    return value;
+  }
+
+  virtual std::string str() override { return "<native fn>"; }
+};

include/Parser.h

@@ -30,8 +30,12 @@ class Parser {
   Expr *term();
   Expr *factor();
   Expr *unary();
+  Expr *call();
   Expr *primary();
 
+  // Expr helper functions
+  Expr *finishCall(Expr *expr);
+
   // Statement helper functions
   Statement *statement();
   Statement *printStatement();
@@ -40,13 +44,15 @@ class Parser {
   Statement *forStatement();
   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();

include/Return.h

@@ -0,0 +1,6 @@
+#include "utls/Object.h"
+
+struct ReturnValue {
+  Object value;
+  ReturnValue(Object value) : value(value){};
+};

include/Statement.h

@@ -6,6 +6,7 @@
 #define CRUX_STATEMENT_H
 
 #include "Expr.h"
+#include "Token.h"
 #include <vector>
 
 enum Statement_type {
@@ -15,7 +16,9 @@ enum Statement_type {
   StmntBlock_type,
   StmntIf_type,
   StmntWhile_type,
-  StmntBreak_type
+  StmntBreak_type,
+  StmntFunc_type,
+  StmntReturn_type
 };
 
 class Statement {
@@ -76,4 +79,21 @@ class Break : public Statement {
   Break(bool breakSet);
 };
 
+class Function : public Statement {
+public:
+  Token *name;
+  std::vector<Token *> params;
+  std::vector<Statement *> body;
+
+  Function(Token *name, std::vector<Token *> params,
+           std::vector<Statement *> body);
+};
+
+class Return : public Statement {
+public:
+  Token *keyword;
+  Expr *value;
+  Return(Token *keyword, Expr *value);
+};
+
 #endif

include/env/Env.h

@@ -2,9 +2,11 @@
 // Created by rohith on 26/03/2024
 //
 
+#ifndef ENV_H
+#define ENV_H
+
 #include "Token.h"
 #include "utls/Object.h"
-#include <string>
 #include <unordered_map>
 
 class Environment {
@@ -14,9 +16,13 @@ class Environment {
 
 public:
   Environment();
-  ~Environment();
+  //~Environment();
   Environment(Environment *enclosing);
+  void define(Token *tkn, Object value);
   void define(std::string name, Object value);
   void assign(Token *name, Object value);
   Object get(Token *name);
+  void deepClean(Environment *enclosing);
 };
+
+#endif

include/utls/Object.h

@@ -7,22 +7,22 @@
 
 #include <string>
 
-enum ObjType {
-  nullptr_type,
-  num_type,
-  string_type,
-  bool_type,
-};
+class CruxCallable;
+
+enum ObjType { nullptr_type, num_type, string_type, bool_type, function_type };
 class Object {
 public:
   ObjType type;
   double num_literal;
   bool bool_literal;
   std::string string_literal;
+  CruxCallable *function;
+
   Object();
   Object(bool type);
   Object(double type);
   Object(std::string type);
+  Object(CruxCallable *func);
   std::string str();
 };
 #endif // CRUX_OBJECT_H

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;
 }

src/CMakeLists.txt

@@ -6,6 +6,7 @@ set(Sources Error.cpp
 				AstPrinter.cpp
 				Interpreter.cpp
 				Statement.cpp
+				Function.cpp
 				env/Env.cpp
 )