From 5bb277cc67c7c3fa8fa3024f1ed3da81a71636e2 Mon Sep 17 00:00:00 2001 From: Yann Herklotz Date: Sun, 19 Mar 2017 19:36:49 +0000 Subject: Finished better expressions --- c_compiler/include/bindings.hpp | 1 + c_compiler/include/expression.hpp | 2 + c_compiler/include/statement.hpp | 16 +++-- c_compiler/src/bindings.cpp | 9 ++- c_compiler/src/c_parser.y | 4 +- c_compiler/src/expression.cpp | 33 ++++++++--- c_compiler/src/function.cpp | 12 +++- c_compiler/src/statement.cpp | 122 ++++++++++++++++++++++++++++++++++---- 8 files changed, 167 insertions(+), 32 deletions(-) (limited to 'c_compiler') 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 << "" << 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 -- cgit