From dc6668459f0bc42e940b51fa6d1a2eb876ac120a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 15 Jul 2025 18:50:15 +0900 Subject: [PATCH 01/13] Added parsee and parsee group --- src/Parser/Parsee.cpp | 39 +++++++++++++++++++++++++++++++++ src/Parser/Parsee.h | 37 +++++++++++++++++++++++++++++++ src/Parser/Parser.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++ src/Parser/Parser.h | 3 +++ 4 files changed, 130 insertions(+) create mode 100644 src/Parser/Parsee.cpp create mode 100644 src/Parser/Parsee.h diff --git a/src/Parser/Parsee.cpp b/src/Parser/Parsee.cpp new file mode 100644 index 0000000..735be13 --- /dev/null +++ b/src/Parser/Parsee.cpp @@ -0,0 +1,39 @@ +#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 tokens, optional repeatedGroup): +isRequired(isRequired), tokens(tokens) { + if (repeatedGroup) { + this->repeatedGroup = *repeatedGroup; + } else { + this->repeatedGroup = {}; + } + } + +bool ParseeTokensGroup::getIsRequired() { + return isRequired; +} + +vector ParseeTokensGroup::getTokens() { + return tokens; +} + +optional> ParseeTokensGroup::getRepeatedGroup() { + return repeatedGroup; +} \ No newline at end of file diff --git a/src/Parser/Parsee.h b/src/Parser/Parsee.h new file mode 100644 index 0000000..22c274e --- /dev/null +++ b/src/Parser/Parsee.h @@ -0,0 +1,37 @@ +#ifndef PARSEE_H +#define PARSEE_H + +#include +#include + +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 tokens; + optional> repeatedGroup; + +public: + ParseeTokensGroup(bool isRequired, vector tokens, optional repeatedGroup); + bool getIsRequired(); + vector getTokens(); + optional> getRepeatedGroup(); +}; + +#endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 9852fa2..f4f824c 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -25,6 +25,8 @@ #include "Parser/Statement/StatementBlock.h" #include "Parser/Statement/StatementRepeat.h" +#include "Parsee.h" + Parser::Parser(vector> tokens) : tokens(tokens) { } @@ -236,6 +238,55 @@ shared_ptr Parser::matchStatementFunction() { } shared_ptr Parser::matchStatementRawFunction() { + ParseeTokensGroup idGroup = ParseeTokensGroup( + true, + { + ParseeToken(TokenKind::IDENTIFIER, true, true), + ParseeToken(TokenKind::RAW_FUNCTION, true, false) + }, + {} + ); + + ParseeTokensGroup optionsGroup = ParseeTokensGroup( + false, + { + ParseeToken(TokenKind::LESS, true, false), + ParseeToken(TokenKind::STRING, true, true), + ParseeToken(TokenKind::GREATER, true, false) + }, + {} + ); + + ParseeTokensGroup argumentsGroup = ParseeTokensGroup( + false, + { + ParseeToken(TokenKind::COLON, true, false), + ParseeToken(TokenKind::NEW_LINE, false, false), + ParseeToken(TokenKind::IDENTIFIER, true, true), + ParseeToken(TokenKind::TYPE, true, true) + }, + ParseeTokensGroup( + true, + { + ParseeToken(TokenKind::COMMA, true, false), + ParseeToken(TokenKind::NEW_LINE, false, false), + ParseeToken(TokenKind::IDENTIFIER, true, true), + ParseeToken(TokenKind::TYPE, true, true) + }, + {} + ) + ); + + ParseeTokensGroup returnGroup = ParseeTokensGroup( + false, + { + ParseeToken(TokenKind::RIGHT_ARROW, true, false), + ParseeToken(TokenKind::NEW_LINE, false, false), + ParseeToken(TokenKind::TYPE, true, true) + }, + {} + ); + if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::RAW_FUNCTION}, true, false)) return nullptr; diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index fdfe4a2..026c609 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -12,6 +12,9 @@ class ValueType; class Expression; class Statement; +class ParseeToken; +class ParseeTokensGroup; + using namespace std; class Parser { From 1dc6010b9b2de9fd738f5f10c21b5d08f511787f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 15 Jul 2025 23:30:28 +0900 Subject: [PATCH 02/13] wip --- samples/test.brc | 6 +- src/Parser/Parser.cpp | 183 ++++++++++++++++++++++++++++++------------ src/Parser/Parser.h | 1 + 3 files changed, 136 insertions(+), 54 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 64e0a6e..78e2ede 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,4 +1,4 @@ -@extern putchar fun: character sint32 -> sint32 +//@extern putchar fun: character sint32 -> sint32 // ./build/brb samples/test.brc -S -x86-asm-syntax=intel @@ -24,9 +24,9 @@ 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 diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index f4f824c..9f37104 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -238,62 +238,105 @@ shared_ptr Parser::matchStatementFunction() { } shared_ptr Parser::matchStatementRawFunction() { - ParseeTokensGroup idGroup = ParseeTokensGroup( - true, - { - ParseeToken(TokenKind::IDENTIFIER, true, true), - ParseeToken(TokenKind::RAW_FUNCTION, true, false) - }, - {} - ); - - ParseeTokensGroup optionsGroup = ParseeTokensGroup( - false, - { - ParseeToken(TokenKind::LESS, true, false), - ParseeToken(TokenKind::STRING, true, true), - ParseeToken(TokenKind::GREATER, true, false) - }, - {} - ); - - ParseeTokensGroup argumentsGroup = ParseeTokensGroup( - false, - { - ParseeToken(TokenKind::COLON, true, false), - ParseeToken(TokenKind::NEW_LINE, false, false), - ParseeToken(TokenKind::IDENTIFIER, true, true), - ParseeToken(TokenKind::TYPE, true, true) - }, - ParseeTokensGroup( - true, - { - ParseeToken(TokenKind::COMMA, true, false), - ParseeToken(TokenKind::NEW_LINE, false, false), - ParseeToken(TokenKind::IDENTIFIER, true, true), - ParseeToken(TokenKind::TYPE, true, true) - }, - {} - ) - ); - - ParseeTokensGroup returnGroup = ParseeTokensGroup( - false, - { - ParseeToken(TokenKind::RIGHT_ARROW, true, false), - ParseeToken(TokenKind::NEW_LINE, false, false), - ParseeToken(TokenKind::TYPE, true, true) - }, - {} - ); - - if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::RAW_FUNCTION}, true, false)) - return nullptr; + bool hasError = false; + optional>> groupTokens; string name; string constraints; vector>> arguments; shared_ptr returnType = ValueType::NONE; + + // identifier + groupTokens = tokensForParseeTokensGroup( + ParseeTokensGroup( + true, + { + ParseeToken(TokenKind::IDENTIFIER, true, true), + ParseeToken(TokenKind::RAW_FUNCTION, true, false) + }, + {} + ) + ); + if (groupTokens) { + name = (*groupTokens).at(0)->getLexme(); + } else { + hasError = true; + } + + // options + if (!hasError) { + groupTokens = tokensForParseeTokensGroup( + ParseeTokensGroup( + false, + { + ParseeToken(TokenKind::LESS, true, false), + ParseeToken(TokenKind::STRING, true, true), + ParseeToken(TokenKind::GREATER, true, false) + }, + {} + ) + ); + if (groupTokens && !(*groupTokens).empty()) { + constraints = (*groupTokens).at(0)->getLexme(); + } else if (!groupTokens) { + hasError = true; + } + } + + // arguments + if (!hasError) { + groupTokens = tokensForParseeTokensGroup( + ParseeTokensGroup( + false, + { + ParseeToken(TokenKind::COLON, true, false), + ParseeToken(TokenKind::NEW_LINE, false, false), + ParseeToken(TokenKind::IDENTIFIER, true, true), + ParseeToken(TokenKind::TYPE, true, true) + }, + ParseeTokensGroup( + true, + { + ParseeToken(TokenKind::COMMA, true, false), + ParseeToken(TokenKind::NEW_LINE, false, false), + ParseeToken(TokenKind::IDENTIFIER, true, true), + ParseeToken(TokenKind::TYPE, true, true) + }, + {} + ) + ) + ); + if (groupTokens && !(*groupTokens).empty()) { + + } else if (!groupTokens) { + hasError = true; + } + } + + // return type + if (!hasError) { + groupTokens = tokensForParseeTokensGroup( + ParseeTokensGroup( + false, + { + ParseeToken(TokenKind::RIGHT_ARROW, true, false), + ParseeToken(TokenKind::NEW_LINE, false, false), + ParseeToken(TokenKind::TYPE, true, true) + }, + {} + ) + ); + + if (groupTokens && !(*groupTokens).empty()) { + + } else if (!groupTokens) { + hasError = true; + } + } + + if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::RAW_FUNCTION}, true, false)) + return nullptr; + string rawSource; // name @@ -828,6 +871,44 @@ shared_ptr Parser::matchValueType() { return ValueType::valueTypeForToken(typeToken, subType, valueArg); } +optional>> Parser::tokensForParseeTokensGroup(ParseeTokensGroup group) { + int nextIndex = currentIndex; + vector> returnTokens; + bool mustFulfill = false; + + for (ParseeToken &parsee : group.getTokens()) { + shared_ptr currentToken = tokens.at(nextIndex); + bool matches = currentToken->isOfKind({parsee.getTokenKind()}); + + // if doesn't match on optional group + if (!matches && parsee.getIsRequired() && !group.getIsRequired() && mustFulfill) + return vector>(); + + // return matching token? + if (matches && parsee.getShouldReturn()) + returnTokens.push_back(currentToken); + + // decide if we're decoding the expected sequence + if (!parsee.getIsRequired() && nextIndex > currentIndex) + mustFulfill = true; + + // invalid sequence detected? + if (!matches && parsee.getIsRequired() && mustFulfill) { + currentIndex = nextIndex; + markError(parsee.getTokenKind(), {}); + return {}; + } + + // got to the next token if we got a match + if (matches) + nextIndex++; + } + + currentIndex = nextIndex; + + return returnTokens; +} + bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance) { int requiredCount = shouldMatchAll ? kinds.size() : 1; if (currentIndex + requiredCount > tokens.size()) diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 026c609..3e325e6 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -55,6 +55,7 @@ private: shared_ptr matchValueType(); + optional>> tokensForParseeTokensGroup(ParseeTokensGroup group); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 502e4d2f6f5fcd7625102eaa31b3599986f87c37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 17 Jul 2025 16:00:12 +0900 Subject: [PATCH 03/13] added parsee and parsee group --- src/Parser/Parsee.cpp | 39 --------------------- src/Parser/Parsee.h | 37 -------------------- src/Parser/Parsee/Parsee.cpp | 36 +++++++++++++++++++ src/Parser/Parsee/Parsee.h | 31 +++++++++++++++++ src/Parser/Parsee/ParseeGroup.cpp | 24 +++++++++++++ src/Parser/Parsee/ParseeGroup.h | 24 +++++++++++++ src/Parser/Parser.cpp | 57 ++++++++++++++++--------------- src/Parser/Parser.h | 5 ++- 8 files changed, 146 insertions(+), 107 deletions(-) delete mode 100644 src/Parser/Parsee.cpp delete mode 100644 src/Parser/Parsee.h create mode 100644 src/Parser/Parsee/Parsee.cpp create mode 100644 src/Parser/Parsee/Parsee.h create mode 100644 src/Parser/Parsee/ParseeGroup.cpp create mode 100644 src/Parser/Parsee/ParseeGroup.h diff --git a/src/Parser/Parsee.cpp b/src/Parser/Parsee.cpp deleted file mode 100644 index 735be13..0000000 --- a/src/Parser/Parsee.cpp +++ /dev/null @@ -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 tokens, optional repeatedGroup): -isRequired(isRequired), tokens(tokens) { - if (repeatedGroup) { - this->repeatedGroup = *repeatedGroup; - } else { - this->repeatedGroup = {}; - } - } - -bool ParseeTokensGroup::getIsRequired() { - return isRequired; -} - -vector ParseeTokensGroup::getTokens() { - return tokens; -} - -optional> ParseeTokensGroup::getRepeatedGroup() { - return repeatedGroup; -} \ No newline at end of file diff --git a/src/Parser/Parsee.h b/src/Parser/Parsee.h deleted file mode 100644 index 22c274e..0000000 --- a/src/Parser/Parsee.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef PARSEE_H -#define PARSEE_H - -#include -#include - -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 tokens; - optional> repeatedGroup; - -public: - ParseeTokensGroup(bool isRequired, vector tokens, optional repeatedGroup); - bool getIsRequired(); - vector getTokens(); - optional> getRepeatedGroup(); -}; - -#endif \ No newline at end of file diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp new file mode 100644 index 0000000..945494e --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/src/Parser/Parsee/Parsee.h b/src/Parser/Parsee/Parsee.h new file mode 100644 index 0000000..649b50a --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeGroup.cpp b/src/Parser/Parsee/ParseeGroup.cpp new file mode 100644 index 0000000..debd442 --- /dev/null +++ b/src/Parser/Parsee/ParseeGroup.cpp @@ -0,0 +1,24 @@ +#include "ParseeGroup.h" + +#include "Parsee.h" + +ParseeGroup::ParseeGroup(bool isRequired, vector parsees, optional repeatedGroup): +isRequired(isRequired), parsees(parsees) { + if (repeatedGroup) { + this->repeatedGroup = *repeatedGroup; + } else { + this->repeatedGroup = {}; + } + } + +bool ParseeGroup::getIsRequired() { + return isRequired; +} + +vector ParseeGroup::getParsees() { + return parsees; +} + +optional> ParseeGroup::getRepeatedGroup() { + return repeatedGroup; +} \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeGroup.h b/src/Parser/Parsee/ParseeGroup.h new file mode 100644 index 0000000..0dfb4f8 --- /dev/null +++ b/src/Parser/Parsee/ParseeGroup.h @@ -0,0 +1,24 @@ +#ifndef PARSEE_GROUP_H +#define PARSEE_GROUP_H + +#include +#include + +class Parsee; + +using namespace std; + +class ParseeGroup { +private: + bool isRequired; + vector parsees; + optional> repeatedGroup; + +public: + ParseeGroup(bool isRequired, vector parsees, optional repeatedGroup); + bool getIsRequired(); + vector getParsees(); + optional> getRepeatedGroup(); +}; + +#endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 9f37104..20fc531 100644 --- a/src/Parser/Parser.cpp +++ b/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> tokens) : tokens(tokens) { } @@ -247,12 +248,12 @@ shared_ptr Parser::matchStatementRawFunction() { shared_ptr returnType = ValueType::NONE; // identifier - groupTokens = tokensForParseeTokensGroup( - ParseeTokensGroup( + groupTokens = tokensForParseeGroup( + ParseeGroup( true, { - ParseeToken(TokenKind::IDENTIFIER, true, true), - ParseeToken(TokenKind::RAW_FUNCTION, true, false) + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false) }, {} ) @@ -265,13 +266,13 @@ shared_ptr Parser::matchStatementRawFunction() { // options if (!hasError) { - groupTokens = tokensForParseeTokensGroup( - ParseeTokensGroup( + groupTokens = tokensForParseeGroup( + ParseeGroup( false, { - ParseeToken(TokenKind::LESS, true, false), - ParseeToken(TokenKind::STRING, true, true), - ParseeToken(TokenKind::GREATER, true, false) + Parsee::tokenParsee(TokenKind::LESS, true, false), + Parsee::tokenParsee(TokenKind::STRING, true, true), + Parsee::tokenParsee(TokenKind::GREATER, true, false) }, {} ) @@ -285,22 +286,22 @@ shared_ptr Parser::matchStatementRawFunction() { // arguments if (!hasError) { - groupTokens = tokensForParseeTokensGroup( - ParseeTokensGroup( + groupTokens = tokensForParseeGroup( + ParseeGroup( false, { - ParseeToken(TokenKind::COLON, true, false), - ParseeToken(TokenKind::NEW_LINE, false, false), - ParseeToken(TokenKind::IDENTIFIER, true, true), - ParseeToken(TokenKind::TYPE, true, true) + Parsee::tokenParsee(TokenKind::COLON, true, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::typeParsee() }, - ParseeTokensGroup( + ParseeGroup( true, { - ParseeToken(TokenKind::COMMA, true, false), - ParseeToken(TokenKind::NEW_LINE, false, false), - ParseeToken(TokenKind::IDENTIFIER, true, true), - ParseeToken(TokenKind::TYPE, true, true) + Parsee::tokenParsee(TokenKind::COMMA, true, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::typeParsee() }, {} ) @@ -315,13 +316,13 @@ shared_ptr Parser::matchStatementRawFunction() { // return type if (!hasError) { - groupTokens = tokensForParseeTokensGroup( - ParseeTokensGroup( + groupTokens = tokensForParseeGroup( + ParseeGroup( false, { - ParseeToken(TokenKind::RIGHT_ARROW, true, false), - ParseeToken(TokenKind::NEW_LINE, false, false), - ParseeToken(TokenKind::TYPE, true, true) + Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), + Parsee::typeParsee() }, {} ) @@ -871,12 +872,12 @@ shared_ptr Parser::matchValueType() { return ValueType::valueTypeForToken(typeToken, subType, valueArg); } -optional>> Parser::tokensForParseeTokensGroup(ParseeTokensGroup group) { +optional>> Parser::tokensForParseeGroup(ParseeGroup group) { int nextIndex = currentIndex; vector> returnTokens; bool mustFulfill = false; - for (ParseeToken &parsee : group.getTokens()) { + for (Parsee &parsee : group.getParsees()) { shared_ptr currentToken = tokens.at(nextIndex); bool matches = currentToken->isOfKind({parsee.getTokenKind()}); diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 3e325e6..cbac15e 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -12,8 +12,7 @@ class ValueType; class Expression; class Statement; -class ParseeToken; -class ParseeTokensGroup; +class ParseeGroup; using namespace std; @@ -55,7 +54,7 @@ private: shared_ptr matchValueType(); - optional>> tokensForParseeTokensGroup(ParseeTokensGroup group); + optional>> tokensForParseeGroup(ParseeGroup group); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 8a708d8936c2aa86a335b99ba5d6c69f438b62ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 17 Jul 2025 17:14:19 +0900 Subject: [PATCH 04/13] Use parsee results --- src/Parser/Parsee/Parsee.cpp | 6 ++-- src/Parser/Parsee/Parsee.h | 6 ++-- src/Parser/Parsee/ParseeResult.cpp | 33 ++++++++++++++++++ src/Parser/Parsee/ParseeResult.h | 32 ++++++++++++++++++ src/Parser/Parser.cpp | 54 +++++++++++++++++------------- src/Parser/Parser.h | 3 +- 6 files changed, 102 insertions(+), 32 deletions(-) create mode 100644 src/Parser/Parsee/ParseeResult.cpp create mode 100644 src/Parser/Parsee/ParseeResult.h diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index 945494e..227b23e 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/src/Parser/Parsee/Parsee.cpp @@ -10,9 +10,9 @@ Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldRetu return parsee; } -Parsee Parsee::typeParsee() { - Parsee parsee; - parsee.kind = ParseeKind::TYPE; +Parsee Parsee::valueTypeParsee() { + Parsee parsee; + parsee.kind = ParseeKind::VALUE_TYPE; return parsee; } diff --git a/src/Parser/Parsee/Parsee.h b/src/Parser/Parsee/Parsee.h index 649b50a..dc7cfd4 100644 --- a/src/Parser/Parsee/Parsee.h +++ b/src/Parser/Parsee/Parsee.h @@ -5,7 +5,7 @@ enum class TokenKind; enum class ParseeKind { TOKEN, - TYPE + VALUE_TYPE }; class Parsee { @@ -14,15 +14,13 @@ private: TokenKind tokenKind; bool isRequired; bool shouldReturn; - Parsee(); public: static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn); - static Parsee typeParsee(); + static Parsee valueTypeParsee(); ParseeKind getKind(); - TokenKind getTokenKind(); bool getIsRequired(); bool getShouldReturn(); diff --git a/src/Parser/Parsee/ParseeResult.cpp b/src/Parser/Parsee/ParseeResult.cpp new file mode 100644 index 0000000..66dc619 --- /dev/null +++ b/src/Parser/Parsee/ParseeResult.cpp @@ -0,0 +1,33 @@ +#include "ParseeResult.h" + +#include "Lexer/Token.h" +#include "Parser/ValueType.h" + +ParseeResult ParseeResult::tokenResult(shared_ptr token) { + ParseeResult parseeResult; + parseeResult.kind = ParseeResultKind::TOKEN; + parseeResult.token = token; + return parseeResult; +} + +ParseeResult ParseeResult::valueTypeResult(shared_ptr valueType) { + ParseeResult parseeResult; + parseeResult.kind = ParseeResultKind::VALUE_TYPE; + parseeResult.valueType = valueType; + return parseeResult; +} + +ParseeResult::ParseeResult() { } + + +ParseeResultKind ParseeResult::getKind() { + return kind; +} + +shared_ptr ParseeResult::getToken() { + return token; +} + +shared_ptr ParseeResult::getValueType() { + return valueType; +} \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeResult.h b/src/Parser/Parsee/ParseeResult.h new file mode 100644 index 0000000..a909152 --- /dev/null +++ b/src/Parser/Parsee/ParseeResult.h @@ -0,0 +1,32 @@ +#ifndef PARSEE_RESULT_H +#define PARSEE_RESULT_H + +#include + +class Token; +class ValueType; + +using namespace std; + +enum class ParseeResultKind { + TOKEN, + VALUE_TYPE, +}; + +class ParseeResult { +private: + ParseeResultKind kind; + shared_ptr token; + shared_ptr valueType; + ParseeResult(); + +public: + static ParseeResult tokenResult(shared_ptr token); + static ParseeResult valueTypeResult(shared_ptr valueType); + + ParseeResultKind getKind(); + shared_ptr getToken(); + shared_ptr getValueType(); +}; + +#endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 20fc531..cd0d81e 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -27,6 +27,7 @@ #include "Parsee/Parsee.h" #include "Parsee/ParseeGroup.h" +#include "Parsee/ParseeResult.h" Parser::Parser(vector> tokens) : tokens(tokens) { } @@ -240,7 +241,7 @@ shared_ptr Parser::matchStatementFunction() { shared_ptr Parser::matchStatementRawFunction() { bool hasError = false; - optional>> groupTokens; + optional> parseeResults; string name; string constraints; @@ -248,7 +249,7 @@ shared_ptr Parser::matchStatementRawFunction() { shared_ptr returnType = ValueType::NONE; // identifier - groupTokens = tokensForParseeGroup( + parseeResults = parseeResultsForParseeGroup( ParseeGroup( true, { @@ -258,15 +259,15 @@ shared_ptr Parser::matchStatementRawFunction() { {} ) ); - if (groupTokens) { - name = (*groupTokens).at(0)->getLexme(); + if (parseeResults) { + name = (*parseeResults).at(0).getToken()->getLexme(); } else { hasError = true; } // options if (!hasError) { - groupTokens = tokensForParseeGroup( + parseeResults = parseeResultsForParseeGroup( ParseeGroup( false, { @@ -277,23 +278,23 @@ shared_ptr Parser::matchStatementRawFunction() { {} ) ); - if (groupTokens && !(*groupTokens).empty()) { - constraints = (*groupTokens).at(0)->getLexme(); - } else if (!groupTokens) { + if (parseeResults && !(*parseeResults).empty()) { + constraints = (*parseeResults).at(0).getToken()->getLexme(); + } else if (!parseeResults) { hasError = true; } } // arguments if (!hasError) { - groupTokens = tokensForParseeGroup( + parseeResults = parseeResultsForParseeGroup( ParseeGroup( false, { Parsee::tokenParsee(TokenKind::COLON, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::typeParsee() + Parsee::valueTypeParsee() }, ParseeGroup( true, @@ -301,36 +302,41 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::tokenParsee(TokenKind::COMMA, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::typeParsee() + Parsee::valueTypeParsee() }, {} ) ) ); - if (groupTokens && !(*groupTokens).empty()) { - - } else if (!groupTokens) { + if (parseeResults && !(*parseeResults).empty()) { + for (int i=0; i<(*parseeResults).size(); i+=2) { + pair> arg; + arg.first = (*parseeResults).at(i).getToken()->getLexme(); + arg.second = (*parseeResults).at(i+1).getValueType(); + arguments.push_back(arg); + } + } else if (!parseeResults) { hasError = true; } } // return type if (!hasError) { - groupTokens = tokensForParseeGroup( + parseeResults = parseeResultsForParseeGroup( ParseeGroup( false, { Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::typeParsee() + Parsee::valueTypeParsee() }, {} ) ); - if (groupTokens && !(*groupTokens).empty()) { - - } else if (!groupTokens) { + if (parseeResults && !(*parseeResults).empty()) { + returnType = (*parseeResults).at(0).getValueType(); + } else if (!parseeResults) { hasError = true; } } @@ -872,9 +878,9 @@ shared_ptr Parser::matchValueType() { return ValueType::valueTypeForToken(typeToken, subType, valueArg); } -optional>> Parser::tokensForParseeGroup(ParseeGroup group) { +optional> Parser::parseeResultsForParseeGroup(ParseeGroup group) { int nextIndex = currentIndex; - vector> returnTokens; + vector results; bool mustFulfill = false; for (Parsee &parsee : group.getParsees()) { @@ -883,11 +889,11 @@ optional>> Parser::tokensForParseeGroup(ParseeGroup gro // if doesn't match on optional group if (!matches && parsee.getIsRequired() && !group.getIsRequired() && mustFulfill) - return vector>(); + return vector(); // return matching token? if (matches && parsee.getShouldReturn()) - returnTokens.push_back(currentToken); + results.push_back(ParseeResult::tokenResult(currentToken)); // decide if we're decoding the expected sequence if (!parsee.getIsRequired() && nextIndex > currentIndex) @@ -907,7 +913,7 @@ optional>> Parser::tokensForParseeGroup(ParseeGroup gro currentIndex = nextIndex; - return returnTokens; + return results; } bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance) { diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index cbac15e..db079d4 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -13,6 +13,7 @@ class Expression; class Statement; class ParseeGroup; +class ParseeResult; using namespace std; @@ -54,7 +55,7 @@ private: shared_ptr matchValueType(); - optional>> tokensForParseeGroup(ParseeGroup group); + optional> parseeResultsForParseeGroup(ParseeGroup group); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 3041c4383b74970c5edd91f2f090d9e292d75754 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 22 Jul 2025 15:03:34 +0900 Subject: [PATCH 05/13] Single parsing logic --- samples/test.brc | 11 ++- src/Parser/Parsee/Parsee.cpp | 1 + src/Parser/Parsee/ParseeResult.cpp | 8 +- src/Parser/Parsee/ParseeResult.h | 4 +- src/Parser/Parser.cpp | 139 +++++++++++++++-------------- src/Parser/Parser.h | 2 + 6 files changed, 95 insertions(+), 70 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 78e2ede..9fabe98 100644 --- a/samples/test.brc +++ b/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) - res2 sint32 <- rawAdd(4, 5) + //res1 sint32 <- normAdd(4, 5) + //res2 sint32 <- rawAdd(4, 5) ret 0 ; \ No newline at end of file diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index 227b23e..292e997 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/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; } diff --git a/src/Parser/Parsee/ParseeResult.cpp b/src/Parser/Parsee/ParseeResult.cpp index 66dc619..ce00984 100644 --- a/src/Parser/Parsee/ParseeResult.cpp +++ b/src/Parser/Parsee/ParseeResult.cpp @@ -7,13 +7,15 @@ ParseeResult ParseeResult::tokenResult(shared_ptr token) { ParseeResult parseeResult; parseeResult.kind = ParseeResultKind::TOKEN; parseeResult.token = token; + parseeResult.tokensCount = 1; return parseeResult; } -ParseeResult ParseeResult::valueTypeResult(shared_ptr valueType) { +ParseeResult ParseeResult::valueTypeResult(shared_ptr valueType, int tokensCount) { ParseeResult parseeResult; parseeResult.kind = ParseeResultKind::VALUE_TYPE; parseeResult.valueType = valueType; + parseeResult.tokensCount = tokensCount; return parseeResult; } @@ -30,4 +32,8 @@ shared_ptr ParseeResult::getToken() { shared_ptr ParseeResult::getValueType() { return valueType; +} + +int ParseeResult::getTokensCount() { + return tokensCount; } \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeResult.h b/src/Parser/Parsee/ParseeResult.h index a909152..fb56d45 100644 --- a/src/Parser/Parsee/ParseeResult.h +++ b/src/Parser/Parsee/ParseeResult.h @@ -18,15 +18,17 @@ private: ParseeResultKind kind; shared_ptr token; shared_ptr valueType; + int tokensCount; ParseeResult(); public: static ParseeResult tokenResult(shared_ptr token); - static ParseeResult valueTypeResult(shared_ptr valueType); + static ParseeResult valueTypeResult(shared_ptr valueType, int tokensCount); ParseeResultKind getKind(); shared_ptr getToken(); shared_ptr getValueType(); + int getTokensCount(); }; #endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index cd0d81e..5550800 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -247,6 +247,7 @@ shared_ptr Parser::matchStatementRawFunction() { string constraints; vector>> arguments; shared_ptr returnType = ValueType::NONE; + string rawSource; // identifier parseeResults = parseeResultsForParseeGroup( @@ -297,7 +298,7 @@ shared_ptr 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 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 identifierToken = tokens.at(currentIndex++); - shared_ptr argumentType = matchValueType(); - if (argumentType == nullptr) { - markError(TokenKind::TYPE, {}); - return nullptr; - } - - arguments.push_back(pair>(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 Parser::matchValueType() { } optional> Parser::parseeResultsForParseeGroup(ParseeGroup group) { - int nextIndex = currentIndex; + int startIndex = currentIndex; vector results; bool mustFulfill = false; for (Parsee &parsee : group.getParsees()) { - shared_ptr currentToken = tokens.at(nextIndex); - bool matches = currentToken->isOfKind({parsee.getTokenKind()}); + optional result; + 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(); + } // return matching token? - if (matches && parsee.getShouldReturn()) - results.push_back(ParseeResult::tokenResult(currentToken)); + if (result && parsee.getShouldReturn()) + 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) { - currentIndex = nextIndex; + if (!result && parsee.getIsRequired() && mustFulfill) { markError(parsee.getTokenKind(), {}); return {}; } // got to the next token if we got a match - if (matches) - nextIndex++; + if (result) + currentIndex += (*result).getTokensCount(); } - currentIndex = nextIndex; + if (group.getRepeatedGroup()) { + bool hasSubResults = false; + + optional> subResults; + do { + subResults = parseeResultsForParseeGroup(*group.getRepeatedGroup()); + if (!subResults) + return {}; + + for (ParseeResult &subResult : *subResults) + results.push_back(subResult); + } while (!(*subResults).empty()); + } return results; } +optional Parser::tokenParseeResult(int index, TokenKind tokenKind) { + shared_ptr token = tokens.at(index); + if (token->isOfKind({tokenKind})) + return ParseeResult::tokenResult(token); + return {}; +} + +optional Parser::valueTypeParseeResult(int index) { + int startIndex = index; + + if (!tokens.at(index)->isOfKind({TokenKind::TYPE})) + return {}; + + shared_ptr typeToken = tokens.at(index++); + shared_ptr subType; + int typeArg = 0; + + if (tokens.at(index)->isOfKind({TokenKind::LESS})) { + index++; + optional 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::valueTypeForToken(typeToken, subType, 0); + return ParseeResult::valueTypeResult(valueType, index - startIndex); +} + bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance) { int requiredCount = shouldMatchAll ? kinds.size() : 1; if (currentIndex + requiredCount > tokens.size()) diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index db079d4..a3c35ef 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -56,6 +56,8 @@ private: shared_ptr matchValueType(); optional> parseeResultsForParseeGroup(ParseeGroup group); + optional tokenParseeResult(int index, TokenKind tokenKind); + optional valueTypeParseeResult(int index); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 68018e71067a4e2d7b76d9edd2c86a8eb5893e9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Wed, 30 Jul 2025 21:52:22 +0900 Subject: [PATCH 06/13] wip --- samples/test.brc | 6 +- src/Parser/Parsee/Parsee.cpp | 13 +- src/Parser/Parsee/Parsee.h | 9 +- src/Parser/Parsee/ParseeGroup.cpp | 8 +- src/Parser/Parsee/ParseeGroup.h | 6 +- src/Parser/Parsee/ParseeResult.cpp | 12 ++ src/Parser/Parsee/ParseeResult.h | 5 + src/Parser/Parsee/ParseeResultsGroup.cpp | 30 ++++ src/Parser/Parsee/ParseeResultsGroup.h | 30 ++++ src/Parser/Parser.cpp | 183 ++++++++++++++++++++--- src/Parser/Parser.h | 5 +- 11 files changed, 269 insertions(+), 38 deletions(-) create mode 100644 src/Parser/Parsee/ParseeResultsGroup.cpp create mode 100644 src/Parser/Parsee/ParseeResultsGroup.h diff --git a/samples/test.brc b/samples/test.brc index 9fabe98..1862622 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -33,10 +33,10 @@ i u32 <- 0, rep text[i] != 0: mov $0, $1 ;*/ -rawAdd raw: num1 sint32, num2 sint32 -> sint32 +/*rawAdd raw: num1 sint32, num2 sint32 -> sint32 add $1, $2 mov $0, $1 -; +;*/ /*printChar raw .global REGISTER @@ -54,5 +54,5 @@ main fun -> sint32 //res1 sint32 <- normAdd(4, 5) //res2 sint32 <- rawAdd(4, 5) - ret 0 + ret 2- ; \ No newline at end of file diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index 292e997..dc8c526 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/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; } diff --git a/src/Parser/Parsee/Parsee.h b/src/Parser/Parsee/Parsee.h index dc7cfd4..9b1db48 100644 --- a/src/Parser/Parsee/Parsee.h +++ b/src/Parser/Parsee/Parsee.h @@ -1,11 +1,15 @@ #ifndef PARSEE_H #define PARSEE_H +#include + 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(); diff --git a/src/Parser/Parsee/ParseeGroup.cpp b/src/Parser/Parsee/ParseeGroup.cpp index debd442..81e7b81 100644 --- a/src/Parser/Parsee/ParseeGroup.cpp +++ b/src/Parser/Parsee/ParseeGroup.cpp @@ -2,8 +2,8 @@ #include "Parsee.h" -ParseeGroup::ParseeGroup(bool isRequired, vector parsees, optional repeatedGroup): -isRequired(isRequired), parsees(parsees) { +ParseeGroup::ParseeGroup(/*bool isRequired, */vector parsees, optional 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 ParseeGroup::getParsees() { return parsees; diff --git a/src/Parser/Parsee/ParseeGroup.h b/src/Parser/Parsee/ParseeGroup.h index 0dfb4f8..62d2570 100644 --- a/src/Parser/Parsee/ParseeGroup.h +++ b/src/Parser/Parsee/ParseeGroup.h @@ -10,13 +10,13 @@ using namespace std; class ParseeGroup { private: - bool isRequired; + //bool isRequired; vector parsees; optional> repeatedGroup; public: - ParseeGroup(bool isRequired, vector parsees, optional repeatedGroup); - bool getIsRequired(); + ParseeGroup(/*bool isRequired, */vector parsees, optional repeatedGroup); + //bool getIsRequired(); vector getParsees(); optional> getRepeatedGroup(); }; diff --git a/src/Parser/Parsee/ParseeResult.cpp b/src/Parser/Parsee/ParseeResult.cpp index ce00984..5e09309 100644 --- a/src/Parser/Parsee/ParseeResult.cpp +++ b/src/Parser/Parsee/ParseeResult.cpp @@ -19,6 +19,14 @@ ParseeResult ParseeResult::valueTypeResult(shared_ptr valueType, int return parseeResult; } +ParseeResult ParseeResult::expressionResult(shared_ptr 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 ParseeResult::getValueType() { return valueType; } +shared_ptr ParseeResult::getExpression() { + return expression; +} + int ParseeResult::getTokensCount() { return tokensCount; } \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeResult.h b/src/Parser/Parsee/ParseeResult.h index fb56d45..f59114e 100644 --- a/src/Parser/Parsee/ParseeResult.h +++ b/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; shared_ptr valueType; + shared_ptr expression; int tokensCount; ParseeResult(); public: static ParseeResult tokenResult(shared_ptr token); static ParseeResult valueTypeResult(shared_ptr valueType, int tokensCount); + static ParseeResult expressionResult(shared_ptr expression, int tokensCount); ParseeResultKind getKind(); shared_ptr getToken(); shared_ptr getValueType(); + shared_ptr getExpression(); int getTokensCount(); }; diff --git a/src/Parser/Parsee/ParseeResultsGroup.cpp b/src/Parser/Parsee/ParseeResultsGroup.cpp new file mode 100644 index 0000000..ca3cc9c --- /dev/null +++ b/src/Parser/Parsee/ParseeResultsGroup.cpp @@ -0,0 +1,30 @@ +#include "ParseeResultsGroup.h" + +#include "ParseeResult.h" + +ParseeResultsGroup ParseeResultsGroup::success(vector 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 ParseeResultsGroup::getResults() { + return results; +} \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeResultsGroup.h b/src/Parser/Parsee/ParseeResultsGroup.h new file mode 100644 index 0000000..3ba23b4 --- /dev/null +++ b/src/Parser/Parsee/ParseeResultsGroup.h @@ -0,0 +1,30 @@ +#ifndef PARSEE_RESULTS_GROUP_H +#define PARSEE_RESULTS_GROUP_H + +#include + +class ParseeResult; + +using namespace std; + +enum class ParseeResultsGroupKind { + SUCCESS, + NO_MATCH, + FAILURE +}; + +class ParseeResultsGroup { +private: + ParseeResultsGroupKind kind; + vector results; + +public: + static ParseeResultsGroup success(vector results); + static ParseeResultsGroup noMatch(); + static ParseeResultsGroup failure(); + + ParseeResultsGroupKind getKind(); + vector getResults(); +}; + +#endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 5550800..25f2204 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -28,6 +28,7 @@ #include "Parsee/Parsee.h" #include "Parsee/ParseeGroup.h" #include "Parsee/ParseeResult.h" +#include "Parsee/ParseeResultsGroup.h" Parser::Parser(vector> tokens) : tokens(tokens) { } @@ -158,7 +159,7 @@ shared_ptr Parser::matchStatementMetaExternFunction() { } shared_ptr Parser::matchStatementVariable() { - if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) + /*if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) return nullptr; shared_ptr identifierToken = tokens.at(currentIndex++); @@ -174,7 +175,43 @@ shared_ptr Parser::matchStatementVariable() { if (expression == nullptr) return nullptr; - return make_shared(identifierToken->getLexme(), valueType, expression); + return make_shared(identifierToken->getLexme(), valueType, expression);*/ + + 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; + + string name = resultsGroup.getResults().at(0).getToken()->getLexme();// tokens.at(currentIndex++); + shared_ptr valueType = resultsGroup.getResults().at(1).getValueType(); + shared_ptr expression = resultsGroup.getResults().at(2).getExpression(); + + return make_shared(name, valueType, expression); + + /*optional> parseeResults = parseeResultsForParseeGroup( + ParseeGroup( + false, + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::valueTypeParsee(), + Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), + Parsee::expressionParsee() + }, + { } + ) + ); + + optional> parseeResults = parseeResultsForParseeGroup(parseeGroup);*/ } shared_ptr Parser::matchStatementFunction() { @@ -227,7 +264,7 @@ shared_ptr Parser::matchStatementFunction() { } // block - statementBlock = matchStatementBlock({TokenKind::SEMICOLON}); + statementBlock = matchStatementBlock({TokenKind::SEMICOLON, TokenKind::END}); if (statementBlock == nullptr) return nullptr; @@ -240,7 +277,8 @@ shared_ptr Parser::matchStatementFunction() { } shared_ptr Parser::matchStatementRawFunction() { - bool hasError = false; + return nullptr; + /*bool hasError = false; optional> parseeResults; string name; @@ -295,7 +333,7 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::tokenParsee(TokenKind::COLON, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee() + Parsee::valueTypeParsee(true) }, ParseeGroup( false, @@ -303,7 +341,7 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::tokenParsee(TokenKind::COMMA, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee() + Parsee::valueTypeParsee(true) }, {} ) @@ -329,7 +367,7 @@ shared_ptr Parser::matchStatementRawFunction() { { Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::valueTypeParsee() + Parsee::valueTypeParsee(true) }, {} ) @@ -363,7 +401,7 @@ shared_ptr Parser::matchStatementRawFunction() { return nullptr; } - return make_shared(name, constraints, arguments, returnType, rawSource); + return make_shared(name, constraints, arguments, returnType, rawSource);*/ } shared_ptr Parser::matchStatementBlock(vector terminalTokenKinds) { @@ -418,13 +456,27 @@ shared_ptr Parser::matchStatementAssignment() { } shared_ptr Parser::matchStatementReturn() { - if (!tryMatchingTokenKinds({TokenKind::RETURN}, true, true)) - return nullptr; + shared_ptr expression; + + ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::RETURN, true, false), + Parsee::expressionParsee(false) + }, + { } + ) + ); + + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: + expression = !resultsGroup.getResults().empty() ? resultsGroup.getResults().at(0).getExpression() : nullptr; + break; + case ParseeResultsGroupKind::NO_MATCH: + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } - shared_ptr expression = nextExpression(); - if (expression == nullptr) - return nullptr; - return make_shared(expression); } @@ -521,7 +573,7 @@ shared_ptr Parser::nextExpression() { if (expression != nullptr || errors.size() > errorsCount) return expression; - markError({}, {}); + //markError({}, {}); return nullptr; } @@ -757,6 +809,7 @@ shared_ptr Parser::matchExpressionBinary(shared_ptr left } if (right == nullptr) { + markError({}, "Expected expression"); return nullptr; } else { return make_shared(token, left, right); @@ -827,7 +880,8 @@ shared_ptr Parser::matchValueType() { return ValueType::valueTypeForToken(typeToken, subType, valueArg); } -optional> Parser::parseeResultsForParseeGroup(ParseeGroup group) { +ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { + int errorsCount = errors.size(); int startIndex = currentIndex; vector results; bool mustFulfill = false; @@ -835,12 +889,83 @@ optional> Parser::parseeResultsForParseeGroup(ParseeGroup g for (Parsee &parsee : group.getParsees()) { optional result; switch (parsee.getKind()) { - case ParseeKind::TOKEN: - result = tokenParseeResult(currentIndex, parsee.getTokenKind()); - break; - case ParseeKind::VALUE_TYPE: - result = valueTypeParseeResult(currentIndex); - break; + case ParseeKind::TOKEN: + result = tokenParseeResult(currentIndex, parsee.getTokenKind()); + break; + case ParseeKind::VALUE_TYPE: + result = valueTypeParseeResult(currentIndex); + break; + case ParseeKind::EXPRESSION: + result = expressionParseeResult(currentIndex); + break; + } + + // generated an error? + if (errors.size() > errorsCount) + return ParseeResultsGroup::failure(); + + // if doesn't match on optional group + if (!result && parsee.getIsRequired() && !mustFulfill) { + currentIndex = startIndex; + //return vector(); + 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(); + } + + /*if (group.getRepeatedGroup()) { + bool hasSubResults = false; + + optional> subResults; + do { + subResults = parseeResultsForParseeGroup(*group.getRepeatedGroup()); + if (!subResults) + return ParseeResultsGroup::failure(); + //return {}; + + for (ParseeResult &subResult : *subResults) + results.push_back(subResult); + } while (!(*subResults).empty()); + }*/ + + return ParseeResultsGroup::success(results); +} + +/*optional> Parser::parseeResultsForParseeGroup(ParseeGroup group) { + int startIndex = currentIndex; + vector results; + bool mustFulfill = false; + + for (Parsee &parsee : group.getParsees()) { + optional result; + switch (parsee.getKind()) { + case ParseeKind::TOKEN: + result = tokenParseeResult(currentIndex, parsee.getTokenKind()); + break; + case ParseeKind::VALUE_TYPE: + result = valueTypeParseeResult(currentIndex); + break; + case ParseeKind::EXPRESSION: + result = expressionParseeResult(currentIndex); + break; } // if doesn't match on optional group @@ -883,7 +1008,7 @@ optional> Parser::parseeResultsForParseeGroup(ParseeGroup g } return results; -} +}*/ optional Parser::tokenParseeResult(int index, TokenKind tokenKind) { shared_ptr token = tokens.at(index); @@ -925,6 +1050,18 @@ optional Parser::valueTypeParseeResult(int index) { return ParseeResult::valueTypeResult(valueType, index - startIndex); } +optional Parser::expressionParseeResult(int index) { + int startIndex = currentIndex; + int errorsCount = errors.size(); + shared_ptr expression = nextExpression(); + if (errors.size() > errorsCount) + return {}; + + int tokensCount = currentIndex - startIndex; + currentIndex = startIndex; + return ParseeResult::expressionResult(expression, tokensCount); +} + bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance) { int requiredCount = shouldMatchAll ? kinds.size() : 1; if (currentIndex + requiredCount > tokens.size()) diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index a3c35ef..7e80f40 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -14,6 +14,7 @@ class Statement; class ParseeGroup; class ParseeResult; +class ParseeResultsGroup; using namespace std; @@ -55,9 +56,11 @@ private: shared_ptr matchValueType(); - optional> parseeResultsForParseeGroup(ParseeGroup group); + ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); + //optional> parseeResultsForParseeGroup(ParseeGroup group); optional tokenParseeResult(int index, TokenKind tokenKind); optional valueTypeParseeResult(int index); + optional expressionParseeResult(int index); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 953a8acb181e764fe32f71d4e6c362b3fa14e57e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Wed, 30 Jul 2025 23:41:28 +0900 Subject: [PATCH 07/13] Use new parser for function --- samples/test.brc | 6 +- src/Parser/Parsee/ParseeGroup.cpp | 8 +- src/Parser/Parsee/ParseeGroup.h | 4 +- src/Parser/Parser.cpp | 224 ++++++++++++------------------ src/Parser/Parser.h | 1 - 5 files changed, 96 insertions(+), 147 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 1862622..563c1bc 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -48,11 +48,11 @@ i u32 <- 0, rep text[i] != 0: ;*/ -main fun -> sint32 +main fun: a sint32, b sint32 -> sint32 //printChar() - //res1 sint32 <- normAdd(4, 5) + res1 sint32 <- a - b //res2 sint32 <- rawAdd(4, 5) - ret 2- + ret res1 ; \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeGroup.cpp b/src/Parser/Parsee/ParseeGroup.cpp index 81e7b81..ead5352 100644 --- a/src/Parser/Parsee/ParseeGroup.cpp +++ b/src/Parser/Parsee/ParseeGroup.cpp @@ -2,8 +2,8 @@ #include "Parsee.h" -ParseeGroup::ParseeGroup(/*bool isRequired, */vector parsees, optional repeatedGroup): -/*isRequired(isRequired), */parsees(parsees) { +ParseeGroup::ParseeGroup(vector parsees, optional repeatedGroup): +parsees(parsees) { if (repeatedGroup) { this->repeatedGroup = *repeatedGroup; } else { @@ -11,10 +11,6 @@ ParseeGroup::ParseeGroup(/*bool isRequired, */vector parsees, optional

