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