WIP break continue

doc/operator-precedence.md

@@ -1,12 +1,14 @@
 
 ```
 program                 -> statement* EOF
-statement               -> expressionStatement | declarationStatement | assignmentStatement | incDecStatement | returnStatement | print | block | while | for | if | function
+statement               -> expressionStatement | declarationStatement | assignmentStatement | incDecStatement | returnStatement | breakStatement | continueStatement | print | block | while | for | if | function
 expressionStatement     -> expression ';'
 declarationStatement    -> declaration ';'
 assignementStatement    -> assignement ';'
 incDecStatement         -> incDec ';'
 returnStatement         -> return (expression)? ';'
+breakStatement          -> break ';'
+continueStatement       -> continue ';'
 declaration             -> Type Identifier ('=' expression)?
 assignment              -> Identifier assimentOperator expression
 assignmentOperator      -> '=' | '+= | '+-' | '*=' | '%=' | '/='

error-input.txt

@@ -1,5 +1,3 @@
-fnc f() int {
-}
-
-f()();
-print(f());
+{
+    return 1;
+}

inc/token/token.hpp

@@ -46,6 +46,7 @@ class Token
             IF, ELSE,
             FOR,
             FNC, RETURN,
+            BREAK, CONTINUE,
 
             // Identifier
             IDENTIFIER

main.cpp

@@ -19,6 +19,8 @@ void runFileMode(const std::string &filePath)
 
 int main(int ac, char **av)
 {
+    for (int i = 0; i < 10; i++) continue;
+
     try {
         if (ac < 2)
             runInteractiveMode();

tst/lexer/lexer_test.cpp

@@ -249,6 +249,20 @@ TEST(LexerTest, KeyWords)
             .expected = {
                 Token{Token::RETURN, "return"}
             }
+        },
+        LexerTest{
+            .description = "7. break",
+            .expression = "break",
+            .expected = {
+                Token{Token::BREAK, "break"}
+            }
+        },
+        LexerTest{
+            .description = "8. continue",
+            .expression = "continue",
+            .expected = {
+                Token{Token::CONTINUE, "continue"}
+            }
         }
 
     };

tst/parser/functions_error_test.cpp → tst/parser/parser_error_test.cpp

@@ -1,75 +1,90 @@
 #include <gtest/gtest.h>
 #include "Parser.hpp"
 
-struct FunctionsErrorTest
+struct ParserErrorTest
 {
     std::string description;
     std::string program;
 };
 
-void testFunctionsError(const std::vector<FunctionsErrorTest> &testCases)
+void testParserError(const std::vector<ParserErrorTest> &testCases)
 {
     for (const auto &tc: testCases) {
         std::cout << tc.description << std::endl;
 
         Parser parser;
-
         EXPECT_THROW(parser.feed(tc.program), SyntaxError);
     }
 }
 
 TEST(ParserTest, FunctionsDeclarationError)
 {
-    const std::vector<FunctionsErrorTest> testCases{
-        FunctionsErrorTest{
+    const std::vector<ParserErrorTest> testCases{
+        ParserErrorTest{
             .description = "1. Function declaration without identifier",
             .program = "fnc () {}"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "1. Function declaration without identifier",
             .program = "fnc () {}"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "2. Function declaration without parenthesis",
             .program = "fnc f {}"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "3. Function declaration with already used parameter name",
             .program = "fnc f (int x, int x){}"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "4. Function declaration without close parenthesis",
             .program = "fnc f (int x, int y {}"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "5. Function declaration without body",
             .program = "fnc f (int x, int y)"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "6. Function declaration with return type and without body",
             .program = "fnc f (int x, int y) int"
         }
     };
 
-    testFunctionsError(testCases);
+    testParserError(testCases);
 }
 
 TEST(ParserTest, CallError)
 {
-    const std::vector<FunctionsErrorTest> testCases{
-        FunctionsErrorTest{
+    const std::vector<ParserErrorTest> testCases{
+        ParserErrorTest{
             .description = "1. Missing param or closed parenthesis",
             .program = "f(;"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "2. Missing closed parenthesis",
             .program = "f(1, 2;"
         },
-        FunctionsErrorTest{
+        ParserErrorTest{
             .description = "3. Missing expression after comma",
             .program = "f(1, );"
         }
     };
 
-    testFunctionsError(testCases);
+    testParserError(testCases);
+}
+
+TEST(ParserTest, BreakContinueError)
+{
+    const std::vector<ParserErrorTest> testCases{
+        ParserErrorTest{
+            .description = "1. Missing semi after break",
+            .program = "break"
+        },
+        ParserErrorTest{
+            .description = "2. Missing semi after continue",
+            .program = "continue"
+        },
+    };
+
+    testParserError(testCases);
 }

tst/tst.cmake

@@ -5,5 +5,5 @@ set(
     ${PROJECT_ROOT}/tst/evaluator/evaluator_test.cpp
     ${PROJECT_ROOT}/tst/evaluator/statements_test.cpp
     ${PROJECT_ROOT}/tst/parser/parser_test.cpp
-    ${PROJECT_ROOT}/tst/parser/functions_error_test.cpp
+    ${PROJECT_ROOT}/tst/parser/parser_error_test.cpp
 )