Lines Matching full:e1
34 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2) in expr_alloc_two() argument
38 e->left.expr = e1; in expr_alloc_two()
52 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2) in expr_alloc_and() argument
54 if (!e1) in expr_alloc_and()
56 return e2 ? expr_alloc_two(E_AND, e1, e2) : e1; in expr_alloc_and()
59 struct expr *expr_alloc_or(struct expr *e1, struct expr *e2) in expr_alloc_or() argument
61 if (!e1) in expr_alloc_or()
63 return e2 ? expr_alloc_two(E_OR, e1, e2) : e1; in expr_alloc_or()
139 #define e1 (*ep1) macro
154 if (e1->type == type) { in __expr_eliminate_eq()
155 __expr_eliminate_eq(type, &e1->left.expr, &e2); in __expr_eliminate_eq()
156 __expr_eliminate_eq(type, &e1->right.expr, &e2); in __expr_eliminate_eq()
160 __expr_eliminate_eq(type, &e1, &e2->left.expr); in __expr_eliminate_eq()
161 __expr_eliminate_eq(type, &e1, &e2->right.expr); in __expr_eliminate_eq()
165 /* e1 and e2 are leaves. Compare them. */ in __expr_eliminate_eq()
167 if (e1->type == E_SYMBOL && e2->type == E_SYMBOL && in __expr_eliminate_eq()
168 e1->left.sym == e2->left.sym && in __expr_eliminate_eq()
169 (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no)) in __expr_eliminate_eq()
171 if (!expr_eq(e1, e2)) in __expr_eliminate_eq()
174 /* e1 and e2 are equal leaves. Prepare them for elimination. */ in __expr_eliminate_eq()
177 expr_free(e1); expr_free(e2); in __expr_eliminate_eq()
180 e1 = expr_alloc_symbol(&symbol_no); in __expr_eliminate_eq()
184 e1 = expr_alloc_symbol(&symbol_yes); in __expr_eliminate_eq()
209 * For example, in the expression 'e1 && (e2 || e3) && (e4 || e5)', the
212 * - 'e1', 'e2 || e3', and 'e4 || e5', against each other
216 * Parentheses are irrelevant within a single level. 'e1 && (e2 && e3)' and
217 * '(e1 && e2) && e3' are both a single level.
223 if (!e1 || !e2) in expr_eliminate_eq()
225 switch (e1->type) { in expr_eliminate_eq()
228 __expr_eliminate_eq(e1->type, ep1, ep2); in expr_eliminate_eq()
232 if (e1->type != e2->type) switch (e2->type) { in expr_eliminate_eq()
239 e1 = expr_eliminate_yn(e1); in expr_eliminate_eq()
243 #undef e1
247 * Returns true if 'e1' and 'e2' are equal, after minor simplification. Two
252 int expr_eq(struct expr *e1, struct expr *e2) in expr_eq() argument
260 if (!e1 || !e2) in expr_eq()
261 return expr_is_yes(e1) && expr_is_yes(e2); in expr_eq()
263 if (e1->type != e2->type) in expr_eq()
265 switch (e1->type) { in expr_eq()
272 return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym; in expr_eq()
274 return e1->left.sym == e2->left.sym; in expr_eq()
276 return expr_eq(e1->left.expr, e2->left.expr); in expr_eq()
279 e1 = expr_copy(e1); in expr_eq()
282 expr_eliminate_eq(&e1, &e2); in expr_eq()
283 res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL && in expr_eq()
284 e1->left.sym == e2->left.sym); in expr_eq()
285 expr_free(e1); in expr_eq()
296 expr_fprint(e1, stdout); in expr_eq()
400 * e1 || e2 -> ?
402 static struct expr *expr_join_or(struct expr *e1, struct expr *e2) in expr_join_or() argument
407 if (expr_eq(e1, e2)) in expr_join_or()
408 return expr_copy(e1); in expr_join_or()
409 if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT) in expr_join_or()
413 if (e1->type == E_NOT) { in expr_join_or()
414 tmp = e1->left.expr; in expr_join_or()
419 sym1 = e1->left.sym; in expr_join_or()
431 if (e1->type == E_EQUAL && e2->type == E_EQUAL && in expr_join_or()
432 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) || in expr_join_or()
433 (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) { in expr_join_or()
437 if (e1->type == E_EQUAL && e2->type == E_EQUAL && in expr_join_or()
438 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) || in expr_join_or()
439 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) { in expr_join_or()
443 if (e1->type == E_EQUAL && e2->type == E_EQUAL && in expr_join_or()
444 ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) || in expr_join_or()
445 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) { in expr_join_or()
451 if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) || in expr_join_or()
452 (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL)) in expr_join_or()
458 expr_fprint(e1, stdout); in expr_join_or()
466 static struct expr *expr_join_and(struct expr *e1, struct expr *e2) in expr_join_and() argument
471 if (expr_eq(e1, e2)) in expr_join_and()
472 return expr_copy(e1); in expr_join_and()
473 if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT) in expr_join_and()
477 if (e1->type == E_NOT) { in expr_join_and()
478 tmp = e1->left.expr; in expr_join_and()
483 sym1 = e1->left.sym; in expr_join_and()
495 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) || in expr_join_and()
496 (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes)) in expr_join_and()
500 if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) || in expr_join_and()
501 (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no)) in expr_join_and()
505 if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) || in expr_join_and()
506 (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod)) in expr_join_and()
511 if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) { in expr_join_and()
513 sym2 = e1->right.sym; in expr_join_and()
518 if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) { in expr_join_and()
521 if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST)) in expr_join_and()
522 return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2) in expr_join_and()
525 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL && in expr_join_and()
526 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) || in expr_join_and()
527 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) in expr_join_and()
531 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL && in expr_join_and()
532 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) || in expr_join_and()
533 (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) in expr_join_and()
537 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL && in expr_join_and()
538 ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) || in expr_join_and()
539 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) in expr_join_and()
543 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) || in expr_join_and()
544 (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) || in expr_join_and()
545 (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) || in expr_join_and()
546 (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes)) in expr_join_and()
552 expr_fprint(e1, stdout); in expr_join_and()
569 #define e1 (*ep1) in expr_eliminate_dups1() macro
575 if (e1->type == type) { in expr_eliminate_dups1()
576 expr_eliminate_dups1(type, &e1->left.expr, &e2); in expr_eliminate_dups1()
577 expr_eliminate_dups1(type, &e1->right.expr, &e2); in expr_eliminate_dups1()
581 expr_eliminate_dups1(type, &e1, &e2->left.expr); in expr_eliminate_dups1()
582 expr_eliminate_dups1(type, &e1, &e2->right.expr); in expr_eliminate_dups1()
586 /* e1 and e2 are leaves. Compare and process them. */ in expr_eliminate_dups1()
588 if (e1 == e2) in expr_eliminate_dups1()
591 switch (e1->type) { in expr_eliminate_dups1()
593 expr_eliminate_dups1(e1->type, &e1, &e1); in expr_eliminate_dups1()
600 tmp = expr_join_or(e1, e2); in expr_eliminate_dups1()
602 expr_free(e1); expr_free(e2); in expr_eliminate_dups1()
603 e1 = expr_alloc_symbol(&symbol_no); in expr_eliminate_dups1()
609 tmp = expr_join_and(e1, e2); in expr_eliminate_dups1()
611 expr_free(e1); expr_free(e2); in expr_eliminate_dups1()
612 e1 = expr_alloc_symbol(&symbol_yes); in expr_eliminate_dups1()
620 #undef e1 in expr_eliminate_dups1()
895 struct expr *e1, *e2; in expr_trans_compare() local
905 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); in expr_trans_compare()
908 e = expr_alloc_two(E_AND, e1, e2); in expr_trans_compare()
910 e = expr_alloc_two(E_OR, e1, e2); in expr_trans_compare()
915 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); in expr_trans_compare()
918 e = expr_alloc_two(E_OR, e1, e2); in expr_trans_compare()
920 e = expr_alloc_two(E_AND, e1, e2); in expr_trans_compare()