added parsee and parsee group

src/Parser/Parsee.cpp

@@ -1,39 +0,0 @@
-#include "Parsee.h"
-
-#include "Lexer/Token.h"
-
-ParseeToken::ParseeToken(TokenKind tokenKind, bool isRequired, bool shouldReturn):
-tokenKind(tokenKind), isRequired(isRequired), shouldReturn(shouldReturn) { }
-
-TokenKind ParseeToken::getTokenKind() {
-    return tokenKind;
-}
-
-bool ParseeToken::getIsRequired() {
-    return isRequired;
-}
-
-bool ParseeToken::getShouldReturn() {
-    return shouldReturn;
-}
-
-ParseeTokensGroup::ParseeTokensGroup(bool isRequired, vector<ParseeToken> tokens, optional<ParseeTokensGroup> repeatedGroup):
-isRequired(isRequired), tokens(tokens) {
-    if (repeatedGroup) {
-        this->repeatedGroup = *repeatedGroup;
-    } else {
-        this->repeatedGroup = {};
-    }
- }
-
-bool ParseeTokensGroup::getIsRequired() {
-    return isRequired;
-}
-
-vector<ParseeToken> ParseeTokensGroup::getTokens() {
-    return tokens;
-}
-
-optional<reference_wrapper<ParseeTokensGroup>> ParseeTokensGroup::getRepeatedGroup() {
-    return repeatedGroup;
-}

src/Parser/Parsee.h

@@ -1,37 +0,0 @@
-#ifndef PARSEE_H
-#define PARSEE_H
-
-#include <vector>
-#include <optional>
-
-enum class TokenKind;
-
-using namespace std;
-
-class ParseeToken {
-private:
-    TokenKind tokenKind;
-    bool isRequired;
-    bool shouldReturn;
-
-public:
-    ParseeToken(TokenKind tokenKind, bool isRequired, bool shouldReturn);
-    TokenKind getTokenKind();
-    bool getIsRequired();
-    bool getShouldReturn();
-};
-
-class ParseeTokensGroup {
-private:
-    bool isRequired;
-    vector<ParseeToken> tokens;
-    optional<reference_wrapper<ParseeTokensGroup>> repeatedGroup;
-
-public:
-    ParseeTokensGroup(bool isRequired, vector<ParseeToken> tokens, optional<ParseeTokensGroup> repeatedGroup);
-    bool getIsRequired();
-    vector<ParseeToken> getTokens();
-    optional<reference_wrapper<ParseeTokensGroup>> getRepeatedGroup();
-};
-
-#endif

src/Parser/Parsee/Parsee.cpp

@@ -0,0 +1,36 @@
+#include "Parsee.h"
+
+Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn) {
+    Parsee  parsee;
+    parsee.kind = ParseeKind::TOKEN;
+    parsee.tokenKind = tokenKind;
+    parsee.isRequired = isRequired;
+    parsee.shouldReturn = shouldReturn;
+
+    return parsee;
+}
+
+Parsee Parsee::typeParsee() {
+    Parsee  parsee;
+    parsee.kind = ParseeKind::TYPE;
+
+    return parsee;
+}
+
+Parsee::Parsee() { }
+
+ParseeKind Parsee::getKind() {
+    return kind;
+}
+
+TokenKind Parsee::getTokenKind() {
+    return tokenKind;
+}
+
+bool Parsee::getIsRequired() {
+    return isRequired;
+}
+
+bool Parsee::getShouldReturn() {
+    return shouldReturn;
+}

src/Parser/Parsee/Parsee.h

@@ -0,0 +1,31 @@
+#ifndef PARSEE_H
+#define PARSEE_H
+
+enum class TokenKind;
+
+enum class ParseeKind {
+    TOKEN,
+    TYPE
+};
+
+class Parsee {
+private:
+    ParseeKind kind;
+    TokenKind tokenKind;
+    bool isRequired;
+    bool shouldReturn;
+    
+    Parsee();
+
+public:
+    static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn);
+    static Parsee typeParsee();
+
+    ParseeKind getKind();
+
+    TokenKind getTokenKind();
+    bool getIsRequired();
+    bool getShouldReturn();
+};
+
+#endif

src/Parser/Parsee/ParseeGroup.cpp

@@ -0,0 +1,24 @@
+#include "ParseeGroup.h"
+
+#include "Parsee.h"
+
+ParseeGroup::ParseeGroup(bool isRequired, vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup):
+isRequired(isRequired), parsees(parsees) {
+    if (repeatedGroup) {
+        this->repeatedGroup = *repeatedGroup;
+    } else {
+        this->repeatedGroup = {};
+    }
+ }
+
+bool ParseeGroup::getIsRequired() {
+    return isRequired;
+}
+
+vector<Parsee> ParseeGroup::getParsees() {
+    return parsees;
+}
+
+optional<reference_wrapper<ParseeGroup>> ParseeGroup::getRepeatedGroup() {
+    return repeatedGroup;
+}

src/Parser/Parsee/ParseeGroup.h

