FInished parser but still have one shift/reduce warning

4 files changed, 284 insertions, 68 deletions

diff --git a/c_parser/include/ast_expression.hpp b/c_parser/include/ast_expression.hpp
index 2e223f4..87db997 100644
--- a/c_parser/include/ast_expression.hpp
+++ b/c_parser/include/ast_expression.hpp
@@ -8,9 +8,8 @@
 
 class ast_Expression : public ast_Base {
 private:
-    std::string id;
 public:
-    ast_Expression(const std::string& _id) : id(_id) {}
+    ast_Expression() {}
 
     virtual void print() const {
 	
@@ -22,9 +21,4 @@ public:
     }
 };
 
-class ast_ReturnExpression : public ast_Expression {
-public:
-    ast_ReturnExpression(const std::string& _id) : ast_Expression(_id) {}
-};
-
 #endif
diff --git a/c_parser/include/ast_statement.hpp b/c_parser/include/ast_statement.hpp
index e9864e9..224a809 100644
--- a/c_parser/include/ast_statement.hpp
+++ b/c_parser/include/ast_statement.hpp
@@ -77,4 +77,46 @@ public:
     }
 };
 
+class ast_ExpressionStatement : public ast_Statement {
+public:
+    ast_ExpressionStatement() : ast_Statement() {}
+    ast_ExpressionStatement(const ast_Base* _el) : ast_Statement(_el) {}
+    ast_ExpressionStatement(const ast_Base* _if, const ast_Base* _else) :
+	ast_Statement(_if, _else) {}
+
+    virtual void print() const override {
+	for(size_t i = 0; i < ast_list.size(); ++i) {
+	    ast_list[i]->print();
+	}
+    }
+};
+
+class ast_JumpStatement : public ast_Statement {
+public:
+    ast_JumpStatement() : ast_Statement() {}
+    ast_JumpStatement(const ast_Base* _el) : ast_Statement(_el) {}
+    ast_JumpStatement(const ast_Base* _if, const ast_Base* _else) :
+	ast_Statement(_if, _else) {}
+
+    virtual void print() const override {
+	for(size_t i = 0; i < ast_list.size(); ++i) {
+	    ast_list[i]->print();
+	}
+    }
+};
+
+class ast_IterationStatement : public ast_Statement {
+public:
+    ast_IterationStatement() : ast_Statement() {}
+    ast_IterationStatement(const ast_Base* _el) : ast_Statement(_el) {}
+    ast_IterationStatement(const ast_Base* _if, const ast_Base* _else) :
+	ast_Statement(_if, _else) {}
+
+    virtual void print() const override {
+	for(size_t i = 0; i < ast_list.size(); ++i) {
+	    ast_list[i]->print();
+	}
+    }
+};
+
 #endif
