From 915c49f93d9a4120dc89872f609824603b9310bb Mon Sep 17 00:00:00 2001
From: Yann Herklotz <ymherklotz@gmail.com>
Date: Tue, 28 Mar 2017 12:39:37 +0100
Subject: Multidimensional array working

---
 c_compiler/include/bindings.hpp   |  1 +
 c_compiler/include/expression.hpp |  2 ++
 c_compiler/src/bindings.cpp       |  6 +++++
 c_compiler/src/declaration.cpp    |  7 ++++--
 c_compiler/src/expression.cpp     | 46 ++++++++++++++++++++++++++++++++++++++-
 test.c                            |  2 ++
 6 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/c_compiler/include/bindings.hpp b/c_compiler/include/bindings.hpp
index 42d52e1..a8d8eba 100644
--- a/c_compiler/include/bindings.hpp
+++ b/c_compiler/include/bindings.hpp
@@ -42,6 +42,7 @@ public:
     void setExpressionStackPosition(const int &stack_counter);
 
     TypePtr getType(const std::string &id) const;
+    const std::vector<int> &getArraySizes(const std::string &id) const;
 
     std::string breakLabel();
     std::string breakLabel(const std::string &label);
diff --git a/c_compiler/include/expression.hpp b/c_compiler/include/expression.hpp
index 6bade38..f11ea02 100644
--- a/c_compiler/include/expression.hpp
+++ b/c_compiler/include/expression.hpp
@@ -74,8 +74,10 @@ public:
     virtual void expressionDepth(int &depth_count) const;
     virtual void stackPosition(Bindings bindings, int &depth_count) const;
     virtual TypePtr getType(const Bindings &bindings) const;
+    virtual std::string id() const;
 
     ExpressionPtr getIndex() const;
+    ExpressionPtr getPostfix() const;    
 };
 
 class PostfixFunctionCall : public UnaryExpression
diff --git a/c_compiler/src/bindings.cpp b/c_compiler/src/bindings.cpp
index 0fe4c2f..7deda13 100644
--- a/c_compiler/src/bindings.cpp
+++ b/c_compiler/src/bindings.cpp
@@ -83,6 +83,12 @@ TypePtr Bindings::getType(const std::string &id) const
     return (*binding).second.type;
 }
 
+const std::vector<int> &Bindings::getArraySizes(const std::string &id) const
+{
+    auto binding = bindings_.find(id);
+    return (*binding).second.array_sizes;
+}
+
 std::string Bindings::breakLabel()
 {
     return break_label_;
diff --git a/c_compiler/src/declaration.cpp b/c_compiler/src/declaration.cpp
index 149bdab..0865619 100644
--- a/c_compiler/src/declaration.cpp
+++ b/c_compiler/src/declaration.cpp
@@ -3,6 +3,7 @@
 #include "type.hpp"
 #include "expression.hpp"
 
+#include <algorithm>
 #include <cstdio>
 #include <memory>
 #include <vector>
@@ -214,8 +215,10 @@ Bindings ArrayDeclaration::localAsm(Bindings bindings, int &label_count) const
 	std::shared_ptr<Initializer> initializer;
 	initializer = std::static_pointer_cast<Initializer>(initializer_);
 	initializer->printInitializerAsm(bindings, label_count, array_sizes.size()-1, array_sizes, type_->type());
-
-	bindings.insertBinding(getId(), type_, stack_position);
+	
+	// reverse vector to store in binding
+	std::reverse(array_sizes.begin(), array_sizes.end());
+	bindings.insertBinding(getId(), type_, stack_position, array_sizes);
     }
     
     return bindings;
diff --git a/c_compiler/src/expression.cpp b/c_compiler/src/expression.cpp
index 3df0a94..59440ec 100644
--- a/c_compiler/src/expression.cpp
+++ b/c_compiler/src/expression.cpp
@@ -147,7 +147,32 @@ PostfixArrayElement::PostfixArrayElement(Expression *postfix_expression, Express
 
 Bindings PostfixArrayElement::printAsm(Bindings bindings, int &label_count) const
 {
-    stackPosition(bindings, label_count);
+    std::shared_ptr<PostfixArrayElement> array_element
+	(std::dynamic_pointer_cast<PostfixArrayElement>(postfix_expression_));
+    
+    std::vector<int> array_sizes = bindings.getArraySizes(postfix_expression_->id());
+    
+    int counter = 1;
+    printf("\tmove\t$t1,$0\n");
+    index_expression_->printAsm(bindings, label_count);
+    printf("\taddu\t$t1,$t1,$2\n");    
+    while(array_element != nullptr)
+    {
+	array_element->getIndex()->printAsm(bindings, label_count);
+	int sum = 0;
+	std::for_each(array_sizes.end()-counter, array_sizes.end(), [&] (int n) {
+		sum += n;
+	    });
+	printf("\tmul\t$2,$2,%d\n", sum);
+	printf("\taddu\t$t1,$t1,$2\n");
+	array_element = std::dynamic_pointer_cast<PostfixArrayElement>(array_element->getPostfix());
+	counter++;
+    }
+    auto identifier_expression = std::make_shared<Identifier>(postfix_expression_->id());
+    identifier_expression->stackPosition(bindings, label_count);
+    printf("\tsll\t$t1,$t1,%d\n", postfix_expression_->getType(bindings)->getSize()/2);
+    printf("\taddu\t$t0,$t0,$t1\n");
+    
     TypePtr type_ptr = postfix_expression_->getType(bindings);
     std::shared_ptr<Pointer> pointer_type_ptr;
     pointer_type_ptr = std::dynamic_pointer_cast<Pointer>(type_ptr);
@@ -185,6 +210,25 @@ TypePtr PostfixArrayElement::getType(const Bindings &bindings) const
     return postfix_expression_->getType(bindings);
 }
 
+std::string PostfixArrayElement::id() const
+{
+    return postfix_expression_->id();
+}
+
+ExpressionPtr PostfixArrayElement::getIndex() const
+{
+    if(index_expression_ == nullptr)
+	throw std::runtime_error("Error : No index expression found");
+    return index_expression_;
+}
+
+ExpressionPtr PostfixArrayElement::getPostfix() const
+{
+    if(postfix_expression_ == nullptr)
+	throw std::runtime_error("Error : No index expression postfix");
+    return postfix_expression_;
+}
+
 
 // PostfixFunctionCall
 
diff --git a/test.c b/test.c
index cb188a3..4bfc9da 100644
--- a/test.c
+++ b/test.c
@@ -5,4 +5,6 @@ int main()
 		{ 3, 4, 5},
 		{ 6, 7, 8 }
 	};
+	
+	return x[2][1];
 }
-- 
cgit