parser: Implement parsing of relational-expression, shift-expression, additive-expres...

diff --git a/src/parser.c b/src/parser.c
index 09c2d5f72f637bda06111b4317b8442e4d4b78de..9f7bfd19620486f04a1f2b979fc6751e3a5fcc1f 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -962,5 +962,216 @@ struct and_expression *parse_and_expression(void)
 
 struct equality_expression *parse_equality_expression(void)
 {
-       return(NULL);
+       struct equality_expression *expr;
+       int pos;
+
+       expr = equality_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->eqexpr = parse_equality_expression();
+       expr->op = lex_gettoken();
+
+       if(!expr->eqexpr || !expr->op || (expr->op->type != TOKEN_EQ &&
+                                         expr->op->type != TOKEN_NEQ)) {
+               if(expr->eqexpr) {
+                       free(expr->eqexpr);
+                       expr->eqexpr = NULL;
+               }
+
+               expr->op = NULL;
+               lex_setpos(pos);
+       }
+
+       if(!(expr->relexpr = parse_relational_expression())) {
+               if(expr->eqexpr) {
+                       free(expr->eqexpr);
+                       expr->eqexpr = NULL;
+               }
+
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct relational_expression *parse_relational_expression(void)
+{
+       struct relational_expression *expr;
+       int pos;
+
+       expr = relational_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->relexpr = parse_relational_expression();
+       expr->op = lex_gettoken();
+
+       if(!expr->relexpr || !expr->op || (expr->op->type != TOKEN_LT &&
+                                          expr->op->type != TOKEN_GT &&
+                                          expr->op->type != TOKEN_LE &&
+                                          expr->op->type != TOKEN_GE)) {
+               if(expr->relexpr) {
+                       free(expr->relexpr);
+                       expr->relexpr = NULL;
+               }
+
+               expr->op = NULL;
+               lex_setpos(pos);
+       }
+
+       if(!(expr->sexpr = parse_shift_expression())) {
+               if(expr->relexpr) {
+                       free(expr->relexpr);
+                       expr->relexpr = NULL;
+               }
+
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct shift_expression *parse_shift_expression(void)
+{
+       struct shift_expression *expr;
+       int pos;
+
+       expr = shift_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->sexpr = parse_shift_expression();
+       expr->op = lex_gettoken();
+
+       if(!expr->sexpr || !expr->op || (expr->op->type != TOKEN_SHL &&
+                                        expr->op->type != TOKEN_SHR)) {
+               if(expr->sexpr) {
+                       free(expr->sexpr);
+                       expr->sexpr = NULL;
+               }
+
+               expr->op = NULL;
+
+               lex_setpos(pos);
+       }
+
+       if(!(expr->addexpr = parse_additive_expression())) {
+               if(expr->sexpr) {
+                       free(expr->sexpr);
+                       expr->sexpr = NULL;
+               }
+
+               expr->op = NULL;
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct additive_expression *parse_additive_expression(void)
+{
+       struct additive_expression *expr;
+       int pos;
+
+       expr = additive_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+       expr->addexpr = parse_additive_expression();
+       expr->op = lex_gettoken();
+
+       if(!expr->addexpr || !expr->op || (expr->op->type != TOKEN_ADD &&
+                                          expr->op->type != TOKEN_SUB)) {
+               if(expr->addexpr) {
+                       free(expr->addexpr);
+                       expr->addexpr = NULL;
+               }
+
+               expr->op = NULL;
+               lex_setpos(pos);
+       }
+
+       if(!(expr->mulexpr = parse_multiplicative_expression())) {
+               if(expr->addexpr) {
+                       free(expr->addexpr);
+                       expr->addexpr = NULL;
+               }
+
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct multiplicative_expression *parse_multiplicative_expression(void)
+{
+       struct multiplicative_expression *expr;
+       int pos;
+
+       expr = multiplicative_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->mulexpr = parse_multiplicative_expression();
+       expr->op = lex_gettoken();
+
+       if(!expr->mulexpr || !expr->op || (expr->op->type != TOKEN_MUL &&
+                                          expr->op->type != TOKEN_DIV &&
+                                          expr->op->type != TOKEN_MOD)) {
+               if(expr->mulexpr) {
+                       free(expr->mulexpr);
+                       expr->mulexpr = NULL;
+               }
+
+               expr->op = NULL;
+
+               lex_setpos(pos);
+       }
+
+       if(!(expr->castexpr = parse_cast_expression())) {
+               if(expr->mulexpr) {
+                       free(expr->mulexpr);
+                       expr->mulexpr = NULL;
+               }
+
+               expr->op = NULL;
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
 }

diff --git a/src/parser.h b/src/parser.h
index 71a88a8a165acf152d9b7721e789fb6da65b5b26..4a0e8063f6d51b3784daff553c700f9c55a968bf 100644 (file)
--- a/src/parser.h
+++ b/src/parser.h
@@ -17,6 +17,11 @@ struct inclusive_or_expression *parse_inclusive_or_expression(void);
 struct exclusive_or_expression *parse_exclusive_or_expression(void);
 struct and_expression *parse_and_expression(void);
 struct equality_expression *parse_equality_expression(void);
+struct relational_expression *parse_relational_expression(void);
+struct shift_expression *parse_shift_expression(void);
+struct additive_expression *parse_additive_expression(void);
+struct multiplicative_expression *parse_multiplicative_expression(void);
+struct cast_expression *parse_cast_expression(void);
 
 struct unary_expression *parse_unary_expression(void);
 struct conditional_expression *parse_conditional_expression(void);