Implements while loop

src/Parser/ParsedStatements/ParsedStatement.hpp

@@ -13,6 +13,7 @@
 namespace Porygon::Parser {
     enum class ParsedStatementKind : uint8_t {
         Bad,
+        Break,
         Script,
         Block,
         Expression,
@@ -23,7 +24,7 @@ namespace Porygon::Parser {
         Conditional,
         NumericalFor,
         GenericFor,
-        Break
+        While
     };
 
     class ParsedStatement {
@@ -375,5 +376,31 @@ namespace Porygon::Parser {
         }
     };
 
+    class ParsedWhileStatement : public ParsedStatement{
+        const ParsedExpression* _condition;
+        const ParsedStatement* _block;
+    public:
+        ParsedWhileStatement(const ParsedExpression *condition, const ParsedStatement *block,
+                             unsigned int start, unsigned int length)
+                : ParsedStatement(start, length), _condition(condition), _block(block) {}
+
+        ~ParsedWhileStatement() final{
+            delete _condition;
+            delete _block;
+        }
+
+        const ParsedStatementKind GetKind() const final {
+            return ParsedStatementKind::While;
+        }
+
+        const ParsedExpression* GetCondition(){
+            return _condition;
+        }
+
+        const ParsedStatement* GetBlock(){
+            return _block;
+        }
+    };
+
 }
 #endif //PORYGONLANG_PARSEDSTATEMENT_HPP

src/Parser/Parser.cpp

@@ -46,6 +46,8 @@ namespace Porygon::Parser {
                 return this->ParseIfStatement(current);
             case TokenKind ::ForKeyword:
                 return this->ParseForStatement();
+            case TokenKind ::WhileKeyword:
+                return this->ParseWhileStatement(current);
             case TokenKind ::BreakKeyword:
                 return new ParsedBreakStatement(current->GetStartPosition(), current -> GetLength());
             default:
@@ -312,6 +314,19 @@ namespace Porygon::Parser {
         }
     }
 
+    ParsedStatement *Parser::ParseWhileStatement(const IToken *current) {
+        auto condition = this -> ParseExpression(this -> Next());
+        auto doKeyword = this -> Next();
+        if (doKeyword -> GetKind() != TokenKind::DoKeyword){
+            this->ScriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UnexpectedToken, doKeyword->GetStartPosition(),
+                                                    doKeyword->GetLength());
+            return new ParsedBadStatement(doKeyword->GetStartPosition(), doKeyword->GetLength());
+        }
+        auto block = this -> ParseBlock({TokenKind ::EndKeyword});
+        auto start = current -> GetStartPosition();
+        return new ParsedWhileStatement(condition, block, start, block->GetEndPosition() - start);
+    }
+
     /////////////////
     // Expressions //
     /////////////////
@@ -597,5 +612,4 @@ namespace Porygon::Parser {
             return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start);
         }
     }
-
 }

src/Parser/Parser.hpp

@@ -32,39 +32,26 @@ namespace Porygon::Parser {
         // Statements
 
         ParsedStatement *ParseStatement(const IToken *current);
-
         ParsedStatement *ParseVariableAssignment(const IToken *current);
-
         ParsedStatement *ParseIndexAssignment(ParsedExpression *indexer);
-
         ParsedStatement *ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements = {});
-
         ParsedStatement *ParseFunctionDeclaration(const IToken *current);
-
         ParsedStatement *ParseReturnStatement(const IToken *current);
-
         ParsedStatement *ParseIfStatement(const IToken *current);
-
         ParsedStatement *ParseForStatement();
         ParsedStatement *ParseNumericForStatement(const IToken *current);
         ParsedStatement *ParseGenericForStatement(const IToken *current);
+        ParsedStatement *ParseWhileStatement(const IToken *current);
 
         // Expressions
 
         ParsedExpression *ParseExpression(const IToken *current);
-
         ParsedExpression *ParseBinaryExpression(const IToken *current, OperatorPrecedence parentPrecedence);
-
         ParsedExpression *ParsePrimaryExpression(const IToken *current);
-
         ParsedExpression *ParseParenthesizedExpression(const IToken *current);
-
         ParsedExpression *ParseFunctionCallExpression(ParsedExpression *functionExpression);
-
         ParsedExpression *ParseIndexExpression(ParsedExpression *indexingExpression);
-
         ParsedExpression *ParsePeriodIndexExpression(ParsedExpression *indexingExpression);
-
         ParsedExpression *ParseTableExpression(const IToken *current);
 
     public: