GNU Linux-libre 4.19.211-gnu1
[releases.git] / scripts / kconfig / expr.c
1 /*
2  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3  * Released under the terms of the GNU GPL v2.0.
4  */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include "lkc.h"
11
12 #define DEBUG_EXPR      0
13
14 static int expr_eq(struct expr *e1, struct expr *e2);
15 static struct expr *expr_eliminate_yn(struct expr *e);
16
17 struct expr *expr_alloc_symbol(struct symbol *sym)
18 {
19         struct expr *e = xcalloc(1, sizeof(*e));
20         e->type = E_SYMBOL;
21         e->left.sym = sym;
22         return e;
23 }
24
25 struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
26 {
27         struct expr *e = xcalloc(1, sizeof(*e));
28         e->type = type;
29         e->left.expr = ce;
30         return e;
31 }
32
33 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
34 {
35         struct expr *e = xcalloc(1, sizeof(*e));
36         e->type = type;
37         e->left.expr = e1;
38         e->right.expr = e2;
39         return e;
40 }
41
42 struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
43 {
44         struct expr *e = xcalloc(1, sizeof(*e));
45         e->type = type;
46         e->left.sym = s1;
47         e->right.sym = s2;
48         return e;
49 }
50
51 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
52 {
53         if (!e1)
54                 return e2;
55         return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
56 }
57
58 struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
59 {
60         if (!e1)
61                 return e2;
62         return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
63 }
64
65 struct expr *expr_copy(const struct expr *org)
66 {
67         struct expr *e;
68
69         if (!org)
70                 return NULL;
71
72         e = xmalloc(sizeof(*org));
73         memcpy(e, org, sizeof(*org));
74         switch (org->type) {
75         case E_SYMBOL:
76                 e->left = org->left;
77                 break;
78         case E_NOT:
79                 e->left.expr = expr_copy(org->left.expr);
80                 break;
81         case E_EQUAL:
82         case E_GEQ:
83         case E_GTH:
84         case E_LEQ:
85         case E_LTH:
86         case E_UNEQUAL:
87                 e->left.sym = org->left.sym;
88                 e->right.sym = org->right.sym;
89                 break;
90         case E_AND:
91         case E_OR:
92         case E_LIST:
93                 e->left.expr = expr_copy(org->left.expr);
94                 e->right.expr = expr_copy(org->right.expr);
95                 break;
96         default:
97                 fprintf(stderr, "can't copy type %d\n", e->type);
98                 free(e);
99                 e = NULL;
100                 break;
101         }
102
103         return e;
104 }
105
106 void expr_free(struct expr *e)
107 {
108         if (!e)
109                 return;
110
111         switch (e->type) {
112         case E_SYMBOL:
113                 break;
114         case E_NOT:
115                 expr_free(e->left.expr);
116                 break;
117         case E_EQUAL:
118         case E_GEQ:
119         case E_GTH:
120         case E_LEQ:
121         case E_LTH:
122         case E_UNEQUAL:
123                 break;
124         case E_OR:
125         case E_AND:
126                 expr_free(e->left.expr);
127                 expr_free(e->right.expr);
128                 break;
129         default:
130                 fprintf(stderr, "how to free type %d?\n", e->type);
131                 break;
132         }
133         free(e);
134 }
135
136 static int trans_count;
137
138 #define e1 (*ep1)
139 #define e2 (*ep2)
140
141 /*
142  * expr_eliminate_eq() helper.
143  *
144  * Walks the two expression trees given in 'ep1' and 'ep2'. Any node that does
145  * not have type 'type' (E_OR/E_AND) is considered a leaf, and is compared
146  * against all other leaves. Two equal leaves are both replaced with either 'y'
147  * or 'n' as appropriate for 'type', to be eliminated later.
148  */
149 static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
150 {
151         /* Recurse down to leaves */
152
153         if (e1->type == type) {
154                 __expr_eliminate_eq(type, &e1->left.expr, &e2);
155                 __expr_eliminate_eq(type, &e1->right.expr, &e2);
156                 return;
157         }
158         if (e2->type == type) {
159                 __expr_eliminate_eq(type, &e1, &e2->left.expr);
160                 __expr_eliminate_eq(type, &e1, &e2->right.expr);
161                 return;
162         }
163
164         /* e1 and e2 are leaves. Compare them. */
165
166         if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
167             e1->left.sym == e2->left.sym &&
168             (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
169                 return;
170         if (!expr_eq(e1, e2))
171                 return;
172
173         /* e1 and e2 are equal leaves. Prepare them for elimination. */
174
175         trans_count++;
176         expr_free(e1); expr_free(e2);
177         switch (type) {
178         case E_OR:
179                 e1 = expr_alloc_symbol(&symbol_no);
180                 e2 = expr_alloc_symbol(&symbol_no);
181                 break;
182         case E_AND:
183                 e1 = expr_alloc_symbol(&symbol_yes);
184                 e2 = expr_alloc_symbol(&symbol_yes);
185                 break;
186         default:
187                 ;
188         }
189 }
190
191 /*
192  * Rewrites the expressions 'ep1' and 'ep2' to remove operands common to both.
193  * Example reductions:
194  *
195  *      ep1: A && B           ->  ep1: y
196  *      ep2: A && B && C      ->  ep2: C
197  *
198  *      ep1: A || B           ->  ep1: n
199  *      ep2: A || B || C      ->  ep2: C
200  *
201  *      ep1: A && (B && FOO)  ->  ep1: FOO
202  *      ep2: (BAR && B) && A  ->  ep2: BAR
203  *
204  *      ep1: A && (B || C)    ->  ep1: y
205  *      ep2: (C || B) && A    ->  ep2: y
206  *
207  * Comparisons are done between all operands at the same "level" of && or ||.
208  * For example, in the expression 'e1 && (e2 || e3) && (e4 || e5)', the
209  * following operands will be compared:
210  *
211  *      - 'e1', 'e2 || e3', and 'e4 || e5', against each other
212  *      - e2 against e3
213  *      - e4 against e5
214  *
215  * Parentheses are irrelevant within a single level. 'e1 && (e2 && e3)' and
216  * '(e1 && e2) && e3' are both a single level.
217  *
218  * See __expr_eliminate_eq() as well.
219  */
220 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
221 {
222         if (!e1 || !e2)
223                 return;
224         switch (e1->type) {
225         case E_OR:
226         case E_AND:
227                 __expr_eliminate_eq(e1->type, ep1, ep2);
228         default:
229                 ;
230         }
231         if (e1->type != e2->type) switch (e2->type) {
232         case E_OR:
233         case E_AND:
234                 __expr_eliminate_eq(e2->type, ep1, ep2);
235         default:
236                 ;
237         }
238         e1 = expr_eliminate_yn(e1);
239         e2 = expr_eliminate_yn(e2);
240 }
241
242 #undef e1
243 #undef e2
244
245 /*
246  * Returns true if 'e1' and 'e2' are equal, after minor simplification. Two
247  * &&/|| expressions are considered equal if every operand in one expression
248  * equals some operand in the other (operands do not need to appear in the same
249  * order), recursively.
250  */
251 static int expr_eq(struct expr *e1, struct expr *e2)
252 {
253         int res, old_count;
254
255         /*
256          * A NULL expr is taken to be yes, but there's also a different way to
257          * represent yes. expr_is_yes() checks for either representation.
258          */
259         if (!e1 || !e2)
260                 return expr_is_yes(e1) && expr_is_yes(e2);
261
262         if (e1->type != e2->type)
263                 return 0;
264         switch (e1->type) {
265         case E_EQUAL:
266         case E_GEQ:
267         case E_GTH:
268         case E_LEQ:
269         case E_LTH:
270         case E_UNEQUAL:
271                 return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
272         case E_SYMBOL:
273                 return e1->left.sym == e2->left.sym;
274         case E_NOT:
275                 return expr_eq(e1->left.expr, e2->left.expr);
276         case E_AND:
277         case E_OR:
278                 e1 = expr_copy(e1);
279                 e2 = expr_copy(e2);
280                 old_count = trans_count;
281                 expr_eliminate_eq(&e1, &e2);
282                 res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
283                        e1->left.sym == e2->left.sym);
284                 expr_free(e1);
285                 expr_free(e2);
286                 trans_count = old_count;
287                 return res;
288         case E_LIST:
289         case E_RANGE:
290         case E_NONE:
291                 /* panic */;
292         }
293
294         if (DEBUG_EXPR) {
295                 expr_fprint(e1, stdout);
296                 printf(" = ");
297                 expr_fprint(e2, stdout);
298                 printf(" ?\n");
299         }
300
301         return 0;
302 }
303
304 /*
305  * Recursively performs the following simplifications in-place (as well as the
306  * corresponding simplifications with swapped operands):
307  *
308  *      expr && n  ->  n
309  *      expr && y  ->  expr
310  *      expr || n  ->  expr
311  *      expr || y  ->  y
312  *
313  * Returns the optimized expression.
314  */
315 static struct expr *expr_eliminate_yn(struct expr *e)
316 {
317         struct expr *tmp;
318
319         if (e) switch (e->type) {
320         case E_AND:
321                 e->left.expr = expr_eliminate_yn(e->left.expr);
322                 e->right.expr = expr_eliminate_yn(e->right.expr);
323                 if (e->left.expr->type == E_SYMBOL) {
324                         if (e->left.expr->left.sym == &symbol_no) {
325                                 expr_free(e->left.expr);
326                                 expr_free(e->right.expr);
327                                 e->type = E_SYMBOL;
328                                 e->left.sym = &symbol_no;
329                                 e->right.expr = NULL;
330                                 return e;
331                         } else if (e->left.expr->left.sym == &symbol_yes) {
332                                 free(e->left.expr);
333                                 tmp = e->right.expr;
334                                 *e = *(e->right.expr);
335                                 free(tmp);
336                                 return e;
337                         }
338                 }
339                 if (e->right.expr->type == E_SYMBOL) {
340                         if (e->right.expr->left.sym == &symbol_no) {
341                                 expr_free(e->left.expr);
342                                 expr_free(e->right.expr);
343                                 e->type = E_SYMBOL;
344                                 e->left.sym = &symbol_no;
345                                 e->right.expr = NULL;
346                                 return e;
347                         } else if (e->right.expr->left.sym == &symbol_yes) {
348                                 free(e->right.expr);
349                                 tmp = e->left.expr;
350                                 *e = *(e->left.expr);
351                                 free(tmp);
352                                 return e;
353                         }
354                 }
355                 break;
356         case E_OR:
357                 e->left.expr = expr_eliminate_yn(e->left.expr);
358                 e->right.expr = expr_eliminate_yn(e->right.expr);
359                 if (e->left.expr->type == E_SYMBOL) {
360                         if (e->left.expr->left.sym == &symbol_no) {
361                                 free(e->left.expr);
362                                 tmp = e->right.expr;
363                                 *e = *(e->right.expr);
364                                 free(tmp);
365                                 return e;
366                         } else if (e->left.expr->left.sym == &symbol_yes) {
367                                 expr_free(e->left.expr);
368                                 expr_free(e->right.expr);
369                                 e->type = E_SYMBOL;
370                                 e->left.sym = &symbol_yes;
371                                 e->right.expr = NULL;
372                                 return e;
373                         }
374                 }
375                 if (e->right.expr->type == E_SYMBOL) {
376                         if (e->right.expr->left.sym == &symbol_no) {
377                                 free(e->right.expr);
378                                 tmp = e->left.expr;
379                                 *e = *(e->left.expr);
380                                 free(tmp);
381                                 return e;
382                         } else if (e->right.expr->left.sym == &symbol_yes) {
383                                 expr_free(e->left.expr);
384                                 expr_free(e->right.expr);
385                                 e->type = E_SYMBOL;
386                                 e->left.sym = &symbol_yes;
387                                 e->right.expr = NULL;
388                                 return e;
389                         }
390                 }
391                 break;
392         default:
393                 ;
394         }
395         return e;
396 }
397
398 /*
399  * bool FOO!=n => FOO
400  */
401 struct expr *expr_trans_bool(struct expr *e)
402 {
403         if (!e)
404                 return NULL;
405         switch (e->type) {
406         case E_AND:
407         case E_OR:
408         case E_NOT:
409                 e->left.expr = expr_trans_bool(e->left.expr);
410                 e->right.expr = expr_trans_bool(e->right.expr);
411                 break;
412         case E_UNEQUAL:
413                 // FOO!=n -> FOO
414                 if (e->left.sym->type == S_TRISTATE) {
415                         if (e->right.sym == &symbol_no) {
416                                 e->type = E_SYMBOL;
417                                 e->right.sym = NULL;
418                         }
419                 }
420                 break;
421         default:
422                 ;
423         }
424         return e;
425 }
426
427 /*
428  * e1 || e2 -> ?
429  */
430 static struct expr *expr_join_or(struct expr *e1, struct expr *e2)
431 {
432         struct expr *tmp;
433         struct symbol *sym1, *sym2;
434
435         if (expr_eq(e1, e2))
436                 return expr_copy(e1);
437         if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
438                 return NULL;
439         if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
440                 return NULL;
441         if (e1->type == E_NOT) {
442                 tmp = e1->left.expr;
443                 if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
444                         return NULL;
445                 sym1 = tmp->left.sym;
446         } else
447                 sym1 = e1->left.sym;
448         if (e2->type == E_NOT) {
449                 if (e2->left.expr->type != E_SYMBOL)
450                         return NULL;
451                 sym2 = e2->left.expr->left.sym;
452         } else
453                 sym2 = e2->left.sym;
454         if (sym1 != sym2)
455                 return NULL;
456         if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
457                 return NULL;
458         if (sym1->type == S_TRISTATE) {
459                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
460                     ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
461                      (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
462                         // (a='y') || (a='m') -> (a!='n')
463                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_no);
464                 }
465                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
466                     ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
467                      (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
468                         // (a='y') || (a='n') -> (a!='m')
469                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_mod);
470                 }
471                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
472                     ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
473                      (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
474                         // (a='m') || (a='n') -> (a!='y')
475                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_yes);
476                 }
477         }
478         if (sym1->type == S_BOOLEAN && sym1 == sym2) {
479                 if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
480                     (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
481                         return expr_alloc_symbol(&symbol_yes);
482         }
483
484         if (DEBUG_EXPR) {
485                 printf("optimize (");
486                 expr_fprint(e1, stdout);
487                 printf(") || (");
488                 expr_fprint(e2, stdout);
489                 printf(")?\n");
490         }
491         return NULL;
492 }
493
494 static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
495 {
496         struct expr *tmp;
497         struct symbol *sym1, *sym2;
498
499         if (expr_eq(e1, e2))
500                 return expr_copy(e1);
501         if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
502                 return NULL;
503         if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
504                 return NULL;
505         if (e1->type == E_NOT) {
506                 tmp = e1->left.expr;
507                 if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
508                         return NULL;
509                 sym1 = tmp->left.sym;
510         } else
511                 sym1 = e1->left.sym;
512         if (e2->type == E_NOT) {
513                 if (e2->left.expr->type != E_SYMBOL)
514                         return NULL;
515                 sym2 = e2->left.expr->left.sym;
516         } else
517                 sym2 = e2->left.sym;
518         if (sym1 != sym2)
519                 return NULL;
520         if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
521                 return NULL;
522
523         if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
524             (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
525                 // (a) && (a='y') -> (a='y')
526                 return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
527
528         if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
529             (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
530                 // (a) && (a!='n') -> (a)
531                 return expr_alloc_symbol(sym1);
532
533         if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
534             (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
535                 // (a) && (a!='m') -> (a='y')
536                 return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
537
538         if (sym1->type == S_TRISTATE) {
539                 if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
540                         // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
541                         sym2 = e1->right.sym;
542                         if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
543                                 return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
544                                                              : expr_alloc_symbol(&symbol_no);
545                 }
546                 if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
547                         // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
548                         sym2 = e2->right.sym;
549                         if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
550                                 return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
551                                                              : expr_alloc_symbol(&symbol_no);
552                 }
553                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
554                            ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
555                             (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
556                         // (a!='y') && (a!='n') -> (a='m')
557                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_mod);
558
559                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
560                            ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
561                             (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
562                         // (a!='y') && (a!='m') -> (a='n')
563                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_no);
564
565                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
566                            ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
567                             (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
568                         // (a!='m') && (a!='n') -> (a='m')
569                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
570
571                 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
572                     (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
573                     (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
574                     (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
575                         return NULL;
576         }
577
578         if (DEBUG_EXPR) {
579                 printf("optimize (");
580                 expr_fprint(e1, stdout);
581                 printf(") && (");
582                 expr_fprint(e2, stdout);
583                 printf(")?\n");
584         }
585         return NULL;
586 }
587
588 /*
589  * expr_eliminate_dups() helper.
590  *
591  * Walks the two expression trees given in 'ep1' and 'ep2'. Any node that does
592  * not have type 'type' (E_OR/E_AND) is considered a leaf, and is compared
593  * against all other leaves to look for simplifications.
594  */
595 static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2)
596 {
597 #define e1 (*ep1)
598 #define e2 (*ep2)
599         struct expr *tmp;
600
601         /* Recurse down to leaves */
602
603         if (e1->type == type) {
604                 expr_eliminate_dups1(type, &e1->left.expr, &e2);
605                 expr_eliminate_dups1(type, &e1->right.expr, &e2);
606                 return;
607         }
608         if (e2->type == type) {
609                 expr_eliminate_dups1(type, &e1, &e2->left.expr);
610                 expr_eliminate_dups1(type, &e1, &e2->right.expr);
611                 return;
612         }
613
614         /* e1 and e2 are leaves. Compare and process them. */
615
616         if (e1 == e2)
617                 return;
618
619         switch (e1->type) {
620         case E_OR: case E_AND:
621                 expr_eliminate_dups1(e1->type, &e1, &e1);
622         default:
623                 ;
624         }
625
626         switch (type) {
627         case E_OR:
628                 tmp = expr_join_or(e1, e2);
629                 if (tmp) {
630                         expr_free(e1); expr_free(e2);
631                         e1 = expr_alloc_symbol(&symbol_no);
632                         e2 = tmp;
633                         trans_count++;
634                 }
635                 break;
636         case E_AND:
637                 tmp = expr_join_and(e1, e2);
638                 if (tmp) {
639                         expr_free(e1); expr_free(e2);
640                         e1 = expr_alloc_symbol(&symbol_yes);
641                         e2 = tmp;
642                         trans_count++;
643                 }
644                 break;
645         default:
646                 ;
647         }
648 #undef e1
649 #undef e2
650 }
651
652 /*
653  * Rewrites 'e' in-place to remove ("join") duplicate and other redundant
654  * operands.
655  *
656  * Example simplifications:
657  *
658  *      A || B || A    ->  A || B
659  *      A && B && A=y  ->  A=y && B
660  *
661  * Returns the deduplicated expression.
662  */
663 struct expr *expr_eliminate_dups(struct expr *e)
664 {
665         int oldcount;
666         if (!e)
667                 return e;
668
669         oldcount = trans_count;
670         while (1) {
671                 trans_count = 0;
672                 switch (e->type) {
673                 case E_OR: case E_AND:
674                         expr_eliminate_dups1(e->type, &e, &e);
675                 default:
676                         ;
677                 }
678                 if (!trans_count)
679                         /* No simplifications done in this pass. We're done */
680                         break;
681                 e = expr_eliminate_yn(e);
682         }
683         trans_count = oldcount;
684         return e;
685 }
686
687 /*
688  * Performs various simplifications involving logical operators and
689  * comparisons.
690  *
691  * Allocates and returns a new expression.
692  */
693 struct expr *expr_transform(struct expr *e)
694 {
695         struct expr *tmp;
696
697         if (!e)
698                 return NULL;
699         switch (e->type) {
700         case E_EQUAL:
701         case E_GEQ:
702         case E_GTH:
703         case E_LEQ:
704         case E_LTH:
705         case E_UNEQUAL:
706         case E_SYMBOL:
707         case E_LIST:
708                 break;
709         default:
710                 e->left.expr = expr_transform(e->left.expr);
711                 e->right.expr = expr_transform(e->right.expr);
712         }
713
714         switch (e->type) {
715         case E_EQUAL:
716                 if (e->left.sym->type != S_BOOLEAN)
717                         break;
718                 if (e->right.sym == &symbol_no) {
719                         e->type = E_NOT;
720                         e->left.expr = expr_alloc_symbol(e->left.sym);
721                         e->right.sym = NULL;
722                         break;
723                 }
724                 if (e->right.sym == &symbol_mod) {
725                         printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
726                         e->type = E_SYMBOL;
727                         e->left.sym = &symbol_no;
728                         e->right.sym = NULL;
729                         break;
730                 }
731                 if (e->right.sym == &symbol_yes) {
732                         e->type = E_SYMBOL;
733                         e->right.sym = NULL;
734                         break;
735                 }
736                 break;
737         case E_UNEQUAL:
738                 if (e->left.sym->type != S_BOOLEAN)
739                         break;
740                 if (e->right.sym == &symbol_no) {
741                         e->type = E_SYMBOL;
742                         e->right.sym = NULL;
743                         break;
744                 }
745                 if (e->right.sym == &symbol_mod) {
746                         printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
747                         e->type = E_SYMBOL;
748                         e->left.sym = &symbol_yes;
749                         e->right.sym = NULL;
750                         break;
751                 }
752                 if (e->right.sym == &symbol_yes) {
753                         e->type = E_NOT;
754                         e->left.expr = expr_alloc_symbol(e->left.sym);
755                         e->right.sym = NULL;
756                         break;
757                 }
758                 break;
759         case E_NOT:
760                 switch (e->left.expr->type) {
761                 case E_NOT:
762                         // !!a -> a
763                         tmp = e->left.expr->left.expr;
764                         free(e->left.expr);
765                         free(e);
766                         e = tmp;
767                         e = expr_transform(e);
768                         break;
769                 case E_EQUAL:
770                 case E_UNEQUAL:
771                         // !a='x' -> a!='x'
772                         tmp = e->left.expr;
773                         free(e);
774                         e = tmp;
775                         e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL;
776                         break;
777                 case E_LEQ:
778                 case E_GEQ:
779                         // !a<='x' -> a>'x'
780                         tmp = e->left.expr;
781                         free(e);
782                         e = tmp;
783                         e->type = e->type == E_LEQ ? E_GTH : E_LTH;
784                         break;
785                 case E_LTH:
786                 case E_GTH:
787                         // !a<'x' -> a>='x'
788                         tmp = e->left.expr;
789                         free(e);
790                         e = tmp;
791                         e->type = e->type == E_LTH ? E_GEQ : E_LEQ;
792                         break;
793                 case E_OR:
794                         // !(a || b) -> !a && !b
795                         tmp = e->left.expr;
796                         e->type = E_AND;
797                         e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
798                         tmp->type = E_NOT;
799                         tmp->right.expr = NULL;
800                         e = expr_transform(e);
801                         break;
802                 case E_AND:
803                         // !(a && b) -> !a || !b
804                         tmp = e->left.expr;
805                         e->type = E_OR;
806                         e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
807                         tmp->type = E_NOT;
808                         tmp->right.expr = NULL;
809                         e = expr_transform(e);
810                         break;
811                 case E_SYMBOL:
812                         if (e->left.expr->left.sym == &symbol_yes) {
813                                 // !'y' -> 'n'
814                                 tmp = e->left.expr;
815                                 free(e);
816                                 e = tmp;
817                                 e->type = E_SYMBOL;
818                                 e->left.sym = &symbol_no;
819                                 break;
820                         }
821                         if (e->left.expr->left.sym == &symbol_mod) {
822                                 // !'m' -> 'm'
823                                 tmp = e->left.expr;
824                                 free(e);
825                                 e = tmp;
826                                 e->type = E_SYMBOL;
827                                 e->left.sym = &symbol_mod;
828                                 break;
829                         }
830                         if (e->left.expr->left.sym == &symbol_no) {
831                                 // !'n' -> 'y'
832                                 tmp = e->left.expr;
833                                 free(e);
834                                 e = tmp;
835                                 e->type = E_SYMBOL;
836                                 e->left.sym = &symbol_yes;
837                                 break;
838                         }
839                         break;
840                 default:
841                         ;
842                 }
843                 break;
844         default:
845                 ;
846         }
847         return e;
848 }
849
850 int expr_contains_symbol(struct expr *dep, struct symbol *sym)
851 {
852         if (!dep)
853                 return 0;
854
855         switch (dep->type) {
856         case E_AND:
857         case E_OR:
858                 return expr_contains_symbol(dep->left.expr, sym) ||
859                        expr_contains_symbol(dep->right.expr, sym);
860         case E_SYMBOL:
861                 return dep->left.sym == sym;
862         case E_EQUAL:
863         case E_GEQ:
864         case E_GTH:
865         case E_LEQ:
866         case E_LTH:
867         case E_UNEQUAL:
868                 return dep->left.sym == sym ||
869                        dep->right.sym == sym;
870         case E_NOT:
871                 return expr_contains_symbol(dep->left.expr, sym);
872         default:
873                 ;
874         }
875         return 0;
876 }
877
878 bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
879 {
880         if (!dep)
881                 return false;
882
883         switch (dep->type) {
884         case E_AND:
885                 return expr_depends_symbol(dep->left.expr, sym) ||
886                        expr_depends_symbol(dep->right.expr, sym);
887         case E_SYMBOL:
888                 return dep->left.sym == sym;
889         case E_EQUAL:
890                 if (dep->left.sym == sym) {
891                         if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
892                                 return true;
893                 }
894                 break;
895         case E_UNEQUAL:
896                 if (dep->left.sym == sym) {
897                         if (dep->right.sym == &symbol_no)
898                                 return true;
899                 }
900                 break;
901         default:
902                 ;
903         }
904         return false;
905 }
906
907 /*
908  * Inserts explicit comparisons of type 'type' to symbol 'sym' into the
909  * expression 'e'.
910  *
911  * Examples transformations for type == E_UNEQUAL, sym == &symbol_no:
912  *
913  *      A              ->  A!=n
914  *      !A             ->  A=n
915  *      A && B         ->  !(A=n || B=n)
916  *      A || B         ->  !(A=n && B=n)
917  *      A && (B || C)  ->  !(A=n || (B=n && C=n))
918  *
919  * Allocates and returns a new expression.
920  */
921 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
922 {
923         struct expr *e1, *e2;
924
925         if (!e) {
926                 e = expr_alloc_symbol(sym);
927                 if (type == E_UNEQUAL)
928                         e = expr_alloc_one(E_NOT, e);
929                 return e;
930         }
931         switch (e->type) {
932         case E_AND:
933                 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
934                 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
935                 if (sym == &symbol_yes)
936                         e = expr_alloc_two(E_AND, e1, e2);
937                 if (sym == &symbol_no)
938                         e = expr_alloc_two(E_OR, e1, e2);
939                 if (type == E_UNEQUAL)
940                         e = expr_alloc_one(E_NOT, e);
941                 return e;
942         case E_OR:
943                 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
944                 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
945                 if (sym == &symbol_yes)
946                         e = expr_alloc_two(E_OR, e1, e2);
947                 if (sym == &symbol_no)
948                         e = expr_alloc_two(E_AND, e1, e2);
949                 if (type == E_UNEQUAL)
950                         e = expr_alloc_one(E_NOT, e);
951                 return e;
952         case E_NOT:
953                 return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
954         case E_UNEQUAL:
955         case E_LTH:
956         case E_LEQ:
957         case E_GTH:
958         case E_GEQ:
959         case E_EQUAL:
960                 if (type == E_EQUAL) {
961                         if (sym == &symbol_yes)
962                                 return expr_copy(e);
963                         if (sym == &symbol_mod)
964                                 return expr_alloc_symbol(&symbol_no);
965                         if (sym == &symbol_no)
966                                 return expr_alloc_one(E_NOT, expr_copy(e));
967                 } else {
968                         if (sym == &symbol_yes)
969                                 return expr_alloc_one(E_NOT, expr_copy(e));
970                         if (sym == &symbol_mod)
971                                 return expr_alloc_symbol(&symbol_yes);
972                         if (sym == &symbol_no)
973                                 return expr_copy(e);
974                 }
975                 break;
976         case E_SYMBOL:
977                 return expr_alloc_comp(type, e->left.sym, sym);
978         case E_LIST:
979         case E_RANGE:
980         case E_NONE:
981                 /* panic */;
982         }
983         return NULL;
984 }
985
986 enum string_value_kind {
987         k_string,
988         k_signed,
989         k_unsigned,
990         k_invalid
991 };
992
993 union string_value {
994         unsigned long long u;
995         signed long long s;
996 };
997
998 static enum string_value_kind expr_parse_string(const char *str,
999                                                 enum symbol_type type,
1000                                                 union string_value *val)
1001 {
1002         char *tail;
1003         enum string_value_kind kind;
1004
1005         errno = 0;
1006         switch (type) {
1007         case S_BOOLEAN:
1008         case S_TRISTATE:
1009                 val->s = !strcmp(str, "n") ? 0 :
1010                          !strcmp(str, "m") ? 1 :
1011                          !strcmp(str, "y") ? 2 : -1;
1012                 return k_signed;
1013         case S_INT:
1014                 val->s = strtoll(str, &tail, 10);
1015                 kind = k_signed;
1016                 break;
1017         case S_HEX:
1018                 val->u = strtoull(str, &tail, 16);
1019                 kind = k_unsigned;
1020                 break;
1021         case S_STRING:
1022         case S_UNKNOWN:
1023                 val->s = strtoll(str, &tail, 0);
1024                 kind = k_signed;
1025                 break;
1026         default:
1027                 return k_invalid;
1028         }
1029         return !errno && !*tail && tail > str && isxdigit(tail[-1])
1030                ? kind : k_string;
1031 }
1032
1033 tristate expr_calc_value(struct expr *e)
1034 {
1035         tristate val1, val2;
1036         const char *str1, *str2;
1037         enum string_value_kind k1 = k_string, k2 = k_string;
1038         union string_value lval = {}, rval = {};
1039         int res;
1040
1041         if (!e)
1042                 return yes;
1043
1044         switch (e->type) {
1045         case E_SYMBOL:
1046                 sym_calc_value(e->left.sym);
1047                 return e->left.sym->curr.tri;
1048         case E_AND:
1049                 val1 = expr_calc_value(e->left.expr);
1050                 val2 = expr_calc_value(e->right.expr);
1051                 return EXPR_AND(val1, val2);
1052         case E_OR:
1053                 val1 = expr_calc_value(e->left.expr);
1054                 val2 = expr_calc_value(e->right.expr);
1055                 return EXPR_OR(val1, val2);
1056         case E_NOT:
1057                 val1 = expr_calc_value(e->left.expr);
1058                 return EXPR_NOT(val1);
1059         case E_EQUAL:
1060         case E_GEQ:
1061         case E_GTH:
1062         case E_LEQ:
1063         case E_LTH:
1064         case E_UNEQUAL:
1065                 break;
1066         default:
1067                 printf("expr_calc_value: %d?\n", e->type);
1068                 return no;
1069         }
1070
1071         sym_calc_value(e->left.sym);
1072         sym_calc_value(e->right.sym);
1073         str1 = sym_get_string_value(e->left.sym);
1074         str2 = sym_get_string_value(e->right.sym);
1075
1076         if (e->left.sym->type != S_STRING || e->right.sym->type != S_STRING) {
1077                 k1 = expr_parse_string(str1, e->left.sym->type, &lval);
1078                 k2 = expr_parse_string(str2, e->right.sym->type, &rval);
1079         }
1080
1081         if (k1 == k_string || k2 == k_string)
1082                 res = strcmp(str1, str2);
1083         else if (k1 == k_invalid || k2 == k_invalid) {
1084                 if (e->type != E_EQUAL && e->type != E_UNEQUAL) {
1085                         printf("Cannot compare \"%s\" and \"%s\"\n", str1, str2);
1086                         return no;
1087                 }
1088                 res = strcmp(str1, str2);
1089         } else if (k1 == k_unsigned || k2 == k_unsigned)
1090                 res = (lval.u > rval.u) - (lval.u < rval.u);
1091         else /* if (k1 == k_signed && k2 == k_signed) */
1092                 res = (lval.s > rval.s) - (lval.s < rval.s);
1093
1094         switch(e->type) {
1095         case E_EQUAL:
1096                 return res ? no : yes;
1097         case E_GEQ:
1098                 return res >= 0 ? yes : no;
1099         case E_GTH:
1100                 return res > 0 ? yes : no;
1101         case E_LEQ:
1102                 return res <= 0 ? yes : no;
1103         case E_LTH:
1104                 return res < 0 ? yes : no;
1105         case E_UNEQUAL:
1106                 return res ? yes : no;
1107         default:
1108                 printf("expr_calc_value: relation %d?\n", e->type);
1109                 return no;
1110         }
1111 }
1112
1113 static int expr_compare_type(enum expr_type t1, enum expr_type t2)
1114 {
1115         if (t1 == t2)
1116                 return 0;
1117         switch (t1) {
1118         case E_LEQ:
1119         case E_LTH:
1120         case E_GEQ:
1121         case E_GTH:
1122                 if (t2 == E_EQUAL || t2 == E_UNEQUAL)
1123                         return 1;
1124         case E_EQUAL:
1125         case E_UNEQUAL:
1126                 if (t2 == E_NOT)
1127                         return 1;
1128         case E_NOT:
1129                 if (t2 == E_AND)
1130                         return 1;
1131         case E_AND:
1132                 if (t2 == E_OR)
1133                         return 1;
1134         case E_OR:
1135                 if (t2 == E_LIST)
1136                         return 1;
1137         case E_LIST:
1138                 if (t2 == 0)
1139                         return 1;
1140         default:
1141                 return -1;
1142         }
1143         printf("[%dgt%d?]", t1, t2);
1144         return 0;
1145 }
1146
1147 void expr_print(struct expr *e,
1148                 void (*fn)(void *, struct symbol *, const char *),
1149                 void *data, int prevtoken)
1150 {
1151         if (!e) {
1152                 fn(data, NULL, "y");
1153                 return;
1154         }
1155
1156         if (expr_compare_type(prevtoken, e->type) > 0)
1157                 fn(data, NULL, "(");
1158         switch (e->type) {
1159         case E_SYMBOL:
1160                 if (e->left.sym->name)
1161                         fn(data, e->left.sym, e->left.sym->name);
1162                 else
1163                         fn(data, NULL, "<choice>");
1164                 break;
1165         case E_NOT:
1166                 fn(data, NULL, "!");
1167                 expr_print(e->left.expr, fn, data, E_NOT);
1168                 break;
1169         case E_EQUAL:
1170                 if (e->left.sym->name)
1171                         fn(data, e->left.sym, e->left.sym->name);
1172                 else
1173                         fn(data, NULL, "<choice>");
1174                 fn(data, NULL, "=");
1175                 fn(data, e->right.sym, e->right.sym->name);
1176                 break;
1177         case E_LEQ:
1178         case E_LTH:
1179                 if (e->left.sym->name)
1180                         fn(data, e->left.sym, e->left.sym->name);
1181                 else
1182                         fn(data, NULL, "<choice>");
1183                 fn(data, NULL, e->type == E_LEQ ? "<=" : "<");
1184                 fn(data, e->right.sym, e->right.sym->name);
1185                 break;
1186         case E_GEQ:
1187         case E_GTH:
1188                 if (e->left.sym->name)
1189                         fn(data, e->left.sym, e->left.sym->name);
1190                 else
1191                         fn(data, NULL, "<choice>");
1192                 fn(data, NULL, e->type == E_GEQ ? ">=" : ">");
1193                 fn(data, e->right.sym, e->right.sym->name);
1194                 break;
1195         case E_UNEQUAL:
1196                 if (e->left.sym->name)
1197                         fn(data, e->left.sym, e->left.sym->name);
1198                 else
1199                         fn(data, NULL, "<choice>");
1200                 fn(data, NULL, "!=");
1201                 fn(data, e->right.sym, e->right.sym->name);
1202                 break;
1203         case E_OR:
1204                 expr_print(e->left.expr, fn, data, E_OR);
1205                 fn(data, NULL, " || ");
1206                 expr_print(e->right.expr, fn, data, E_OR);
1207                 break;
1208         case E_AND:
1209                 expr_print(e->left.expr, fn, data, E_AND);
1210                 fn(data, NULL, " && ");
1211                 expr_print(e->right.expr, fn, data, E_AND);
1212                 break;
1213         case E_LIST:
1214                 fn(data, e->right.sym, e->right.sym->name);
1215                 if (e->left.expr) {
1216                         fn(data, NULL, " ^ ");
1217                         expr_print(e->left.expr, fn, data, E_LIST);
1218                 }
1219                 break;
1220         case E_RANGE:
1221                 fn(data, NULL, "[");
1222                 fn(data, e->left.sym, e->left.sym->name);
1223                 fn(data, NULL, " ");
1224                 fn(data, e->right.sym, e->right.sym->name);
1225                 fn(data, NULL, "]");
1226                 break;
1227         default:
1228           {
1229                 char buf[32];
1230                 sprintf(buf, "<unknown type %d>", e->type);
1231                 fn(data, NULL, buf);
1232                 break;
1233           }
1234         }
1235         if (expr_compare_type(prevtoken, e->type) > 0)
1236                 fn(data, NULL, ")");
1237 }
1238
1239 static void expr_print_file_helper(void *data, struct symbol *sym, const char *str)
1240 {
1241         xfwrite(str, strlen(str), 1, data);
1242 }
1243
1244 void expr_fprint(struct expr *e, FILE *out)
1245 {
1246         expr_print(e, expr_print_file_helper, out, E_NONE);
1247 }
1248
1249 static void expr_print_gstr_helper(void *data, struct symbol *sym, const char *str)
1250 {
1251         struct gstr *gs = (struct gstr*)data;
1252         const char *sym_str = NULL;
1253
1254         if (sym)
1255                 sym_str = sym_get_string_value(sym);
1256
1257         if (gs->max_width) {
1258                 unsigned extra_length = strlen(str);
1259                 const char *last_cr = strrchr(gs->s, '\n');
1260                 unsigned last_line_length;
1261
1262                 if (sym_str)
1263                         extra_length += 4 + strlen(sym_str);
1264
1265                 if (!last_cr)
1266                         last_cr = gs->s;
1267
1268                 last_line_length = strlen(gs->s) - (last_cr - gs->s);
1269
1270                 if ((last_line_length + extra_length) > gs->max_width)
1271                         str_append(gs, "\\\n");
1272         }
1273
1274         str_append(gs, str);
1275         if (sym && sym->type != S_UNKNOWN)
1276                 str_printf(gs, " [=%s]", sym_str);
1277 }
1278
1279 void expr_gstr_print(struct expr *e, struct gstr *gs)
1280 {
1281         expr_print(e, expr_print_gstr_helper, gs, E_NONE);
1282 }
1283
1284 /*
1285  * Transform the top level "||" tokens into newlines and prepend each
1286  * line with a minus. This makes expressions much easier to read.
1287  * Suitable for reverse dependency expressions.
1288  */
1289 static void expr_print_revdep(struct expr *e,
1290                               void (*fn)(void *, struct symbol *, const char *),
1291                               void *data, tristate pr_type, const char **title)
1292 {
1293         if (e->type == E_OR) {
1294                 expr_print_revdep(e->left.expr, fn, data, pr_type, title);
1295                 expr_print_revdep(e->right.expr, fn, data, pr_type, title);
1296         } else if (expr_calc_value(e) == pr_type) {
1297                 if (*title) {
1298                         fn(data, NULL, *title);
1299                         *title = NULL;
1300                 }
1301
1302                 fn(data, NULL, "  - ");
1303                 expr_print(e, fn, data, E_NONE);
1304                 fn(data, NULL, "\n");
1305         }
1306 }
1307
1308 void expr_gstr_print_revdep(struct expr *e, struct gstr *gs,
1309                             tristate pr_type, const char *title)
1310 {
1311         expr_print_revdep(e, expr_print_gstr_helper, gs, pr_type, &title);
1312 }