Finished better expressions

9 files changed, 176 insertions, 40 deletions

diff --git a/Notes.org b/Notes.org
index d865313..509d913 100644
--- a/Notes.org
+++ b/Notes.org
@@ -3,7 +3,6 @@
 #+AUTHOR: Yann Herklotz
 #+EMAIL: ymherklotz@gmail.com
 #+DESCRIPTION: These are notes about the Compiler project.
-#+DATE: <2017-03-09 Thu>
 
 * Lexer
 
@@ -134,15 +133,17 @@
      Expressions like > or < or == etc..
 
 **** TODO Add more statements
-
-***** TODO If statement
+***** DONE If statement
       CLOCK: [2017-03-18 Sat 08:42]--[2017-03-18 Sat 09:57] =>  1:15
-
-
-
-***** TODO For statement
-***** TODO While statement
+***** DONE For statement
+***** DONE While statement
+***** TODO Do While statement
 **** DONE Fixing Seg fault 1
      CLOCK: [2017-03-17 Fri 15:44]--[2017-03-17 Fri 16:00] =>  0:16
 
      Have to fix type assigment for declaration lists, need to make new pointers of the right type.
+**** TODO Load more that 4 bytes into a variable.
+**** TODO Fix expressions and temporary variables
+
+     I have to store the temporary expression in normal registers.
+
diff --git a/c_compiler/include/bindings.hpp b/c_compiler/include/bindings.hpp
index 1104bb8..0afb3e9 100644
--- a/c_compiler/include/bindings.hpp
+++ b/c_compiler/include/bindings.hpp
@@ -33,6 +33,7 @@ public:
     void increaseStackPosition();
     void setStackPosition(int stack_counter);
     void nextExpressionStackPosition();
+    void setExpressionStackPosition(const int& stack_counter);
 
     int currentStackPosition() const;
     int stackPosition(const std::string& id) const;
diff --git a/c_compiler/include/expression.hpp b/c_compiler/include/expression.hpp
index 9a22ce7..313d678 100644
--- a/c_compiler/include/expression.hpp
+++ b/c_compiler/include/expression.hpp
@@ -25,6 +25,7 @@ public:
     virtual void print() const;
     virtual void printXml() 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);
@@ -46,6 +47,7 @@ public:
 
     virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const = 0;
 
+    virtual void expressionDepth(unsigned& depth_count) const;
     void evaluateExpression(VariableStackBindings bindings, unsigned& label_count) const;
 };
 
diff --git a/c_compiler/include/statement.hpp b/c_compiler/include/statement.hpp
index 121db2c..887ffc5 100644
--- a/c_compiler/include/statement.hpp
+++ b/c_compiler/include/statement.hpp
@@ -27,6 +27,7 @@ public:
 
     virtual void countVariables(unsigned& var_count) const = 0;
     virtual void countArguments(unsigned& argument_count) const = 0;
+    virtual void countExpressionDepth(unsigned& depth_count) const = 0;
 
     void linkStatement(Statement* next);
 };
@@ -47,7 +48,8 @@ public:
     virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
 
     virtual void countVariables(unsigned& var_count) const;
-    virtual void countArguments(unsigned& argument_count) const;    
+    virtual void countArguments(unsigned& argument_count) const;
+    virtual void countExpressionDepth(unsigned& depth_count) const;
 };
 
 
@@ -65,7 +67,8 @@ public:
     virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
 
     virtual void countVariables(unsigned& var_count) const;
-    virtual void countArguments(unsigned& argument_count) const;    
+    virtual void countArguments(unsigned& argument_count) const;
+    virtual void countExpressionDepth(unsigned& depth_count) const;
 };
 
 
@@ -81,7 +84,8 @@ public:
     virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
 
     virtual void countVariables(unsigned& var_count) const;
-    virtual void countArguments(unsigned& argument_count) const;    
+    virtual void countArguments(unsigned& argument_count) const;
+    virtual void countExpressionDepth(unsigned& depth_count) const;    
 };
 
 
@@ -98,6 +102,7 @@ public:
 
     virtual void countVariables(unsigned& var_count) const;
     virtual void countArguments(unsigned& argument_count) const;
+    virtual void countExpressionDepth(unsigned& depth_count) const;    
 };
 
 
@@ -114,7 +119,8 @@ public:
     virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const = 0;
 
     virtual void countVariables(unsigned& var_count) const;
-    virtual void countArguments(unsigned& argument_count) const;    
+    virtual void countArguments(unsigned& argument_count) const;
+    virtual void countExpressionDepth(unsigned& depth_count) const;
 };
 
 class WhileLoop : public IterationStatement
