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

Use parsee results

Browse Source
This commit is contained in:
Rafał Grodziński
2025-07-17 17:14:19 +09:00
parent 502e4d2f6f
commit 8a708d8936
6 changed files with 102 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

6
src/Parser/Parsee/Parsee.h
View File

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

33
src/Parser/Parsee/ParseeResult.cpp Normal file
View File

@@ -0,0 +1,33 @@
#include "ParseeResult.h"
#include "Lexer/Token.h"
#include "Parser/ValueType.h"
ParseeResult ParseeResult::tokenResult(shared_ptr<Token> token) {
ParseeResult parseeResult;
parseeResult.kind = ParseeResultKind::TOKEN;
parseeResult.token = token;
return parseeResult;
}
ParseeResult ParseeResult::valueTypeResult(shared_ptr<ValueType> valueType) {
ParseeResult parseeResult;
parseeResult.kind = ParseeResultKind::VALUE_TYPE;
parseeResult.valueType = valueType;
return parseeResult;
}
ParseeResult::ParseeResult() { }
ParseeResultKind ParseeResult::getKind() {
return kind;
}
shared_ptr<Token> ParseeResult::getToken() {
return token;
}
shared_ptr<ValueType> ParseeResult::getValueType() {
return valueType;
}

32
src/Parser/Parsee/ParseeResult.h Normal file
View File

@@ -0,0 +1,32 @@
#ifndef PARSEE_RESULT_H
#define PARSEE_RESULT_H
#include <memory>
class Token;
class ValueType;
using namespace std;
enum class ParseeResultKind {
TOKEN,
VALUE_TYPE,
};
class ParseeResult {
private:
ParseeResultKind kind;
shared_ptr<Token> token;
shared_ptr<ValueType> valueType;
ParseeResult();
public:
static ParseeResult tokenResult(shared_ptr<Token> token);
static ParseeResult valueTypeResult(shared_ptr<ValueType> valueType);
ParseeResultKind getKind();
shared_ptr<Token> getToken();
shared_ptr<ValueType> getValueType();
};
#endif

54
src/Parser/Parser.cpp
View File

@@ -27,6 +27,7 @@
#include "Parsee/Parsee.h"
#include "Parsee/ParseeGroup.h"
#include "Parsee/ParseeResult.h"
Parser::Parser(vector<shared_ptr<Token>> tokens) :
tokens(tokens) { }
@@ -240,7 +241,7 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
shared_ptr<Statement> Parser::matchStatementRawFunction() {
bool hasError = false;
optional<vector<shared_ptr<Token>>> groupTokens;
optional<vector<ParseeResult>> parseeResults;
string name;
string constraints;
@@ -248,7 +249,7 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
shared_ptr<ValueType> returnType = ValueType::NONE;
// identifier
groupTokens = tokensForParseeGroup(
parseeResults = parseeResultsForParseeGroup(
ParseeGroup(
true,
{
@@ -258,15 +259,15 @@ shared_ptr<Statement> 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<Statement> 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<Statement> 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<string, shared_ptr<ValueType>> 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<ValueType> Parser::matchValueType() {
return ValueType::valueTypeForToken(typeToken, subType, valueArg);
}
optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup group) {
optional<vector<ParseeResult>> Parser::parseeResultsForParseeGroup(ParseeGroup group) {
int nextIndex = currentIndex;
vector<shared_ptr<Token>> returnTokens;
vector<ParseeResult> results;
bool mustFulfill = false;
for (Parsee &parsee : group.getParsees()) {
@@ -883,11 +889,11 @@ optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup gro
// if doesn't match on optional group
if (!matches && parsee.getIsRequired() && !group.getIsRequired() && mustFulfill)
return vector<shared_ptr<Token>>();
return vector<ParseeResult>();
// 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<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup gro
currentIndex = nextIndex;
return returnTokens;
return results;
}
bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) {

3
src/Parser/Parser.h
View File

@@ -13,6 +13,7 @@ class Expression;
class Statement;
class ParseeGroup;
class ParseeResult;
using namespace std;
@@ -54,7 +55,7 @@ private:
shared_ptr<ValueType> matchValueType();
optional<vector<shared_ptr<Token>>> tokensForParseeGroup(ParseeGroup group);
optional<vector<ParseeResult>> parseeResultsForParseeGroup(ParseeGroup group);
bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
void markError(optional<TokenKind> expectedTokenKind, optional<string> message);