kconfig: remove 'e1' and 'e2' macros from expression deduplication

I do not think the macros 'e1' and 'e2' are readable.

The statement:

    e1 = expr_alloc_symbol(...);

affects the caller's variable, but this is not sufficiently clear from the code.

Remove the macros. No functional change intended.

Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>

diff --git a/scripts/kconfig/expr.c b/scripts/kconfig/expr.c
index a85e0d603322181f27537d0a33c10535c52fc486..c349da7fe3f88d6c0fc7eb51b9bc50fe66cc1017 100644 (file)
--- a/scripts/kconfig/expr.c
+++ b/scripts/kconfig/expr.c
@@ -135,9 +135,6 @@ void expr_free(struct expr *e)
 
 static int trans_count;
 
-#define e1 (*ep1)
-#define e2 (*ep2)
-
 /*
  * expr_eliminate_eq() helper.
  *
@@ -150,38 +147,38 @@ static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct e
 {
        /* Recurse down to leaves */
 
-       if (e1->type == type) {
-               __expr_eliminate_eq(type, &e1->left.expr, &e2);
-               __expr_eliminate_eq(type, &e1->right.expr, &e2);
+       if ((*ep1)->type == type) {
+               __expr_eliminate_eq(type, &(*ep1)->left.expr, ep2);
+               __expr_eliminate_eq(type, &(*ep1)->right.expr, ep2);
                return;
        }
-       if (e2->type == type) {
-               __expr_eliminate_eq(type, &e1, &e2->left.expr);
-               __expr_eliminate_eq(type, &e1, &e2->right.expr);
+       if ((*ep2)->type == type) {
+               __expr_eliminate_eq(type, ep1, &(*ep2)->left.expr);
+               __expr_eliminate_eq(type, ep1, &(*ep2)->right.expr);
                return;
        }
 
-       /* e1 and e2 are leaves. Compare them. */
+       /* *ep1 and *ep2 are leaves. Compare them. */
 
-       if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
-           e1->left.sym == e2->left.sym &&
-           (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
+       if ((*ep1)->type == E_SYMBOL && (*ep2)->type == E_SYMBOL &&
+           (*ep1)->left.sym == (*ep2)->left.sym &&
+           ((*ep1)->left.sym == &symbol_yes || (*ep1)->left.sym == &symbol_no))
                return;
-       if (!expr_eq(e1, e2))
+       if (!expr_eq(*ep1, *ep2))
                return;
 
-       /* e1 and e2 are equal leaves. Prepare them for elimination. */
+       /* *ep1 and *ep2 are equal leaves. Prepare them for elimination. */
 
        trans_count++;
-       expr_free(e1); expr_free(e2);
+       expr_free(*ep1); expr_free(*ep2);
        switch (type) {
        case E_OR:
-               e1 = expr_alloc_symbol(&symbol_no);
-               e2 = expr_alloc_symbol(&symbol_no);
+               *ep1 = expr_alloc_symbol(&symbol_no);
+               *ep2 = expr_alloc_symbol(&symbol_no);
                break;
        case E_AND:
-               e1 = expr_alloc_symbol(&symbol_yes);
-               e2 = expr_alloc_symbol(&symbol_yes);
+               *ep1 = expr_alloc_symbol(&symbol_yes);
+               *ep2 = expr_alloc_symbol(&symbol_yes);
                break;
        default:
                ;
@@ -219,29 +216,26 @@ static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct e
  */
 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
 {
-       if (!e1 || !e2)
+       if (!*ep1 || !*ep2)
                return;
-       switch (e1->type) {
+       switch ((*ep1)->type) {
        case E_OR:
        case E_AND:
-               __expr_eliminate_eq(e1->type, ep1, ep2);
+               __expr_eliminate_eq((*ep1)->type, ep1, ep2);
        default:
                ;
        }
-       if (e1->type != e2->type) switch (e2->type) {
+       if ((*ep1)->type != (*ep2)->type) switch ((*ep2)->type) {
        case E_OR:
        case E_AND:
-               __expr_eliminate_eq(e2->type, ep1, ep2);
+               __expr_eliminate_eq((*ep2)->type, ep1, ep2);
        default:
                ;
        }
-       e1 = expr_eliminate_yn(e1);
-       e2 = expr_eliminate_yn(e2);
+       *ep1 = expr_eliminate_yn(*ep1);
+       *ep2 = expr_eliminate_yn(*ep2);
 }
 
-#undef e1
-#undef e2
-
 /*
  * Returns true if 'e1' and 'e2' are equal, after minor simplification. Two
  * &&/|| expressions are considered equal if every operand in one expression
@@ -564,59 +558,55 @@ static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
  */
 static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2)
 {
-#define e1 (*ep1)
-#define e2 (*ep2)
        struct expr *tmp;
 
        /* Recurse down to leaves */
 
-       if (e1->type == type) {
-               expr_eliminate_dups1(type, &e1->left.expr, &e2);
-               expr_eliminate_dups1(type, &e1->right.expr, &e2);
+       if ((*ep1)->type == type) {
+               expr_eliminate_dups1(type, &(*ep1)->left.expr, ep2);
+               expr_eliminate_dups1(type, &(*ep1)->right.expr, ep2);
                return;
        }
-       if (e2->type == type) {
-               expr_eliminate_dups1(type, &e1, &e2->left.expr);
-               expr_eliminate_dups1(type, &e1, &e2->right.expr);
+       if ((*ep2)->type == type) {
+               expr_eliminate_dups1(type, ep1, &(*ep2)->left.expr);
+               expr_eliminate_dups1(type, ep1, &(*ep2)->right.expr);
                return;
        }
 
-       /* e1 and e2 are leaves. Compare and process them. */
+       /* *ep1 and *ep2 are leaves. Compare and process them. */
 
-       if (e1 == e2)
+       if (*ep1 == *ep2)
                return;
 
-       switch (e1->type) {
+       switch ((*ep1)->type) {
        case E_OR: case E_AND:
-               expr_eliminate_dups1(e1->type, &e1, &e1);
+               expr_eliminate_dups1((*ep1)->type, ep1, ep1);
        default:
                ;
        }
 
        switch (type) {
        case E_OR:
-               tmp = expr_join_or(e1, e2);
+               tmp = expr_join_or(*ep1, *ep2);
                if (tmp) {
-                       expr_free(e1); expr_free(e2);
-                       e1 = expr_alloc_symbol(&symbol_no);
-                       e2 = tmp;
+                       expr_free(*ep1); expr_free(*ep2);
+                       *ep1 = expr_alloc_symbol(&symbol_no);
+                       *ep2 = tmp;
                        trans_count++;
                }
                break;
        case E_AND:
-               tmp = expr_join_and(e1, e2);
+               tmp = expr_join_and(*ep1, *ep2);
                if (tmp) {
-                       expr_free(e1); expr_free(e2);
-                       e1 = expr_alloc_symbol(&symbol_yes);
-                       e2 = tmp;
+                       expr_free(*ep1); expr_free(*ep2);
+                       *ep1 = expr_alloc_symbol(&symbol_yes);
+                       *ep2 = tmp;
                        trans_count++;
                }
                break;
        default:
                ;
        }
-#undef e1
-#undef e2
 }
 
 /*