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

Using the groupParsee

Browse Source
This commit is contained in:
Rafał Grodziński
2025-08-08 12:34:28 +09:00
parent 39be17e6a1
commit e4c956cdd6
8 changed files with 292 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
samples/test.brc
View File

@@ -1,10 +1,19 @@
@extern putchar fun: character u32 -> u32
User blob
num1 s32
num2 u8
;
rawAdd raw<"=r,r,r">: num1 u32, num2 u32 -> u32
add $1, $2
mov $0, $1
;
main fun -> u32
user User <- 0
n1 u32 <- 5
n2 u32 <- 4
n3 u32 <- rawAdd(n1, n2)
ret 0
;

5
src/Logger.cpp
View File

@@ -326,7 +326,10 @@ string Logger::toString(shared_ptr<StatementBlock> statement) {
}
string Logger::toString(shared_ptr<StatementAssignment> statement) {
return format("{} <- {}", statement->getName(), toString(statement->getExpression()));
if (statement->getIndexExpression() != nullptr)
return format("{}[{}] <- {}", statement->getName(), toString(statement->getIndexExpression()), toString(statement->getExpression()));
else
return format("{} <- {}", statement->getName(), toString(statement->getExpression()));
}
string Logger::toString(shared_ptr<StatementReturn> statement) {

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

@@ -2,6 +2,16 @@
#include "ParseeGroup.h"
Parsee Parsee::groupParsee(ParseeGroup group, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
Parsee parsee;
parsee.kind = ParseeKind::GROUP;
parsee.group = group;
parsee.isRequired = isRequired;
parsee.shouldReturn = shouldReturn;
parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
return parsee;
}
Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
Parsee parsee;
parsee.kind = ParseeKind::REPEATED_GROUP;
@@ -12,33 +22,40 @@ Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, b
return parsee;
}
Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn) {
Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
Parsee parsee;
parsee.kind = ParseeKind::TOKEN;
parsee.tokenKind = tokenKind;
parsee.isRequired = isRequired;
parsee.shouldReturn = shouldReturn;
parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
return parsee;
}
Parsee Parsee::valueTypeParsee(bool isRequired) {
Parsee Parsee::valueTypeParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
Parsee parsee;
parsee.kind = ParseeKind::VALUE_TYPE;
parsee.isRequired = isRequired;
parsee.shouldReturn = true;
parsee.shouldReturn = shouldReturn;
parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
return parsee;
}
Parsee Parsee::expressionParsee(bool isRequired) {
Parsee Parsee::expressionParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
Parsee parsee;
parsee.kind = ParseeKind::EXPRESSION;
parsee.isRequired = isRequired;
parsee.shouldReturn = true;
parsee.shouldReturn = shouldReturn;
parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
return parsee;
}
Parsee::Parsee() { }
optional<ParseeGroup> Parsee::getGroup() {
return group;
}
optional<ParseeGroup> Parsee::getRepeatedGroup() {
return repeatedGroup;
}

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

