parser: Implement parsing of inclusive-or-expression, exclusive-or-expression, and...

diff --git a/src/grammar.h b/src/grammar.h
index ec8fd4f10ec826bd9ca6ccc8b69823205d1a9784..b55e53676f67deea598d383dc13a6238142c1907 100644 (file)
--- a/src/grammar.h
+++ b/src/grammar.h
@@ -140,7 +140,7 @@ struct exclusive_or_expression {
 };
 
 struct inclusive_or_expression {
-       struct inclusive_or_expression *iorepr;
+       struct inclusive_or_expression *iorexpr;
        struct token *op;
        struct exclusive_or_expression *xorexpr;
 };

diff --git a/src/parser.c b/src/parser.c
index a8d0bc4c3406960c42b48cf4f17710fc2404cb0b..09c2d5f72f637bda06111b4317b8442e4d4b78de 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -766,13 +766,13 @@ struct logical_or_expression *parse_logical_or_expression(void)
        if(!expr->lorexpr || !expr->op || expr->op->type != TOKEN_LOR) {
                /* doesn't look like a prefix... */
 
-               lex_setpos(pos);
-
                if(expr->lorexpr) {
                        free(expr->lorexpr);
                        expr->lorexpr = NULL;
                }
                expr->op = NULL;
+
+               lex_setpos(pos);
        }
 
        if(!(expr->landexpr = parse_logical_and_expression())) {
@@ -783,12 +783,184 @@ struct logical_or_expression *parse_logical_or_expression(void)
 
                free(expr);
                expr = NULL;
+
+               lex_setpos(pos);
        }
 
        return(expr);
 }
 
 struct logical_and_expression *parse_logical_and_expression(void)
+{
+       struct logical_and_expression *expr;
+       int pos;
+
+       expr = logical_and_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       /* same logic as in parse_logical_or_expression() */
+
+       expr->landexpr = parse_logical_and_expression();
+       expr->op = lex_gettoken();
+
+       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->iorexpr = parse_inclusive_or_expression())) {
+               if(expr->landexpr) {
+                       free(expr->landexpr);
+                       expr->landexpr = NULL;
+               }
+
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct inclusive_or_expression *parse_inclusive_or_expression(void)
+{
+       struct inclusive_or_expression *expr;
+       int pos;
+
+       expr = inclusive_or_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->iorexpr = parse_inclusive_or_expression();
+       expr->op = lex_gettoken();
+
+       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->xorexpr = parse_exclusive_or_expression())) {
+               if(expr->iorexpr) {
+                       free(expr->iorexpr);
+                       expr->iorexpr = NULL;
+               }
+
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct exclusive_or_expression *parse_exclusive_or_expression(void)
+{
+       struct exclusive_or_expression *expr;
+       int pos;
+
+       expr = exclusive_or_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->xorexpr = parse_exclusive_or_expression();
+       expr->op = lex_gettoken();
+
+       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->andexpr = parse_and_expression())) {
+               if(expr->xorexpr) {
+                       free(expr->xorexpr);
+                       expr->xorexpr = NULL;
+               }
+
+               expr->op = NULL;
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct and_expression *parse_and_expression(void)
+{
+       struct and_expression *expr;
+       int pos;
+
+       expr = and_expression_new();
+
+       if(!expr) {
+               return(NULL);
+       }
+
+       pos = lex_getpos();
+
+       expr->andexpr = parse_and_expression();
+       expr->op = lex_gettoken();
+
+       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->eqexpr = parse_equality_expression())) {
+               if(expr->andexpr) {
+                       free(expr->andexpr);
+                       expr->andexpr = NULL;
+               }
+
+               free(expr);
+               expr = NULL;
+
+               lex_setpos(pos);
+       }
+
+       return(expr);
+}
+
+struct equality_expression *parse_equality_expression(void)
 {
        return(NULL);
 }

diff --git a/src/parser.h b/src/parser.h
index 8a72a6e3575b7cb6986d450304e737acffe4d821..71a88a8a165acf152d9b7721e789fb6da65b5b26 100644 (file)
--- a/src/parser.h
+++ b/src/parser.h
@@ -13,6 +13,10 @@ struct type_name *parse_type_name(void);
 
 struct logical_or_expression *parse_logical_or_expression(void);
 struct logical_and_expression *parse_logical_and_expression(void);
+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 unary_expression *parse_unary_expression(void);
 struct conditional_expression *parse_conditional_expression(void);