From c866f245103e2a7cffbfe27ac4e71be44d0a663f Mon Sep 17 00:00:00 2001
From: Matthias Kruk <m@m10k.eu>
Date: Tue, 7 Jul 2020 20:39:22 +0900
Subject: [PATCH] parser: Fix parsing of logical-or-expression,
 logical-and-expression, inclusive-or-expression, exclusive-or-expression,
 and-expression, equality-expression, relational-expression, shift-expression,
 additive-expression, and multiplicative-expression grammatical structures

---
 src/parser.c | 331 +++++++++++++++++----------------------------------
 1 file changed, 109 insertions(+), 222 deletions(-)

diff --git a/src/parser.c b/src/parser.c
index 9f7bfd1..6e6a93b 100644
--- 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);
 }
-- 
2.47.3