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

Updated statement matching

Browse Source
This commit is contained in:
Rafał Grodziński
2025-06-03 23:30:15 +09:00
parent 4665a1f5f5
commit 84c1e823cb
4 changed files with 107 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/Parser.cpp
View File

@@ -10,9 +10,7 @@ vector<shared_ptr<Statement>> Parser::getStatements() {
shared_ptr<Statement> statement = nextStatement();
// Abort parsing if we got an error
if (!statement->isValid()) {
//cerr << "Unexpected token '" << statement->getToken()->getLexme() << "' at " << statement->getToken()->getLine() << ":" << statement->getToken()->getColumn() << endl;
cerr << statement->toString();
//return vector<shared_ptr<Statement>>();
exit(1);
}
statements.push_back(statement);
@@ -25,32 +23,28 @@ vector<shared_ptr<Statement>> Parser::getStatements() {
// Statement
//
shared_ptr<Statement> Parser::nextStatement() {
/*{
shared_ptr<Statement> statement = matchFunctionDeclarationStatement();
if (statement->isValid())
return statement;
}
shared_ptr<Statement> statement;
{
shared_ptr<Statement> statement = matchReturnStatement();
if (statement->isValid())
return statement;
}
statement = matchStatementFunctionDeclaration();
if (statement != nullptr)
return statement;
{
shared_ptr<Statement> statement = matchExpressionStatement();
if (statement->isValid())
return statement;
}*/
statement = matchStatementReturn();
if (statement != nullptr)
return statement;
return matchInvalidStatement();
statement = matchStatementExpression();
if (statement != nullptr)
return statement;
return matchStatementInvalid();
}
/*shared_ptr<Statement> Parser::matchFunctionDeclarationStatement() {
shared_ptr<Statement> Parser::matchStatementFunctionDeclaration() {
if (!matchesTokenKinds({Token::Kind::IDENTIFIER, Token::Kind::COLON, Token::Kind::FUNCTION}))
return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, vector<shared_ptr<Statement>>(), "");
return nullptr;
Token identifierToken = tokens.at(currentIndex);
shared_ptr<Token> identifierToken = tokens.at(currentIndex);
currentIndex++;
currentIndex++; // skip colon
currentIndex++; // skip fun
@@ -59,68 +53,78 @@ shared_ptr<Statement> Parser::nextStatement() {
currentIndex++;
}
currentIndex++; // new line
shared_ptr<Statement> blockStatement = matchBlockStatement();
if (!blockStatement->isValid())
return blockStatement;
return make_shared<Statement>(Statement::Kind::FUNCTION_DECLARATION, nullptr, nullptr, blockStatement, vector<shared_ptr<Statement>>(), identifierToken.getLexme());
}*/
shared_ptr<Statement> statementBlock = matchStatementBlock();
if (statementBlock == nullptr)
return matchStatementInvalid();
else if (!statementBlock->isValid())
return statementBlock;
else
return make_shared<StatementFunctionDeclaration>(identifierToken->getLexme(), dynamic_pointer_cast<StatementBlock>(statementBlock));
}
/*shared_ptr<Statement> Parser::matchBlockStatement() {
shared_ptr<Statement> Parser::matchStatementBlock() {
vector<shared_ptr<Statement>> statements;
while (tokens.at(currentIndex)->getKind() != Token::Kind::SEMICOLON) {
shared_ptr<Statement> statement = nextStatement();
if (!statement->isValid())
if (statement == nullptr)
return matchStatementInvalid();
else if (!statement->isValid())
return statement;
statements.push_back(statement);
else
statements.push_back(statement);
}
currentIndex++; // skip ;
if (!tokens.at(currentIndex)->isOfKind({Token::Kind::NEW_LINE, Token::Kind::END}))
return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, vector<shared_ptr<Statement>>(), "");
return matchStatementInvalid();
if (tokens.at(currentIndex)->getKind() == Token::Kind::NEW_LINE)
currentIndex++;
return make_shared<Statement>(Statement::Kind::BLOCK, nullptr, nullptr, nullptr, statements, "");
}*/
return make_shared<StatementBlock>(statements);
}
/*shared_ptr<Statement> Parser::matchReturnStatement() {
shared_ptr<Statement> Parser::matchStatementReturn() {
if (tokens.at(currentIndex)->getKind() != Token::Kind::RETURN)
return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, vector<shared_ptr<Statement>>(), "");
return nullptr;
currentIndex++;
shared_ptr<Expression> expression = term();
if (!expression->isValid())
expression = nullptr;
shared_ptr<Expression> expression = nextExpression();
if (expression != nullptr && !expression->isValid())
return matchStatementInvalid();
if (tokens.at(currentIndex)->getKind() != Token::Kind::NEW_LINE)
return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, vector<shared_ptr<Statement>>(), "");
return matchStatementInvalid();
currentIndex++; // new line
return make_shared<Statement>(Statement::Kind::RETURN, nullptr, expression, nullptr, vector<shared_ptr<Statement>>(), "");
}*/
return make_shared<StatementReturn>(expression);
}
shared_ptr<StatementInvalid> Parser::matchInvalidStatement() {
//return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, vector<shared_ptr<Statement>>(), "");
return make_shared<StatementInvalid>();
shared_ptr<Statement> Parser::matchStatementExpression() {
shared_ptr<Expression> expression = nextExpression();
if (expression == nullptr)
return nullptr;
else if (!expression->isValid())
return make_shared<StatementInvalid>(tokens.at(currentIndex));
currentIndex++;
return make_shared<StatementExpression>(expression);
}
shared_ptr<StatementInvalid> Parser::matchStatementInvalid() {
return make_shared<StatementInvalid>(tokens.at(currentIndex));
}
//
// Expression
//
/*shared_ptr<Statement> Parser::matchExpressionStatement() {
shared_ptr<Expression> expression = term();
if (expression->isValid() && tokens.at(currentIndex)->isOfKind({Token::Kind::NEW_LINE, Token::Kind::END})) {
currentIndex++;
return make_shared<Statement>(Statement::Kind::EXPRESSION, nullptr, expression, nullptr, vector<shared_ptr<Statement>>(), "");
} else {
return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), expression, nullptr, vector<shared_ptr<Statement>>(), "");
}
}*/
shared_ptr<Expression> Parser::nextExpression() {
return nullptr;
}
/*shared_ptr<Expression> Parser::term() {
shared_ptr<Expression> expression = factor();
@@ -201,7 +205,7 @@ shared_ptr<Expression> Parser::matchBinary(shared_ptr<Expression> left) {
}
return make_shared<Expression>(Expression::Kind::INVALID, token, nullptr, nullptr);
}
}*/
bool Parser::matchesTokenKinds(vector<Token::Kind> kinds) {
if (currentIndex + kinds.size() >= tokens.size())
@@ -211,5 +215,6 @@ bool Parser::matchesTokenKinds(vector<Token::Kind> kinds) {
if (kinds.at(i) != tokens.at(currentIndex + i)->getKind())
return false;
}
return true;
}*/
}

