Fixed decrement

8 files changed, 494 insertions, 494 deletions

diff --git a/c_compiler/include/bindings.hpp b/c_compiler/include/bindings.hpp
index a8d8eba..7c2a264 100644
--- a/c_compiler/include/bindings.hpp
+++ b/c_compiler/include/bindings.hpp
@@ -13,50 +13,50 @@ typedef std::shared_ptr<Type> TypePtr;
 // struct containing information on the variable declaration
 struct DeclarationData
 {
-    TypePtr type;
-    int stack_position;
-    std::vector<int> array_sizes;
+	TypePtr type;
+	int stack_position;
+	std::vector<int> array_sizes;
 };
 
 // stores bindings for the current scope and where they are in the stack
 class Bindings
 {
 private:
-    static std::vector<std::string> string_literals;
+	static std::vector<std::string> string_literals;
     
-    std::unordered_map<std::string, DeclarationData> bindings_;
-    std::string break_label_;
-    std::string continue_label_;
-    int stack_counter_;
-    int expression_stack_;
+	std::unordered_map<std::string, DeclarationData> bindings_;
+	std::string break_label_;
+	std::string continue_label_;
+	int stack_counter_;
+	int expression_stack_;
 public:
-    Bindings();
+	Bindings();
 
-    void insertBinding(const std::string &id, const TypePtr &type, const int &stack_position);
-    void insertBinding(const std::string &id, const TypePtr &type, const int &stack_position, const std::vector<int> array_sizes);
-    int insertStringLiteral(const std::string &string_literal);
-    void increaseStackPosition();
-    void increaseStackPosition(const int &position);
-    void setStackPosition(const int &stack_counter);
-    void nextExpressionStackPosition();
-    void setExpressionStackPosition(const int &stack_counter);
+	void insertBinding(const std::string &id, const TypePtr &type, const int &stack_position);
+	void insertBinding(const std::string &id, const TypePtr &type, const int &stack_position, const std::vector<int> array_sizes);
+	int insertStringLiteral(const std::string &string_literal);
+	void increaseStackPosition();
+	void increaseStackPosition(const int &position);
+	void setStackPosition(const int &stack_counter);
+	void nextExpressionStackPosition();
+	void setExpressionStackPosition(const int &stack_counter);
 
-    TypePtr getType(const std::string &id) const;
-    const std::vector<int> &getArraySizes(const std::string &id) const;
+	TypePtr getType(const std::string &id) const;
+	const std::vector<int> &getArraySizes(const std::string &id) const;
 
-    std::string breakLabel();
-    std::string breakLabel(const std::string &label);
-    std::string continueLabel();
-    std::string continueLabel(const std::string &label);
+	std::string breakLabel();
+	std::string breakLabel(const std::string &label);
+	std::string continueLabel();
+	std::string continueLabel(const std::string &label);
 
-    int currentStackPosition() const;
-    int stackPosition(const std::string &id) const;
-    int currentExpressionStackPosition() const;
+	int currentStackPosition() const;
+	int stackPosition(const std::string &id) const;
+	int currentExpressionStackPosition() const;
 
-    std::pair<std::vector<std::string>::const_iterator, std::vector<std::string>::const_iterator>
-    getStringLiteralIterator() const;
+	std::pair<std::vector<std::string>::const_iterator, std::vector<std::string>::const_iterator>
+	getStringLiteralIterator() const;
 
-    bool bindingExists(const std::string &id) const;
+	bool bindingExists(const std::string &id) const;
 };
 
 
