Lines Matching refs:e1
34 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
38 e->left.expr = e1;
52 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
54 if (!e1)
56 return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
59 struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
61 if (!e1)
63 return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
139 #define e1 (*ep1)
154 if (e1->type == type) {
155 __expr_eliminate_eq(type, &e1->left.expr, &e2);
156 __expr_eliminate_eq(type, &e1->right.expr, &e2);
160 __expr_eliminate_eq(type, &e1, &e2->left.expr);
161 __expr_eliminate_eq(type, &e1, &e2->right.expr);
165 /* e1 and e2 are leaves. Compare them. */
167 if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
168 e1->left.sym == e2->left.sym &&
169 (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
171 if (!expr_eq(e1, e2))
174 /* e1 and e2 are equal leaves. Prepare them for elimination. */
177 expr_free(e1); expr_free(e2);
180 e1 = expr_alloc_symbol(&symbol_no);
184 e1 = expr_alloc_symbol(&symbol_yes);
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)
225 switch (e1->type) {
228 __expr_eliminate_eq(e1->type, ep1, ep2);
232 if (e1->type != e2->type) switch (e2->type) {
239 e1 = expr_eliminate_yn(e1);
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)
260 if (!e1 || !e2)
261 return expr_is_yes(e1) && expr_is_yes(e2);
263 if (e1->type != e2->type)
265 switch (e1->type) {
272 return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
274 return e1->left.sym == e2->left.sym;
276 return expr_eq(e1->left.expr, e2->left.expr);
279 e1 = expr_copy(e1);
282 expr_eliminate_eq(&e1, &e2);
283 res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
284 e1->left.sym == e2->left.sym);
285 expr_free(e1);
296 expr_fprint(e1, stdout);
429 * e1 || e2 -> ?
431 static struct expr *expr_join_or(struct expr *e1, struct expr *e2)
436 if (expr_eq(e1, e2))
437 return expr_copy(e1);
438 if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
442 if (e1->type == E_NOT) {
443 tmp = e1->left.expr;
448 sym1 = e1->left.sym;
460 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
461 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
462 (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
466 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
467 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
468 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
472 if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
473 ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
474 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
480 if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
481 (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
487 expr_fprint(e1, stdout);
495 static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
500 if (expr_eq(e1, e2))
501 return expr_copy(e1);
502 if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
506 if (e1->type == E_NOT) {
507 tmp = e1->left.expr;
512 sym1 = e1->left.sym;
524 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
525 (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
529 if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
530 (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
534 if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
535 (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
540 if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
542 sym2 = e1->right.sym;
547 if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
550 if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
551 return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
554 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
555 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
556 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
560 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
561 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
562 (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
566 if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
567 ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
568 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
572 if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
573 (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
574 (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
575 (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
581 expr_fprint(e1, stdout);
598 #define e1 (*ep1)
604 if (e1->type == type) {
605 expr_eliminate_dups1(type, &e1->left.expr, &e2);
606 expr_eliminate_dups1(type, &e1->right.expr, &e2);
610 expr_eliminate_dups1(type, &e1, &e2->left.expr);
611 expr_eliminate_dups1(type, &e1, &e2->right.expr);
615 /* e1 and e2 are leaves. Compare and process them. */
617 if (e1 == e2)
620 switch (e1->type) {
622 expr_eliminate_dups1(e1->type, &e1, &e1);
629 tmp = expr_join_or(e1, e2);
631 expr_free(e1); expr_free(e2);
632 e1 = expr_alloc_symbol(&symbol_no);
638 tmp = expr_join_and(e1, e2);
640 expr_free(e1); expr_free(e2);
641 e1 = expr_alloc_symbol(&symbol_yes);
649 #undef e1
924 struct expr *e1, *e2;
934 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
937 e = expr_alloc_two(E_AND, e1, e2);
939 e = expr_alloc_two(E_OR, e1, e2);
944 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
947 e = expr_alloc_two(E_OR, e1, e2);
949 e = expr_alloc_two(E_AND, e1, e2);