Allow loading stack values

src/ast.cpp

@@ -27,6 +27,10 @@ namespace AST {
         return out.str();
     }
 
+    std::string ValueReferenceExpression::formatted() {
+        return this->m_name;
+    }
+
     std::string Function::formatted() {
         std::stringstream out{ "" };
         out << this->m_name;

src/ast.h

@@ -41,6 +41,16 @@ namespace AST {
         virtual llvm::Value* codegen(codegen::Builder& builder, codegen::Scope& scope) override;
     };
 
+    class ValueReferenceExpression : public Expression {
+    private:
+        std::string m_name;
+    public:
+        ValueReferenceExpression(std::string name) : m_name{ name } {}
+        virtual ~ValueReferenceExpression() override = default;
+        virtual std::string formatted() override;
+        virtual llvm::Value* codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+    };
+
 
     class ReturnStatement : public Statement {
     private:

src/codegen.cpp

@@ -12,6 +12,16 @@ namespace AST {
         return llvm::ConstantInt::get(ty, this->m_value);
     }
 
+    llvm::Value* ValueReferenceExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
+        auto value = scope.values.find(this->m_name);
+        if (value != scope.values.end()) {
+            return builder.builder->CreateLoad(value->second.ty, value->second.value);
+        }
+        else {
+            throw new std::runtime_error("Value " + this->m_name + " not found");
+        }
+    }
+
     void ReturnStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         if (!builder.block)
             return;
@@ -35,6 +45,7 @@ namespace AST {
             builder.builder->CreateStore(value, ptr, false);
         }
 
+        scope.values[this->m_name] = codegen::StackValue{ ptr, ty };
     }
 
     void Function::codegen(codegen::Builder& builder, codegen::Scope& scope) {

src/codegen.h

@@ -14,13 +14,13 @@ namespace codegen {
         std::unique_ptr<llvm::BasicBlock> block;
     };
 
-    struct ScopeValue {
+    struct StackValue {
         llvm::Value* value;
         llvm::Type* ty;
     };
 
     struct Scope {
-        std::map<std::string, ScopeValue> values;
+        std::map<std::string, StackValue> values;
     };
 }
 

src/parsing.cpp

@@ -28,6 +28,12 @@ namespace parsing {
                     auto expr = new AST::IntLiteralExpression{ std::stoi(token.content) };
                     return new std::unique_ptr<AST::Expression>{ expr };
                 }
+                else if (token.type == token::Type::Ident) {
+                    stream.m_position = inner.m_position;
+
+                    auto expr = new AST::ValueReferenceExpression{ token.content };
+                    return new std::unique_ptr<AST::Expression>{ expr };
+                }
                 else {
                     throw std::runtime_error("Expected expression");
                 }

test.c

@@ -1,4 +1,4 @@
 int main() {
     int a = 5;
-    return 15;
+    return a;
 }