Merge pull request #31 from rafalgrodzinski/29-match-line-of-tokens-through-a-function

Match line of tokens through a function

samples/test.brc

@@ -24,15 +24,20 @@ i u32 <- 0, rep text[i] != 0:
     add $1, $0
 ;*/
 
-normAdd fun: num1 sint32, num2 sint32 -> sint32
+/*normAdd fun: num1 sint32, num2 sint32 -> sint32
     ret num1 + num2
-;
+;*/
 
 rawAdd raw<"=r,r,r">: num1 sint32, num2 sint32 -> sint32
     add $1, $2
     mov $0, $1
 ;
 
+/*rawAdd raw: num1 sint32, num2 sint32 -> sint32
+    add $1, $2
+    mov $0, $1
+;*/
+
 /*printChar raw
     .global REGISTER
     .text
@@ -44,10 +49,12 @@ rawAdd raw<"=r,r,r">: num1 sint32, num2 sint32 -> sint32
 ;*/
 
 main fun -> sint32
-    //printChar()
+    /*a sint32 <- 4
+    b sint32 <- 5
 
-    res1 sint32 <- normAdd(4, 5)
+    res sint32 <- rawAdd(4, 5)*/
-    res2 sint32 <- rawAdd(4, 5)
+    putchar('@')
+    putchar('\n')
 
     ret 0
 ;

src/Logger.cpp

