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

added parsee and parsee group

Browse Source
This commit is contained in:
Rafał Grodziński
2025-07-17 16:00:12 +09:00
parent 1dc6010b9b
commit 502e4d2f6f
8 changed files with 146 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/Parser/Parsee.cpp
View File

@@ -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<ParseeToken> tokens, optional<ParseeTokensGroup> repeatedGroup):
isRequired(isRequired), tokens(tokens) {
if (repeatedGroup) {
this->repeatedGroup = *repeatedGroup;
} else {
this->repeatedGroup = {};
}
}
bool ParseeTokensGroup::getIsRequired() {
return isRequired;
}
vector<ParseeToken> ParseeTokensGroup::getTokens() {
return tokens;
}
optional<reference_wrapper<ParseeTokensGroup>> ParseeTokensGroup::getRepeatedGroup() {
return repeatedGroup;
}

37
src/Parser/Parsee.h
View File

@@ -1,37 +0,0 @@
#ifndef PARSEE_H
#define PARSEE_H
#include <vector>
#include <optional>
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<ParseeToken> tokens;
optional<reference_wrapper<ParseeTokensGroup>> repeatedGroup;
public:
ParseeTokensGroup(bool isRequired, vector<ParseeToken> tokens, optional<ParseeTokensGroup> repeatedGroup);
bool getIsRequired();
vector<ParseeToken> getTokens();
optional<reference_wrapper<ParseeTokensGroup>> getRepeatedGroup();
};
#endif

36
src/Parser/Parsee/Parsee.cpp Normal file
View File

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

31
src/Parser/Parsee/Parsee.h Normal file
View File

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

24
src/Parser/Parsee/ParseeGroup.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include "ParseeGroup.h"
#include "Parsee.h"
ParseeGroup::ParseeGroup(bool isRequired, vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup):
isRequired(isRequired), parsees(parsees) {
if (repeatedGroup) {
this->repeatedGroup = *repeatedGroup;
} else {
this->repeatedGroup = {};
}
}
bool ParseeGroup::getIsRequired() {
return isRequired;
}
vector<Parsee> ParseeGroup::getParsees() {
return parsees;
}
optional<reference_wrapper<ParseeGroup>> ParseeGroup::getRepeatedGroup() {
return repeatedGroup;
}

24
src/Parser/Parsee/ParseeGroup.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef PARSEE_GROUP_H
#define PARSEE_GROUP_H
#include <vector>
#include <optional>
class Parsee;
using namespace std;
class ParseeGroup {
private:
bool isRequired;
vector<Parsee> parsees;
optional<reference_wrapper<ParseeGroup>> repeatedGroup;
public:
ParseeGroup(bool isRequired, vector<Parsee> parsees, optional<ParseeGroup> repeatedGroup);
bool getIsRequired();
vector<Parsee> getParsees();
optional<reference_wrapper<ParseeGroup>> getRepeatedGroup();
};
#endif

57
src/Parser/Parser.cpp
View File

@@ -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<shared_ptr<Token>> tokens) :
tokens(tokens) { }
@@ -247,12 +248,12 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
shared_ptr<ValueType> 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<Statement> 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<Statement> 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<Statement> 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<ValueType> Parser::matchValueType() {
return ValueType::valueTypeForToken(typeToken, subType, valueArg);
}
optional<vector<shared_ptr<Token>>> Parser::tokensForParseeTokensGroup(ParseeTokensGroup group) {
optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup group) {
int nextIndex = currentIndex;
vector<shared_ptr<Token>> returnTokens;
bool mustFulfill = false;
for (ParseeToken &parsee : group.getTokens()) {
for (Parsee &parsee : group.getParsees()) {
shared_ptr<Token> currentToken = tokens.at(nextIndex);
bool matches = currentToken->isOfKind({parsee.getTokenKind()});

5
src/Parser/Parser.h
View File

@@ -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<ValueType> matchValueType();
optional<vector<shared_ptr<Token>>> tokensForParseeTokensGroup(ParseeTokensGroup group);
optional<vector<shared_ptr<Token>>> tokensForParseeGroup(ParseeGroup group);
bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
void markError(optional<TokenKind> expectedTokenKind, optional<string> message);