Implemented value assignment

src/Compiler/ModuleBuilder.cpp

@@ -10,6 +10,7 @@
 
 #include "Parser/Statement/StatementFunction.h"
 #include "Parser/Statement/StatementVariable.h"
+#include "Parser/Statement/StatementAssignment.h"
 #include "Parser/Statement/StatementReturn.h"
 #include "Parser/Statement/StatementExpression.h"
 #include "Parser/Statement/StatementLoop.h"
@@ -44,6 +45,9 @@ void ModuleBuilder::buildStatement(shared_ptr<Statement> statement) {
         case StatementKind::VARIABLE:
             buildVarDeclaration(dynamic_pointer_cast<StatementVariable>(statement));
             break;
+        case StatementKind::ASSIGNMENT:
+            buildAssignment(dynamic_pointer_cast<StatementAssignment>(statement));
+            break;
         case StatementKind::BLOCK:
             buildBlock(dynamic_pointer_cast<StatementBlock>(statement));
             break;
@@ -111,6 +115,15 @@ void ModuleBuilder::buildVarDeclaration(shared_ptr<StatementVariable> statement)
     builder->CreateStore(value, alloca);
 }
 
+void ModuleBuilder::buildAssignment(shared_ptr<StatementAssignment> statement) {
+    llvm::AllocaInst *alloca = allocaMap[statement->getName()];
+    if (alloca == nullptr)
+        failWithMessage("Variable " + statement->getName() + " not defined");
+
+    llvm::Value *value = valueForExpression(statement->getExpression());
+    builder->CreateStore(value, alloca);
+}
+
 void ModuleBuilder::buildBlock(shared_ptr<StatementBlock> statement) {
     for (shared_ptr<Statement> &innerStatement : statement->getStatements())
         buildStatement(innerStatement);

src/Compiler/ModuleBuilder.h

@@ -24,6 +24,7 @@ enum class ExpressionBinaryOperation;
 class Statement;
 class StatementFunction;
 class StatementVariable;
+class StatementAssignment;
 class StatementReturn;
 class StatementExpression;
 class StatementLoop;
@@ -53,6 +54,7 @@ private:
     void buildStatement(shared_ptr<Statement> statement);
     void buildFunctionDeclaration(shared_ptr<StatementFunction> statement);
     void buildVarDeclaration(shared_ptr<StatementVariable> statement);
+    void buildAssignment(shared_ptr<StatementAssignment> statement);
     void buildBlock(shared_ptr<StatementBlock> statement);
     void buildReturn(shared_ptr<StatementReturn> statement);
     void buildLoop(shared_ptr<StatementLoop> statement);

src/Parser/Parser.cpp

@@ -11,6 +11,7 @@
 
 #include "Parser/Statement/StatementFunction.h"
 #include "Parser/Statement/StatementVariable.h"
+#include "Parser/Statement/StatementAssignment.h"
 #include "Parser/Statement/StatementReturn.h"
 #include "Parser/Statement/StatementExpression.h"
 #include "Parser/Statement/StatementMetaExternFunction.h"
@@ -51,6 +52,10 @@ shared_ptr<Statement> Parser::nextStatement() {
     if (statement != nullptr)
         return statement;
 
+    statement = matchStatementAssignment();
+    if (statement != nullptr)
+        return statement;
+
     statement = matchStatementReturn();
     if (statement != nullptr)
         return statement;
@@ -163,6 +168,25 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
     return make_shared<StatementVariable>(identifierToken->getLexme(), valueType, expression);
 }
 
+shared_ptr<Statement> Parser::matchStatementAssignment() {
+    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::LEFT_ARROW}, true, false))
+        return nullptr;
+     
+    shared_ptr<Token> identifierToken = tokens.at(currentIndex);
+    currentIndex++; // identifier
+    currentIndex++; // arrow
+
+    shared_ptr<Expression> expression = nextExpression();
+    if (expression == nullptr || !expression->isValid())
+        return matchStatementInvalid("Expected expression");
+
+    // Expect new line
+    if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, false, true))
+        return matchStatementInvalid("Expected a new line after variable declaration");
+
+    return make_shared<StatementAssignment>(identifierToken->getLexme(), expression);
+}
+
 shared_ptr<Statement> Parser::matchStatementReturn() {
     if (!tryMatchingTokenKinds({TokenKind::RETURN}, true, true))
         return nullptr;
@@ -396,14 +420,14 @@ shared_ptr<Expression> Parser::matchPrimary() {
     if (expression != nullptr)
         return expression;
 
-    expression = matchExpressionVariable();
-    if (expression != nullptr)
-    return expression;
-        
     expression = matchExpressionCall();
     if (expression != nullptr)
         return expression;
 
+    expression = matchExpressionVariable();
+    if (expression != nullptr)
+    return expression;
+
     return nullptr;
 }
 

src/Parser/Parser.h

@@ -21,6 +21,7 @@ private:
     shared_ptr<Statement> nextStatement();
     shared_ptr<Statement> matchStatementFunction();
     shared_ptr<Statement> matchStatementVariable();
+    shared_ptr<Statement> matchStatementAssignment();
     shared_ptr<Statement> matchStatementReturn();
     shared_ptr<Statement> matchStatementLoop();
     shared_ptr<Statement> matchStatementExpression();

src/Parser/Statement/Statement.h

@@ -13,6 +13,7 @@ enum class StatementKind {
     RETURN,
     FUNCTION,
     VARIABLE,
+    ASSIGNMENT,
     LOOP,
     META_EXTERN_FUNCTION,
     INVALID

src/Parser/Statement/StatementAssignment.cpp

@@ -0,0 +1,12 @@
+#include "StatementAssignment.h"
+
+StatementAssignment::StatementAssignment(string name, shared_ptr<Expression> expression):
+Statement(StatementKind::ASSIGNMENT), name(name), expression(expression) { }
+
+string StatementAssignment::getName() {
+    return name;
+}
+
+shared_ptr<Expression> StatementAssignment::getExpression() {
+    return expression;
+}

src/Parser/Statement/StatementAssignment.h

@@ -0,0 +1,14 @@
+#include "Parser/Statement/Statement.h"
+
+class Expression;
+
+class StatementAssignment: public Statement {
+private:
+    string name;
+    shared_ptr<Expression> expression;
+
+public:
+    StatementAssignment(string name, shared_ptr<Expression> expression);
+    string getName();
+    shared_ptr<Expression> getExpression();
+};

test.brc

@@ -1,5 +1,17 @@
-test fun: num1 sint32, num2 sint32
+@extern putchar fun: character sint32 -> sint32
-    rep num3 sint32 <- 5, true, num1 < num2
+
-        abc sint32 <- 5
+stuff fun: num1 sint32, num2 sint32
+    ? num1 > num2
+        putchar(0x54)
+        
+    :
+        putchar(0x4e)
+        
     ;
+    putchar(0x0a)
+;
+
+main fun -> sint32
+    stuff(8, 108)
+    ret 42
 ;