@@ -482,7 +482,7 @@ void Logger::print(shared_ptr<Error> error) {
     switch (error->getKind()) {
         case ErrorKind::LEXER_ERROR: {
             string lexme = error->getLexme() ? *(error->getLexme()) : "";
-            message = format("Unexpected token \"{}\" at line: {}, column: {}", lexme, error->getLine() + 1, error->getColumn() + 1);
+            message = format("At line {}, column {}: Unexpected token \"{}\"", error->getLine() + 1, error->getColumn() + 1, lexme);
             break;
         }
         case ErrorKind::PARSER_ERROR: {
@@ -492,13 +492,13 @@ void Logger::print(shared_ptr<Error> error) {
 
             if (expectedTokenKind) {
                 message = format(
-                    "Expected token {} but instead found {} at line: {}, column: {}",
+                    "At line {}, column {}: Expected token {} but found {} instead",
-                    toString(*expectedTokenKind), toString(token), token->getLine() + 1, token->getColumn() + 1
+                    token->getLine() + 1, token->getColumn() + 1, toString(*expectedTokenKind), toString(token)
                 );
             } else {
                 message = format(
-                    "Unexpected token \"{}\" found at line: {}, column: {}",
+                    "At line {}, column {}: Unexpected token \"{}\" found",
-                    toString(token), token->getLine() + 1, token->getColumn() + 1
+                    token->getLine() + 1, token->getColumn() + 1, toString(token)
                 );
             }
             if (errorMessage)
@@ -507,7 +507,7 @@ void Logger::print(shared_ptr<Error> error) {
         }
         case ErrorKind::BUILDER_ERROR: {
             string errorMessage = error->getMessage() ? *(error->getMessage()) : "";
-            message = format("Error at line {}, column {}: {}", error->getLine(), error->getColumn(), errorMessage);
+            message = format("At line {}, column {}: {}", error->getLine(), error->getColumn(), errorMessage);
             break;
         }
     }

src/Parser/Parsee/Parsee.cpp

@@ -0,0 +1,44 @@
+#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::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;
+}
+
+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,33 @@
+#ifndef PARSEE_H
+#define PARSEE_H
+
+#include <memory>
+
+enum class TokenKind;
+
+enum class ParseeKind {
+    TOKEN,
+    VALUE_TYPE,
+    EXPRESSION
+};
+
+class Parsee {
+private:
+    ParseeKind kind;
+    TokenKind tokenKind;
+    bool isRequired;
+    bool shouldReturn;
+    Parsee();
+
+public:
+    static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn);
+    static Parsee valueTypeParsee(bool isRequired);
+    static Parsee expressionParsee(bool isRequired);
+
+    ParseeKind getKind();
+    TokenKind getTokenKind();
+    bool getIsRequired();
+    bool getShouldReturn();
+};
+
+#endif

src/Parser/Parsee/ParseeGroup.cpp

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

src/Parser/Parsee/ParseeGroup.h

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

src/Parser/Parsee/ParseeResult.cpp

@@ -0,0 +1,51 @@
+#include "ParseeResult.h"
+
+#include "Lexer/Token.h"
+#include "Parser/ValueType.h"
+
+ParseeResult ParseeResult::tokenResult(shared_ptr<Token> token) {
+    ParseeResult parseeResult;
+    parseeResult.kind = ParseeResultKind::TOKEN;
+    parseeResult.token = token;
+    parseeResult.tokensCount = 1;
+    return parseeResult;
+}
+
+ParseeResult ParseeResult::valueTypeResult(shared_ptr<ValueType> valueType, int tokensCount) {
+    ParseeResult parseeResult;
+    parseeResult.kind = ParseeResultKind::VALUE_TYPE;
+    parseeResult.valueType = valueType;
+    parseeResult.tokensCount = tokensCount;
+    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() { }
+
+
+ParseeResultKind ParseeResult::getKind() {
+    return kind;
+}
+
+shared_ptr<Token> ParseeResult::getToken() {
+    return token;
+}
+
+shared_ptr<ValueType> ParseeResult::getValueType() {
+    return valueType;
+}
+
+shared_ptr<Expression> ParseeResult::getExpression() {
+    return expression;
+}
+
+int ParseeResult::getTokensCount() {
+    return tokensCount;
+}

src/Parser/Parsee/ParseeResult.h

@@ -0,0 +1,39 @@
+#ifndef PARSEE_RESULT_H
+#define PARSEE_RESULT_H
+
+#include <memory>
+
+class Token;
+class ValueType;
+class Expression;
+
+using namespace std;
+
+enum class ParseeResultKind {
+    TOKEN,
+    VALUE_TYPE,
+    EXPRESSION
+};
+
+class ParseeResult {
+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();
+};
+
+#endif

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

src/Parser/Parser.cpp

@@ -25,6 +25,11 @@
 #include "Parser/Statement/StatementBlock.h"
 #include "Parser/Statement/StatementRepeat.h"
 
+#include "Parsee/Parsee.h"
+#include "Parsee/ParseeGroup.h"
+#include "Parsee/ParseeResult.h"
+#include "Parsee/ParseeResultsGroup.h"
+
 Parser::Parser(vector<shared_ptr<Token>> tokens) :
 tokens(tokens) { }
 
@@ -107,112 +112,207 @@ shared_ptr<Statement> Parser::nextInBlockStatement() {
 }
 
 shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
-    if (!tryMatchingTokenKinds({TokenKind::M_EXTERN, TokenKind::IDENTIFIER, TokenKind::FUNCTION}, true, false))
+    ParseeResultsGroup resultsGroup;
-        return nullptr;
 
-    string name;
+    string identifier;
     vector<pair<string, shared_ptr<ValueType>>> arguments;
     shared_ptr<ValueType> returnType = ValueType::NONE;
 
-    currentIndex++; // skip meta
+    // identifier
-    shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
+    resultsGroup = parseeResultsGroupForParseeGroup(
-    currentIndex++; // skip fun
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::M_EXTERN, true, false),
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::FUNCTION, true, false)
+            },
+            {}
+        )
+    );
+
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+        case ParseeResultsGroupKind::FAILURE:
+            return nullptr;
+    }
 
     // arguments
-    if (tryMatchingTokenKinds({TokenKind::COLON}, true, true)) {
+    resultsGroup = parseeResultsGroupForParseeGroup(
-        do {
+        ParseeGroup(
-            tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
+            {
-            if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) {
+                Parsee::tokenParsee(TokenKind::COLON, true, false),
-                markError({}, "Expected function argument");
+                Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                return nullptr;
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::valueTypeParsee(true)
+            },
+            ParseeGroup(
+                {
+                    Parsee::tokenParsee(TokenKind::COMMA, true, false),
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                    Parsee::valueTypeParsee(true)
+                },
+                {}
+            )
+        )
+    );
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            for (int i=0; i<resultsGroup.getResults().size(); i+=2) {
+                pair<string, shared_ptr<ValueType>> arg;
+                arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
+                arg.second = resultsGroup.getResults().at(i+1).getValueType();
+                arguments.push_back(arg);
             }
-            shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
+            break;
-            //shared_ptr<Token> argumentTypeToken = tokens.at(currentIndex++);
+        case ParseeResultsGroupKind::NO_MATCH:
-            shared_ptr<ValueType> argumentType = matchValueType();
+            break;
-            if (argumentType == nullptr) {
+        case ParseeResultsGroupKind::FAILURE:
-                markError(TokenKind::TYPE, {});
-                return nullptr;
-            }
-            
-            arguments.push_back(pair<string, shared_ptr<ValueType>>(identifierToken->getLexme(), argumentType));
-        } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
-    }
-
-    // Return type
-    if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
-        tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
-
-        //shared_ptr<Token> returnTypeToken = tokens.at(currentIndex);
-        returnType = matchValueType();
-        if (returnType == nullptr) {
-            markError(TokenKind::TYPE, {});
             return nullptr;
-        }
     }
 
