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

Single parsing logic

Browse Source
This commit is contained in:
Rafał Grodziński
2025-07-22 15:03:34 +09:00
parent 8a708d8936
commit 3041c4383b
6 changed files with 95 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
samples/test.brc
View File

@@ -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
;

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

@@ -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;
}

8
src/Parser/Parsee/ParseeResult.cpp
View File

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

4
src/Parser/Parsee/ParseeResult.h
View File

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

139
src/Parser/Parser.cpp
View File

@@ -247,6 +247,7 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
string constraints;
vector<pair<string, shared_ptr<ValueType>>> arguments;
shared_ptr<ValueType> returnType = ValueType::NONE;
string rawSource;
// identifier
parseeResults = parseeResultsForParseeGroup(
@@ -297,7 +298,7 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
Parsee::valueTypeParsee()
},
ParseeGroup(
true,
false,
{
Parsee::tokenParsee(TokenKind::COMMA, true, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
@@ -341,58 +342,6 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
}
}
if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::RAW_FUNCTION}, true, false))
return nullptr;
string rawSource;
// name
name = tokens.at(currentIndex++)->getLexme();
currentIndex++; // skip raw
// constraints
if (tryMatchingTokenKinds({TokenKind::LESS}, true, true)) {
if (tokens.at(currentIndex)->isOfKind({TokenKind::STRING})) {
constraints = tokens.at(currentIndex++)->getLexme();
// remove enclosing quotes
if (constraints.length() >= 2)
constraints = constraints.substr(1, constraints.length() - 2);
}
if (!tryMatchingTokenKinds({TokenKind::GREATER}, true, true))
markError({TokenKind::GREATER}, {});
}
// arguments
if (tryMatchingTokenKinds({TokenKind::COLON}, true, true)) {
do {
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::TYPE}, true, false)) {
markError({}, "Expected function argument");
return nullptr;
}
shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
shared_ptr<ValueType> argumentType = matchValueType();
if (argumentType == nullptr) {
markError(TokenKind::TYPE, {});
return nullptr;
}
arguments.push_back(pair<string, shared_ptr<ValueType>>(identifierToken->getLexme(), argumentType));
} while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
}
// return type
if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
returnType = matchValueType();
if (returnType == nullptr) {
markError(TokenKind::TYPE, {});
return nullptr;
}
}
// consume new line
if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
markError(TokenKind::NEW_LINE, {});
@@ -879,43 +828,103 @@ shared_ptr<ValueType> Parser::matchValueType() {
}
optional<vector<ParseeResult>> Parser::parseeResultsForParseeGroup(ParseeGroup group) {
int nextIndex = currentIndex;
int startIndex = currentIndex;
vector<ParseeResult> results;
bool mustFulfill = false;
for (Parsee &parsee : group.getParsees()) {
shared_ptr<Token> currentToken = tokens.at(nextIndex);
bool matches = currentToken->isOfKind({parsee.getTokenKind()});
optional<ParseeResult> 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<ParseeResult>();
}
// 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<vector<ParseeResult>> subResults;
do {
subResults = parseeResultsForParseeGroup(*group.getRepeatedGroup());
if (!subResults)
return {};
for (ParseeResult &subResult : *subResults)
results.push_back(subResult);
} while (!(*subResults).empty());
}
return results;
}
optional<ParseeResult> Parser::tokenParseeResult(int index, TokenKind tokenKind) {
shared_ptr<Token> token = tokens.at(index);
if (token->isOfKind({tokenKind}))
return ParseeResult::tokenResult(token);
return {};
}
optional<ParseeResult> Parser::valueTypeParseeResult(int index) {
int startIndex = index;
if (!tokens.at(index)->isOfKind({TokenKind::TYPE}))
return {};
shared_ptr<Token> typeToken = tokens.at(index++);
shared_ptr<ValueType> subType;
int typeArg = 0;
if (tokens.at(index)->isOfKind({TokenKind::LESS})) {
index++;
optional<ParseeResult> subResult = valueTypeParseeResult(index);
if (!subResult)
return {};
subType = (*subResult).getValueType();
if (tokens.at(index)->isOfKind({TokenKind::COMMA})) {
index++;
if (!tokens.at(index)->isOfKind({TokenKind::INTEGER_DEC, TokenKind::INTEGER_HEX, TokenKind::INTEGER_BIN, TokenKind::INTEGER_CHAR}))
return {};
}
if (!tokens.at(index)->isOfKind({TokenKind::GREATER}))
return {};
}
shared_ptr<ValueType> valueType = ValueType::valueTypeForToken(typeToken, subType, 0);
return ParseeResult::valueTypeResult(valueType, index - startIndex);
}
bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) {
int requiredCount = shouldMatchAll ? kinds.size() : 1;
if (currentIndex + requiredCount > tokens.size())

2
src/Parser/Parser.h
View File

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