wip

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;
-}
+}*/

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

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;
+            //cerr << "Unexpected token '" << statement->getToken()->getLexme() << "' at " << statement->getToken()->getLine() << ":" << statement->getToken()->getColumn() << endl;
-            return vector<shared_ptr<Statement>>();
+            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() {
+/*shared_ptr<Statement> Parser::matchReturnStatement() {
-    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>>(), "");
     
     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() {
+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<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;
-}
+}*/

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> matchFunctionDeclarationStatement();
-    shared_ptr<Statement> matchBlockStatement();
+    //shared_ptr<Statement> matchBlockStatement();
-    shared_ptr<Statement> matchReturnStatement();
+    //shared_ptr<Statement> matchReturnStatement();
-    shared_ptr<Statement> matchInvalidStatement();
+    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();
 };
 

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) {
+}

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<Token> token;
-    shared_ptr<Expression> expression;
+    //shared_ptr<Expression> expression;
-    shared_ptr<Statement> blockStatement;
+    //shared_ptr<Statement> blockStatement;
-    vector<shared_ptr<Statement>> statements;
+    //vector<shared_ptr<Statement>> statements;
-    string name;
+    //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<Token> getToken();
-    shared_ptr<Expression> getExpression();
+    //shared_ptr<Expression> getExpression();
-    shared_ptr<Statement> getBlockStatement();
+    //shared_ptr<Statement> getBlockStatement();
-    vector<shared_ptr<Statement>> getStatements();
+    //vector<shared_ptr<Statement>> getStatements();
-    string getName();
+    //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

src/main.cpp

@@ -43,15 +43,12 @@ int main(int argc, char **argv) {
     }
     std::cout << std::endl;
 
-    //Parser parser(tokens);
+    Parser parser(tokens);
-    //vector<shared_ptr<Statement>> statements = parser.getStatements();
+    vector<shared_ptr<Statement>> statements = parser.getStatements();
-    //if (statements.empty()) {
+    for (shared_ptr<Statement> &statement : statements) {
-    //    exit(1);
+        cout << statement->toString();
-    //}
+        cout << endl;
-    //for (shared_ptr<Statement> &statement : statements) {
+    }
-    //    cout << statement->toString();
-    //    cout << endl;
-    //}
 
     //ModuleBuilder moduleBuilder(statements);
     //shared_ptr<llvm::Module> module = moduleBuilder.getModule();