17
src/Parser.h
View File

@@ -15,23 +15,22 @@ private:
int currentIndex = 0;
shared_ptr<Statement> nextStatement();
shared_ptr<Statement> matchStatementFunctionDeclaration();
shared_ptr<Statement> matchStatementBlock();
shared_ptr<Statement> matchStatementReturn();
shared_ptr<Statement> matchStatementExpression();
shared_ptr<StatementInvalid> matchStatementInvalid();
//shared_ptr<Statement> matchFunctionDeclarationStatement();
//shared_ptr<Statement> matchBlockStatement();
//shared_ptr<Statement> matchReturnStatement();
shared_ptr<StatementInvalid> matchInvalidStatement();
/*shared_ptr<Statement> matchExpressionStatement();
shared_ptr<Expression> term(); // +, -
shared_ptr<Expression> nextExpression();
/*shared_ptr<Expression> term(); // +, -
shared_ptr<Expression> factor(); // *, /, %
shared_ptr<Expression> primary(); // integer, ()
shared_ptr<Expression> matchInteger();
shared_ptr<Expression> matchGrouping();
shared_ptr<Expression> matchBinary(shared_ptr<Expression> left);
shared_ptr<Expression> matchBinary(shared_ptr<Expression> left);*/
bool matchesTokenKinds(vector<Token::Kind> kinds);
*/
public:
Parser(vector<shared_ptr<Token>> tokens);

79
src/Statement.cpp
View File

