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

115
src/Parser.cpp
View File

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

17
src/Parser.h
View File

@@ -15,23 +15,22 @@ private:
int currentIndex = 0; int currentIndex = 0;
shared_ptr<Statement> nextStatement(); 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<Expression> nextExpression();
//shared_ptr<Statement> matchBlockStatement(); /*shared_ptr<Expression> term(); // +, -
//shared_ptr<Statement> matchReturnStatement();
shared_ptr<StatementInvalid> matchInvalidStatement();
/*shared_ptr<Statement> matchExpressionStatement();
shared_ptr<Expression> term(); // +, -
shared_ptr<Expression> factor(); // *, /, % shared_ptr<Expression> factor(); // *, /, %
shared_ptr<Expression> primary(); // integer, () shared_ptr<Expression> primary(); // integer, ()
shared_ptr<Expression> matchInteger(); shared_ptr<Expression> matchInteger();
shared_ptr<Expression> matchGrouping(); 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); bool matchesTokenKinds(vector<Token::Kind> kinds);
*/
public: public:
Parser(vector<shared_ptr<Token>> tokens); Parser(vector<shared_ptr<Token>> tokens);

79
src/Statement.cpp
View File

@@ -1,8 +1,5 @@
#include "Statement.h" #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) { Statement::Statement(Kind kind): kind(kind) {
} }
@@ -10,56 +7,12 @@ Statement::Kind Statement::getKind() {
return kind; 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() { bool Statement::isValid() {
return kind != Statement::Kind::INVALID; return kind != Statement::Kind::INVALID;
} }
string Statement::toString() { string Statement::toString() {
/*switch (kind) { return "STATEMENT";
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";
} }
// //
@@ -72,6 +25,10 @@ string StatementFunctionDeclaration::getName() {
return name; return name;
} }
string StatementFunctionDeclaration::toString() {
return "FUNCTION(" + name + ")\n" + statementBlock->toString() + "\n;";
}
shared_ptr<StatementBlock> StatementFunctionDeclaration::getStatementBlock() { shared_ptr<StatementBlock> StatementFunctionDeclaration::getStatementBlock() {
return statementBlock; return statementBlock;
} }
@@ -86,6 +43,13 @@ vector<shared_ptr<Statement>> StatementBlock::getStatements() {
return statements; 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::StatementReturn(shared_ptr<Expression> expression): StatementReturn::StatementReturn(shared_ptr<Expression> expression):
@@ -97,6 +61,13 @@ shared_ptr<Expression> StatementReturn::getExpression() {
return expression; return expression;
} }
string StatementReturn::toString() {
string value = "RETURN";
if (expression != nullptr)
value += "(" + expression->toString() + ")";
return value;
}
// //
// StatementExpression // StatementExpression
StatementExpression::StatementExpression(shared_ptr<Expression> expression): StatementExpression::StatementExpression(shared_ptr<Expression> expression):
@@ -107,8 +78,16 @@ shared_ptr<Expression> StatementExpression::getExpression() {
return expression; return expression;
} }
string StatementExpression::toString() {
return "EXPRESSION(" + expression->toString() + ")";
}
// //
// StatementInvalid // StatementInvalid
StatementInvalid::StatementInvalid(): StatementInvalid::StatementInvalid(shared_ptr<Token> token):
Statement(Statement::Kind::INVALID) { 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: private:
Kind kind; Kind kind;
//shared_ptr<Token> token;
//shared_ptr<Expression> expression;
//shared_ptr<Statement> blockStatement;
//vector<shared_ptr<Statement>> statements;
//string name;
public: public:
Statement(Kind kind); 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(); Kind getKind();
//shared_ptr<Token> getToken();
//shared_ptr<Expression> getExpression();
//shared_ptr<Statement> getBlockStatement();
//vector<shared_ptr<Statement>> getStatements();
//string getName();
bool isValid(); bool isValid();
string toString(); virtual string toString();
}; };
class StatementFunctionDeclaration: public Statement { class StatementFunctionDeclaration: public Statement {
@@ -54,6 +43,7 @@ public:
StatementFunctionDeclaration(string name, shared_ptr<StatementBlock> statementBlock); StatementFunctionDeclaration(string name, shared_ptr<StatementBlock> statementBlock);
string getName(); string getName();
shared_ptr<StatementBlock> getStatementBlock(); shared_ptr<StatementBlock> getStatementBlock();
string toString() override;
}; };
class StatementBlock: public Statement { class StatementBlock: public Statement {
@@ -63,6 +53,7 @@ private:
public: public:
StatementBlock(vector<shared_ptr<Statement>> statements); StatementBlock(vector<shared_ptr<Statement>> statements);
vector<shared_ptr<Statement>> getStatements(); vector<shared_ptr<Statement>> getStatements();
string toString() override;
}; };
class StatementReturn: public Statement { class StatementReturn: public Statement {
@@ -72,6 +63,7 @@ private:
public: public:
StatementReturn(shared_ptr<Expression> expression); StatementReturn(shared_ptr<Expression> expression);
shared_ptr<Expression> getExpression(); shared_ptr<Expression> getExpression();
string toString() override;
}; };
class StatementExpression: public Statement { class StatementExpression: public Statement {
@@ -81,16 +73,16 @@ private:
public: public:
StatementExpression(shared_ptr<Expression> expression); StatementExpression(shared_ptr<Expression> expression);
shared_ptr<Expression> getExpression(); shared_ptr<Expression> getExpression();
string toString() override;
}; };
class StatementInvalid: public Statement { class StatementInvalid: public Statement {
//private: private:
// string message; shared_ptr<Token> token;
public: public:
StatementInvalid(); StatementInvalid(shared_ptr<Token> token);
//StatementInvalid(string message); string toString() override;
//string getMessage();
}; };
#endif #endif