wip

2025-06-03 12:04:43 +09:00
parent f5952ad3ee
commit 4665a1f5f5
7 changed files with 184 additions and 74 deletions
--- a/src/ModuleBuilder.cpp
+++ b/src/ModuleBuilder.cpp
@@ -3,7 +3,7 @@
 #include "llvm/IR/Constants.h"
 #include "llvm/Support/raw_ostream.h"

-ModuleBuilder::ModuleBuilder(vector<shared_ptr<Statement>> statements): statements(statements) {
+/*ModuleBuilder::ModuleBuilder(vector<shared_ptr<Statement>> statements): statements(statements) {
    context = make_shared<llvm::LLVMContext>();
    module = make_shared<llvm::Module>("dummy", *context);
    builder = make_shared<llvm::IRBuilder<>>(*context);
@@ -88,4 +88,4 @@ shared_ptr<llvm::Module> ModuleBuilder::getModule() {
        buildCodeForStatement(statement);
    }
    return module;
-}
+}*/
--- a/src/ModuleBuilder.h
+++ b/src/ModuleBuilder.h
@@ -10,7 +10,7 @@
 using namespace std;

 class ModuleBuilder {
-private:
+/*private:
    shared_ptr<llvm::LLVMContext> context;
    shared_ptr<llvm::Module> module;
    shared_ptr<llvm::IRBuilder<>> builder;
@@ -29,7 +29,7 @@ private:

 public:
    ModuleBuilder(vector<shared_ptr<Statement>> statements);
-    shared_ptr<llvm::Module> getModule();
+    shared_ptr<llvm::Module> getModule();*/
 };

 #endif
--- a/src/Parser.cpp
+++ b/src/Parser.cpp
@@ -1,17 +1,19 @@
 #include "Parser.h"

-Parser::Parser(vector<Token> tokens): tokens(tokens) {
+Parser::Parser(vector<shared_ptr<Token>> tokens): tokens(tokens) {
 }

 vector<shared_ptr<Statement>> Parser::getStatements() {
    vector<shared_ptr<Statement>> statements;

-    while (tokens.at(currentIndex).getKind() != Token::Kind::END) {
+    while (tokens.at(currentIndex)->getKind() != Token::Kind::END) {
        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;
-            return vector<shared_ptr<Statement>>();
+            //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);
    }
@@ -23,7 +25,7 @@ vector<shared_ptr<Statement>> Parser::getStatements() {
 // Statement
 //
 shared_ptr<Statement> Parser::nextStatement() {
-    {
+    /*{
        shared_ptr<Statement> statement = matchFunctionDeclarationStatement();
        if (statement->isValid())
            return statement;
@@ -39,12 +41,12 @@ shared_ptr<Statement> Parser::nextStatement() {
        shared_ptr<Statement> statement = matchExpressionStatement();
        if (statement->isValid())
            return statement;
-    }
+    }*/

    return matchInvalidStatement();
 }

-shared_ptr<Statement> Parser::matchFunctionDeclarationStatement() {
+/*shared_ptr<Statement> Parser::matchFunctionDeclarationStatement() {
    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>>(), "");

@@ -53,7 +55,7 @@ shared_ptr<Statement> Parser::matchFunctionDeclarationStatement() {
    currentIndex++; // skip colon
    currentIndex++; // skip fun

-    while (tokens.at(currentIndex).getKind() != Token::Kind::NEW_LINE) {
+    while (tokens.at(currentIndex)->getKind() != Token::Kind::NEW_LINE) {
        currentIndex++;
    }
    currentIndex++; // new line
@@ -62,12 +64,12 @@ shared_ptr<Statement> Parser::matchFunctionDeclarationStatement() {
        return blockStatement;
    
    return make_shared<Statement>(Statement::Kind::FUNCTION_DECLARATION, nullptr, nullptr, blockStatement, vector<shared_ptr<Statement>>(), identifierToken.getLexme());
-}
+}*/

-shared_ptr<Statement> Parser::matchBlockStatement() {
+/*shared_ptr<Statement> Parser::matchBlockStatement() {
    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();
        if (!statement->isValid())
            return statement;
@@ -75,17 +77,17 @@ shared_ptr<Statement> Parser::matchBlockStatement() {
    }
    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>>(), "");
    
-    if (tokens.at(currentIndex).getKind() == Token::Kind::NEW_LINE)
+    if (tokens.at(currentIndex)->getKind() == Token::Kind::NEW_LINE)
        currentIndex++;

    return make_shared<Statement>(Statement::Kind::BLOCK, nullptr, nullptr, nullptr, statements, "");
-}
+}*/

-shared_ptr<Statement> Parser::matchReturnStatement() {
-    if (tokens.at(currentIndex).getKind() != Token::Kind::RETURN)
+/*shared_ptr<Statement> Parser::matchReturnStatement() {
+    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>>(), "");
    
    currentIndex++;
@@ -94,37 +96,38 @@ shared_ptr<Statement> Parser::matchReturnStatement() {
    if (!expression->isValid())
        expression = nullptr;
    
-    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>>(), "");
    
    currentIndex++; // new line
    
    return make_shared<Statement>(Statement::Kind::RETURN, nullptr, expression, nullptr, vector<shared_ptr<Statement>>(), "");
-}
+}*/

-shared_ptr<Statement> Parser::matchInvalidStatement() {
-    return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, vector<shared_ptr<Statement>>(), "");
+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>();
 }

 //
 // Expression
 //
-shared_ptr<Statement> Parser::matchExpressionStatement() {
+/*shared_ptr<Statement> Parser::matchExpressionStatement() {
    shared_ptr<Expression> expression = term();
-    if (expression->isValid() && tokens.at(currentIndex).isOfKind({Token::Kind::NEW_LINE, Token::Kind::END})) {
+    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();
    if (!expression->isValid())
        return expression;

-    while (tokens.at(currentIndex).isOfKind({Token::Kind::PLUS, Token::Kind::MINUS})) {
+    while (tokens.at(currentIndex)->isOfKind({Token::Kind::PLUS, Token::Kind::MINUS})) {
        expression = matchBinary(expression);
    }

@@ -136,7 +139,7 @@ shared_ptr<Expression> Parser::factor() {
    if (!expression->isValid())
        return expression;

-    while (tokens.at(currentIndex).isOfKind({Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT})) {
+    while (tokens.at(currentIndex)->isOfKind({Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT})) {
        expression = matchBinary(expression);
    }

@@ -177,7 +180,7 @@ shared_ptr<Expression> Parser::matchGrouping() {
        // has grouped expression failed?
        if (!expression->isValid())
            return expression;
-        if (tokens.at(currentIndex).getKind() == Token::Kind::RIGHT_PAREN) {
+        if (tokens.at(currentIndex)->getKind() == Token::Kind::RIGHT_PAREN) {
            currentIndex++;
            return make_shared<Expression>(Expression::Kind::GROUPING, token, expression, nullptr);
        }
@@ -205,8 +208,8 @@ bool Parser::matchesTokenKinds(vector<Token::Kind> kinds) {
        return false;

    for (int i=0; i<kinds.size(); i++) {
-        if (kinds.at(i) != tokens.at(currentIndex + i).getKind())
+        if (kinds.at(i) != tokens.at(currentIndex + i)->getKind())
            return false;
    }
    return true;
-}
+}*/
--- a/src/Parser.h
+++ b/src/Parser.h
@@ -11,17 +11,17 @@ using namespace std;

 class Parser {
 private:
-    vector<Token> tokens;
+    vector<shared_ptr<Token>> tokens;
    int currentIndex = 0;

    shared_ptr<Statement> nextStatement();

-    shared_ptr<Statement> matchFunctionDeclarationStatement();
-    shared_ptr<Statement> matchBlockStatement();
-    shared_ptr<Statement> matchReturnStatement();
-    shared_ptr<Statement> matchInvalidStatement();
+    //shared_ptr<Statement> matchFunctionDeclarationStatement();
+    //shared_ptr<Statement> matchBlockStatement();
+    //shared_ptr<Statement> matchReturnStatement();
+    shared_ptr<StatementInvalid> matchInvalidStatement();

-    shared_ptr<Statement> matchExpressionStatement();
+    /*shared_ptr<Statement> matchExpressionStatement();
    shared_ptr<Expression> term(); // +, -
    shared_ptr<Expression> factor(); // *, /, %
    shared_ptr<Expression> primary(); // integer, ()
@@ -31,9 +31,10 @@ private:
    shared_ptr<Expression> matchBinary(shared_ptr<Expression> left);

    bool matchesTokenKinds(vector<Token::Kind> kinds);
+    */

 public:
-    Parser(vector<Token> tokens);
+    Parser(vector<shared_ptr<Token>> tokens);
    vector<shared_ptr<Statement>> getStatements();
 };

--- a/src/Statement.cpp
+++ b/src/Statement.cpp
@@ -1,39 +1,41 @@
 #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):
+/*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::Kind Statement::getKind() {
    return kind;
 }

-shared_ptr<Token> Statement::getToken() {
+/*shared_ptr<Token> Statement::getToken() {
    return token;
-}
+}*/

-shared_ptr<Expression> Statement::getExpression() {
+/*shared_ptr<Expression> Statement::getExpression() {
    return expression;
-}
+}*/

-shared_ptr<Statement> Statement::getBlockStatement() {
+/*shared_ptr<Statement> Statement::getBlockStatement() {
    return blockStatement;
-}
+}*/

-vector<shared_ptr<Statement>> Statement::getStatements() {
+/*vector<shared_ptr<Statement>> Statement::getStatements() {
    return statements;
-}
+}*/

-string Statement::getName() {
+/*string Statement::getName() {
    return name;
-}
+}*/

 bool Statement::isValid() {
    return kind != Statement::Kind::INVALID;
 }

 string Statement::toString() {
-    switch (kind) {
+    /*switch (kind) {
        case EXPRESSION:
            return expression->toString();
        case BLOCK: {
@@ -56,5 +58,57 @@ string Statement::toString() {
        }
        case INVALID:
            return "INVALID";
-    }
-}
+    }*/
+   return "abc";
+}
+
+//
+// StatementFunctionDeclaration
+StatementFunctionDeclaration::StatementFunctionDeclaration(string name, shared_ptr<StatementBlock> statementBlock):
+    Statement(Statement::Kind::FUNCTION_DECLARATION), name(name), statementBlock(statementBlock) {
+}
+
+string StatementFunctionDeclaration::getName() {
+    return name;
+}
+
+shared_ptr<StatementBlock> StatementFunctionDeclaration::getStatementBlock() {
+    return statementBlock;
+}
+
+//
+// StatementBlock
+StatementBlock::StatementBlock(vector<shared_ptr<Statement>> statements):
+    Statement(Statement::Kind::BLOCK), statements(statements) {
+}
+
+vector<shared_ptr<Statement>> StatementBlock::getStatements() {
+    return statements;
+}
+
+//
+// StatementReturn
+StatementReturn::StatementReturn(shared_ptr<Expression> expression):
+    Statement(Statement::Kind::RETURN), expression(expression) {
+
+}
+
+shared_ptr<Expression> StatementReturn::getExpression() {
+    return expression;
+}
+
+//
+// StatementExpression
+StatementExpression::StatementExpression(shared_ptr<Expression> expression):
+    Statement(Statement::Kind::EXPRESSION), expression(expression) {
+}
+
+shared_ptr<Expression> StatementExpression::getExpression() {
+    return expression;
+}
+
+//
+// StatementInvalid
+StatementInvalid::StatementInvalid():
+    Statement(Statement::Kind::INVALID) {
+}
--- a/src/Statement.h
+++ b/src/Statement.h
@@ -8,6 +8,12 @@

 using namespace std;

+class Statement;
+class StatementBlock;
+class StatementReturn;
+class StatementExpression;
+class StatementInvalid;
+
 class Statement {
 public:
    enum Kind {
@@ -20,22 +26,71 @@ public:

 private:
    Kind kind;
-    shared_ptr<Token> token;
-    shared_ptr<Expression> expression;
-    shared_ptr<Statement> blockStatement;
-    vector<shared_ptr<Statement>> statements;
-    string name;
+    //shared_ptr<Token> token;
+    //shared_ptr<Expression> expression;
+    //shared_ptr<Statement> blockStatement;
+    //vector<shared_ptr<Statement>> statements;
+    //string name;

 public:
-    Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression, shared_ptr<Statement> blockStatement, vector<shared_ptr<Statement>> statements, string name);
+    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();
+    //shared_ptr<Token> getToken();
+    //shared_ptr<Expression> getExpression();
+    //shared_ptr<Statement> getBlockStatement();
+    //vector<shared_ptr<Statement>> getStatements();
+    //string getName();
    bool isValid();
    string toString();
 };

+class StatementFunctionDeclaration: public Statement {
+private:
+    string name;
+    shared_ptr<StatementBlock> statementBlock;
+
+public:
+    StatementFunctionDeclaration(string name, shared_ptr<StatementBlock> statementBlock);
+    string getName();
+    shared_ptr<StatementBlock> getStatementBlock();
+};
+
+class StatementBlock: public Statement {
+private:
+    vector<shared_ptr<Statement>> statements;
+
+public:
+    StatementBlock(vector<shared_ptr<Statement>> statements);
+    vector<shared_ptr<Statement>> getStatements();
+};
+
+class StatementReturn: public Statement {
+private:
+    shared_ptr<Expression> expression;
+
+public:
+    StatementReturn(shared_ptr<Expression> expression);
+    shared_ptr<Expression> getExpression();
+};
+
+class StatementExpression: public Statement {
+private:
+    shared_ptr<Expression> expression;
+
+public:
+    StatementExpression(shared_ptr<Expression> expression);
+    shared_ptr<Expression> getExpression();
+};
+
+class StatementInvalid: public Statement {
+//private:
+//    string message;
+
+public:
+    StatementInvalid();
+    //StatementInvalid(string message);
+    //string getMessage();
+};
+
 #endif
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -43,15 +43,12 @@ int main(int argc, char **argv) {
    }
    std::cout << std::endl;

-    //Parser parser(tokens);
-    //vector<shared_ptr<Statement>> statements = parser.getStatements();
-    //if (statements.empty()) {
-    //    exit(1);
-    //}
-    //for (shared_ptr<Statement> &statement : statements) {
-    //    cout << statement->toString();
-    //    cout << endl;
-    //}
+    Parser parser(tokens);
+    vector<shared_ptr<Statement>> statements = parser.getStatements();
+    for (shared_ptr<Statement> &statement : statements) {
+        cout << statement->toString();
+        cout << endl;
+    }

    //ModuleBuilder moduleBuilder(statements);
    //shared_ptr<llvm::Module> module = moduleBuilder.getModule();