wip

src/Parser/Parsee/Parsee.cpp

@@ -1,20 +1,29 @@
 #include "Parsee.h"
 
+#include "Parser/Expression/Expression.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::valueTypeParsee() {
+Parsee Parsee::valueTypeParsee(bool isRequired) {
     Parsee parsee;
     parsee.kind = ParseeKind::VALUE_TYPE;
+    parsee.isRequired = isRequired;
     parsee.shouldReturn = true;
+    return parsee;
+}
 
+Parsee Parsee::expressionParsee(bool isRequired) {
+    Parsee parsee;
+    parsee.kind = ParseeKind::EXPRESSION;
+    parsee.isRequired = isRequired;
+    parsee.shouldReturn = true;
     return parsee;
 }
 

src/Parser/Parsee/Parsee.h

@@ -1,11 +1,15 @@
 #ifndef PARSEE_H
 #define PARSEE_H
 
+#include <memory>
+
 enum class TokenKind;
+class Expression;
 
 enum class ParseeKind {
     TOKEN,
-    VALUE_TYPE
+    VALUE_TYPE,
+    EXPRESSION
 };
 
 class Parsee {
@@ -18,7 +22,8 @@ private:
 
 public:
     static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn);
-    static Parsee valueTypeParsee();
+    static Parsee valueTypeParsee(bool isRequired);
+    static Parsee expressionParsee(bool isRequired);
 
     ParseeKind getKind();
     TokenKind getTokenKind();

src/Parser/Parsee/ParseeGroup.cpp

@@ -2,8 +2,8 @@
 
 #include "Parsee.h"
 
-ParseeGroup::ParseeGroup(bool isRequired, vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup):
-isRequired(isRequired), parsees(parsees) {
+ParseeGroup::ParseeGroup(/*bool isRequired, */vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup):
+/*isRequired(isRequired), */parsees(parsees) {
     if (repeatedGroup) {
         this->repeatedGroup = *repeatedGroup;
     } else {
@@ -11,9 +11,9 @@ isRequired(isRequired), parsees(parsees) {
     }
  }
 
-bool ParseeGroup::getIsRequired() {
+/*bool ParseeGroup::getIsRequired() {
     return isRequired;
-}
+}*/
 
 vector<Parsee> ParseeGroup::getParsees() {
     return parsees;

src/Parser/Parsee/ParseeGroup.h

@@ -10,13 +10,13 @@ using namespace std;
 
 class ParseeGroup {
 private:
-    bool isRequired;
+    //bool isRequired;
     vector<Parsee> parsees;
     optional<reference_wrapper<ParseeGroup>> repeatedGroup;
 
 public:
-    ParseeGroup(bool isRequired, vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup);
-    bool getIsRequired();
+    ParseeGroup(/*bool isRequired, */vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup);
+    //bool getIsRequired();
     vector<Parsee> getParsees();
     optional<reference_wrapper<ParseeGroup>> getRepeatedGroup();
 };

src/Parser/Parsee/ParseeResult.cpp

@@ -19,6 +19,14 @@ ParseeResult ParseeResult::valueTypeResult(shared_ptr<ValueType> valueType, int
     return parseeResult;    
 }
 
+ParseeResult ParseeResult::expressionResult(shared_ptr<Expression> expression, int tokensCount) {
+    ParseeResult result;
+    result.kind = ParseeResultKind::EXPRESSION;
+    result.expression = expression;
+    result.tokensCount = tokensCount;
+    return result;
+}
+
 ParseeResult::ParseeResult() { }
 
 
@@ -34,6 +42,10 @@ shared_ptr<ValueType> ParseeResult::getValueType() {
     return valueType;
 }
 
+shared_ptr<Expression> ParseeResult::getExpression() {
+    return expression;
+}
+
 int ParseeResult::getTokensCount() {
     return tokensCount;
 }

src/Parser/Parsee/ParseeResult.h

@@ -5,12 +5,14 @@
 
 class Token;
 class ValueType;
+class Expression;
 
 using namespace std;
 
 enum class ParseeResultKind {
     TOKEN,
     VALUE_TYPE,
+    EXPRESSION
 };
 
 class ParseeResult {
@@ -18,16 +20,19 @@ private:
     ParseeResultKind kind;
     shared_ptr<Token> token;
     shared_ptr<ValueType> valueType;
+    shared_ptr<Expression> expression;
     int tokensCount;
     ParseeResult();
 
 public:
     static ParseeResult tokenResult(shared_ptr<Token> token);
     static ParseeResult valueTypeResult(shared_ptr<ValueType> valueType, int tokensCount);
+    static ParseeResult expressionResult(shared_ptr<Expression> expression, int tokensCount);
 
     ParseeResultKind getKind();
     shared_ptr<Token> getToken();
     shared_ptr<ValueType> getValueType();
+    shared_ptr<Expression> getExpression();
     int getTokensCount();
 };
 

src/Parser/Parsee/ParseeResultsGroup.cpp

@@ -0,0 +1,30 @@
+#include "ParseeResultsGroup.h"
+
+#include "ParseeResult.h"
+
+ParseeResultsGroup ParseeResultsGroup::success(vector<ParseeResult> results) {
+    ParseeResultsGroup resultsGroup;
+    resultsGroup.kind = ParseeResultsGroupKind::SUCCESS;
+    resultsGroup.results = results;
+    return resultsGroup;
+}
+
+ParseeResultsGroup ParseeResultsGroup::noMatch() {
+    ParseeResultsGroup resultsGroup;
+    resultsGroup.kind = ParseeResultsGroupKind::NO_MATCH;
+    return resultsGroup;
+}
+
+ParseeResultsGroup ParseeResultsGroup::failure() {
+    ParseeResultsGroup resultsGroup;
+    resultsGroup.kind = ParseeResultsGroupKind::FAILURE;
+    return resultsGroup;
+}
+
+ParseeResultsGroupKind ParseeResultsGroup::getKind() {
+    return kind;
+}
+
+vector<ParseeResult> ParseeResultsGroup::getResults() {
+    return results;
+}

src/Parser/Parsee/ParseeResultsGroup.h

@@ -0,0 +1,30 @@
+#ifndef PARSEE_RESULTS_GROUP_H
+#define PARSEE_RESULTS_GROUP_H
+
+#include <vector>
+
+class ParseeResult;
+
+using namespace std;
+
+enum class ParseeResultsGroupKind {
+    SUCCESS,
+    NO_MATCH,
+    FAILURE
+};
+
+class ParseeResultsGroup {
+private:
+    ParseeResultsGroupKind kind;
+    vector<ParseeResult> results;
+
+public:
+    static ParseeResultsGroup success(vector<ParseeResult> results);
+    static ParseeResultsGroup noMatch();
+    static ParseeResultsGroup failure();
+
+    ParseeResultsGroupKind getKind();
+    vector<ParseeResult> getResults();
+};
+
+#endif