Adding more tests and fixing

26 files changed, 363 insertions, 113 deletions

diff --git a/c_compiler/include/expression.hpp b/c_compiler/include/expression.hpp
index 1377a22..0ded5c2 100644
--- a/c_compiler/include/expression.hpp
+++ b/c_compiler/include/expression.hpp
@@ -25,10 +25,10 @@ public:
     virtual int constantFold() const;
     virtual void print() const;
     virtual void printXml() const;
-    virtual void countArguments(unsigned& argument_count) const;
-    virtual void expressionDepth(unsigned& depth_count) const;    
+    virtual void countArguments(unsigned &argument_count) const;
+    virtual void expressionDepth(unsigned &depth_count) const;    
     virtual int postfixStackPosition(VariableStackBindings bindings) const;
-    virtual void setPostfixExpression(Expression* postfix_expression);
+    virtual void setPostfixExpression(Expression *postfix_expression);
     virtual std::string id() const;
     virtual ExpressionPtr getLhs() const;
     virtual ExpressionPtr getRhs() const;
@@ -44,17 +44,17 @@ protected:
     ExpressionPtr lhs_;
     ExpressionPtr rhs_;
 public:
-    OperationExpression(Expression* lhs, Expression* rhs);
-    OperationExpression(ExpressionPtr lhs, Expression* rhs);
+    OperationExpression(Expression *lhs, Expression *rhs);
+    OperationExpression(ExpressionPtr lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const = 0;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const = 0;
     
     virtual int constantFold() const;
-    virtual void expressionDepth(unsigned& depth_count) const;
+    virtual void expressionDepth(unsigned &depth_count) const;
     virtual ExpressionPtr getLhs() const;
     virtual ExpressionPtr getRhs() const;
     
-    void evaluateExpression(VariableStackBindings bindings, unsigned& label_count) const;
+    void evaluateExpression(VariableStackBindings bindings, unsigned &label_count) const;
 };
 
 
@@ -63,7 +63,7 @@ class PostfixArrayElement : public Expression
 public:
     PostfixArrayElement();
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
 };
 
 
@@ -74,12 +74,12 @@ private:
     ExpressionPtr argument_expression_list_;
     
 public:
-    PostfixFunctionCall(Expression* argument_expression_list = nullptr);
+    PostfixFunctionCall(Expression *argument_expression_list = nullptr);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
-    virtual void countArguments(unsigned& argument_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
+    virtual void countArguments(unsigned &argument_count) const;
     
-    void setPostfixExpression(Expression* postfix_expression);
+    void setPostfixExpression(Expression *postfix_expression);
 };
 
 class PostfixPostIncDecExpression : public Expression
@@ -89,9 +89,9 @@ private:
     ExpressionPtr postfix_expression_;
 
 public:
-    PostfixPostIncDecExpression(const std::string& _operator, Expression* postfix_expression);
+    PostfixPostIncDecExpression(const std::string &_operator, Expression *postfix_expression);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     
 };
 
@@ -103,9 +103,21 @@ private:
     ExpressionPtr unary_expression_;
     
 public:
-    UnaryPreIncDecExpression(const std::string& _operator, Expression* unary_expression);
+    UnaryPreIncDecExpression(const std::string &_operator, Expression *unary_expression);
+
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
+};
+
+class OperatorUnaryExpression : public Expression
+{
+private:
+    std::string operator_;
+    ExpressionPtr cast_expression_;
+
+public:
+    OperatorUnaryExpression(const std::string &_operator, Expression *cast_expression);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
 };
 
 
@@ -116,9 +128,9 @@ private:
     ExpressionPtr expression_;
 
 public:
-    CastExpression(Type* type, Expression* expression);
+    CastExpression(Type *type, Expression *expression);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
 };
 
 
@@ -128,9 +140,9 @@ private:
     std::string operator_;
 
 public:
-    AdditiveExpression(Expression* lhs, const std::string& _operator, Expression* rhs);
+    AdditiveExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -141,9 +153,9 @@ private:
     std::string operator_;
 
 public:
-    MultiplicativeExpression(Expression* lhs, const std::string& _operator, Expression* rhs);
+    MultiplicativeExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -153,9 +165,9 @@ class ShiftExpression : public OperationExpression
 private:
     std::string operator_;
 public:
-    ShiftExpression(Expression* lhs, const std::string& _operator, Expression* rhs);
+    ShiftExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -165,9 +177,9 @@ class RelationalExpression : public OperationExpression
 private:
     std::string operator_;
 public:
-    RelationalExpression(Expression* lhs, const std::string& _operator, Expression* rhs);
+    RelationalExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -177,9 +189,9 @@ class EqualityExpression : public OperationExpression
 private:
     std::string operator_;
 public:
-    EqualityExpression(Expression* lhs, const std::string& _operator, Expression* rhs);
+    EqualityExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -187,9 +199,9 @@ public:
 class AndExpression : public OperationExpression
 {
 public:
-    AndExpression(Expression* lhs, Expression* rhs);
+    AndExpression(Expression *lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -197,9 +209,9 @@ public:
 class ExclusiveOrExpression : public OperationExpression
 {
 public:
-    ExclusiveOrExpression(Expression* lhs, Expression* rhs);
+    ExclusiveOrExpression(Expression *lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -207,9 +219,9 @@ public:
 class InclusiveOrExpression : public OperationExpression
 {
 public:
-    InclusiveOrExpression(Expression* lhs, Expression* rhs);
+    InclusiveOrExpression(Expression *lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const; 
 };
 
@@ -217,9 +229,9 @@ public:
 class LogicalAndExpression : public OperationExpression
 {
 public:
-    LogicalAndExpression(Expression* lhs, Expression* rhs);
+    LogicalAndExpression(Expression *lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
@@ -227,9 +239,9 @@ public:
 class LogicalOrExpression : public OperationExpression
 {
 public:
-    LogicalOrExpression(Expression* lhs, Expression* rhs);
+    LogicalOrExpression(Expression *lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;    
 };
 
@@ -242,20 +254,20 @@ private:
     ExpressionPtr conditional_expression_;
 
 public:
-    ConditionalExpression(Expression* logical_or, Expression* expression,
-			  Expression* conditional_expression);
+    ConditionalExpression(Expression *logical_or, Expression *expression,
+			  Expression *conditional_expression);
     
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
 };
 
 
 class AssignmentExpression : public OperationExpression
 {
 public:
-    AssignmentExpression(Expression* lhs, Expression* rhs);
-    AssignmentExpression(ExpressionPtr lhs, Expression* rhs);
+    AssignmentExpression(Expression *lhs, Expression *rhs);
+    AssignmentExpression(ExpressionPtr lhs, Expression *rhs);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
 };
 
 
@@ -264,9 +276,9 @@ class Identifier : public Expression
 private:
     std::string id_;
 public:
-    Identifier(const std::string& id);
+    Identifier(const std::string &id);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int postfixStackPosition(VariableStackBindings bindings) const;
     virtual std::string id() const;
 };
@@ -277,9 +289,9 @@ class Constant : public Expression
 private:
     int32_t constant_;
 public:
-    Constant(const int32_t& constant);
+    Constant(const int32_t &constant);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned &label_count) const;
     virtual int constantFold() const;
 };
 
diff --git a/c_compiler/src/bindings.cpp b/c_compiler/src/bindings.cpp
index 944ce56..333f21d 100644
--- a/c_compiler/src/bindings.cpp
+++ b/c_compiler/src/bindings.cpp
@@ -9,11 +9,20 @@ VariableStackBindings::VariableStackBindings()
 
 void VariableStackBindings::insertBinding(std::string id, TypePtr type, int stack_position)
 {
-    DeclarationData decl_data;
-    decl_data.type = type;
-    decl_data.stack_position = stack_position;
+    auto binding = bindings_.find(id);
 
-    bindings_.insert(std::pair<std::string, DeclarationData>(id, decl_data));
+    if(binding == bindings_.end())
+    {
+	DeclarationData decl_data;
+	decl_data.type = type;
+	decl_data.stack_position = stack_position;
+	bindings_.insert(std::pair<std::string, DeclarationData>(id, decl_data));
+    }
+    else
+    {
+	(*binding).second.stack_position = stack_position;
+	(*binding).second.type = type;
+    }
 }
 
 void VariableStackBindings::increaseStackPosition()
diff --git a/c_compiler/src/c_lexer.flex b/c_compiler/src/c_lexer.flex
index 0530df0..7ed46ae 100644
--- a/c_compiler/src/c_lexer.flex
+++ b/c_compiler/src/c_lexer.flex
@@ -70,7 +70,7 @@ ALL .
 [&][&]		{ return T_LOG_AND; }
 [|]		{ return T_OR; }
 [\^]		{ return T_XOR; }
-[&]		{ return T_AND; }
+[&]		{ yylval.string = new std::string(yytext); return T_AND; }
 [=][=]		{ yylval.string = new std::string(yytext); return T_EQUALITY_OP; }
 [!][=]		{ yylval.string = new std::string(yytext); return T_EQUALITY_OP; }
 ([<>][=])|[<>]	{ yylval.string = new std::string(yytext); return T_REL_OP; }
@@ -78,8 +78,8 @@ ALL .
 [*] 		{ yylval.string = new std::string(yytext); return T_MULT; }
 [\/]		{ yylval.string = new std::string(yytext); return T_DIV; }
 [%]		{ yylval.string = new std::string(yytext); return T_REM; }
-[~]		{ return T_TILDE; }
-[!]		{ return T_NOT; }
+[~]		{ yylval.string = new std::string(yytext); return T_TILDE; }
+[!]		{ yylval.string = new std::string(yytext); return T_NOT; }
 [.]		{ return T_DOT; }
 [-][>]		{ return T_ARROW; }
 [+-][+-]	{ yylval.string = new std::string(yytext); return T_INCDEC; }
diff --git a/c_compiler/src/c_parser.y b/c_compiler/src/c_parser.y
index cbf1e32..2f26ade 100644
--- a/c_compiler/src/c_parser.y
+++ b/c_compiler/src/c_parser.y
@@ -402,7 +402,7 @@ CastExpression:	UnaryExpression { $$ = $1; }
 UnaryExpression:
 		PostfixExpression { $$ = $1; }
 	|	T_INCDEC UnaryExpression { $$ = new UnaryPreIncDecExpression(*$1, $2); delete $1; }
-	|	UnaryOperator CastExpression { $$ = $2; }
+	|	UnaryOperator CastExpression { $$ = new OperatorUnaryExpression(*$1, $2); delete $1; }
 	|	T_SIZEOF UnaryExpression { $$ = $2; }
 	|	T_SIZEOF T_LRB DeclarationSpecifierList T_RRB { $$ = new Constant(0); delete $3; }
 		;
diff --git a/c_compiler/src/expression.cpp b/c_compiler/src/expression.cpp
index 9c04afe..f55246b 100644
--- a/c_compiler/src/expression.cpp
+++ b/c_compiler/src/expression.cpp
@@ -17,7 +17,7 @@ void Expression::print() const
 void Expression::printXml() const
 {}
 
-void Expression::countArguments(unsigned& argument_count) const
+void Expression::countArguments(unsigned &argument_count) const
 {
     // by default don't do anything to the count
     (void)argument_count;
@@ -68,11 +68,11 @@ ExpressionPtr Expression::nextExpression() const
 
 // OperationExpression definition
 
-OperationExpression::OperationExpression(Expression* lhs, Expression* rhs)
+OperationExpression::OperationExpression(Expression *lhs, Expression *rhs)
     : lhs_(lhs), rhs_(rhs)
 {}
 
-OperationExpression::OperationExpression(ExpressionPtr lhs, Expression* rhs)
+OperationExpression::OperationExpression(ExpressionPtr lhs, Expression *rhs)
     : lhs_(lhs), rhs_(rhs)
 {}
 
@@ -81,7 +81,7 @@ int OperationExpression::constantFold() const
     throw std::runtime_error("Error : Cannot constant fold expression\n");
 }
 
-void OperationExpression::expressionDepth(unsigned& depth_count) const
+void OperationExpression::expressionDepth(unsigned &depth_count) const
 {
     unsigned lhs_depth_count = depth_count;
     unsigned rhs_depth_count = depth_count+1;
@@ -105,7 +105,7 @@ ExpressionPtr OperationExpression::getRhs() const
     return rhs_;
 }
 
-void OperationExpression::evaluateExpression(VariableStackBindings bindings, unsigned& label_count) const
+void OperationExpression::evaluateExpression(VariableStackBindings bindings, unsigned &label_count) const
 {
     // I can just evaluate the lhs with the same entry stack position
     lhs_->printAsm(bindings, label_count);
@@ -128,7 +128,7 @@ void OperationExpression::evaluateExpression(VariableStackBindings bindings, uns
 PostfixArrayElement::PostfixArrayElement()
 {}
 
-VariableStackBindings PostfixArrayElement::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings PostfixArrayElement::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     return bindings;
 }
@@ -136,11 +136,11 @@ VariableStackBindings PostfixArrayElement::printAsm(VariableStackBindings bindin
 
 // PostfixFunctionCall
 
-PostfixFunctionCall::PostfixFunctionCall(Expression* argument_expression_list)
+PostfixFunctionCall::PostfixFunctionCall(Expression *argument_expression_list)
     : argument_expression_list_(argument_expression_list)
 {}
 
-VariableStackBindings PostfixFunctionCall::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings PostfixFunctionCall::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     std::vector<ExpressionPtr> argument_vector;
     ExpressionPtr current_argument = argument_expression_list_;
@@ -169,7 +169,7 @@ VariableStackBindings PostfixFunctionCall::printAsm(VariableStackBindings bindin
     return bindings;
 }
 
-void PostfixFunctionCall::countArguments(unsigned int &argument_count) const
+void PostfixFunctionCall::countArguments(unsigned &argument_count) const
 {
     ExpressionPtr current_argument = argument_expression_list_;
 
@@ -182,7 +182,7 @@ void PostfixFunctionCall::countArguments(unsigned int &argument_count) const
     }
 }
 
-void PostfixFunctionCall::setPostfixExpression(Expression* postfix_expression)
+void PostfixFunctionCall::setPostfixExpression(Expression *postfix_expression)
 {
     ExpressionPtr expression_ptr(postfix_expression);
     postfix_expression_ = expression_ptr;
@@ -191,11 +191,11 @@ void PostfixFunctionCall::setPostfixExpression(Expression* postfix_expression)
 
 // Post increment and decrement definition
 
-PostfixPostIncDecExpression::PostfixPostIncDecExpression(const std::string& _operator, Expression* postfix_expression)
+PostfixPostIncDecExpression::PostfixPostIncDecExpression(const std::string &_operator, Expression *postfix_expression)
     : operator_(_operator), postfix_expression_(postfix_expression)
 {}
 
-VariableStackBindings PostfixPostIncDecExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings PostfixPostIncDecExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     postfix_expression_->printAsm(bindings, label_count);
     if(operator_ == "++")
@@ -213,11 +213,11 @@ VariableStackBindings PostfixPostIncDecExpression::printAsm(VariableStackBinding
 
 // Pre increment and decrement implementation
 
-UnaryPreIncDecExpression::UnaryPreIncDecExpression(const std::string& _operator, Expression* unary_expression)
+UnaryPreIncDecExpression::UnaryPreIncDecExpression(const std::string &_operator, Expression *unary_expression)
     : operator_(_operator), unary_expression_(unary_expression)
 {}
 
-VariableStackBindings UnaryPreIncDecExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings UnaryPreIncDecExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     unary_expression_->printAsm(bindings, label_count);
     if(operator_ == "++")
@@ -233,13 +233,49 @@ VariableStackBindings UnaryPreIncDecExpression::printAsm(VariableStackBindings b
 }
 
 
+// Operator unary definition
+
+OperatorUnaryExpression::OperatorUnaryExpression(const std::string &_operator, Expression *cast_expression)
+    : operator_(_operator), cast_expression_(cast_expression)
+{}
+
+VariableStackBindings OperatorUnaryExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
+{
+    cast_expression_->printAsm(bindings, label_count);
+    if(operator_ == "!")
+    {
+	printf("\tsltu\t$2,$2,1\n\tandi\t$2,$2,0x00ff\n");
+    }
+    else if(operator_ == "~")
+    {
+	printf("\tnor\t$2,$0,$2\n");
+    }
+    else if(operator_ == "&")
+    {
+	printf("\taddiu\t$2,$fp,%d\n", cast_expression_->postfixStackPosition(bindings));
+    }
+    else if(operator_ == "-")
+    {
+	printf("\tsubu\t$2,$0,$2\n");
+    }
+    else if(operator_ == "*")
+    {
+	printf("\tlw\t$2,0($2)\n");
+    }
+
+    printf("\tsw\t$2,%d($fp)\n", bindings.currentExpressionStackPosition());
+
+    return bindings;
+}
+
+
 // CastExpression definition
 
-CastExpression::CastExpression(Type* type, Expression* expression)
+CastExpression::CastExpression(Type *type, Expression *expression)
     : type_(type), expression_(expression)
 {}
 
-VariableStackBindings CastExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings CastExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     return bindings;
 }
@@ -247,11 +283,11 @@ VariableStackBindings CastExpression::printAsm(VariableStackBindings bindings, u
 
 // Additive Expression definition
 
-AdditiveExpression::AdditiveExpression(Expression* lhs, const std::string& _operator, Expression* rhs)
+AdditiveExpression::AdditiveExpression(Expression *lhs, const std::string &_operator, Expression *rhs)
     : OperationExpression(lhs, rhs), operator_(_operator)
 {}
 
-VariableStackBindings AdditiveExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings AdditiveExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
     
@@ -281,11 +317,11 @@ int AdditiveExpression::constantFold() const
 // Multiplicative Expression definition
 
 
-MultiplicativeExpression::MultiplicativeExpression(Expression* lhs, const std::string& _operator, Expression* rhs)
+MultiplicativeExpression::MultiplicativeExpression(Expression *lhs, const std::string &_operator, Expression *rhs)
     : OperationExpression(lhs, rhs), operator_(_operator)
 {}
 
-VariableStackBindings MultiplicativeExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings MultiplicativeExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
 
@@ -326,11 +362,11 @@ int MultiplicativeExpression::constantFold() const
 
 // ShiftExpression definition
 
-ShiftExpression::ShiftExpression(Expression* lhs, const std::string& _operator, Expression* rhs)
+ShiftExpression::ShiftExpression(Expression* lhs, const std::string &_operator, Expression *rhs)
     : OperationExpression(lhs, rhs), operator_(_operator)
 {}
 
-VariableStackBindings ShiftExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings ShiftExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
 
@@ -362,11 +398,11 @@ int ShiftExpression::constantFold() const
 
 // RelationalExpression definition
 
-RelationalExpression::RelationalExpression(Expression* lhs, const std::string& _operator, Expression* rhs)
+RelationalExpression::RelationalExpression(Expression* lhs, const std::string &_operator, Expression *rhs)
     : OperationExpression(lhs, rhs), operator_(_operator)
 {}
 
-VariableStackBindings RelationalExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings RelationalExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
 
@@ -417,11 +453,11 @@ int RelationalExpression::constantFold() const
 
 // EqualityExpression definition
 
-EqualityExpression::EqualityExpression(Expression* lhs, const std::string& _operator, Expression* rhs)
+EqualityExpression::EqualityExpression(Expression *lhs, const std::string &_operator, Expression *rhs)
     : OperationExpression(lhs, rhs), operator_(_operator)
 {}
 
-VariableStackBindings EqualityExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings EqualityExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
     printf("\txor\t$2,$2,$3\n");
@@ -454,11 +490,11 @@ int EqualityExpression::constantFold() const
 
 // AndExpression definition
 
-AndExpression::AndExpression(Expression* lhs, Expression* rhs)
+AndExpression::AndExpression(Expression *lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-VariableStackBindings AndExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings AndExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
     printf("\tand\t$2,$2,$3\n\tsw\t$2,%d($fp)\n", bindings.currentExpressionStackPosition());
@@ -473,11 +509,11 @@ int AndExpression::constantFold() const
 
 // ExclusiveOrExpression definition
 
-ExclusiveOrExpression::ExclusiveOrExpression(Expression* lhs, Expression* rhs)
+ExclusiveOrExpression::ExclusiveOrExpression(Expression *lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-VariableStackBindings ExclusiveOrExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings ExclusiveOrExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
     printf("\txor\t$2,$2,$3\n\tsw\t$2,%d($fp)\n", bindings.currentExpressionStackPosition());
@@ -492,11 +528,11 @@ int ExclusiveOrExpression::constantFold() const
 
 // InclusiveOrExpression definition
 
-InclusiveOrExpression::InclusiveOrExpression(Expression* lhs, Expression* rhs)
+InclusiveOrExpression::InclusiveOrExpression(Expression *lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-VariableStackBindings InclusiveOrExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings InclusiveOrExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     evaluateExpression(bindings, label_count);
     printf("\tor\t$2,$2,$3\n\tsw\t$2,%d($fp)\n", bindings.currentExpressionStackPosition());
@@ -511,12 +547,20 @@ int InclusiveOrExpression::constantFold() const
 
 // LogicalAndExpression definition
 
-LogicalAndExpression::LogicalAndExpression(Expression* lhs, Expression* rhs)
+LogicalAndExpression::LogicalAndExpression(Expression *lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-VariableStackBindings LogicalAndExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings LogicalAndExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
+    unsigned log_and = label_count++;
+    lhs_->printAsm(bindings, label_count);
+    printf("\tbeq\t$2,$0,$%d_log_and_load_0\n\tnop\n", log_and);
+    rhs_->printAsm(bindings, label_count);
+    printf("\tbeq\t$2,$0,$%d_log_and_load_0\n\tnop\n", log_and);
+    printf("\tli\t$2,1\n\tb\t$%d_log_and_end\n\tnop\n", log_and);
+    printf("$%d_log_and_load_0:\n\tmove\t$2,$0\n$%d_log_and_end:\n", log_and, log_and);
+    printf("\tsw\t$2,%d($fp)\n", bindings.currentExpressionStackPosition());
     return bindings;
 }
 
@@ -528,12 +572,20 @@ int LogicalAndExpression::constantFold() const
 
 // LogicalOrExpression definition
 
-LogicalOrExpression::LogicalOrExpression(Expression* lhs, Expression* rhs)
+LogicalOrExpression::LogicalOrExpression(Expression *lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-VariableStackBindings LogicalOrExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings LogicalOrExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
+    unsigned log_or = label_count++;
+    lhs_->printAsm(bindings, label_count);
+    printf("\tbne\t$2,$0,$%d_log_or_load_1\n\tnop\n", log_or);
+    rhs_->printAsm(bindings, label_count);
+    printf("\tbeq\t$2,$0,$%d_log_or_load_0\n\tnop\n", log_or);
+    printf("$%d_log_or_load_1:\n\tli\t$2,1\n\tb\t$%d_log_or_end\n\tnop\n", log_or, log_or);
+    printf("$%d_log_or_load_0:\n\tmove\t$2,$0\n$%d_log_or_end:\n", log_or, log_or);
+    printf("\tsw\t$2,%d($fp)\n", bindings.currentExpressionStackPosition());
     return bindings;
 }
 
@@ -545,14 +597,14 @@ int LogicalOrExpression::constantFold() const
 
 // ConditionalExpression definition
 
-ConditionalExpression::ConditionalExpression(Expression* logical_or,
-					     Expression* expression,
-					     Expression* conditional_expression)
+ConditionalExpression::ConditionalExpression(Expression *logical_or,
+					     Expression *expression,
+					     Expression *conditional_expression)
     : logical_or_(logical_or), expression_(expression),
       conditional_expression_(conditional_expression)
 {}
 
-VariableStackBindings ConditionalExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings ConditionalExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     return bindings;
 }
@@ -560,15 +612,15 @@ VariableStackBindings ConditionalExpression::printAsm(VariableStackBindings bind
 
 // Assignment Expression definition
 
-AssignmentExpression::AssignmentExpression(Expression* lhs, Expression* rhs)
+AssignmentExpression::AssignmentExpression(Expression *lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-AssignmentExpression::AssignmentExpression(ExpressionPtr lhs, Expression* rhs)
+AssignmentExpression::AssignmentExpression(ExpressionPtr lhs, Expression *rhs)
     : OperationExpression(lhs, rhs)
 {}
 
-VariableStackBindings AssignmentExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings AssignmentExpression::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     // TODO add stack and store results in there, also for addition and multiplication.
 
@@ -593,11 +645,11 @@ VariableStackBindings AssignmentExpression::printAsm(VariableStackBindings bindi
 
 // Identifier definition
 
-Identifier::Identifier(const std::string& id)
+Identifier::Identifier(const std::string &id)
     : id_(id)
 {}
 
-VariableStackBindings Identifier::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings Identifier::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     (void)label_count;
     
@@ -640,11 +692,11 @@ std::string Identifier::id() const
 
 // Constant definition
 
-Constant::Constant(const int32_t& constant)
+Constant::Constant(const int32_t &constant)
     : constant_(constant)
 {}
 
-VariableStackBindings Constant::printAsm(VariableStackBindings bindings, unsigned& label_count) const
+VariableStackBindings Constant::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
     (void)label_count;
     // constant only has to load to $2 because the other expression will take care of the rest
diff --git a/c_compiler/src/statement.cpp b/c_compiler/src/statement.cpp
index e5fd369..c266140 100644
--- a/c_compiler/src/statement.cpp
+++ b/c_compiler/src/statement.cpp
@@ -65,6 +65,8 @@ VariableStackBindings LabelStatement::printAsm(VariableStackBindings bindings, u
 
     printf("%s:\n", label_.c_str());
 
+    statement_->printAsm(bindings, label_count);
+
     return bindings;
 }
 
@@ -468,7 +470,7 @@ VariableStackBindings SwitchStatement::printAsm(VariableStackBindings bindings,
 	
 	if((*itr)->isDefault())
 	    printf("$%d_default_switch:\n", switch_count);
-	
+	(*itr)->linkStatement(nullptr);
 	(*itr)->printAsm(bindings, label_count);
     }
 
@@ -693,8 +695,11 @@ void ReturnStatement::countExpressionDepth(unsigned &depth_count) const
 BreakStatement::BreakStatement()
 {}
 
-VariableStackBindings BreakStatement::printAsm(VariableStackBindings bindings, unsigned &) const
+VariableStackBindings BreakStatement::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
+    if(next_statement_ != nullptr)
+	next_statement_->printAsm(bindings, label_count);
+    
     printf("\tb\t%s\n\tnop\n", bindings.breakLabel().c_str());
     return bindings;
 }
@@ -705,8 +710,11 @@ VariableStackBindings BreakStatement::printAsm(VariableStackBindings bindings, u
 ContinueStatement::ContinueStatement()
 {}
 
-VariableStackBindings ContinueStatement::printAsm(VariableStackBindings bindings, unsigned &) const
+VariableStackBindings ContinueStatement::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
+    if(next_statement_ != nullptr)
+	next_statement_->printAsm(bindings, label_count);
+    
     printf("\tb\t%s\n\tnop\n", bindings.continueLabel().c_str());
     return bindings;
 }
@@ -718,8 +726,11 @@ GotoStatement::GotoStatement(const std::string &label)
     : label_(label)
 {}
 
-VariableStackBindings GotoStatement::printAsm(VariableStackBindings bindings, unsigned &) const
+VariableStackBindings GotoStatement::printAsm(VariableStackBindings bindings, unsigned &label_count) const
 {
+    if(next_statement_ != nullptr)
+	next_statement_->printAsm(bindings, label_count);
+    
     printf("\tb\t%s\n\tnop\n", label_.c_str());
     return bindings;
 }
diff --git a/run_test_deliverable.sh b/run_test_deliverable.sh
index 03770a0..74a285d 100755
--- a/run_test_deliverable.sh
+++ b/run_test_deliverable.sh
@@ -1,17 +1,18 @@
 #!/bin/bash
 
-if [[ -z "$1" ]]; then 
+if [[ "$1" -eq 0 ]]; then 
     COMPILER=bin/c_compiler
-    #COMPILER=test_deliverable/c_compiler_ref.sh
-else
+elif [[ "$1" -eq 1 ]]; then
     COMPILER=bin/c_compiler
     make clean
     make -B ${COMPILER}
+elif [[ "$1" -eq 2 ]]; then
+    COMPILER=test_deliverable/c_compiler_ref.sh
 fi
 
 echo ""
 echo "========================================"
-echo " Testing compiler"
+echo " Testing compiler : ${COMPILER}"
 echo ""
 
 PASSED=0
diff --git a/test_deliverable/testcases/test_ALLOPER.c b/test_deliverable/testcases/test_ALLOPER.c
new file mode 100644
index 0000000..ab57181
--- /dev/null
+++ b/test_deliverable/testcases/test_ALLOPER.c
@@ -0,0 +1,28 @@
+int alloper(int a, int b, int c, int d, int f)
+{
+    a = b * c + d - f;
+    {
+	int c = 2;
+	b += c + 2;
+    }
+    a -= b;
+    d = a - c;
+    
+    if((a == b || a != c || b > d || f < d) && a)
+    {
+	a = 2 * b;
+    }
+    else
+    {
+	a -= d;
+    }
+
+    do
+    {
+	a += 1;
+	f++;
+    }
+    while(f < 50);
+    
+    return a;
+}
diff --git a/test_deliverable/testcases/test_ALLOPER_driver.c b/test_deliverable/testcases/test_ALLOPER_driver.c
new file mode 100644
index 0000000..dc29ac0
--- /dev/null
+++ b/test_deliverable/testcases/test_ALLOPER_driver.c
@@ -0,0 +1,6 @@
+int alloper(int, int, int, int, int);
+
+int main()
+{
+    return !( 58 == alloper(4, 3, 5, 4, 6) );
+}
diff --git a/test_deliverable/testcases/test_CONTINUE.c b/test_deliverable/testcases/test_CONTINUE.c
new file mode 100644
index 0000000..e907908
--- /dev/null
+++ b/test_deliverable/testcases/test_CONTINUE.c
@@ -0,0 +1,18 @@
+int cont(int a, int b)
+{
+    int c = 0;
+    while(a < b)
+    {
+	++a;
+	if(a < b/2)
+	{
+	    continue;
+	}
+	else
+	{
+	    c += 2;
+	}
+    }
+
+    return c;
+}
diff --git a/test_deliverable/testcases/test_CONTINUE_driver.c b/test_deliverable/testcases/test_CONTINUE_driver.c
new file mode 100644
index 0000000..4a9eb58
--- /dev/null
+++ b/test_deliverable/testcases/test_CONTINUE_driver.c
@@ -0,0 +1,6 @@
+int cont(int, int);
+
+int main()
+{
+    return !( 96 == cont(4, 93) );
+}
diff --git a/test_deliverable/testcases/test_GOTO.c b/test_deliverable/testcases/test_GOTO.c
new file mode 100644
index 0000000..4aa1266
--- /dev/null
+++ b/test_deliverable/testcases/test_GOTO.c
@@ -0,0 +1,17 @@
+int goto_(int a)
+{
+    goto helloWorld;
+
+start_:
+    a += 2;
+
+    goto end_;
+
+helloWorld:
+    a *= 3;
+    goto start_;
+
+end_:
+    a -= 1;
+    return a;
+}
diff --git a/test_deliverable/testcases/test_GOTO_driver.c b/test_deliverable/testcases/test_GOTO_driver.c
new file mode 100644
index 0000000..fe6ab06
--- /dev/null
+++ b/test_deliverable/testcases/test_GOTO_driver.c
@@ -0,0 +1,6 @@
+int goto_(int);
+
+int main()
+{
+    return !( 202 == goto_(67) );
+}
diff --git a/test_deliverable/testcases/test_LOGAND.c b/test_deliverable/testcases/test_LOGAND.c
new file mode 100644
index 0000000..6a16f72
--- /dev/null
+++ b/test_deliverable/testcases/test_LOGAND.c
@@ -0,0 +1,11 @@
+int logand(int a, int b)
+{
+    if(4 && 0)
+    {
+	return a * b;
+    }
+    else
+    {
+	return a * a * b;
+    }
+}
diff --git a/test_deliverable/testcases/test_LOGAND_driver.c b/test_deliverable/testcases/test_LOGAND_driver.c
new file mode 100644
index 0000000..32a0f0b
--- /dev/null
+++ b/test_deliverable/testcases/test_LOGAND_driver.c
@@ -0,0 +1,6 @@
+int logand(int, int);
+
+int main()
+{
+    return !( 36 == logand(3, 4) );
+}
diff --git a/test_deliverable/testcases/test_LOGICAL.c b/test_deliverable/testcases/test_LOGICAL.c
new file mode 100644
index 0000000..0bf68e2
--- /dev/null
+++ b/test_deliverable/testcases/test_LOGICAL.c
@@ -0,0 +1,4 @@
+int logical(int a, int b, int c)
+{
+    return (( (a != b || c == 2) && (3 / c + 2) ) && (5 / 2 + c)) + 32;
+}
diff --git a/test_deliverable/testcases/test_LOGICAL_driver.c b/test_deliverable/testcases/test_LOGICAL_driver.c
new file mode 100644
index 0000000..8bb333b
--- /dev/null
+++ b/test_deliverable/testcases/test_LOGICAL_driver.c
@@ -0,0 +1,6 @@
+int logical(int, int, int);
+
+int main()
+{
+    return !( 33 == logical(23, 392, 49) );
+}
diff --git a/test_deliverable/testcases/test_LOGOR.c b/test_deliverable/testcases/test_LOGOR.c
new file mode 100644
index 0000000..f079ab7
--- /dev/null
+++ b/test_deliverable/testcases/test_LOGOR.c
@@ -0,0 +1,7 @@
+int logor(int a, int b)
+{
+    if(a || b)
+	return a * b;
+    else
+	return a + b;
+}
diff --git a/test_deliverable/testcases/test_LOGOR_driver.c b/test_deliverable/testcases/test_LOGOR_driver.c
new file mode 100644
index 0000000..c8db0ef
--- /dev/null
+++ b/test_deliverable/testcases/test_LOGOR_driver.c
@@ -0,0 +1,6 @@
+int logor(int, int);
+
+int main()
+{
+    return !( 52 == logor(4, 13) );
+}
diff --git a/test_deliverable/testcases/test_NOT.c b/test_deliverable/testcases/test_NOT.c
new file mode 100644
index 0000000..1504d42
--- /dev/null
+++ b/test_deliverable/testcases/test_NOT.c
@@ -0,0 +1,6 @@
+int not(int a)
+{
+    a *= 4;
+
+    return !a;
+}
diff --git a/test_deliverable/testcases/test_NOT_driver.c b/test_deliverable/testcases/test_NOT_driver.c
new file mode 100644
index 0000000..1069052
--- /dev/null
+++ b/test_deliverable/testcases/test_NOT_driver.c
@@ -0,0 +1,6 @@
+int not(int);
+
+int main()
+{
+    return !( 5 == (not(0) * 5 + not(4)) );
+}
diff --git a/test_deliverable/testcases/test_SHADOWING.c b/test_deliverable/testcases/test_SHADOWING.c
new file mode 100644
index 0000000..a635ab5
--- /dev/null
+++ b/test_deliverable/testcases/test_SHADOWING.c
@@ -0,0 +1,9 @@
+int shadowing(int a, int b)
+{
+    {
+	int a = 2;
+	b = a;
+    }
+
+    return b + a;
+}
diff --git a/test_deliverable/testcases/test_SHADOWING1.c b/test_deliverable/testcases/test_SHADOWING1.c
new file mode 100644
index 0000000..fbc4a8a
--- /dev/null
+++ b/test_deliverable/testcases/test_SHADOWING1.c
@@ -0,0 +1,11 @@
+int f()
+{
+    int a = 5;
+    int b = 8;
+    {
+	int b = 2;
+	a = b-1;
+    }
+
+    return a * b;
+}
diff --git a/test_deliverable/testcases/test_SHADOWING1_driver.c b/test_deliverable/testcases/test_SHADOWING1_driver.c
new file mode 100644
index 0000000..0998c39
--- /dev/null
+++ b/test_deliverable/testcases/test_SHADOWING1_driver.c
@@ -0,0 +1,6 @@
+int f();
+
+int main()
+{
+    return !( 8 == f() );
+}
diff --git a/test_deliverable/testcases/test_SHADOWING_driver.c b/test_deliverable/testcases/test_SHADOWING_driver.c
new file mode 100644
index 0000000..52a2769
--- /dev/null
+++ b/test_deliverable/testcases/test_SHADOWING_driver.c
@@ -0,0 +1,6 @@
+int shadowing(int, int);
+
+int main()
+{
+    return !( 48 == shadowing(46, 29) );
+}
diff --git a/test_deliverable/testcases/test_SWITCHDEF_driver.c b/test_deliverable/testcases/test_SWITCHDEF_driver.c
index 091a2dd..d7dbdf1 100644
--- a/test_deliverable/testcases/test_SWITCHDEF_driver.c
+++ b/test_deliverable/testcases/test_SWITCHDEF_driver.c
@@ -2,5 +2,5 @@ int switchdef(int);
 
 int main()
 {
-    return ( 14 == switchdef(2) );
+    return !( 14 == switchdef(2) );
 }