@@ -122,7 +128,7 @@ class WhileLoop : public IterationStatement
 public:
     WhileLoop(Expression* condition, Statement* statement);
 
-    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_cout) const;
+    virtual VariableStackBindings printAsm(VariableStackBindings bindings, unsigned& label_count) const;
 };
 
 class ForLoop : public IterationStatement
diff --git a/c_compiler/src/bindings.cpp b/c_compiler/src/bindings.cpp
index 05bd288..a76429c 100644
--- a/c_compiler/src/bindings.cpp
+++ b/c_compiler/src/bindings.cpp
@@ -6,7 +6,7 @@
 // VariableStackBindings definition
 
 VariableStackBindings::VariableStackBindings()
-    : stack_counter_(0), expression_stack_(-4)
+    : stack_counter_(0), expression_stack_(16)
 {}
 
 void VariableStackBindings::insertBinding(std::string id, TypePtr type, int stack_position)
@@ -30,7 +30,12 @@ void VariableStackBindings::setStackPosition(int stack_counter)
 
 void VariableStackBindings::nextExpressionStackPosition()
 {
-    expression_stack_ -= 4;
+    expression_stack_ += 4;
+}
+
+void VariableStackBindings::setExpressionStackPosition(const int& stack_counter)
+{
+    expression_stack_ = stack_counter;
 }
 
 int VariableStackBindings::currentStackPosition() const
diff --git a/c_compiler/src/c_parser.y b/c_compiler/src/c_parser.y
index 315d227..9e9997b 100644
--- a/c_compiler/src/c_parser.y
+++ b/c_compiler/src/c_parser.y
@@ -177,7 +177,7 @@ IdentifierList:	T_IDENTIFIER { $$ = new Declaration(); }
 
 StatementList:
 		Statement { $$ = $1; }
-|	StatementList Statement { $2->linkStatement($$); $$ = $2; printf("# Making statement list\n"); }
+	|	StatementList Statement { $2->linkStatement($$); $$ = $2; }
 		;
 
 Statement:	CompoundStatement { $$ = $1; }
@@ -205,7 +205,7 @@ SelectionStatement:
 
 ExpressionStatement:
 		T_SC { $$ = new ExpressionStatement(); }
-|	Expression T_SC { $$ = new ExpressionStatement($1); printf("# Adding Expression statement\n"); }
+|	Expression T_SC { $$ = new ExpressionStatement($1); }
 		;
 
 JumpStatement:	T_RETURN Expression T_SC { $$ = new JumpStatement($2); }
diff --git a/c_compiler/src/expression.cpp b/c_compiler/src/expression.cpp
index e780a55..e19d845 100644
--- a/c_compiler/src/expression.cpp
+++ b/c_compiler/src/expression.cpp
@@ -6,22 +6,25 @@
 // Expression definition
 
 void Expression::print() const
-{
-    std::cerr << "This expression has not been implemented yet" << std::endl;
-}
+{}
 
 void Expression::printXml() const
+{}
+
+void Expression::countArguments(unsigned& argument_count) const
 {
-    // Does nothing as I do not want it to appear in the xml output
+    // by default don't do anything to the count
+    (void)argument_count;
 }
 
