Reformatting

17 files changed, 355 insertions, 368 deletions

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 <cstdint>
 #include <map>
 #include <memory>
 #include <string>
@@ -15,7 +14,7 @@ typedef std::shared_ptr<Type> TypePtr;
 struct DeclarationData
 {
     TypePtr type;
-    int32_t stack_position;
+    int stack_position;
 };
 
 
@@ -23,22 +22,22 @@ struct DeclarationData
 class VariableStackBindings
 {
 private:
-    std::map<std::string, DeclarationData> bindings;
-    int32_t stack_counter;
-    int8_t current_register;
+    std::map<std::string, DeclarationData> 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<Declaration> 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 <cstdint>
 #include <memory>
+#include <string>
 
 class Expression;
 
@@ -13,79 +16,79 @@ typedef std::shared_ptr<Expression> 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 <memory>
+#include <string>
 
 class Declaration;
 class Statement;
@@ -18,17 +23,17 @@ typedef std::shared_ptr<Function> 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 <memory>
 
-class Declaration;
-class Expression;
 class Statement;
 
 typedef std::shared_ptr<Declaration> DeclarationPtr;
@@ -16,92 +17,92 @@ typedef std::shared_ptr<Statement> 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 <memory>
@@ -11,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* 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 <memory>
+#include <string>
 
 class Type;
 
@@ -12,8 +14,8 @@ typedef std::shared_ptr<Type> 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<std::string, DeclarationData>(id, decl_data));
+    bindings_.insert(std::pair<std::string, DeclarationData>(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	<node>		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 << "<Variable id=\""<< id << "\" />" << std::endl;
+    if(id_ != "")
+	std::cout << "<Variable id=\""<< id_ << "\" />" << 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 <iostream>
 
@@ -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 <iostream>
 #include <vector>
@@ -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 << "<Function id=\"" << id << "\">" << std::endl;
+    std::cout << "<Function id=\"" << id_ << "\">" << std::endl;
 
-    DeclarationPtr parameter = parameter_list;
+    DeclarationPtr parameter = parameter_list_;
     std::vector<std::string> parameter_vec;
     
     while(parameter != nullptr) {
@@ -43,30 +40,30 @@ void Function::printxml() const
 	std::cout << "<Parameter id=\"" << *itr << "\" />" << std::endl;	
     }
     
-    if(statement != nullptr)
-	statement->printxml();
+    if(statement_ != nullptr)
+	statement_->printXml();
 
     std::cout << "</Function>" << 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 <iostream>
 
@@ -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 << "<Scope>" << 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 << "</Scope>" << 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 <iostream>
 
 // 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 << "<?xml version=\"1.0\"?>\n<Program>" << std::endl;
-    for(auto& node : translation_unit) {
-	node->printxml();
+    for(auto& node : translation_unit_) {
+	node->printXml();
     }
     std::cout << "</Program>" << 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 <iostream>
 
@@ -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();
 }