Variable loading seems to be working

src/Expression.cpp

@@ -23,7 +23,7 @@ string Expression::toString(int indent) {
 //
 // ExpressionBinary
 ExpressionBinary::ExpressionBinary(shared_ptr<Token> token, shared_ptr<Expression> left, shared_ptr<Expression> right):
-    Expression(ExpressionKind::BINARY, ValueType::VOID), left(left), right(right) {
+Expression(ExpressionKind::BINARY, ValueType::VOID), left(left), right(right) {
     // Types must match
     if (left->getValueType() != right->getValueType())
         exit(1);
@@ -124,7 +124,7 @@ string ExpressionBinary::toString(int indent) {
 //
 // ExpressionLiteral
 ExpressionLiteral::ExpressionLiteral(shared_ptr<Token> token):
-    Expression(ExpressionKind::LITERAL, ValueType::VOID) {
+Expression(ExpressionKind::LITERAL, ValueType::VOID) {
     switch (token->getKind()) {
         case TokenKind::BOOL:
             boolValue = token->getLexme().compare("true") == 0;
@@ -171,7 +171,7 @@ string ExpressionLiteral::toString(int indent) {
 //
 // ExpressionGrouping
 ExpressionGrouping::ExpressionGrouping(shared_ptr<Expression> expression):
-    Expression(ExpressionKind::GROUPING, expression->getValueType()), expression(expression) {
+Expression(ExpressionKind::GROUPING, expression->getValueType()), expression(expression) {
 }
 
 shared_ptr<Expression> ExpressionGrouping::getExpression() {
@@ -185,7 +185,7 @@ string ExpressionGrouping::toString(int indent) {
 //
 // ExpressionIfElse
 ExpressionIfElse::ExpressionIfElse(shared_ptr<Expression> condition, shared_ptr<StatementBlock> thenBlock, shared_ptr<StatementBlock> elseBlock):
-    Expression(ExpressionKind::IF_ELSE, ValueType::VOID), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) {
+Expression(ExpressionKind::IF_ELSE, ValueType::VOID), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) {
     // Condition must evaluate to bool
     if (condition->getValueType() != ValueType::BOOL)
         exit(1);
@@ -232,10 +232,24 @@ string ExpressionIfElse::toString(int indent) {
     return  value;
 }
 
+//
+// ExpressionVar
+ExpressionVar::ExpressionVar(string name):
+Expression(ExpressionKind::VAR, ValueType::VOID), name(name) {
+}
+
+string ExpressionVar::getName() {
+    return name;
+}
+
+string ExpressionVar::toString(int indent) {
+    return "VAR(" + name + ")";
+}
+
 //
 // ExpressionInvalid
 ExpressionInvalid::ExpressionInvalid(shared_ptr<Token> token):
-    Expression(ExpressionKind::INVALID, ValueType::VOID), token(token) {
+Expression(ExpressionKind::INVALID, ValueType::VOID), token(token) {
 }
 
 shared_ptr<Token> ExpressionInvalid::getToken() {

src/Expression.h

@@ -102,6 +102,18 @@ public:
     string toString(int indent) override;
 };
 
+//
+// ExpressionVar
+class ExpressionVar: public Expression {
+private:
+    string name;
+
+public:
+    ExpressionVar(string name);
+    string getName();
+    string toString(int indent) override;
+};
+
 //
 // ExpressionInvalid
 class ExpressionInvalid: public Expression {

src/ModuleBuilder.cpp

@@ -51,6 +51,7 @@ void ModuleBuilder::buildFunctionDeclaration(shared_ptr<StatementFunctionDeclara
 void ModuleBuilder::buildVarDeclaration(shared_ptr<StatementVarDeclaration> statement) {
     llvm::Value *value = valueForExpression(statement->getExpression());
     llvm::AllocaInst *alloca = builder->CreateAlloca(typeForValueType(statement->getValueType()), nullptr, statement->getName());
+    allocaMap[statement->getName()] = alloca;
     builder->CreateStore(value, alloca);
 }
 
@@ -85,6 +86,8 @@ llvm::Value *ModuleBuilder::valueForExpression(shared_ptr<Expression> expression
             return valueForBinary(dynamic_pointer_cast<ExpressionBinary>(expression));
         case ExpressionKind::IF_ELSE:
             return valueForIfElse(dynamic_pointer_cast<ExpressionIfElse>(expression));
+        case ExpressionKind::VAR:
+            return valueForVar(dynamic_pointer_cast<ExpressionVar>(expression));
         default:
             exit(1);
     }
@@ -242,6 +245,14 @@ llvm::Value *ModuleBuilder::valueForIfElse(shared_ptr<ExpressionIfElse> expressi
     return phi;
 }
 
+llvm::Value *ModuleBuilder::valueForVar(shared_ptr<ExpressionVar> expression) {
+    llvm::AllocaInst *alloca = allocaMap[expression->getName()];
+    if (alloca == nullptr)
+        exit(1);
+
+    return builder->CreateLoad(alloca->getAllocatedType(), alloca, expression->getName());
+}
+
 llvm::Type *ModuleBuilder::typeForValueType(ValueType valueType) {
     switch (valueType) {
         case ValueType::VOID:

src/ModuleBuilder.h

@@ -1,6 +1,8 @@
 #ifndef MODULE_BUILDER_H
 #define MODULE_BUILDER_H
 
+#include <map>
+
 #include "llvm/IR/Module.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
@@ -24,6 +26,7 @@ private:
     llvm::Type *typeReal32;
 
     vector<shared_ptr<Statement>> statements;
+    map<string, llvm::AllocaInst*> allocaMap;
 
     void buildStatement(shared_ptr<Statement> statement);
     void buildFunctionDeclaration(shared_ptr<StatementFunctionDeclaration> statement);
@@ -40,6 +43,7 @@ private:
     llvm::Value *valueForBinaryInteger(shared_ptr<ExpressionBinary> expression);
     llvm::Value *valueForBinaryReal(shared_ptr<ExpressionBinary> expression);
     llvm::Value *valueForIfElse(shared_ptr<ExpressionIfElse> expression);
+    llvm::Value *valueForVar(shared_ptr<ExpressionVar> expression);
 
     llvm::Type *typeForValueType(ValueType valueType);
 

src/Parser.cpp

@@ -97,10 +97,11 @@ shared_ptr<Statement> Parser::matchStatementVarDeclaration() {
     else
         return matchStatementInvalid();
 
-    //if (tokens.at(currentIndex)->getKind() != TokenKind::NEW_LINE)
+    // Expect new line
-    //    return matchStatementInvalid();
+    if (tokens.at(currentIndex)->getKind() != TokenKind::NEW_LINE)
+        return matchStatementInvalid();
     
-    //currentIndex++;
+    currentIndex++;
 
     return make_shared<StatementVarDeclaration>(identifierToken->getLexme(), valueType, expression);
 }
@@ -182,6 +183,10 @@ shared_ptr<Expression> Parser::nextExpression() {
     expression = matchExpressionIfElse();
     if (expression != nullptr)
         return expression;
+    
+    expression = matchExpressionVar();
+    if (expression != nullptr)
+        return expression;
 
     return nullptr;
 }
@@ -346,11 +351,25 @@ shared_ptr<Expression> Parser::matchExpressionIfElse() {
             return matchExpressionInvalid();
         else if (!elseBlock->isValid())
             return matchExpressionInvalid(); // FIXME
+
+        // hack to treat statement as an expression
+        if (tokens.at(currentIndex-1)->getKind() == TokenKind::NEW_LINE)
+            currentIndex--;
     }
 
     return make_shared<ExpressionIfElse>(condition, dynamic_pointer_cast<StatementBlock>(thenBlock), dynamic_pointer_cast<StatementBlock>(elseBlock));
 }
 
+shared_ptr<Expression> Parser::matchExpressionVar() {
+    shared_ptr<Token> token = tokens.at(currentIndex);
+    if (token->isOfKind({TokenKind::IDENTIFIER})) {
+        currentIndex++;
+        return make_shared<ExpressionVar>(token->getLexme());
+    }
+    
+    return nullptr;
+}
+
 shared_ptr<ExpressionInvalid> Parser::matchExpressionInvalid() {
     return make_shared<ExpressionInvalid>(tokens.at(currentIndex));
 }

src/Parser.h

@@ -33,6 +33,7 @@ private:
     shared_ptr<Expression> matchExpressionGrouping();
     shared_ptr<Expression> matchExpressionBinary(shared_ptr<Expression> left);
     shared_ptr<Expression> matchExpressionIfElse();
+    shared_ptr<Expression> matchExpressionVar();
     shared_ptr<ExpressionInvalid> matchExpressionInvalid();
 
     bool matchesTokenKinds(vector<TokenKind> kinds);

src/Types.h

@@ -44,6 +44,7 @@ enum class ExpressionKind {
     GROUPING,
     BINARY,
     IF_ELSE,
+    VAR,
     INVALID
 };