Lines Matching defs:e
21 static struct expr *expr_eliminate_yn(struct expr *e);
35 struct expr *e;
40 hash_for_each_possible(expr_hashtable, e, node, hash) {
41 if (e->type == type && e->left._initdata == l &&
42 e->right._initdata == r)
43 return e;
46 e = xmalloc(sizeof(*e));
47 e->type = type;
48 e->left._initdata = l;
49 e->right._initdata = r;
50 e->val_is_valid = false;
52 hash_add(expr_hashtable, &e->node, hash);
54 return e;
267 static struct expr *expr_eliminate_yn(struct expr *e)
271 if (e) switch (e->type) {
273 l = expr_eliminate_yn(e->left.expr);
274 r = expr_eliminate_yn(e->right.expr);
289 l = expr_eliminate_yn(e->left.expr);
290 r = expr_eliminate_yn(e->right.expr);
307 return e;
527 * Rewrites 'e' in-place to remove ("join") duplicate and other redundant
537 struct expr *expr_eliminate_dups(struct expr *e)
540 if (!e)
541 return e;
548 switch (e->type) {
550 l = expr_eliminate_dups(e->left.expr);
551 r = expr_eliminate_dups(e->right.expr);
552 expr_eliminate_dups1(e->type, &l, &r);
553 e = expr_alloc_two(e->type, l, r);
557 e = expr_eliminate_yn(e);
560 return e;
593 struct expr *expr_transform(struct expr *e)
595 if (!e)
597 switch (e->type) {
607 e = expr_alloc_two(e->type,
608 expr_transform(e->left.expr),
609 expr_transform(e->right.expr));
612 switch (e->type) {
614 if (e->left.sym->type != S_BOOLEAN)
616 if (e->right.sym == &symbol_no) {
618 e = expr_alloc_one(E_NOT, expr_alloc_symbol(e->left.sym));
621 if (e->right.sym == &symbol_mod) {
623 printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
624 e = expr_alloc_symbol(&symbol_no);
627 if (e->right.sym == &symbol_yes) {
629 e = expr_alloc_symbol(e->left.sym);
634 if (e->left.sym->type != S_BOOLEAN)
636 if (e->right.sym == &symbol_no) {
638 e = expr_alloc_symbol(e->left.sym);
641 if (e->right.sym == &symbol_mod) {
643 printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
644 e = expr_alloc_symbol(&symbol_yes);
647 if (e->right.sym == &symbol_yes) {
649 e = expr_alloc_one(E_NOT, e->left.expr);
654 switch (e->left.expr->type) {
657 e = e->left.expr->left.expr;
662 e = expr_alloc_comp(e->left.expr->type == E_EQUAL ? E_UNEQUAL : E_EQUAL,
663 e->left.expr->left.sym,
664 e->left.expr->right.sym);
669 e = expr_alloc_comp(e->left.expr->type == E_LEQ ? E_GTH : E_LTH,
670 e->left.expr->left.sym,
671 e->left.expr->right.sym);
676 e = expr_alloc_comp(e->left.expr->type == E_LTH ? E_GEQ : E_LEQ,
677 e->left.expr->left.sym,
678 e->left.expr->right.sym);
682 e = expr_alloc_and(expr_alloc_one(E_NOT, e->left.expr->left.expr),
683 expr_alloc_one(E_NOT, e->left.expr->right.expr));
684 e = expr_transform(e);
688 e = expr_alloc_or(expr_alloc_one(E_NOT, e->left.expr->left.expr),
689 expr_alloc_one(E_NOT, e->left.expr->right.expr));
690 e = expr_transform(e);
693 if (e->left.expr->left.sym == &symbol_yes)
695 e = expr_alloc_symbol(&symbol_no);
696 else if (e->left.expr->left.sym == &symbol_mod)
698 e = expr_alloc_symbol(&symbol_mod);
699 else if (e->left.expr->left.sym == &symbol_no)
701 e = expr_alloc_symbol(&symbol_yes);
710 return e;
743 * with 'sym' disabled, e.g.'sym!=y'.
805 * expression 'e'.
817 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
821 if (!e) {
822 e = expr_alloc_symbol(sym);
824 e = expr_alloc_one(E_NOT, e);
825 return e;
827 switch (e->type) {
829 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
830 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
832 e = expr_alloc_two(E_AND, e1, e2);
834 e = expr_alloc_two(E_OR, e1, e2);
836 e = expr_alloc_one(E_NOT, e);
837 return e;
839 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
840 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
842 e = expr_alloc_two(E_OR, e1, e2);
844 e = expr_alloc_two(E_AND, e1, e2);
846 e = expr_alloc_one(E_NOT, e);
847 return e;
849 return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
858 return e;
862 return expr_alloc_one(E_NOT, e);
865 return expr_alloc_one(E_NOT, e);
869 return e;
873 return expr_alloc_comp(type, e->left.sym, sym);
924 static tristate __expr_calc_value(struct expr *e)
932 switch (e->type) {
934 sym_calc_value(e->left.sym);
935 return e->left.sym->curr.tri;
937 val1 = expr_calc_value(e->left.expr);
938 val2 = expr_calc_value(e->right.expr);
941 val1 = expr_calc_value(e->left.expr);
942 val2 = expr_calc_value(e->right.expr);
945 val1 = expr_calc_value(e->left.expr);
955 printf("expr_calc_value: %d?\n", e->type);
959 sym_calc_value(e->left.sym);
960 sym_calc_value(e->right.sym);
961 str1 = sym_get_string_value(e->left.sym);
962 str2 = sym_get_string_value(e->right.sym);
964 if (e->left.sym->type != S_STRING || e->right.sym->type != S_STRING) {
965 k1 = expr_parse_string(str1, e->left.sym->type, &lval);
966 k2 = expr_parse_string(str2, e->right.sym->type, &rval);
976 switch(e->type) {
990 printf("expr_calc_value: relation %d?\n", e->type);
997 * @e: expression
1000 tristate expr_calc_value(struct expr *e)
1002 if (!e)
1005 if (!e->val_is_valid) {
1006 e->val = __expr_calc_value(e);
1007 e->val_is_valid = true;
1010 return e->val;
1018 struct expr *e;
1020 hash_for_each(expr_hashtable, e, node)
1021 e->val_is_valid = false;
1055 void expr_print(const struct expr *e,
1059 if (!e) {
1064 if (expr_compare_type(prevtoken, e->type) > 0)
1066 switch (e->type) {
1068 if (e->left.sym->name)
1069 fn(data, e->left.sym, e->left.sym->name);
1075 expr_print(e->left.expr, fn, data, E_NOT);
1078 if (e->left.sym->name)
1079 fn(data, e->left.sym, e->left.sym->name);
1083 fn(data, e->right.sym, e->right.sym->name);
1087 if (e->left.sym->name)
1088 fn(data, e->left.sym, e->left.sym->name);
1091 fn(data, NULL, e->type == E_LEQ ? "<=" : "<");
1092 fn(data, e->right.sym, e->right.sym->name);
1096 if (e->left.sym->name)
1097 fn(data, e->left.sym, e->left.sym->name);
1100 fn(data, NULL, e->type == E_GEQ ? ">=" : ">");
1101 fn(data, e->right.sym, e->right.sym->name);
1104 if (e->left.sym->name)
1105 fn(data, e->left.sym, e->left.sym->name);
1109 fn(data, e->right.sym, e->right.sym->name);
1112 expr_print(e->left.expr, fn, data, E_OR);
1114 expr_print(e->right.expr, fn, data, E_OR);
1117 expr_print(e->left.expr, fn, data, E_AND);
1119 expr_print(e->right.expr, fn, data, E_AND);
1123 fn(data, e->left.sym, e->left.sym->name);
1125 fn(data, e->right.sym, e->right.sym->name);
1131 sprintf(buf, "<unknown type %d>", e->type);
1136 if (expr_compare_type(prevtoken, e->type) > 0)
1145 void expr_fprint(struct expr *e, FILE *out)
1147 expr_print(e, expr_print_file_helper, out, E_NONE);
1180 void expr_gstr_print(const struct expr *e, struct gstr *gs)
1182 expr_print(e, expr_print_gstr_helper, gs, E_NONE);
1190 static void expr_print_revdep(struct expr *e,
1194 if (e->type == E_OR) {
1195 expr_print_revdep(e->left.expr, fn, data, pr_type, title);
1196 expr_print_revdep(e->right.expr, fn, data, pr_type, title);
1197 } else if (expr_calc_value(e) == pr_type) {
1204 expr_print(e, fn, data, E_NONE);
1209 void expr_gstr_print_revdep(struct expr *e, struct gstr *gs,
1212 expr_print_revdep(e, expr_print_gstr_helper, gs, pr_type, &title);