From 8d3db310926c414d199fca62f0c349a263543096 Mon Sep 17 00:00:00 2001 From: Yann Herklotz Date: Mon, 13 Mar 2017 19:31:50 +0000 Subject: Reformatting --- Notes.org | 6 ++ c_compiler/include/bindings.hpp | 19 ++-- c_compiler/include/declaration.hpp | 22 ++-- c_compiler/include/expression.hpp | 43 ++++---- c_compiler/include/function.hpp | 19 ++-- c_compiler/include/node.hpp | 4 +- c_compiler/include/statement.hpp | 61 +++++------ c_compiler/include/translation_unit.hpp | 11 +- c_compiler/include/type.hpp | 16 +-- c_compiler/src/bindings.cpp | 39 ++++--- c_compiler/src/c_parser.y | 73 ++++++-------- c_compiler/src/compiler_main.cpp | 2 +- c_compiler/src/declaration.cpp | 72 ++++++------- c_compiler/src/expression.cpp | 86 ++++++++-------- c_compiler/src/function.cpp | 43 ++++---- c_compiler/src/statement.cpp | 174 ++++++++++++++++---------------- c_compiler/src/translation_unit.cpp | 25 +++-- c_compiler/src/type.cpp | 14 +-- 18 files changed, 361 insertions(+), 368 deletions(-) diff --git a/Notes.org b/Notes.org index 844367d..f9df1ff 100644 --- a/Notes.org +++ b/Notes.org @@ -102,6 +102,11 @@ Implement the adding to the bindings part that has to be added in the statements and declarations. +***** TODO Store expression results on the stack + + To do this I created a function in my VariableStackBindings that will store the + position of the stack that will be used for the next expression. + ***** TODO Work on expressions ***** TODO Comment code @@ -115,6 +120,7 @@ ****** TODO Implement multiplication + **** TODO Expression ***** printasm(VSB binding) diff --git a/c_compiler/include/bindings.hpp b/c_compiler/include/bindings.hpp index 5dd1e1f..512e426 100644 --- a/c_compiler/include/bindings.hpp +++ b/c_compiler/include/bindings.hpp @@ -1,7 +1,6 @@ #ifndef BINDINGS_HPP #define BINDINGS_HPP -#include #include #include #include @@ -15,7 +14,7 @@ typedef std::shared_ptr TypePtr; struct DeclarationData { TypePtr type; - int32_t stack_position; + int stack_position; }; @@ -23,22 +22,22 @@ struct DeclarationData class VariableStackBindings { private: - std::map bindings; - int32_t stack_counter; - int8_t current_register; + std::map bindings_; + int stack_counter_; + unsigned expression_stack_; public: VariableStackBindings(); void insertBinding(std::string id, TypePtr type, int32_t stack_position); void increaseStackPosition(); - void resetRegister(); - void increaseRegister(); + void resetExpressionStack(); + void nextExpressionStackPosition(); - int32_t getCurrentStackPosition() const; - int32_t getStackPosition(const std::string& id) const; + int currentStackPosition() const; + int stackPosition(const std::string& id) const; - int8_t getCurrentRegister() const; + unsigned currentExpressionStackPosition() const; bool bindingExists(const std::string& id) const; }; diff --git a/c_compiler/include/declaration.hpp b/c_compiler/include/declaration.hpp index 08fd641..4fe754a 100644 --- a/c_compiler/include/declaration.hpp +++ b/c_compiler/include/declaration.hpp @@ -16,23 +16,23 @@ typedef std::shared_ptr DeclarationPtr; class Declaration : public Node { private: - TypePtr type; - std::string id; - ExpressionPtr init; - DeclarationPtr next_decl; - DeclarationPtr list_next_decl; + TypePtr type_; + std::string id_; + ExpressionPtr initializer_; + DeclarationPtr next_declaration_; + DeclarationPtr next_list_declaration_; public: - Declaration(const std::string& _id = "", Expression* _init = nullptr); + Declaration(const std::string& id = "", Expression* initializer = nullptr); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - void addDeclaration(Declaration* _next_decl); - void addList(Declaration* _next_decl); + void linkDeclaration(Declaration* next_declaration); + void linkListDeclaration(Declaration* next_list_declaration); - void setType(Type* _type); + void setType(Type* type); DeclarationPtr getNext() const; DeclarationPtr getNextListItem() const; diff --git a/c_compiler/include/expression.hpp b/c_compiler/include/expression.hpp index a4939a9..ae186d1 100644 --- a/c_compiler/include/expression.hpp +++ b/c_compiler/include/expression.hpp @@ -2,8 +2,11 @@ #define AST_EXPRESSION_HPP #include "node.hpp" +#include "bindings.hpp" +#include #include +#include class Expression; @@ -13,79 +16,79 @@ typedef std::shared_ptr ExpressionPtr; class Expression : public Node { public: - virtual VariableStackBindings printasm(VariableStackBindings bindings) const = 0; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const = 0; virtual void print() const; - virtual void printxml() const; - virtual int32_t getPostfixStackPosition(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual int postfixStackPosition(VariableStackBindings bindings) const; }; class OperationExpression : public Expression { protected: - ExpressionPtr lhs; - ExpressionPtr rhs; + ExpressionPtr lhs_; + ExpressionPtr rhs_; public: - OperationExpression(Expression* _lhs, Expression* _rhs); + OperationExpression(Expression* lhs, Expression* rhs); - virtual VariableStackBindings printasm(VariableStackBindings bindings) const = 0; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const = 0; }; class AssignmentExpression : public OperationExpression { public: - AssignmentExpression(Expression* _lhs, Expression* _rhs); + AssignmentExpression(Expression* lhs, Expression* rhs); - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; }; class AdditiveExpression : public OperationExpression { private: - std::string operation; + std::string operation_; public: - AdditiveExpression(Expression* _lhs, const std::string& _operation, Expression* _rhs); + AdditiveExpression(Expression* lhs, const std::string& operation, Expression* rhs); - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; }; class MultiplicativeExpression : public OperationExpression { private: - std::string operation; + std::string operation_; public: - MultiplicativeExpression(Expression* _lhs, const std::string& _operation, Expression* _rhs); + MultiplicativeExpression(Expression* lhs, const std::string& operation, Expression* rhs); - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; }; class Identifier : public Expression { private: - std::string m_id; + std::string id_; public: Identifier(const std::string& id); - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; - virtual int32_t getPostfixStackPosition(VariableStackBindings bindings) const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; + virtual int postfixStackPosition(VariableStackBindings bindings) const; }; class Constant : public Expression { private: - int32_t m_constant; + int32_t constant_; public: Constant(const int32_t& constant); - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; }; diff --git a/c_compiler/include/function.hpp b/c_compiler/include/function.hpp index 57e0ac1..dc8640e 100644 --- a/c_compiler/include/function.hpp +++ b/c_compiler/include/function.hpp @@ -1,9 +1,14 @@ #ifndef AST_FUNCTION_HPP #define AST_FUNCTION_HPP +#include "bindings.hpp" +#include "declaration.hpp" #include "node.hpp" +#include "statement.hpp" +#include "type.hpp" #include +#include class Declaration; class Statement; @@ -18,17 +23,17 @@ typedef std::shared_ptr FunctionPtr; class Function : public Node { protected: - TypePtr type; - std::string id; - DeclarationPtr parameter_list; - StatementPtr statement; + TypePtr type_; + std::string id_; + DeclarationPtr parameter_list_; + StatementPtr statement_; public: - Function(const std::string& _id, Declaration* _parameter_list, Statement* _statement); + Function(const std::string& id, Declaration* parameter_list, Statement* statement); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; }; diff --git a/c_compiler/include/node.hpp b/c_compiler/include/node.hpp index e14a711..f27c804 100644 --- a/c_compiler/include/node.hpp +++ b/c_compiler/include/node.hpp @@ -16,8 +16,8 @@ public: virtual ~Node() {} virtual void print() const = 0; - virtual void printxml() const = 0; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const = 0; + virtual void printXml() const = 0; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const = 0; }; diff --git a/c_compiler/include/statement.hpp b/c_compiler/include/statement.hpp index d491b68..76d9303 100644 --- a/c_compiler/include/statement.hpp +++ b/c_compiler/include/statement.hpp @@ -1,12 +1,13 @@ #ifndef AST_STATEMENT_HPP #define AST_STATEMENT_HPP +#include "bindings.hpp" +#include "declaration.hpp" +#include "expression.hpp" #include "node.hpp" #include -class Declaration; -class Expression; class Statement; typedef std::shared_ptr DeclarationPtr; @@ -16,92 +17,92 @@ typedef std::shared_ptr StatementPtr; class Statement : public Node { protected: - StatementPtr next_statement; + StatementPtr next_statement_; public: Statement(Statement* statement = nullptr); virtual void print() const = 0; - virtual void printxml() const = 0; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const = 0; + virtual void printXml() const = 0; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const = 0; - virtual void count_variables(int32_t& var_count) const = 0; + virtual void countVariables(unsigned& var_count) const = 0; - void addStatement(Statement* _next); + void linkStatement(Statement* next); }; class CompoundStatement : public Statement { protected: - DeclarationPtr m_decl; - StatementPtr m_statement; + DeclarationPtr declaration_; + StatementPtr statement_; public: - CompoundStatement(Declaration* decl = nullptr, Statement* statement = nullptr); + CompoundStatement(Declaration* declaration = nullptr, Statement* statement = nullptr); CompoundStatement(Statement* statement); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - virtual void count_variables(int32_t& var_count) const; + virtual void countVariables(unsigned& var_count) const; }; class SelectionStatement : public Statement { protected: - StatementPtr m_if; - StatementPtr m_else; + StatementPtr if_; + StatementPtr else_; public: SelectionStatement(Statement* _if = nullptr, Statement* _else = nullptr); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - virtual void count_variables(int32_t& var_count) const; + virtual void countVariables(unsigned& var_count) const; }; class ExpressionStatement : public Statement { protected: - ExpressionPtr m_expr; + ExpressionPtr expr_; public: ExpressionStatement(Expression* expr = nullptr); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - virtual void count_variables(int32_t& var_count) const; + virtual void countVariables(unsigned& var_count) const; }; class JumpStatement : public Statement { protected: - ExpressionPtr m_expr; + ExpressionPtr expr_; public: JumpStatement(Expression* expr = nullptr); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - virtual void count_variables(int32_t& var_count) const; + virtual void countVariables(unsigned& var_count) const; }; class IterationStatement : public Statement { protected: - StatementPtr m_statement; + StatementPtr statement_; public: IterationStatement(Statement* statement); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - virtual void count_variables(int32_t& var_count) const; + virtual void countVariables(unsigned& var_count) const; }; diff --git a/c_compiler/include/translation_unit.hpp b/c_compiler/include/translation_unit.hpp index 75ee53b..3e8197a 100644 --- a/c_compiler/include/translation_unit.hpp +++ b/c_compiler/include/translation_unit.hpp @@ -1,6 +1,7 @@ #ifndef TRANSLATION_UNIT_HPP #define TRANSLATION_UNIT_HPP +#include "bindings.hpp" #include "node.hpp" #include @@ -11,16 +12,16 @@ typedef std::shared_ptr NodePtr; class TranslationUnit : public Node { protected: - std::vector translation_unit; + std::vector translation_unit_; public: - TranslationUnit(Node* decl); + TranslationUnit(Node* external_declaration); virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; - void push(Node* decl); + void push(Node* external_declaration); }; diff --git a/c_compiler/include/type.hpp b/c_compiler/include/type.hpp index 608b660..80afdfe 100644 --- a/c_compiler/include/type.hpp +++ b/c_compiler/include/type.hpp @@ -1,9 +1,11 @@ #ifndef TYPE_HPP #define TYPE_HPP +#include "bindings.hpp" #include "node.hpp" #include +#include class Type; @@ -12,8 +14,8 @@ typedef std::shared_ptr TypePtr; class Type : public Node { public: virtual void print() const; - virtual void printxml() const; - virtual VariableStackBindings printasm(VariableStackBindings bindings) const; + virtual void printXml() const; + virtual VariableStackBindings printAsm(VariableStackBindings bindings) const; virtual std::string getType() const = 0; }; @@ -27,10 +29,10 @@ public: class Pointer : public Type { protected: - TypePtr pointer_type; + TypePtr pointer_type_; public: - Pointer(Type* _pointer_type); + Pointer(Type* pointer_type); virtual std::string getType() const; }; @@ -38,11 +40,11 @@ public: class Array : public Type { protected: - int32_t size; - TypePtr array_type; + TypePtr array_type_; + unsigned size_; public: - Array(Type* _array_type, int32_t _size = 0); + Array(Type* array_type, unsigned size = 0); virtual std::string getType() const; }; diff --git a/c_compiler/src/bindings.cpp b/c_compiler/src/bindings.cpp index 80375e7..ba3fdfd 100644 --- a/c_compiler/src/bindings.cpp +++ b/c_compiler/src/bindings.cpp @@ -6,63 +6,58 @@ // VariableStackBindings definition VariableStackBindings::VariableStackBindings() - : stack_counter(4), current_register(2) + : stack_counter_(4), expression_stack_(-4) {} -void VariableStackBindings::insertBinding(std::string id, TypePtr type, int32_t stack_position) +void VariableStackBindings::insertBinding(std::string id, TypePtr type, int stack_position) { DeclarationData decl_data; decl_data.type = type; decl_data.stack_position = stack_position; - bindings.insert(std::pair(id, decl_data)); + bindings_.insert(std::pair(id, decl_data)); } void VariableStackBindings::increaseStackPosition() { - stack_counter += 4; + stack_counter_ += 4; } -void VariableStackBindings::resetRegister() +void VariableStackBindings::resetExpressionStack() { - current_register = 2; + expression_stack_ = -4; } -void VariableStackBindings::increaseRegister() +void VariableStackBindings::nextExpressionStackPosition() { - if(current_register == 15) - current_register = 24; - else if(current_register == 25) - std::cerr << "Error : cannot allocate more registers" << std::endl; - else - current_register++; + expression_stack_ -= 4; } -int32_t VariableStackBindings::getCurrentStackPosition() const +int VariableStackBindings::currentStackPosition() const { - return stack_counter; + return stack_counter_; } -int32_t VariableStackBindings::getStackPosition(const std::string &id) const +int VariableStackBindings::stackPosition(const std::string &id) const { - auto binding = bindings.find(id); + auto binding = bindings_.find(id); - if(binding != bindings.end()) + if(binding != bindings_.end()) return (*binding).second.stack_position; else return 0; } -int8_t VariableStackBindings::getCurrentRegister() const +unsigned VariableStackBindings::currentExpressionStackPosition() const { - return current_register; + return expression_stack_; } bool VariableStackBindings::bindingExists(const std::string &id) const { - auto binding = bindings.find(id); + auto binding = bindings_.find(id); - if(binding == bindings.end()) + if(binding == bindings_.end()) return false; else diff --git a/c_compiler/src/c_parser.y b/c_compiler/src/c_parser.y index 5a35c63..e87f8f7 100644 --- a/c_compiler/src/c_parser.y +++ b/c_compiler/src/c_parser.y @@ -37,12 +37,12 @@ void yyerror(const char *); T_LOG_AND T_OR T_XOR T_AND T_EQUALITY_OP T_REL_OP T_SHIFT_OP T_MULT T_DIV T_REM T_TILDE T_NOT T_DOT T_ARROW T_INCDEC T_ADDSUB_OP T_ASSIGN_OPER T_EQ T_SIZEOF T_INT_CONST T_IF T_WHILE T_DO T_FOR T_RETURN - + T_VOID T_CHAR T_SCHAR T_UCHAR T_SSINT T_USINT T_LINT T_ULINT T_UINT T_SINT %nonassoc T_RRB %nonassoc T_ELSE - + %type ExternalDeclaration @@ -97,28 +97,25 @@ ExternalDeclaration: // FUNCTION DEFINITION FunctionDefinition: -DeclarationSpec T_IDENTIFIER T_LRB ParameterList T_RRB CompoundStatement { $$ = new Function(*$2, $4, $6); delete $2; } + DeclarationSpec T_IDENTIFIER T_LRB ParameterList T_RRB CompoundStatement { $$ = new Function(*$2, $4, $6); delete $2; } ; -ParameterList: - %empty { $$ = new Declaration(); } +ParameterList:% empty { $$ = new Declaration(); } | Parameter { $$ = $1; } - | ParameterList T_CMA Parameter { $3->addDeclaration($$); $$ = $3;} + | ParameterList T_CMA Parameter { $3->linkDeclaration($$); $$ = $3;} ; -Parameter: -DeclarationSpec T_IDENTIFIER { $$ = new Declaration(*$2); delete $2; } +Parameter: DeclarationSpec T_IDENTIFIER { $$ = new Declaration(*$2); delete $2; } ; // Declaration DeclarationList: Declaration { $$ = $1; } - | DeclarationList Declaration { $2->addDeclaration($$); $$ = $2; } + | DeclarationList Declaration { $2->linkDeclaration($$); $$ = $2; } ; -Declaration: - DeclarationSpec InitDeclaratorList T_SC { +Declaration: DeclarationSpec InitDeclaratorList T_SC { $$ = $2; Declaration* tmp_decl = $2; @@ -142,17 +139,15 @@ DeclarationSpec: ; InitDeclaratorList: -InitDeclarator { $$ = new Declaration(*$1); delete $1;} - | InitDeclaratorList T_CMA InitDeclarator { $3->addList($$); $$ = $3; } + InitDeclarator { $$ = new Declaration(*$1); delete $1;} + | InitDeclaratorList T_CMA InitDeclarator { $3->linkListDeclaration($$); $$ = $3; } ; -InitDeclarator: -Declarator { $$ = new Declaration(*$1); delete $1; } -| Declarator T_EQ AssignmentExpression { $$ = new Declaration(*$1, $3); delete $1; } +InitDeclarator: Declarator { $$ = new Declaration(*$1); delete $1; } + | Declarator T_EQ AssignmentExpression { $$ = new Declaration(*$1, $3); delete $1; } ; -Declarator: - DirectDeclarator { $$ = $1; } +Declarator: DirectDeclarator { $$ = $1; } | T_MULT DirectDeclarator { $$ = $2; } ; @@ -165,19 +160,17 @@ DirectDeclarator: | DirectDeclarator T_LRB IdentifierList T_RRB { $$ = $1; } ; -IdentifierList: - T_IDENTIFIER { $$ = new Declaration(); } +IdentifierList: T_IDENTIFIER { $$ = new Declaration(); } | IdentifierList T_CMA T_IDENTIFIER { $$ = new Declaration(); } // Statement StatementList: Statement { $$ = $1; } - | StatementList Statement { $2->addStatement($$); $$ = $2; } + | StatementList Statement { $2->linkStatement($$); $$ = $2; } ; -Statement: - CompoundStatement { $$ = $1; } +Statement: CompoundStatement { $$ = $1; } | SelectionStatement { $$ = $1; } | ExpressionStatement { $$ = $1; } | JumpStatement { $$ = $1; } @@ -202,11 +195,10 @@ SelectionStatement: ExpressionStatement: T_SC { $$ = new ExpressionStatement(); } -| Expression T_SC { $$ = new ExpressionStatement($1); } + | Expression T_SC { $$ = new ExpressionStatement($1); } ; -JumpStatement: - T_RETURN Expression T_SC { $$ = new JumpStatement($2); } +JumpStatement: T_RETURN Expression T_SC { $$ = new JumpStatement($2); } ; IterationStatement: @@ -217,17 +209,15 @@ IterationStatement: // Expressions -Expression: - AssignmentExpression { $$ = $1; } +Expression: AssignmentExpression { $$ = $1; } ; AssignmentExpression: ConditionalExpression { $$ = $1; } -| UnaryExpression ASSIGN_OPER AssignmentExpression { $$ = new AssignmentExpression($1, $3); } + | UnaryExpression ASSIGN_OPER AssignmentExpression { $$ = new AssignmentExpression($1, $3); } ; -ASSIGN_OPER: - T_ASSIGN_OPER { ; } +ASSIGN_OPER: T_ASSIGN_OPER { ; } | T_EQ { ; } ; @@ -256,8 +246,7 @@ ExclusiveOrExpression: | ExclusiveOrExpression T_XOR AndExpression { $$ = $3; } ; -AndExpression: - EqualityExpression { $$ = $1; } +AndExpression: EqualityExpression { $$ = $1; } | AndExpression T_AND EqualityExpression { $$ = $3; } ; @@ -278,22 +267,20 @@ ShiftExpression: AdditiveExpression: MultiplicativeExpression { $$ = $1; } -| AdditiveExpression T_ADDSUB_OP MultiplicativeExpression { $$ = new AdditiveExpression($1, *$2, $3); delete $2; } + | AdditiveExpression T_ADDSUB_OP MultiplicativeExpression { $$ = new AdditiveExpression($1, *$2, $3); delete $2; } ; MultiplicativeExpression: CastExpression { $$ = $1; } -| MultiplicativeExpression MultDivRemOP CastExpression { $$ = new MultiplicativeExpression($1, *$2, $3); delete $2; } + | MultiplicativeExpression MultDivRemOP CastExpression { $$ = new MultiplicativeExpression($1, *$2, $3); delete $2; } ; -MultDivRemOP: - T_MULT { $$ = $1; } +MultDivRemOP: T_MULT { $$ = $1; } | T_DIV { $$ = $1; } | T_REM { $$ = $1; } ; -CastExpression: - UnaryExpression { $$ = $1; } +CastExpression: UnaryExpression { $$ = $1; } | T_LRB DeclarationSpec T_RRB CastExpression { $$ = $4; } ; @@ -305,8 +292,7 @@ UnaryExpression: | T_SIZEOF T_LRB DeclarationSpec T_RRB { $$ = new Constant(0); } ; -UnaryOperator: - T_AND { $$ = $1; } +UnaryOperator: T_AND { $$ = $1; } | T_ADDSUB_OP { $$ = $1; } | T_MULT { $$ = $1; } | T_TILDE { $$ = $1; } @@ -333,13 +319,12 @@ ArgumentExpressionList: ; PrimaryExpression: -T_IDENTIFIER { $$ = new Identifier(*$1); delete $1; } + T_IDENTIFIER { $$ = new Identifier(*$1); delete $1; } | Constant { $$ = $1; } | T_LRB Expression T_RRB { $$ = $2; } ; -Constant: - T_INT_CONST { $$ = new Constant($1); } +Constant: T_INT_CONST { $$ = new Constant($1); } ; %% diff --git a/c_compiler/src/compiler_main.cpp b/c_compiler/src/compiler_main.cpp index dc243e0..0805de3 100644 --- a/c_compiler/src/compiler_main.cpp +++ b/c_compiler/src/compiler_main.cpp @@ -11,7 +11,7 @@ int main(int argc, char *argv[]) VariableStackBindings bindings; - ast->printasm(bindings); + ast->printAsm(bindings); return 0; } diff --git a/c_compiler/src/declaration.cpp b/c_compiler/src/declaration.cpp index dfe6158..9faf133 100644 --- a/c_compiler/src/declaration.cpp +++ b/c_compiler/src/declaration.cpp @@ -8,33 +8,33 @@ // Declaration definition -Declaration::Declaration(const std::string& _id, Expression* _init) - : id(_id), init(_init) +Declaration::Declaration(const std::string& id, Expression* initializer) + : id_(id), initializer_(initializer) {} void Declaration::print() const { - if(next_decl != nullptr) - next_decl->print(); + if(next_declaration_ != nullptr) + next_declaration_->print(); - if(id != "") - std::cout << id << std::endl; + if(id_ != "") + std::cout << id_ << std::endl; } -void Declaration::printxml() const +void Declaration::printXml() const { - if(next_decl != nullptr) - next_decl->printxml(); + if(next_declaration_ != nullptr) + next_declaration_->printXml(); - if(list_next_decl != nullptr) { - list_next_decl->printxml(); + if(next_list_declaration_ != nullptr) { + next_list_declaration_->printXml(); } - if(id != "") - std::cout << "" << std::endl; + if(id_ != "") + std::cout << "" << std::endl; } -VariableStackBindings Declaration::printasm(VariableStackBindings bindings) const +VariableStackBindings Declaration::printAsm(VariableStackBindings bindings) const { // if(init == nullptr) // std::cout << "\t.comm\t" << id << ",4,4" << std::endl; @@ -45,23 +45,23 @@ VariableStackBindings Declaration::printasm(VariableStackBindings bindings) cons // return bindings; - if(next_decl != nullptr) - bindings = next_decl->printasm(bindings); + if(next_declaration_ != nullptr) + bindings = next_declaration_->printAsm(bindings); - if(list_next_decl != nullptr) - bindings = list_next_decl->printasm(bindings); + if(next_list_declaration_ != nullptr) + bindings = next_list_declaration_->printAsm(bindings); - if(id != "") { - if(init != nullptr) - init->printasm(bindings); + if(id_ != "") { + if(initializer_ != nullptr) + initializer_->printAsm(bindings); else std::cout << "\tmove\t$2,$0" << std::endl; - int32_t stack_position = bindings.getCurrentStackPosition(); + int32_t stack_position = bindings.currentStackPosition(); std::cout << "\tsw\t$2," << stack_position << "($fp)" << std::endl; - bindings.insertBinding(id, type, stack_position); + bindings.insertBinding(id_, type_, stack_position); bindings.increaseStackPosition(); } @@ -69,40 +69,40 @@ VariableStackBindings Declaration::printasm(VariableStackBindings bindings) cons return bindings; } -void Declaration::addDeclaration(Declaration* _next_decl) +void Declaration::linkDeclaration(Declaration* next_declaration) { - DeclarationPtr decl_ptr(_next_decl); - next_decl = decl_ptr; + DeclarationPtr decl_ptr(next_declaration); + next_declaration_ = decl_ptr; } -void Declaration::addList(Declaration* _next_decl) +void Declaration::linkListDeclaration(Declaration* next_declaration) { - DeclarationPtr decl_ptr(_next_decl); - list_next_decl = decl_ptr; + DeclarationPtr decl_ptr(next_declaration); + next_list_declaration_ = decl_ptr; } -void Declaration::setType(Type* _type) +void Declaration::setType(Type* type) { - TypePtr type_ptr(_type); - type = type_ptr; + TypePtr type_ptr(type); + type_ = type_ptr; } DeclarationPtr Declaration::getNext() const { - return next_decl; + return next_declaration_; } DeclarationPtr Declaration::getNextListItem() const { - return list_next_decl; + return next_list_declaration_; } std::string Declaration::getId() const { - return id; + return id_; } std::string Declaration::getType() const { - return type->getType(); + return type_->getType(); } diff --git a/c_compiler/src/expression.cpp b/c_compiler/src/expression.cpp index dea282f..5e15f42 100644 --- a/c_compiler/src/expression.cpp +++ b/c_compiler/src/expression.cpp @@ -1,5 +1,4 @@ #include "expression.hpp" -#include "bindings.hpp" #include @@ -10,14 +9,14 @@ void Expression::print() const std::cerr << "This expression has not been implemented yet" << std::endl; } -void Expression::printxml() const +void Expression::printXml() const { // Does nothing as I do not want it to appear in the xml output } -int32_t Expression::getPostfixStackPosition(VariableStackBindings bindings) const +int Expression::postfixStackPosition(VariableStackBindings bindings) const { - std::cerr << "Error: Can't call 'getPostfixStackPosition(VariableStackBindings " << + std::cerr << "Error : Can't call 'getPostfixStackPosition(VariableStackBindings " << "bindings)' on this type of expression" << std::endl; (void)bindings; return -1; @@ -26,54 +25,61 @@ int32_t Expression::getPostfixStackPosition(VariableStackBindings bindings) cons // OperationExpression definition -OperationExpression::OperationExpression(Expression* _lhs, Expression* _rhs) - : lhs(_lhs), rhs(_rhs) +OperationExpression::OperationExpression(Expression* lhs, Expression* rhs) + : lhs_(lhs), rhs_(rhs) {} // Assignment Expression definition -AssignmentExpression::AssignmentExpression(Expression* _lhs, Expression* _rhs) - : OperationExpression(_lhs, _rhs) +AssignmentExpression::AssignmentExpression(Expression* lhs, Expression* rhs) + : OperationExpression(lhs, rhs) {} -VariableStackBindings AssignmentExpression::printasm(VariableStackBindings bindings) const +VariableStackBindings AssignmentExpression::printAsm(VariableStackBindings bindings) const { + // TODO // the lhs is forced to have a stack position due to it being a function, array or other type of variable - int32_t store_stack_position = lhs->getPostfixStackPosition(bindings); - rhs->printasm(bindings); + /*unsigned current_stack = bindings.currentRegister(); + // std::cout << "Current Register: " << current_reg << std::endl; + bindings.increaseRegister(); + + int store_stack_position = lhs->getPostfixStackPosition(bindings); + + rhs->printAsm(bindings); // we are assigning so we don't have to evaluate the lhs as it will be overwritten anyways - std::cout << "\tsw\t$2," << store_stack_position << "($fp)" << std::endl; + std::cout << "\tsw\t$" << current_reg << "," << store_stack_position + << "($fp)" << std::endl; */ return bindings; } // Additive Expression definition -AdditiveExpression::AdditiveExpression(Expression* _lhs, const std::string& _operation, Expression* _rhs) - : OperationExpression(_lhs, _rhs), operation(_operation) +AdditiveExpression::AdditiveExpression(Expression* lhs, const std::string& operation, Expression* rhs) + : OperationExpression(lhs, rhs), operation_(operation) {} -VariableStackBindings AdditiveExpression::printasm(VariableStackBindings bindings) const +VariableStackBindings AdditiveExpression::printAsm(VariableStackBindings bindings) const { - lhs->printasm(bindings); + lhs_->printAsm(bindings); // move the rhs out of the way to be able to evaluate the lhs std::cout << "\tmove\t$3,$2" << std::endl; - rhs->printasm(bindings); + rhs_->printAsm(bindings); // then perform the right operation // currently using signed and sub because I only have signed numbers implemented // must update this as I add more types - if(operation == "+") + if(operation_ == "+") std::cout << "\tadd\t$2,$3,$2" << std::endl; - else if(operation == "-") + else if(operation_ == "-") std::cout << "\tsub\t$2,$3,$2" << std::endl; else - std::cerr << "Don't recognize symbol: '" << operation << "'" << std::endl; + std::cerr << "Don't recognize symbol: '" << operation_ << "'" << std::endl; return bindings; } @@ -82,29 +88,29 @@ VariableStackBindings AdditiveExpression::printasm(VariableStackBindings binding // Multiplicative Expression definition -MultiplicativeExpression::MultiplicativeExpression(Expression* _lhs, const std::string& _operation, Expression* _rhs) - : OperationExpression(_lhs, _rhs), operation(_operation) +MultiplicativeExpression::MultiplicativeExpression(Expression* lhs, const std::string& operation, Expression* rhs) + : OperationExpression(lhs, rhs), operation_(operation) {} -VariableStackBindings MultiplicativeExpression::printasm(VariableStackBindings bindings) const +VariableStackBindings MultiplicativeExpression::printAsm(VariableStackBindings bindings) const { - lhs->printasm(bindings); + lhs_->printAsm(bindings); std::cout << "\tmove\t$3,$2" << std::endl; - rhs->printasm(bindings); + rhs_->printAsm(bindings); // then perform the right operation - if(operation == "*") + if(operation_ == "*") std::cout << "\tmul\t$2,$3,$2" << std::endl; - else if(operation == "/" || operation == "%") { + else if(operation_ == "/" || operation_ == "%") { std::cout << "\tdiv\t$3,$2" << std::endl; - if(operation == "/") + if(operation_ == "/") std::cout << "\tmflo\t$2" << std::endl; else std::cout << "\tmfhi\t$2" << std::endl; } else - std::cerr << "Don't recognize symbol '" << operation << "'" << std::endl; + std::cerr << "Don't recognize symbol '" << operation_ << "'" << std::endl; return bindings; } @@ -113,25 +119,23 @@ VariableStackBindings MultiplicativeExpression::printasm(VariableStackBindings b // Identifier definition Identifier::Identifier(const std::string& id) - : m_id(id) + : id_(id) {} -VariableStackBindings Identifier::printasm(VariableStackBindings bindings) const +VariableStackBindings Identifier::printAsm(VariableStackBindings bindings) const { - if(bindings.bindingExists(m_id)) { - int32_t stack_position = bindings.getStackPosition(m_id); - - std::cout << "\tlw\t$2," << stack_position << "($fp)" << std::endl; - } else - std::cerr << "Can't find identifier '" << m_id << "' in current scope binding" << std::endl; + if(bindings.bindingExists(id_)) + std::cout << "\tlw\t$2," << bindings.stackPosition(id_) << "($fp)" << std::endl; + else + std::cerr << "Can't find identifier '" << id_ << "' in current scope binding" << std::endl; return bindings; } -int32_t Identifier::getPostfixStackPosition(VariableStackBindings bindings) const +int Identifier::postfixStackPosition(VariableStackBindings bindings) const { - if(bindings.bindingExists(m_id)) { - return bindings.getStackPosition(m_id); + if(bindings.bindingExists(id_)) { + return bindings.stackPosition(id_); } return -1; @@ -144,7 +148,7 @@ Constant::Constant(const int32_t& constant) : m_constant(constant) {} -VariableStackBindings Constant::printasm(VariableStackBindings bindings) const +VariableStackBindings Constant::printAsm(VariableStackBindings bindings) const { // constant only has to load to $2 because the other expression will take care of the rest std::cout << "\tli\t$2," << m_constant << std::endl; diff --git a/c_compiler/src/function.cpp b/c_compiler/src/function.cpp index 1d9db33..2152c71 100644 --- a/c_compiler/src/function.cpp +++ b/c_compiler/src/function.cpp @@ -1,7 +1,4 @@ #include "function.hpp" -#include "statement.hpp" -#include "declaration.hpp" -#include "bindings.hpp" #include #include @@ -9,26 +6,26 @@ // Function definition -Function::Function(const std::string& _id, Declaration* _parameter_list, Statement* _statement) - : id(_id), parameter_list(_parameter_list), statement(_statement) +Function::Function(const std::string& id, Declaration* parameter_list, Statement* statement) + : id_(id), parameter_list_(parameter_list), statement_(statement) {} void Function::print() const { - std::cout << id << std::endl; + std::cout << id_ << std::endl; - if(parameter_list != nullptr) - parameter_list->print(); + if(parameter_list_ != nullptr) + parameter_list_->print(); - if(statement != nullptr) - statement->print(); + if(statement_ != nullptr) + statement_->print(); } -void Function::printxml() const +void Function::printXml() const { - std::cout << "" << std::endl; + std::cout << "" << std::endl; - DeclarationPtr parameter = parameter_list; + DeclarationPtr parameter = parameter_list_; std::vector parameter_vec; while(parameter != nullptr) { @@ -43,30 +40,30 @@ void Function::printxml() const std::cout << "" << std::endl; } - if(statement != nullptr) - statement->printxml(); + if(statement_ != nullptr) + statement_->printXml(); std::cout << "" << std::endl; } -VariableStackBindings Function::printasm(VariableStackBindings bindings) const +VariableStackBindings Function::printAsm(VariableStackBindings bindings) const { // Counting all the variables being declared in the function - int32_t count = 0; - if(statement != nullptr) - statement->count_variables(count); - + unsigned count = 0; + if(statement_ != nullptr) + statement_->countVariables(count); + // This includes the space for the old frame counter and (return address)? - int32_t memory_needed = 4*count+8; + unsigned memory_needed = 4*count+8; - std::cout << "\t.text\n\t.globl\t" << id << std::endl << id << ":\n\taddiu\t$sp,$sp,-" + std::cout << "\t.text\n\t.globl\t" << id_ << std::endl << id_ << ":\n\taddiu\t$sp,$sp,-" << memory_needed << "\n\tsw\t$fp," << memory_needed-4 << "($sp)\n\tmove\t$fp,$sp" << std::endl; // TODO print asm for parameters // Prints the asm for the compound statement in the function - statement->printasm(bindings); + statement_->printAsm(bindings); std::cout << "\tmove\t$sp,$fp\n\tlw\t$fp," << memory_needed-4 << "($sp)\n\taddiu\t$sp,$sp," << memory_needed << "\n\tjr\t$31\n\tnop" << std::endl; diff --git a/c_compiler/src/statement.cpp b/c_compiler/src/statement.cpp index f86329f..871043e 100644 --- a/c_compiler/src/statement.cpp +++ b/c_compiler/src/statement.cpp @@ -1,7 +1,4 @@ #include "statement.hpp" -#include "declaration.hpp" -#include "expression.hpp" -#include "bindings.hpp" #include @@ -9,76 +6,76 @@ // General base Statement definition Statement::Statement(Statement* statement) - : next_statement(statement) + : next_statement_(statement) {} -void Statement::addStatement(Statement* _next) +void Statement::linkStatement(Statement* next) { - StatementPtr statement_ptr(_next); - next_statement = statement_ptr; + StatementPtr statement_ptr(next); + next_statement_ = statement_ptr; } // Compound Statement definition -CompoundStatement::CompoundStatement(Declaration* decl, Statement* statement) - : Statement(), m_decl(decl), m_statement(statement) +CompoundStatement::CompoundStatement(Declaration* declaration, Statement* statement) + : Statement(), declaration_(declaration), statement_(statement) {} CompoundStatement::CompoundStatement(Statement* statement) - : m_statement(statement) + : statement_(statement) {} void CompoundStatement::print() const { - if(m_decl != nullptr) - m_decl->print(); + if(declaration_ != nullptr) + declaration_->print(); - if(m_statement != nullptr) - m_statement->print(); + if(statement_ != nullptr) + statement_->print(); } -void CompoundStatement::printxml() const +void CompoundStatement::printXml() const { - if(next_statement != nullptr) - next_statement->printxml(); + if(next_statement_ != nullptr) + next_statement_->printXml(); std::cout << "" << std::endl; - if(m_decl != nullptr) - m_decl->printxml(); + if(declaration_ != nullptr) + declaration_->printXml(); - if(m_statement != nullptr) - m_statement->printxml(); + if(statement_ != nullptr) + statement_->printXml(); std::cout << "" << std::endl; } -VariableStackBindings CompoundStatement::printasm(VariableStackBindings bindings) const +VariableStackBindings CompoundStatement::printAsm(VariableStackBindings bindings) const { VariableStackBindings outer_scope_bindings = bindings; - if(next_statement != nullptr) - next_statement->printasm(bindings); + if(next_statement_ != nullptr) + next_statement_->printAsm(bindings); - if(m_decl != nullptr) - bindings = m_decl->printasm(bindings); + if(declaration_ != nullptr) + bindings = declaration_->printAsm(bindings); - if(m_statement != nullptr) - m_statement->printasm(bindings); + if(statement_ != nullptr) + statement_->printAsm(bindings); return outer_scope_bindings; } -void CompoundStatement::count_variables(int32_t& var_count) const +void CompoundStatement::countVariables(unsigned& var_count) const { - DeclarationPtr declaration = m_decl; + DeclarationPtr declaration = declaration_; - if(next_statement != nullptr) - next_statement->count_variables(var_count); + if(next_statement_ != nullptr) + next_statement_->countVariables(var_count); - if(m_statement != nullptr) - m_statement->count_variables(var_count); + if(statement_ != nullptr) + statement_->countVariables(var_count); while(declaration != nullptr) { DeclarationPtr declaration_list = declaration->getNextListItem(); @@ -99,141 +96,140 @@ void CompoundStatement::count_variables(int32_t& var_count) const // Selection Statement definition SelectionStatement::SelectionStatement(Statement* _if, Statement* _else) - : Statement(), m_if(_if), m_else(_else) {} + : Statement(), if_(_if), else_(_else) {} void SelectionStatement::print() const { - m_if->print(); - m_else->print(); + if_->print(); + else_->print(); } -void SelectionStatement::printxml() const +void SelectionStatement::printXml() const { - if(next_statement != nullptr) - next_statement->printxml(); + if(next_statement_ != nullptr) + next_statement_->printXml(); - if(m_if != nullptr) - m_if->printxml(); + if(if_ != nullptr) + if_->printXml(); - if(m_else != nullptr) - m_else->printxml(); + if(else_ != nullptr) + else_->printXml(); } -VariableStackBindings SelectionStatement::printasm(VariableStackBindings bindings) const +VariableStackBindings SelectionStatement::printAsm(VariableStackBindings bindings) const { return bindings; } -void SelectionStatement::count_variables(int32_t& var_count) const +void SelectionStatement::countVariables(unsigned& var_count) const { - if(next_statement != nullptr) - next_statement->count_variables(var_count); + if(next_statement_ != nullptr) + next_statement_->countVariables(var_count); - if(m_if != nullptr) - m_if->count_variables(var_count); + if(if_ != nullptr) + if_->countVariables(var_count); - if(m_else != nullptr) - m_else->count_variables(var_count); + if(else_ != nullptr) + else_->countVariables(var_count); } // Expression Statement definition ExpressionStatement::ExpressionStatement(Expression* expr) - : Statement(), m_expr(expr) + : Statement(), expr_(expr) {} void ExpressionStatement::print() const {} -void ExpressionStatement::printxml() const +void ExpressionStatement::printXml() const {} -VariableStackBindings ExpressionStatement::printasm(VariableStackBindings bindings) const +VariableStackBindings ExpressionStatement::printAsm(VariableStackBindings bindings) const { - if(next_statement != nullptr) - next_statement->printasm(bindings); + if(next_statement_ != nullptr) + next_statement_->printAsm(bindings); - if(m_expr != nullptr) + if(expr_ != nullptr) { - bindings.resetRegister(); - m_expr->printasm(bindings); + bindings.resetExpressionStack(); + expr_->printAsm(bindings); } return bindings; } -void ExpressionStatement::count_variables(int32_t& var_count) const +void ExpressionStatement::countVariables(unsigned& var_count) const { - if(next_statement != nullptr) - next_statement->count_variables(var_count); + if(next_statement_ != nullptr) + next_statement_->countVariables(var_count); } // Jump Statement definition JumpStatement::JumpStatement(Expression* expr) - : m_expr(expr) + : expr_(expr) {} void JumpStatement::print() const {} -void JumpStatement::printxml() const +void JumpStatement::printXml() const { - if(next_statement != nullptr) - next_statement->printxml(); + if(next_statement_ != nullptr) + next_statement_->printXml(); } -VariableStackBindings JumpStatement::printasm(VariableStackBindings bindings) const +VariableStackBindings JumpStatement::printAsm(VariableStackBindings bindings) const { - if(next_statement != nullptr) - next_statement->printasm(bindings); + if(next_statement_ != nullptr) + next_statement_->printAsm(bindings); - if(m_expr != nullptr) - { - bindings.resetRegister(); - m_expr->printasm(bindings); + if(expr_ != nullptr) { + bindings.resetExpressionStack(); + expr_->printAsm(bindings); } return bindings; } -void JumpStatement::count_variables(int32_t& var_count) const +void JumpStatement::countVariables(unsigned& var_count) const { - if(next_statement != nullptr) - next_statement->count_variables(var_count); + if(next_statement_ != nullptr) + next_statement_->countVariables(var_count); } // Iteration Statement definition IterationStatement::IterationStatement(Statement* statement) - : m_statement(statement) + : statement_(statement) {} void IterationStatement::print() const {} -void IterationStatement::printxml() const +void IterationStatement::printXml() const { - if(next_statement != nullptr) - next_statement->printxml(); + if(next_statement_ != nullptr) + next_statement_->printXml(); - if(m_statement != nullptr) - m_statement->printxml(); + if(statement_ != nullptr) + statement_->printXml(); } -VariableStackBindings IterationStatement::printasm(VariableStackBindings bindings) const +VariableStackBindings IterationStatement::printAsm(VariableStackBindings bindings) const { return bindings; } -void IterationStatement::count_variables(int32_t& var_count) const +void IterationStatement::countVariables(unsigned& var_count) const { - if(next_statement != nullptr) - next_statement->count_variables(var_count); + if(next_statement_ != nullptr) + next_statement_->countVariables(var_count); - if(m_statement != nullptr) - m_statement->count_variables(var_count); + if(statement_ != nullptr) + statement_->countVariables(var_count); } diff --git a/c_compiler/src/translation_unit.cpp b/c_compiler/src/translation_unit.cpp index 1d09410..a671851 100644 --- a/c_compiler/src/translation_unit.cpp +++ b/c_compiler/src/translation_unit.cpp @@ -1,42 +1,41 @@ #include "translation_unit.hpp" -#include "bindings.hpp" #include // Translation Unit definition -TranslationUnit::TranslationUnit(Node* decl) +TranslationUnit::TranslationUnit(Node* external_declaration) { - push(decl); + push(external_declaration); } void TranslationUnit::print() const { - for(auto& node : translation_unit) { + for(auto& node : translation_unit_) { node->print(); } } -void TranslationUnit::printxml() const +void TranslationUnit::printXml() const { std::cout << "\n" << std::endl; - for(auto& node : translation_unit) { - node->printxml(); + for(auto& node : translation_unit_) { + node->printXml(); } std::cout << "" << std::endl; } -VariableStackBindings TranslationUnit::printasm(VariableStackBindings bindings) const +VariableStackBindings TranslationUnit::printAsm(VariableStackBindings bindings) const { - for(auto& node : translation_unit) { - node->printasm(bindings); + for(auto& node : translation_unit_) { + node->printAsm(bindings); } return bindings; } -void TranslationUnit::push(Node* decl) +void TranslationUnit::push(Node* external_declaration) { - NodePtr node_ptr(decl); - translation_unit.push_back(node_ptr); + NodePtr node_ptr(external_declaration); + translation_unit_.push_back(node_ptr); } diff --git a/c_compiler/src/type.cpp b/c_compiler/src/type.cpp index 6a89e2a..feda3a5 100644 --- a/c_compiler/src/type.cpp +++ b/c_compiler/src/type.cpp @@ -1,5 +1,4 @@ #include "type.hpp" -#include "bindings.hpp" #include @@ -11,10 +10,10 @@ void Type::print() const std::cout << getType() << " " << std::endl; } -void Type::printxml() const +void Type::printXml() const {} -VariableStackBindings Type::printasm(VariableStackBindings bindings) const +VariableStackBindings Type::printAsm(VariableStackBindings bindings) const { return bindings; } @@ -22,23 +21,24 @@ VariableStackBindings Type::printasm(VariableStackBindings bindings) const // Pointer definition -Pointer::Pointer(Type* _pointer_type) : pointer_type(_pointer_type) +Pointer::Pointer(Type* pointer_type) : pointer_type_(pointer_type) {} std::string Pointer::getType() const { - return "pointer " + pointer_type->getType(); + return "pointer " + pointer_type_->getType(); } // Array definition -Array::Array(Type* _array_type, int32_t _size) : size(_size), array_type(_array_type) +Array::Array(Type* array_type, unsigned size) + : array_type_(array_type), size_(size) {} std::string Array::getType() const { - return "array " + array_type->getType(); + return "array " + array_type_->getType(); } -- cgit