From d955226c2197578f69c510282a4e9ad1ea8fe771 Mon Sep 17 00:00:00 2001
From: kergoth <kergoth>
Date: Thu, 31 Oct 2002 17:11:35 +0000
Subject: Initial bits to start work on revamping the buildsystem

---
(limited to 'scripts/kconfig/cml1.y')

diff --git a/scripts/kconfig/cml1.y b/scripts/kconfig/cml1.y
new file mode 100644
index 0000000..42c4216
--- a/dev/null
+++ b/scripts/kconfig/cml1.y
@@ -0,0 +1,2482 @@
+%{
+/*
+ * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
+ * Released under the terms of the GNU GPL v2.0.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define PRINTD		0x0001
+#define DEBUG_PARSE	0x0002
+#define DEBUG_OPT	0x0004
+#define DEBUG_OPT1	0x0008
+#define DEBUG_OPT2	0x0010
+#define DEBUG_OPT3	0x0020
+#define DEBUG_OPT4	0x0040
+#define DEBUG_OPT5	0x0080
+#define DEBUG_DEP	0x0100
+
+int cdebug = PRINTD;//DEBUG_OPT|-1;
+
+#define YYERROR_VERBOSE
+%}
+
+%union
+{
+	char *string;
+	struct expr *expr;
+	struct symbol *symbol;
+	struct statement *stmt;
+}
+
+%token <string> T_WORD
+%token <string> T_WORD_QUOTE
+%token <string> T_WORD_DQUOTE
+%token T_MAINMENU_NAME
+%token T_MAINMENU_OPTION
+%token T_NEXT_COMMENT
+%token T_ENDMENU
+%token T_COMMENT
+%token T_BOOL
+%token T_HEX
+%token T_INT
+%token T_STRING
+%token T_TRISTATE
+%token T_DEFINE_BOOL
+%token T_DEFINE_HEX
+%token T_DEFINE_INT
+%token T_DEFINE_STRING
+%token T_DEFINE_TRISTATE
+%token T_DEP_BOOL
+%token T_DEP_MBOOL
+%token T_DEP_TRISTATE
+%token T_UNSET
+%token T_CHOICE
+%token T_SOURCE
+%token T_IF
+%token T_ELSE
+%token T_FI
+%token T_THEN
+%token T_UNEQUAL
+%token <string> T_SH_COMMENT
+
+%type <string> prompt
+%type <string> word
+%type <string> menu_comment
+%type <symbol> symbol
+%type <symbol> symbol_ref
+%type <symbol> symbol_other
+%type <stmt> statement
+%type <expr> expr
+%type <expr> dep
+%type <expr> deps
+%type <stmt> comment_opt
+
+%left T_OR
+%left T_AND
+%nonassoc '!'
+%left '=' T_UNEQUAL
+
+%{
+#include "cml1.h"
+
+extern int cml1lex(void);
+static void cml1error(const char *err);
+extern int lineno(void);
+extern void scan_nextfile(char *file);
+
+struct statement *create_stmt(int token);
+struct statement *add_stmt(struct symbol *sym, int token,
+			   char *prompt, struct symbol *def);
+void print_expr(int mask, struct expr *e, int prevtoken);
+void print_dep(int mask, struct statement *stmt);
+
+void eliminate_eq(int token, struct expr **ep1, struct expr **ep2);
+static inline int expr_is_yes(struct expr *e);
+static inline int expr_is_no(struct expr *e);
+struct expr *trans_dep_bool(struct expr *e);
+struct expr *trans_bool_expr(struct expr *e);
+struct expr *fixup_expr(struct expr *e);
+struct expr *trans_expr(struct expr *e);
+void extract_eq(int token, struct expr **ep, struct expr **ep1, struct expr **ep2);
+struct expr *extract_eq_and(struct expr **ep1, struct expr **ep2);
+struct expr *extract_eq_or(struct expr **ep1, struct expr **ep2);
+struct expr *optimize_expr_or(struct expr *e);
+struct expr *eliminate_dups(struct expr *e);
+struct expr *eliminate_yn(struct expr *e);
+void eliminate_dep(struct symbol *sym, struct expr *dep);
+int contains_expr(struct expr *dep, struct expr *e);
+
+#define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
+#define fprintd(f, mask, fmt...) if (cdebug & (mask)) fprintf(f, fmt)
+
+static struct expr *if_expr;
+static struct menu root_menu;
+static struct menu *current_menu = &root_menu;
+
+struct symbol *symbol_hash[257];
+%}
+%%
+input:	line
+;
+
+line:	/* empty */
+;
+
+line:	line statement
+;
+
+line:	line '\n'
+;
+
+statement: T_SH_COMMENT
+{
+	$$ = create_stmt(T_SH_COMMENT);
+	$$->text = $1;
+};
+
+statement: T_MAINMENU_NAME prompt '\n'
+{
+	$$ = create_stmt(T_MAINMENU_NAME);
+	$$->text = $2;
+	printd(DEBUG_PARSE, "%d:mainmenu_name: %s\n", lineno(), $2);
+};
+
+statement: T_COMMENT prompt '\n'
+{
+	$$ = create_stmt(T_COMMENT);
+	$$->text = $2;
+	$$->dep = trans_expr(fixup_expr(expr_copy(if_expr)));
+	printd(DEBUG_PARSE, "%d:comment: %s\n", lineno(), $2);
+};
+
+statement: T_BOOL prompt symbol dep '\n'
+{
+	$$ = add_stmt($3, T_BOOL, $2, NULL);
+	printd(DEBUG_PARSE, "%d:bool: %s %s\n", lineno(), $2, $3->name);
+	if ($4) {
+		printf("%s:%d: warning ignoring dependencies\n", current_file->name, current_file->lineno);
+		expr_free($4);
+	}
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_HEX prompt symbol symbol_other '\n'
+{
+	$$ = add_stmt($3, T_HEX, $2, NULL);
+	add_stmt($3, T_DEFINE_HEX, NULL, $4);
+	printd(DEBUG_PARSE, "%d:hex: %s %s %s\n", lineno(), $2, $3->name, $4->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_INT prompt symbol symbol_other '\n'
+{
+	$$ = add_stmt($3, T_INT, $2, NULL);
+	add_stmt($3, T_DEFINE_INT, NULL, $4);
+	printd(DEBUG_PARSE, "%d:int: %s %s %s\n", lineno(), $2, $3->name, $4->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_STRING prompt symbol symbol_other '\n'
+{
+	$$ = add_stmt($3, T_STRING, $2, NULL);
+	add_stmt($3, T_DEFINE_STRING, NULL, $4);
+	printd(DEBUG_PARSE, "%d:string: %s %s %s\n", lineno(), $2, $3->name, $4->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_TRISTATE prompt symbol dep '\n'
+{
+	$$ = add_stmt($3, T_TRISTATE, $2, NULL);
+	printd(DEBUG_PARSE, "%d:tristate: %s %s\n", lineno(), $2, $3->name);
+	if ($4) {
+		printf("%s:%d: warning ignoring dependencies\n", current_file->name, current_file->lineno);
+		expr_free($4);
+	}
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEFINE_BOOL symbol symbol_ref comment_opt '\n'
+{
+	$$ = add_stmt($2, T_DEFINE_BOOL, NULL, $3);
+	printd(DEBUG_PARSE, "%d:define_bool: %s %s\n", lineno(), $2->name, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEFINE_HEX symbol symbol_other '\n'
+{
+	$$ = add_stmt($2, T_DEFINE_HEX, NULL, $3);
+	printd(DEBUG_PARSE, "%d:define_hex: %s %s\n", lineno(), $2->name, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEFINE_INT symbol symbol_other comment_opt '\n'
+{
+	$$ = add_stmt($2, T_DEFINE_INT, NULL, $3);
+	printd(DEBUG_PARSE, "%d:define_int: %s %s\n", lineno(), $2->name, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEFINE_STRING symbol symbol_other '\n'
+{
+	$$ = add_stmt($2, T_DEFINE_STRING, NULL, $3);
+	printd(DEBUG_PARSE, "%d:define_string: %s %s\n", lineno(), $2->name, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEFINE_TRISTATE symbol symbol_ref '\n'
+{
+	$$ = add_stmt($2, T_DEFINE_TRISTATE, NULL, $3);
+	printd(DEBUG_PARSE, "%d:define_tristate: %s %s\n", lineno(), $2->name, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEP_BOOL prompt symbol dep '\n'
+{
+	$$ = add_stmt($3, T_DEP_BOOL, $2, NULL);
+	if (!($$->dep2 = $4))
+		printf("%s:%d: warning dep_bool without dependencies\n", current_file->name, current_file->lineno);
+	printd(DEBUG_PARSE, "%d:dep_bool: %s %s\n", lineno(), $2, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEP_MBOOL prompt symbol dep '\n'
+{
+	$$ = add_stmt($3, T_DEP_MBOOL, $2, NULL);
+	if (!($$->dep2 = $4))
+		printf("%s:%d: warning dep_mbool without dependencies\n", current_file->name, current_file->lineno);
+	printd(DEBUG_PARSE, "%d:dep_mbool: %s %s\n", lineno(), $2, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_DEP_TRISTATE prompt symbol dep '\n'
+{
+	$$ = add_stmt($3, T_DEP_TRISTATE, $2, NULL);
+	if (!($$->dep2 = $4))
+		printf("%s:%d: warning dep_tristate without dependencies\n", current_file->name, current_file->lineno);
+	printd(DEBUG_PARSE, "%d:dep_tristate: %s %s\n", lineno(), $2, $3->name);
+	print_dep(DEBUG_PARSE, $$);
+};
+
+statement: T_UNSET deps '\n'
+{
+	//add_stmt($2, T_UNSET, NULL, NULL);
+	printd(DEBUG_PARSE, "%d:unset\n", lineno());
+	print_dep(DEBUG_PARSE, NULL);
+};
+
+statement: T_CHOICE prompt word word '\n'
+{
+	struct statement *stmt;
+	struct symbol *sym;
+	struct expr **depp;
+	char *ptr, *name, *def, end;
+
+	printd(DEBUG_PARSE, "%d:choice: %s %s %s\n", lineno(), $2, $3, $4);
+	$$ = create_stmt('^');
+	$$->text = $2;
+	ptr = $3;
+	depp = &$$->dep;
+	do {
+		while (isspace(*ptr))
+			ptr++;
+		if (!*ptr)
+			break;
+		def = ptr;
+		while (*ptr && !isspace(*ptr))
+			ptr++;
+		*ptr++ = 0;
+		//def = lookup_symbol(name, SYMBOL_OTHER);
+		while (isspace(*ptr))
+			ptr++;
+		if (!*ptr)
+			break;
+		name = ptr;
+		while (*ptr && !isspace(*ptr))
+			ptr++;
+		end = *ptr;
+		*ptr++ = 0;
+		sym = lookup_symbol(name, SYMBOL_BOOLEAN);
+		if (!$$->def) {
+			if (!strncmp(def, $4, strlen($4)))
+				$$->def = sym;
+		}
+		sym->flags |= SYMBOL_CHOICE;
+		stmt = add_stmt(sym, T_BOOL, strdup(def), NULL);
+		if (!stmt->next) {
+			stmt->next = $$;
+		} else
+			printf("warning: unexpected stmt for choice symbol %s\n", sym->name);
+		*depp = expr_alloc_one('^', NULL);
+		(*depp)->right.sym = sym;
+		depp = &(*depp)->left.expr;
+		printd(DEBUG_PARSE, "added symbol: %s %s\n", sym->name, stmt->text);
+	} while (end);
+	print_dep(DEBUG_PARSE, NULL);
+};
+
+statement: T_IF '[' expr ']' semi_or_nl T_THEN comment_opt '\n'
+{
+	struct expr *e;
+	printd(DEBUG_PARSE, "%d:if ", lineno());
+	print_expr(DEBUG_PARSE, $3, 0);
+	printd(DEBUG_PARSE, "\n");
+	e = expr_alloc_one(T_IF, $3);
+	e->right.expr = if_expr;
+	if_expr = e;
+	$$ = NULL;
+};
+
+semi_or_nl: ';' | '\n'
+;
+
+statement: T_ELSE comment_opt '\n'
+{
+	printd(DEBUG_PARSE, "%d:else\n", lineno());
+	if_expr->token = T_ELSE;
+	$$ = NULL;
+};
+
+statement: T_FI comment_opt '\n'
+{
+	struct expr *e;
+	printd(DEBUG_PARSE, "%d:fi\n", lineno());
+	e = if_expr;
+	if (e) {
+		if_expr = e->right.expr;
+		expr_free(e->left.expr);
+		free(e);
+	} else
+		YYABORT;
+	$$ = NULL;
+};
+
+statement: T_MAINMENU_OPTION T_NEXT_COMMENT menu_comment '\n'
+{
+	printd(DEBUG_PARSE, "%d:mainmenu_option: %s\n", lineno(), $3);
+	$$ = create_stmt(T_MAINMENU_OPTION);
+	$$->text = $3;
+	$$->dep = trans_expr(fixup_expr(expr_copy(if_expr)));
+	current_menu = $$->menu;
+};
+
+menu_comment: '\n' T_COMMENT prompt { $$ = $3; }
+	    | '\n' menu_comment { $$ = $2; }
+;
+
+statement: T_ENDMENU '\n'
+{
+	$$ = create_stmt(T_ENDMENU);
+	printd(DEBUG_PARSE, "%d:endmenu\n", lineno());
+	current_menu = current_menu->parent;
+};
+
+statement: T_SOURCE word '\n'
+{
+	static char helppath[256];
+	char *p;
+	$$ = create_stmt(T_SOURCE);
+	$$->text = $2;
+	printd(DEBUG_PARSE, "%d:source: %s\n", lineno(), $2);
+	strcpy(helppath, $2);
+	p = strrchr(helppath, '.');
+	if (p) {
+		strcpy(p, ".help");
+		helplex(helppath);
+	}
+	scan_nextfile($2);
+};
+
+comment_opt:	/* empty */	{ $$ = NULL; }
+	|	T_SH_COMMENT
+{
+	$$ = create_stmt(T_SH_COMMENT);
+	$$->text = $1;
+};
+
+prompt:   T_WORD_QUOTE
+	| T_WORD_DQUOTE
+;
+
+word:	  T_WORD
+	| T_WORD_QUOTE
+	| T_WORD_DQUOTE
+;
+
+dep:	  /* empty */		{ $$ = NULL; }
+	| deps			{ $$ = $1; }
+;
+
+deps:	  symbol_ref		{ $$ = expr_alloc_symbol($1); }
+	| deps symbol_ref	{ $$ = expr_alloc_two('&', $1, expr_alloc_symbol($2)); }
+;
+
+symbol:	T_WORD			{ $$ = lookup_symbol($1, SYMBOL_UNKNOWN); free($1); }
+;
+
+expr:	  symbol_ref '=' symbol_ref		{ $$ = expr_alloc_comp('=', $1, $3); }
+	| symbol_ref T_UNEQUAL symbol_ref	{ $$ = expr_alloc_comp(T_UNEQUAL, $1, $3); }
+	| '!' expr		{ $$ = expr_alloc_one('!', $2); }
+	| expr T_AND expr	{ $$ = expr_alloc_two(T_AND, $1, $3); }
+	| expr T_OR expr	{ $$ = expr_alloc_two(T_OR, $1, $3); }
+;
+
+symbol_ref: T_WORD		{ $$ = lookup_symbol_ref($1); free($1); }
+	  | T_WORD_QUOTE	{ $$ = lookup_symbol_ref($1); free($1); }
+	  | T_WORD_DQUOTE	{ $$ = lookup_symbol_ref($1); free($1); }
+;
+
+symbol_other: T_WORD		{ $$ = lookup_symbol($1, SYMBOL_OTHER); free($1); }
+	    | T_WORD_QUOTE	{ $$ = lookup_symbol($1, SYMBOL_OTHER); free($1); }
+	    | T_WORD_DQUOTE	{ $$ = lookup_symbol($1, SYMBOL_OTHER); free($1); }
+;
+
+%%
+
+static void yyerror(const char *err)
+{
+	printf("%s:%d: %s\n", current_file->name, current_file->lineno + 1, err);
+	exit(1);
+}
+
+void print_dep(int mask, struct statement *stmt)
+{
+	printd(mask, "dep: ");
+	if (stmt) {
+		if (stmt->dep2)
+			printd(mask, "[");
+		print_expr(mask, stmt->dep, 0);
+		if (stmt->dep2) {
+			printd(mask, " & ");
+			print_expr(mask, stmt->dep2, 0);
+			printd(mask, "]");
+		}
+	} else
+		print_expr(mask, if_expr, 0);
+	printd(mask, "\n");
+}
+
+struct symbol *lookup_symbol(char *name, int type)
+{
+	struct symbol *symbol;
+	char *ptr;
+	int hash = 0;
+
+	//printf("lookup: %s -> ", name);
+	if (type != SYMBOL_OTHER && !strncmp(name, "CONFIG_", 7)) {
+		name += 7;
+	} else {
+		//printf("Warning: Invalid symbol name '%s'\n", name);
+		type = SYMBOL_OTHER;
+	}
+
+	for (ptr = name; *ptr; ptr++)
+		hash += *ptr;
+
+	for (symbol = symbol_hash[hash&255]; symbol; symbol = symbol->next) {
+		if (!strcmp(symbol->name, name)) {
+			//printf("h:%p\n", symbol);
+			if (type == SYMBOL_BOOLEAN)
+				symbol->type = SYMBOL_BOOLEAN;
+			return symbol;
+		}
+	}
+
+	symbol = malloc(sizeof(*symbol));
+	memset(symbol, 0, sizeof(*symbol));
+	symbol->name = strdup(name);
+	symbol->type = type;
+
+	symbol->next = symbol_hash[hash&255];
+	symbol_hash[hash&255] = symbol;
+
+	//printf("n:%p\n", symbol);
+	return symbol;
+}
+
+struct symbol *lookup_symbol_ref(char *name)
+{
+	if (name[0] == 'y' && !name[1])
+		return &symbol_yes;
+	if (name[0] == 'm' && !name[1])
+		return &symbol_mod;
+	if (name[0] == 'n' && !name[1])
+		return &symbol_no;
+	if (name[0] == '$')
+		return lookup_symbol(name+1, SYMBOL_UNKNOWN);
+	return lookup_symbol(name, SYMBOL_OTHER);
+}
+
+struct statement *create_stmt(int token)
+{
+	struct statement *stmt;
+	struct menu *menu, **menup;
+
+	stmt = malloc(sizeof(*stmt));
+	memset(stmt, 0, sizeof(*stmt));
+	stmt->token = token;
+	stmt->file = current_file;
+	stmt->lineno = lineno();
+
+	if (!current_file->stmt)
+		current_file->stmt = stmt;
+	if (current_file->last_stmt)
+		current_file->last_stmt->next_pos = stmt;
+	current_file->last_stmt = stmt;
+
+	menu = malloc(sizeof(*menu));
+	memset(menu, 0, sizeof(*menu));
+	menu->prompt = stmt;
+	menu->parent = current_menu;
+	for (menup = &current_menu->list; *menup; menup = &(*menup)->next)
+		;
+	*menup = menu;
+
+	stmt->menu = menu;
+
+	return stmt;
+}
+
+struct statement *add_stmt(struct symbol *sym, int token, char *prompt, struct symbol *def)
+{
+	struct statement *stmt = create_stmt(token);
+
+	stmt->dep = expr_copy(if_expr);
+	stmt->text = prompt;
+	stmt->def = def;
+
+	stmt->sym = sym;
+	stmt->next = sym->stmt;
+	sym->stmt = stmt;
+
+	return stmt;
+}
+
+void print_quoted_string(FILE *out, const char *str)
+{
+	const char *p;
+	int len;
+
+	putc('"', out);
+	while ((p = strchr(str, '"'))) {
+		len = p - str;
+		if (len)
+			fprintf(out, "%.*s", len, str);
+		fputs("\\\"", out);
+		str += len + 1;
+	}
+	fputs(str, out);
+	putc('"', out);
+}
+
+const char *skip_space(const char *p)
+{
+	while (*p == ' ')
+		p++;
+	return p;
+}
+
+void do_print_symbol(FILE *out, struct symbol *sym)
+{
+	struct statement *zero_stmt, *stmt, *stmt2;
+	struct expr *dep, *dep2;
+
+#define VALID_STMT(s) (s->token && s->token != '^' && s->menu && s->menu->parent == current_menu)
+
+	dep = NULL;
+	for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+		if (!VALID_STMT(stmt))
+			continue;
+		if (!dep) {
+			if (!stmt->dep)
+				break;
+			dep = stmt->dep;
+			stmt->dep = NULL;
+		} else {
+			struct expr *e = dep;
+			if (stmt->dep) {
+				dep = extract_eq_and(&e, &stmt->dep);
+				if (expr_is_yes(e)) {
+					expr_free(e);
+					continue;
+				}
+			} else
+				dep = NULL;
+			for (stmt2 = sym->stmt; stmt != stmt2; stmt2 = stmt2->next) {
+				if (!VALID_STMT(stmt2))
+					continue;
+				stmt2->dep = !stmt2->dep ? expr_copy(e) :
+					expr_alloc_two(T_AND, expr_copy(e), stmt2->dep);
+			}
+			expr_free(e);
+			if (!dep)
+				break;
+		}
+	}
+
+	zero_stmt = NULL;
+	for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+		if (!stmt->token)
+			zero_stmt = stmt;
+		if (VALID_STMT(stmt))
+			break;
+	}
+	if (!stmt) {
+		if (sym->flags & SYMBOL_PRINTED)
+			return;
+		if (!zero_stmt)
+			return;
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			if (stmt->token)
+				return;
+		}
+		stmt = zero_stmt;
+	}
+
+	fprintf(out, "config %s\n", sym->name);
+
+	switch (sym->type) {
+	case SYMBOL_BOOLEAN: fputs("\tbool", out); break;
+	case SYMBOL_TRISTATE: fputs("\ttristate", out); break;
+	case SYMBOL_INT: fputs("\tint", out); break;
+	case SYMBOL_HEX: fputs("\thex", out); break;
+	case SYMBOL_STRING: fputs("\tstring", out); break;
+	default: fputs("\t#unknown type?", out); break;
+	}
+
+	if (stmt->text) {
+		fputc(' ', out);
+		print_quoted_string(out, skip_space(stmt->text));
+		if (!expr_is_yes(stmt->dep)) {
+			fputs(" if ", out);
+			fprint_expr(out, stmt->dep, 0);
+		}
+		stmt->menu = NULL;
+		stmt = stmt->next;
+	}
+	fputc('\n', out);
+
+	if (sym->dep || dep) {
+		dep = expr_alloc_and(expr_copy(sym->dep), dep);
+		dep = eliminate_yn(dep);
+		if (current_menu->prompt && current_menu->prompt->dep) {
+			dep2 = expr_copy(current_menu->prompt->dep);
+			switch (sym->type) {
+			case SYMBOL_BOOLEAN: case SYMBOL_INT: case SYMBOL_HEX: case SYMBOL_STRING:
+				dep2 = trans_bool_expr(dep2);
+				break;
+			}
+			eliminate_eq(T_AND, &dep, &dep2);
+			dep = eliminate_yn(dep);
+#if 0
+			dep2 = eliminate_yn(dep2);
+			if (!expr_is_yes(dep2)) {
+				printf("Warning, I'm still confused (%s)?\n", sym->name);
+				print_expr(PRINTD, dep, 0);
+				printf(" - ");
+				print_expr(PRINTD, dep2, 0);
+				printf("\n");
+			}
+#endif
+			expr_free(dep2);
+		}
+		if (!expr_is_yes(dep)) {
+			fputs("\tdepends on ", out);
+			fprint_expr(out, eliminate_yn(dep), 0);
+			fputc('\n', out);
+		}
+	}
+	for (; stmt; stmt = stmt->next) {
+		if (!VALID_STMT(stmt))
+			continue;
+		if (stmt->text) {
+			;
+		} else if (stmt->def) {
+			if (sym->flags & SYMBOL_CHOICE)
+				printf("Choice value %s has default value!\n", sym->name);
+			fputs( "\tdefault ", out);
+			switch (sym->type) {
+			case SYMBOL_BOOLEAN:
+			case SYMBOL_TRISTATE:
+				fputs(stmt->def->name, out);
+				break;
+			default:
+				print_quoted_string(out, stmt->def->name);
+				break;
+			}
+			if (!expr_is_yes(stmt->dep)) {
+				fputs(" if ", out);
+				fprint_expr(out, eliminate_yn(stmt->dep), 0);
+			}
+			fputc('\n', out);
+			stmt->menu = NULL;
+		}
+	}
+	if (sym->help && !(sym->flags & SYMBOL_PRINTED)) {
+		int len = strlen(sym->help);
+		char *p, *p2;
+		int cnt;
+
+		while (sym->help[--len] == '\n')
+			sym->help[len] = 0;
+		for (p = sym->help, cnt = 0; (p = strchr(p, '\n')); p++, cnt++)
+			;
+		if (cnt >= 9)
+			fprintf(out, "\t---help---\n");
+		else
+			fprintf(out, "\thelp\n");
+		for (p = sym->help;; p = p2 + 1) {
+			while (*p == ' ')
+				p++;
+			if (*p == '\n') {
+				fputc('\n', out);
+				p2 = p;
+				continue;
+			}
+			p2 = strchr(p, '\n');
+			if (!p2)
+				break;
+			fprintf(out, "\t  %.*s\n", p2 - p, p);
+		}
+		fprintf(out, "\t  %s\n", p);
+	}
+	fputc('\n', out);
+	for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+		if (!VALID_STMT(stmt))
+			continue;
+		if (stmt->text) {
+			fprintf(out, "config %s\n", sym->name);
+			fputs( "\tprompt ", out);
+			print_quoted_string(out, skip_space(stmt->text));
+			fputc('\n', out);
+			dep2 = expr_alloc_and(expr_copy(dep), expr_copy(stmt->dep));
+			dep2 = eliminate_dups(dep2);
+			if (!expr_is_yes(dep2)) {
+				fputs("\tdepends on ", out);
+				fprint_expr(out, dep2, 0);
+				fputc('\n', out);
+			}
+			expr_free(dep2);
+			fputc('\n', out);
+			stmt->menu = NULL;
+		}
+	}
+	sym->flags |= SYMBOL_PRINTED;
+	expr_free(dep);
+}
+
+void print_choice(FILE *out, struct symbol *sym)
+{
+	struct statement *stmt;
+	struct expr *lst, *dep, *tmp, *tmp2;
+
+	if (sym->flags & SYMBOL_PRINTED)
+		return;
+
+	for (stmt = sym->stmt; stmt; stmt = stmt->next)
+		if (stmt->token == '^')
+			break;
+	if (!stmt)
+		//warn?
+		return;
+
+	fputs("choice\n", out);
+	if (stmt->text) {
+		fputs("\tprompt ", out);
+		print_quoted_string(out, skip_space(stmt->text));
+		fputc('\n', out);
+	}
+
+	dep = NULL;
+	for (lst = stmt->dep; lst; lst = lst->left.expr) {
+		sym = lst->right.sym;
+		if (sym == &symbol_no) {
+			fputs("\toptional\n", out);
+			continue;
+		}
+		if (!dep) {
+			if (!sym->dep)
+				break;
+			dep = sym->dep;
+			sym->dep = NULL;
+		} else {
+			tmp = dep;
+			if (sym->dep) {
+				dep = extract_eq_and(&tmp, &sym->dep);
+				if (expr_is_yes(tmp)) {
+					expr_free(tmp);
+					continue;
+				}
+			} else
+				dep = NULL;
+			for (tmp2 = stmt->dep; tmp2 != lst; tmp2 = tmp2->left.expr) {
+				sym = tmp2->right.sym;
+				if (sym == &symbol_no)
+					continue;
+				sym->dep = !sym->dep ? expr_copy(tmp) :
+					expr_alloc_two(T_AND, expr_copy(tmp), sym->dep);
+				sym->dep = eliminate_yn(sym->dep);
+			}
+			expr_free(tmp);
+			if (!dep)
+				break;
+		}
+	}
+	for (;lst; lst = lst->left.expr) {
+		sym = lst->right.sym;
+		if (sym == &symbol_no) {
+			fputs("\toptional\n", out);
+			continue;
+		}
+	}
+	if (!expr_is_yes(dep)) {
+		fputs("\tdepends on ", out);
+		fprint_expr(out, dep, 0);
+		fputc('\n', out);
+	}
+	if (stmt->def)
+		fprintf(out, "\tdefault %s\n", stmt->def->name);
+
+	fputc('\n', out);
+
+	for (lst = stmt->dep; lst; lst = lst->left.expr) {
+		sym = lst->right.sym;
+		if (sym == &symbol_no)
+			continue;
+		do_print_symbol(out, sym);
+		sym->flags |= SYMBOL_PRINTED;
+	}
+
+	fputs("endchoice\n\n", out);
+}
+
+void print_symbols(FILE *out, struct symbol *sym)
+{
+	//if (sym->flags & SYMBOL_PRINTED)
+	//	return;
+	//sym->flags |= SYMBOL_PRINTED;
+
+	if (sym->flags & SYMBOL_CHOICE) {
+		print_choice(out, sym);
+		return;
+	}
+	do_print_symbol(out, sym);
+}
+
+char *gen_filename(const char *name)
+{
+	static char newname[128];
+	char *p;
+
+	strcpy(newname, name);
+	p = strrchr(newname, '/');
+	if (!p)
+		p = newname;
+	else
+		p++;
+#if 0
+	p = strrchr(p, '.');
+	if (!p)
+		p = newname + strlen(newname);
+	strcpy(p, ".new");
+#else
+#if 0
+	memcpy(p, "Build", 5);
+	memmove(p + 5, p + 6, strlen(p) - 5);
+	p = strrchr(p, '.');
+	if (!p)
+		p = newname + strlen(newname);
+	strcpy(p, ".conf");
+#else
+	memmove(p + 1, p, strlen(p) + 1);
+	p[0] = 'K';
+	p[1] = 'c';
+	p = strrchr(p, '.');
+	*p = 0;
+#endif
+#endif
+	return newname;
+}
+
+void print_files(FILE *all_out, const char *name)
+{
+	struct file *file;
+	FILE *out = all_out;
+	struct symbol *sym;
+	struct statement *stmt;
+	struct expr *dep1, *dep2;
+	char *p;
+
+	print_type = 0;
+
+	file = lookup_file(name);
+	if (!file) {
+		fprintf(stderr, "# file %s not found!\n\n", file->name);
+		return;
+	} else if (file->flags & FILE_PRINTED) {
+		fprintf(stderr, "# file %s skipped\n\n", file->name);
+		return;
+	}
+
+	if (!out) {
+		p = gen_filename(file->name);
+		strcat(p, ".lkc");
+		out = fopen(p, "w");
+		if (!out) {
+			printf("unable to open %s for writing!\n", p);
+			exit(1);
+		}
+	}
+
+	if (all_out)
+		fprintf(all_out, "# file %s\n\n", file->name);
+	file->flags |= FILE_PRINTED;
+
+	for (stmt = file->stmt; stmt; stmt = stmt->next_pos) {
+		sym = stmt->sym;
+		if (!sym) {
+			switch (stmt->token) {
+			case T_MAINMENU_NAME:
+				fputs("\nmainmenu ", out);
+				print_quoted_string(out, skip_space(stmt->text));
+				fputs("\n\n", out);
+				break;
+			case T_COMMENT:
+				fputs("comment ", out);
+				print_quoted_string(out, skip_space(stmt->text));
+				stmt->dep = eliminate_dups(trans_expr(stmt->dep));
+				dep1 = expr_copy(stmt->dep);
+				if (dep1 && current_menu->prompt && current_menu->prompt->dep) {
+					dep2 = expr_copy(current_menu->prompt->dep);
+					eliminate_eq(T_AND, &dep1, &dep2);
+					dep1 = eliminate_yn(dep1);
+					dep2 = eliminate_yn(dep2);
+					if (!expr_is_yes(dep2)) {
+						printf("Warning, I'm confused!\n");
+					}
+					expr_free(dep2);
+				}
+				if (!expr_is_yes(dep1)) {
+					dep1 = trans_bool_expr(dep1);
+					fputs("\n\tdepends on ", out);
+					fprint_expr(out, dep1, 0);
+				}
+				expr_free(dep1);
+				fputs("\n\n", out);
+				break;
+			case T_SH_COMMENT:
+				fprintf(out, "%s\n", stmt->text);
+				break;
+			case T_MAINMENU_OPTION:
+				fputs("\nmenu ", out);
+				print_quoted_string(out, skip_space(stmt->text));
+				stmt->dep = eliminate_dups(trans_expr(stmt->dep));
+				dep1 = expr_copy(stmt->dep);
+				if (dep1 && current_menu->prompt && current_menu->prompt->dep) {
+					dep2 = expr_copy(current_menu->prompt->dep);
+					eliminate_eq(T_AND, &dep1, &dep2);
+					dep1 = eliminate_yn(dep1);
+					dep2 = eliminate_yn(dep2);
+					if (!expr_is_yes(dep2)) {
+						printf("Warning, I'm confused!\n");
+					}
+					expr_free(dep2);
+				}
+				if (!expr_is_yes(dep1)) {
+					fputs("\n\tdepends on ", out);
+					fprint_expr(out, dep1, 0);
+				}
+				expr_free(dep1);
+				fputs("\n\n", out);
+				current_menu = stmt->menu;
+				break;
+			case T_ENDMENU:
+				fputs("endmenu\n\n", out);
+				current_menu = current_menu->parent;
+				break;
+			case T_SOURCE:
+				fprintf(out, "%ssource ", all_out ? "#" : "");
+				print_quoted_string(out, gen_filename(stmt->text));
+				fputs("\n\n", out);
+				print_files(all_out, stmt->text);
+				break;
+			}
+		} else
+			print_symbols(out, sym);
+	}
+
+	if (all_out)
+		fprintf(out, "# fileend %s\n\n", file->name);
+}
+
+static int trans_count;
+
+void eliminate_eq(int token, struct expr **ep1, struct expr **ep2)
+{
+#define e1 (*ep1)
+#define e2 (*ep2)
+
+	if (e1->token == token) {
+		eliminate_eq(token, &e1->left.expr, &e2);
+		eliminate_eq(token, &e1->right.expr, &e2);
+		return;
+	}
+	if (e2->token == token) {
+		eliminate_eq(token, &e1, &e2->left.expr);
+		eliminate_eq(token, &e1, &e2->right.expr);
+		return;
+	}
+	if (e1->token == T_WORD && e2->token == T_WORD &&
+	    e1->left.sym == e2->left.sym && (e1->left.sym->flags & (SYMBOL_YES|SYMBOL_NO)))
+		return;
+	if (!expr_eq(e1, e2))
+		return;
+	trans_count++;
+	expr_free(e1); expr_free(e2);
+	switch (token) {
+	case T_OR:
+		e1 = expr_alloc_symbol(&symbol_no);
+		e2 = expr_alloc_symbol(&symbol_no);
+		break;
+	case T_AND:
+		e1 = expr_alloc_symbol(&symbol_yes);
+		e2 = expr_alloc_symbol(&symbol_yes);
+		break;
+	}
+#undef e1
+#undef e2
+}
+
+int expr_eq(struct expr *e1, struct expr *e2)
+{
+	int res, old_count;
+
+	if (e1->token != e2->token)
+		return 0;
+	switch (e1->token) {
+	case '=':
+	case T_UNEQUAL:
+		return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
+	case T_WORD:
+		return e1->left.sym == e2->left.sym;
+	case '!':
+		return expr_eq(e1->left.expr, e2->left.expr);
+	case T_AND:
+	case T_OR:
+		e1 = expr_copy(e1);
+		e2 = expr_copy(e2);
+		old_count = trans_count;
+		eliminate_eq(e1->token, &e1, &e2);
+		e1 = eliminate_yn(e1);
+		e2 = eliminate_yn(e2);
+		res = (e1->token == T_WORD &&
+		       e2->token == T_WORD &&
+		       e1->left.sym == e2->left.sym);
+		expr_free(e1);
+		expr_free(e2);
+		trans_count = old_count;
+		return res;
+	}
+	print_expr(PRINTD, e1, 0);
+	printf(" = ");
+	print_expr(PRINTD, e2, 0);
+	printf(" ?\n");
+	return 0;
+}
+
+/*
+ * dep_bool FOO -> FOO=y
+ */
+struct expr *trans_dep_bool(struct expr *e)
+{
+	switch (e->token) {
+	case '&':
+	case T_AND:
+		e->left.expr = trans_dep_bool(e->left.expr);
+		e->right.expr = trans_dep_bool(e->right.expr);
+		break;
+	case T_WORD:
+		if (e->left.sym->type == SYMBOL_TRISTATE) {
+			e->token = '=';
+			e->right.sym = &symbol_yes;
+		}
+		break;
+	}
+	return e;
+}
+
+/*
+ * bool FOO!=n => FOO
+ */
+struct expr *trans_bool_expr(struct expr *e)
+{
+	if (!e)
+		return NULL;
+	switch (e->token) {
+	case T_AND:
+	case T_OR:
+	case '!':
+		e->left.expr = trans_bool_expr(e->left.expr);
+		e->right.expr = trans_bool_expr(e->right.expr);
+		break;
+	case T_UNEQUAL:
+		// FOO!=n -> FOO
+		if (e->left.sym->type == SYMBOL_TRISTATE) {
+			if (e->right.sym == &symbol_no) {
+				e->token = T_WORD;
+				e->right.sym = NULL;
+			}
+		}
+		break;
+	}
+	return e;
+}
+
+struct expr *fixup_expr(struct expr *e)
+{
+	struct expr *tmp;
+
+	if (!e)
+		return NULL;
+
+	switch (e->token) {
+	case T_IF:
+		// if expr if expr ... -> expr && expr ...
+		print_expr(DEBUG_OPT1, e, 0);
+		printd(DEBUG_OPT1, " -> ");
+		tmp = e->left.expr;
+		if (!e->right.expr) {
+			free(e);
+			e = fixup_expr(tmp);
+			print_expr(DEBUG_OPT1, e, 0);
+			printd(DEBUG_OPT1, "\n");
+			return e;
+		}
+		e->left.expr = e->right.expr;
+		e->right.expr = tmp;
+		e->token = T_AND;
+		print_expr(DEBUG_OPT1, e, 0);
+		printd(DEBUG_OPT1, "\n");
+		break;
+	case T_ELSE:
+		// if expr else expr ... -> expr && !expr ...
+		print_expr(DEBUG_OPT1, e, 0);
+		printd(DEBUG_OPT1, " -> ");
+		e->token = '!';
+		if (!e->right.expr) {
+			print_expr(DEBUG_OPT1, e, 0);
+			printd(DEBUG_OPT1, "\n");
+			break;
+		}
+		tmp = e;
+		e = expr_alloc_two(T_AND, e->right.expr, e);
+		tmp->right.expr = NULL;
+		print_expr(DEBUG_OPT1, e, 0);
+		printd(DEBUG_OPT1, "\n");
+		break;
+	case '&':
+		// expr & expr -> expr && expr
+		print_expr(DEBUG_OPT1, e, 0);
+		printd(DEBUG_OPT1, " -> ");
+		e->token = T_AND;
+		print_expr(DEBUG_OPT1, e, 0);
+		printd(DEBUG_OPT1, "\n");
+		break;
+	case '=':
+	case T_UNEQUAL:
+		if (!(e->left.sym->flags & SYMBOL_CONST))
+			return e;
+		if (e->right.sym->flags & SYMBOL_CONST) {
+			if (e->left.sym == e->right.sym) {
+				e->left.sym = e->token == '=' ? &symbol_yes : &symbol_no;
+			} else {
+				e->left.sym = e->token != '=' ? &symbol_yes : &symbol_no;
+			}
+			e->token = T_WORD;
+			e->right.sym = NULL;
+		} else {
+			// y/n/m = sym -> sym = y/n/m
+			struct symbol *sym;
+			print_expr(DEBUG_OPT1, e, 0);
+			printd(DEBUG_OPT1, " -> ");
+			sym = e->left.sym;
+			e->left.sym = e->right.sym;
+			e->right.sym = sym;
+			print_expr(DEBUG_OPT1, e, 0);
+			printd(DEBUG_OPT1, "\n");
+		}
+		return e;
+	case T_WORD:
+	case '^':
+		return e;
+	}
+	e->left.expr = fixup_expr(e->left.expr);
+	e->right.expr = fixup_expr(e->right.expr);
+	return e;
+}
+
+struct expr *join_or(struct expr *e1, struct expr *e2)
+{
+	struct expr *tmp;
+	struct symbol *sym1, *sym2;
+
+	if (expr_eq(e1, e2))
+		return expr_copy(e1);
+	if (e1->token != '=' && e1->token != T_UNEQUAL && e1->token != T_WORD && e1->token != '!')
+		return NULL;
+	if (e2->token != '=' && e2->token != T_UNEQUAL && e2->token != T_WORD && e2->token != '!')
+		return NULL;
+	if (e1->token == '!') {
+		tmp = e1->left.expr;
+		if (tmp->token != '=' && tmp->token != T_UNEQUAL && tmp->token != T_WORD)
+			return NULL;
+		sym1 = tmp->left.sym;
+	} else
+		sym1 = e1->left.sym;
+	if (e2->token == '!') {
+		if (e2->left.expr->token != T_WORD)
+			return NULL;
+		sym2 = e2->left.expr->left.sym;
+	} else
+		sym2 = e2->left.sym;
+	if (sym1 != sym2)
+		return NULL;
+	if (sym1->type != SYMBOL_BOOLEAN && sym1->type != SYMBOL_TRISTATE)
+		return NULL;
+	if (sym1->type == SYMBOL_TRISTATE) {
+		if (e1->token == '=' && e2->token == '=' &&
+		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
+		     (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
+			// (a='y') || (a='m') -> (a!='n')
+			return expr_alloc_comp(T_UNEQUAL, sym1, &symbol_no);
+		}
+		if (e1->token == '=' && e2->token == '=' &&
+		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
+		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
+			// (a='y') || (a='n') -> (a!='m')
+			return expr_alloc_comp(T_UNEQUAL, sym1, &symbol_mod);
+		}
+		if (e1->token == '=' && e2->token == '=' &&
+		    ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
+		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
+			// (a='m') || (a='n') -> (a!='y')
+			return expr_alloc_comp(T_UNEQUAL, sym1, &symbol_yes);
+		}
+	}
+	if (sym1->type == SYMBOL_BOOLEAN && sym1 == sym2) {
+		if ((e1->token == '!' && e1->left.expr->token == T_WORD && e2->token == T_WORD) ||
+		    (e2->token == '!' && e2->left.expr->token == T_WORD && e1->token == T_WORD))
+			return expr_alloc_symbol(&symbol_yes);
+	}
+
+	printf("optimize ");
+	print_expr(PRINTD, e1, 0);
+	printf(" || ");
+	print_expr(PRINTD, e2, 0);
+	printf(" ?\n");
+	return NULL;
+}
+
+struct expr *join_and(struct expr *e1, struct expr *e2)
+{
+	struct expr *tmp;
+	struct symbol *sym1, *sym2;
+
+	if (expr_eq(e1, e2))
+		return expr_copy(e1);
+	if (e1->token != '=' && e1->token != T_UNEQUAL && e1->token != T_WORD && e1->token != '!')
+		return NULL;
+	if (e2->token != '=' && e2->token != T_UNEQUAL && e2->token != T_WORD && e2->token != '!')
+		return NULL;
+	if (e1->token == '!') {
+		tmp = e1->left.expr;
+		if (tmp->token != '=' && tmp->token != T_UNEQUAL && tmp->token != T_WORD)
+			return NULL;
+		sym1 = tmp->left.sym;
+	} else
+		sym1 = e1->left.sym;
+	if (e2->token == '!') {
+		if (e2->left.expr->token != T_WORD)
+			return NULL;
+		sym2 = e2->left.expr->left.sym;
+	} else
+		sym2 = e2->left.sym;
+	if (sym1 != sym2)
+		return NULL;
+	if (sym1->type != SYMBOL_BOOLEAN && sym1->type != SYMBOL_TRISTATE)
+		return NULL;
+
+	if ((e1->token == T_WORD && e2->token == '=' && e2->right.sym == &symbol_yes) ||
+	    (e2->token == T_WORD && e1->token == '=' && e1->right.sym == &symbol_yes))
+		// (a) && (a='y') -> (a='y')
+		return expr_alloc_comp('=', sym1, &symbol_yes);
+
+	if ((e1->token == T_WORD && e2->token == T_UNEQUAL && e2->right.sym == &symbol_no) ||
+	    (e2->token == T_WORD && e1->token == T_UNEQUAL && e1->right.sym == &symbol_no))
+		// (a) && (a!='n') -> (a)
+		return expr_alloc_symbol(sym1);
+
+	if (sym1->type == SYMBOL_TRISTATE) {
+		if (e1->token == '=' && e2->token == T_UNEQUAL) {
+			// (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
+			sym2 = e1->right.sym;
+			if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
+				return sym2 != e2->right.sym ? expr_alloc_comp('=', sym1, sym2)
+							     : expr_alloc_symbol(&symbol_no);
+		}
+		if (e1->token == T_UNEQUAL && e2->token == '=') {
+			// (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
+			sym2 = e2->right.sym;
+			if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
+				return sym2 != e1->right.sym ? expr_alloc_comp('=', sym1, sym2)
+							     : expr_alloc_symbol(&symbol_no);
+		}
+		if (e1->token == T_UNEQUAL && e2->token == T_UNEQUAL &&
+			   ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
+			    (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes)))
+			// (a!='y') && (a!='n') -> (a='m')
+			return expr_alloc_comp('=', sym1, &symbol_mod);
+
+		if (e1->token == T_UNEQUAL && e2->token == T_UNEQUAL &&
+			   ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
+			    (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes)))
+			// (a!='y') && (a!='m') -> (a='n')
+			return expr_alloc_comp('=', sym1, &symbol_no);
+
+		if (e1->token == T_UNEQUAL && e2->token == T_UNEQUAL &&
+			   ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
+			    (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod)))
+			// (a!='m') && (a!='n') -> (a='m')
+			return expr_alloc_comp('=', sym1, &symbol_yes);
+
+		if ((e1->token == T_WORD && e2->token == '=' && e2->right.sym == &symbol_mod) ||
+		    (e2->token == T_WORD && e1->token == '=' && e1->right.sym == &symbol_mod) ||
+		    (e1->token == T_WORD && e2->token == T_UNEQUAL && e2->right.sym == &symbol_yes) ||
+		    (e2->token == T_WORD && e1->token == T_UNEQUAL && e1->right.sym == &symbol_yes))
+			return NULL;
+	}
+	printf("optimize ");
+	print_expr(PRINTD, e1, 0);
+	printf(" && ");
+	print_expr(PRINTD, e2, 0);
+	printf(" ?\n");
+	return NULL;
+}
+
+void eliminate_dups1(int token, struct expr **ep1, struct expr **ep2)
+{
+#define e1 (*ep1)
+#define e2 (*ep2)
+	struct expr *tmp;
+
+	if (e1->token == token) {
+		eliminate_dups1(token, &e1->left.expr, &e2);
+		eliminate_dups1(token, &e1->right.expr, &e2);
+		return;
+	}
+	if (e2->token == token) {
+		eliminate_dups1(token, &e1, &e2->left.expr);
+		eliminate_dups1(token, &e1, &e2->right.expr);
+		return;
+	}
+	if (e1 == e2)
+		return;
+
+	switch (e1->token) {
+	case T_OR: case T_AND:
+		eliminate_dups1(e1->token, &e1, &e1);
+	}
+
+	switch (token) {
+	case T_OR:
+		tmp = join_or(e1, e2);
+		if (tmp) {
+			expr_free(e1); expr_free(e2);
+			e1 = expr_alloc_symbol(&symbol_no);
+			e2 = tmp;
+			trans_count++;
+		}
+		break;
+	case T_AND:
+		tmp = join_and(e1, e2);
+		if (tmp) {
+			expr_free(e1); expr_free(e2);
+			e1 = expr_alloc_symbol(&symbol_yes);
+			e2 = tmp;
+			trans_count++;
+		}
+		break;
+	}
+#undef e1
+#undef e2
+}
+
+void eliminate_dups2(int token, struct expr **ep1, struct expr **ep2)
+{
+#define e1 (*ep1)
+#define e2 (*ep2)
+	struct expr *tmp, *tmp1, *tmp2;
+
+	if (e1->token == token) {
+		eliminate_dups2(token, &e1->left.expr, &e2);
+		eliminate_dups2(token, &e1->right.expr, &e2);
+		return;
+	}
+	if (e2->token == token) {
+		eliminate_dups2(token, &e1, &e2->left.expr);
+		eliminate_dups2(token, &e1, &e2->right.expr);
+	}
+	if (e1 == e2)
+		return;
+
+	switch (e1->token) {
+	case T_OR:
+		eliminate_dups2(e1->token, &e1, &e1);
+		// (FOO || BAR) && (!FOO && !BAR) -> n
+		tmp1 = trans_expr(expr_alloc_one('!', expr_copy(e1)));
+		tmp2 = expr_copy(e2);
+		tmp = extract_eq_and(&tmp1, &tmp2);
+		if (expr_is_yes(tmp1)) {
+			expr_free(e1);
+			e1 = expr_alloc_symbol(&symbol_no);
+			trans_count++;
+		}
+		expr_free(tmp2);
+		expr_free(tmp1);
+		expr_free(tmp);
+		break;
+	case T_AND:
+		eliminate_dups2(e1->token, &e1, &e1);
+		// (FOO && BAR) || (!FOO || !BAR) -> y
+		tmp1 = trans_expr(expr_alloc_one('!', expr_copy(e1)));
+		tmp2 = expr_copy(e2);
+		tmp = extract_eq_or(&tmp1, &tmp2);
+		if (expr_is_no(tmp1)) {
+			expr_free(e1);
+			e1 = expr_alloc_symbol(&symbol_yes);
+			trans_count++;
+		}
+		expr_free(tmp2);
+		expr_free(tmp1);
+		expr_free(tmp);
+		break;
+	}
+#undef e1
+#undef e2
+}
+
+struct expr *eliminate_dups(struct expr *e)
+{
+	int oldcount;
+	if (!e)
+		return e;
+
+	oldcount = trans_count;
+	while (1) {
+		trans_count = 0;
+		switch (e->token) {
+		case T_OR: case T_AND:
+			eliminate_dups1(e->token, &e, &e);
+			eliminate_dups2(e->token, &e, &e);
+		}
+		if (!trans_count)
+			break;
+		e = eliminate_yn(e);
+	}
+	trans_count = oldcount;
+	return e;
+}
+
+struct expr *eliminate_yn(struct expr *e)
+{
+	struct expr *tmp;
+
+	if (e) switch (e->token) {
+	case T_AND:
+		e->left.expr = eliminate_yn(e->left.expr);
+		e->right.expr = eliminate_yn(e->right.expr);
+		if (e->left.expr->token == T_WORD) {
+			if (e->left.expr->left.sym == &symbol_no) {
+				expr_free(e->left.expr);
+				expr_free(e->right.expr);
+				e->token = T_WORD;
+				e->left.sym = &symbol_no;
+				e->right.expr = NULL;
+				return e;
+			} else if (e->left.expr->left.sym == &symbol_yes) {
+				free(e->left.expr);
+				tmp = e->right.expr;
+				*e = *(e->right.expr);
+				free(tmp);
+				return e;
+			}
+		}
+		if (e->right.expr->token == T_WORD) {
+			if (e->right.expr->left.sym == &symbol_no) {
+				expr_free(e->left.expr);
+				expr_free(e->right.expr);
+				e->token = T_WORD;
+				e->left.sym = &symbol_no;
+				e->right.expr = NULL;
+				return e;
+			} else if (e->right.expr->left.sym == &symbol_yes) {
+				free(e->right.expr);
+				tmp = e->left.expr;
+				*e = *(e->left.expr);
+				free(tmp);
+				return e;
+			}
+		}
+		break;
+	case T_OR:
+		e->left.expr = eliminate_yn(e->left.expr);
+		e->right.expr = eliminate_yn(e->right.expr);
+		if (e->left.expr->token == T_WORD) {
+			if (e->left.expr->left.sym == &symbol_no) {
+				free(e->left.expr);
+				tmp = e->right.expr;
+				*e = *(e->right.expr);
+				free(tmp);
+				return e;
+			} else if (e->left.expr->left.sym == &symbol_yes) {
+				expr_free(e->left.expr);
+				expr_free(e->right.expr);
+				e->token = T_WORD;
+				e->left.sym = &symbol_yes;
+				e->right.expr = NULL;
+				return e;
+			}
+		}
+		if (e->right.expr->token == T_WORD) {
+			if (e->right.expr->left.sym == &symbol_no) {
+				free(e->right.expr);
+				tmp = e->left.expr;
+				*e = *(e->left.expr);
+				free(tmp);
+				return e;
+			} else if (e->right.expr->left.sym == &symbol_yes) {
+				expr_free(e->left.expr);
+				expr_free(e->right.expr);
+				e->token = T_WORD;
+				e->left.sym = &symbol_yes;
+				e->right.expr = NULL;
+				return e;
+			}
+		}
+		break;
+	}
+	return e;
+}
+
+struct expr *trans_expr(struct expr *e)
+{
+	struct expr *tmp;
+
+	if (!e)
+		return NULL;
+	switch (e->token) {
+	case '=':
+	case T_UNEQUAL:
+	case T_WORD:
+	case '^':
+		break;
+	default:
+		e->left.expr = trans_expr(e->left.expr);
+		e->right.expr = trans_expr(e->right.expr);
+	}
+
+	switch (e->token) {
+	case '=':
+		if (e->left.sym->type != SYMBOL_BOOLEAN)
+			break;
+		if (e->right.sym == &symbol_no) {
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			e->token = '!';
+			e->left.expr = expr_alloc_symbol(e->left.sym);
+			e->right.sym = NULL;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			break;
+		}
+		if (e->right.sym == &symbol_mod) {
+			printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
+			e->token = T_WORD;
+			e->left.sym = &symbol_no;
+			e->right.sym = NULL;
+			break;
+		}
+		if (e->right.sym == &symbol_yes) {
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			e->token = T_WORD;
+			e->right.sym = NULL;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			break;
+		}
+		break;
+	case T_UNEQUAL:
+		if (e->left.sym->type != SYMBOL_BOOLEAN)
+			break;
+		if (e->right.sym == &symbol_no) {
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			e->token = T_WORD;
+			e->right.sym = NULL;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			break;
+		}
+		if (e->right.sym == &symbol_mod) {
+			printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
+			e->token = T_WORD;
+			e->left.sym = &symbol_yes;
+			e->right.sym = NULL;
+			break;
+		}
+		if (e->right.sym == &symbol_yes) {
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			e->token = '!';
+			e->left.expr = expr_alloc_symbol(e->left.sym);
+			e->right.sym = NULL;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			break;
+		}
+		break;
+	case '!':
+		switch (e->left.expr->token) {
+		case '!':
+			// !!a -> a
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			tmp = e->left.expr->left.expr;
+			free(e->left.expr);
+			free(e);
+			e = tmp;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			e = trans_expr(e);
+			break;
+		case '=':
+		case T_UNEQUAL:
+			// !a='x' -> a!='x'
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			tmp = e->left.expr;
+			free(e);
+			e = tmp;
+			if (e->token == '=')
+				e->token = T_UNEQUAL;
+			else
+				e->token = '=';
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			break;
+		case T_OR:
+			// !(a || b) -> !a && !b
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			tmp = e->left.expr;
+			e->token = T_AND;
+			e->right.expr = expr_alloc_one('!', tmp->right.expr);
+			tmp->token = '!';
+			tmp->right.expr = NULL;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			e = trans_expr(e);
+			break;
+		case T_AND:
+			// !(a && b) -> !a || !b
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, " -> ");
+			tmp = e->left.expr;
+			e->token = T_OR;
+			e->right.expr = expr_alloc_one('!', tmp->right.expr);
+			tmp->token = '!';
+			tmp->right.expr = NULL;
+			print_expr(DEBUG_OPT2, e, 0);
+			printd(DEBUG_OPT2, "\n");
+			e = trans_expr(e);
+			break;
+		case T_WORD:
+			if (e->left.expr->left.sym == &symbol_yes) {
+				// !'y' -> 'n'
+				print_expr(DEBUG_OPT2, e, 0);
+				printd(DEBUG_OPT2, " -> ");
+				tmp = e->left.expr;
+				free(e);
+				e = tmp;
+				e->token = T_WORD;
+				e->left.sym = &symbol_no;
+				print_expr(DEBUG_OPT2, e, 0);
+				printd(DEBUG_OPT2, "\n");
+				break;
+			}
+			if (e->left.expr->left.sym == &symbol_no) {
+				// !'n' -> 'y'
+				print_expr(DEBUG_OPT2, e, 0);
+				printd(DEBUG_OPT2, " -> ");
+				tmp = e->left.expr;
+				free(e);
+				e = tmp;
+				e->token = T_WORD;
+				e->left.sym = &symbol_yes;
+				print_expr(DEBUG_OPT2, e, 0);
+				printd(DEBUG_OPT2, "\n");
+				break;
+			}
+			break;
+		}
+		break;
+	}
+	return e;
+}
+
+struct expr *extract_eq_and(struct expr **ep1, struct expr **ep2)
+{
+	struct expr *tmp = NULL;
+	extract_eq(T_AND, &tmp, ep1, ep2);
+	if (tmp) {
+		*ep1 = eliminate_yn(*ep1);
+		*ep2 = eliminate_yn(*ep2);
+	}
+	return tmp;
+}
+
+struct expr *extract_eq_or(struct expr **ep1, struct expr **ep2)
+{
+	struct expr *tmp = NULL;
+	extract_eq(T_OR, &tmp, ep1, ep2);
+	if (tmp) {
+		*ep1 = eliminate_yn(*ep1);
+		*ep2 = eliminate_yn(*ep2);
+	}
+	return tmp;
+}
+
+void extract_eq(int token, struct expr **ep, struct expr **ep1, struct expr **ep2)
+{
+#define e1 (*ep1)
+#define e2 (*ep2)
+	if (e1->token == token) {
+		extract_eq(token, ep, &e1->left.expr, &e2);
+		extract_eq(token, ep, &e1->right.expr, &e2);
+		return;
+	}
+	if (e2->token == token) {
+		extract_eq(token, ep, ep1, &e2->left.expr);
+		extract_eq(token, ep, ep1, &e2->right.expr);
+		return;
+	}
+	if (expr_eq(e1, e2)) {
+		*ep = *ep ? expr_alloc_two(token, *ep, e1) : e1;
+		expr_free(e2);
+		if (token == T_AND) {
+			e1 = expr_alloc_symbol(&symbol_yes);
+			e2 = expr_alloc_symbol(&symbol_yes);
+		} else if (token == T_OR) {
+			e1 = expr_alloc_symbol(&symbol_no);
+			e2 = expr_alloc_symbol(&symbol_no);
+		}
+	}
+#undef e1
+#undef e2
+}
+
+struct expr *optimize_expr_or(struct expr *e)
+{
+	struct expr *tmp;
+
+	if (!e || e->token != T_OR)
+		return e;
+
+	e->left.expr = optimize_expr_or(e->left.expr);
+	e->right.expr = optimize_expr_or(e->right.expr);
+
+	tmp = extract_eq_and(&e->left.expr, &e->right.expr);
+	if (!tmp)
+		return e;
+	return expr_alloc_two(T_AND, tmp, e);
+}
+
+int contains_expr(struct expr *dep, struct expr *e)
+{
+	if (!dep)
+		return 0;
+	if (dep->token == T_AND)
+		return contains_expr(dep->left.expr, e) || contains_expr(dep->right.expr, e);
+	return expr_eq(dep, e);
+}
+
+struct expr *trans_comp_expr(struct expr *e, int token, struct symbol *sym)
+{
+	struct expr *e1, *e2;
+
+	switch (e->token) {
+	case T_AND:
+		e1 = trans_comp_expr(e->left.expr, '=', sym);
+		e2 = trans_comp_expr(e->right.expr, '=', sym);
+		if (sym == &symbol_yes)
+			e = expr_alloc_two(T_AND, e1, e2);
+		if (sym == &symbol_no)
+			e = expr_alloc_two(T_OR, e1, e2);
+		if (token == T_UNEQUAL)
+			e = expr_alloc_one('!', e);
+		return e;
+	case T_OR:
+		e1 = trans_comp_expr(e->left.expr, '=', sym);
+		e2 = trans_comp_expr(e->right.expr, '=', sym);
+		if (sym == &symbol_yes)
+			e = expr_alloc_two(T_OR, e1, e2);
+		if (sym == &symbol_no)
+			e = expr_alloc_two(T_AND, e1, e2);
+		if (token == T_UNEQUAL)
+			e = expr_alloc_one('!', e);
+		return e;
+	case '!':
+		switch (token) {
+		case '=':
+			return trans_comp_expr(e->left.expr, T_UNEQUAL, sym);
+		case T_UNEQUAL:
+			return trans_comp_expr(e->left.expr, '=', sym);
+		}
+		break;
+	case T_UNEQUAL:
+	case '=':
+		if (token == '=') {
+			if (sym == &symbol_yes)
+				return expr_copy(e);
+			if (sym == &symbol_mod)
+				return expr_alloc_symbol(&symbol_no);
+			if (sym == &symbol_no)
+				return expr_alloc_one('!', expr_copy(e));
+		} else {
+			if (sym == &symbol_yes)
+				return expr_alloc_one('!', expr_copy(e));
+			if (sym == &symbol_mod)
+				return expr_alloc_symbol(&symbol_yes);
+			if (sym == &symbol_no)
+				return expr_copy(e);
+		}
+		break;
+	case T_WORD:
+		return expr_alloc_comp(token, e->left.sym, sym);
+	}
+	return NULL;
+}
+
+void eliminate_dep(struct symbol *sym, struct expr *dep)
+{
+	struct symbol *sym2;
+	struct expr *dep2;
+
+	if (dep->token == T_AND) {
+		eliminate_dep(sym, dep->left.expr);
+		eliminate_dep(sym, dep->right.expr);
+	}
+#if 0
+	if (dep->token == T_WORD ||
+	    (sym->type == SYMBOL_BOOLEAN &&
+	     ((dep->token == T_UNEQUAL && dep->right.sym == &symbol_no) ||
+	      (dep->token == '=' && dep->right.sym == &symbol_yes)))) {
+		sym2 = dep->left.sym;
+		if (sym2->dep) {
+			if (!sym2->dep2)
+				eliminate_dep(sym2, sym2->dep);
+			sym->dep2 = !sym->dep2 ? expr_copy(sym2->dep2)
+				: expr_alloc_two(T_AND, expr_copy(sym2->dep2), sym->dep2);
+		}
+	}
+#else
+	switch (dep->token) {
+	case T_WORD:
+	case T_UNEQUAL:
+	case '=':
+		sym2 = dep->left.sym;
+		if (sym2->type != SYMBOL_BOOLEAN && sym2->type != SYMBOL_TRISTATE)
+			break;
+		if (!sym2->dep)
+			break;
+		if (!sym2->dep2)
+			eliminate_dep(sym2, sym2->dep);
+		if (dep->token == T_WORD) {
+			if (sym2->type == SYMBOL_BOOLEAN)
+				dep2 = trans_comp_expr(sym2->dep2, T_UNEQUAL, &symbol_no);
+			else
+				dep2 = expr_copy(sym2->dep2);
+		} else {
+			//if ((dep->token == T_UNEQUAL && dep->right.sym == &symbol_no) ||
+			//    (sym2->type == SYMBOL_BOOLEAN &&
+			//     dep->token == '=' && dep->right.sym == &symbol_yes))
+			if ((dep->token == '=' && dep->right.sym == &symbol_yes) ||
+			    (sym2->type == SYMBOL_BOOLEAN &&
+			     dep->token == T_UNEQUAL && dep->right.sym == &symbol_no))
+				dep2 = trans_comp_expr(sym2->dep2, dep->token, dep->right.sym);
+			else
+				break;
+		}
+		dep2 = eliminate_yn(trans_expr(fixup_expr(dep2)));
+		sym->dep2 = !sym->dep2 ? dep2 : expr_alloc_two(T_AND, dep2, sym->dep2);
+	}
+#endif
+	if (sym->dep == dep) {
+		printd(DEBUG_DEP, "el: %s (", sym->name);
+		print_expr(DEBUG_DEP, sym->dep, 0);
+		printd(DEBUG_DEP, ")\n");
+		if (sym->dep2) {
+			print_expr(DEBUG_DEP, sym->dep2, 0); printd(DEBUG_DEP, "\n");
+			sym->dep2 = eliminate_yn(eliminate_dups(sym->dep2));
+			switch (sym->type) {
+			case SYMBOL_BOOLEAN: case SYMBOL_INT: case SYMBOL_HEX: case SYMBOL_STRING:
+				sym->dep2 = trans_bool_expr(sym->dep2);
+				break;
+			}
+			print_expr(DEBUG_DEP, sym->dep2, 0); printd(DEBUG_DEP, "\n");
+			sym->dep = expr_alloc_two(T_AND, expr_copy(sym->dep2), sym->dep);
+			sym->dep = eliminate_dups(sym->dep);
+			print_expr(DEBUG_DEP, sym->dep, 0); printd(DEBUG_DEP, "\n");
+			dep = expr_copy(sym->dep2);
+			eliminate_eq(T_AND, &dep, &sym->dep);
+			sym->dep = eliminate_yn(sym->dep);
+			sym->dep2 = expr_alloc_two(T_AND, sym->dep2, expr_copy(sym->dep));
+		} else
+			sym->dep2 = expr_copy(sym->dep);
+		printd(DEBUG_DEP, " -> ");
+		print_expr(DEBUG_DEP, sym->dep2, 0);
+		printd(DEBUG_DEP, " -> ");
+		print_expr(DEBUG_DEP, sym->dep, 0);
+		printd(DEBUG_DEP, "\n");
+	}
+}
+
+struct symbol * dep_check_symbol(struct symbol *sym);
+
+struct symbol *dep_check_expr(struct expr *e)
+{
+	struct symbol *sym;
+	if (!e)
+		return 0;
+	switch (e->token) {
+	case T_WORD:
+	case T_WORD_QUOTE:
+	case T_WORD_DQUOTE:
+		return dep_check_symbol(e->left.sym);
+	case '=':
+	case T_UNEQUAL:
+		sym = dep_check_symbol(e->left.sym);
+		if (sym)
+			return sym;
+		return dep_check_symbol(e->right.sym);
+	case T_OR:
+	case T_AND:
+		sym = dep_check_expr(e->left.expr);
+		if (sym)
+			return sym;
+		return dep_check_expr(e->right.expr);
+	case '!':
+		return dep_check_expr(e->left.expr);
+	}
+	printf("how to check %d?\n", e->token);
+	return NULL;
+}
+
+struct symbol *dep_check_symbol(struct symbol *sym)
+{
+	struct statement *stmt, *stmt2;
+	struct symbol *sym2;
+	struct expr *e1, *e2;
+
+	if (sym->flags & SYMBOL_CHECK) {
+		printf("recursive dependency: %s", sym->name);
+		return sym;
+	}
+
+	sym->flags |= SYMBOL_CHECK;
+	sym2 = dep_check_expr(sym->dep);
+	if (sym2) {
+		printf(" %s", sym->name);
+		if (sym->type != sym2->type)
+			goto out;
+		switch (sym->type) {
+		case SYMBOL_TRISTATE:
+			e1 = expr_alloc_comp(T_UNEQUAL, sym, &symbol_yes);
+			e2 = expr_alloc_comp(T_UNEQUAL, sym2, &symbol_yes);
+			break;
+		case SYMBOL_BOOLEAN:
+			e1 = expr_alloc_one('!', expr_alloc_symbol(sym));
+			e2 = expr_alloc_one('!', expr_alloc_symbol(sym2));
+			break;
+		default:
+			goto out;
+		}
+		if (contains_expr(sym->dep, e2) && contains_expr(sym2->dep, e1)) {
+			printf(" (choice(%d) detected)", sym->type);
+			sym->flags |= SYMBOL_CHOICE;
+			eliminate_eq(T_AND, &sym->dep, &e2);
+			sym->dep = eliminate_yn(sym->dep);
+			sym2->flags |= SYMBOL_CHOICE;
+			eliminate_eq(T_AND, &sym2->dep, &e1);
+			sym2->dep = eliminate_yn(sym2->dep);
+			stmt = malloc(sizeof(*stmt));
+			memset(stmt, 0, sizeof(*stmt));
+			stmt->token = '^';
+			stmt->text = "change me!";
+			stmt->dep = expr_alloc_one('^', NULL);
+			stmt->dep->right.sym = sym;
+			stmt->dep = expr_alloc_one('^', stmt->dep);
+			stmt->dep->right.sym = sym2;
+			stmt->dep = expr_alloc_one('^', stmt->dep);
+			stmt->dep->right.sym = &symbol_no;
+			for (stmt2 = sym->stmt; stmt2->next; stmt2 = stmt2->next)
+				;
+			if (stmt2->token == '^')
+				printf("warning: symbol %s has dup choice statement?\n", sym->name);
+			else
+				stmt2->next = stmt;
+			for (stmt2 = sym2->stmt; stmt2->next; stmt2 = stmt2->next)
+				;
+			if (stmt2->token == '^')
+				printf("warning: symbol %s has dup choice statement?\n", sym->name);
+			else
+				stmt2->next = stmt;
+		}
+		expr_free(e1);
+		expr_free(e2);
+	}
+	if (!sym2) for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+		if (!stmt->token || stmt->token == '^')
+			continue;
+		sym2 = dep_check_expr(stmt->dep);
+		if (sym2) {
+			printf(" %s", sym->name);
+			break;
+		}
+	}
+out:
+	sym->flags &= ~SYMBOL_CHECK;
+
+	return sym2;
+}
+
+const char *sym_typename(int type)
+{
+	switch (type) {
+	case SYMBOL_UNKNOWN: return "unknown";
+	case SYMBOL_BOOLEAN: return "bool";
+	case SYMBOL_TRISTATE: return "tristate";
+	case SYMBOL_INT: return "integer";
+	case SYMBOL_HEX: return "hex";
+	case SYMBOL_STRING: return "string";
+	case SYMBOL_OTHER: return "other";
+	default: return "???";
+	}
+}
+
+void optimize_config(void)
+{
+	struct symbol *sym;
+	struct statement *stmt, *stmt2, **stmtp;
+	struct expr *e;
+	int i;
+
+	for_all_symbols(i, sym) {
+	again:
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			switch (stmt->token) {
+			case '^':
+			case T_BOOL:
+			case T_DEP_BOOL:
+			case T_DEP_MBOOL:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_BOOLEAN;
+				if (sym->type != SYMBOL_BOOLEAN)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_BOOLEAN));
+				if (sym->type == SYMBOL_TRISTATE) {
+					printf("%s:%d:Force stmt to dep_tristate\n",
+						stmt->file->name, stmt->lineno);
+					stmt->token = T_DEP_TRISTATE;
+				}
+				break;
+			case T_DEFINE_BOOL:
+				if (stmt->def == &symbol_mod) {
+					printf("%s:%d:warning: symbol %s set to 'm', force stmt to define_tristate\n",
+						stmt->file->name, stmt->lineno, sym->name);
+					stmt->token = T_DEFINE_TRISTATE;
+				}
+				break;
+			case T_HEX:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_HEX;
+				if (sym->type != SYMBOL_HEX)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_HEX));
+				break;
+			case T_INT:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_INT;
+				if (sym->type != SYMBOL_INT)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_INT));
+				break;
+			case T_STRING:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_STRING;
+				if (sym->type != SYMBOL_STRING)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_STRING));
+				break;
+			case T_TRISTATE:
+			case T_DEP_TRISTATE:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_TRISTATE;
+				if (sym->type != SYMBOL_TRISTATE) {
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s), force symbol to tristate\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_TRISTATE));
+					sym->type = SYMBOL_TRISTATE;
+					goto again;
+				}
+				break;
+			}
+		}
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			switch (stmt->token) {
+			case T_DEFINE_BOOL:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_BOOLEAN;
+				if (sym->type != SYMBOL_BOOLEAN)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_BOOLEAN));
+				if (sym->type == SYMBOL_TRISTATE) {
+					printf("%s:%d:Force stmt to define_tristate\n",
+						stmt->file->name, stmt->lineno);
+					stmt->token = T_DEFINE_TRISTATE;
+				}
+				break;
+			case T_DEFINE_TRISTATE:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_TRISTATE;
+				if (sym->type != SYMBOL_TRISTATE) {
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s), force symbol to tristate\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_TRISTATE));
+					sym->type = SYMBOL_TRISTATE;
+					goto again;
+				}
+				break;
+			case T_DEFINE_HEX:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_HEX;
+				if (sym->type != SYMBOL_HEX)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_HEX));
+				break;
+			case T_DEFINE_INT:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_INT;
+				if (sym->type != SYMBOL_INT)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_INT));
+				break;
+			case T_DEFINE_STRING:
+				if (sym->type == SYMBOL_UNKNOWN)
+					sym->type = SYMBOL_STRING;
+				if (sym->type != SYMBOL_STRING)
+					printf("%s:%d:warning: symbol %s has conflicting types (%s,%s)\n",
+						stmt->file->name, stmt->lineno, sym->name,
+						sym_typename(sym->type), sym_typename(SYMBOL_STRING));
+				break;
+			}
+		}
+	}
+	for_all_symbols(i, sym) {
+		printd(DEBUG_OPT1, "o1: %s\n", sym->name);
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			print_expr(DEBUG_OPT1, stmt->dep, 0);
+			printd(DEBUG_OPT1, " & ");
+			print_expr(DEBUG_OPT1, stmt->dep2, 0);
+			printd(DEBUG_OPT1, "\n");
+			if (stmt->dep || stmt->dep2) {
+				struct expr *e = stmt->dep2;
+				if (stmt->token == T_DEP_BOOL) {
+					e = trans_dep_bool(e);
+					stmt->token = T_DEP_MBOOL;
+				}
+				if (stmt->dep && e) {
+					stmt->dep = expr_alloc_two(T_AND, stmt->dep, e);
+				} else if (e)
+					stmt->dep = e;
+				stmt->dep2 = NULL;
+				switch (stmt->token) {
+				case T_DEP_MBOOL:	stmt->token = T_BOOL; break;
+				case T_DEP_TRISTATE:	stmt->token = T_TRISTATE; break;
+				}
+			}
+			stmt->dep = fixup_expr(stmt->dep);
+			print_expr(DEBUG_OPT1, stmt->dep, 0);
+			printd(DEBUG_OPT1, "\n");
+		}
+	}
+	for_all_symbols(i, sym) {
+		printd(DEBUG_OPT3, "o3: %s\n", sym->name);
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			print_expr(DEBUG_OPT3, stmt->dep, 0);
+			printd(DEBUG_OPT3, "\n");
+			stmt->dep = eliminate_dups(trans_expr(stmt->dep));
+			switch (sym->type) {
+			case SYMBOL_BOOLEAN: case SYMBOL_INT: case SYMBOL_HEX: case SYMBOL_STRING:
+				stmt->dep = trans_bool_expr(stmt->dep);
+				break;
+			}
+			print_expr(DEBUG_OPT3, stmt->dep, 0);
+			printd(DEBUG_OPT3, "\n");
+		}
+	}
+	for_all_symbols(i, sym) {
+		sym->dep = eliminate_yn(sym->dep);
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			stmt->dep = eliminate_yn(stmt->dep);
+			if (expr_is_no(stmt->dep)) {
+				printf("%s:%d: stmt can never be reached, removed!\n", stmt->file->name, stmt->lineno);
+				stmt->token = 0;
+			}
+		}
+	}
+	for_all_symbols(i, sym) {
+		stmtp = &sym->stmt;
+		stmt = *stmtp;
+		if (!stmt) {
+			printf("undefined symbol %s\n", sym->name);
+			continue;
+		}
+		//if (sym->flags & SYMBOL_CHOICE)
+		//	continue;
+		while (stmt) {
+			if (!stmt->token || stmt->token == '^') {
+				stmtp = &stmt->next;
+				stmt = *stmtp;
+				continue;
+			}
+#if 1
+			if ((stmt->token == T_DEFINE_BOOL || stmt->token == T_DEFINE_TRISTATE) &&
+			    (stmt->def == &symbol_no || expr_is_no(stmt->dep))) {
+				stmt->token = 0;
+				stmt->def = NULL;
+				expr_free(stmt->dep);
+				stmt->dep = NULL;
+				continue;
+			}
+#endif
+			//if (stmt->text && stmt != sym->stmt) {
+			//	if (sym->stmt->text)
+			//		printf("warning: another stmt with prompt for %s????\n", sym->name);
+			//	*stmtp = stmt->next;
+			//	stmt->next = sym->stmt;
+			//	sym->stmt = stmt;
+			//}
+			for (stmt2 = stmt->next; stmt2; stmt2 = stmt2->next) {
+				if (stmt->token != stmt2->token || stmt->def != stmt2->def ||
+				    stmt->menu->parent != stmt2->menu->parent)
+					continue;
+				if (stmt->text) {
+					if (strcmp(skip_space(stmt->text), skip_space(stmt2->text))) {
+						printf("warning: prompts differ for %s?\n", sym->name);
+						continue;
+					}
+				}
+				if (!stmt->dep)
+					stmt->dep = expr_alloc_symbol(&symbol_yes);
+				if (!stmt2->dep)
+					stmt2->dep = expr_alloc_symbol(&symbol_yes);
+				stmt->dep = optimize_expr_or(expr_alloc_two(T_OR, stmt->dep, stmt2->dep));
+				stmt2->token = 0;
+				free((void *)stmt2->text);
+				stmt2->text = NULL;
+				stmt2->def = NULL;
+				stmt2->dep = NULL;
+			}
+			if (stmt->text && stmt != sym->stmt) {
+				*stmtp = stmt->next;
+				stmt->next = sym->stmt;
+				sym->stmt = stmt;
+			} else
+				stmtp = &stmt->next;
+			stmt = *stmtp;
+		}
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			if (!stmt->token || stmt->token == '^')
+				continue;
+			if (!sym->dep) {
+				if (!stmt->dep)
+					break;
+				sym->dep = stmt->dep;
+				stmt->dep = NULL;
+			} else {
+				e = sym->dep;
+				if (stmt->dep) {
+					sym->dep = extract_eq_and(&e, &stmt->dep);
+					if (expr_is_yes(e)) {
+						expr_free(e);
+						continue;
+					}
+				} else
+					sym->dep = NULL;
+				for (stmt2 = sym->stmt; stmt != stmt2; stmt2 = stmt2->next) {
+					if (!stmt2->token || stmt2->token == '^')
+						continue;
+					stmt2->dep = !stmt2->dep ? expr_copy(e) :
+						expr_alloc_two(T_AND, expr_copy(e), stmt2->dep);
+				}
+				expr_free(e);
+				if (!sym->dep)
+					break;
+			}
+		}
+#if 0
+		for (stmt1 = sym->stmt; stmt1; stmt1 = stmt1->next)
+			if (stmt1->token && stmt1->token != '^')
+				break;
+		if (stmt1 && !expr_is_yes(stmt1->dep)) {
+			e = trans_expr(expr_alloc_one('!', stmt1->dep));
+			stmt1->dep = NULL;
+			for (stmt = stmt1->next; stmt; stmt = stmt->next) {
+				if (!stmt->token || stmt->token == '^')
+					continue;
+				if (stmt->dep) {
+					tmp = extract_eq_and(&e, &stmt->dep);
+					if (expr_is_yes(e)) {
+						expr_free(e);
+						e = tmp;
+						continue;
+					}
+					if (tmp) {
+						e = expr_alloc_two(T_AND, expr_copy(tmp), e);
+						stmt->dep = expr_alloc_two(T_AND, tmp, stmt->dep);
+					}
+				}
+				for (stmt2 = stmt1->next; stmt != stmt2; stmt2 = stmt2->next) {
+					if (!stmt2->token || stmt2->token == '^')
+						continue;
+					stmt2->dep = !stmt2->dep ? expr_copy(e) :
+						expr_alloc_two(T_AND, expr_copy(e), stmt2->dep);
+				}
+				stmt1->dep = trans_expr(expr_alloc_one('!', e));
+				break;
+			}
+			if (!stmt1->dep) {
+				e = trans_expr(expr_alloc_one('!', e));
+				//sym->dep = sym->dep ? expr_alloc_two(T_AND, sym->dep, e) : e;
+				stmt1->dep = e;
+			}
+		}
+		for (stmtp = &sym->stmt; *stmtp; stmtp = &stmt->next) {
+			stmt = *stmtp;
+			if (!stmt->token || stmt->token == '^')
+				continue;
+			if (!stmt->dep || stmt->text)
+				continue;
+			for (stmt2 = stmt->next; stmt2; stmt2 = stmt2->next) {
+				trans_count = 0;
+				if (!stmt2->dep || stmt2->text)
+					continue;
+				e = trans_expr(expr_alloc_one('!', expr_copy(stmt->dep)));
+				tmp = extract_eq_and(&e, &stmt2->dep);
+				if (expr_is_yes(e)) {
+					expr_free(e);
+					expr_free(tmp);
+					continue;
+				}
+				if (tmp)
+					stmt2->dep = expr_alloc_two(T_AND, tmp, stmt2->dep);
+				e = trans_expr(expr_alloc_one('!', expr_copy(stmt2->dep)));
+				tmp = extract_eq_and(&e, &stmt->dep);
+				if (expr_is_yes(e)) {
+					expr_free(e);
+					expr_free(tmp);
+					while (stmt->next != stmt2)
+						stmt = stmt->next;
+					stmt->next = *stmtp;
+					*stmtp = stmt2;
+					stmt = stmt->next;
+					stmt2 = stmt->next;
+					stmt->next = (*stmtp)->next;
+					(*stmtp)->next = stmt2;
+					continue;
+				}
+				if (tmp)
+					stmt->dep = expr_alloc_two(T_AND, tmp, stmt->dep);
+			}
+		}
+#endif
+	}
+	for_all_symbols(i, sym) {
+		printd(DEBUG_OPT4, "o4: %s\n", sym->name);
+		print_expr(DEBUG_OPT4, sym->dep, 0); printd(DEBUG_OPT4, "\n");
+		sym->dep = eliminate_dups(sym->dep);
+		sym->dep = eliminate_yn(sym->dep);
+		print_expr(DEBUG_OPT4, sym->dep, 0); printd(DEBUG_OPT4, "\n");
+		for (stmt = sym->stmt; stmt; stmt = stmt->next) {
+			print_expr(DEBUG_OPT4, stmt->dep, 0); printd(DEBUG_OPT4, "\n");
+			stmt->dep = eliminate_dups(stmt->dep);
+			stmt->dep = eliminate_yn(stmt->dep);
+			print_expr(DEBUG_OPT4, stmt->dep, 0); printd(DEBUG_OPT4, "\n");
+		}
+	}
+	for_all_symbols(i, sym) {
+		if (dep_check_symbol(sym))
+			printf("\n");
+	}
+	for_all_symbols(i, sym) {
+		if (sym->dep && !sym->dep2) {
+			printd(DEBUG_OPT5, "o5: %s\n", sym->name);
+			print_expr(DEBUG_OPT5, sym->dep, 0); printd(DEBUG_OPT5, "\n");
+			eliminate_dep(sym, sym->dep);
+			print_expr(DEBUG_OPT5, sym->dep, 0); printd(DEBUG_OPT5, "\n");
+		}
+	}
+}
+
+int main(int ac, char **av)
+{
+	FILE *out = NULL;
+	char name[128];
+	struct symbol *sym;
+	struct statement *stmt;
+
+	if (ac > 2)
+		cml1debug = 1;
+	helplex("Documentation/Configure.help");
+	sprintf(name, "arch/%s/Config.help", av[1]);
+	helplex(name);
+	sprintf(name, "arch/%s/config.in", av[1]);
+	scan_init(name);
+	sym = lookup_symbol("CONFIG_ARCH", SYMBOL_STRING);
+	stmt = add_stmt(sym, T_DEFINE_STRING, NULL, lookup_symbol(av[1], SYMBOL_OTHER));
+	stmt->menu = NULL;
+	cml1parse();
+	optimize_config();
+#if 0
+	out = fopen("config.new", "w");
+	if (!out) {
+		printf("unable to open config.new!\n");
+		exit(1);
+	}
+#endif
+	print_files(out, name);
+
+	return 0;
+}
--
cgit v0.9.0.2