diff --git a/c_parser/src/c_lexer.flex b/c_parser/src/c_lexer.flex
index 32ef4fb..63366cb 100644
--- a/c_parser/src/c_lexer.flex
+++ b/c_parser/src/c_lexer.flex
@@ -14,6 +14,8 @@ IDENTIFIER [_a-zA-Z][_a-zA-Z0-9]*
 
 OPERATOR [.][.][.]|[<>][<>][=]|[-][-]|[+][+]|[|][|]|[#][#]|[&][&]|[+\-*\/<>=!%^|&][=]|[<][<]|[->][>]|[<>&=+\/\-*(){}\[\]\.,%~!?:|^;]
 
+ASSIGNMENT_OPERATOR (([<>][<>]|[*\/%+\-&^|])[=]|[=])
+
 FRACTIONALCONSTANT (([0-9]*\.[0-9]+)|([0-9]+\.))
 EXPONENTPART ([eE][+-]?[0-9]+)
 
@@ -41,21 +43,48 @@ void|char|short|int|long|float|double|signed|unsigned	      { return T_TYPE_SPEC
 const|volatile						      { return T_TYPE_QUAL; }
 
 [;]		{ return T_SC; }
-[=]		{ return T_EQ; }
-[=][=]		{ return T_EQUALITY; }
 [,]		{ return T_CMA; }
 [(]		{ return T_LRB; }
 [)]		{ return T_RRB; }
 [{]             { return T_LCB; }
 [}]             { return T_RCB; }
+[[]		{ return T_LSB; }
+[]]		{ return T_RSB; }
+[?]		{ return T_QU; }
+[:]		{ return T_COL; }
+[|][|]		{ return T_LOG_OR; }
+[&][&]		{ return T_LOG_AND; }
+[|]		{ return T_OR; }
+[\^]		{ return T_XOR; }
+[&]		{ return T_AND; }
+[=][=]		{ return T_EQUALITY_OP; }
+[!][=]		{ return T_EQUALITY_OP; }
+([<>][=])|[<>]	{ return T_REL_OP; }
+[<>][<>]	{ return T_SHIFT_OP; }
+[*] 		{ return T_MULT; }
+[\/]		{ return T_DIV; }
+[%]		{ return T_REM; }
+[~]		{ return T_TILDE; }
+[!]		{ return T_NOT; }
+[.]		{ return T_DOT; }
+[-][>]		{ return T_ARROW; }
+[+-][+-]	{ return T_INCDEC; }
+[+-]		{ return T_ADDSUB_OP; }
+[=]		{ return T_EQ; }
+
+{ASSIGNMENT_OPERATOR} { return T_ASSIGN_OPER; }
 
 if		{ return T_IF; }
 else		{ return T_ELSE; }
 return		{ return T_RETURN; }
+while		{ return T_WHILE; }
+do		{ return T_DO; }
+for		{ return T_FOR; }
+sizeof		{ return T_SIZEOF; }
 
 {IDENTIFIER}	{ yylval.string = new std::string(yytext); return T_IDENTIFIER; }
 
-({HEXCONSTANT}|{OCTALCONSTANT}|{DECIMALCONSTANT}){INTEGERSUFFIX}?	{ return T_INT_CONST; }
+({HEXCONSTANT}|{OCTALCONSTANT}|{DECIMALCONSTANT}){INTEGERSUFFIX}?	{ yylval.number = strtol(yytext, NULL, 0); return T_INT_CONST; }
 
 {WHITESPACE}		{ ; }
 
diff --git a/c_parser/src/c_parser.y b/c_parser/src/c_parser.y
index 5b3af36..6dabbe7 100644
--- a/c_parser/src/c_parser.y
+++ b/c_parser/src/c_parser.y
@@ -15,128 +15,279 @@ void yyerror(const char *);
 // AST node.
 %union{
     const ast_Base *stmnt;
-    //   double number;
+    double number;
     std::string *string;
 }
                         
 %token T_TYPE_SPEC T_TYPE_QUAL T_STRG_SPEC T_IDENTIFIER
-%token T_SC T_CMA T_EQ T_LRB T_RRB T_LCB T_RCB T_EQUALITY T_RETURN
+%token T_SC T_CMA T_LRB T_RRB T_LCB T_RCB T_LSB T_RSB T_QU T_COL T_LOG_OR 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
 %token T_INT_CONST
-%token T_IF T_ELSE
+%token T_IF T_ELSE T_WHILE T_DO T_FOR T_RETURN
                         
 %type <stmnt> EXT_DEF EXT_DECLARATION
 %type <stmnt> FUNC_DEF PARAMETER_LIST PARAMETER PARAM_DECLARATOR
 %type <stmnt> DECLARATION_LIST DECLARATION DECLARATION_SPEC DECLARATION_SPEC_T INIT_DECLARATOR INIT_DECLARATOR_LIST DECLARATOR INITIALIZER
-%type <stmnt> STATEMENT_LIST STATEMENT COMPOUND_STATEMENT COMPOUND_STATEMENT_2 SELECTION_STATEMENT SELECTION_STATEMENT_2 EXPRESSION_STATEMENT
-%type <stmnt> EXPRESSION EQUALITY_EXPRESSION RETURN_EXPRESSION
-//                      %type <number> //       T_CONSTANT
-%type <string> T_IDENTIFIER //T_OPERATOR
+%type <stmnt> STATEMENT_LIST STATEMENT COMPOUND_STATEMENT COMPOUND_STATEMENT_2 SELECTION_STATEMENT SELECTION_STATEMENT_2 EXPRESSION_STATEMENT JUMP_STATEMENT JUMP_STATEMENT_2 ITERATION_STATEMENT
+%type <stmnt> EXPRESSION ASSIGNMENT_EXPRESSION CONDITIONAL_EXPRESSION LOGICAL_OR_EXPRESSION LOGICAL_AND_EXPRESSION INCLUSIVE_OR_EXPRESSION EXCLUSIVE_OR_EXPRESSION AND_EXPRESSION EQUALITY_EXPRESSION RELATIONAL_EXPRESSION SHIFT_EXPRESSION ADDITIVE_EXPRESSION MULTIPLICATIVE_EXPRESSION CAST_EXPRESSION UNARY_EXPRESSION POSTFIX_EXPRESSION POSTFIX_EXPRESSION_2 ARGUMENT_EXPRESSION_LIST PRIMARY_EXPRESSION
+%type <number> CONSTANT T_INT_CONST
+%type <string> T_IDENTIFIER MULTDIVREM_OP UNARY_OPERATOR T_AND T_ADDSUB_OP T_TILDE T_NOT T_MULT T_DIV T_REM //T_OPERATOR
                         
 %start ROOT
                         
 %%
 
-ROOT : EXT_DEF { ; }
-;
+ROOT:
+		EXT_DEF { ; }
+		;
 
 // EXTERNAL DEFINITION
 
-EXT_DEF : EXT_DECLARATION { g_root->push($1); }
+EXT_DEF:
+		EXT_DECLARATION { g_root->push($1); }
         |       EXT_DEF EXT_DECLARATION { g_root->push($2); }
-;
+		;
 
-EXT_DECLARATION : DECLARATION { $$ = $1; }
+EXT_DECLARATION:
+		DECLARATION { $$ = $1; }
         |       FUNC_DEF { $$ = $1; }
-;
+		;
 
 // FUNCTION DEFINITION
 
-FUNC_DEF : DECLARATION_SPEC T_IDENTIFIER T_LRB PARAMETER_LIST T_RRB COMPOUND_STATEMENT { $$ = new ast_Function(*$2, $4, $6); }
-;
+FUNC_DEF:
+		DECLARATION_SPEC T_IDENTIFIER T_LRB PARAMETER_LIST T_RRB COMPOUND_STATEMENT { $$ = new ast_Function(*$2, $4, $6); }
+		;
 
-PARAMETER_LIST : %empty { $$ = new ast_ParamList(); }
+PARAMETER_LIST:
+		%empty { $$ = new ast_ParamList(); }
 	| 	PARAMETER { $$ = new ast_ParamList($1); }
 	|	PARAMETER_LIST T_CMA PARAMETER { $$->push($3); }
-;
+		;
 
-PARAMETER : DECLARATION_SPEC PARAM_DECLARATOR { $$ = $2; }
-;
+PARAMETER:
+		DECLARATION_SPEC PARAM_DECLARATOR { $$ = $2; }
+		;
 
-PARAM_DECLARATOR : T_IDENTIFIER { $$ = new ast_Parameter(*$1);}
-;
+PARAM_DECLARATOR:
+		T_IDENTIFIER { $$ = new ast_Parameter(*$1);}
+		;
 
 // DECLARATION
 
-DECLARATION_LIST : DECLARATION { $$ = new ast_DeclarationList($1); }
+DECLARATION_LIST:
+		DECLARATION { $$ = new ast_DeclarationList($1); }
 	|	DECLARATION_LIST DECLARATION { $$->push($2); }
+		;
 
-DECLARATION : DECLARATION_SPEC INIT_DECLARATOR_LIST T_SC { $$ = $2; }
-;
+DECLARATION:
+		DECLARATION_SPEC INIT_DECLARATOR_LIST T_SC { $$ = $2; }
+		;
 
-DECLARATION_SPEC : DECLARATION_SPEC_T { ; }
+DECLARATION_SPEC:
+		DECLARATION_SPEC_T { ; }
 	|	DECLARATION_SPEC_T DECLARATION_SPEC { ; }
-;
+		;
 
-DECLARATION_SPEC_T : T_TYPE_SPEC { ; }
+DECLARATION_SPEC_T:
+		T_TYPE_SPEC { ; }
 	|	T_TYPE_QUAL { ; }
 	|	T_STRG_SPEC { ; }
-;
+		;
 
-INIT_DECLARATOR_LIST : INIT_DECLARATOR { $$ = new ast_VariableDeclaration($1); }
+INIT_DECLARATOR_LIST:
+		INIT_DECLARATOR { $$ = new ast_VariableDeclaration($1); }
 	|       INIT_DECLARATOR_LIST T_CMA INIT_DECLARATOR { $$->push($3); }
-;
+		;
 
-INIT_DECLARATOR : DECLARATOR { ; }
+INIT_DECLARATOR:
+		DECLARATOR { ; }
 	|	DECLARATOR T_EQ INITIALIZER { ; }
-;
+		;
 
-DECLARATOR : T_IDENTIFIER {$$ = new ast_Variable(*$1); }
-;
+DECLARATOR:
+		T_IDENTIFIER {$$ = new ast_Variable(*$1); }
+		;
 
-INITIALIZER : T_INT_CONST { ; }
-;
+INITIALIZER:
+		T_INT_CONST { ; }
+		;
 
 // STATEMENT
 
-STATEMENT_LIST : STATEMENT { $$ = new ast_StatementList($1); }
+STATEMENT_LIST:
+		STATEMENT { $$ = new ast_StatementList($1); }
 	|	STATEMENT_LIST STATEMENT { $$->push($2); }
-;
+		;
 
-STATEMENT : COMPOUND_STATEMENT { $$ = $1; }
+STATEMENT:
+		COMPOUND_STATEMENT { $$ = $1; }
 	|	SELECTION_STATEMENT { $$ = $1; }
 	|	EXPRESSION_STATEMENT { $$ = $1; }
-;
+	|	JUMP_STATEMENT { $$ = $1; }
+	|	ITERATION_STATEMENT { $$ = $1; }
+		;
 
-COMPOUND_STATEMENT : T_LCB COMPOUND_STATEMENT_2 { $$ = $2; }
-;
+COMPOUND_STATEMENT:
+		T_LCB COMPOUND_STATEMENT_2 { $$ = $2; }
+		;
 
-COMPOUND_STATEMENT_2 : T_RCB { $$ = new ast_CompoundStatement; }
+COMPOUND_STATEMENT_2:
+		T_RCB { $$ = new ast_CompoundStatement; }
 	|	DECLARATION_LIST T_RCB { $$ = new ast_CompoundStatement($1); }
 	|	DECLARATION_LIST STATEMENT_LIST T_RCB { $$ = new ast_CompoundStatement($1, $2); }
 	|	STATEMENT_LIST T_RCB { $$ = new ast_CompoundStatement($1); }
-;
+		;
 
-SELECTION_STATEMENT : T_IF T_LRB EXPRESSION T_RRB STATEMENT SELECTION_STATEMENT_2 { $$ = new ast_SelectionStatement($5, $6); }
-;
+SELECTION_STATEMENT:
+		T_IF T_LRB EXPRESSION T_RRB STATEMENT SELECTION_STATEMENT_2 { $$ = new ast_SelectionStatement($5, $6); }
+		;
 
-SELECTION_STATEMENT_2 : %empty { $$ = new ast_SelectionStatement(); }
+SELECTION_STATEMENT_2:
+		%empty { $$ = new ast_SelectionStatement(); }
 	|	T_ELSE STATEMENT { $$ = $2; }
-;
+		;
 
-EXPRESSION_STATEMENT : EXPRESSION T_SC { $$ = $1; }
-;
+EXPRESSION_STATEMENT:
+		T_SC { $$ = new ast_ExpressionStatement(); }
+	|	EXPRESSION T_SC { $$ = $1; }
+		;
 
-// Expressions
+JUMP_STATEMENT:
+		T_RETURN JUMP_STATEMENT_2 { $$ = $2; }
+		;
+
+JUMP_STATEMENT_2:
+		T_SC { $$ = new ast_JumpStatement(); }
+	|	EXPRESSION T_SC { $$ = $1; }
+		;
 
-EXPRESSION : EQUALITY_EXPRESSION { $$ = $1; }
-	|	RETURN_EXPRESSION { $$ = $1; }
-;
+ITERATION_STATEMENT:
+		T_WHILE T_LRB EXPRESSION T_RRB STATEMENT { $$ = $5; }
+	|	T_DO STATEMENT T_WHILE T_LRB EXPRESSION T_RRB T_SC { $$ = $2; }
+	|	T_FOR T_LRB EXPRESSION T_SC EXPRESSION T_SC EXPRESSION T_RRB STATEMENT { $$ = $9; }
+		;
 
-EQUALITY_EXPRESSION : T_IDENTIFIER T_EQUALITY T_IDENTIFIER { $$ = new ast_Variable(*$1); }
-;
+// Expressions
 
-RETURN_EXPRESSION : T_RETURN T_IDENTIFIER { $$ = new ast_ReturnExpression(*$2); }
-;
+EXPRESSION:
+		ASSIGNMENT_EXPRESSION { $$ = $1; }
+		;
+
+ASSIGNMENT_EXPRESSION:
+		CONDITIONAL_EXPRESSION { $$ = $1; }
+	|	UNARY_EXPRESSION T_ASSIGN_OPER ASSIGNMENT_EXPRESSION { $$ = $1; }
+		;
+
+CONDITIONAL_EXPRESSION:
+		LOGICAL_OR_EXPRESSION { $$ = $1; }
+	|	LOGICAL_OR_EXPRESSION T_QU EXPRESSION T_COL CONDITIONAL_EXPRESSION { $$ = $1; }
+		;
+
+LOGICAL_OR_EXPRESSION:
+		LOGICAL_AND_EXPRESSION { $$ = $1; }
+	|	LOGICAL_OR_EXPRESSION T_LOG_OR LOGICAL_AND_EXPRESSION { $$ = $3; }
+		;
+
+LOGICAL_AND_EXPRESSION:
+		INCLUSIVE_OR_EXPRESSION { $$ = $1; }
+	|	LOGICAL_AND_EXPRESSION T_LOG_AND INCLUSIVE_OR_EXPRESSION { $$ = $3; }
+		;
+
+INCLUSIVE_OR_EXPRESSION:
+		EXCLUSIVE_OR_EXPRESSION { $$ = $1; }
+	|	INCLUSIVE_OR_EXPRESSION T_OR EXCLUSIVE_OR_EXPRESSION { $$ = $3; }
+		;
+
+EXCLUSIVE_OR_EXPRESSION:
+		AND_EXPRESSION { $$ = $1; }
+	|	EXCLUSIVE_OR_EXPRESSION T_XOR AND_EXPRESSION { $$ = $3; }
+		;
+
+AND_EXPRESSION:
+		EQUALITY_EXPRESSION { $$ = $1; }
+	|	AND_EXPRESSION T_AND EQUALITY_EXPRESSION { $$ = $3; }
+		;
+
+EQUALITY_EXPRESSION:
+		RELATIONAL_EXPRESSION { $$ = $1; }
+	|	EQUALITY_EXPRESSION T_EQUALITY_OP RELATIONAL_EXPRESSION { $$ = $3; }
+		;
+
+RELATIONAL_EXPRESSION:
+		SHIFT_EXPRESSION { $$ = $1; }
+	|	RELATIONAL_EXPRESSION T_REL_OP SHIFT_EXPRESSION { $$ = $3; }
+		;
+
+SHIFT_EXPRESSION:
+		ADDITIVE_EXPRESSION { $$ = $1; }
+	|	SHIFT_EXPRESSION T_SHIFT_OP ADDITIVE_EXPRESSION { $$ = $3; }
+		;
+
+ADDITIVE_EXPRESSION:
+		MULTIPLICATIVE_EXPRESSION { $$ = $1; }
+	|	ADDITIVE_EXPRESSION T_ADDSUB_OP MULTIPLICATIVE_EXPRESSION { $$ = $3; }
+		;
+
+MULTIPLICATIVE_EXPRESSION:
+		CAST_EXPRESSION { $$ = $1; }
+	|	MULTIPLICATIVE_EXPRESSION MULTDIVREM_OP CAST_EXPRESSION { $$ = $3; }
+		;
+
+MULTDIVREM_OP:
+		T_MULT { $$ = $1; }
+	|	T_DIV { $$ = $1; }
+	|	T_REM { $$ = $1; }
+	;
+
+CAST_EXPRESSION:
+		UNARY_EXPRESSION { $$ = $1; }
+	|	T_LRB T_TYPE_SPEC T_RRB CAST_EXPRESSION { $$ = $4; }
+	;
+
+UNARY_EXPRESSION:
+		POSTFIX_EXPRESSION { $$ = $1; }
+	|	T_INCDEC UNARY_EXPRESSION { $$ = $2; }
+	|	UNARY_OPERATOR CAST_EXPRESSION { $$ = $2; }
+	|	T_SIZEOF UNARY_EXPRESSION { $$ = $2; }
+	|	T_SIZEOF T_LRB T_TYPE_SPEC T_RRB { $$ = new ast_Expression(); }
+	;
+
+UNARY_OPERATOR:
+		T_AND { $$ = $1; }
+	|	T_ADDSUB_OP { $$ = $1; }
+	|	T_MULT { $$ = $1; }
+	|	T_TILDE { $$ = $1; }
+	|	T_NOT { $$ = $1; }
+	;
+
+POSTFIX_EXPRESSION:
+		PRIMARY_EXPRESSION { $$ = $1; }
+	|	POSTFIX_EXPRESSION T_LSB EXPRESSION T_RSB { $$ = $3; }
+	|	POSTFIX_EXPRESSION T_LRB POSTFIX_EXPRESSION_2 { $$ = $3; }
+	|	POSTFIX_EXPRESSION T_DOT T_IDENTIFIER { $$ = new ast_Expression(); }
+	|	POSTFIX_EXPRESSION T_ARROW T_IDENTIFIER { $$ = new ast_Expression(); }
+	|	POSTFIX_EXPRESSION T_INCDEC { $$ = new ast_Expression(); }
+	;
+
+POSTFIX_EXPRESSION_2:
+		T_RRB { $$ = new ast_Expression(); }
+	|	ARGUMENT_EXPRESSION_LIST T_RRB { $$ = $1; }
+	;
+
+ARGUMENT_EXPRESSION_LIST:
+		ASSIGNMENT_EXPRESSION { $$ = $1; }
+	|	ARGUMENT_EXPRESSION_LIST T_CMA ASSIGNMENT_EXPRESSION { $$ = $3; }
+	;
+
+PRIMARY_EXPRESSION:
+		T_IDENTIFIER { $$ = new ast_Expression(); }
+	|	CONSTANT { $$ = new ast_Expression(); }
+	|	T_LRB EXPRESSION T_RRB { $$ = $2; }
+	;
+
+CONSTANT:
+		T_INT_CONST { $$ = $1; }
+	;
 
 %%