-void Expression::countArguments(unsigned int &argument_count) const
+void Expression::expressionDepth(unsigned& depth_count) const
 {
-    (void)argument_count;
+    (void)depth_count;
 }
 
 int Expression::postfixStackPosition(VariableStackBindings bindings) const
 {
+    // call this if the expression is not a postfix expression
     std::cerr << "Error : Can't call 'getPostfixStackPosition(VariableStackBindings " <<
 	"bindings)' on this type of expression" << std::endl;
     (void)bindings;
@@ -30,11 +33,13 @@ int Expression::postfixStackPosition(VariableStackBindings bindings) const
 
 void Expression::setPostfixExpression(Expression *postfix_expression)
 {
+    // do nothing if expression isn't a postfix expression
     (void)postfix_expression;
 }
 
 std::string Expression::id() const
 {
+    // by default return empty id, which cannot be valid.
     return "";
 }
 
@@ -56,6 +61,20 @@ OperationExpression::OperationExpression(Expression* lhs, Expression* rhs)
     : lhs_(lhs), rhs_(rhs)
 {}
 
+void OperationExpression::expressionDepth(unsigned& depth_count) const
+{
+    unsigned lhs_depth_count = depth_count;
+    unsigned rhs_depth_count = depth_count+1;
+
+    lhs_->expressionDepth(lhs_depth_count);
+    rhs_->expressionDepth(rhs_depth_count);
+
+    if(lhs_depth_count > rhs_depth_count)
+	depth_count = lhs_depth_count;
+    else
+	depth_count = rhs_depth_count;
+}
+
 void OperationExpression::evaluateExpression(VariableStackBindings bindings, unsigned& label_count) const
 {
     // I can just evaluate the lhs with the same entry stack position
@@ -414,7 +433,6 @@ AssignmentExpression::AssignmentExpression(Expression* lhs, Expression* rhs)
 
 VariableStackBindings AssignmentExpression::printAsm(VariableStackBindings bindings, unsigned& label_count) const
 {
-    std::cout << "# Assignment at stack position: " << lhs_->postfixStackPosition(bindings) << std::endl;
     // TODO add stack and store results in there, also for addition and multiplication.
 
     // get the current location of lhs in the stack so that I can store result there
@@ -484,4 +502,3 @@ VariableStackBindings Constant::printAsm(VariableStackBindings bindings, unsigne
     std::cout << "\tsw\t$2," << bindings.currentExpressionStackPosition() << "($fp)" << std::endl;
     return bindings;
 }
-
diff --git a/c_compiler/src/function.cpp b/c_compiler/src/function.cpp
index c979277..55d8a2c 100644
--- a/c_compiler/src/function.cpp
+++ b/c_compiler/src/function.cpp
@@ -56,6 +56,11 @@ VariableStackBindings Function::printAsm(VariableStackBindings bindings, unsigne
     // Count the maximum number of arguments
     statement_->countArguments(max_argument_count);
 
+    unsigned max_depth = 0;
+    statement_->countExpressionDepth(max_depth);
+
+    std::cout << "# max depth: " << max_depth << "\n";
+
     if(max_argument_count < 4)
 	max_argument_count = 4;
 
@@ -63,7 +68,7 @@ VariableStackBindings Function::printAsm(VariableStackBindings bindings, unsigne
     countParameters(parameter_count);
     
     // This adds 2 to store the frame pointer and the return address
-    unsigned memory_needed = 4*(variable_count + max_argument_count + parameter_count + 2);
+    unsigned memory_needed = 4*(variable_count+max_argument_count+max_depth+parameter_count+2);
     
     // make frame double word aligned
     if(memory_needed % 8 != 0)
@@ -73,11 +78,12 @@ VariableStackBindings Function::printAsm(VariableStackBindings bindings, unsigne
 	      << memory_needed << "\n\tsw\t$31," << memory_needed-4 << "($sp)\n" << "\tsw\t$fp,"
 	      << memory_needed-8 << "($sp)\n\tmove\t$fp,$sp\n";
 
-    // TODO print asm for parameters
-    printParameterAsm(bindings, max_argument_count, memory_needed);
 
     // set the stack counter to the right value
     bindings.setStackPosition((max_argument_count+parameter_count)*4);
+    bindings.setExpressionStackPosition((max_argument_count+parameter_count+variable_count)*4);
+
+    printParameterAsm(bindings, max_argument_count, memory_needed);
     
     // Prints the asm for the compound statement in the function
     statement_->printAsm(bindings, label_count);
diff --git a/c_compiler/src/statement.cpp b/c_compiler/src/statement.cpp
index 84f517a..13e779f 100644
--- a/c_compiler/src/statement.cpp
+++ b/c_compiler/src/statement.cpp
@@ -51,10 +51,8 @@ void CompoundStatement::printXml() const
     std::cout << "</Scope>" << std::endl;
 }
 
-VariableStackBindings CompoundStatement::printAsm(VariableStackBindings bindings,
-						  unsigned& label_count) const
+VariableStackBindings CompoundStatement::printAsm(VariableStackBindings bindings, unsigned& label_count) const
 {
-    std::cout << "# printint compound statement" << std::endl;
     VariableStackBindings outer_scope_bindings = bindings;
     
     if(next_statement_ != nullptr)
@@ -103,6 +101,23 @@ void CompoundStatement::countArguments(unsigned& argument_count) const
 	statement_->countArguments(argument_count);
 }
 
+void CompoundStatement::countExpressionDepth(unsigned &depth_count) const
+{
+    unsigned previous_depth_count = depth_count;
+    if(next_statement_ != nullptr) {
+	next_statement_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+	previous_depth_count = depth_count;
+    }
+
+    if(statement_ != nullptr) {
+	statement_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+    }
+}
+
 
 // Selection Statement definition
 
@@ -129,10 +144,8 @@ void SelectionStatement::printXml() const
 	else_->printXml();
 }
 
-VariableStackBindings SelectionStatement::printAsm(VariableStackBindings bindings,
-						   unsigned& label_count) const
+VariableStackBindings SelectionStatement::printAsm(VariableStackBindings bindings, unsigned& label_count) const
 {
-    std::cout << "# If Statement\n";
     if(next_statement_ != nullptr)
 	next_statement_->printAsm(bindings, label_count);
     
@@ -177,6 +190,34 @@ void SelectionStatement::countArguments(unsigned& argument_count) const
 	else_->countArguments(argument_count);
 }
 
+void SelectionStatement::countExpressionDepth(unsigned& depth_count) const
+{
+    unsigned previous_depth_count = depth_count;
+
+    if(next_statement_ != nullptr) {
+	next_statement_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+	previous_depth_count = depth_count;
+    }
+
+    depth_count = 1;
+    condition_->expressionDepth(depth_count);
+    if(previous_depth_count > depth_count)
+	depth_count = previous_depth_count;
+    previous_depth_count = depth_count;
+    
+    if_->countExpressionDepth(depth_count);
+    if(previous_depth_count > depth_count)
+	depth_count = previous_depth_count;
+    previous_depth_count = depth_count;
+
+    if(else_ != nullptr) {
+	else_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+    }
+}
 
 // Expression Statement definition
 
@@ -190,10 +231,8 @@ void ExpressionStatement::print() const
 void ExpressionStatement::printXml() const
 {}
 
-VariableStackBindings ExpressionStatement::printAsm(VariableStackBindings bindings,
-						    unsigned& label_count) const
+VariableStackBindings ExpressionStatement::printAsm(VariableStackBindings bindings, unsigned& label_count) const
 {
-    std::cout << "# Expression Statement\n";
     if(next_statement_ != nullptr)
 	next_statement_->printAsm(bindings, label_count);
     
@@ -223,6 +262,25 @@ void ExpressionStatement::countArguments(unsigned& argument_count) const
 	argument_count = tmp_argument_count;
 }
 
+void ExpressionStatement::countExpressionDepth(unsigned& depth_count) const
+{
+    unsigned previous_depth_count = depth_count;
+
+    if(next_statement_ != nullptr) {
+	next_statement_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+	previous_depth_count = depth_count;
+    }
+
+    if(expression_ != nullptr) {
+	depth_count = 1;
+	expression_->expressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+    }
+}
+
 
 // Jump Statement definition
 
@@ -239,8 +297,7 @@ void JumpStatement::printXml() const
 	next_statement_->printXml();
 }
 
-VariableStackBindings JumpStatement::printAsm(VariableStackBindings bindings,
-					      unsigned& label_count) const
+VariableStackBindings JumpStatement::printAsm(VariableStackBindings bindings, unsigned& label_count) const
 {
     if(next_statement_ != nullptr)
 	next_statement_->printAsm(bindings, label_count);
@@ -273,6 +330,25 @@ void JumpStatement::countArguments(unsigned& argument_count) const
 	argument_count = tmp_argument_count;
 }
 
+void JumpStatement::countExpressionDepth(unsigned& depth_count) const
+{
+    unsigned previous_depth_count = depth_count;
+
+    if(next_statement_ != nullptr) {
+	next_statement_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+	previous_depth_count = depth_count;
+    }
+
+    if(expression_ != nullptr) {
+	depth_count = 1;
+	expression_->expressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+    }
+}
+
 
 // Iteration Statement definition
 
@@ -301,7 +377,7 @@ void IterationStatement::countVariables(unsigned& var_count) const
 	statement_->countVariables(var_count);
 }
 
-void IterationStatement::countArguments(unsigned int &argument_count) const
+void IterationStatement::countArguments(unsigned& argument_count) const
 {
     if(next_statement_ != nullptr)
 	next_statement_->countArguments(argument_count);
@@ -310,6 +386,28 @@ void IterationStatement::countArguments(unsigned int &argument_count) const
 	statement_->countArguments(argument_count);
 }
 
+void IterationStatement::countExpressionDepth(unsigned& depth_count) const
+{
+    unsigned previous_depth_count = depth_count;
+
+    if(next_statement_ != nullptr) {
+	next_statement_->countExpressionDepth(depth_count);
+	if(previous_depth_count > depth_count)
+	    depth_count = previous_depth_count;
+	previous_depth_count = depth_count;
+    }
+    
+    depth_count = 1;
+    condition_->expressionDepth(depth_count);
+    if(previous_depth_count > depth_count)
+	depth_count = previous_depth_count;
+    previous_depth_count = depth_count;
+
+    statement_->countExpressionDepth(depth_count);
+    if(previous_depth_count > depth_count)
+	depth_count = previous_depth_count;
+}
+
 
 // While Loop definition