Single parsing logic

samples/test.brc

@@ -28,7 +28,12 @@ i u32 <- 0, rep text[i] != 0:
     ret num1 + num2
 ;*/
 
-rawAdd raw<"=r,r,r">: num1 sint32, num2 sint32 -> sint32
+/*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
 ;
@@ -46,8 +51,8 @@ rawAdd raw<"=r,r,r">: num1 sint32, num2 sint32 -> sint32
 main fun -> sint32
     //printChar()
 
-    res1 sint32 <- normAdd(4, 5)
+    //res1 sint32 <- normAdd(4, 5)
-    res2 sint32 <- rawAdd(4, 5)
+    //res2 sint32 <- rawAdd(4, 5)
 
     ret 0
 ;

src/Parser/Parsee/Parsee.cpp

@@ -13,6 +13,7 @@ Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldRetu
 Parsee Parsee::valueTypeParsee() {
     Parsee parsee;
     parsee.kind = ParseeKind::VALUE_TYPE;
+    parsee.shouldReturn = true;
 
     return parsee;
 }

src/Parser/Parsee/ParseeResult.cpp

@@ -7,13 +7,15 @@ 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) {
+ParseeResult ParseeResult::valueTypeResult(shared_ptr<ValueType> valueType, int tokensCount) {
     ParseeResult parseeResult;
     parseeResult.kind = ParseeResultKind::VALUE_TYPE;
     parseeResult.valueType = valueType;
+    parseeResult.tokensCount = tokensCount;
     return parseeResult;    
 }
 
@@ -30,4 +32,8 @@ shared_ptr<Token> ParseeResult::getToken() {
 
 shared_ptr<ValueType> ParseeResult::getValueType() {
     return valueType;
+}
+
+int ParseeResult::getTokensCount() {
+    return tokensCount;
 }

src/Parser/Parsee/ParseeResult.h

@@ -18,15 +18,17 @@ private:
     ParseeResultKind kind;
     shared_ptr<Token> token;
     shared_ptr<ValueType> valueType;
+    int tokensCount;
     ParseeResult();
 
 public:
     static ParseeResult tokenResult(shared_ptr<Token> token);
-    static ParseeResult valueTypeResult(shared_ptr<ValueType> valueType);
+    static ParseeResult valueTypeResult(shared_ptr<ValueType> valueType, int tokensCount);
 
     ParseeResultKind getKind();
     shared_ptr<Token> getToken();
     shared_ptr<ValueType> getValueType();
+    int getTokensCount();
 };
 
 #endif

src/Parser/Parser.cpp

@@ -247,6 +247,7 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
     string constraints;
     vector<pair<string, shared_ptr<ValueType>>> arguments;
     shared_ptr<ValueType> returnType = ValueType::NONE;
+    string rawSource;
 
     // identifier
     parseeResults = parseeResultsForParseeGroup(
@@ -297,7 +298,7 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
                     Parsee::valueTypeParsee()
                 },
                 ParseeGroup(
-                    true,
+                    false,
                     {
                         Parsee::tokenParsee(TokenKind::COMMA, true, false),
                         Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
@@ -341,58 +342,6 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
         }
     }
 
-    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::RAW_FUNCTION}, true, false))
-        return nullptr;
-
-    string rawSource;
-
-    // name
-    name = tokens.at(currentIndex++)->getLexme();
-    currentIndex++; // skip raw
-
-    // constraints
-
-    if (tryMatchingTokenKinds({TokenKind::LESS}, true, true)) {
-        if (tokens.at(currentIndex)->isOfKind({TokenKind::STRING})) {
-            constraints = tokens.at(currentIndex++)->getLexme();
-            // remove enclosing quotes
-            if (constraints.length() >= 2)
-                constraints = constraints.substr(1, constraints.length() - 2);
-        }
-        if (!tryMatchingTokenKinds({TokenKind::GREATER}, true, true))
-            markError({TokenKind::GREATER}, {});
-    }
-
-    // arguments
-    if (tryMatchingTokenKinds({TokenKind::COLON}, true, true)) {
-        do {
-            tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
-            if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) {
-                markError({}, "Expected function argument");
-                return nullptr;
-            }
-            shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
-            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
-    if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
-        tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
-
-        returnType = matchValueType();
-        if (returnType == nullptr) {
-            markError(TokenKind::TYPE, {});
-            return nullptr;
-        }
-    }
-
     // consume new line
     if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
         markError(TokenKind::NEW_LINE, {});
@@ -879,43 +828,103 @@ shared_ptr<ValueType> Parser::matchValueType() {
 }
 
 optional<vector<ParseeResult>> Parser::parseeResultsForParseeGroup(ParseeGroup group) {
-    int nextIndex = currentIndex;
+    int startIndex = currentIndex;
     vector<ParseeResult> results;
     bool mustFulfill = false;
 
     for (Parsee &parsee : group.getParsees()) {
-        shared_ptr<Token> currentToken = tokens.at(nextIndex);
+        optional<ParseeResult> result;
-        bool matches = currentToken->isOfKind({parsee.getTokenKind()});
+        switch (parsee.getKind()) {
+        case ParseeKind::TOKEN:
+            result = tokenParseeResult(currentIndex, parsee.getTokenKind());
+            break;
+        case ParseeKind::VALUE_TYPE:
+            result = valueTypeParseeResult(currentIndex);
+            break;
+        }
 
         // if doesn't match on optional group
-        if (!matches && parsee.getIsRequired() && !group.getIsRequired() && mustFulfill)
+        if (!result && parsee.getIsRequired() && !group.getIsRequired() && !mustFulfill) {
+            currentIndex = startIndex;
             return vector<ParseeResult>();
+        }
 
         // return matching token?
-        if (matches && parsee.getShouldReturn())
+        if (result && parsee.getShouldReturn())
-            results.push_back(ParseeResult::tokenResult(currentToken));
+            results.push_back(*result);
 
         // decide if we're decoding the expected sequence
-        if (!parsee.getIsRequired() && nextIndex > currentIndex)
+        if (!parsee.getIsRequired() && currentIndex > startIndex)
             mustFulfill = true;
 
         // invalid sequence detected?
-        if (!matches && parsee.getIsRequired() && mustFulfill) {
+        if (!result && parsee.getIsRequired() && mustFulfill) {
-            currentIndex = nextIndex;
             markError(parsee.getTokenKind(), {});
             return {};
         }
 
         // got to the next token if we got a match
-        if (matches)
+        if (result)
-            nextIndex++;
+            currentIndex += (*result).getTokensCount();
     }
 
-    currentIndex = nextIndex;
+    if (group.getRepeatedGroup()) {
+        bool hasSubResults = false;
+
+        optional<vector<ParseeResult>> subResults;
+        do {
+            subResults = parseeResultsForParseeGroup(*group.getRepeatedGroup());
+            if (!subResults)
+                return {};
+
+            for (ParseeResult &subResult : *subResults)
+                results.push_back(subResult);
+        } while (!(*subResults).empty());
+    }
 
     return 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();
+
+
+        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 {};
+        }
+
+        if (!tokens.at(index)->isOfKind({TokenKind::GREATER}))
+            return {};
+    }
+
+    shared_ptr<ValueType> valueType = ValueType::valueTypeForToken(typeToken, subType, 0);
+    return ParseeResult::valueTypeResult(valueType, index - startIndex);
+}
+
 bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) {
     int requiredCount = shouldMatchAll ? kinds.size() : 1;
     if (currentIndex + requiredCount > tokens.size())

src/Parser/Parser.h

@@ -56,6 +56,8 @@ private:
     shared_ptr<ValueType> matchValueType();
 
     optional<vector<ParseeResult>> parseeResultsForParseeGroup(ParseeGroup group);
+    optional<ParseeResult> tokenParseeResult(int index, TokenKind tokenKind);
+    optional<ParseeResult> valueTypeParseeResult(int index);
     bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
 
     void markError(optional<TokenKind> expectedTokenKind, optional<string> message);