From 2cead1f5e8bfb78b7f54257f4f50b9c22bf79ffc Mon Sep 17 00:00:00 2001
From: Austin Sun <austinsunc@yahoo.com>
Date: Sun, 29 May 2016 19:09:31 -0700
Subject: [PATCH] minor fixes arrays still dont work

---
 ast_decl.cc | 11 ++++++++++-
 ast_expr.cc | 36 +++++++++++++++++++++++++++++++++---
 ast_expr.h  |  5 +++++
 ast_stmt.cc |  3 +++
 ast_type.h  |  1 +
 irgen.h     |  2 +-
 6 files changed, 53 insertions(+), 5 deletions(-)

diff --git a/ast_decl.cc b/ast_decl.cc
index 37ed518..14bc4e8 100644
--- a/ast_decl.cc
+++ b/ast_decl.cc
@@ -70,8 +70,17 @@ void FnDecl::PrintChildren(int indentLevel) {
 llvm::Value* VarDecl::Emit() {
     llvm::BasicBlock* b = irgen.GetBasicBlock();
     llvm::Value* val;
+    //locals
     if(b) {
-        val = new llvm::AllocaInst(convertType(type), id->GetName(), b);
+        if(dynamic_cast<ArrayType *>(type) !=NULL){
+            llvm::Value* val2 = llvm::ConstantInt::get(irgen.GetIntType(), dynamic_cast<ArrayType*>(type)->GetElemCount());
+            llvm::Type* thisType = convertType(dynamic_cast<ArrayType*>(type)->GetElemType());
+            llvm::ArrayType* arrType = llvm::ArrayType::get(thisType, dynamic_cast<ArrayType*>(type)->GetElemCount());
+            val = new llvm::AllocaInst(arrType, val2, id->GetName(), irgen.GetBasicBlock());
+        }
+        else{
+            val = new llvm::AllocaInst(convertType(type), id->GetName(), b);
+        }
         if(assignTo) new llvm::StoreInst(assignTo->Emit(), val, false, irgen.GetBasicBlock());
     }
     else {
diff --git a/ast_expr.cc b/ast_expr.cc
index 014b7b1..03db64b 100644
--- a/ast_expr.cc
+++ b/ast_expr.cc
@@ -9,6 +9,7 @@
 #include "ast_decl.h"
 #include "symtable.h"
 
+
 IntConstant::IntConstant(yyltype loc, int val) : Expr(loc) {
     value = val;
 }
@@ -320,6 +321,7 @@ llvm::Value * AssignExpr::Emit(){
 
     FieldAccess * f = dynamic_cast<FieldAccess *>(left);
     if (f){
+        //std::cerr<< "fuck this assignment"<<"/n";
         return this->AssignField();
     }
     leftval = left->Emit();
@@ -355,7 +357,10 @@ llvm::Value * AssignExpr::Emit(){
     }
     else if ( operationStr.compare("=") == 0 ){
         if (vd){
+            std::cerr<<"--------------------------------------------"<<"\n";
+            std::cerr<< vd->GetIdentifier()->GetName()<<"\n";
             vd->AddressStore(rightval);
+            std::cerr<<"AFTER STOREING" << endl;
             return rightval;
         }
         return ((VarExpr *) left)->AddressStore(rightval);
@@ -558,15 +563,15 @@ llvm::Value * FieldAccess::Emit(){
             maskI.push_back(llvm::ConstantInt::get(intTyp, 0));
             valNum=0;
         }
-        else if(*ptr='y'){
+        else if(*ptr=='y'){
             maskI.push_back(llvm::ConstantInt::get(intTyp, 1));
             valNum=1;
         }
-        else if(*ptr='z'){
+        else if(*ptr=='z'){
             maskI.push_back(llvm::ConstantInt::get(intTyp, 2));
             valNum=2;
         }
-        else if(*ptr='w'){
+        else if(*ptr=='w'){
             maskI.push_back(llvm::ConstantInt::get(intTyp, 3));
             valNum=3;
         }
@@ -582,3 +587,28 @@ llvm::Value * FieldAccess::Emit(){
     llvm::Value * val = new llvm::ShuffleVectorInst(baseF,llvm::UndefValue::get(baseF->getType()), masky,"",irgen.GetBasicBlock());
     return val;
 }
+
+llvm::Value * ArrayAccess::Emit(){
+    Expr * base= GetBase();
+    Expr * sub= GetSubScript();
+    std::cerr<< "arrayAccess"<<"\n";
+
+    if(isInCurrentScope( dynamic_cast< VarExpr* >(base)->GetIdentifier()->GetName())){
+        std::cerr<< "arrayAccess2"<<"\n";
+
+        llvm::Value * val= findSymbol(dynamic_cast< VarExpr* >(base)->GetIdentifier()->GetName()).second;
+        llvm::Value * subscrVal = sub->Emit();
+        std::vector <llvm::Value*> vect;
+        vect.push_back(llvm::ConstantInt::get(irgen.GetIntType(),0));
+        vect.push_back((llvm::Value *const &) subscrVal);
+        llvm::ArrayRef<llvm::Value *> valList(vect);
+        llvm::Value *elmt= llvm::GetElementPtrInst::Create(val,valList,"ARRAYACCESS",irgen.GetBasicBlock());
+
+        return new llvm::LoadInst(elmt,"ARRAYACCESS",irgen.GetBasicBlock());
+    }
+    else{
+        return NULL;
+    }
+}
+
+
diff --git a/ast_expr.h b/ast_expr.h
index af84e7d..b37d0fd 100644
--- a/ast_expr.h
+++ b/ast_expr.h
@@ -199,6 +199,11 @@ class ArrayAccess : public LValue
     ArrayAccess(yyltype loc, Expr *base, Expr *subscript);
     const char *GetPrintNameForNode() { return "ArrayAccess"; }
     void PrintChildren(int indentLevel);
+    Expr *GetBase(){ return base; }
+    Expr *GetSubScript(){ return subscript;}
+    llvm::Value *Emit();
+
+    llvm::Value *EmitHelper(llvm::Value* rightH);
 };
 
 /* Note that field access is used both for qualified names
diff --git a/ast_stmt.cc b/ast_stmt.cc
index ccc3fd0..a1066d4 100644
--- a/ast_stmt.cc
+++ b/ast_stmt.cc
@@ -259,6 +259,7 @@ llvm::Value * WhileStmt::Emit(){
 
 //if statement
 llvm::Value * IfStmt::Emit(){
+
     llvm::LLVMContext * context = irgen.GetContext();
     llvm::Function * func = irgen.GetFunction();
     llvm::BasicBlock * elseBlock = NULL;
@@ -266,6 +267,7 @@ llvm::Value * IfStmt::Emit(){
     llvm::BasicBlock * footBlock = llvm::BasicBlock::Create(*context, "footBlock", func);
     llvm::Value * val;
     llvm::Value * condition = test->Emit();
+
     if(elseBody)
     {
         elseBlock =  llvm::BasicBlock::Create(*context, "elseBlock", func);
@@ -280,6 +282,7 @@ llvm::Value * IfStmt::Emit(){
     {
         val = llvm::BranchInst::Create(footBlock, irgen.GetBasicBlock());
     }
+
     popScope();
 
     if(elseBody)
diff --git a/ast_type.h b/ast_type.h
index 39d6728..a401594 100644
--- a/ast_type.h
+++ b/ast_type.h
@@ -90,6 +90,7 @@ class ArrayType : public Type
     void PrintChildren(int indentLevel);
     void PrintToStream(ostream& out) { out << elemType << "[]"; }
     Type *GetElemType() {return elemType;}
+    int GetElemCount(){return elemCount;}
 };
 
 llvm::Type* convertType(Type* t);
diff --git a/irgen.h b/irgen.h
index 91115d0..12b1a79 100644
--- a/irgen.h
+++ b/irgen.h
@@ -54,7 +54,7 @@ class IRGenerator {
 
     llvm::Type *GetMat4Type() const;
 
-  private:
+private:
     llvm::LLVMContext *context;
     llvm::Module      *module;
 
-- 
1.9.1