-    return make_shared<StatementMetaExternFunction>(identifierToken->getLexme(), arguments, returnType);
+    // return type 
+    resultsGroup = parseeResultsGroupForParseeGroup(
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
+                Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                Parsee::valueTypeParsee(true)
+            },
+            {}
+        )
+    );
+
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            returnType = resultsGroup.getResults().at(0).getValueType();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+            break;
+        case ParseeResultsGroupKind::FAILURE:
+            return nullptr;
+    }
+
+    return make_shared<StatementMetaExternFunction>(identifier, arguments, returnType);
 }
 
 shared_ptr<Statement> Parser::matchStatementVariable() {
-    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false))
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::valueTypeParsee(true),
+                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false),
+                Parsee::expressionParsee(true)
+            },
+            {}
+        )
+    );
+
+    if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
         return nullptr;
 
-    shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
+    string identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
-    shared_ptr<ValueType> valueType = matchValueType();
+    shared_ptr<ValueType> valueType = resultsGroup.getResults().at(1).getValueType();
+    shared_ptr<Expression> expression = resultsGroup.getResults().at(2).getExpression();
 
-    // Expect left arrow
+    return make_shared<StatementVariable>(identifier, valueType, expression);
-    if (!tryMatchingTokenKinds({TokenKind::LEFT_ARROW}, true, true)) {
-        markError(TokenKind::LEFT_ARROW, {});
-        return nullptr;
-    }
-
-    shared_ptr<Expression> expression = nextExpression();
-    if (expression == nullptr)
-        return nullptr;
-
-    return make_shared<StatementVariable>(identifierToken->getLexme(), valueType, expression);
 }
 
 shared_ptr<Statement> Parser::matchStatementFunction() {
-     if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::FUNCTION}, true, false))
+    bool hasError = false;
-        return nullptr;
+    ParseeResultsGroup resultsGroup;
 
     string name;
     vector<pair<string, shared_ptr<ValueType>>> arguments;
     shared_ptr<ValueType> returnType = ValueType::NONE;
     shared_ptr<Statement> statementBlock;
 
-    // name
+    // identifier
-    name = tokens.at(currentIndex++)->getLexme();
+    resultsGroup = parseeResultsGroupForParseeGroup(
-    currentIndex++; // skip fun
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::FUNCTION, true, false)
+            },
+            {}
+        )
+    );
 
-    // arguments
+    switch (resultsGroup.getKind()) {
-    if (tryMatchingTokenKinds({TokenKind::COLON}, true, true)) {
+        case ParseeResultsGroupKind::SUCCESS:
-        do {
+            name = resultsGroup.getResults().at(0).getToken()->getLexme();
-            tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
+            break;
-            if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) {
+        case ParseeResultsGroupKind::NO_MATCH:
-                markError({}, "Expected function argument");
+            return nullptr;
-                return nullptr;
+        case ParseeResultsGroupKind::FAILURE:
-            }
+            hasError = true;
-            shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
+            break;
-            shared_ptr<ValueType> argumentType = matchValueType();
-            if (argumentType == nullptr) {
-                markError(TokenKind::TYPE, {});
-                return nullptr;
-            }
-            
-            arguments.push_back(pair<string, shared_ptr<ValueType>>(identifierToken->getLexme(), argumentType));
-        } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
     }
 