diff --git a/c_compiler/include/declaration.hpp b/c_compiler/include/declaration.hpp
index ef45737..752bece 100644
--- a/c_compiler/include/declaration.hpp
+++ b/c_compiler/include/declaration.hpp
@@ -12,66 +12,66 @@ typedef std::shared_ptr<Declaration> DeclarationPtr;
 
 class Declaration : public Node {
 protected:
-    DeclarationPtr next_declaration_;
-    DeclarationPtr next_list_declaration_;    
-    ExpressionPtr initializer_;
-    TypePtr type_;
-    bool extern_declaration_;    
+	DeclarationPtr next_declaration_;
+	DeclarationPtr next_list_declaration_;    
+	ExpressionPtr initializer_;
+	TypePtr type_;
+	bool extern_declaration_;    
 public:
-    Declaration(Expression *initializer);
-    Declaration(ExpressionPtr initializer);
+	Declaration(Expression *initializer);
+	Declaration(ExpressionPtr initializer);
     
-    virtual void print() const = 0;
-    virtual void printXml() const = 0;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
-    virtual Bindings localAsm(Bindings bindings, int &label_count) const = 0;
-    virtual void countDeclarations(int &declaration_count) const = 0;
-    virtual std::string getId() const = 0;
+	virtual void print() const = 0;
+	virtual void printXml() const = 0;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+	virtual Bindings localAsm(Bindings bindings, int &label_count) const = 0;
+	virtual void countDeclarations(int &declaration_count) const = 0;
+	virtual std::string getId() const = 0;
 
-    void linkDeclaration(Declaration *next_declaration);    
-    void linkListDeclaration(Declaration *next_list_declaration);
-    void setType(TypePtr type);
-    void setInitializer(Expression *initializer);
-    void setExternDeclaration(bool is_extern);
+	void linkDeclaration(Declaration *next_declaration);    
+	void linkListDeclaration(Declaration *next_list_declaration);
+	void setType(TypePtr type);
+	void setInitializer(Expression *initializer);
+	void setExternDeclaration(bool is_extern);
 
-    DeclarationPtr getNext() const;
-    DeclarationPtr getNextListItem() const;
-    ExpressionPtr getInitializer() const;
-    TypePtr getType() const;
+	DeclarationPtr getNext() const;
+	DeclarationPtr getNextListItem() const;
+	ExpressionPtr getInitializer() const;
+	TypePtr getType() const;
 };
 
 class IdentifierDeclaration : public Declaration {
 private:
-    std::string id_;
+	std::string id_;
 public:
-    IdentifierDeclaration(const std::string &id="", Expression *initializer=nullptr);
-    IdentifierDeclaration(const std::string &id, ExpressionPtr initializer);
+	IdentifierDeclaration(const std::string &id="", Expression *initializer=nullptr);
+	IdentifierDeclaration(const std::string &id, ExpressionPtr initializer);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual Bindings localAsm(Bindings bindings, int &label_count) const;
-    virtual void countDeclarations(int &declaration_count) const;
-    virtual std::string getId() const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual Bindings localAsm(Bindings bindings, int &label_count) const;
+	virtual void countDeclarations(int &declaration_count) const;
+	virtual std::string getId() const;
 };
 
 class ArrayDeclaration : public Declaration
 {
 private:
-    int size_;
-    DeclarationPtr declarator_;
+	int size_;
+	DeclarationPtr declarator_;
 public:
-    ArrayDeclaration(Declaration *declarator, ExpressionPtr initializer, const int &size=0);
+	ArrayDeclaration(Declaration *declarator, ExpressionPtr initializer, const int &size=0);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual Bindings localAsm(Bindings bindings, int &label_count) const;
-    virtual void countDeclarations(int &declaration_count) const;
-    virtual std::string getId() const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual Bindings localAsm(Bindings bindings, int &label_count) const;
+	virtual void countDeclarations(int &declaration_count) const;
+	virtual std::string getId() const;
 
-    int getSize() const;
-    DeclarationPtr getNextArrayDeclaration() const;
+	int getSize() const;
+	DeclarationPtr getNextArrayDeclaration() const;
 };
 
 #endif
