kconfig: fix relational operators for bool and tristate symbols
[muen/linux.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                 printf("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                 return;
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                 printf("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 static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
142 {
143         if (e1->type == type) {
144                 __expr_eliminate_eq(type, &e1->left.expr, &e2);
145                 __expr_eliminate_eq(type, &e1->right.expr, &e2);
146                 return;
147         }
148         if (e2->type == type) {
149                 __expr_eliminate_eq(type, &e1, &e2->left.expr);
150                 __expr_eliminate_eq(type, &e1, &e2->right.expr);
151                 return;
152         }
153         if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
154             e1->left.sym == e2->left.sym &&
155             (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
156                 return;
157         if (!expr_eq(e1, e2))
158                 return;
159         trans_count++;
160         expr_free(e1); expr_free(e2);
161         switch (type) {
162         case E_OR:
163                 e1 = expr_alloc_symbol(&symbol_no);
164                 e2 = expr_alloc_symbol(&symbol_no);
165                 break;
166         case E_AND:
167                 e1 = expr_alloc_symbol(&symbol_yes);
168                 e2 = expr_alloc_symbol(&symbol_yes);
169                 break;
170         default:
171                 ;
172         }
173 }
174
175 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
176 {
177         if (!e1 || !e2)
178                 return;
179         switch (e1->type) {
180         case E_OR:
181         case E_AND:
182                 __expr_eliminate_eq(e1->type, ep1, ep2);
183         default:
184                 ;
185         }
186         if (e1->type != e2->type) switch (e2->type) {
187         case E_OR:
188         case E_AND:
189                 __expr_eliminate_eq(e2->type, ep1, ep2);
190         default:
191                 ;
192         }
193         e1 = expr_eliminate_yn(e1);
194         e2 = expr_eliminate_yn(e2);
195 }
196
197 #undef e1
198 #undef e2
199
200 static int expr_eq(struct expr *e1, struct expr *e2)
201 {
202         int res, old_count;
203
204         if (e1->type != e2->type)
205                 return 0;
206         switch (e1->type) {
207         case E_EQUAL:
208         case E_GEQ:
209         case E_GTH:
210         case E_LEQ:
211         case E_LTH:
212         case E_UNEQUAL:
213                 return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
214         case E_SYMBOL:
215                 return e1->left.sym == e2->left.sym;
216         case E_NOT:
217                 return expr_eq(e1->left.expr, e2->left.expr);
218         case E_AND:
219         case E_OR:
220                 e1 = expr_copy(e1);
221                 e2 = expr_copy(e2);
222                 old_count = trans_count;
223                 expr_eliminate_eq(&e1, &e2);
224                 res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
225                        e1->left.sym == e2->left.sym);
226                 expr_free(e1);
227                 expr_free(e2);
228                 trans_count = old_count;
229                 return res;
230         case E_LIST:
231         case E_RANGE:
232         case E_NONE:
233                 /* panic */;
234         }
235
236         if (DEBUG_EXPR) {
237                 expr_fprint(e1, stdout);
238                 printf(" = ");
239                 expr_fprint(e2, stdout);
240                 printf(" ?\n");
241         }
242
243         return 0;
244 }
245
246 static struct expr *expr_eliminate_yn(struct expr *e)
247 {
248         struct expr *tmp;
249
250         if (e) switch (e->type) {
251         case E_AND:
252                 e->left.expr = expr_eliminate_yn(e->left.expr);
253                 e->right.expr = expr_eliminate_yn(e->right.expr);
254                 if (e->left.expr->type == E_SYMBOL) {
255                         if (e->left.expr->left.sym == &symbol_no) {
256                                 expr_free(e->left.expr);
257                                 expr_free(e->right.expr);
258                                 e->type = E_SYMBOL;
259                                 e->left.sym = &symbol_no;
260                                 e->right.expr = NULL;
261                                 return e;
262                         } else if (e->left.expr->left.sym == &symbol_yes) {
263                                 free(e->left.expr);
264                                 tmp = e->right.expr;
265                                 *e = *(e->right.expr);
266                                 free(tmp);
267                                 return e;
268                         }
269                 }
270                 if (e->right.expr->type == E_SYMBOL) {
271                         if (e->right.expr->left.sym == &symbol_no) {
272                                 expr_free(e->left.expr);
273                                 expr_free(e->right.expr);
274                                 e->type = E_SYMBOL;
275                                 e->left.sym = &symbol_no;
276                                 e->right.expr = NULL;
277                                 return e;
278                         } else if (e->right.expr->left.sym == &symbol_yes) {
279                                 free(e->right.expr);
280                                 tmp = e->left.expr;
281                                 *e = *(e->left.expr);
282                                 free(tmp);
283                                 return e;
284                         }
285                 }
286                 break;
287         case E_OR:
288                 e->left.expr = expr_eliminate_yn(e->left.expr);
289                 e->right.expr = expr_eliminate_yn(e->right.expr);
290                 if (e->left.expr->type == E_SYMBOL) {
291                         if (e->left.expr->left.sym == &symbol_no) {
292                                 free(e->left.expr);
293                                 tmp = e->right.expr;
294                                 *e = *(e->right.expr);
295                                 free(tmp);
296                                 return e;
297                         } else if (e->left.expr->left.sym == &symbol_yes) {
298                                 expr_free(e->left.expr);
299                                 expr_free(e->right.expr);
300                                 e->type = E_SYMBOL;
301                                 e->left.sym = &symbol_yes;
302                                 e->right.expr = NULL;
303                                 return e;
304                         }
305                 }
306                 if (e->right.expr->type == E_SYMBOL) {
307                         if (e->right.expr->left.sym == &symbol_no) {
308                                 free(e->right.expr);
309                                 tmp = e->left.expr;
310                                 *e = *(e->left.expr);
311                                 free(tmp);
312                                 return e;
313                         } else if (e->right.expr->left.sym == &symbol_yes) {
314                                 expr_free(e->left.expr);
315                                 expr_free(e->right.expr);
316                                 e->type = E_SYMBOL;
317                                 e->left.sym = &symbol_yes;
318                                 e->right.expr = NULL;
319                                 return e;
320                         }
321                 }
322                 break;
323         default:
324                 ;
325         }
326         return e;
327 }
328
329 /*
330  * bool FOO!=n => FOO
331  */
332 struct expr *expr_trans_bool(struct expr *e)
333 {
334         if (!e)
335                 return NULL;
336         switch (e->type) {
337         case E_AND:
338         case E_OR:
339         case E_NOT:
340                 e->left.expr = expr_trans_bool(e->left.expr);
341                 e->right.expr = expr_trans_bool(e->right.expr);
342                 break;
343         case E_UNEQUAL:
344                 // FOO!=n -> FOO
345                 if (e->left.sym->type == S_TRISTATE) {
346                         if (e->right.sym == &symbol_no) {
347                                 e->type = E_SYMBOL;
348                                 e->right.sym = NULL;
349                         }
350                 }
351                 break;
352         default:
353                 ;
354         }
355         return e;
356 }
357
358 /*
359  * e1 || e2 -> ?
360  */
361 static struct expr *expr_join_or(struct expr *e1, struct expr *e2)
362 {
363         struct expr *tmp;
364         struct symbol *sym1, *sym2;
365
366         if (expr_eq(e1, e2))
367                 return expr_copy(e1);
368         if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
369                 return NULL;
370         if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
371                 return NULL;
372         if (e1->type == E_NOT) {
373                 tmp = e1->left.expr;
374                 if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
375                         return NULL;
376                 sym1 = tmp->left.sym;
377         } else
378                 sym1 = e1->left.sym;
379         if (e2->type == E_NOT) {
380                 if (e2->left.expr->type != E_SYMBOL)
381                         return NULL;
382                 sym2 = e2->left.expr->left.sym;
383         } else
384                 sym2 = e2->left.sym;
385         if (sym1 != sym2)
386                 return NULL;
387         if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
388                 return NULL;
389         if (sym1->type == S_TRISTATE) {
390                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
391                     ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
392                      (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
393                         // (a='y') || (a='m') -> (a!='n')
394                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_no);
395                 }
396                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
397                     ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
398                      (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
399                         // (a='y') || (a='n') -> (a!='m')
400                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_mod);
401                 }
402                 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
403                     ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
404                      (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
405                         // (a='m') || (a='n') -> (a!='y')
406                         return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_yes);
407                 }
408         }
409         if (sym1->type == S_BOOLEAN && sym1 == sym2) {
410                 if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
411                     (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
412                         return expr_alloc_symbol(&symbol_yes);
413         }
414
415         if (DEBUG_EXPR) {
416                 printf("optimize (");
417                 expr_fprint(e1, stdout);
418                 printf(") || (");
419                 expr_fprint(e2, stdout);
420                 printf(")?\n");
421         }
422         return NULL;
423 }
424
425 static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
426 {
427         struct expr *tmp;
428         struct symbol *sym1, *sym2;
429
430         if (expr_eq(e1, e2))
431                 return expr_copy(e1);
432         if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
433                 return NULL;
434         if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
435                 return NULL;
436         if (e1->type == E_NOT) {
437                 tmp = e1->left.expr;
438                 if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
439                         return NULL;
440                 sym1 = tmp->left.sym;
441         } else
442                 sym1 = e1->left.sym;
443         if (e2->type == E_NOT) {
444                 if (e2->left.expr->type != E_SYMBOL)
445                         return NULL;
446                 sym2 = e2->left.expr->left.sym;
447         } else
448                 sym2 = e2->left.sym;
449         if (sym1 != sym2)
450                 return NULL;
451         if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
452                 return NULL;
453
454         if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
455             (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
456                 // (a) && (a='y') -> (a='y')
457                 return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
458
459         if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
460             (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
461                 // (a) && (a!='n') -> (a)
462                 return expr_alloc_symbol(sym1);
463
464         if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
465             (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
466                 // (a) && (a!='m') -> (a='y')
467                 return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
468
469         if (sym1->type == S_TRISTATE) {
470                 if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
471                         // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
472                         sym2 = e1->right.sym;
473                         if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
474                                 return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
475                                                              : expr_alloc_symbol(&symbol_no);
476                 }
477                 if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
478                         // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
479                         sym2 = e2->right.sym;
480                         if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
481                                 return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
482                                                              : expr_alloc_symbol(&symbol_no);
483                 }
484                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
485                            ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
486                             (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
487                         // (a!='y') && (a!='n') -> (a='m')
488                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_mod);
489
490                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
491                            ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
492                             (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
493                         // (a!='y') && (a!='m') -> (a='n')
494                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_no);
495
496                 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
497                            ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
498                             (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
499                         // (a!='m') && (a!='n') -> (a='m')
500                         return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
501
502                 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
503                     (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
504                     (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
505                     (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
506                         return NULL;
507         }
508
509         if (DEBUG_EXPR) {
510                 printf("optimize (");
511                 expr_fprint(e1, stdout);
512                 printf(") && (");
513                 expr_fprint(e2, stdout);
514                 printf(")?\n");
515         }
516         return NULL;
517 }
518
519 static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2)
520 {
521 #define e1 (*ep1)
522 #define e2 (*ep2)
523         struct expr *tmp;
524
525         if (e1->type == type) {
526                 expr_eliminate_dups1(type, &e1->left.expr, &e2);
527                 expr_eliminate_dups1(type, &e1->right.expr, &e2);
528                 return;
529         }
530         if (e2->type == type) {
531                 expr_eliminate_dups1(type, &e1, &e2->left.expr);
532                 expr_eliminate_dups1(type, &e1, &e2->right.expr);
533                 return;
534         }
535         if (e1 == e2)
536                 return;
537
538         switch (e1->type) {
539         case E_OR: case E_AND:
540                 expr_eliminate_dups1(e1->type, &e1, &e1);
541         default:
542                 ;
543         }
544
545         switch (type) {
546         case E_OR:
547                 tmp = expr_join_or(e1, e2);
548                 if (tmp) {
549                         expr_free(e1); expr_free(e2);
550                         e1 = expr_alloc_symbol(&symbol_no);
551                         e2 = tmp;
552                         trans_count++;
553                 }
554                 break;
555         case E_AND:
556                 tmp = expr_join_and(e1, e2);
557                 if (tmp) {
558                         expr_free(e1); expr_free(e2);
559                         e1 = expr_alloc_symbol(&symbol_yes);
560                         e2 = tmp;
561                         trans_count++;
562                 }
563                 break;
564         default:
565                 ;
566         }
567 #undef e1
568 #undef e2
569 }
570
571 struct expr *expr_eliminate_dups(struct expr *e)
572 {
573         int oldcount;
574         if (!e)
575                 return e;
576
577         oldcount = trans_count;
578         while (1) {
579                 trans_count = 0;
580                 switch (e->type) {
581                 case E_OR: case E_AND:
582                         expr_eliminate_dups1(e->type, &e, &e);
583                 default:
584                         ;
585                 }
586                 if (!trans_count)
587                         break;
588                 e = expr_eliminate_yn(e);
589         }
590         trans_count = oldcount;
591         return e;
592 }
593
594 struct expr *expr_transform(struct expr *e)
595 {
596         struct expr *tmp;
597
598         if (!e)
599                 return NULL;
600         switch (e->type) {
601         case E_EQUAL:
602         case E_GEQ:
603         case E_GTH:
604         case E_LEQ:
605         case E_LTH:
606         case E_UNEQUAL:
607         case E_SYMBOL:
608         case E_LIST:
609                 break;
610         default:
611                 e->left.expr = expr_transform(e->left.expr);
612                 e->right.expr = expr_transform(e->right.expr);
613         }
614
615         switch (e->type) {
616         case E_EQUAL:
617                 if (e->left.sym->type != S_BOOLEAN)
618                         break;
619                 if (e->right.sym == &symbol_no) {
620                         e->type = E_NOT;
621                         e->left.expr = expr_alloc_symbol(e->left.sym);
622                         e->right.sym = NULL;
623                         break;
624                 }
625                 if (e->right.sym == &symbol_mod) {
626                         printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
627                         e->type = E_SYMBOL;
628                         e->left.sym = &symbol_no;
629                         e->right.sym = NULL;
630                         break;
631                 }
632                 if (e->right.sym == &symbol_yes) {
633                         e->type = E_SYMBOL;
634                         e->right.sym = NULL;
635                         break;
636                 }
637                 break;
638         case E_UNEQUAL:
639                 if (e->left.sym->type != S_BOOLEAN)
640                         break;
641                 if (e->right.sym == &symbol_no) {
642                         e->type = E_SYMBOL;
643                         e->right.sym = NULL;
644                         break;
645                 }
646                 if (e->right.sym == &symbol_mod) {
647                         printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
648                         e->type = E_SYMBOL;
649                         e->left.sym = &symbol_yes;
650                         e->right.sym = NULL;
651                         break;
652                 }
653                 if (e->right.sym == &symbol_yes) {
654                         e->type = E_NOT;
655                         e->left.expr = expr_alloc_symbol(e->left.sym);
656                         e->right.sym = NULL;
657                         break;
658                 }
659                 break;
660         case E_NOT:
661                 switch (e->left.expr->type) {
662                 case E_NOT:
663                         // !!a -> a
664                         tmp = e->left.expr->left.expr;
665                         free(e->left.expr);
666                         free(e);
667                         e = tmp;
668                         e = expr_transform(e);
669                         break;
670                 case E_EQUAL:
671                 case E_UNEQUAL:
672                         // !a='x' -> a!='x'
673                         tmp = e->left.expr;
674                         free(e);
675                         e = tmp;
676                         e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL;
677                         break;
678                 case E_LEQ:
679                 case E_GEQ:
680                         // !a<='x' -> a>'x'
681                         tmp = e->left.expr;
682                         free(e);
683                         e = tmp;
684                         e->type = e->type == E_LEQ ? E_GTH : E_LTH;
685                         break;
686                 case E_LTH:
687                 case E_GTH:
688                         // !a<'x' -> a>='x'
689                         tmp = e->left.expr;
690                         free(e);
691                         e = tmp;
692                         e->type = e->type == E_LTH ? E_GEQ : E_LEQ;
693                         break;
694                 case E_OR:
695                         // !(a || b) -> !a && !b
696                         tmp = e->left.expr;
697                         e->type = E_AND;
698                         e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
699                         tmp->type = E_NOT;
700                         tmp->right.expr = NULL;
701                         e = expr_transform(e);
702                         break;
703                 case E_AND:
704                         // !(a && b) -> !a || !b
705                         tmp = e->left.expr;
706                         e->type = E_OR;
707                         e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
708                         tmp->type = E_NOT;
709                         tmp->right.expr = NULL;
710                         e = expr_transform(e);
711                         break;
712                 case E_SYMBOL:
713                         if (e->left.expr->left.sym == &symbol_yes) {
714                                 // !'y' -> 'n'
715                                 tmp = e->left.expr;
716                                 free(e);
717                                 e = tmp;
718                                 e->type = E_SYMBOL;
719                                 e->left.sym = &symbol_no;
720                                 break;
721                         }
722                         if (e->left.expr->left.sym == &symbol_mod) {
723                                 // !'m' -> 'm'
724                                 tmp = e->left.expr;
725                                 free(e);
726                                 e = tmp;
727                                 e->type = E_SYMBOL;
728                                 e->left.sym = &symbol_mod;
729                                 break;
730                         }
731                         if (e->left.expr->left.sym == &symbol_no) {
732                                 // !'n' -> 'y'
733                                 tmp = e->left.expr;
734                                 free(e);
735                                 e = tmp;
736                                 e->type = E_SYMBOL;
737                                 e->left.sym = &symbol_yes;
738                                 break;
739                         }
740                         break;
741                 default:
742                         ;
743                 }
744                 break;
745         default:
746                 ;
747         }
748         return e;
749 }
750
751 int expr_contains_symbol(struct expr *dep, struct symbol *sym)
752 {
753         if (!dep)
754                 return 0;
755
756         switch (dep->type) {
757         case E_AND:
758         case E_OR:
759                 return expr_contains_symbol(dep->left.expr, sym) ||
760                        expr_contains_symbol(dep->right.expr, sym);
761         case E_SYMBOL:
762                 return dep->left.sym == sym;
763         case E_EQUAL:
764         case E_GEQ:
765         case E_GTH:
766         case E_LEQ:
767         case E_LTH:
768         case E_UNEQUAL:
769                 return dep->left.sym == sym ||
770                        dep->right.sym == sym;
771         case E_NOT:
772                 return expr_contains_symbol(dep->left.expr, sym);
773         default:
774                 ;
775         }
776         return 0;
777 }
778
779 bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
780 {
781         if (!dep)
782                 return false;
783
784         switch (dep->type) {
785         case E_AND:
786                 return expr_depends_symbol(dep->left.expr, sym) ||
787                        expr_depends_symbol(dep->right.expr, sym);
788         case E_SYMBOL:
789                 return dep->left.sym == sym;
790         case E_EQUAL:
791                 if (dep->left.sym == sym) {
792                         if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
793                                 return true;
794                 }
795                 break;
796         case E_UNEQUAL:
797                 if (dep->left.sym == sym) {
798                         if (dep->right.sym == &symbol_no)
799                                 return true;
800                 }
801                 break;
802         default:
803                 ;
804         }
805         return false;
806 }
807
808 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
809 {
810         struct expr *e1, *e2;
811
812         if (!e) {
813                 e = expr_alloc_symbol(sym);
814                 if (type == E_UNEQUAL)
815                         e = expr_alloc_one(E_NOT, e);
816                 return e;
817         }
818         switch (e->type) {
819         case E_AND:
820                 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
821                 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
822                 if (sym == &symbol_yes)
823                         e = expr_alloc_two(E_AND, e1, e2);
824                 if (sym == &symbol_no)
825                         e = expr_alloc_two(E_OR, e1, e2);
826                 if (type == E_UNEQUAL)
827                         e = expr_alloc_one(E_NOT, e);
828                 return e;
829         case E_OR:
830                 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
831                 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
832                 if (sym == &symbol_yes)
833                         e = expr_alloc_two(E_OR, e1, e2);
834                 if (sym == &symbol_no)
835                         e = expr_alloc_two(E_AND, e1, e2);
836                 if (type == E_UNEQUAL)
837                         e = expr_alloc_one(E_NOT, e);
838                 return e;
839         case E_NOT:
840                 return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
841         case E_UNEQUAL:
842         case E_LTH:
843         case E_LEQ:
844         case E_GTH:
845         case E_GEQ:
846         case E_EQUAL:
847                 if (type == E_EQUAL) {
848                         if (sym == &symbol_yes)
849                                 return expr_copy(e);
850                         if (sym == &symbol_mod)
851                                 return expr_alloc_symbol(&symbol_no);
852                         if (sym == &symbol_no)
853                                 return expr_alloc_one(E_NOT, expr_copy(e));
854                 } else {
855                         if (sym == &symbol_yes)
856                                 return expr_alloc_one(E_NOT, expr_copy(e));
857                         if (sym == &symbol_mod)
858                                 return expr_alloc_symbol(&symbol_yes);
859                         if (sym == &symbol_no)
860                                 return expr_copy(e);
861                 }
862                 break;
863         case E_SYMBOL:
864                 return expr_alloc_comp(type, e->left.sym, sym);
865         case E_LIST:
866         case E_RANGE:
867         case E_NONE:
868                 /* panic */;
869         }
870         return NULL;
871 }
872
873 enum string_value_kind {
874         k_string,
875         k_signed,
876         k_unsigned,
877         k_invalid
878 };
879
880 union string_value {
881         unsigned long long u;
882         signed long long s;
883 };
884
885 static enum string_value_kind expr_parse_string(const char *str,
886                                                 enum symbol_type type,
887                                                 union string_value *val)
888 {
889         char *tail;
890         enum string_value_kind kind;
891
892         errno = 0;
893         switch (type) {
894         case S_BOOLEAN:
895         case S_TRISTATE:
896                 val->s = !strcmp(str, "n") ? 0 :
897                          !strcmp(str, "m") ? 1 :
898                          !strcmp(str, "y") ? 2 : -1;
899                 return k_signed;
900         case S_INT:
901                 val->s = strtoll(str, &tail, 10);
902                 kind = k_signed;
903                 break;
904         case S_HEX:
905                 val->u = strtoull(str, &tail, 16);
906                 kind = k_unsigned;
907                 break;
908         case S_STRING:
909         case S_UNKNOWN:
910                 val->s = strtoll(str, &tail, 0);
911                 kind = k_signed;
912                 break;
913         default:
914                 return k_invalid;
915         }
916         return !errno && !*tail && tail > str && isxdigit(tail[-1])
917                ? kind : k_string;
918 }
919
920 tristate expr_calc_value(struct expr *e)
921 {
922         tristate val1, val2;
923         const char *str1, *str2;
924         enum string_value_kind k1 = k_string, k2 = k_string;
925         union string_value lval = {}, rval = {};
926         int res;
927
928         if (!e)
929                 return yes;
930
931         switch (e->type) {
932         case E_SYMBOL:
933                 sym_calc_value(e->left.sym);
934                 return e->left.sym->curr.tri;
935         case E_AND:
936                 val1 = expr_calc_value(e->left.expr);
937                 val2 = expr_calc_value(e->right.expr);
938                 return EXPR_AND(val1, val2);
939         case E_OR:
940                 val1 = expr_calc_value(e->left.expr);
941                 val2 = expr_calc_value(e->right.expr);
942                 return EXPR_OR(val1, val2);
943         case E_NOT:
944                 val1 = expr_calc_value(e->left.expr);
945                 return EXPR_NOT(val1);
946         case E_EQUAL:
947         case E_GEQ:
948         case E_GTH:
949         case E_LEQ:
950         case E_LTH:
951         case E_UNEQUAL:
952                 break;
953         default:
954                 printf("expr_calc_value: %d?\n", e->type);
955                 return no;
956         }
957
958         sym_calc_value(e->left.sym);
959         sym_calc_value(e->right.sym);
960         str1 = sym_get_string_value(e->left.sym);
961         str2 = sym_get_string_value(e->right.sym);
962
963         if (e->left.sym->type != S_STRING || e->right.sym->type != S_STRING) {
964                 k1 = expr_parse_string(str1, e->left.sym->type, &lval);
965                 k2 = expr_parse_string(str2, e->right.sym->type, &rval);
966         }
967
968         if (k1 == k_string || k2 == k_string)
969                 res = strcmp(str1, str2);
970         else if (k1 == k_invalid || k2 == k_invalid) {
971                 if (e->type != E_EQUAL && e->type != E_UNEQUAL) {
972                         printf("Cannot compare \"%s\" and \"%s\"\n", str1, str2);
973                         return no;
974                 }
975                 res = strcmp(str1, str2);
976         } else if (k1 == k_unsigned || k2 == k_unsigned)
977                 res = (lval.u > rval.u) - (lval.u < rval.u);
978         else /* if (k1 == k_signed && k2 == k_signed) */
979                 res = (lval.s > rval.s) - (lval.s < rval.s);
980
981         switch(e->type) {
982         case E_EQUAL:
983                 return res ? no : yes;
984         case E_GEQ:
985                 return res >= 0 ? yes : no;
986         case E_GTH:
987                 return res > 0 ? yes : no;
988         case E_LEQ:
989                 return res <= 0 ? yes : no;
990         case E_LTH:
991                 return res < 0 ? yes : no;
992         case E_UNEQUAL:
993                 return res ? yes : no;
994         default:
995                 printf("expr_calc_value: relation %d?\n", e->type);
996                 return no;
997         }
998 }
999
1000 static int expr_compare_type(enum expr_type t1, enum expr_type t2)
1001 {
1002         if (t1 == t2)
1003                 return 0;
1004         switch (t1) {
1005         case E_LEQ:
1006         case E_LTH:
1007         case E_GEQ:
1008         case E_GTH:
1009                 if (t2 == E_EQUAL || t2 == E_UNEQUAL)
1010                         return 1;
1011         case E_EQUAL:
1012         case E_UNEQUAL:
1013                 if (t2 == E_NOT)
1014                         return 1;
1015         case E_NOT:
1016                 if (t2 == E_AND)
1017                         return 1;
1018         case E_AND:
1019                 if (t2 == E_OR)
1020                         return 1;
1021         case E_OR:
1022                 if (t2 == E_LIST)
1023                         return 1;
1024         case E_LIST:
1025                 if (t2 == 0)
1026                         return 1;
1027         default:
1028                 return -1;
1029         }
1030         printf("[%dgt%d?]", t1, t2);
1031         return 0;
1032 }
1033
1034 static inline struct expr *
1035 expr_get_leftmost_symbol(const struct expr *e)
1036 {
1037
1038         if (e == NULL)
1039                 return NULL;
1040
1041         while (e->type != E_SYMBOL)
1042                 e = e->left.expr;
1043
1044         return expr_copy(e);
1045 }
1046
1047 /*
1048  * Given expression `e1' and `e2', returns the leaf of the longest
1049  * sub-expression of `e1' not containing 'e2.
1050  */
1051 struct expr *expr_simplify_unmet_dep(struct expr *e1, struct expr *e2)
1052 {
1053         struct expr *ret;
1054
1055         switch (e1->type) {
1056         case E_OR:
1057                 return expr_alloc_and(
1058                     expr_simplify_unmet_dep(e1->left.expr, e2),
1059                     expr_simplify_unmet_dep(e1->right.expr, e2));
1060         case E_AND: {
1061                 struct expr *e;
1062                 e = expr_alloc_and(expr_copy(e1), expr_copy(e2));
1063                 e = expr_eliminate_dups(e);
1064                 ret = (!expr_eq(e, e1)) ? e1 : NULL;
1065                 expr_free(e);
1066                 break;
1067                 }
1068         default:
1069                 ret = e1;
1070                 break;
1071         }
1072
1073         return expr_get_leftmost_symbol(ret);
1074 }
1075
1076 void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *), void *data, int prevtoken)
1077 {
1078         if (!e) {
1079                 fn(data, NULL, "y");
1080                 return;
1081         }
1082
1083         if (expr_compare_type(prevtoken, e->type) > 0)
1084                 fn(data, NULL, "(");
1085         switch (e->type) {
1086         case E_SYMBOL:
1087                 if (e->left.sym->name)
1088                         fn(data, e->left.sym, e->left.sym->name);
1089                 else
1090                         fn(data, NULL, "<choice>");
1091                 break;
1092         case E_NOT:
1093                 fn(data, NULL, "!");
1094                 expr_print(e->left.expr, fn, data, E_NOT);
1095                 break;
1096         case E_EQUAL:
1097                 if (e->left.sym->name)
1098                         fn(data, e->left.sym, e->left.sym->name);
1099                 else
1100                         fn(data, NULL, "<choice>");
1101                 fn(data, NULL, "=");
1102                 fn(data, e->right.sym, e->right.sym->name);
1103                 break;
1104         case E_LEQ:
1105         case E_LTH:
1106                 if (e->left.sym->name)
1107                         fn(data, e->left.sym, e->left.sym->name);
1108                 else
1109                         fn(data, NULL, "<choice>");
1110                 fn(data, NULL, e->type == E_LEQ ? "<=" : "<");
1111                 fn(data, e->right.sym, e->right.sym->name);
1112                 break;
1113         case E_GEQ:
1114         case E_GTH:
1115                 if (e->left.sym->name)
1116                         fn(data, e->left.sym, e->left.sym->name);
1117                 else
1118                         fn(data, NULL, "<choice>");
1119                 fn(data, NULL, e->type == E_GEQ ? ">=" : ">");
1120                 fn(data, e->right.sym, e->right.sym->name);
1121                 break;
1122         case E_UNEQUAL:
1123                 if (e->left.sym->name)
1124                         fn(data, e->left.sym, e->left.sym->name);
1125                 else
1126                         fn(data, NULL, "<choice>");
1127                 fn(data, NULL, "!=");
1128                 fn(data, e->right.sym, e->right.sym->name);
1129                 break;
1130         case E_OR:
1131                 expr_print(e->left.expr, fn, data, E_OR);
1132                 fn(data, NULL, " || ");
1133                 expr_print(e->right.expr, fn, data, E_OR);
1134                 break;
1135         case E_AND:
1136                 expr_print(e->left.expr, fn, data, E_AND);
1137                 fn(data, NULL, " && ");
1138                 expr_print(e->right.expr, fn, data, E_AND);
1139                 break;
1140         case E_LIST:
1141                 fn(data, e->right.sym, e->right.sym->name);
1142                 if (e->left.expr) {
1143                         fn(data, NULL, " ^ ");
1144                         expr_print(e->left.expr, fn, data, E_LIST);
1145                 }
1146                 break;
1147         case E_RANGE:
1148                 fn(data, NULL, "[");
1149                 fn(data, e->left.sym, e->left.sym->name);
1150                 fn(data, NULL, " ");
1151                 fn(data, e->right.sym, e->right.sym->name);
1152                 fn(data, NULL, "]");
1153                 break;
1154         default:
1155           {
1156                 char buf[32];
1157                 sprintf(buf, "<unknown type %d>", e->type);
1158                 fn(data, NULL, buf);
1159                 break;
1160           }
1161         }
1162         if (expr_compare_type(prevtoken, e->type) > 0)
1163                 fn(data, NULL, ")");
1164 }
1165
1166 static void expr_print_file_helper(void *data, struct symbol *sym, const char *str)
1167 {
1168         xfwrite(str, strlen(str), 1, data);
1169 }
1170
1171 void expr_fprint(struct expr *e, FILE *out)
1172 {
1173         expr_print(e, expr_print_file_helper, out, E_NONE);
1174 }
1175
1176 static void expr_print_gstr_helper(void *data, struct symbol *sym, const char *str)
1177 {
1178         struct gstr *gs = (struct gstr*)data;
1179         const char *sym_str = NULL;
1180
1181         if (sym)
1182                 sym_str = sym_get_string_value(sym);
1183
1184         if (gs->max_width) {
1185                 unsigned extra_length = strlen(str);
1186                 const char *last_cr = strrchr(gs->s, '\n');
1187                 unsigned last_line_length;
1188
1189                 if (sym_str)
1190                         extra_length += 4 + strlen(sym_str);
1191
1192                 if (!last_cr)
1193                         last_cr = gs->s;
1194
1195                 last_line_length = strlen(gs->s) - (last_cr - gs->s);
1196
1197                 if ((last_line_length + extra_length) > gs->max_width)
1198                         str_append(gs, "\\\n");
1199         }
1200
1201         str_append(gs, str);
1202         if (sym && sym->type != S_UNKNOWN)
1203                 str_printf(gs, " [=%s]", sym_str);
1204 }
1205
1206 void expr_gstr_print(struct expr *e, struct gstr *gs)
1207 {
1208         expr_print(e, expr_print_gstr_helper, gs, E_NONE);
1209 }