xref: /third_party/toybox/kconfig/expr.c

33 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
38 	e->left.expr = e1;
53 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
55 	if (!e1)
57 	return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
60 struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
62 	if (!e1)
64 	return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
132 #define e1 (*ep1)
137 	if (e1->type == type) {
138 		__expr_eliminate_eq(type, &e1->left.expr, &e2);
139 		__expr_eliminate_eq(type, &e1->right.expr, &e2);
143 		__expr_eliminate_eq(type, &e1, &e2->left.expr);
144 		__expr_eliminate_eq(type, &e1, &e2->right.expr);
147 	if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
148 	    e1->left.sym == e2->left.sym &&
149 	    (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
151 	if (!expr_eq(e1, e2))
154 	expr_free(e1); expr_free(e2);
157 		e1 = expr_alloc_symbol(&symbol_no);
161 		e1 = expr_alloc_symbol(&symbol_yes);
171 	if (!e1 || !e2)
173 	switch (e1->type) {
176 		__expr_eliminate_eq(e1->type, ep1, ep2);
180 	if (e1->type != e2->type) switch (e2->type) {
187 	e1 = expr_eliminate_yn(e1);
191 #undef e1
194 int expr_eq(struct expr *e1, struct expr *e2)
198 	if (e1->type != e2->type)
200 	switch (e1->type) {
203 		return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
205 		return e1->left.sym == e2->left.sym;
207 		return expr_eq(e1->left.expr, e2->left.expr);
210 		e1 = expr_copy(e1);
213 		expr_eliminate_eq(&e1, &e2);
214 		res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
215 		       e1->left.sym == e2->left.sym);
216 		expr_free(e1);
227 		expr_fprint(e1, stdout);
349  * e1 || e2 -> ?
351 struct expr *expr_join_or(struct expr *e1, struct expr *e2)
356 	if (expr_eq(e1, e2))
357 		return expr_copy(e1);
358 	if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
362 	if (e1->type == E_NOT) {
363 		tmp = e1->left.expr;
368 		sym1 = e1->left.sym;
380 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
381 		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
382 		     (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
386 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
387 		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
388 		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
392 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
393 		    ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
394 		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
400 		if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
401 		    (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
407 		expr_fprint(e1, stdout);
415 struct expr *expr_join_and(struct expr *e1, struct expr *e2)
420 	if (expr_eq(e1, e2))
421 		return expr_copy(e1);
422 	if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
426 	if (e1->type == E_NOT) {
427 		tmp = e1->left.expr;
432 		sym1 = e1->left.sym;
444 	if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
445 	    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
449 	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
450 	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
454 	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
455 	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
460 		if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
462 			sym2 = e1->right.sym;
467 		if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
470 			if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
471 				return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
474 		if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
475 			   ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
476 			    (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
480 		if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
481 			   ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
482 			    (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
486 		if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
487 			   ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
488 			    (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
492 		if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
493 		    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
494 		    (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
495 		    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
501 		expr_fprint(e1, stdout);
511 #define e1 (*ep1)
515 	if (e1->type == type) {
516 		expr_eliminate_dups1(type, &e1->left.expr, &e2);
517 		expr_eliminate_dups1(type, &e1->right.expr, &e2);
521 		expr_eliminate_dups1(type, &e1, &e2->left.expr);
522 		expr_eliminate_dups1(type, &e1, &e2->right.expr);
525 	if (e1 == e2)
528 	switch (e1->type) {
530 		expr_eliminate_dups1(e1->type, &e1, &e1);
537 		tmp = expr_join_or(e1, e2);
539 			expr_free(e1); expr_free(e2);
540 			e1 = expr_alloc_symbol(&symbol_no);
546 		tmp = expr_join_and(e1, e2);
548 			expr_free(e1); expr_free(e2);
549 			e1 = expr_alloc_symbol(&symbol_yes);
557 #undef e1
563 #define e1 (*ep1)
567 	if (e1->type == type) {
568 		expr_eliminate_dups2(type, &e1->left.expr, &e2);
569 		expr_eliminate_dups2(type, &e1->right.expr, &e2);
573 		expr_eliminate_dups2(type, &e1, &e2->left.expr);
574 		expr_eliminate_dups2(type, &e1, &e2->right.expr);
576 	if (e1 == e2)
579 	switch (e1->type) {
581 		expr_eliminate_dups2(e1->type, &e1, &e1);
583 		tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
587 			expr_free(e1);
588 			e1 = expr_alloc_symbol(&symbol_no);
596 		expr_eliminate_dups2(e1->type, &e1, &e1);
598 		tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
602 			expr_free(e1);
603 			e1 = expr_alloc_symbol(&symbol_yes);
613 #undef e1
855 #define e1 (*ep1)
857 	if (e1->type == type) {
858 		expr_extract_eq(type, ep, &e1->left.expr, &e2);
859 		expr_extract_eq(type, ep, &e1->right.expr, &e2);
867 	if (expr_eq(e1, e2)) {
868 		*ep = *ep ? expr_alloc_two(type, *ep, e1) : e1;
871 			e1 = expr_alloc_symbol(&symbol_yes);
874 			e1 = expr_alloc_symbol(&symbol_no);
878 #undef e1
884 	struct expr *e1, *e2;
894 		e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
897 			e = expr_alloc_two(E_AND, e1, e2);
899 			e = expr_alloc_two(E_OR, e1, e2);
904 		e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
907 			e = expr_alloc_two(E_OR, e1, e2);
909 			e = expr_alloc_two(E_AND, e1, e2);

Indexes created Thu Nov 07 10:32:03 CST 2024