blob: cbf4996dd9c1045ecc7ffa66a9ec79edd99b1038 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include "lkc.h"
11
12#define DEBUG_EXPR 0
13
Michal Marekad8d40c2015-02-24 16:37:13 +010014static int expr_eq(struct expr *e1, struct expr *e2);
15static struct expr *expr_eliminate_yn(struct expr *e);
Michal Marekad8d40c2015-02-24 16:37:13 +010016
Linus Torvalds1da177e2005-04-16 15:20:36 -070017struct expr *expr_alloc_symbol(struct symbol *sym)
18{
Alan Cox177acf72012-11-06 14:32:08 +000019 struct expr *e = xcalloc(1, sizeof(*e));
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 e->type = E_SYMBOL;
21 e->left.sym = sym;
22 return e;
23}
24
25struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
26{
Alan Cox177acf72012-11-06 14:32:08 +000027 struct expr *e = xcalloc(1, sizeof(*e));
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 e->type = type;
29 e->left.expr = ce;
30 return e;
31}
32
33struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
34{
Alan Cox177acf72012-11-06 14:32:08 +000035 struct expr *e = xcalloc(1, sizeof(*e));
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 e->type = type;
37 e->left.expr = e1;
38 e->right.expr = e2;
39 return e;
40}
41
42struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
43{
Alan Cox177acf72012-11-06 14:32:08 +000044 struct expr *e = xcalloc(1, sizeof(*e));
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 e->type = type;
46 e->left.sym = s1;
47 e->right.sym = s2;
48 return e;
49}
50
51struct 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
58struct 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
Michal Marek17742dc2010-12-20 16:06:44 +010065struct expr *expr_copy(const struct expr *org)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
67 struct expr *e;
68
69 if (!org)
70 return NULL;
71
Alan Cox177acf72012-11-06 14:32:08 +000072 e = xmalloc(sizeof(*org));
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 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:
Jan Beulich31847b62015-06-15 13:00:21 +010082 case E_GEQ:
83 case E_GTH:
84 case E_LEQ:
85 case E_LTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 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:
Roman Zippel7a962922008-01-14 04:50:23 +010092 case E_LIST:
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 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
106void 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:
Jan Beulich31847b62015-06-15 13:00:21 +0100118 case E_GEQ:
119 case E_GTH:
120 case E_LEQ:
121 case E_LTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 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
136static int trans_count;
137
138#define e1 (*ep1)
139#define e2 (*ep2)
140
141static 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 &&
Roman Zippelc0e150ac2006-06-08 22:12:40 -0700154 e1->left.sym == e2->left.sym &&
155 (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 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
175void 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
Michal Marekad8d40c2015-02-24 16:37:13 +0100200static int expr_eq(struct expr *e1, struct expr *e2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
202 int res, old_count;
203
204 if (e1->type != e2->type)
205 return 0;
206 switch (e1->type) {
207 case E_EQUAL:
Jan Beulich31847b62015-06-15 13:00:21 +0100208 case E_GEQ:
209 case E_GTH:
210 case E_LEQ:
211 case E_LTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 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;
Roman Zippel7a962922008-01-14 04:50:23 +0100230 case E_LIST:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 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
Michal Marekad8d40c2015-02-24 16:37:13 +0100246static struct expr *expr_eliminate_yn(struct expr *e)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
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 */
332struct 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 */
Trevor Keith4356f482009-09-18 12:49:23 -0700361static struct expr *expr_join_or(struct expr *e1, struct expr *e2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
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
Trevor Keith4356f482009-09-18 12:49:23 -0700425static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
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
519static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571struct 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 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
594struct 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:
Jan Beulich31847b62015-06-15 13:00:21 +0100602 case E_GEQ:
603 case E_GTH:
604 case E_LEQ:
605 case E_LTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 case E_UNEQUAL:
607 case E_SYMBOL:
Roman Zippel7a962922008-01-14 04:50:23 +0100608 case E_LIST:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 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;
Jan Beulich31847b62015-06-15 13:00:21 +0100678 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 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
751int 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:
Jan Beulich31847b62015-06-15 13:00:21 +0100764 case E_GEQ:
765 case E_GTH:
766 case E_LEQ:
767 case E_LTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 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
779bool 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808struct 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:
Jan Beulich31847b62015-06-15 13:00:21 +0100842 case E_LTH:
843 case E_LEQ:
844 case E_GTH:
845 case E_GEQ:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 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);
Roman Zippel7a962922008-01-14 04:50:23 +0100865 case E_LIST:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 case E_RANGE:
867 case E_NONE:
868 /* panic */;
869 }
870 return NULL;
871}
872
Jan Beulich31847b62015-06-15 13:00:21 +0100873enum string_value_kind {
874 k_string,
875 k_signed,
876 k_unsigned,
877 k_invalid
878};
879
880union string_value {
881 unsigned long long u;
882 signed long long s;
883};
884
885static 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 return k_string;
897 case S_INT:
898 val->s = strtoll(str, &tail, 10);
899 kind = k_signed;
900 break;
901 case S_HEX:
902 val->u = strtoull(str, &tail, 16);
903 kind = k_unsigned;
904 break;
905 case S_STRING:
906 case S_UNKNOWN:
907 val->s = strtoll(str, &tail, 0);
908 kind = k_signed;
909 break;
910 default:
911 return k_invalid;
912 }
913 return !errno && !*tail && tail > str && isxdigit(tail[-1])
914 ? kind : k_string;
915}
916
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917tristate expr_calc_value(struct expr *e)
918{
919 tristate val1, val2;
920 const char *str1, *str2;
Jan Beulich31847b62015-06-15 13:00:21 +0100921 enum string_value_kind k1 = k_string, k2 = k_string;
922 union string_value lval = {}, rval = {};
923 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
925 if (!e)
926 return yes;
927
928 switch (e->type) {
929 case E_SYMBOL:
930 sym_calc_value(e->left.sym);
931 return e->left.sym->curr.tri;
932 case E_AND:
933 val1 = expr_calc_value(e->left.expr);
934 val2 = expr_calc_value(e->right.expr);
Sam Ravnborgd6ee3572008-01-07 21:09:55 +0100935 return EXPR_AND(val1, val2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 case E_OR:
937 val1 = expr_calc_value(e->left.expr);
938 val2 = expr_calc_value(e->right.expr);
Sam Ravnborgd6ee3572008-01-07 21:09:55 +0100939 return EXPR_OR(val1, val2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 case E_NOT:
941 val1 = expr_calc_value(e->left.expr);
Sam Ravnborgd6ee3572008-01-07 21:09:55 +0100942 return EXPR_NOT(val1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 case E_EQUAL:
Jan Beulich31847b62015-06-15 13:00:21 +0100944 case E_GEQ:
945 case E_GTH:
946 case E_LEQ:
947 case E_LTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 case E_UNEQUAL:
Jan Beulich31847b62015-06-15 13:00:21 +0100949 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 default:
951 printf("expr_calc_value: %d?\n", e->type);
952 return no;
953 }
Jan Beulich31847b62015-06-15 13:00:21 +0100954
955 sym_calc_value(e->left.sym);
956 sym_calc_value(e->right.sym);
957 str1 = sym_get_string_value(e->left.sym);
958 str2 = sym_get_string_value(e->right.sym);
959
960 if (e->left.sym->type != S_STRING || e->right.sym->type != S_STRING) {
961 k1 = expr_parse_string(str1, e->left.sym->type, &lval);
962 k2 = expr_parse_string(str2, e->right.sym->type, &rval);
963 }
964
965 if (k1 == k_string || k2 == k_string)
966 res = strcmp(str1, str2);
967 else if (k1 == k_invalid || k2 == k_invalid) {
968 if (e->type != E_EQUAL && e->type != E_UNEQUAL) {
969 printf("Cannot compare \"%s\" and \"%s\"\n", str1, str2);
970 return no;
971 }
972 res = strcmp(str1, str2);
973 } else if (k1 == k_unsigned || k2 == k_unsigned)
974 res = (lval.u > rval.u) - (lval.u < rval.u);
975 else /* if (k1 == k_signed && k2 == k_signed) */
976 res = (lval.s > rval.s) - (lval.s < rval.s);
977
978 switch(e->type) {
979 case E_EQUAL:
980 return res ? no : yes;
981 case E_GEQ:
982 return res >= 0 ? yes : no;
983 case E_GTH:
984 return res > 0 ? yes : no;
985 case E_LEQ:
986 return res <= 0 ? yes : no;
987 case E_LTH:
988 return res < 0 ? yes : no;
989 case E_UNEQUAL:
990 return res ? yes : no;
991 default:
992 printf("expr_calc_value: relation %d?\n", e->type);
993 return no;
994 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
996
Michal Marekad8d40c2015-02-24 16:37:13 +0100997static int expr_compare_type(enum expr_type t1, enum expr_type t2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 if (t1 == t2)
1000 return 0;
1001 switch (t1) {
Jan Beulich31847b62015-06-15 13:00:21 +01001002 case E_LEQ:
1003 case E_LTH:
1004 case E_GEQ:
1005 case E_GTH:
1006 if (t2 == E_EQUAL || t2 == E_UNEQUAL)
1007 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 case E_EQUAL:
1009 case E_UNEQUAL:
1010 if (t2 == E_NOT)
1011 return 1;
1012 case E_NOT:
1013 if (t2 == E_AND)
1014 return 1;
1015 case E_AND:
1016 if (t2 == E_OR)
1017 return 1;
1018 case E_OR:
Roman Zippel7a962922008-01-14 04:50:23 +01001019 if (t2 == E_LIST)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 return 1;
Roman Zippel7a962922008-01-14 04:50:23 +01001021 case E_LIST:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 if (t2 == 0)
1023 return 1;
1024 default:
1025 return -1;
1026 }
1027 printf("[%dgt%d?]", t1, t2);
1028 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029}
1030
Arnaud Lacombe1137c562010-09-26 16:24:08 -04001031static inline struct expr *
1032expr_get_leftmost_symbol(const struct expr *e)
1033{
1034
1035 if (e == NULL)
1036 return NULL;
1037
1038 while (e->type != E_SYMBOL)
1039 e = e->left.expr;
1040
1041 return expr_copy(e);
1042}
1043
1044/*
1045 * Given expression `e1' and `e2', returns the leaf of the longest
1046 * sub-expression of `e1' not containing 'e2.
1047 */
1048struct expr *expr_simplify_unmet_dep(struct expr *e1, struct expr *e2)
1049{
1050 struct expr *ret;
1051
1052 switch (e1->type) {
1053 case E_OR:
1054 return expr_alloc_and(
1055 expr_simplify_unmet_dep(e1->left.expr, e2),
1056 expr_simplify_unmet_dep(e1->right.expr, e2));
1057 case E_AND: {
1058 struct expr *e;
1059 e = expr_alloc_and(expr_copy(e1), expr_copy(e2));
1060 e = expr_eliminate_dups(e);
1061 ret = (!expr_eq(e, e1)) ? e1 : NULL;
1062 expr_free(e);
1063 break;
1064 }
1065 default:
1066 ret = e1;
1067 break;
1068 }
1069
1070 return expr_get_leftmost_symbol(ret);
1071}
1072
Roman Zippelab45d192006-06-08 22:12:47 -07001073void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *), void *data, int prevtoken)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074{
1075 if (!e) {
Roman Zippelab45d192006-06-08 22:12:47 -07001076 fn(data, NULL, "y");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return;
1078 }
1079
1080 if (expr_compare_type(prevtoken, e->type) > 0)
Roman Zippelab45d192006-06-08 22:12:47 -07001081 fn(data, NULL, "(");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 switch (e->type) {
1083 case E_SYMBOL:
1084 if (e->left.sym->name)
Roman Zippelab45d192006-06-08 22:12:47 -07001085 fn(data, e->left.sym, e->left.sym->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 else
Roman Zippelab45d192006-06-08 22:12:47 -07001087 fn(data, NULL, "<choice>");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 break;
1089 case E_NOT:
Roman Zippelab45d192006-06-08 22:12:47 -07001090 fn(data, NULL, "!");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 expr_print(e->left.expr, fn, data, E_NOT);
1092 break;
1093 case E_EQUAL:
Jan Beulichf5eaa322008-01-24 11:54:23 +00001094 if (e->left.sym->name)
1095 fn(data, e->left.sym, e->left.sym->name);
1096 else
1097 fn(data, NULL, "<choice>");
Roman Zippelab45d192006-06-08 22:12:47 -07001098 fn(data, NULL, "=");
1099 fn(data, e->right.sym, e->right.sym->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 break;
Jan Beulich31847b62015-06-15 13:00:21 +01001101 case E_LEQ:
1102 case E_LTH:
1103 if (e->left.sym->name)
1104 fn(data, e->left.sym, e->left.sym->name);
1105 else
1106 fn(data, NULL, "<choice>");
1107 fn(data, NULL, e->type == E_LEQ ? "<=" : "<");
1108 fn(data, e->right.sym, e->right.sym->name);
1109 break;
1110 case E_GEQ:
1111 case E_GTH:
1112 if (e->left.sym->name)
1113 fn(data, e->left.sym, e->left.sym->name);
1114 else
1115 fn(data, NULL, "<choice>");
Michal Sojkaf6aad262015-10-19 16:51:02 +02001116 fn(data, NULL, e->type == E_GEQ ? ">=" : ">");
Jan Beulich31847b62015-06-15 13:00:21 +01001117 fn(data, e->right.sym, e->right.sym->name);
1118 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 case E_UNEQUAL:
Jan Beulichf5eaa322008-01-24 11:54:23 +00001120 if (e->left.sym->name)
1121 fn(data, e->left.sym, e->left.sym->name);
1122 else
1123 fn(data, NULL, "<choice>");
Roman Zippelab45d192006-06-08 22:12:47 -07001124 fn(data, NULL, "!=");
1125 fn(data, e->right.sym, e->right.sym->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 break;
1127 case E_OR:
1128 expr_print(e->left.expr, fn, data, E_OR);
Roman Zippelab45d192006-06-08 22:12:47 -07001129 fn(data, NULL, " || ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 expr_print(e->right.expr, fn, data, E_OR);
1131 break;
1132 case E_AND:
1133 expr_print(e->left.expr, fn, data, E_AND);
Roman Zippelab45d192006-06-08 22:12:47 -07001134 fn(data, NULL, " && ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 expr_print(e->right.expr, fn, data, E_AND);
1136 break;
Roman Zippel7a962922008-01-14 04:50:23 +01001137 case E_LIST:
Roman Zippelab45d192006-06-08 22:12:47 -07001138 fn(data, e->right.sym, e->right.sym->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 if (e->left.expr) {
Roman Zippelab45d192006-06-08 22:12:47 -07001140 fn(data, NULL, " ^ ");
Roman Zippel7a962922008-01-14 04:50:23 +01001141 expr_print(e->left.expr, fn, data, E_LIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 }
1143 break;
1144 case E_RANGE:
Roman Zippelab45d192006-06-08 22:12:47 -07001145 fn(data, NULL, "[");
1146 fn(data, e->left.sym, e->left.sym->name);
1147 fn(data, NULL, " ");
1148 fn(data, e->right.sym, e->right.sym->name);
1149 fn(data, NULL, "]");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 break;
1151 default:
1152 {
1153 char buf[32];
1154 sprintf(buf, "<unknown type %d>", e->type);
Roman Zippelab45d192006-06-08 22:12:47 -07001155 fn(data, NULL, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 break;
1157 }
1158 }
1159 if (expr_compare_type(prevtoken, e->type) > 0)
Roman Zippelab45d192006-06-08 22:12:47 -07001160 fn(data, NULL, ")");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161}
1162
Roman Zippelab45d192006-06-08 22:12:47 -07001163static void expr_print_file_helper(void *data, struct symbol *sym, const char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
Jean Sacrenbf5e3272010-08-04 16:01:02 -06001165 xfwrite(str, strlen(str), 1, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166}
1167
1168void expr_fprint(struct expr *e, FILE *out)
1169{
1170 expr_print(e, expr_print_file_helper, out, E_NONE);
1171}
1172
Roman Zippelab45d192006-06-08 22:12:47 -07001173static void expr_print_gstr_helper(void *data, struct symbol *sym, const char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174{
Vadim Bendebury (вб)da60fbb2009-12-20 00:29:49 -08001175 struct gstr *gs = (struct gstr*)data;
1176 const char *sym_str = NULL;
1177
Cheng Renquan544e4332009-07-12 16:11:43 +08001178 if (sym)
Vadim Bendebury (вб)da60fbb2009-12-20 00:29:49 -08001179 sym_str = sym_get_string_value(sym);
1180
1181 if (gs->max_width) {
1182 unsigned extra_length = strlen(str);
1183 const char *last_cr = strrchr(gs->s, '\n');
1184 unsigned last_line_length;
1185
1186 if (sym_str)
1187 extra_length += 4 + strlen(sym_str);
1188
1189 if (!last_cr)
1190 last_cr = gs->s;
1191
1192 last_line_length = strlen(gs->s) - (last_cr - gs->s);
1193
1194 if ((last_line_length + extra_length) > gs->max_width)
1195 str_append(gs, "\\\n");
1196 }
1197
1198 str_append(gs, str);
Li Zefan70ed0742010-05-07 13:56:50 +08001199 if (sym && sym->type != S_UNKNOWN)
Vadim Bendebury (вб)da60fbb2009-12-20 00:29:49 -08001200 str_printf(gs, " [=%s]", sym_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201}
1202
1203void expr_gstr_print(struct expr *e, struct gstr *gs)
1204{
1205 expr_print(e, expr_print_gstr_helper, gs, E_NONE);
1206}