@@ -7,11 +7,11 @@
#include "ParseeGroup.h"
enum class TokenKind;
//class ParseeGroup;
using namespace std;
enum class ParseeKind {
GROUP,
REPEATED_GROUP,
TOKEN,
VALUE_TYPE,
@@ -21,6 +21,7 @@ enum class ParseeKind {
class Parsee {
private:
ParseeKind kind;
optional<ParseeGroup> group;
optional<ParseeGroup> repeatedGroup;
TokenKind tokenKind;
bool isRequired;
@@ -29,12 +30,14 @@ private:
Parsee();
public:
static Parsee groupParsee(ParseeGroup group, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
static Parsee repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn);
static Parsee valueTypeParsee(bool isRequired);
static Parsee expressionParsee(bool isRequired);
static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
static Parsee valueTypeParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
static Parsee expressionParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
ParseeKind getKind();
optional<ParseeGroup> getGroup();
optional<ParseeGroup> getRepeatedGroup();
TokenKind getTokenKind();
bool getIsRequired();

14
src/Parser/Parsee/ParseeGroup.cpp
View File

@@ -2,19 +2,9 @@
#include "Parsee.h"
ParseeGroup::ParseeGroup(vector<Parsee> parsees)://, optional<ParseeGroup> repeatedGroup):
parsees(parsees) {
/*if (repeatedGroup) {
this->repeatedGroup = *repeatedGroup;
} else {
this->repeatedGroup = {};
}*/
}
ParseeGroup::ParseeGroup(vector<Parsee> parsees):
parsees(parsees) { }
vector<Parsee> ParseeGroup::getParsees() {
return parsees;
}
/*optional<reference_wrapper<ParseeGroup>> ParseeGroup::getRepeatedGroup() {
return repeatedGroup;
}*/

5
src/Parser/Parsee/ParseeGroup.h
View File

@@ -2,7 +2,6 @@
#define PARSEE_GROUP_H
#include <vector>
#include <optional>
class Parsee;
@@ -11,12 +10,10 @@ using namespace std;
class ParseeGroup {
private:
vector<Parsee> parsees;
//optional<reference_wrapper<ParseeGroup>> repeatedGroup;
public:
ParseeGroup(vector<Parsee> parsees);//, optional<ParseeGroup> repeatedGroup);
ParseeGroup(vector<Parsee> parsees);
vector<Parsee> getParsees();
//optional<reference_wrapper<ParseeGroup>> getRepeatedGroup();
};
#endif

595
src/Parser/Parser.cpp
View File

@@ -118,89 +118,70 @@ shared_ptr<Statement> Parser::nextInBlockStatement() {
}
shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
ParseeResultsGroup resultsGroup;
string identifier;
vector<pair<string, shared_ptr<ValueType>>> arguments;
shared_ptr<ValueType> returnType = ValueType::NONE;
// identifier
resultsGroup = parseeResultsGroupForParseeGroup(
ParseeResultsGroup 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
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<resultsGroup.getResults().size(); i+=2) {
pair<string, shared_ptr<ValueType>> arg;
arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
arg.second = resultsGroup.getResults().at(i+1).getValueType();
arguments.push_back(arg);
// identifier
Parsee::tokenParsee(TokenKind::M_EXTERN, true, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
Parsee::tokenParsee(TokenKind::FUNCTION, true, false, false),
// arguments
Parsee::groupParsee(
ParseeGroup(
{
// first argument
Parsee::tokenParsee(TokenKind::COLON, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
Parsee::valueTypeParsee(true, true, true),
// additional arguments
Parsee::repeatedGroupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::COMMA, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
Parsee::valueTypeParsee(true, true, true)
}
), false, true, false
)
}
), false, true, false
),
// return type
Parsee::groupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::valueTypeParsee(true, true, true)
}
), false, true, false
)
}
break;
case ParseeResultsGroupKind::NO_MATCH:
break;
case ParseeResultsGroupKind::FAILURE:
return nullptr;
}
// 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;
if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
return nullptr;
int i = 0;
// identifier
identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
// arguments
while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) {
pair<string, shared_ptr<ValueType>> argument;
argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme();
argument.second = resultsGroup.getResults().at(i++).getValueType();
arguments.push_back(argument);
}
// return type
if (i < resultsGroup.getResults().size())
returnType = resultsGroup.getResults().at(i).getValueType();
return make_shared<StatementMetaExternFunction>(identifier, arguments, returnType);
}
@@ -209,12 +190,11 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::valueTypeParsee(true),
Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false),
Parsee::expressionParsee(true)
}/*,
{}*/
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
Parsee::valueTypeParsee(true, true, false),
Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, true),
Parsee::expressionParsee(true, true, true)
}
)
);
@@ -229,106 +209,79 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
}
shared_ptr<Statement> Parser::matchStatementFunction() {
bool hasError = false;
ParseeResultsGroup resultsGroup;
string name;
string identifier;
vector<pair<string, shared_ptr<ValueType>>> arguments;
shared_ptr<ValueType> returnType = ValueType::NONE;
shared_ptr<Statement> statementBlock;
// identifier
resultsGroup = parseeResultsGroupForParseeGroup(
ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::tokenParsee(TokenKind::FUNCTION, true, false)
}/*,
{}*/
// identifier
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
Parsee::tokenParsee(TokenKind::FUNCTION, true, false, false),
// arguments
Parsee::groupParsee(
ParseeGroup(
{
// first argument
Parsee::tokenParsee(TokenKind::COLON, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
Parsee::valueTypeParsee(true, true, true),
// additional arguments
Parsee::repeatedGroupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::COMMA, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
Parsee::valueTypeParsee(true, true, true)
}
), false, true, false
)
}
), false, true, false
),
// return type
Parsee::groupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::valueTypeParsee(true, true, true)
}
), false, true, false
),
// new line
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true)
}
)
);
switch (resultsGroup.getKind()) {
case ParseeResultsGroupKind::SUCCESS:
name = resultsGroup.getResults().at(0).getToken()->getLexme();
case ParseeResultsGroupKind::SUCCESS: {
int i = 0;
// identifier
identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
// arguments
while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) {
pair<string, shared_ptr<ValueType>> argument;
argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme();
argument.second = resultsGroup.getResults().at(i++).getValueType();
arguments.push_back(argument);
}
// return type
if (i < resultsGroup.getResults().size())
returnType = resultsGroup.getResults().at(i).getValueType();
}
break;
case ParseeResultsGroupKind::NO_MATCH:
return nullptr;
case ParseeResultsGroupKind::FAILURE:
hasError = true;
break;
}
// 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<resultsGroup.getResults().size(); i+=2) {
pair<string, shared_ptr<ValueType>> 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) {
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;
}
}
// consume new line
if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
markError(TokenKind::NEW_LINE, {});
return nullptr;
}
// block
statementBlock = matchStatementBlock({TokenKind::SEMICOLON, TokenKind::END});
if (statementBlock == nullptr)
@@ -340,140 +293,99 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
return nullptr;
}
return make_shared<StatementFunction>(name, arguments, returnType, dynamic_pointer_cast<StatementBlock>(statementBlock));
return make_shared<StatementFunction>(identifier, arguments, returnType, dynamic_pointer_cast<StatementBlock>(statementBlock));
}
shared_ptr<Statement> Parser::matchStatementRawFunction() {
bool hasError = false;
ParseeResultsGroup resultsGroup;
string name;
string identifier;
string constraints;
vector<pair<string, shared_ptr<ValueType>>> arguments;
shared_ptr<ValueType> returnType = ValueType::NONE;
string rawSource;
// identifier
resultsGroup = parseeResultsGroupForParseeGroup(
ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false)
}/*,
{}*/
// identifier
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false, false),
// constraints
Parsee::groupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::LESS, true, false, true),
Parsee::tokenParsee(TokenKind::STRING, true, true, true),
Parsee::tokenParsee(TokenKind::GREATER, true, false, true)
}
), true, true, true
),
// arguments
Parsee::groupParsee(
ParseeGroup(
{
// first argument
Parsee::tokenParsee(TokenKind::COLON, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
Parsee::valueTypeParsee(true, true, true),
// additional arguments
Parsee::repeatedGroupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::COMMA, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
Parsee::valueTypeParsee(true, true, true)
}
), false, true, false
)
}
), false, true, false
),
// return type
Parsee::groupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
Parsee::valueTypeParsee(true, true, true)
}
), false, true, false
),
// new line
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true)
}
)
);
switch (resultsGroup.getKind()) {
case ParseeResultsGroupKind::SUCCESS:
name = resultsGroup.getResults().at(0).getToken()->getLexme();
case ParseeResultsGroupKind::SUCCESS: {
int i = 0;
// identifier
identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
// constraints
constraints = resultsGroup.getResults().at(i++).getToken()->getLexme();
// remove enclosing quotes
if (constraints.length() >= 2)
constraints = constraints.substr(1, constraints.length() - 2);
// arguments
while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) {
pair<string, shared_ptr<ValueType>> argument;
argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme();
argument.second = resultsGroup.getResults().at(i++).getValueType();
arguments.push_back(argument);
}
// return type
if (i < resultsGroup.getResults().size())
returnType = resultsGroup.getResults().at(i).getValueType();
}
break;
case ParseeResultsGroupKind::NO_MATCH:
return nullptr;
break;
case ParseeResultsGroupKind::FAILURE:
hasError = true;
break;
}
// constraints
if (!hasError) {
resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::LESS, true, false),
Parsee::tokenParsee(TokenKind::STRING, true, true),
Parsee::tokenParsee(TokenKind::GREATER, true, false)
}/*,
{}*/
)
);
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) {
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<resultsGroup.getResults().size(); i+=2) {
pair<string, shared_ptr<ValueType>> 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) {
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;
}
}
// consume new line
if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
markError(TokenKind::NEW_LINE, {});
return nullptr;
}
// source
while (tryMatchingTokenKinds({TokenKind::RAW_SOURCE_LINE}, true, false)) {
if (!rawSource.empty())
@@ -484,12 +396,13 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true);
}
// closing semicolon
if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) {
markError(TokenKind::SEMICOLON, {});
return nullptr;
}
return make_shared<StatementRawFunction>(name, constraints, arguments, returnType, rawSource);
return make_shared<StatementRawFunction>(identifier, constraints, arguments, returnType, rawSource);
}
shared_ptr<Statement> Parser::matchStatementBlob() {
@@ -501,22 +414,19 @@ shared_ptr<Statement> Parser::matchStatementBlob() {
resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::tokenParsee(TokenKind::BLOB, true, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false),
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
Parsee::tokenParsee(TokenKind::BLOB, true, false, false),
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true),
Parsee::repeatedGroupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
Parsee::valueTypeParsee(true),
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false)
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
Parsee::valueTypeParsee(true, true, true),
Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true)
}
),
false,
true,
false
), false, true, false
),
Parsee::tokenParsee(TokenKind::SEMICOLON, true, false)
Parsee::tokenParsee(TokenKind::SEMICOLON, true, false, true)
}
)
);
@@ -560,71 +470,43 @@ shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalToke
}
shared_ptr<Statement> Parser::matchStatementAssignment() {
int startIndex = currentIndex;
ParseeResultsGroup resultsGroup;
string identifier;
shared_ptr<Expression> indexExpression;
shared_ptr<Expression> expression;
// identifier
resultsGroup = parseeResultsGroupForParseeGroup(
ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
}/*,
{}*/
// identifier
Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
// index expression
Parsee::groupParsee(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false, false),
Parsee::expressionParsee(true, true, true),
Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false, true)
}
), false, true, false
),
// expression
Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false),
Parsee::expressionParsee(true, true, true)
}
)
);
if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
return nullptr;
identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
int i = 0;
// identifier
identifier = resultsGroup.getResults().at(i++).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;
}
if (i < resultsGroup.getResults().size()-1)
indexExpression = resultsGroup.getResults().at(i++).getExpression();
// 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:
currentIndex = startIndex;
return nullptr;
case ParseeResultsGroupKind::FAILURE:
return nullptr;
}
expression = resultsGroup.getResults().at(i).getExpression();
return make_shared<StatementAssignment>(identifier, indexExpression, expression);
}
@@ -633,10 +515,9 @@ shared_ptr<Statement> Parser::matchStatementReturn() {
ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
ParseeGroup(
{
Parsee::tokenParsee(TokenKind::RETURN, true, false),
Parsee::expressionParsee(false)
}/*,
{}*/
Parsee::tokenParsee(TokenKind::RETURN, true, false, false),
Parsee::expressionParsee(false, true, false)
}
)
);
@@ -1024,11 +905,13 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
int errorsCount = errors.size();
int startIndex = currentIndex;
vector<ParseeResult> parseeResults;
bool mustFulfill = false;
for (Parsee &parsee : group.getParsees()) {
optional<pair<vector<ParseeResult>, int>> subResults;
switch (parsee.getKind()) {
case ParseeKind::GROUP:
subResults = groupParseeResults(*parsee.getGroup());
break;
case ParseeKind::REPEATED_GROUP:
subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup());
break;
@@ -1047,24 +930,20 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
if (errors.size() > errorsCount)
return ParseeResultsGroup::failure();
// if doesn't match on optional group
if (!subResults && parsee.getIsRequired() && !mustFulfill) {
// if doesn't match a required but non-failing parsee
if (!subResults && parsee.getIsRequired() && !parsee.getShouldFailOnNoMatch()) {
currentIndex = startIndex;
return ParseeResultsGroup::noMatch();
}
// return matching token?
// should return a matching result?
if (subResults && parsee.getShouldReturn()) {
for (ParseeResult &subResult : (*subResults).first)
parseeResults.push_back(subResult);
}
// decide if we're decoding the expected sequence
if (!parsee.getIsRequired() && currentIndex > startIndex)
mustFulfill = true;
// invalid sequence detected?
if (!subResults && parsee.getIsRequired() && mustFulfill) {
if (!subResults && parsee.getShouldFailOnNoMatch()) {
markError(parsee.getTokenKind(), {});
return ParseeResultsGroup::failure();
}
@@ -1077,6 +956,22 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
return ParseeResultsGroup::success(parseeResults);
}
optional<pair<vector<ParseeResult>, int>> Parser::groupParseeResults(ParseeGroup group) {
int startIndex = currentIndex;
vector<ParseeResult> results;
ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(group);
if (resultsGroup.getKind() == ParseeResultsGroupKind::FAILURE)
return {};
for (ParseeResult &result : resultsGroup.getResults())
results.push_back(result);
int tokensCount = currentIndex - startIndex;
currentIndex = startIndex;
return pair(results, tokensCount);
}
optional<pair<vector<ParseeResult>, int>> Parser::repeatedGroupParseeResults(ParseeGroup group) {
int startIndex = currentIndex;
vector<ParseeResult> results;

1
src/Parser/Parser.h
View File

@@ -57,6 +57,7 @@ private:
shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds);
ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group);
optional<pair<vector<ParseeResult>, int>> groupParseeResults(ParseeGroup group);
optional<pair<vector<ParseeResult>, int>> repeatedGroupParseeResults(ParseeGroup group);
optional<pair<vector<ParseeResult>, int>> tokenParseeResults(int index, TokenKind tokenKind);
optional<pair<vector<ParseeResult>, int>> valueTypeParseeResults(int index);