parser: Fix parsing of logical-or-expression, logical-and-expression, inclusive-or...

diff --git a/src/parser.c b/src/parser.c
index 9f7bfd19620486f04a1f2b979fc6751e3a5fcc1f..6e6a93b5f9b0a8305fb6e72d1a689f4671517892 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -756,38 +756,24 @@ struct logical_or_expression *parse_logical_or_expression(void)
                return(NULL);
        }
 
-       pos = lex_getpos();
+       if((expr->landexpr = parse_logical_and_expression())) {
+               return(expr);
+       }
 
-       /* attempt to parse `logical-OR-expression ||' prefix */
+       pos = lex_getpos();
 
        expr->lorexpr = parse_logical_or_expression();
        expr->op = lex_gettoken();
+       expr->landexpr = parse_logical_and_expression();
 
-       if(!expr->lorexpr || !expr->op || expr->op->type != TOKEN_LOR) {
-               /* doesn't look like a prefix... */
-
-               if(expr->lorexpr) {
-                       free(expr->lorexpr);
-                       expr->lorexpr = NULL;
-               }
-               expr->op = NULL;
-
-               lex_setpos(pos);
+       if(expr->lorexpr && expr->landexpr && expr->op && expr->op->type == TOKEN_LOR) {
+               return(expr);
        }
 
-       if(!(expr->landexpr = parse_logical_and_expression())) {
-               if(expr->lorexpr) {
-                       free(expr->lorexpr);
-                       expr->lorexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
-
-               lex_setpos(pos);
-       }
+       lex_setpos(pos);
+       logical_or_expression_free(expr);
 
-       return(expr);
+       return(NULL);
 }
 
 struct logical_and_expression *parse_logical_and_expression(void)
@@ -801,38 +787,24 @@ struct logical_and_expression *parse_logical_and_expression(void)
                return(NULL);
        }
 
-       pos = lex_getpos();
+       if((expr->iorexpr = parse_inclusive_or_expression())) {
+               return(expr);
+       }
 
-       /* same logic as in parse_logical_or_expression() */
+       pos = lex_getpos();
 
        expr->landexpr = parse_logical_and_expression();
        expr->op = lex_gettoken();
+       expr->iorexpr = parse_inclusive_or_expression();
 
-       if(!expr->landexpr || !expr->op || expr->op->type != TOKEN_LAND) {
-               /* wasn't a prefix after all */
-
-               if(expr->landexpr) {
-                       free(expr->landexpr);
-                       expr->landexpr = NULL;
-               }
-
-               expr->op = NULL;
-               lex_setpos(pos);
+       if(expr->landexpr && expr->iorexpr && expr->op && expr->op->type == TOKEN_LAND) {
+               return(expr);
        }
 
-       if(!(expr->iorexpr = parse_inclusive_or_expression())) {
-               if(expr->landexpr) {
-                       free(expr->landexpr);
-                       expr->landexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
+       lex_setpos(pos);
+       logical_and_expression_free(expr);
 
-               lex_setpos(pos);
-       }
-
-       return(expr);
+       return(NULL);
 }
 
 struct inclusive_or_expression *parse_inclusive_or_expression(void)
@@ -846,34 +818,24 @@ struct inclusive_or_expression *parse_inclusive_or_expression(void)
                return(NULL);
        }
 