@@ -0,0 +1,24 @@
+#ifndef PARSEE_GROUP_H
+#define PARSEE_GROUP_H
+
+#include <vector>
+#include <optional>
+
+class Parsee;
+
+using namespace std;
+
+class ParseeGroup {
+private:
+    bool isRequired;
+    vector<Parsee> parsees;
+    optional<reference_wrapper<ParseeGroup>> repeatedGroup;
+
+public:
+    ParseeGroup(bool isRequired, vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup);
+    bool getIsRequired();
+    vector<Parsee> getParsees();
+    optional<reference_wrapper<ParseeGroup>> getRepeatedGroup();
+};
+
+#endif

src/Parser/Parser.cpp

@@ -25,7 +25,8 @@
 #include "Parser/Statement/StatementBlock.h"
 #include "Parser/Statement/StatementRepeat.h"
 
-#include "Parsee.h"
+#include "Parsee/Parsee.h"
+#include "Parsee/ParseeGroup.h"
 
 Parser::Parser(vector<shared_ptr<Token>> tokens) :
 tokens(tokens) { }
@@ -247,12 +248,12 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
     shared_ptr<ValueType> returnType = ValueType::NONE;
 
     // identifier
-    groupTokens = tokensForParseeTokensGroup(
+    groupTokens = tokensForParseeGroup(
-        ParseeTokensGroup(
+        ParseeGroup(
             true,
             {
-                ParseeToken(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                ParseeToken(TokenKind::RAW_FUNCTION, true, false)
+                Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false)
             },
             {}
         )
@@ -265,13 +266,13 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
 
     // options
     if (!hasError) {
-        groupTokens = tokensForParseeTokensGroup(
+        groupTokens = tokensForParseeGroup(
-            ParseeTokensGroup(
+            ParseeGroup(
                 false,
                 {
-                    ParseeToken(TokenKind::LESS, true, false),
+                    Parsee::tokenParsee(TokenKind::LESS, true, false),
-                    ParseeToken(TokenKind::STRING, true, true),
+                    Parsee::tokenParsee(TokenKind::STRING, true, true),
-                    ParseeToken(TokenKind::GREATER, true, false)
+                    Parsee::tokenParsee(TokenKind::GREATER, true, false)
                 },
                 {}
             )
@@ -285,22 +286,22 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
 
     // arguments
     if (!hasError) {
-        groupTokens = tokensForParseeTokensGroup(
+        groupTokens = tokensForParseeGroup(
-            ParseeTokensGroup(
+            ParseeGroup(
                 false,
                 {
-                    ParseeToken(TokenKind::COLON, true, false),
+                    Parsee::tokenParsee(TokenKind::COLON, true, false),
-                    ParseeToken(TokenKind::NEW_LINE, false, false),
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    ParseeToken(TokenKind::IDENTIFIER, true, true),
+                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                    ParseeToken(TokenKind::TYPE, true, true)
+                    Parsee::typeParsee()
                 },
-                ParseeTokensGroup(
+                ParseeGroup(
                     true,
                     {
-                        ParseeToken(TokenKind::COMMA, true, false),
+                        Parsee::tokenParsee(TokenKind::COMMA, true, false),
-                        ParseeToken(TokenKind::NEW_LINE, false, false),
+                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                        ParseeToken(TokenKind::IDENTIFIER, true, true),
+                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                        ParseeToken(TokenKind::TYPE, true, true)
+                        Parsee::typeParsee()
                     },
                     {}
                 )
@@ -315,13 +316,13 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
 
     // return type 
     if (!hasError) {
-        groupTokens = tokensForParseeTokensGroup(
+        groupTokens = tokensForParseeGroup(
-            ParseeTokensGroup(
+            ParseeGroup(
                 false,
                 {
-                    ParseeToken(TokenKind::RIGHT_ARROW, true, false),
+                    Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
-                    ParseeToken(TokenKind::NEW_LINE, false, false),
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    ParseeToken(TokenKind::TYPE, true, true)
+                    Parsee::typeParsee()
                 },
                 {}
             )
@@ -871,12 +872,12 @@ shared_ptr<ValueType> Parser::matchValueType() {
     return ValueType::valueTypeForToken(typeToken, subType, valueArg);
 }
 
-optional<vector<shared_ptr<Token>>> Parser::tokensForParseeTokensGroup(ParseeTokensGroup group) {
+optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup group) {
     int nextIndex = currentIndex;
     vector<shared_ptr<Token>> returnTokens;
     bool mustFulfill = false;
 
-    for (ParseeToken &parsee : group.getTokens()) {
+    for (Parsee &parsee : group.getParsees()) {
         shared_ptr<Token> currentToken = tokens.at(nextIndex);
         bool matches = currentToken->isOfKind({parsee.getTokenKind()});
 

src/Parser/Parser.h

@@ -12,8 +12,7 @@ class ValueType;
 class Expression;
 class Statement;
 
-class ParseeToken;
+class ParseeGroup;
-class ParseeTokensGroup;
 
 using namespace std;
 
@@ -55,7 +54,7 @@ private:
 
     shared_ptr<ValueType> matchValueType();
 
-    optional<vector<shared_ptr<Token>>> tokensForParseeTokensGroup(ParseeTokensGroup group);
+    optional<vector<shared_ptr<Token>>> tokensForParseeGroup(ParseeGroup group);
     bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
 
     void markError(optional<TokenKind> expectedTokenKind, optional<string> message);