-    // return type
+    // arguments
-    if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
+    if (!hasError) {
-        tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
+        resultsGroup = parseeResultsGroupForParseeGroup(
+            ParseeGroup(
+                {
+                    Parsee::tokenParsee(TokenKind::COLON, true, false),
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                    Parsee::valueTypeParsee(true)
+                },
+                ParseeGroup(
+                    {
+                        Parsee::tokenParsee(TokenKind::COMMA, true, false),
+                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                        Parsee::valueTypeParsee(true)
+                    },
+                    {}
+                )
+            )
+        );
+        switch (resultsGroup.getKind()) {
+            case ParseeResultsGroupKind::SUCCESS:
+                for (int i=0; i<resultsGroup.getResults().size(); i+=2) {
+                    pair<string, shared_ptr<ValueType>> arg;
+                    arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
+                    arg.second = resultsGroup.getResults().at(i+1).getValueType();
+                    arguments.push_back(arg);
+                }
+                break;
+            case ParseeResultsGroupKind::NO_MATCH:
+                break;
+            case ParseeResultsGroupKind::FAILURE:
+                hasError = true;
+                break;
+        }
+    }
 
-        returnType = matchValueType();
+    // return type 
-        if (returnType == nullptr) {
+    if (!hasError) {
-            markError(TokenKind::TYPE, {});
+        resultsGroup = parseeResultsGroupForParseeGroup(
-            return nullptr;
+            ParseeGroup(
+                {
+                    Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                    Parsee::valueTypeParsee(true)
+                },
+                {}
+            )
+        );
+
+        switch (resultsGroup.getKind()) {
+            case ParseeResultsGroupKind::SUCCESS:
+                returnType = resultsGroup.getResults().at(0).getValueType();
+                break;
+            case ParseeResultsGroupKind::NO_MATCH:
+                break;
+            case ParseeResultsGroupKind::FAILURE:
+                hasError = true;
+                break;
         }
     }
 
@@ -223,10 +323,11 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
     }
 
     // block
-    statementBlock = matchStatementBlock({TokenKind::SEMICOLON});
+    statementBlock = matchStatementBlock({TokenKind::SEMICOLON, TokenKind::END});
     if (statementBlock == nullptr)
         return nullptr;
 
+    // closing semicolon
     if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) {
         markError(TokenKind::SEMICOLON, {});
         return nullptr;
@@ -236,8 +337,8 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
 }
 
 shared_ptr<Statement> Parser::matchStatementRawFunction() {
-    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::RAW_FUNCTION}, true, false))
+    bool hasError = false;
-        return nullptr;
+    ParseeResultsGroup resultsGroup;
 
     string name;
     string constraints;
@@ -245,50 +346,118 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
     shared_ptr<ValueType> returnType = ValueType::NONE;
     string rawSource;
 
-    // name
+    // identifier
-    name = tokens.at(currentIndex++)->getLexme();
+    resultsGroup = parseeResultsGroupForParseeGroup(
-    currentIndex++; // skip raw
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false)
+            },
+            {}
+        )
+    );
+
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            name = resultsGroup.getResults().at(0).getToken()->getLexme();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+            return nullptr;
+            break;
+        case ParseeResultsGroupKind::FAILURE:
+            hasError = true;
+            break;
+    }
 
     // constraints
