update(test): add tests to interpereter

include/Interpreter.h

@@ -33,6 +33,8 @@ class Interpreter {
   bool checkCompatibility(Token *op, Object left, Object right);
 
 public:
+  bool isBreakUsed = false;
+
   void interpret(std::vector<Statement *> &statements);
 
   void visitPrintStmnt(Print *stmnt);

include/Parser.h

@@ -16,6 +16,9 @@ class Parser {
   };
   std::vector<Token> tokens;
   int current = 0;
+  // loopCounter to determine if "break" is valid or not. (break should only
+  // occur in loops)
+  int loopCounter = 0;
 
   // Precidence
   Expr *Or();
@@ -35,6 +38,7 @@ class Parser {
   Statement *ifStatement();
   Statement *whileStatement();
   Statement *forStatement();
+  Statement *breakStatement();
   Statement *expressionStatement();
   std::vector<Statement *> blockStatement();
 

include/Statement.h

@@ -14,7 +14,8 @@ enum Statement_type {
   StmntVar_type,
   StmntBlock_type,
   StmntIf_type,
-  StmntWhile_type
+  StmntWhile_type,
+  StmntBreak_type
 };
 
 class Statement {
@@ -69,4 +70,10 @@ class While : public Statement {
   ~While();
 };
 
+class Break : public Statement {
+public:
+  bool isBreakPresent = false;
+  Break(bool breakSet);
+};
+
 #endif

include/Token.h

@@ -56,6 +56,7 @@ enum TokenType {
   TRUE,
   VAR,
   WHILE,
+  BREAK,
 
   ENDOFFILE
 };

src/Interpreter.cpp

@@ -1,6 +1,4 @@
 //
-// Created by Rohith on 3/17/24
-//
 
 #include "Interpreter.h"
 #include "Error.h"
@@ -33,6 +31,8 @@ void Interpreter::excecute(Statement *stmnt) {
   case StmntWhile_type:
     visitWhileStmnt((While *)stmnt);
     break;
+  case StmntBreak_type:
+    isBreakUsed = true;
   }
 }
 
@@ -135,10 +135,12 @@ void Interpreter::visitIfStmnt(If *stmnt) {
 }
 
 void Interpreter::visitWhileStmnt(While *stmnt) {
-  while (isTruthy(evaluate(stmnt->condition)))
+  while (isTruthy(evaluate(stmnt->condition))) {
     excecute(stmnt->body);
+    if (isBreakUsed)
+      break;
+  }
 }
-
 void Interpreter::visitBlockStmnt(Block *stmnt) {
   excecuteBlock(stmnt->stmnt, new Environment(environment));
 }
@@ -191,7 +193,7 @@ Object Interpreter::visitUnaryExp(Unary *expr) {
     checkNumberOperand(expr->op, right);
     return -right.num_literal;
   default:
-    RuntimeError(*expr->op, "Invalid operator used");
+    throw RuntimeError(*expr->op, "Invalid operator used");
   }
   return Object();
 }

src/Parser.cpp

@@ -53,6 +53,8 @@ Statement *Parser::statement() {
     return whileStatement();
   if (match(FOR))
     return forStatement();
+  if (match(BREAK))
+    return breakStatement();
   if (match(LEFT_BRACE))
     return new Block(blockStatement());
   return expressionStatement();
@@ -83,10 +85,12 @@ Statement *Parser::ifStatement() {
 }
 
 Statement *Parser::whileStatement() {
-  consume(LEFT_PAREN, "expected ( after while");
+  consume(LEFT_PAREN, "Expected ( after while");
   Expr *expr = expression();
-  consume(RIGHT_PAREN, "expected ) after while");
+  consume(RIGHT_PAREN, "Expected ) after while");
+  loopCounter++;
   Statement *body = statement();
+  loopCounter--;
   return new While(expr, body);
 }
 
@@ -115,7 +119,7 @@ Statement *Parser::forStatement() {
   else
     increment = expression();
 
-  consume(RIGHT_PAREN, "expected ) after clause");
+  consume(RIGHT_PAREN, "Expected ) after clause");
 
   Statement *body;
   body = statement();
@@ -141,6 +145,15 @@ Statement *Parser::forStatement() {
   return body;
 }
 
+Statement *Parser::breakStatement() {
+  if (loopCounter == 0) {
+    Token tkn = tokens[current];
+    crux::error(tkn, "break should ony occur in for/while loops");
+  }
+  consume(SEMICOLON, "Expected ';' after 'break'.");
+  return new Break(true);
+}
+
 Statement *Parser::printStatement() {
   Expr *expr = expression();
   consume(SEMICOLON, "Expected ; at the end of the statement");

src/Scanner.cpp

@@ -210,4 +210,5 @@ void tkn::initializeKeywords() {
   keywords["true"] = TRUE;
   keywords["var"] = VAR;
   keywords["while"] = WHILE;
+  keywords["break"] = BREAK;
 }

src/Statement.cpp

@@ -43,3 +43,6 @@ While::~While() {
   delete condition;
   delete body;
 }
+
+Break::Break(bool isBrkPre)
+    : Statement(StmntBreak_type), isBreakPresent(isBrkPre) {}

test/TestInterpreter.cpp

@@ -7,51 +7,70 @@
 #include "Scanner.h"
 #include "gtest/gtest.h"
 #include <Statement.h>
+#include <iostream>
+#include <stdexcept>
+#include <streambuf>
 #include <string>
 #include <vector>
 
-TEST(InterpreterTest, TestInterpreterFlow) {
+TEST(InterpreterTest, TestInterpreterExpression) {
   std::string test = "10 + (40 + (20 - 30) - 10) + 50;";
   Scanner scan(test);
   std::vector<Token> tokens = scan.scanTokens();
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
-  // ASSERT_EQ(Interpreter{}.interpret(statements), "80.000000");
+  testing::internal::CaptureStdout();
+  Interpreter{}.interpret(statements);
+  std::string result = testing::internal::GetCapturedStdout();
+  ASSERT_EQ(result, "80.000000\n");
 }
 
-TEST(InterpreterTest, TestInterpreterUnary) {
+TEST(InterpreterTest, TestInterpreterUnaryExpression) {
   std::string test = "!true;";
   Scanner scan(test);
   std::vector<Token> tokens = scan.scanTokens();
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
-  // ASSERT_EQ(Interpreter{}.interpret(statements), "false");
+  testing::internal::CaptureStdout();
+  Interpreter{}.interpret(statements);
+  std::string result = testing::internal::GetCapturedStdout();
+  ASSERT_EQ(result, "false\n");
 }
 
-TEST(InterpreterTest, TestParserTernary) {
+TEST(InterpreterTest, TestParserTernaryExpression) {
   std::string test = "3 > 1 ? true : false;";
   Scanner scan(test);
   std::vector<Token> tokens = scan.scanTokens();
   Parser p(tokens);
   std::vector<Statement *> statements = p.parse();
-  // ASSERT_EQ(Interpreter{}.interpret(statements), "true");
+  testing::internal::CaptureStdout();
+  Interpreter{}.interpret(statements);
+  std::string result = testing::internal::GetCapturedStdout();
+  ASSERT_EQ(result, "true\n");
 }
 
-TEST(IntrepreterTest, TestStringNumExpressions) {
-  std::string test1 = "\"test\"+8;";
-  std::string test2 = "8+\"test\";";
+TEST(InterpreterTest, TestInterpreterVarStatement) {
 
-  Scanner scan1(test1);
-  Scanner scan2(test2);
-  std::vector<Token> tokens1 = scan1.scanTokens();
-  std::vector<Token> tokens2 = scan2.scanTokens();
+  std::string test = "var a = 10; print(a);";
+  std::string test_f = "a = 10"; // fails
 
-  Parser p1(tokens1);
-  Parser p2(tokens2);
+  Scanner scan(test);
+  Scanner scan_f(test_f);
+
+  std::vector<Token> token = scan.scanTokens();
+  std::vector<Token> token_f = scan_f.scanTokens();
+
+  Parser parser(token);
+  Parser parser_f(token_f);
+
+  std::vector<Statement *> statement = parser.parse();
 
-  std::vector<Statement *> statements1 = p1.parse();
-  std::vector<Statement *> statements2 = p2.parse();
+  std::stringstream buffer;
+  std::streambuf *sbuf = std::cout.rdbuf();
+  std::cout.rdbuf(buffer.rdbuf());
+  Interpreter{}.interpret(statement);
+  std::cout.rdbuf(sbuf);
+  ASSERT_EQ(buffer.str(), "10.000000\n");
 
-  // ASSERT_EQ(Interpreter{}.interpret(statements1), "test8.000000");
-  // ASSERT_EQ(Interpreter{}.interpret(statements2), "8.000000test");
+  EXPECT_THROW(parser_f.parse(), std::runtime_error);
 }