+       if((expr->xorexpr = parse_exclusive_or_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->iorexpr = parse_inclusive_or_expression();
        expr->op = lex_gettoken();
+       expr->xorexpr = parse_exclusive_or_expression();
 
-       if(!expr->iorexpr || !expr->op || expr->op->type != TOKEN_OR) {
-               if(expr->iorexpr) {
-                       free(expr->iorexpr);
-                       expr->iorexpr = NULL;
-               }
-
-               expr->op = NULL;
-               lex_setpos(pos);
+       if(expr->iorexpr && expr->xorexpr && expr->op && expr->op->type && TOKEN_OR) {
+               return(expr);
        }
 
-       if(!(expr->xorexpr = parse_exclusive_or_expression())) {
-               if(expr->iorexpr) {
-                       free(expr->iorexpr);
-                       expr->iorexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
+       lex_setpos(pos);
+       inclusive_or_expression_free(expr);
 
-               lex_setpos(pos);
-       }
-
-       return(expr);
+       return(NULL);
 }
 
 struct exclusive_or_expression *parse_exclusive_or_expression(void)
@@ -887,36 +849,24 @@ struct exclusive_or_expression *parse_exclusive_or_expression(void)
                return(NULL);
        }
 
+       if((expr->andexpr = parse_and_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->xorexpr = parse_exclusive_or_expression();
        expr->op = lex_gettoken();
+       expr->andexpr = parse_and_expression();
 
-       if(!expr->xorexpr || !expr->op || expr->op->type != TOKEN_XOR) {
-               if(expr->xorexpr) {
-                       free(expr->xorexpr);
-                       expr->xorexpr = NULL;
-               }
-
-               expr->op = NULL;
-
-               lex_setpos(pos);
+       if(expr->xorexpr && expr->andexpr && expr->op && expr->op->type == TOKEN_XOR) {
+               return(expr);
        }
 
-       if(!(expr->andexpr = parse_and_expression())) {
-               if(expr->xorexpr) {
-                       free(expr->xorexpr);
-                       expr->xorexpr = NULL;
-               }
-
-               expr->op = NULL;
-               free(expr);
-               expr = NULL;
-
-               lex_setpos(pos);
-       }
+       lex_setpos(pos);
+       exclusive_or_expression_free(expr);
 
-       return(expr);
+       return(NULL);
 }
 
 struct and_expression *parse_and_expression(void)
@@ -930,34 +880,24 @@ struct and_expression *parse_and_expression(void)
                return(NULL);
        }
 
+       if((expr->eqexpr = parse_equality_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->andexpr = parse_and_expression();
        expr->op = lex_gettoken();
+       expr->eqexpr = parse_equality_expression();
 
-       if(!expr->andexpr || !expr->op || expr->op->type != TOKEN_AND) {
-               if(expr->andexpr) {
-                       free(expr->andexpr);
-                       expr->andexpr = NULL;
-               }
-
-               expr->op = NULL;
-               lex_setpos(pos);
+       if(expr->andexpr && expr->eqexpr && expr->op && expr->op->type == TOKEN_AND) {
+               return(expr);
        }
 
-       if(!(expr->eqexpr = parse_equality_expression())) {
-               if(expr->andexpr) {
-                       free(expr->andexpr);
-                       expr->andexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
-
-               lex_setpos(pos);
-       }
+       lex_setpos(pos);
+       and_expression_free(expr);
 
-       return(expr);
+       return(NULL);
 }
 
 struct equality_expression *parse_equality_expression(void)
@@ -971,35 +911,25 @@ struct equality_expression *parse_equality_expression(void)
                return(NULL);
        }
 
+       if((expr->relexpr = parse_relational_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->eqexpr = parse_equality_expression();
        expr->op = lex_gettoken();
+       expr->relexpr = parse_relational_expression();
 
-       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->eqexpr && expr->relexpr && expr->op && (expr->op->type == TOKEN_EQ ||
+                                                        expr->op->type == TOKEN_NEQ)) {
+               return(expr);
        }
 
-       if(!(expr->relexpr = parse_relational_expression())) {
-               if(expr->eqexpr) {
-                       free(expr->eqexpr);
-                       expr->eqexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
-
-               lex_setpos(pos);
-       }
+       lex_setpos(pos);
+       equality_expression_free(expr);
 
-       return(expr);
+       return(NULL);
 }
 
 struct relational_expression *parse_relational_expression(void)
@@ -1013,37 +943,27 @@ struct relational_expression *parse_relational_expression(void)
                return(NULL);
        }
 
+       if((expr->sexpr = parse_shift_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->relexpr = parse_relational_expression();
        expr->op = lex_gettoken();
+       expr->sexpr = parse_shift_expression();
 
-       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->relexpr && expr->sexpr && expr->op && (expr->op->type == TOKEN_GT ||
+                                                       expr->op->type == TOKEN_LT ||
+                                                       expr->op->type == TOKEN_GE ||
+                                                       expr->op->type == TOKEN_LE)) {
+               return(expr);
        }
 
-       if(!(expr->sexpr = parse_shift_expression())) {
-               if(expr->relexpr) {
-                       free(expr->relexpr);
-                       expr->relexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
-
-               lex_setpos(pos);
-       }
+       lex_setpos(pos);
+       relational_expression_free(expr);
 
-       return(expr);
+       return(NULL);
 }
 
 struct shift_expression *parse_shift_expression(void)
@@ -1057,37 +977,25 @@ struct shift_expression *parse_shift_expression(void)
                return(NULL);
        }
 
+       if((expr->addexpr = parse_additive_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->sexpr = parse_shift_expression();
        expr->op = lex_gettoken();
+       expr->addexpr = parse_additive_expression();
 
-       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->sexpr && expr->addexpr && expr->op && (expr->op->type == TOKEN_SHL ||
+                                                       expr->op->type == TOKEN_SHR)) {
+               return(expr);
        }
 
-       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);
-       }
+       lex_setpos(pos);
+       shift_expression_free(expr);
 
-       return(expr);
+       return(NULL);
 }
 
 struct additive_expression *parse_additive_expression(void)
@@ -1101,34 +1009,25 @@ struct additive_expression *parse_additive_expression(void)
                return(NULL);
        }
 
+       if((expr->mulexpr = parse_multiplicative_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
+
        expr->addexpr = parse_additive_expression();
        expr->op = lex_gettoken();
+       expr->mulexpr = parse_multiplicative_expression();
 
-       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 && expr->addexpr && expr->op && (expr->op->type == TOKEN_ADD ||
+                                                         expr->op->type == TOKEN_SUB)) {
+               return(expr);
        }
 
-       if(!(expr->mulexpr = parse_multiplicative_expression())) {
-               if(expr->addexpr) {
-                       free(expr->addexpr);
-                       expr->addexpr = NULL;
-               }
-
-               free(expr);
-               expr = NULL;
+       lex_setpos(pos);
+       additive_expression_free(expr);
 
-               lex_setpos(pos);
-       }
-
-       return(expr);
+       return(NULL);
 }
 
 struct multiplicative_expression *parse_multiplicative_expression(void)
@@ -1142,36 +1041,24 @@ struct multiplicative_expression *parse_multiplicative_expression(void)
                return(NULL);
        }
 
+       if((expr->castexpr = parse_cast_expression())) {
+               return(expr);
+       }
+
        pos = lex_getpos();
 
        expr->mulexpr = parse_multiplicative_expression();
        expr->op = lex_gettoken();
+       expr->castexpr = parse_cast_expression();
 
-       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->mulexpr && expr->castexpr && expr->op && (expr->op->type == TOKEN_MUL ||
+                                                          expr->op->type == TOKEN_DIV ||
+                                                          expr->op->type == TOKEN_MOD)) {
+               return(expr);
        }
 
-       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);
+       multiplicative_expression_free(expr);
 
-               lex_setpos(pos);
-       }
-
-       return(expr);
+       return(NULL);
 }