Lines Matching refs:sym
18 struct expr *expr_alloc_symbol(struct symbol *sym)
22 e->left.sym = sym;
47 e->left.sym = s1;
48 e->right.sym = s2;
88 e->left.sym = org->left.sym;
89 e->right.sym = org->right.sym;
168 e1->left.sym == e2->left.sym &&
169 (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
272 return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
274 return e1->left.sym == e2->left.sym;
284 e1->left.sym == e2->left.sym);
325 if (e->left.expr->left.sym == &symbol_no) {
329 e->left.sym = &symbol_no;
332 } else if (e->left.expr->left.sym == &symbol_yes) {
341 if (e->right.expr->left.sym == &symbol_no) {
345 e->left.sym = &symbol_no;
348 } else if (e->right.expr->left.sym == &symbol_yes) {
361 if (e->left.expr->left.sym == &symbol_no) {
367 } else if (e->left.expr->left.sym == &symbol_yes) {
371 e->left.sym = &symbol_yes;
377 if (e->right.expr->left.sym == &symbol_no) {
383 } else if (e->right.expr->left.sym == &symbol_yes) {
387 e->left.sym = &symbol_yes;
415 if (e->left.sym->type == S_TRISTATE) {
416 if (e->right.sym == &symbol_no) {
418 e->right.sym = NULL;
446 sym1 = tmp->left.sym;
448 sym1 = e1->left.sym;
452 sym2 = e2->left.expr->left.sym;
454 sym2 = e2->left.sym;
461 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
462 (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
467 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
468 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
473 ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
474 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
510 sym1 = tmp->left.sym;
512 sym1 = e1->left.sym;
516 sym2 = e2->left.expr->left.sym;
518 sym2 = e2->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))
542 sym2 = e1->right.sym;
543 if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
544 return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
549 sym2 = e2->right.sym;
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)
555 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
556 (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
561 ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
562 (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
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))
717 if (e->left.sym->type != S_BOOLEAN)
719 if (e->right.sym == &symbol_no) {
721 e->left.expr = expr_alloc_symbol(e->left.sym);
722 e->right.sym = NULL;
725 if (e->right.sym == &symbol_mod) {
726 printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
728 e->left.sym = &symbol_no;
729 e->right.sym = NULL;
732 if (e->right.sym == &symbol_yes) {
734 e->right.sym = NULL;
739 if (e->left.sym->type != S_BOOLEAN)
741 if (e->right.sym == &symbol_no) {
743 e->right.sym = NULL;
746 if (e->right.sym == &symbol_mod) {
747 printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
749 e->left.sym = &symbol_yes;
750 e->right.sym = NULL;
753 if (e->right.sym == &symbol_yes) {
755 e->left.expr = expr_alloc_symbol(e->left.sym);
756 e->right.sym = NULL;
813 if (e->left.expr->left.sym == &symbol_yes) {
819 e->left.sym = &symbol_no;
822 if (e->left.expr->left.sym == &symbol_mod) {
828 e->left.sym = &symbol_mod;
831 if (e->left.expr->left.sym == &symbol_no) {
837 e->left.sym = &symbol_yes;
851 int expr_contains_symbol(struct expr *dep, struct symbol *sym)
859 return expr_contains_symbol(dep->left.expr, sym) ||
860 expr_contains_symbol(dep->right.expr, sym);
862 return dep->left.sym == sym;
869 return dep->left.sym == sym ||
870 dep->right.sym == sym;
872 return expr_contains_symbol(dep->left.expr, sym);
879 bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
886 return expr_depends_symbol(dep->left.expr, sym) ||
887 expr_depends_symbol(dep->right.expr, sym);
889 return dep->left.sym == sym;
891 if (dep->left.sym == sym) {
892 if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
897 if (dep->left.sym == sym) {
898 if (dep->right.sym == &symbol_no)
909 * Inserts explicit comparisons of type 'type' to symbol 'sym' into the
912 * Examples transformations for type == E_UNEQUAL, sym == &symbol_no:
922 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
927 e = expr_alloc_symbol(sym);
934 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
935 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
936 if (sym == &symbol_yes)
938 if (sym == &symbol_no)
944 e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
945 e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
946 if (sym == &symbol_yes)
948 if (sym == &symbol_no)
954 return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
962 if (sym == &symbol_yes)
964 if (sym == &symbol_mod)
966 if (sym == &symbol_no)
969 if (sym == &symbol_yes)
971 if (sym == &symbol_mod)
973 if (sym == &symbol_no)
978 return expr_alloc_comp(type, e->left.sym, sym);
1043 sym_calc_value(e->left.sym);
1044 return e->left.sym->curr.tri;
1068 sym_calc_value(e->left.sym);
1069 sym_calc_value(e->right.sym);
1070 str1 = sym_get_string_value(e->left.sym);
1071 str2 = sym_get_string_value(e->right.sym);
1073 if (e->left.sym->type != S_STRING || e->right.sym->type != S_STRING) {
1074 k1 = expr_parse_string(str1, e->left.sym->type, &lval);
1075 k2 = expr_parse_string(str2, e->right.sym->type, &rval);
1151 if (e->left.sym->name)
1152 fn(data, e->left.sym, e->left.sym->name);
1161 if (e->left.sym->name)
1162 fn(data, e->left.sym, e->left.sym->name);
1166 fn(data, e->right.sym, e->right.sym->name);
1170 if (e->left.sym->name)
1171 fn(data, e->left.sym, e->left.sym->name);
1175 fn(data, e->right.sym, e->right.sym->name);
1179 if (e->left.sym->name)
1180 fn(data, e->left.sym, e->left.sym->name);
1184 fn(data, e->right.sym, e->right.sym->name);
1187 if (e->left.sym->name)
1188 fn(data, e->left.sym, e->left.sym->name);
1192 fn(data, e->right.sym, e->right.sym->name);
1205 fn(data, e->right.sym, e->right.sym->name);
1213 fn(data, e->left.sym, e->left.sym->name);
1215 fn(data, e->right.sym, e->right.sym->name);
1230 static void expr_print_file_helper(void *data, struct symbol *sym, const char *str)
1240 static void expr_print_gstr_helper(void *data, struct symbol *sym, const char *str)
1245 if (sym)
1246 sym_str = sym_get_string_value(sym);
1266 if (sym && sym->type != S_UNKNOWN)