diff --git a/c_compiler/include/expression.hpp b/c_compiler/include/expression.hpp
index b0f1733..d136bdf 100644
--- a/c_compiler/include/expression.hpp
+++ b/c_compiler/include/expression.hpp
@@ -15,320 +15,320 @@ typedef std::shared_ptr<Expression> ExpressionPtr;
 class Expression : public Node
 {
 protected:
-    ExpressionPtr next_expression_;
+	ExpressionPtr next_expression_;
     
 public:
-    virtual Bindings printAsm(Bindings bindings, int& label_count) const = 0;
+	virtual Bindings printAsm(Bindings bindings, int& label_count) const = 0;
     
-    virtual int constantFold() const;
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void expressionDepth(int &depth_count) const;
-    virtual std::string id() const;
-    virtual TypePtr getType(const Bindings &bindings) const = 0;
+	virtual int constantFold() const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void expressionDepth(int &depth_count) const;
+	virtual std::string id() const;
+	virtual TypePtr getType(const Bindings &bindings) const = 0;
        
-    void linkExpression(Expression* next_expression);
-    ExpressionPtr nextExpression() const;
+	void linkExpression(Expression* next_expression);
+	ExpressionPtr nextExpression() const;
 };
 
 class OperationExpression : public Expression
 {
 protected:
-    ExpressionPtr lhs_;
-    ExpressionPtr rhs_;
+	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 Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
     
-    virtual int constantFold() const;
-    virtual void expressionDepth(int &depth_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual int constantFold() const;
+	virtual void expressionDepth(int &depth_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 
-    ExpressionPtr getLhs() const;
-    ExpressionPtr getRhs() const;
+	ExpressionPtr getLhs() const;
+	ExpressionPtr getRhs() const;
     
-    void evaluateExpression(Bindings bindings, int &label_count) const;
+	void evaluateExpression(Bindings bindings, int &label_count) const;
 };
 
 class UnaryExpression : public Expression
 {
 public:
-    virtual void expressionDepth(int &depth_count) const;
-    virtual void pointerPosition(Bindings bindings) const;
-    virtual void stackPosition(Bindings bindings, int &depth_count) const;
+	virtual void expressionDepth(int &depth_count) const;
+	virtual void pointerPosition(Bindings bindings) const;
+	virtual void stackPosition(Bindings bindings, int &depth_count) const;
 };
 
 class PostfixArrayElement : public UnaryExpression
 {
 private:
-    ExpressionPtr postfix_expression_;
-    ExpressionPtr index_expression_;
+	ExpressionPtr postfix_expression_;
+	ExpressionPtr index_expression_;
     
 public:
-    PostfixArrayElement(Expression *postfix_expression, Expression *index_expression);
+	PostfixArrayElement(Expression *postfix_expression, Expression *index_expression);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void expressionDepth(int &depth_count) const;
-    virtual void stackPosition(Bindings bindings, int &depth_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
-    virtual std::string id() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void expressionDepth(int &depth_count) const;
+	virtual void stackPosition(Bindings bindings, int &depth_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
+	virtual std::string id() const;
 
-    ExpressionPtr getIndex() const;
-    ExpressionPtr getPostfix() const;    
+	ExpressionPtr getIndex() const;
+	ExpressionPtr getPostfix() const;    
 };
 
 class PostfixFunctionCall : public UnaryExpression
 {
 private:
-    ExpressionPtr postfix_expression_;
-    ExpressionPtr argument_expression_list_;
+	ExpressionPtr postfix_expression_;
+	ExpressionPtr argument_expression_list_;
     
 public:
-    PostfixFunctionCall(Expression *argument_expression_list = nullptr);
+	PostfixFunctionCall(Expression *argument_expression_list = nullptr);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void expressionDepth(int &depth_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void expressionDepth(int &depth_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
     
-    void setPostfixExpression(Expression *postfix_expression);
+	void setPostfixExpression(Expression *postfix_expression);
 };
 
 class PostfixPostIncDecExpression : public UnaryExpression
 {
 private:
-    std::string operator_;
-    ExpressionPtr postfix_expression_;
+	std::string operator_;
+	ExpressionPtr postfix_expression_;
 
 public:
-    PostfixPostIncDecExpression(const std::string &_operator, Expression *postfix_expression);
+	PostfixPostIncDecExpression(const std::string &_operator, Expression *postfix_expression);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
     
 };
 
 class UnaryPreIncDecExpression : public UnaryExpression
 {
 private:
-    std::string operator_;
-    ExpressionPtr unary_expression_;
+	std::string operator_;
+	ExpressionPtr unary_expression_;
     
 public:
-    UnaryPreIncDecExpression(const std::string &_operator, Expression *unary_expression);
+	UnaryPreIncDecExpression(const std::string &_operator, Expression *unary_expression);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 };
 
 class OperatorUnaryExpression : public UnaryExpression
 {
 private:
-    std::string operator_;
-    ExpressionPtr cast_expression_;
+	std::string operator_;
+	ExpressionPtr cast_expression_;
 
 public:
-    OperatorUnaryExpression(const std::string &_operator, Expression *cast_expression);
+	OperatorUnaryExpression(const std::string &_operator, Expression *cast_expression);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void stackPosition(Bindings bindings, int &depth_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
-    std::string getOperator() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void stackPosition(Bindings bindings, int &depth_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
+	std::string getOperator() const;
 };
 
 
 class CastExpression : public Expression
 {
 private:
-    TypePtr type_;
-    ExpressionPtr expression_;
+	TypePtr type_;
+	ExpressionPtr expression_;
 
 public:
-    CastExpression(Type *type, Expression *expression);
+	CastExpression(Type *type, Expression *expression);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void expressionDepth(int &depth_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void expressionDepth(int &depth_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 };
 
 class AdditiveExpression : public OperationExpression
 {
 private:
-    std::string operator_;
+	std::string operator_;
 
 public:
-    AdditiveExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
+	AdditiveExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class MultiplicativeExpression : public OperationExpression
 {
 private:
-    std::string operator_;
+	std::string operator_;
 
 public:
-    MultiplicativeExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
+	MultiplicativeExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class ShiftExpression : public OperationExpression
 {
 private:
-    std::string operator_;
+	std::string operator_;
 public:
-    ShiftExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
+	ShiftExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class RelationalExpression : public OperationExpression
 {
 private:
-    std::string operator_;
+	std::string operator_;
 public:
-    RelationalExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
+	RelationalExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class EqualityExpression : public OperationExpression
 {
 private:
-    std::string operator_;
+	std::string operator_;
 public:
-    EqualityExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
+	EqualityExpression(Expression *lhs, const std::string &_operator, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class AndExpression : public OperationExpression
 {
 public:
-    AndExpression(Expression *lhs, Expression *rhs);
+	AndExpression(Expression *lhs, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class ExclusiveOrExpression : public OperationExpression
 {
 public:
-    ExclusiveOrExpression(Expression *lhs, Expression *rhs);
+	ExclusiveOrExpression(Expression *lhs, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class InclusiveOrExpression : public OperationExpression
 {
 public:
-    InclusiveOrExpression(Expression *lhs, Expression *rhs);
+	InclusiveOrExpression(Expression *lhs, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const; 
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const; 
 };
 
 class LogicalAndExpression : public OperationExpression
 {
 public:
-    LogicalAndExpression(Expression *lhs, Expression *rhs);
+	LogicalAndExpression(Expression *lhs, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
 };
 
 class LogicalOrExpression : public OperationExpression
 {
 public:
-    LogicalOrExpression(Expression *lhs, Expression *rhs);
+	LogicalOrExpression(Expression *lhs, Expression *rhs);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;    
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;    
 };
 
 class ConditionalExpression : public Expression
 {
 private:
-    ExpressionPtr logical_or_;
-    ExpressionPtr expression_;
-    ExpressionPtr conditional_expression_;
+	ExpressionPtr logical_or_;
+	ExpressionPtr expression_;
+	ExpressionPtr conditional_expression_;
 
 public:
-    ConditionalExpression(Expression *logical_or, Expression *expression,
-			  Expression *conditional_expression);
+	ConditionalExpression(Expression *logical_or, Expression *expression,
+	                      Expression *conditional_expression);
     
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual TypePtr getType(const Bindings &bindings) 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 Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 };
 
 class Identifier : public UnaryExpression
 {
 private:
-    std::string id_;
+	std::string id_;
 public:
-    Identifier(const std::string &id);
+	Identifier(const std::string &id);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void pointerPosition(Bindings bindings) const;
-    virtual void stackPosition(Bindings bindings, int &depth_count) const;
-    virtual std::string id() const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void pointerPosition(Bindings bindings) const;
+	virtual void stackPosition(Bindings bindings, int &depth_count) const;
+	virtual std::string id() const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 };
 
 class StringLiteral : public UnaryExpression
 {
 private:
-    std::string string_content_;
+	std::string string_content_;
 public:
-    StringLiteral(const std::string &string_content);
+	StringLiteral(const std::string &string_content);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 };
 
 class Constant : public UnaryExpression
 {
 private:
-    int32_t constant_;
+	int32_t constant_;
 public:
-    Constant(const int32_t &constant);
+	Constant(const int32_t &constant);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual int constantFold() const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual int constantFold() const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 };
 
 class Initializer : public Expression
 {
 private:
-    ExpressionPtr next_initializer_;
+	ExpressionPtr next_initializer_;
 public:
-    Initializer(Expression *next_initializer);
+	Initializer(Expression *next_initializer);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual TypePtr getType(const Bindings &bindings) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual TypePtr getType(const Bindings &bindings) const;
 
-    void printInitializerAsm(Bindings &bindings, int &label_count, int position, const std::vector<int> &iteration_vector, const TypePtr &type) const;
-    ExpressionPtr getNext() const;
+	void printInitializerAsm(Bindings &bindings, int &label_count, int position, const std::vector<int> &iteration_vector, const TypePtr &type) const;
+	ExpressionPtr getNext() const;
 };
 
 #endif
diff --git a/c_compiler/include/function.hpp b/c_compiler/include/function.hpp
index 2227f52..1c76749 100644
--- a/c_compiler/include/function.hpp
+++ b/c_compiler/include/function.hpp
@@ -17,20 +17,20 @@ typedef std::shared_ptr<Function> FunctionPtr;
 
 class Function : public Node {
 protected:
-    TypePtr type_;
-    std::string id_;
-    StatementPtr statement_;
-    DeclarationPtr parameter_list_;
+	TypePtr type_;
+	std::string id_;
+	StatementPtr statement_;
+	DeclarationPtr parameter_list_;
     
 public:
-    Function(const std::string& id, Statement* statement, DeclarationPtr parameter_list = nullptr);
+	Function(const std::string& id, Statement* statement, DeclarationPtr parameter_list = nullptr);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int& label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int& label_count) const;
 
-    void printParameterAsm(Bindings& bindings, int& frame_offset) const;
-    void countParameters(int& parameter_count) const;
+	void printParameterAsm(Bindings& bindings, int& frame_offset) const;
+	void countParameters(int& parameter_count) const;
 };
 
 
diff --git a/c_compiler/include/node.hpp b/c_compiler/include/node.hpp
index 1612aaf..6945b21 100644
--- a/c_compiler/include/node.hpp
+++ b/c_compiler/include/node.hpp
@@ -13,11 +13,11 @@ class Bindings;
 class Node
 {
 public:
-    virtual ~Node() {}
+	virtual ~Node() {}
 
-    virtual void print() const = 0;
-    virtual void printXml() const = 0;
-    virtual Bindings printAsm(Bindings bindings, int& label_count) const = 0;
+	virtual void print() const = 0;
+	virtual void printXml() const = 0;
+	virtual Bindings printAsm(Bindings bindings, int& label_count) const = 0;
 };
 
     
diff --git a/c_compiler/include/statement.hpp b/c_compiler/include/statement.hpp
index 94c1a36..a01307f 100644
--- a/c_compiler/include/statement.hpp
+++ b/c_compiler/include/statement.hpp
@@ -16,227 +16,227 @@ typedef std::shared_ptr<Statement> StatementPtr;
 class Statement : public Node
 {
 protected:
-    StatementPtr next_statement_;
+	StatementPtr next_statement_;
     
 public:
-    Statement(Statement *statement = nullptr);
+	Statement(Statement *statement = nullptr);
 
-    virtual void print() const = 0;
-    virtual void printXml() const = 0;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+	virtual void print() const = 0;
+	virtual void printXml() const = 0;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
 
-    virtual void countVariables(int &var_count) const = 0;
-    virtual void countArguments(int &argument_count) const = 0;
-    virtual void countExpressionDepth(int &depth_count) const = 0;
+	virtual void countVariables(int &var_count) const = 0;
+	virtual void countArguments(int &argument_count) const = 0;
+	virtual void countExpressionDepth(int &depth_count) const = 0;
 
-    virtual int constantFold() const;
-    virtual ExpressionPtr getExpression() const;
-    virtual bool isDefault() const;
+	virtual int constantFold() const;
+	virtual ExpressionPtr getExpression() const;
+	virtual bool isDefault() const;
     
-    void linkStatement(Statement *next);
-    StatementPtr getNext() const;
+	void linkStatement(Statement *next);
+	StatementPtr getNext() const;
 };
 
 class LabelStatement : public Statement
 {
 private:
-    std::string label_;
-    StatementPtr statement_;
+	std::string label_;
+	StatementPtr statement_;
 
 public:
-    LabelStatement(const std::string &label, Statement *statement);
+	LabelStatement(const std::string &label, Statement *statement);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
 };
 
 class CaseStatement : public Statement
 {
 private:
-    ExpressionPtr constant_expression_;
-    StatementPtr statement_;
-    bool default_;
+	ExpressionPtr constant_expression_;
+	StatementPtr statement_;
+	bool default_;
 
 public:
-    CaseStatement(Statement *statement, Expression *constant_expression_ = nullptr, const bool &_default = false);
-
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
-    virtual int constantFold() const;
-    virtual ExpressionPtr getExpression() const;
-    virtual bool isDefault() const;
+	CaseStatement(Statement *statement, Expression *constant_expression_ = nullptr, const bool &_default = false);
+
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
+	virtual int constantFold() const;
+	virtual ExpressionPtr getExpression() const;
+	virtual bool isDefault() const;
 };
 
 class CompoundStatement : public Statement
 {
 protected:
-    DeclarationPtr declaration_;
-    StatementPtr statement_;
+	DeclarationPtr declaration_;
+	StatementPtr statement_;
     
 public:
-    CompoundStatement(Declaration *declaration = nullptr, Statement *statement = nullptr);
-    CompoundStatement(Statement *statement);
+	CompoundStatement(Declaration *declaration = nullptr, Statement *statement = nullptr);
+	CompoundStatement(Statement *statement);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
 
-    StatementPtr getStatementList() const;
+	StatementPtr getStatementList() const;
 };
 
 class IfElseStatement : public Statement
 {
 private:
-    ExpressionPtr condition_;
-    StatementPtr if_;
-    StatementPtr else_;
+	ExpressionPtr condition_;
+	StatementPtr if_;
+	StatementPtr else_;
 public:
-    IfElseStatement(Expression *condition, Statement *_if, Statement *_else = nullptr);
+	IfElseStatement(Expression *condition, Statement *_if, Statement *_else = nullptr);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
 };
 
 class SwitchStatement : public Statement
 {
 private:
-    ExpressionPtr condition_;
-    StatementPtr statement_;
+	ExpressionPtr condition_;
+	StatementPtr statement_;
 public:
-    SwitchStatement(Expression *condition, Statement *statement);
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
+	SwitchStatement(Expression *condition, Statement *statement);
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
 };
 
 class ExpressionStatement : public Statement
 {
 protected:
-    ExpressionPtr expression_;
+	ExpressionPtr expression_;
 public:
-    ExpressionStatement(Expression *expression = nullptr);
+	ExpressionStatement(Expression *expression = nullptr);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;    
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;    
 };
 
 class JumpStatement : public Statement
 {
 public:
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
     
-    virtual void print() const;
-    virtual void printXml() const;
+	virtual void print() const;
+	virtual void printXml() const;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
 };
 
 class ReturnStatement : public JumpStatement
 {
 private:
-    ExpressionPtr expression_;
+	ExpressionPtr expression_;
 public:
-    ReturnStatement(Expression *expression = nullptr);
+	ReturnStatement(Expression *expression = nullptr);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;    
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;    
 };
 
 class BreakStatement : public JumpStatement
 {
 public:
-    BreakStatement();
+	BreakStatement();
 
-    virtual Bindings printAsm(Bindings bindings, int &) const;
+	virtual Bindings printAsm(Bindings bindings, int &) const;
 };
 
 class ContinueStatement : public JumpStatement
 {
 public:
-    ContinueStatement();
+	ContinueStatement();
 
-    virtual Bindings printAsm(Bindings bindings, int &) const;
+	virtual Bindings printAsm(Bindings bindings, int &) const;
 };
 
 class GotoStatement : public JumpStatement
 {
 private:
-    std::string label_;
+	std::string label_;
 public:
-    GotoStatement(const std::string &label);
+	GotoStatement(const std::string &label);
 
-    virtual Bindings printAsm(Bindings bindings, int &) const;
+	virtual Bindings printAsm(Bindings bindings, int &) const;
 };
 
 class IterationStatement : public Statement
 {
 protected:
-    ExpressionPtr condition_;
-    StatementPtr statement_;
+	ExpressionPtr condition_;
+	StatementPtr statement_;
 public:
-    IterationStatement(Expression *condition, Statement *statement);
+	IterationStatement(Expression *condition, Statement *statement);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
 
-    virtual void countVariables(int &var_count) const;
-    virtual void countArguments(int &argument_count) const;
-    virtual void countExpressionDepth(int &depth_count) const;
+	virtual void countVariables(int &var_count) const;
+	virtual void countArguments(int &argument_count) const;
+	virtual void countExpressionDepth(int &depth_count) const;
 };
 
 class WhileLoop : public IterationStatement
 {
 private:
-    bool is_while_;
+	bool is_while_;
 public:
-    WhileLoop(Expression *condition, Statement *statement, const bool &is_while = true);
+	WhileLoop(Expression *condition, Statement *statement, const bool &is_while = true);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 };
 
 class ForLoop : public IterationStatement
 {
 private:
-    ExpressionPtr initializer_;
-    ExpressionPtr incrementer_;
+	ExpressionPtr initializer_;
+	ExpressionPtr incrementer_;
 public:
-    ForLoop(Expression *initializer, Expression *condition, Expression *incrementer, Statement *statement);
+	ForLoop(Expression *initializer, Expression *condition, Expression *incrementer, Statement *statement);
 
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
 };
 
 
diff --git a/c_compiler/include/translation_unit.hpp b/c_compiler/include/translation_unit.hpp
index 04a9d16..c554f91 100644
--- a/c_compiler/include/translation_unit.hpp
+++ b/c_compiler/include/translation_unit.hpp
@@ -12,16 +12,16 @@ typedef std::shared_ptr<Node> NodePtr;
 
 class TranslationUnit : public Node {
 protected:
-    std::vector<NodePtr> translation_unit_;
+	std::vector<NodePtr> translation_unit_;
     
 public:
-    TranslationUnit(Node* external_declaration);
+	TranslationUnit(Node* external_declaration);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int& label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int& label_count) const;
 
-    void push(Node* external_declaration);
+	void push(Node* external_declaration);
 };
 
 
diff --git a/c_compiler/include/type.hpp b/c_compiler/include/type.hpp
index 7da2100..e0fa4d9 100644
--- a/c_compiler/include/type.hpp
+++ b/c_compiler/include/type.hpp
@@ -13,223 +13,223 @@ typedef std::shared_ptr<Type> TypePtr;
 class Type : public Node
 {
 public:
-    virtual void print() const = 0;
-    virtual void printXml() const = 0;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+	virtual void print() const = 0;
+	virtual void printXml() const = 0;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
     
-    virtual TypePtr type() = 0;
-    virtual TypePtr type(Type *type_ptr) = 0;
-    virtual TypePtr type(TypePtr type_ptr) = 0;
-
-    virtual void increaseStackPosition(Bindings &bindings) const = 0;
-    virtual void load() const = 0;
-    virtual void load(const int &reg, const int &position) const = 0;
-    virtual void store() const = 0;    
-    virtual void store(const int &position) const = 0;
-    virtual void store(const int &reg, const int &position) const = 0;
-    virtual int getSize() const = 0;
+	virtual TypePtr type() = 0;
+	virtual TypePtr type(Type *type_ptr) = 0;
+	virtual TypePtr type(TypePtr type_ptr) = 0;
+
+	virtual void increaseStackPosition(Bindings &bindings) const = 0;
+	virtual void load() const = 0;
+	virtual void load(const int &reg, const int &position) const = 0;
+	virtual void store() const = 0;    
+	virtual void store(const int &position) const = 0;
+	virtual void store(const int &reg, const int &position) const = 0;
+	virtual int getSize() const = 0;
     
-    virtual void setSigned(bool _signed);
-    virtual void setExtern(bool _extern);
-    virtual void setStatic(bool _static);
-    virtual void setConst(bool _const);
-    virtual void setSize(int size);
+	virtual void setSigned(bool _signed);
+	virtual void setExtern(bool _extern);
+	virtual void setStatic(bool _static);
+	virtual void setConst(bool _const);
+	virtual void setSize(int size);
 };
 
 class Array : public Type
 {
 private:
-    int size_;
-    TypePtr type_;
+	int size_;
+	TypePtr type_;
 public:
-    Array(const int &size, TypePtr type_ = nullptr);
+	Array(const int &size, TypePtr type_ = nullptr);
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
     
-    virtual TypePtr type();
-    virtual TypePtr type(Type *type_ptr);
-    virtual TypePtr type(TypePtr type_ptr);
-
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;    
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	virtual TypePtr type();
+	virtual TypePtr type(Type *type_ptr);
+	virtual TypePtr type(TypePtr type_ptr);
+
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;    
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
 };
 
 class Pointer : public Type
 {
 private:
-    TypePtr type_;
+	TypePtr type_;
 public:
-    Pointer();
+	Pointer();
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
     
-    virtual TypePtr type();
-    virtual TypePtr type(Type *type_ptr);
-    virtual TypePtr type(TypePtr type_ptr);
-
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
-
-    void pointerLoad() const;
-    void pointerLoad(const int &reg, const int &position) const;
-    void pointerStore() const;
-    void pointerStore(const int &position) const;
-    void pointerStore(const int &reg, const int &position) const;
+	virtual TypePtr type();
+	virtual TypePtr type(Type *type_ptr);
+	virtual TypePtr type(TypePtr type_ptr);
+
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
+
+	void pointerLoad() const;
+	void pointerLoad(const int &reg, const int &position) const;
+	void pointerStore() const;
+	void pointerStore(const int &position) const;
+	void pointerStore(const int &reg, const int &position) const;
 };
 
 class TypeContainer : public Type
 {
 protected:
-    TypePtr type_;
-    int size_;
-    bool extern_;
-    bool static_;
-    bool const_;
-    bool signed_;
+	TypePtr type_;
+	int size_;
+	bool extern_;
+	bool static_;
+	bool const_;
+	bool signed_;
 
 public:
-    TypeContainer();
+	TypeContainer();
 
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
     
-    virtual TypePtr type();    
-    virtual TypePtr type(Type *type_ptr);
-    virtual TypePtr type(TypePtr type_ptr);
-
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;    
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	virtual TypePtr type();    
+	virtual TypePtr type(Type *type_ptr);
+	virtual TypePtr type(TypePtr type_ptr);
+
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;    
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
     
-    virtual void setSigned(bool _signed);
-    virtual void setExtern(bool _extern);
-    virtual void setStatic(bool _static);
-    virtual void setConst(bool _const);
-    virtual void setSize(int size);
+	virtual void setSigned(bool _signed);
+	virtual void setExtern(bool _extern);
+	virtual void setStatic(bool _static);
+	virtual void setConst(bool _const);
+	virtual void setSize(int size);
 };
 
 class Specifier : public Type
 {
 public:
-    virtual void print() const = 0;
-    virtual void printXml() const = 0;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
-
-    virtual void increaseStackPosition(Bindings &bindings) const = 0;
-    virtual void load() const = 0;
-    virtual void load(const int &reg, const int &position) const = 0;
-    virtual void store() const = 0;    
-    virtual void store(const int &position) const = 0;
-    virtual void store(const int &reg, const int &position) const = 0;
-    virtual int getSize() const = 0;
+	virtual void print() const = 0;
+	virtual void printXml() const = 0;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const = 0;
+
+	virtual void increaseStackPosition(Bindings &bindings) const = 0;
+	virtual void load() const = 0;
+	virtual void load(const int &reg, const int &position) const = 0;
+	virtual void store() const = 0;    
+	virtual void store(const int &position) const = 0;
+	virtual void store(const int &reg, const int &position) const = 0;
+	virtual int getSize() const = 0;
     
-    virtual TypePtr type();
-    virtual TypePtr type(Type *type_ptr);
-    virtual TypePtr type(TypePtr type_ptr);
+	virtual TypePtr type();
+	virtual TypePtr type(Type *type_ptr);
+	virtual TypePtr type(TypePtr type_ptr);
 };
 
 class Int : public Specifier
 {
 public:
-    Int();
-
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	Int();
+
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
 };
 
 class Short : public Specifier
 {
 public:
-    Short();
-
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;    
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	Short();
+
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;    
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
 };
 
 class Void : public Specifier
 {
 public:
-    Void();
-
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;    
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	Void();
+
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;    
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
 };
 
 class Char : public Specifier
 {
 public:
-    Char();
-
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;    
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	Char();
+
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;    
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
 };
 
 class Float : public Specifier
 {
 public:
-    Float();
-
-    virtual void print() const;
-    virtual void printXml() const;
-    virtual Bindings printAsm(Bindings bindings, int &label_count) const;
-    virtual void increaseStackPosition(Bindings &bindings) const;
-    virtual void load() const;    
-    virtual void load(const int &reg, const int &position) const;
-    virtual void store() const;
-    virtual void store(const int &position) const;
-    virtual void store(const int &reg, const int &position) const;
-    virtual int getSize() const;
+	Float();
+
+	virtual void print() const;
+	virtual void printXml() const;
+	virtual Bindings printAsm(Bindings bindings, int &label_count) const;
+	virtual void increaseStackPosition(Bindings &bindings) const;
+	virtual void load() const;    
+	virtual void load(const int &reg, const int &position) const;
+	virtual void store() const;
+	virtual void store(const int &position) const;
+	virtual void store(const int &reg, const int &position) const;
+	virtual int getSize() const;
 };
 
 #endif