+    if (!hasError) {
+        resultsGroup = parseeResultsGroupForParseeGroup(
+            ParseeGroup(
+                {
+                    Parsee::tokenParsee(TokenKind::LESS, true, false),
+                    Parsee::tokenParsee(TokenKind::STRING, true, true),
+                    Parsee::tokenParsee(TokenKind::GREATER, true, false)
+                },
+                {}
+            )
+        );
 
-    if (tryMatchingTokenKinds({TokenKind::LESS}, true, true)) {
+        switch (resultsGroup.getKind()) {
-        if (tokens.at(currentIndex)->isOfKind({TokenKind::STRING})) {
+            case ParseeResultsGroupKind::SUCCESS:
-            constraints = tokens.at(currentIndex++)->getLexme();
+                constraints = resultsGroup.getResults().at(0).getToken()->getLexme();
-            // remove enclosing quotes
+                // remove enclosing quotes
-            if (constraints.length() >= 2)
+                if (constraints.length() >= 2)
-                constraints = constraints.substr(1, constraints.length() - 2);
+                    constraints = constraints.substr(1, constraints.length() - 2);
+                break;
+            case ParseeResultsGroupKind::NO_MATCH:
+                return nullptr;
+                break;
+            case ParseeResultsGroupKind::FAILURE:
+                hasError = true;
+                break;
         }
-        if (!tryMatchingTokenKinds({TokenKind::GREATER}, true, true))
-            markError({TokenKind::GREATER}, {});
     }
 
     // arguments
-    if (tryMatchingTokenKinds({TokenKind::COLON}, true, true)) {
+    if (!hasError) {
-        do {
+        resultsGroup = parseeResultsGroupForParseeGroup(
-            tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
+            ParseeGroup(
-            if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) {
+                {
-                markError({}, "Expected function argument");
+                    Parsee::tokenParsee(TokenKind::COLON, true, false),
-                return nullptr;
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-            }
+                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-            shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
+                    Parsee::valueTypeParsee(true)
-            shared_ptr<ValueType> argumentType = matchValueType();
+                },
-            if (argumentType == nullptr) {
+                ParseeGroup(
-                markError(TokenKind::TYPE, {});
+                    {
-                return nullptr;
+                        Parsee::tokenParsee(TokenKind::COMMA, true, false),
-            }
+                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-            
+                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-            arguments.push_back(pair<string, shared_ptr<ValueType>>(identifierToken->getLexme(), argumentType));
+                        Parsee::valueTypeParsee(true)
-        } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
+                    },
+                    {}
+                )
+            )
+        );
+        switch (resultsGroup.getKind()) {
+            case ParseeResultsGroupKind::SUCCESS:
+                for (int i=0; i<resultsGroup.getResults().size(); i+=2) {
+                    pair<string, shared_ptr<ValueType>> arg;
+                    arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
+                    arg.second = resultsGroup.getResults().at(i+1).getValueType();
+                    arguments.push_back(arg);
+                }
+                break;
+            case ParseeResultsGroupKind::NO_MATCH:
+                break;
+            case ParseeResultsGroupKind::FAILURE:
+                hasError = true;
+                break;
+        }
     }
 
-    // return type
+    // return type 
-    if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
+    if (!hasError) {
-        tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
+        resultsGroup = parseeResultsGroupForParseeGroup(
+            ParseeGroup(
+                {
+                    Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
+                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                    Parsee::valueTypeParsee(true)
+                },
+                {}
+            )
+        );
 
-        returnType = matchValueType();
+        switch (resultsGroup.getKind()) {
-        if (returnType == nullptr) {
+            case ParseeResultsGroupKind::SUCCESS:
-            markError(TokenKind::TYPE, {});
+                returnType = resultsGroup.getResults().at(0).getValueType();
-            return nullptr;
+                break;
+            case ParseeResultsGroupKind::NO_MATCH:
+                break;
+            case ParseeResultsGroupKind::FAILURE:
+                hasError = true;
+                break;
         }
     }
 
@@ -337,44 +506,90 @@ shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalToke
 
 shared_ptr<Statement> Parser::matchStatementAssignment() {
     int startIndex = currentIndex;
+    ParseeResultsGroup resultsGroup;
 
-    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, false))
+    string identifier;
-        return nullptr;
-    shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
     shared_ptr<Expression> indexExpression;
+    shared_ptr<Expression> expression;
 
-    if (tryMatchingTokenKinds({TokenKind::LEFT_SQUARE_BRACKET}, true, true)) {
+    // identifier
-        indexExpression = nextExpression();
+    resultsGroup = parseeResultsGroupForParseeGroup(
-        if (indexExpression == nullptr)
+        ParseeGroup(
-            return nullptr;
+            {
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+            },
+            {}
+        )
+    );
 
-        if (!tryMatchingTokenKinds({TokenKind::RIGHT_SQUARE_BRACKET}, true, true)) {
+    if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
-            markError(TokenKind::RIGHT_SQUARE_BRACKET, {});
-            return nullptr;
-        }
-    }
-
-    // assignment requires left arrow, otherwise abort
-    if (!tryMatchingTokenKinds({TokenKind::LEFT_ARROW}, true, true)) {
-        currentIndex = startIndex;
-        return nullptr;
-    }
-
-    shared_ptr<Expression> expression = nextExpression();
-    if (expression == nullptr)
         return nullptr;
 
-    return make_shared<StatementAssignment>(identifierToken->getLexme(), indexExpression, expression);
+    identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
+
+    // index expression
+    resultsGroup = parseeResultsGroupForParseeGroup(
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false),
+                Parsee::expressionParsee(true),
+                Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false),
+            },
+            {}
+        )
+    );
+
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            indexExpression = resultsGroup.getResults().at(0).getExpression();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+            break;
+        case ParseeResultsGroupKind::FAILURE:
+            return nullptr;
+    }
+
+    // expression
+    resultsGroup = parseeResultsGroupForParseeGroup(
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false),
+                Parsee::expressionParsee(true)
+            },
+            {}
+        )
+    );
+
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            expression = resultsGroup.getResults().at(0).getExpression();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+            currentIndex = startIndex;
+            return nullptr;
+        case ParseeResultsGroupKind::FAILURE:
+            return nullptr;
+    }
+
+    return make_shared<StatementAssignment>(identifier, indexExpression, expression);
 }
 
 shared_ptr<Statement> Parser::matchStatementReturn() {
-    if (!tryMatchingTokenKinds({TokenKind::RETURN}, true, true))
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::RETURN, true, false),
+                Parsee::expressionParsee(false)
+            },
+            {}
+        )
+    );
+
+    if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
         return nullptr;
 
