From 84c1e823cb593c865ae6ec47001da6c56177b81b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 3 Jun 2025 23:30:15 +0900 Subject: [PATCH] Updated statement matching --- src/Parser.cpp | 117 ++++++++++++++++++++++++---------------------- src/Parser.h | 17 ++++--- src/Statement.cpp | 79 ++++++++++++------------------- src/Statement.h | 26 ++++------- 4 files changed, 107 insertions(+), 132 deletions(-) diff --git a/src/Parser.cpp b/src/Parser.cpp index 9a1670c..8cf23f0 100644 --- a/src/Parser.cpp +++ b/src/Parser.cpp @@ -10,9 +10,7 @@ vector> Parser::getStatements() { shared_ptr 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>(); exit(1); } statements.push_back(statement); @@ -25,32 +23,28 @@ vector> Parser::getStatements() { // Statement // shared_ptr Parser::nextStatement() { - /*{ - shared_ptr statement = matchFunctionDeclarationStatement(); - if (statement->isValid()) - return statement; - } + shared_ptr statement; - { - shared_ptr statement = matchReturnStatement(); - if (statement->isValid()) - return statement; - } + statement = matchStatementFunctionDeclaration(); + if (statement != nullptr) + return statement; - { - shared_ptr 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 Parser::matchFunctionDeclarationStatement() { +shared_ptr Parser::matchStatementFunctionDeclaration() { if (!matchesTokenKinds({Token::Kind::IDENTIFIER, Token::Kind::COLON, Token::Kind::FUNCTION})) - return make_shared(Statement::Kind::INVALID, make_shared(tokens.at(currentIndex)), nullptr, nullptr, vector>(), ""); + return nullptr; - Token identifierToken = tokens.at(currentIndex); + shared_ptr identifierToken = tokens.at(currentIndex); currentIndex++; currentIndex++; // skip colon currentIndex++; // skip fun @@ -59,68 +53,78 @@ shared_ptr Parser::nextStatement() { currentIndex++; } currentIndex++; // new line - shared_ptr blockStatement = matchBlockStatement(); - if (!blockStatement->isValid()) - return blockStatement; - - return make_shared(Statement::Kind::FUNCTION_DECLARATION, nullptr, nullptr, blockStatement, vector>(), identifierToken.getLexme()); -}*/ + shared_ptr statementBlock = matchStatementBlock(); + if (statementBlock == nullptr) + return matchStatementInvalid(); + else if (!statementBlock->isValid()) + return statementBlock; + else + return make_shared(identifierToken->getLexme(), dynamic_pointer_cast(statementBlock)); +} -/*shared_ptr Parser::matchBlockStatement() { +shared_ptr Parser::matchStatementBlock() { vector> statements; while (tokens.at(currentIndex)->getKind() != Token::Kind::SEMICOLON) { shared_ptr 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::Kind::INVALID, make_shared(tokens.at(currentIndex)), nullptr, nullptr, vector>(), ""); + return matchStatementInvalid(); if (tokens.at(currentIndex)->getKind() == Token::Kind::NEW_LINE) currentIndex++; - return make_shared(Statement::Kind::BLOCK, nullptr, nullptr, nullptr, statements, ""); -}*/ + return make_shared(statements); +} -/*shared_ptr Parser::matchReturnStatement() { +shared_ptr Parser::matchStatementReturn() { if (tokens.at(currentIndex)->getKind() != Token::Kind::RETURN) - return make_shared(Statement::Kind::INVALID, make_shared(tokens.at(currentIndex)), nullptr, nullptr, vector>(), ""); + return nullptr; currentIndex++; - shared_ptr expression = term(); - if (!expression->isValid()) - expression = nullptr; - + shared_ptr expression = nextExpression(); + if (expression != nullptr && !expression->isValid()) + return matchStatementInvalid(); + if (tokens.at(currentIndex)->getKind() != Token::Kind::NEW_LINE) - return make_shared(Statement::Kind::INVALID, make_shared(tokens.at(currentIndex)), nullptr, nullptr, vector>(), ""); + return matchStatementInvalid(); currentIndex++; // new line - return make_shared(Statement::Kind::RETURN, nullptr, expression, nullptr, vector>(), ""); -}*/ + return make_shared(expression); +} -shared_ptr Parser::matchInvalidStatement() { - //return make_shared(Statement::Kind::INVALID, make_shared(tokens.at(currentIndex)), nullptr, nullptr, vector>(), ""); - return make_shared(); +shared_ptr Parser::matchStatementExpression() { + shared_ptr expression = nextExpression(); + + if (expression == nullptr) + return nullptr; + else if (!expression->isValid()) + return make_shared(tokens.at(currentIndex)); + + currentIndex++; + return make_shared(expression); +} + +shared_ptr Parser::matchStatementInvalid() { + return make_shared(tokens.at(currentIndex)); } // // Expression // -/*shared_ptr Parser::matchExpressionStatement() { - shared_ptr expression = term(); - if (expression->isValid() && tokens.at(currentIndex)->isOfKind({Token::Kind::NEW_LINE, Token::Kind::END})) { - currentIndex++; - return make_shared(Statement::Kind::EXPRESSION, nullptr, expression, nullptr, vector>(), ""); - } else { - return make_shared(Statement::Kind::INVALID, make_shared(tokens.at(currentIndex)), expression, nullptr, vector>(), ""); - } -}*/ +shared_ptr Parser::nextExpression() { + return nullptr; +} /*shared_ptr Parser::term() { shared_ptr expression = factor(); @@ -201,7 +205,7 @@ shared_ptr Parser::matchBinary(shared_ptr left) { } return make_shared(Expression::Kind::INVALID, token, nullptr, nullptr); -} +}*/ bool Parser::matchesTokenKinds(vector kinds) { if (currentIndex + kinds.size() >= tokens.size()) @@ -211,5 +215,6 @@ bool Parser::matchesTokenKinds(vector kinds) { if (kinds.at(i) != tokens.at(currentIndex + i)->getKind()) return false; } + return true; -}*/ +} diff --git a/src/Parser.h b/src/Parser.h index f271f6e..6749622 100644 --- a/src/Parser.h +++ b/src/Parser.h @@ -15,23 +15,22 @@ private: int currentIndex = 0; shared_ptr nextStatement(); + shared_ptr matchStatementFunctionDeclaration(); + shared_ptr matchStatementBlock(); + shared_ptr matchStatementReturn(); + shared_ptr matchStatementExpression(); + shared_ptr matchStatementInvalid(); - //shared_ptr matchFunctionDeclarationStatement(); - //shared_ptr matchBlockStatement(); - //shared_ptr matchReturnStatement(); - shared_ptr matchInvalidStatement(); - - /*shared_ptr matchExpressionStatement(); - shared_ptr term(); // +, - + shared_ptr nextExpression(); + /*shared_ptr term(); // +, - shared_ptr factor(); // *, /, % shared_ptr primary(); // integer, () shared_ptr matchInteger(); shared_ptr matchGrouping(); - shared_ptr matchBinary(shared_ptr left); + shared_ptr matchBinary(shared_ptr left);*/ bool matchesTokenKinds(vector kinds); - */ public: Parser(vector> tokens); diff --git a/src/Statement.cpp b/src/Statement.cpp index 8cb9ab4..7c096c3 100644 --- a/src/Statement.cpp +++ b/src/Statement.cpp @@ -1,8 +1,5 @@ #include "Statement.h" -/*Statement::Statement(Kind kind, shared_ptr token, shared_ptr expression, shared_ptr blockStatement, vector> 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 Statement::getToken() { - return token; -}*/ - -/*shared_ptr Statement::getExpression() { - return expression; -}*/ - -/*shared_ptr Statement::getBlockStatement() { - return blockStatement; -}*/ - -/*vector> 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; itoString(); - 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 StatementFunctionDeclaration::getStatementBlock() { return statementBlock; } @@ -86,6 +43,13 @@ vector> StatementBlock::getStatements() { return statements; } +string StatementBlock::toString() { + string value; + for (int i=0; itoString(); + return value; +} + // // StatementReturn StatementReturn::StatementReturn(shared_ptr expression): @@ -97,6 +61,13 @@ shared_ptr StatementReturn::getExpression() { return expression; } +string StatementReturn::toString() { + string value = "RETURN"; + if (expression != nullptr) + value += "(" + expression->toString() + ")"; + return value; +} + // // StatementExpression StatementExpression::StatementExpression(shared_ptr expression): @@ -107,8 +78,16 @@ shared_ptr StatementExpression::getExpression() { return expression; } +string StatementExpression::toString() { + return "EXPRESSION(" + expression->toString() + ")"; +} + // // StatementInvalid -StatementInvalid::StatementInvalid(): - Statement(Statement::Kind::INVALID) { +StatementInvalid::StatementInvalid(shared_ptr 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"; } diff --git a/src/Statement.h b/src/Statement.h index eb24d73..01aac2c 100644 --- a/src/Statement.h +++ b/src/Statement.h @@ -26,23 +26,12 @@ public: private: Kind kind; - //shared_ptr token; - //shared_ptr expression; - //shared_ptr blockStatement; - //vector> statements; - //string name; public: Statement(Kind kind); - //Statement(Kind kind, shared_ptr token, shared_ptr expression, shared_ptr blockStatement, vector> statements, string name); Kind getKind(); - //shared_ptr getToken(); - //shared_ptr getExpression(); - //shared_ptr getBlockStatement(); - //vector> 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); string getName(); shared_ptr getStatementBlock(); + string toString() override; }; class StatementBlock: public Statement { @@ -63,6 +53,7 @@ private: public: StatementBlock(vector> statements); vector> getStatements(); + string toString() override; }; class StatementReturn: public Statement { @@ -72,6 +63,7 @@ private: public: StatementReturn(shared_ptr expression); shared_ptr getExpression(); + string toString() override; }; class StatementExpression: public Statement { @@ -81,16 +73,16 @@ private: public: StatementExpression(shared_ptr expression); shared_ptr getExpression(); + string toString() override; }; class StatementInvalid: public Statement { -//private: -// string message; +private: + shared_ptr token; public: - StatementInvalid(); - //StatementInvalid(string message); - //string getMessage(); + StatementInvalid(shared_ptr token); + string toString() override; }; #endif \ No newline at end of file