yann@1: /*
yann@1:  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
yann@1:  * Released under the terms of the GNU GPL v2.0.
yann@1:  */
yann@1: 
yann@1: #include <stdio.h>
yann@1: #include <stdlib.h>
yann@1: #include <string.h>
yann@1: 
yann@1: #define LKC_DIRECT_LINK
yann@1: #include "lkc.h"
yann@1: 
yann@1: #define DEBUG_EXPR	0
yann@1: 
yann@1: struct expr *expr_alloc_symbol(struct symbol *sym)
yann@1: {
yann@1: 	struct expr *e = malloc(sizeof(*e));
yann@1: 	memset(e, 0, sizeof(*e));
yann@1: 	e->type = E_SYMBOL;
yann@1: 	e->left.sym = sym;
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
yann@1: {
yann@1: 	struct expr *e = malloc(sizeof(*e));
yann@1: 	memset(e, 0, sizeof(*e));
yann@1: 	e->type = type;
yann@1: 	e->left.expr = ce;
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
yann@1: {
yann@1: 	struct expr *e = malloc(sizeof(*e));
yann@1: 	memset(e, 0, sizeof(*e));
yann@1: 	e->type = type;
yann@1: 	e->left.expr = e1;
yann@1: 	e->right.expr = e2;
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
yann@1: {
yann@1: 	struct expr *e = malloc(sizeof(*e));
yann@1: 	memset(e, 0, sizeof(*e));
yann@1: 	e->type = type;
yann@1: 	e->left.sym = s1;
yann@1: 	e->right.sym = s2;
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
yann@1: {
yann@1: 	if (!e1)
yann@1: 		return e2;
yann@1: 	return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
yann@1: }
yann@1: 
yann@1: struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
yann@1: {
yann@1: 	if (!e1)
yann@1: 		return e2;
yann@1: 	return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
yann@1: }
yann@1: 
yann@2448: struct expr *expr_copy(const struct expr *org)
yann@1: {
yann@1: 	struct expr *e;
yann@1: 
yann@1: 	if (!org)
yann@1: 		return NULL;
yann@1: 
yann@1: 	e = malloc(sizeof(*org));
yann@1: 	memcpy(e, org, sizeof(*org));
yann@1: 	switch (org->type) {
yann@1: 	case E_SYMBOL:
yann@1: 		e->left = org->left;
yann@1: 		break;
yann@1: 	case E_NOT:
yann@1: 		e->left.expr = expr_copy(org->left.expr);
yann@1: 		break;
yann@1: 	case E_EQUAL:
yann@1: 	case E_UNEQUAL:
yann@1: 		e->left.sym = org->left.sym;
yann@1: 		e->right.sym = org->right.sym;
yann@1: 		break;
yann@1: 	case E_AND:
yann@1: 	case E_OR:
yann@943: 	case E_LIST:
yann@1: 		e->left.expr = expr_copy(org->left.expr);
yann@1: 		e->right.expr = expr_copy(org->right.expr);
yann@1: 		break;
yann@1: 	default:
yann@1: 		printf("can't copy type %d\n", e->type);
yann@1: 		free(e);
yann@1: 		e = NULL;
yann@1: 		break;
yann@1: 	}
yann@1: 
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: void expr_free(struct expr *e)
yann@1: {
yann@1: 	if (!e)
yann@1: 		return;
yann@1: 
yann@1: 	switch (e->type) {
yann@1: 	case E_SYMBOL:
yann@1: 		break;
yann@1: 	case E_NOT:
yann@1: 		expr_free(e->left.expr);
yann@1: 		return;
yann@1: 	case E_EQUAL:
yann@1: 	case E_UNEQUAL:
yann@1: 		break;
yann@1: 	case E_OR:
yann@1: 	case E_AND:
yann@1: 		expr_free(e->left.expr);
yann@1: 		expr_free(e->right.expr);
yann@1: 		break;
yann@1: 	default:
yann@1: 		printf("how to free type %d?\n", e->type);
yann@1: 		break;
yann@1: 	}
yann@1: 	free(e);
yann@1: }
yann@1: 
yann@1: static int trans_count;
yann@1: 
yann@1: #define e1 (*ep1)
yann@1: #define e2 (*ep2)
yann@1: 
yann@1: static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: 	if (e1->type == type) {
yann@1: 		__expr_eliminate_eq(type, &e1->left.expr, &e2);
yann@1: 		__expr_eliminate_eq(type, &e1->right.expr, &e2);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (e2->type == type) {
yann@1: 		__expr_eliminate_eq(type, &e1, &e2->left.expr);
yann@1: 		__expr_eliminate_eq(type, &e1, &e2->right.expr);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
yann@1: 	    e1->left.sym == e2->left.sym &&
yann@1: 	    (e1->left.sym == &symbol_yes || e1->left.sym == &symbol_no))
yann@1: 		return;
yann@1: 	if (!expr_eq(e1, e2))
yann@1: 		return;
yann@1: 	trans_count++;
yann@1: 	expr_free(e1); expr_free(e2);
yann@1: 	switch (type) {
yann@1: 	case E_OR:
yann@1: 		e1 = expr_alloc_symbol(&symbol_no);
yann@1: 		e2 = expr_alloc_symbol(&symbol_no);
yann@1: 		break;
yann@1: 	case E_AND:
yann@1: 		e1 = expr_alloc_symbol(&symbol_yes);
yann@1: 		e2 = expr_alloc_symbol(&symbol_yes);
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: }
yann@1: 
yann@1: void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: 	if (!e1 || !e2)
yann@1: 		return;
yann@1: 	switch (e1->type) {
yann@1: 	case E_OR:
yann@1: 	case E_AND:
yann@1: 		__expr_eliminate_eq(e1->type, ep1, ep2);
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 	if (e1->type != e2->type) switch (e2->type) {
yann@1: 	case E_OR:
yann@1: 	case E_AND:
yann@1: 		__expr_eliminate_eq(e2->type, ep1, ep2);
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 	e1 = expr_eliminate_yn(e1);
yann@1: 	e2 = expr_eliminate_yn(e2);
yann@1: }
yann@1: 
yann@1: #undef e1
yann@1: #undef e2
yann@1: 
yann@1: int expr_eq(struct expr *e1, struct expr *e2)
yann@1: {
yann@1: 	int res, old_count;
yann@1: 
yann@1: 	if (e1->type != e2->type)
yann@1: 		return 0;
yann@1: 	switch (e1->type) {
yann@1: 	case E_EQUAL:
yann@1: 	case E_UNEQUAL:
yann@1: 		return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
yann@1: 	case E_SYMBOL:
yann@1: 		return e1->left.sym == e2->left.sym;
yann@1: 	case E_NOT:
yann@1: 		return expr_eq(e1->left.expr, e2->left.expr);
yann@1: 	case E_AND:
yann@1: 	case E_OR:
yann@1: 		e1 = expr_copy(e1);
yann@1: 		e2 = expr_copy(e2);
yann@1: 		old_count = trans_count;
yann@1: 		expr_eliminate_eq(&e1, &e2);
yann@1: 		res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
yann@1: 		       e1->left.sym == e2->left.sym);
yann@1: 		expr_free(e1);
yann@1: 		expr_free(e2);
yann@1: 		trans_count = old_count;
yann@1: 		return res;
yann@943: 	case E_LIST:
yann@1: 	case E_RANGE:
yann@1: 	case E_NONE:
yann@1: 		/* panic */;
yann@1: 	}
yann@1: 
yann@1: 	if (DEBUG_EXPR) {
yann@1: 		expr_fprint(e1, stdout);
yann@1: 		printf(" = ");
yann@1: 		expr_fprint(e2, stdout);
yann@1: 		printf(" ?\n");
yann@1: 	}
yann@1: 
yann@1: 	return 0;
yann@1: }
yann@1: 
yann@1: struct expr *expr_eliminate_yn(struct expr *e)
yann@1: {
yann@1: 	struct expr *tmp;
yann@1: 
yann@1: 	if (e) switch (e->type) {
yann@1: 	case E_AND:
yann@1: 		e->left.expr = expr_eliminate_yn(e->left.expr);
yann@1: 		e->right.expr = expr_eliminate_yn(e->right.expr);
yann@1: 		if (e->left.expr->type == E_SYMBOL) {
yann@1: 			if (e->left.expr->left.sym == &symbol_no) {
yann@1: 				expr_free(e->left.expr);
yann@1: 				expr_free(e->right.expr);
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_no;
yann@1: 				e->right.expr = NULL;
yann@1: 				return e;
yann@1: 			} else if (e->left.expr->left.sym == &symbol_yes) {
yann@1: 				free(e->left.expr);
yann@1: 				tmp = e->right.expr;
yann@1: 				*e = *(e->right.expr);
yann@1: 				free(tmp);
yann@1: 				return e;
yann@1: 			}
yann@1: 		}
yann@1: 		if (e->right.expr->type == E_SYMBOL) {
yann@1: 			if (e->right.expr->left.sym == &symbol_no) {
yann@1: 				expr_free(e->left.expr);
yann@1: 				expr_free(e->right.expr);
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_no;
yann@1: 				e->right.expr = NULL;
yann@1: 				return e;
yann@1: 			} else if (e->right.expr->left.sym == &symbol_yes) {
yann@1: 				free(e->right.expr);
yann@1: 				tmp = e->left.expr;
yann@1: 				*e = *(e->left.expr);
yann@1: 				free(tmp);
yann@1: 				return e;
yann@1: 			}
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_OR:
yann@1: 		e->left.expr = expr_eliminate_yn(e->left.expr);
yann@1: 		e->right.expr = expr_eliminate_yn(e->right.expr);
yann@1: 		if (e->left.expr->type == E_SYMBOL) {
yann@1: 			if (e->left.expr->left.sym == &symbol_no) {
yann@1: 				free(e->left.expr);
yann@1: 				tmp = e->right.expr;
yann@1: 				*e = *(e->right.expr);
yann@1: 				free(tmp);
yann@1: 				return e;
yann@1: 			} else if (e->left.expr->left.sym == &symbol_yes) {
yann@1: 				expr_free(e->left.expr);
yann@1: 				expr_free(e->right.expr);
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_yes;
yann@1: 				e->right.expr = NULL;
yann@1: 				return e;
yann@1: 			}
yann@1: 		}
yann@1: 		if (e->right.expr->type == E_SYMBOL) {
yann@1: 			if (e->right.expr->left.sym == &symbol_no) {
yann@1: 				free(e->right.expr);
yann@1: 				tmp = e->left.expr;
yann@1: 				*e = *(e->left.expr);
yann@1: 				free(tmp);
yann@1: 				return e;
yann@1: 			} else if (e->right.expr->left.sym == &symbol_yes) {
yann@1: 				expr_free(e->left.expr);
yann@1: 				expr_free(e->right.expr);
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_yes;
yann@1: 				e->right.expr = NULL;
yann@1: 				return e;
yann@1: 			}
yann@1: 		}
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: /*
yann@1:  * bool FOO!=n => FOO
yann@1:  */
yann@1: struct expr *expr_trans_bool(struct expr *e)
yann@1: {
yann@1: 	if (!e)
yann@1: 		return NULL;
yann@1: 	switch (e->type) {
yann@1: 	case E_AND:
yann@1: 	case E_OR:
yann@1: 	case E_NOT:
yann@1: 		e->left.expr = expr_trans_bool(e->left.expr);
yann@1: 		e->right.expr = expr_trans_bool(e->right.expr);
yann@1: 		break;
yann@1: 	case E_UNEQUAL:
yann@1: 		// FOO!=n -> FOO
yann@1: 		if (e->left.sym->type == S_TRISTATE) {
yann@1: 			if (e->right.sym == &symbol_no) {
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->right.sym = NULL;
yann@1: 			}
yann@1: 		}
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: /*
yann@1:  * e1 || e2 -> ?
yann@1:  */
yann@2448: static struct expr *expr_join_or(struct expr *e1, struct expr *e2)
yann@1: {
yann@1: 	struct expr *tmp;
yann@1: 	struct symbol *sym1, *sym2;
yann@1: 
yann@1: 	if (expr_eq(e1, e2))
yann@1: 		return expr_copy(e1);
yann@1: 	if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
yann@1: 		return NULL;
yann@1: 	if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
yann@1: 		return NULL;
yann@1: 	if (e1->type == E_NOT) {
yann@1: 		tmp = e1->left.expr;
yann@1: 		if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
yann@1: 			return NULL;
yann@1: 		sym1 = tmp->left.sym;
yann@1: 	} else
yann@1: 		sym1 = e1->left.sym;
yann@1: 	if (e2->type == E_NOT) {
yann@1: 		if (e2->left.expr->type != E_SYMBOL)
yann@1: 			return NULL;
yann@1: 		sym2 = e2->left.expr->left.sym;
yann@1: 	} else
yann@1: 		sym2 = e2->left.sym;
yann@1: 	if (sym1 != sym2)
yann@1: 		return NULL;
yann@1: 	if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
yann@1: 		return NULL;
yann@1: 	if (sym1->type == S_TRISTATE) {
yann@1: 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
yann@1: 		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
yann@1: 		     (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
yann@1: 			// (a='y') || (a='m') -> (a!='n')
yann@1: 			return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_no);
yann@1: 		}
yann@1: 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
yann@1: 		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
yann@1: 		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
yann@1: 			// (a='y') || (a='n') -> (a!='m')
yann@1: 			return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_mod);
yann@1: 		}
yann@1: 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
yann@1: 		    ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
yann@1: 		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
yann@1: 			// (a='m') || (a='n') -> (a!='y')
yann@1: 			return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_yes);
yann@1: 		}
yann@1: 	}
yann@1: 	if (sym1->type == S_BOOLEAN && sym1 == sym2) {
yann@1: 		if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
yann@1: 		    (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
yann@1: 			return expr_alloc_symbol(&symbol_yes);
yann@1: 	}
yann@1: 
yann@1: 	if (DEBUG_EXPR) {
yann@1: 		printf("optimize (");
yann@1: 		expr_fprint(e1, stdout);
yann@1: 		printf(") || (");
yann@1: 		expr_fprint(e2, stdout);
yann@1: 		printf(")?\n");
yann@1: 	}
yann@1: 	return NULL;
yann@1: }
yann@1: 
yann@2448: static struct expr *expr_join_and(struct expr *e1, struct expr *e2)
yann@1: {
yann@1: 	struct expr *tmp;
yann@1: 	struct symbol *sym1, *sym2;
yann@1: 
yann@1: 	if (expr_eq(e1, e2))
yann@1: 		return expr_copy(e1);
yann@1: 	if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
yann@1: 		return NULL;
yann@1: 	if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
yann@1: 		return NULL;
yann@1: 	if (e1->type == E_NOT) {
yann@1: 		tmp = e1->left.expr;
yann@1: 		if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
yann@1: 			return NULL;
yann@1: 		sym1 = tmp->left.sym;
yann@1: 	} else
yann@1: 		sym1 = e1->left.sym;
yann@1: 	if (e2->type == E_NOT) {
yann@1: 		if (e2->left.expr->type != E_SYMBOL)
yann@1: 			return NULL;
yann@1: 		sym2 = e2->left.expr->left.sym;
yann@1: 	} else
yann@1: 		sym2 = e2->left.sym;
yann@1: 	if (sym1 != sym2)
yann@1: 		return NULL;
yann@1: 	if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
yann@1: 		return NULL;
yann@1: 
yann@1: 	if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
yann@1: 	    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
yann@1: 		// (a) && (a='y') -> (a='y')
yann@1: 		return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
yann@1: 
yann@1: 	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
yann@1: 	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
yann@1: 		// (a) && (a!='n') -> (a)
yann@1: 		return expr_alloc_symbol(sym1);
yann@1: 
yann@1: 	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
yann@1: 	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
yann@1: 		// (a) && (a!='m') -> (a='y')
yann@1: 		return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
yann@1: 
yann@1: 	if (sym1->type == S_TRISTATE) {
yann@1: 		if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
yann@1: 			// (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
yann@1: 			sym2 = e1->right.sym;
yann@1: 			if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
yann@1: 				return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
yann@1: 							     : expr_alloc_symbol(&symbol_no);
yann@1: 		}
yann@1: 		if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
yann@1: 			// (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
yann@1: 			sym2 = e2->right.sym;
yann@1: 			if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
yann@1: 				return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
yann@1: 							     : expr_alloc_symbol(&symbol_no);
yann@1: 		}
yann@1: 		if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
yann@1: 			   ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
yann@1: 			    (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
yann@1: 			// (a!='y') && (a!='n') -> (a='m')
yann@1: 			return expr_alloc_comp(E_EQUAL, sym1, &symbol_mod);
yann@1: 
yann@1: 		if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
yann@1: 			   ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
yann@1: 			    (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
yann@1: 			// (a!='y') && (a!='m') -> (a='n')
yann@1: 			return expr_alloc_comp(E_EQUAL, sym1, &symbol_no);
yann@1: 
yann@1: 		if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL &&
yann@1: 			   ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
yann@1: 			    (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
yann@1: 			// (a!='m') && (a!='n') -> (a='m')
yann@1: 			return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
yann@1: 
yann@1: 		if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
yann@1: 		    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
yann@1: 		    (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
yann@1: 		    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
yann@1: 			return NULL;
yann@1: 	}
yann@1: 
yann@1: 	if (DEBUG_EXPR) {
yann@1: 		printf("optimize (");
yann@1: 		expr_fprint(e1, stdout);
yann@1: 		printf(") && (");
yann@1: 		expr_fprint(e2, stdout);
yann@1: 		printf(")?\n");
yann@1: 	}
yann@1: 	return NULL;
yann@1: }
yann@1: 
yann@1: static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: #define e1 (*ep1)
yann@1: #define e2 (*ep2)
yann@1: 	struct expr *tmp;
yann@1: 
yann@1: 	if (e1->type == type) {
yann@1: 		expr_eliminate_dups1(type, &e1->left.expr, &e2);
yann@1: 		expr_eliminate_dups1(type, &e1->right.expr, &e2);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (e2->type == type) {
yann@1: 		expr_eliminate_dups1(type, &e1, &e2->left.expr);
yann@1: 		expr_eliminate_dups1(type, &e1, &e2->right.expr);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (e1 == e2)
yann@1: 		return;
yann@1: 
yann@1: 	switch (e1->type) {
yann@1: 	case E_OR: case E_AND:
yann@1: 		expr_eliminate_dups1(e1->type, &e1, &e1);
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 
yann@1: 	switch (type) {
yann@1: 	case E_OR:
yann@1: 		tmp = expr_join_or(e1, e2);
yann@1: 		if (tmp) {
yann@1: 			expr_free(e1); expr_free(e2);
yann@1: 			e1 = expr_alloc_symbol(&symbol_no);
yann@1: 			e2 = tmp;
yann@1: 			trans_count++;
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_AND:
yann@1: 		tmp = expr_join_and(e1, e2);
yann@1: 		if (tmp) {
yann@1: 			expr_free(e1); expr_free(e2);
yann@1: 			e1 = expr_alloc_symbol(&symbol_yes);
yann@1: 			e2 = tmp;
yann@1: 			trans_count++;
yann@1: 		}
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: #undef e1
yann@1: #undef e2
yann@1: }
yann@1: 
yann@1: static void expr_eliminate_dups2(enum expr_type type, struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: #define e1 (*ep1)
yann@1: #define e2 (*ep2)
yann@1: 	struct expr *tmp, *tmp1, *tmp2;
yann@1: 
yann@1: 	if (e1->type == type) {
yann@1: 		expr_eliminate_dups2(type, &e1->left.expr, &e2);
yann@1: 		expr_eliminate_dups2(type, &e1->right.expr, &e2);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (e2->type == type) {
yann@1: 		expr_eliminate_dups2(type, &e1, &e2->left.expr);
yann@1: 		expr_eliminate_dups2(type, &e1, &e2->right.expr);
yann@1: 	}
yann@1: 	if (e1 == e2)
yann@1: 		return;
yann@1: 
yann@1: 	switch (e1->type) {
yann@1: 	case E_OR:
yann@1: 		expr_eliminate_dups2(e1->type, &e1, &e1);
yann@1: 		// (FOO || BAR) && (!FOO && !BAR) -> n
yann@1: 		tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
yann@1: 		tmp2 = expr_copy(e2);
yann@1: 		tmp = expr_extract_eq_and(&tmp1, &tmp2);
yann@1: 		if (expr_is_yes(tmp1)) {
yann@1: 			expr_free(e1);
yann@1: 			e1 = expr_alloc_symbol(&symbol_no);
yann@1: 			trans_count++;
yann@1: 		}
yann@1: 		expr_free(tmp2);
yann@1: 		expr_free(tmp1);
yann@1: 		expr_free(tmp);
yann@1: 		break;
yann@1: 	case E_AND:
yann@1: 		expr_eliminate_dups2(e1->type, &e1, &e1);
yann@1: 		// (FOO && BAR) || (!FOO || !BAR) -> y
yann@1: 		tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
yann@1: 		tmp2 = expr_copy(e2);
yann@1: 		tmp = expr_extract_eq_or(&tmp1, &tmp2);
yann@1: 		if (expr_is_no(tmp1)) {
yann@1: 			expr_free(e1);
yann@1: 			e1 = expr_alloc_symbol(&symbol_yes);
yann@1: 			trans_count++;
yann@1: 		}
yann@1: 		expr_free(tmp2);
yann@1: 		expr_free(tmp1);
yann@1: 		expr_free(tmp);
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: #undef e1
yann@1: #undef e2
yann@1: }
yann@1: 
yann@1: struct expr *expr_eliminate_dups(struct expr *e)
yann@1: {
yann@1: 	int oldcount;
yann@1: 	if (!e)
yann@1: 		return e;
yann@1: 
yann@1: 	oldcount = trans_count;
yann@1: 	while (1) {
yann@1: 		trans_count = 0;
yann@1: 		switch (e->type) {
yann@1: 		case E_OR: case E_AND:
yann@1: 			expr_eliminate_dups1(e->type, &e, &e);
yann@1: 			expr_eliminate_dups2(e->type, &e, &e);
yann@1: 		default:
yann@1: 			;
yann@1: 		}
yann@1: 		if (!trans_count)
yann@1: 			break;
yann@1: 		e = expr_eliminate_yn(e);
yann@1: 	}
yann@1: 	trans_count = oldcount;
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: struct expr *expr_transform(struct expr *e)
yann@1: {
yann@1: 	struct expr *tmp;
yann@1: 
yann@1: 	if (!e)
yann@1: 		return NULL;
yann@1: 	switch (e->type) {
yann@1: 	case E_EQUAL:
yann@1: 	case E_UNEQUAL:
yann@1: 	case E_SYMBOL:
yann@943: 	case E_LIST:
yann@1: 		break;
yann@1: 	default:
yann@1: 		e->left.expr = expr_transform(e->left.expr);
yann@1: 		e->right.expr = expr_transform(e->right.expr);
yann@1: 	}
yann@1: 
yann@1: 	switch (e->type) {
yann@1: 	case E_EQUAL:
yann@1: 		if (e->left.sym->type != S_BOOLEAN)
yann@1: 			break;
yann@1: 		if (e->right.sym == &symbol_no) {
yann@1: 			e->type = E_NOT;
yann@1: 			e->left.expr = expr_alloc_symbol(e->left.sym);
yann@1: 			e->right.sym = NULL;
yann@1: 			break;
yann@1: 		}
yann@1: 		if (e->right.sym == &symbol_mod) {
yann@1: 			printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
yann@1: 			e->type = E_SYMBOL;
yann@1: 			e->left.sym = &symbol_no;
yann@1: 			e->right.sym = NULL;
yann@1: 			break;
yann@1: 		}
yann@1: 		if (e->right.sym == &symbol_yes) {
yann@1: 			e->type = E_SYMBOL;
yann@1: 			e->right.sym = NULL;
yann@1: 			break;
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_UNEQUAL:
yann@1: 		if (e->left.sym->type != S_BOOLEAN)
yann@1: 			break;
yann@1: 		if (e->right.sym == &symbol_no) {
yann@1: 			e->type = E_SYMBOL;
yann@1: 			e->right.sym = NULL;
yann@1: 			break;
yann@1: 		}
yann@1: 		if (e->right.sym == &symbol_mod) {
yann@1: 			printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
yann@1: 			e->type = E_SYMBOL;
yann@1: 			e->left.sym = &symbol_yes;
yann@1: 			e->right.sym = NULL;
yann@1: 			break;
yann@1: 		}
yann@1: 		if (e->right.sym == &symbol_yes) {
yann@1: 			e->type = E_NOT;
yann@1: 			e->left.expr = expr_alloc_symbol(e->left.sym);
yann@1: 			e->right.sym = NULL;
yann@1: 			break;
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_NOT:
yann@1: 		switch (e->left.expr->type) {
yann@1: 		case E_NOT:
yann@1: 			// !!a -> a
yann@1: 			tmp = e->left.expr->left.expr;
yann@1: 			free(e->left.expr);
yann@1: 			free(e);
yann@1: 			e = tmp;
yann@1: 			e = expr_transform(e);
yann@1: 			break;
yann@1: 		case E_EQUAL:
yann@1: 		case E_UNEQUAL:
yann@1: 			// !a='x' -> a!='x'
yann@1: 			tmp = e->left.expr;
yann@1: 			free(e);
yann@1: 			e = tmp;
yann@1: 			e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL;
yann@1: 			break;
yann@1: 		case E_OR:
yann@1: 			// !(a || b) -> !a && !b
yann@1: 			tmp = e->left.expr;
yann@1: 			e->type = E_AND;
yann@1: 			e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
yann@1: 			tmp->type = E_NOT;
yann@1: 			tmp->right.expr = NULL;
yann@1: 			e = expr_transform(e);
yann@1: 			break;
yann@1: 		case E_AND:
yann@1: 			// !(a && b) -> !a || !b
yann@1: 			tmp = e->left.expr;
yann@1: 			e->type = E_OR;
yann@1: 			e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
yann@1: 			tmp->type = E_NOT;
yann@1: 			tmp->right.expr = NULL;
yann@1: 			e = expr_transform(e);
yann@1: 			break;
yann@1: 		case E_SYMBOL:
yann@1: 			if (e->left.expr->left.sym == &symbol_yes) {
yann@1: 				// !'y' -> 'n'
yann@1: 				tmp = e->left.expr;
yann@1: 				free(e);
yann@1: 				e = tmp;
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_no;
yann@1: 				break;
yann@1: 			}
yann@1: 			if (e->left.expr->left.sym == &symbol_mod) {
yann@1: 				// !'m' -> 'm'
yann@1: 				tmp = e->left.expr;
yann@1: 				free(e);
yann@1: 				e = tmp;
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_mod;
yann@1: 				break;
yann@1: 			}
yann@1: 			if (e->left.expr->left.sym == &symbol_no) {
yann@1: 				// !'n' -> 'y'
yann@1: 				tmp = e->left.expr;
yann@1: 				free(e);
yann@1: 				e = tmp;
yann@1: 				e->type = E_SYMBOL;
yann@1: 				e->left.sym = &symbol_yes;
yann@1: 				break;
yann@1: 			}
yann@1: 			break;
yann@1: 		default:
yann@1: 			;
yann@1: 		}
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 	return e;
yann@1: }
yann@1: 
yann@1: int expr_contains_symbol(struct expr *dep, struct symbol *sym)
yann@1: {
yann@1: 	if (!dep)
yann@1: 		return 0;
yann@1: 
yann@1: 	switch (dep->type) {
yann@1: 	case E_AND:
yann@1: 	case E_OR:
yann@1: 		return expr_contains_symbol(dep->left.expr, sym) ||
yann@1: 		       expr_contains_symbol(dep->right.expr, sym);
yann@1: 	case E_SYMBOL:
yann@1: 		return dep->left.sym == sym;
yann@1: 	case E_EQUAL:
yann@1: 	case E_UNEQUAL:
yann@1: 		return dep->left.sym == sym ||
yann@1: 		       dep->right.sym == sym;
yann@1: 	case E_NOT:
yann@1: 		return expr_contains_symbol(dep->left.expr, sym);
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1: 	return 0;
yann@1: }
yann@1: 
yann@1: bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
yann@1: {
yann@1: 	if (!dep)
yann@1: 		return false;
yann@1: 
yann@1: 	switch (dep->type) {
yann@1: 	case E_AND:
yann@1: 		return expr_depends_symbol(dep->left.expr, sym) ||
yann@1: 		       expr_depends_symbol(dep->right.expr, sym);
yann@1: 	case E_SYMBOL:
yann@1: 		return dep->left.sym == sym;
yann@1: 	case E_EQUAL:
yann@1: 		if (dep->left.sym == sym) {
yann@1: 			if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
yann@1: 				return true;
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_UNEQUAL:
yann@1: 		if (dep->left.sym == sym) {
yann@1: 			if (dep->right.sym == &symbol_no)
yann@1: 				return true;
yann@1: 		}
yann@1: 		break;
yann@1: 	default:
yann@1: 		;
yann@1: 	}
yann@1:  	return false;
yann@1: }
yann@1: 
yann@1: struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: 	struct expr *tmp = NULL;
yann@1: 	expr_extract_eq(E_AND, &tmp, ep1, ep2);
yann@1: 	if (tmp) {
yann@1: 		*ep1 = expr_eliminate_yn(*ep1);
yann@1: 		*ep2 = expr_eliminate_yn(*ep2);
yann@1: 	}
yann@1: 	return tmp;
yann@1: }
yann@1: 
yann@1: struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: 	struct expr *tmp = NULL;
yann@1: 	expr_extract_eq(E_OR, &tmp, ep1, ep2);
yann@1: 	if (tmp) {
yann@1: 		*ep1 = expr_eliminate_yn(*ep1);
yann@1: 		*ep2 = expr_eliminate_yn(*ep2);
yann@1: 	}
yann@1: 	return tmp;
yann@1: }
yann@1: 
yann@1: void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
yann@1: {
yann@1: #define e1 (*ep1)
yann@1: #define e2 (*ep2)
yann@1: 	if (e1->type == type) {
yann@1: 		expr_extract_eq(type, ep, &e1->left.expr, &e2);
yann@1: 		expr_extract_eq(type, ep, &e1->right.expr, &e2);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (e2->type == type) {
yann@1: 		expr_extract_eq(type, ep, ep1, &e2->left.expr);
yann@1: 		expr_extract_eq(type, ep, ep1, &e2->right.expr);
yann@1: 		return;
yann@1: 	}
yann@1: 	if (expr_eq(e1, e2)) {
yann@1: 		*ep = *ep ? expr_alloc_two(type, *ep, e1) : e1;
yann@1: 		expr_free(e2);
yann@1: 		if (type == E_AND) {
yann@1: 			e1 = expr_alloc_symbol(&symbol_yes);
yann@1: 			e2 = expr_alloc_symbol(&symbol_yes);
yann@1: 		} else if (type == E_OR) {
yann@1: 			e1 = expr_alloc_symbol(&symbol_no);
yann@1: 			e2 = expr_alloc_symbol(&symbol_no);
yann@1: 		}
yann@1: 	}
yann@1: #undef e1
yann@1: #undef e2
yann@1: }
yann@1: 
yann@1: struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
yann@1: {
yann@1: 	struct expr *e1, *e2;
yann@1: 
yann@1: 	if (!e) {
yann@1: 		e = expr_alloc_symbol(sym);
yann@1: 		if (type == E_UNEQUAL)
yann@1: 			e = expr_alloc_one(E_NOT, e);
yann@1: 		return e;
yann@1: 	}
yann@1: 	switch (e->type) {
yann@1: 	case E_AND:
yann@1: 		e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
yann@1: 		e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
yann@1: 		if (sym == &symbol_yes)
yann@1: 			e = expr_alloc_two(E_AND, e1, e2);
yann@1: 		if (sym == &symbol_no)
yann@1: 			e = expr_alloc_two(E_OR, e1, e2);
yann@1: 		if (type == E_UNEQUAL)
yann@1: 			e = expr_alloc_one(E_NOT, e);
yann@1: 		return e;
yann@1: 	case E_OR:
yann@1: 		e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
yann@1: 		e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
yann@1: 		if (sym == &symbol_yes)
yann@1: 			e = expr_alloc_two(E_OR, e1, e2);
yann@1: 		if (sym == &symbol_no)
yann@1: 			e = expr_alloc_two(E_AND, e1, e2);
yann@1: 		if (type == E_UNEQUAL)
yann@1: 			e = expr_alloc_one(E_NOT, e);
yann@1: 		return e;
yann@1: 	case E_NOT:
yann@1: 		return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
yann@1: 	case E_UNEQUAL:
yann@1: 	case E_EQUAL:
yann@1: 		if (type == E_EQUAL) {
yann@1: 			if (sym == &symbol_yes)
yann@1: 				return expr_copy(e);
yann@1: 			if (sym == &symbol_mod)
yann@1: 				return expr_alloc_symbol(&symbol_no);
yann@1: 			if (sym == &symbol_no)
yann@1: 				return expr_alloc_one(E_NOT, expr_copy(e));
yann@1: 		} else {
yann@1: 			if (sym == &symbol_yes)
yann@1: 				return expr_alloc_one(E_NOT, expr_copy(e));
yann@1: 			if (sym == &symbol_mod)
yann@1: 				return expr_alloc_symbol(&symbol_yes);
yann@1: 			if (sym == &symbol_no)
yann@1: 				return expr_copy(e);
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_SYMBOL:
yann@1: 		return expr_alloc_comp(type, e->left.sym, sym);
yann@943: 	case E_LIST:
yann@1: 	case E_RANGE:
yann@1: 	case E_NONE:
yann@1: 		/* panic */;
yann@1: 	}
yann@1: 	return NULL;
yann@1: }
yann@1: 
yann@1: tristate expr_calc_value(struct expr *e)
yann@1: {
yann@1: 	tristate val1, val2;
yann@1: 	const char *str1, *str2;
yann@1: 
yann@1: 	if (!e)
yann@1: 		return yes;
yann@1: 
yann@1: 	switch (e->type) {
yann@1: 	case E_SYMBOL:
yann@1: 		sym_calc_value(e->left.sym);
yann@1: 		return e->left.sym->curr.tri;
yann@1: 	case E_AND:
yann@1: 		val1 = expr_calc_value(e->left.expr);
yann@1: 		val2 = expr_calc_value(e->right.expr);
yann@943: 		return EXPR_AND(val1, val2);
yann@1: 	case E_OR:
yann@1: 		val1 = expr_calc_value(e->left.expr);
yann@1: 		val2 = expr_calc_value(e->right.expr);
yann@943: 		return EXPR_OR(val1, val2);
yann@1: 	case E_NOT:
yann@1: 		val1 = expr_calc_value(e->left.expr);
yann@943: 		return EXPR_NOT(val1);
yann@1: 	case E_EQUAL:
yann@1: 		sym_calc_value(e->left.sym);
yann@1: 		sym_calc_value(e->right.sym);
yann@1: 		str1 = sym_get_string_value(e->left.sym);
yann@1: 		str2 = sym_get_string_value(e->right.sym);
yann@1: 		return !strcmp(str1, str2) ? yes : no;
yann@1: 	case E_UNEQUAL:
yann@1: 		sym_calc_value(e->left.sym);
yann@1: 		sym_calc_value(e->right.sym);
yann@1: 		str1 = sym_get_string_value(e->left.sym);
yann@1: 		str2 = sym_get_string_value(e->right.sym);
yann@1: 		return !strcmp(str1, str2) ? no : yes;
yann@1: 	default:
yann@1: 		printf("expr_calc_value: %d?\n", e->type);
yann@1: 		return no;
yann@1: 	}
yann@1: }
yann@1: 
yann@1: int expr_compare_type(enum expr_type t1, enum expr_type t2)
yann@1: {
yann@1: #if 0
yann@1: 	return 1;
yann@1: #else
yann@1: 	if (t1 == t2)
yann@1: 		return 0;
yann@1: 	switch (t1) {
yann@1: 	case E_EQUAL:
yann@1: 	case E_UNEQUAL:
yann@1: 		if (t2 == E_NOT)
yann@1: 			return 1;
yann@1: 	case E_NOT:
yann@1: 		if (t2 == E_AND)
yann@1: 			return 1;
yann@1: 	case E_AND:
yann@1: 		if (t2 == E_OR)
yann@1: 			return 1;
yann@1: 	case E_OR:
yann@943: 		if (t2 == E_LIST)
yann@1: 			return 1;
yann@943: 	case E_LIST:
yann@1: 		if (t2 == 0)
yann@1: 			return 1;
yann@1: 	default:
yann@1: 		return -1;
yann@1: 	}
yann@1: 	printf("[%dgt%d?]", t1, t2);
yann@1: 	return 0;
yann@1: #endif
yann@1: }
yann@1: 
yann@2448: static inline struct expr *
yann@2448: expr_get_leftmost_symbol(const struct expr *e)
yann@2448: {
yann@2448: 
yann@2448: 	if (e == NULL)
yann@2448: 		return NULL;
yann@2448: 
yann@2448: 	while (e->type != E_SYMBOL)
yann@2448: 		e = e->left.expr;
yann@2448: 
yann@2448: 	return expr_copy(e);
yann@2448: }
yann@2448: 
yann@2448: /*
yann@2448:  * Given expression `e1' and `e2', returns the leaf of the longest
yann@2448:  * sub-expression of `e1' not containing 'e2.
yann@2448:  */
yann@2448: struct expr *expr_simplify_unmet_dep(struct expr *e1, struct expr *e2)
yann@2448: {
yann@2448: 	struct expr *ret;
yann@2448: 
yann@2448: 	switch (e1->type) {
yann@2448: 	case E_OR:
yann@2448: 		return expr_alloc_and(
yann@2448: 		    expr_simplify_unmet_dep(e1->left.expr, e2),
yann@2448: 		    expr_simplify_unmet_dep(e1->right.expr, e2));
yann@2448: 	case E_AND: {
yann@2448: 		struct expr *e;
yann@2448: 		e = expr_alloc_and(expr_copy(e1), expr_copy(e2));
yann@2448: 		e = expr_eliminate_dups(e);
yann@2448: 		ret = (!expr_eq(e, e1)) ? e1 : NULL;
yann@2448: 		expr_free(e);
yann@2448: 		break;
yann@2448: 		}
yann@2448: 	default:
yann@2448: 		ret = e1;
yann@2448: 		break;
yann@2448: 	}
yann@2448: 
yann@2448: 	return expr_get_leftmost_symbol(ret);
yann@2448: }
yann@2448: 
yann@1: void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *), void *data, int prevtoken)
yann@1: {
yann@1: 	if (!e) {
yann@1: 		fn(data, NULL, "y");
yann@1: 		return;
yann@1: 	}
yann@1: 
yann@1: 	if (expr_compare_type(prevtoken, e->type) > 0)
yann@1: 		fn(data, NULL, "(");
yann@1: 	switch (e->type) {
yann@1: 	case E_SYMBOL:
yann@1: 		if (e->left.sym->name)
yann@1: 			fn(data, e->left.sym, e->left.sym->name);
yann@1: 		else
yann@1: 			fn(data, NULL, "<choice>");
yann@1: 		break;
yann@1: 	case E_NOT:
yann@1: 		fn(data, NULL, "!");
yann@1: 		expr_print(e->left.expr, fn, data, E_NOT);
yann@1: 		break;
yann@1: 	case E_EQUAL:
yann@943: 		if (e->left.sym->name)
yann@943: 			fn(data, e->left.sym, e->left.sym->name);
yann@943: 		else
yann@943: 			fn(data, NULL, "<choice>");
yann@1: 		fn(data, NULL, "=");
yann@1: 		fn(data, e->right.sym, e->right.sym->name);
yann@1: 		break;
yann@1: 	case E_UNEQUAL:
yann@943: 		if (e->left.sym->name)
yann@943: 			fn(data, e->left.sym, e->left.sym->name);
yann@943: 		else
yann@943: 			fn(data, NULL, "<choice>");
yann@1: 		fn(data, NULL, "!=");
yann@1: 		fn(data, e->right.sym, e->right.sym->name);
yann@1: 		break;
yann@1: 	case E_OR:
yann@1: 		expr_print(e->left.expr, fn, data, E_OR);
yann@1: 		fn(data, NULL, " || ");
yann@1: 		expr_print(e->right.expr, fn, data, E_OR);
yann@1: 		break;
yann@1: 	case E_AND:
yann@1: 		expr_print(e->left.expr, fn, data, E_AND);
yann@1: 		fn(data, NULL, " && ");
yann@1: 		expr_print(e->right.expr, fn, data, E_AND);
yann@1: 		break;
yann@943: 	case E_LIST:
yann@1: 		fn(data, e->right.sym, e->right.sym->name);
yann@1: 		if (e->left.expr) {
yann@1: 			fn(data, NULL, " ^ ");
yann@943: 			expr_print(e->left.expr, fn, data, E_LIST);
yann@1: 		}
yann@1: 		break;
yann@1: 	case E_RANGE:
yann@1: 		fn(data, NULL, "[");
yann@1: 		fn(data, e->left.sym, e->left.sym->name);
yann@1: 		fn(data, NULL, " ");
yann@1: 		fn(data, e->right.sym, e->right.sym->name);
yann@1: 		fn(data, NULL, "]");
yann@1: 		break;
yann@1: 	default:
yann@1: 	  {
yann@1: 		char buf[32];
yann@1: 		sprintf(buf, "<unknown type %d>", e->type);
yann@1: 		fn(data, NULL, buf);
yann@1: 		break;
yann@1: 	  }
yann@1: 	}
yann@1: 	if (expr_compare_type(prevtoken, e->type) > 0)
yann@1: 		fn(data, NULL, ")");
yann@1: }
yann@1: 
yann@1: static void expr_print_file_helper(void *data, struct symbol *sym, const char *str)
yann@1: {
yann@2448: 	xfwrite(str, strlen(str), 1, data);
yann@1: }
yann@1: 
yann@1: void expr_fprint(struct expr *e, FILE *out)
yann@1: {
yann@1: 	expr_print(e, expr_print_file_helper, out, E_NONE);
yann@1: }
yann@1: 
yann@1: static void expr_print_gstr_helper(void *data, struct symbol *sym, const char *str)
yann@1: {
yann@2448: 	struct gstr *gs = (struct gstr*)data;
yann@2448: 	const char *sym_str = NULL;
yann@2448: 
yann@2448: 	if (sym)
yann@2448: 		sym_str = sym_get_string_value(sym);
yann@2448: 
yann@2448: 	if (gs->max_width) {
yann@2448: 		unsigned extra_length = strlen(str);
yann@2448: 		const char *last_cr = strrchr(gs->s, '\n');
yann@2448: 		unsigned last_line_length;
yann@2448: 
yann@2448: 		if (sym_str)
yann@2448: 			extra_length += 4 + strlen(sym_str);
yann@2448: 
yann@2448: 		if (!last_cr)
yann@2448: 			last_cr = gs->s;
yann@2448: 
yann@2448: 		last_line_length = strlen(gs->s) - (last_cr - gs->s);
yann@2448: 
yann@2448: 		if ((last_line_length + extra_length) > gs->max_width)
yann@2448: 			str_append(gs, "\\\n");
yann@2448: 	}
yann@2448: 
yann@2448: 	str_append(gs, str);
yann@2448: 	if (sym && sym->type != S_UNKNOWN)
yann@2448: 		str_printf(gs, " [=%s]", sym_str);
yann@1: }
yann@1: 
yann@1: void expr_gstr_print(struct expr *e, struct gstr *gs)
yann@1: {
yann@1: 	expr_print(e, expr_print_gstr_helper, gs, E_NONE);
yann@1: }