ParseeGroup::getParsees() { return parsees; } diff --git a/src/Parser/Parsee/ParseeGroup.h b/src/Parser/Parsee/ParseeGroup.h index 62d2570..4e4cc82 100644 --- a/src/Parser/Parsee/ParseeGroup.h +++ b/src/Parser/Parsee/ParseeGroup.h @@ -10,13 +10,11 @@ using namespace std; class ParseeGroup { private: - //bool isRequired; vector parsees; optional> repeatedGroup; public: - ParseeGroup(/*bool isRequired, */vector parsees, optional repeatedGroup); - //bool getIsRequired(); + ParseeGroup(vector parsees, optional repeatedGroup); vector getParsees(); optional> getRepeatedGroup(); }; diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 25f2204..9aa2130 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -159,24 +159,6 @@ shared_ptr Parser::matchStatementMetaExternFunction() { } shared_ptr Parser::matchStatementVariable() { - /*if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) - return nullptr; - - shared_ptr identifierToken = tokens.at(currentIndex++); - shared_ptr valueType = matchValueType(); - - // Expect left arrow - if (!tryMatchingTokenKinds({TokenKind::LEFT_ARROW}, true, true)) { - markError(TokenKind::LEFT_ARROW, {}); - return nullptr; - } - - shared_ptr expression = nextExpression(); - if (expression == nullptr) - return nullptr; - - return make_shared(identifierToken->getLexme(), valueType, expression);*/ - ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { @@ -192,68 +174,105 @@ shared_ptr Parser::matchStatementVariable() { if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) return nullptr; - string name = resultsGroup.getResults().at(0).getToken()->getLexme();// tokens.at(currentIndex++); + string name = resultsGroup.getResults().at(0).getToken()->getLexme(); shared_ptr valueType = resultsGroup.getResults().at(1).getValueType(); shared_ptr expression = resultsGroup.getResults().at(2).getExpression(); return make_shared(name, valueType, expression); - - /*optional> parseeResults = parseeResultsForParseeGroup( - ParseeGroup( - false, - { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(), - Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), - Parsee::expressionParsee() - }, - { } - ) - ); - - optional> parseeResults = parseeResultsForParseeGroup(parseeGroup);*/ } shared_ptr Parser::matchStatementFunction() { - if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::FUNCTION}, true, false)) - return nullptr; + bool hasError = false; + ParseeResultsGroup resultsGroup; string name; vector>> arguments; shared_ptr returnType = ValueType::NONE; shared_ptr statementBlock; - // name - name = tokens.at(currentIndex++)->getLexme(); - currentIndex++; // skip fun + // identifier + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::tokenParsee(TokenKind::FUNCTION, true, false) + }, + {} + ) + ); - // 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 identifierToken = tokens.at(currentIndex++); - shared_ptr argumentType = matchValueType(); - if (argumentType == nullptr) { - markError(TokenKind::TYPE, {}); - return nullptr; - } - - arguments.push_back(pair>(identifierToken->getLexme(), argumentType)); - } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true)); + 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; } - // return type - if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) { - tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line + // arguments + if (!hasError) { + 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> 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(); - if (returnType == nullptr) { - markError(TokenKind::TYPE, {}); - return nullptr; + // return type + if (!hasError) { + 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: + hasError = true; + break; } } @@ -268,6 +287,7 @@ shared_ptr Parser::matchStatementFunction() { if (statementBlock == nullptr) return nullptr; + // closing semicolon if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { markError(TokenKind::SEMICOLON, {}); return nullptr; @@ -931,85 +951,21 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { currentIndex += (*result).getTokensCount(); } - /*if (group.getRepeatedGroup()) { - bool hasSubResults = false; - - optional> subResults; + if (group.getRepeatedGroup()) { + ParseeResultsGroup subResultsGroup; do { - subResults = parseeResultsForParseeGroup(*group.getRepeatedGroup()); - if (!subResults) + subResultsGroup = parseeResultsGroupForParseeGroup(*group.getRepeatedGroup()); + if (subResultsGroup.getKind() == ParseeResultsGroupKind::FAILURE) return ParseeResultsGroup::failure(); - //return {}; - for (ParseeResult &subResult : *subResults) + for (ParseeResult &subResult : subResultsGroup.getResults()) results.push_back(subResult); - } while (!(*subResults).empty()); - }*/ + } while (subResultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS); + } return ParseeResultsGroup::success(results); } -/*optional> Parser::parseeResultsForParseeGroup(ParseeGroup group) { - int startIndex = currentIndex; - vector results; - bool mustFulfill = false; - - for (Parsee &parsee : group.getParsees()) { - optional result; - switch (parsee.getKind()) { - case ParseeKind::TOKEN: - result = tokenParseeResult(currentIndex, parsee.getTokenKind()); - break; - case ParseeKind::VALUE_TYPE: - result = valueTypeParseeResult(currentIndex); - break; - case ParseeKind::EXPRESSION: - result = expressionParseeResult(currentIndex); - break; - } - - // if doesn't match on optional group - if (!result && parsee.getIsRequired() && !group.getIsRequired() && !mustFulfill) { - currentIndex = startIndex; - return vector(); - } - - // 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 {}; - } - - // got to the next token if we got a match - if (result) - currentIndex += (*result).getTokensCount(); - } - - if (group.getRepeatedGroup()) { - bool hasSubResults = false; - - optional> subResults; - do { - subResults = parseeResultsForParseeGroup(*group.getRepeatedGroup()); - if (!subResults) - return {}; - - for (ParseeResult &subResult : *subResults) - results.push_back(subResult); - } while (!(*subResults).empty()); - } - - return results; -}*/ - optional Parser::tokenParseeResult(int index, TokenKind tokenKind) { shared_ptr token = tokens.at(index); if (token->isOfKind({tokenKind})) diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 7e80f40..9ab27a3 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -57,7 +57,6 @@ private: shared_ptr matchValueType(); ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); - //optional> parseeResultsForParseeGroup(ParseeGroup group); optional tokenParseeResult(int index, TokenKind tokenKind); optional valueTypeParseeResult(int index); optional expressionParseeResult(int index); From 163bcb4057336a0c4c69c72148734ea283a2bad9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Wed, 30 Jul 2025 23:58:19 +0900 Subject: [PATCH 08/13] Fixed up raw function --- samples/test.brc | 14 +++--- src/Parser/Parsee/Parsee.cpp | 2 - src/Parser/Parsee/Parsee.h | 1 - src/Parser/Parser.cpp | 92 ++++++++++++++++++++++-------------- 4 files changed, 63 insertions(+), 46 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 563c1bc..6077f04 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -28,10 +28,10 @@ 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 @@ -48,11 +48,11 @@ i u32 <- 0, rep text[i] != 0: ;*/ -main fun: a sint32, b sint32 -> sint32 - //printChar() +main fun -> sint32 + a sint32 <- 4 + b sint32 <- 5 - res1 sint32 <- a - b - //res2 sint32 <- rawAdd(4, 5) + res sint32 <- rawAdd(4, 5) - ret res1 + ret res ; \ No newline at end of file diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index dc8c526..3ec80d9 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/src/Parser/Parsee/Parsee.cpp @@ -1,7 +1,5 @@ #include "Parsee.h" -#include "Parser/Expression/Expression.h" - Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn) { Parsee parsee; parsee.kind = ParseeKind::TOKEN; diff --git a/src/Parser/Parsee/Parsee.h b/src/Parser/Parsee/Parsee.h index 9b1db48..6dfdf0e 100644 --- a/src/Parser/Parsee/Parsee.h +++ b/src/Parser/Parsee/Parsee.h @@ -4,7 +4,6 @@ #include enum class TokenKind; -class Expression; enum class ParseeKind { TOKEN, diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 9aa2130..d55b31e 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -297,9 +297,8 @@ shared_ptr Parser::matchStatementFunction() { } shared_ptr Parser::matchStatementRawFunction() { - return nullptr; - /*bool hasError = false; - optional> parseeResults; + bool hasError = false; + ParseeResultsGroup resultsGroup; string name; string constraints; @@ -308,9 +307,8 @@ shared_ptr Parser::matchStatementRawFunction() { string rawSource; // identifier - parseeResults = parseeResultsForParseeGroup( + resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( - true, { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false) @@ -318,17 +316,23 @@ shared_ptr Parser::matchStatementRawFunction() { {} ) ); - if (parseeResults) { - name = (*parseeResults).at(0).getToken()->getLexme(); - } else { - hasError = true; + + 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; } - // options + // constraints if (!hasError) { - parseeResults = parseeResultsForParseeGroup( + resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( - false, { Parsee::tokenParsee(TokenKind::LESS, true, false), Parsee::tokenParsee(TokenKind::STRING, true, true), @@ -337,18 +341,27 @@ shared_ptr Parser::matchStatementRawFunction() { {} ) ); - if (parseeResults && !(*parseeResults).empty()) { - constraints = (*parseeResults).at(0).getToken()->getLexme(); - } else if (!parseeResults) { - hasError = true; + + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: + constraints = resultsGroup.getResults().at(0).getToken()->getLexme(); + // remove enclosing quotes + if (constraints.length() >= 2) + constraints = constraints.substr(1, constraints.length() - 2); + break; + case ParseeResultsGroupKind::NO_MATCH: + return nullptr; + break; + case ParseeResultsGroupKind::FAILURE: + hasError = true; + break; } } // arguments if (!hasError) { - parseeResults = parseeResultsForParseeGroup( + resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( - false, { Parsee::tokenParsee(TokenKind::COLON, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), @@ -356,7 +369,6 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::valueTypeParsee(true) }, ParseeGroup( - false, { Parsee::tokenParsee(TokenKind::COMMA, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), @@ -367,23 +379,27 @@ shared_ptr Parser::matchStatementRawFunction() { ) ) ); - if (parseeResults && !(*parseeResults).empty()) { - for (int i=0; i<(*parseeResults).size(); i+=2) { - pair> arg; - arg.first = (*parseeResults).at(i).getToken()->getLexme(); - arg.second = (*parseeResults).at(i+1).getValueType(); - arguments.push_back(arg); - } - } else if (!parseeResults) { - hasError = true; + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: + for (int i=0; i> 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 if (!hasError) { - parseeResults = parseeResultsForParseeGroup( + resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( - false, { Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), @@ -393,10 +409,15 @@ shared_ptr Parser::matchStatementRawFunction() { ) ); - if (parseeResults && !(*parseeResults).empty()) { - returnType = (*parseeResults).at(0).getValueType(); - } else if (!parseeResults) { - hasError = 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; } } @@ -421,7 +442,7 @@ shared_ptr Parser::matchStatementRawFunction() { return nullptr; } - return make_shared(name, constraints, arguments, returnType, rawSource);*/ + return make_shared(name, constraints, arguments, returnType, rawSource); } shared_ptr Parser::matchStatementBlock(vector terminalTokenKinds) { @@ -593,7 +614,6 @@ shared_ptr Parser::nextExpression() { if (expression != nullptr || errors.size() > errorsCount) return expression; - //markError({}, {}); return nullptr; } From d3b1d053562fb3e1bcdf4960a3d2685919b5370e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 31 Jul 2025 12:37:49 +0900 Subject: [PATCH 09/13] Converted assignment --- src/Parser/Parser.cpp | 98 +++++++++++++++++++++++++++---------------- 1 file changed, 63 insertions(+), 35 deletions(-) diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index d55b31e..a5f3246 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -207,7 +207,6 @@ shared_ptr Parser::matchStatementFunction() { break; case ParseeResultsGroupKind::NO_MATCH: return nullptr; - break; case ParseeResultsGroupKind::FAILURE: hasError = true; break; @@ -465,58 +464,87 @@ shared_ptr Parser::matchStatementBlock(vector terminalToke } shared_ptr Parser::matchStatementAssignment() { - int startIndex = currentIndex; + ParseeResultsGroup resultsGroup; - if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, false)) - return nullptr; - shared_ptr identifierToken = tokens.at(currentIndex++); + string identifier; shared_ptr indexExpression; + shared_ptr expression; - if (tryMatchingTokenKinds({TokenKind::LEFT_SQUARE_BRACKET}, true, true)) { - indexExpression = nextExpression(); - if (indexExpression == nullptr) - return nullptr; + // identifier + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + }, + {} + ) + ); - if (!tryMatchingTokenKinds({TokenKind::RIGHT_SQUARE_BRACKET}, true, true)) { - 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 = nextExpression(); - if (expression == nullptr) + if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) return nullptr; - return make_shared(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: + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } + + return make_shared(identifier, indexExpression, expression); } shared_ptr Parser::matchStatementReturn() { - shared_ptr expression; - ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { Parsee::tokenParsee(TokenKind::RETURN, true, false), Parsee::expressionParsee(false) }, - { } + {} ) ); - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - expression = !resultsGroup.getResults().empty() ? resultsGroup.getResults().at(0).getExpression() : nullptr; - break; - case ParseeResultsGroupKind::NO_MATCH: - case ParseeResultsGroupKind::FAILURE: - return nullptr; - } + if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) + return nullptr; + + shared_ptr expression = !resultsGroup.getResults().empty() ? resultsGroup.getResults().at(0).getExpression() : nullptr; return make_shared(expression); } From 1522aa517b3b6f1f40804e5dd44cad4ecf34d000 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 31 Jul 2025 13:25:06 +0900 Subject: [PATCH 10/13] refactored meta function --- samples/test.brc | 10 ++-- src/Parser/Parser.cpp | 112 +++++++++++++++++++++++++++++------------- 2 files changed, 84 insertions(+), 38 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 6077f04..21321d7 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,4 +1,4 @@ -//@extern putchar fun: character sint32 -> sint32 +@extern putchar fun: character sint32 -> sint32 // ./build/brb samples/test.brc -S -x86-asm-syntax=intel @@ -49,10 +49,12 @@ rawAdd raw<"=r,r,r">: num1 sint32, num2 sint32 -> sint32 ;*/ main fun -> sint32 - a sint32 <- 4 + /*a sint32 <- 4 b sint32 <- 5 - res sint32 <- rawAdd(4, 5) + res sint32 <- rawAdd(4, 5)*/ + putchar('@') + putchar('\n') - ret res + ret 0 ; \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index a5f3246..3eb154c 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -112,50 +112,91 @@ shared_ptr Parser::nextInBlockStatement() { } shared_ptr Parser::matchStatementMetaExternFunction() { - if (!tryMatchingTokenKinds({TokenKind::M_EXTERN, TokenKind::IDENTIFIER, TokenKind::FUNCTION}, true, false)) - return nullptr; + ParseeResultsGroup resultsGroup; - string name; + string identifier; vector>> arguments; shared_ptr returnType = ValueType::NONE; - currentIndex++; // skip meta - shared_ptr identifierToken = tokens.at(currentIndex++); - currentIndex++; // skip fun + // identifier + resultsGroup = parseeResultsGroupForParseeGroup( + 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)) { - do { - tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line - if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) { - markError({}, "Expected function argument"); - return nullptr; + 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> arg; + arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); + arg.second = resultsGroup.getResults().at(i+1).getValueType(); + arguments.push_back(arg); } - shared_ptr identifierToken = tokens.at(currentIndex++); - //shared_ptr argumentTypeToken = tokens.at(currentIndex++); - shared_ptr argumentType = matchValueType(); - if (argumentType == nullptr) { - markError(TokenKind::TYPE, {}); - return nullptr; - } - - arguments.push_back(pair>(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 returnTypeToken = tokens.at(currentIndex); - returnType = matchValueType(); - if (returnType == nullptr) { - markError(TokenKind::TYPE, {}); + break; + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: return nullptr; - } } - return make_shared(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(identifier, arguments, returnType); } shared_ptr Parser::matchStatementVariable() { @@ -464,6 +505,7 @@ shared_ptr Parser::matchStatementBlock(vector terminalToke } shared_ptr Parser::matchStatementAssignment() { + int startIndex = currentIndex; ParseeResultsGroup resultsGroup; string identifier; @@ -523,6 +565,8 @@ shared_ptr Parser::matchStatementAssignment() { expression = resultsGroup.getResults().at(0).getExpression(); break; case ParseeResultsGroupKind::NO_MATCH: + currentIndex = startIndex; + return nullptr; case ParseeResultsGroupKind::FAILURE: return nullptr; } From ad17bd2b5f7c34c11b254f1c8d15ec1be1c709f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 31 Jul 2025 13:30:50 +0900 Subject: [PATCH 11/13] Cleaned up --- src/Parser/Parser.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 3eb154c..a7d06b4 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -208,18 +208,18 @@ shared_ptr Parser::matchStatementVariable() { Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), Parsee::expressionParsee(true) }, - { } + {} ) ); if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) return nullptr; - string name = resultsGroup.getResults().at(0).getToken()->getLexme(); + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); shared_ptr valueType = resultsGroup.getResults().at(1).getValueType(); shared_ptr expression = resultsGroup.getResults().at(2).getExpression(); - return make_shared(name, valueType, expression); + return make_shared(identifier, valueType, expression); } shared_ptr Parser::matchStatementFunction() { From def96445b27e4dcbb8f456db8f7018fe551fb5ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 31 Jul 2025 13:39:15 +0900 Subject: [PATCH 12/13] Better log message --- src/Logger.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Logger.cpp b/src/Logger.cpp index b8f85e0..98dd04e 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -482,7 +482,7 @@ void Logger::print(shared_ptr 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) { if (expectedTokenKind) { message = format( - "Expected token {} but instead found {} at line: {}, column: {}", - toString(*expectedTokenKind), toString(token), token->getLine() + 1, token->getColumn() + 1 + "At line {}, column {}: Expected token {} but found {} instead", + token->getLine() + 1, token->getColumn() + 1, toString(*expectedTokenKind), toString(token) ); } else { message = format( - "Unexpected token \"{}\" found at line: {}, column: {}", - toString(token), token->getLine() + 1, token->getColumn() + 1 + "At line {}, column {}: Unexpected token \"{}\" found", + token->getLine() + 1, token->getColumn() + 1, toString(token) ); } if (errorMessage) @@ -507,7 +507,7 @@ void Logger::print(shared_ptr 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; } } From e37a34b4e65372b23b51db2488e99cef931799c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 31 Jul 2025 14:01:15 +0900 Subject: [PATCH 13/13] Parse value type arg --- src/Parser/Parser.cpp | 52 +++++++++---------------------------------- src/Parser/Parser.h | 2 -- 2 files changed, 10 insertions(+), 44 deletions(-) diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index a7d06b4..0db1a3d 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -952,46 +952,6 @@ shared_ptr Parser::matchExpressionBlock(vector terminalTo return make_shared(statements); } -shared_ptr Parser::matchValueType() { - if (!tryMatchingTokenKinds({TokenKind::TYPE}, true, false)) - return nullptr; - shared_ptr typeToken = tokens.at(currentIndex++); - shared_ptr subType; - int valueArg = 0; - - if (tryMatchingTokenKinds({TokenKind::LESS}, true, true)) { - if (!tryMatchingTokenKinds({TokenKind::TYPE}, true, false)) { - markError(TokenKind::TYPE, {}); - return nullptr; - } - subType = matchValueType(); - if (subType == nullptr) - return subType; - - if (tryMatchingTokenKinds({TokenKind::COMMA}, true, true)) { - if (!tryMatchingTokenKinds({TokenKind::INTEGER_DEC, TokenKind::INTEGER_HEX, TokenKind::INTEGER_BIN, TokenKind::INTEGER_CHAR}, false, false)) { - markError({}, "Expected integer literal"); - return nullptr; - } - shared_ptr expressionValue = matchExpressionLiteral(); - if (expressionValue == nullptr) { - markError({}, "Expected integer literal"); - return nullptr; - } - - valueArg = dynamic_pointer_cast(expressionValue)->getSint32Value(); - } - - - if (!tryMatchingTokenKinds({TokenKind::GREATER}, true, true)) { - markError(TokenKind::GREATER, {}); - return nullptr; - } - } - - return ValueType::valueTypeForToken(typeToken, subType, valueArg); -} - ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { int errorsCount = errors.size(); int startIndex = currentIndex; @@ -1081,20 +1041,28 @@ optional Parser::valueTypeParseeResult(int 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 expressionValue = matchExpressionLiteral(); + typeArg = dynamic_pointer_cast(expressionValue)->getSint32Value(); + currentIndex = storedIndex; + index++; } if (!tokens.at(index)->isOfKind({TokenKind::GREATER})) return {}; + index++; } - shared_ptr valueType = ValueType::valueTypeForToken(typeToken, subType, 0); + shared_ptr valueType = ValueType::valueTypeForToken(typeToken, subType, typeArg); return ParseeResult::valueTypeResult(valueType, index - startIndex); } diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 9ab27a3..8e5a8d5 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -54,8 +54,6 @@ private: shared_ptr matchExpressionBinary(shared_ptr left); shared_ptr matchExpressionBlock(vector terminalTokenKinds); - shared_ptr matchValueType(); - ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); optional tokenParseeResult(int index, TokenKind tokenKind); optional valueTypeParseeResult(int index);