CarGDev/bits-runner-builder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Correctly parse blob

Browse Source
This commit is contained in:
Rafał Grodziński
2025-08-07 18:35:43 +09:00
parent 76f03ef8e3
commit 8dcdcc7061
3 changed files with 32 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Parser/Parsee/Parsee.cpp
View File

@@ -7,6 +7,7 @@ Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, b
parsee.kind = ParseeKind::REPEATED_GROUP; parsee.kind = ParseeKind::REPEATED_GROUP;
parsee.repeatedGroup = repeatedGroup; parsee.repeatedGroup = repeatedGroup;
parsee.isRequired = isRequired; parsee.isRequired = isRequired;
parsee.shouldReturn = shouldReturn;
parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
return parsee; return parsee;
} }

78
src/Parser/Parser.cpp
View File

@@ -510,20 +510,14 @@ shared_ptr<Statement> Parser::matchStatementBlob() {
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::valueTypeParsee(true), Parsee::valueTypeParsee(true),
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false) Parsee::tokenParsee(TokenKind::NEW_LINE, true, false)
}/*, }
{}*/ ),
), false, true, false false,
true,
false
), ),
Parsee::tokenParsee(TokenKind::SEMICOLON, true, false) Parsee::tokenParsee(TokenKind::SEMICOLON, true, false)
}/*, }
{}
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::valueTypeParsee(true)
},
{}
)*/
) )
); );
@@ -544,16 +538,16 @@ shared_ptr<Statement> Parser::matchStatementBlob() {
} }
// consume new line // consume new line
if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { /*if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
markError(TokenKind::NEW_LINE, {}); markError(TokenKind::NEW_LINE, {});
return nullptr; return nullptr;
} }*/
// closing semicolon // closing semicolon
if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { /*if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) {
markError(TokenKind::SEMICOLON, {}); markError(TokenKind::SEMICOLON, {});
return nullptr; return nullptr;
} }*/
return make_shared<StatementBlob>(identifier, variables); return make_shared<StatementBlob>(identifier, variables);
} }
@@ -1045,10 +1039,9 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
bool mustFulfill = false; bool mustFulfill = false;
for (Parsee &parsee : group.getParsees()) { for (Parsee &parsee : group.getParsees()) {
optional<vector<ParseeResult>> subResults; optional<pair<vector<ParseeResult>, int>> subResults;
switch (parsee.getKind()) { switch (parsee.getKind()) {
case ParseeKind::REPEATED_GROUP: case ParseeKind::REPEATED_GROUP:
//ParseeResultsGroup results = parseeResultsGroupForParseeGroup(*parsee.getRepeatedGroup());
subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup()); subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup());
break; break;
case ParseeKind::TOKEN: case ParseeKind::TOKEN:
@@ -1069,14 +1062,12 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
// if doesn't match on optional group // if doesn't match on optional group
if (!subResults && parsee.getIsRequired() && !mustFulfill) { if (!subResults && parsee.getIsRequired() && !mustFulfill) {
currentIndex = startIndex; currentIndex = startIndex;
//return vector<ParseeResult>();
return ParseeResultsGroup::noMatch(); return ParseeResultsGroup::noMatch();
} }
// return matching token? // return matching token?
if (subResults && parsee.getShouldReturn()) { if (subResults && parsee.getShouldReturn()) {
//parseeResults.push_back(*result); for (ParseeResult &subResult : (*subResults).first)
for (ParseeResult &subResult : *subResults)
parseeResults.push_back(subResult); parseeResults.push_back(subResult);
} }
@@ -1087,34 +1078,18 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
// invalid sequence detected? // invalid sequence detected?
if (!subResults && parsee.getIsRequired() && mustFulfill) { if (!subResults && parsee.getIsRequired() && mustFulfill) {
markError(parsee.getTokenKind(), {}); markError(parsee.getTokenKind(), {});
//return {};
return ParseeResultsGroup::failure(); return ParseeResultsGroup::failure();
} }
// got to the next token if we got a match // got to the next token if we got a match
if (subResults) { if (subResults)
for (ParseeResult &subResult : *subResults ) currentIndex += (*subResults).second;
currentIndex += subResult.getTokensCount();
//currentIndex += (*result).getTokensCount();
} }
}
/*if (group.getRepeatedGroup()) {
ParseeResultsGroup subResultsGroup;
do {
subResultsGroup = parseeResultsGroupForParseeGroup(*group.getRepeatedGroup());
if (subResultsGroup.getKind() == ParseeResultsGroupKind::FAILURE)
return ParseeResultsGroup::failure();
for (ParseeResult &subResult : subResultsGroup.getResults())
results.push_back(subResult);
} while (subResultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS);
}*/
return ParseeResultsGroup::success(parseeResults); return ParseeResultsGroup::success(parseeResults);
} }
optional<vector<ParseeResult>> Parser::repeatedGroupParseeResults(ParseeGroup group) { optional<pair<vector<ParseeResult>, int>> Parser::repeatedGroupParseeResults(ParseeGroup group) {
int startIndex = currentIndex; int startIndex = currentIndex;
vector<ParseeResult> results; vector<ParseeResult> results;
@@ -1128,18 +1103,19 @@ optional<vector<ParseeResult>> Parser::repeatedGroupParseeResults(ParseeGroup gr
results.push_back(result); results.push_back(result);
} while (resultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS); } while (resultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS);
int tokensCount = currentIndex - startIndex;
currentIndex = startIndex; currentIndex = startIndex;
return results; return pair(results, tokensCount);
} }
optional<vector<ParseeResult>> Parser::tokenParseeResults(int index, TokenKind tokenKind) { optional<pair<vector<ParseeResult>, int>> Parser::tokenParseeResults(int index, TokenKind tokenKind) {
shared_ptr<Token> token = tokens.at(index); shared_ptr<Token> token = tokens.at(index);
if (token->isOfKind({tokenKind})) if (token->isOfKind({tokenKind}))
return vector<ParseeResult>({ParseeResult::tokenResult(token)}); return pair(vector<ParseeResult>({ParseeResult::tokenResult(token)}), 1);
return {}; return {};
} }
optional<vector<ParseeResult>> Parser::valueTypeParseeResults(int index) { optional<pair<vector<ParseeResult>, int>> Parser::valueTypeParseeResults(int index) {
int startIndex = index; int startIndex = index;
if (!tokens.at(index)->isOfKind({TokenKind::TYPE})) if (!tokens.at(index)->isOfKind({TokenKind::TYPE}))
@@ -1151,11 +1127,11 @@ optional<vector<ParseeResult>> Parser::valueTypeParseeResults(int index) {
if (tokens.at(index)->isOfKind({TokenKind::LESS})) { if (tokens.at(index)->isOfKind({TokenKind::LESS})) {
index++; index++;
optional<vector<ParseeResult>> subResults = valueTypeParseeResults(index); optional<pair<vector<ParseeResult>, int>> subResults = valueTypeParseeResults(index);
if (!subResults || (*subResults).empty()) if (!subResults || (*subResults).first.empty())
return {}; return {};
subType = (*subResults)[0].getValueType(); subType = (*subResults).first[0].getValueType();
index += (*subResults)[0].getTokensCount(); index += (*subResults).second;
if (tokens.at(index)->isOfKind({TokenKind::COMMA})) { if (tokens.at(index)->isOfKind({TokenKind::COMMA})) {
index++; index++;
@@ -1177,10 +1153,10 @@ optional<vector<ParseeResult>> Parser::valueTypeParseeResults(int index) {
} }
shared_ptr<ValueType> valueType = ValueType::valueTypeForToken(typeToken, subType, typeArg); shared_ptr<ValueType> valueType = ValueType::valueTypeForToken(typeToken, subType, typeArg);
return vector<ParseeResult>({ParseeResult::valueTypeResult(valueType, index - startIndex)}); return pair(vector<ParseeResult>({ParseeResult::valueTypeResult(valueType, index - startIndex)}), index - startIndex);
} }
optional<vector<ParseeResult>> Parser::expressionParseeResults(int index) { optional<pair<vector<ParseeResult>, int>> Parser::expressionParseeResults(int index) {
int startIndex = currentIndex; int startIndex = currentIndex;
int errorsCount = errors.size(); int errorsCount = errors.size();
shared_ptr<Expression> expression = nextExpression(); shared_ptr<Expression> expression = nextExpression();
@@ -1189,7 +1165,7 @@ optional<vector<ParseeResult>> Parser::expressionParseeResults(int index) {
int tokensCount = currentIndex - startIndex; int tokensCount = currentIndex - startIndex;
currentIndex = startIndex; currentIndex = startIndex;
return vector<ParseeResult>({ParseeResult::expressionResult(expression, tokensCount)}); return pair(vector<ParseeResult>({ParseeResult::expressionResult(expression, tokensCount)}), tokensCount);
} }
bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) { bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) {

8
src/Parser/Parser.h
View File

@@ -57,10 +57,10 @@ private:
shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds); shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds);
ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group);
optional<vector<ParseeResult>> repeatedGroupParseeResults(ParseeGroup group); optional<pair<vector<ParseeResult>, int>> repeatedGroupParseeResults(ParseeGroup group);
optional<vector<ParseeResult>> tokenParseeResults(int index, TokenKind tokenKind); optional<pair<vector<ParseeResult>, int>> tokenParseeResults(int index, TokenKind tokenKind);
optional<vector<ParseeResult>> valueTypeParseeResults(int index); optional<pair<vector<ParseeResult>, int>> valueTypeParseeResults(int index);
optional<vector<ParseeResult>> expressionParseeResults(int index); optional<pair<vector<ParseeResult>, int>> expressionParseeResults(int index);
bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance); bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
void markError(optional<TokenKind> expectedTokenKind, optional<string> message); void markError(optional<TokenKind> expectedTokenKind, optional<string> message);