From 12ca1c7ff9ba4e41e9c6ddfde625b6bdc7d09580 Mon Sep 17 00:00:00 2001
From: Matthias Kruk <m@m10k.eu>
Date: Sun, 5 Jul 2020 17:58:38 +0900
Subject: [PATCH] parser: Implement parsing of inclusive-or-expression,
 exclusive-or-expression, and-expression, and equality-expression grammar
 constructs

---
 src/grammar.h |   2 +-
 src/parser.c  | 176 +++++++++++++++++++++++++++++++++++++++++++++++++-
 src/parser.h  |   4 ++
 3 files changed, 179 insertions(+), 3 deletions(-)

diff --git a/src/grammar.h b/src/grammar.h
index ec8fd4f..b55e536 100644
--- 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 a8d0bc4..09c2d5f 100644
--- 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 8a72a6e..71a88a8 100644
--- 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);
-- 
2.47.3