-    shared_ptr<Expression> expression = nextExpression();
+    shared_ptr<Expression> expression = !resultsGroup.getResults().empty() ? resultsGroup.getResults().at(0).getExpression() : nullptr;
-    if (expression == nullptr)
+
-        return nullptr;
-    
     return make_shared<StatementReturn>(expression);
 }
 
@@ -471,7 +686,6 @@ shared_ptr<Expression> Parser::nextExpression() {
     if (expression != nullptr || errors.size() > errorsCount)
         return expression;
 
-    markError({}, {});
     return nullptr;
 }
 
@@ -707,6 +921,7 @@ shared_ptr<Expression> Parser::matchExpressionBinary(shared_ptr<Expression> left
     }
 
     if (right == nullptr) {
+        markError({}, "Expected expression");
         return nullptr;
     } else {
         return make_shared<ExpressionBinary>(token, left, right);
@@ -737,44 +952,130 @@ shared_ptr<Expression> Parser::matchExpressionBlock(vector<TokenKind> terminalTo
     return make_shared<ExpressionBlock>(statements);
 }
 
-shared_ptr<ValueType> Parser::matchValueType() {
+ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
-    if (!tryMatchingTokenKinds({TokenKind::TYPE}, true, false))
+    int errorsCount = errors.size();
-        return nullptr;
+    int startIndex = currentIndex;
-    shared_ptr<Token> typeToken = tokens.at(currentIndex++);
+    vector<ParseeResult> results;
-    shared_ptr<ValueType> subType;
+    bool mustFulfill = false;
-    int valueArg = 0;
 
-    if (tryMatchingTokenKinds({TokenKind::LESS}, true, true)) {
+    for (Parsee &parsee : group.getParsees()) {
-        if (!tryMatchingTokenKinds({TokenKind::TYPE}, true, false)) {
+        optional<ParseeResult> result;
-            markError(TokenKind::TYPE, {});
+        switch (parsee.getKind()) {
-            return nullptr;
+            case ParseeKind::TOKEN:
-        }
+                result = tokenParseeResult(currentIndex, parsee.getTokenKind());
-        subType = matchValueType();
+                break;
-        if (subType == nullptr)
+            case ParseeKind::VALUE_TYPE:
-            return subType;
+                result = valueTypeParseeResult(currentIndex);
-
+                break;
-        if (tryMatchingTokenKinds({TokenKind::COMMA}, true, true)) {
+            case ParseeKind::EXPRESSION:
-            if (!tryMatchingTokenKinds({TokenKind::INTEGER_DEC, TokenKind::INTEGER_HEX, TokenKind::INTEGER_BIN, TokenKind::INTEGER_CHAR}, false, false)) {
+                result = expressionParseeResult(currentIndex);
-                markError({}, "Expected integer literal");
+                break;
-                return nullptr;
-            }
-            shared_ptr<Expression> expressionValue = matchExpressionLiteral();
-            if (expressionValue == nullptr) {
-                markError({}, "Expected integer literal");
-                return nullptr;
-            }
-
-            valueArg = dynamic_pointer_cast<ExpressionLiteral>(expressionValue)->getSint32Value();
         }
 
+        // generated an error?
+        if (errors.size() > errorsCount)
+            return ParseeResultsGroup::failure();
 
-        if (!tryMatchingTokenKinds({TokenKind::GREATER}, true, true)) {
+        // if doesn't match on optional group
-            markError(TokenKind::GREATER, {});
+        if (!result && parsee.getIsRequired() && !mustFulfill) {
-            return nullptr;
+            currentIndex = startIndex;
+            //return vector<ParseeResult>();
+            return ParseeResultsGroup::noMatch();
         }
+
+        // return matching token?
+        if (result && parsee.getShouldReturn())
+            results.push_back(*result);
+
+        // decide if we're decoding the expected sequence
+        if (!parsee.getIsRequired() && currentIndex > startIndex)
+            mustFulfill = true;
+
+        // invalid sequence detected?
+        if (!result && parsee.getIsRequired() && mustFulfill) {
+            markError(parsee.getTokenKind(), {});
+            //return {};
+            return ParseeResultsGroup::failure();
+        }
+
+        // got to the next token if we got a match
+        if (result)
+            currentIndex += (*result).getTokensCount();
     }
 
-    return ValueType::valueTypeForToken(typeToken, subType, valueArg);
+    if (group.getRepeatedGroup()) {
+        ParseeResultsGroup subResultsGroup;
+        do {
+            subResultsGroup = parseeResultsGroupForParseeGroup(*group.getRepeatedGroup());
+            if (subResultsGroup.getKind() == ParseeResultsGroupKind::FAILURE)
+                return ParseeResultsGroup::failure();
+
+            for (ParseeResult &subResult : subResultsGroup.getResults())
+                results.push_back(subResult);
+        } while (subResultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS);
+    }
+
+    return ParseeResultsGroup::success(results);
+}
+
+optional<ParseeResult> Parser::tokenParseeResult(int index, TokenKind tokenKind) {
+    shared_ptr<Token> token = tokens.at(index);
+    if (token->isOfKind({tokenKind}))
+        return ParseeResult::tokenResult(token);
+    return {};
+}
+
+optional<ParseeResult> Parser::valueTypeParseeResult(int index) {
+    int startIndex = index;
+
+    if (!tokens.at(index)->isOfKind({TokenKind::TYPE}))
+        return {};
+
+    shared_ptr<Token> typeToken = tokens.at(index++);
+    shared_ptr<ValueType> subType;
+    int typeArg = 0;
+
+    if (tokens.at(index)->isOfKind({TokenKind::LESS})) {
+        index++;
+        optional<ParseeResult> subResult = valueTypeParseeResult(index);
+        if (!subResult)
+            return {};
+        subType = (*subResult).getValueType();
+        index += (*subResult).getTokensCount();
+
+        if (tokens.at(index)->isOfKind({TokenKind::COMMA})) {
+            index++;
+
+            if (!tokens.at(index)->isOfKind({TokenKind::INTEGER_DEC, TokenKind::INTEGER_HEX, TokenKind::INTEGER_BIN, TokenKind::INTEGER_CHAR}))
+                return {};
+
+            int storedIndex = currentIndex;
+            currentIndex = index;
+            shared_ptr<Expression> expressionValue = matchExpressionLiteral();
+            typeArg = dynamic_pointer_cast<ExpressionLiteral>(expressionValue)->getSint32Value();
+            currentIndex = storedIndex;
+            index++;
+        }
+
+        if (!tokens.at(index)->isOfKind({TokenKind::GREATER}))
+            return {};
+        index++;
+    }
+
+    shared_ptr<ValueType> valueType = ValueType::valueTypeForToken(typeToken, subType, typeArg);
+    return ParseeResult::valueTypeResult(valueType, index - startIndex);
+}
+
+optional<ParseeResult> Parser::expressionParseeResult(int index) {
+    int startIndex = currentIndex;
+    int errorsCount = errors.size();
+    shared_ptr<Expression> expression = nextExpression();
+    if (errors.size() > errorsCount)
+        return {};
+
+    int tokensCount = currentIndex - startIndex;
+    currentIndex = startIndex;
+    return ParseeResult::expressionResult(expression, tokensCount);
 }
 
 bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) {

src/Parser/Parser.h

@@ -12,6 +12,10 @@ class ValueType;
 class Expression;
 class Statement;
 
+class ParseeGroup;
+class ParseeResult;
+class ParseeResultsGroup;
+
 using namespace std;
 
 class Parser {
@@ -50,8 +54,10 @@ private:
     shared_ptr<Expression> matchExpressionBinary(shared_ptr<Expression> left);
     shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds);
 
-    shared_ptr<ValueType> matchValueType();
+    ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group);
-
+    optional<ParseeResult> tokenParseeResult(int index, TokenKind tokenKind);
+    optional<ParseeResult> valueTypeParseeResult(int index);
+    optional<ParseeResult> expressionParseeResult(int index);
     bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
 
     void markError(optional<TokenKind> expectedTokenKind, optional<string> message);