@@ -1,8 +1,5 @@
#include "Statement.h"
/*Statement::Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression, shared_ptr<Statement> blockStatement, vector<shared_ptr<Statement>> statements, string name):
kind(kind), token(token), expression(expression), blockStatement(blockStatement), statements(statements), name(name) {
}*/
Statement::Statement(Kind kind): kind(kind) {
}
@@ -10,56 +7,12 @@ Statement::Kind Statement::getKind() {
return kind;
}
/*shared_ptr<Token> Statement::getToken() {
return token;
}*/
/*shared_ptr<Expression> Statement::getExpression() {
return expression;
}*/
/*shared_ptr<Statement> Statement::getBlockStatement() {
return blockStatement;
}*/
/*vector<shared_ptr<Statement>> Statement::getStatements() {
return statements;
}*/
/*string Statement::getName() {
return name;
}*/
bool Statement::isValid() {
return kind != Statement::Kind::INVALID;
}
string Statement::toString() {
/*switch (kind) {
case EXPRESSION:
return expression->toString();
case BLOCK: {
string value;
for (int i=0; i<statements.size(); i++) {
value += statements.at(i)->toString();
if (i < statements.size() - 1)
value += "\n";
}
return value;
}
case FUNCTION_DECLARATION:
return "FUNCTION " + name + "\n" + blockStatement->toString() + "\n;";
case RETURN: {
string value = "RETURN";
if (expression != nullptr) {
value += " " + expression->toString();
}
return value;
}
case INVALID:
return "INVALID";
}*/
return "abc";
return "STATEMENT";
}
//
@@ -72,6 +25,10 @@ string StatementFunctionDeclaration::getName() {
return name;
}
string StatementFunctionDeclaration::toString() {
return "FUNCTION(" + name + ")\n" + statementBlock->toString() + "\n;";
}
shared_ptr<StatementBlock> StatementFunctionDeclaration::getStatementBlock() {
return statementBlock;
}
@@ -86,6 +43,13 @@ vector<shared_ptr<Statement>> StatementBlock::getStatements() {
return statements;
}
string StatementBlock::toString() {
string value;
for (int i=0; i<statements.size(); i++)
value += statements.at(i)->toString();
return value;
}
//
// StatementReturn
StatementReturn::StatementReturn(shared_ptr<Expression> expression):
@@ -97,6 +61,13 @@ shared_ptr<Expression> StatementReturn::getExpression() {
return expression;
}
string StatementReturn::toString() {
string value = "RETURN";
if (expression != nullptr)
value += "(" + expression->toString() + ")";
return value;
}
//
// StatementExpression
StatementExpression::StatementExpression(shared_ptr<Expression> expression):
@@ -107,8 +78,16 @@ shared_ptr<Expression> StatementExpression::getExpression() {
return expression;
}
string StatementExpression::toString() {
return "EXPRESSION(" + expression->toString() + ")";
}
//
// StatementInvalid
StatementInvalid::StatementInvalid():
Statement(Statement::Kind::INVALID) {
StatementInvalid::StatementInvalid(shared_ptr<Token> token):
Statement(Statement::Kind::INVALID), token(token) {
}
string StatementInvalid::toString() {
return "Invalid token " + token->toString() + " at " + to_string(token->getLine()) + ":" + to_string(token->getColumn()) + "\n";
}

26
src/Statement.h
View File

@@ -26,23 +26,12 @@ public:
private:
Kind kind;
//shared_ptr<Token> token;
//shared_ptr<Expression> expression;
//shared_ptr<Statement> blockStatement;
//vector<shared_ptr<Statement>> statements;
//string name;
public:
Statement(Kind kind);
//Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression, shared_ptr<Statement> blockStatement, vector<shared_ptr<Statement>> statements, string name);
Kind getKind();
//shared_ptr<Token> getToken();
//shared_ptr<Expression> getExpression();
//shared_ptr<Statement> getBlockStatement();
//vector<shared_ptr<Statement>> getStatements();
//string getName();
bool isValid();
string toString();
virtual string toString();
};
class StatementFunctionDeclaration: public Statement {
@@ -54,6 +43,7 @@ public:
StatementFunctionDeclaration(string name, shared_ptr<StatementBlock> statementBlock);
string getName();
shared_ptr<StatementBlock> getStatementBlock();
string toString() override;
};
class StatementBlock: public Statement {
@@ -63,6 +53,7 @@ private:
public:
StatementBlock(vector<shared_ptr<Statement>> statements);
vector<shared_ptr<Statement>> getStatements();
string toString() override;
};
class StatementReturn: public Statement {
@@ -72,6 +63,7 @@ private:
public:
StatementReturn(shared_ptr<Expression> expression);
shared_ptr<Expression> getExpression();
string toString() override;
};
class StatementExpression: public Statement {
@@ -81,16 +73,16 @@ private:
public:
StatementExpression(shared_ptr<Expression> expression);
shared_ptr<Expression> getExpression();
string toString() override;
};
class StatementInvalid: public Statement {
//private:
// string message;
private:
shared_ptr<Token> token;
public:
StatementInvalid();
//StatementInvalid(string message);
//string getMessage();
StatementInvalid(shared_ptr<Token> token);
string toString() override;
};
#endif